squeezelite-esp32/components/spotify/cspot/include/Utils.h

#ifndef UTILS_H
#define UTILS_H
#include <cstdio>     // for snprintf, size_t
#include <vector>     // for vector
#ifdef _WIN32
#include <winsock2.h>
#include <ws2tcpip.h>

#include "win32shim.h"
#else

#endif
#include <cstdint>    // for uint8_t, uint64_t
#include <cstring>    // for memcpy
#include <memory>     // for unique_ptr
#include <stdexcept>  // for runtime_error
#include <string>     // for string

#define HMAC_SHA1_BLOCKSIZE 64

/**
 * @brief Returns current timestamp
 * 
 * @return unsigned long long resulting timestamp in milliseconds from unix time zero
 */
unsigned long long getCurrentTimestamp();

/**
 * @brief portable 64bit equivalent of htons / htonl. aka endianess swap
 * 
 * @param value input value to swap
 * @return uint64_t swapped result
 */
uint64_t hton64(uint64_t value);

std::vector<uint8_t> bigNumDivide(std::vector<uint8_t> num, int n);

/**
 * @brief Performs big number multiplication on two numbers
 * 
 * @param num big num in vector format
 * @param n secondary number
 * @return std::vector<uint8_t> resulting number
 */
std::vector<uint8_t> bigNumMultiply(std::vector<uint8_t> num, int n);

/**
 * @brief Performs big number addition on two numbers
 * 
 * @param num big num in vector format
 * @param n secondary number
 * @return std::vector<uint8_t> resulting number
 */
std::vector<uint8_t> bigNumAdd(std::vector<uint8_t> num, int n);

unsigned char h2int(char c);


std::string urlDecode(std::string str);

/**
 * @brief Converts provided hex string into binary data
 * 
 * @param s string containing hex data
 * @return std::vector<uint8_t> vector containing binary data
 */
std::vector<uint8_t> stringHexToBytes(const std::string &s);

/**
 * @brief Converts provided bytes into a human readable hex string
 * 
 * @param bytes vector containing binary data
 * @return std::string string containing hex representation of inputted data
 */
std::string bytesToHexString(const std::vector<uint8_t> &bytes);

/**
 * @brief Extracts given type from binary data
 * 
 * @tparam T type to extract
 * @param v vector containing binary data to extract from
 * @param pos position offset
 * @return T extracted type
 */
template <typename T>
T extract(const std::vector<unsigned char> &v, int pos)
{
  T value;
  memcpy(&value, &v[pos], sizeof(T));
  return value;
}

/**
 * @brief Packs given type into binary data
 * 
 * @tparam T type of data to pack
 * @param data data to pack
 * @return std::vector<uint8_t> resulting vector containing binary data
 */
template <typename T>
std::vector<uint8_t> pack(T data)
{
     std::vector<std::uint8_t> rawData( (std::uint8_t*)&data, (std::uint8_t*)&(data) + sizeof(T));

     return rawData;
}

template<typename ... Args>
std::string string_format( const std::string& format, Args ... args )
{
    int size_s = std::snprintf( nullptr, 0, format.c_str(), args ... ) + 1; // Extra space for '\0'
    if( size_s <= 0 ){ throw std::runtime_error( "Error during formatting." ); }
    auto size = static_cast<size_t>( size_s );
    std::unique_ptr<char[]> buf( new char[ size ] );
    std::snprintf( buf.get(), size, format.c_str(), args ... );
    return std::string( buf.get(), buf.get() + size - 1 ); // We don't want the '\0' inside
}

#endif