init http framework

.gitignore

@@ -2,3 +2,4 @@
 *.exe
 /build
 /cDrive.*
+/.vscode/settings.json

.vscode/c_cpp_properties.json

@@ -4,6 +4,7 @@
             "name": "MinGW64",
             "includePath": [
                 "${workspaceFolder}/include",
+                "${workspaceFolder}",
                 "C:\\MinGW64\\include",
                 "C:\\MinGW64\\x86_64-w64-mingw32\\include"
             ],

CMakeLists.txt

@@ -1,43 +1,12 @@
 cmake_minimum_required(VERSION 3.15)
 
-include(FetchContent)
+set(CMAKE_BUILD_TYPE Release)
 
-FetchContent_Declare(spdlog
+find_package(mbedtls REQUIRED)
-  URL https://github.com/gabime/spdlog/archive/v1.11.0.tar.gz
+find_package(CURL REQUIRED)
-  DOWNLOAD_EXTRACT_TIMESTAMP TRUE
-)
-FetchContent_MakeAvailable(spdlog)
-
-FetchContent_Declare(mbedtls 
-  URL https://github.com/Mbed-TLS/mbedtls/archive/v2.28.3.tar.gz
-  DOWNLOAD_EXTRACT_TIMESTAMP TRUE
-)
-set(ENABLE_PROGRAMS OFF CACHE INTERNAL "" FORCE)
-set(ENABLE_TESTING OFF CACHE INTERNAL "" FORCE)
-FetchContent_MakeAvailable(mbedtls)
-
-find_package(CURL)
-if (NOT CURL_FOUND)
-  FetchContent_Declare(curl
-      URL https://curl.se/download/curl-8.5.0.tar.xz
-      DOWNLOAD_EXTRACT_TIMESTAMP TRUE
-  )
-  set(CURL_USE_MBEDTLS ON)
-  set(HTTP_ONLY ON)
-  set(BUILD_CURL_EXE OFF)
-  set(BUILD_TESTING OFF)
-  set(BUILD_SHARED_LIBS OFF)
-  set(CURL_DISABLE_PROGRESS_METER ON CACHE INTERNAL "" FORCE)
-  FetchContent_MakeAvailable(curl)
-endif ()
-
-find_library(qrcodegen_FOUND qrcodegen)
-if (qrcodegen_FOUND)
-  message(STATUS "found qrcodegen")
-endif ()
 
 project(clist)
 file(GLOB_RECURSE MAIN_SRC "${CMAKE_SOURCE_DIR}/src/*.cpp")
 add_executable(${PROJECT_NAME} ${MAIN_SRC})
-target_include_directories(${PROJECT_NAME} PRIVATE include)
+target_include_directories(${PROJECT_NAME} PRIVATE include qrcodegen)
-target_link_libraries(${PROJECT_NAME} PRIVATE spdlog mbedtls qrcodegen CURL::libcurl)
+target_link_libraries(${PROJECT_NAME} PRIVATE mbedtls CURL::libcurl)

Makefile

@@ -1,16 +1,17 @@
 TARGET = cDrive
+CC     = gcc
 
-SRCS    := src src/drive
+SRCS    := src src/drive qrcodegen
 
 VPATH     :=  $(foreach dir,$(SRCS),$(CURDIR)/$(dir))
 CFILES    :=	$(foreach dir,$(SRCS),$(notdir $(wildcard $(dir)/*.c)))
 CPPFILES  :=	$(foreach dir,$(SRCS),$(notdir $(wildcard $(dir)/*.cpp)))
 OFILES    :=	$(CPPFILES:.cpp=.o) $(CFILES:.c=.o)
 
-INCLUDES  := -I$(CURDIR)/include
+INCLUDES  := -I$(CURDIR)/include -I$(CURDIR)
 CFLAGS    := -g -Wall $(INCLUDES) `curl-config --cflags`
 CXXFLAGS  := $(CFLAGS) -fno-rtti -std=c++17
-LDFLAGS   :=  `curl-config --libs` -lqrcodegen -lmbedcrypto
+LDFLAGS   :=  `curl-config --libs` -lmbedcrypto
 
 .PHONY:	all
 all: $(TARGET)

README.md

@@ -8,6 +8,19 @@ Cloud drive explorer for C/C++
 ## Build On Windows
 
 ```bash
+curl -sL https://github.com/gabime/spdlog/archive/v1.13.0.tar.gz | tar zxf -
+cmake -B build -G 'MinGW Makefiles' -DCMAKE_INSTALL_PREFIX=/c/MinGW64 -DCMAKE_BUILD_TYPE=Release \
+  -DSPDLOG_BUILD_EXAMPLE=OFF -DSPDLOG_BUILD_SHARED=ON
+
+curl -sL https://github.com/Mbed-TLS/mbedtls/archive/v2.28.3.tar.gz | tar zxf -
+cmake -B build -G 'MinGW Makefiles' -DCMAKE_INSTALL_PREFIX=/c/MinGW64 -DCMAKE_BUILD_TYPE=Release \
+  -DENABLE_PROGRAMS=OFF -DENABLE_TESTING=OFF
+
+curl -sL https://curl.se/download/curl-8.5.0.tar.xz | tar Jxf -
+cmake -B build -G 'MinGW Makefiles' -DCMAKE_INSTALL_PREFIX=/c/MinGW64 -DCMAKE_BUILD_TYPE=Release \
+  -DBUILD_SHARED_LIBS=ON -DHTTP_ONLY=ON -DCURL_USE_MBEDTLS=ON -DCURL_DISABLE_PROGRESS_METER=ON \
+  -DBUILD_CURL_EXE=OFF -DBUILD_TESTING=OFF -DUSE_LIBIDN2=OFF -DCURL_USE_LIBSSH2=OFF -DCURL_USE_LIBPSL=OFF
+
 cmake -B build -DCMAKE_BUILD_TYPE=Release
 cmake --build build
 ```

include/drive.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <string>
+#include <vector>
+#include <memory>
+
+enum drive_type {
+    dt_alipan,
+    dt_filebrowser,
+};
+
+/// @brief file entry
+struct dItem {
+    std::string id;
+    std::string name;
+    bool folder;
+};
+
+class drive {
+public:
+    virtual ~drive() {}
+    typedef std::shared_ptr<drive> ref;
+    typedef void (*fnQrcode)(const std::string&);
+
+    virtual int qrLogin(fnQrcode printQr) = 0;
+    virtual std::vector<dItem> list(const std::string& file_id) = 0;
+    virtual std::string mkdir(const std::string& parent_id, const std::string& name) = 0;
+    virtual std::string upload(const std::string& parent_id, const std::string& file) = 0;
+};
+
+/// @brief factory funtion
+drive::ref new_drive(drive_type type);
+
+std::string hex_encode(const unsigned char* data, size_t len);
+

include/http.h

@@ -0,0 +1,33 @@
+/*
+    Copyright 2023 dragonflylee
+*/
+
+#pragma once
+
+#include <string>
+#include <vector>
+#include <unordered_map>
+#include <curl/curl.h>
+
+class HTTP {
+public:
+    using Form = std::unordered_map<std::string, std::string>;
+
+    HTTP();
+    HTTP(const HTTP& other) = delete;
+    ~HTTP();
+
+    static std::string encode_form(const Form& form);
+    void set_headers(const std::vector<std::string>& headers);
+    int get(const std::string& url, std::ostream *out);
+    std::string put(const std::string& url, std::istream *data);
+    std::string post(const std::string& url, const std::string& data);
+
+private:
+    static size_t easy_write_cb(char* ptr, size_t size, size_t nmemb, void* userdata);
+    static size_t easy_read_cb(char* ptr, size_t size, size_t nmemb, void* userdata);
+    int perform(std::ostream* body);
+
+    CURL* easy;
+    struct curl_slist* chunk;
+};

qrcodegen/qrcodegen.h

@@ -0,0 +1,385 @@
+/* 
+ * QR Code generator library (C)
+ * 
+ * Copyright (c) Project Nayuki. (MIT License)
+ * https://www.nayuki.io/page/qr-code-generator-library
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ * - The above copyright notice and this permission notice shall be included in
+ *   all copies or substantial portions of the Software.
+ * - The Software is provided "as is", without warranty of any kind, express or
+ *   implied, including but not limited to the warranties of merchantability,
+ *   fitness for a particular purpose and noninfringement. In no event shall the
+ *   authors or copyright holders be liable for any claim, damages or other
+ *   liability, whether in an action of contract, tort or otherwise, arising from,
+ *   out of or in connection with the Software or the use or other dealings in the
+ *   Software.
+ */
+
+#pragma once
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/* 
+ * This library creates QR Code symbols, which is a type of two-dimension barcode.
+ * Invented by Denso Wave and described in the ISO/IEC 18004 standard.
+ * A QR Code structure is an immutable square grid of dark and light cells.
+ * The library provides functions to create a QR Code from text or binary data.
+ * The library covers the QR Code Model 2 specification, supporting all versions (sizes)
+ * from 1 to 40, all 4 error correction levels, and 4 character encoding modes.
+ * 
+ * Ways to create a QR Code object:
+ * - High level: Take the payload data and call qrcodegen_encodeText() or qrcodegen_encodeBinary().
+ * - Low level: Custom-make the list of segments and call
+ *   qrcodegen_encodeSegments() or qrcodegen_encodeSegmentsAdvanced().
+ * (Note that all ways require supplying the desired error correction level and various byte buffers.)
+ */
+
+
+/*---- Enum and struct types----*/
+
+/* 
+ * The error correction level in a QR Code symbol.
+ */
+enum qrcodegen_Ecc {
+	// Must be declared in ascending order of error protection
+	// so that an internal qrcodegen function works properly
+	qrcodegen_Ecc_LOW = 0 ,  // The QR Code can tolerate about  7% erroneous codewords
+	qrcodegen_Ecc_MEDIUM  ,  // The QR Code can tolerate about 15% erroneous codewords
+	qrcodegen_Ecc_QUARTILE,  // The QR Code can tolerate about 25% erroneous codewords
+	qrcodegen_Ecc_HIGH    ,  // The QR Code can tolerate about 30% erroneous codewords
+};
+
+
+/* 
+ * The mask pattern used in a QR Code symbol.
+ */
+enum qrcodegen_Mask {
+	// A special value to tell the QR Code encoder to
+	// automatically select an appropriate mask pattern
+	qrcodegen_Mask_AUTO = -1,
+	// The eight actual mask patterns
+	qrcodegen_Mask_0 = 0,
+	qrcodegen_Mask_1,
+	qrcodegen_Mask_2,
+	qrcodegen_Mask_3,
+	qrcodegen_Mask_4,
+	qrcodegen_Mask_5,
+	qrcodegen_Mask_6,
+	qrcodegen_Mask_7,
+};
+
+
+/* 
+ * Describes how a segment's data bits are interpreted.
+ */
+enum qrcodegen_Mode {
+	qrcodegen_Mode_NUMERIC      = 0x1,
+	qrcodegen_Mode_ALPHANUMERIC = 0x2,
+	qrcodegen_Mode_BYTE         = 0x4,
+	qrcodegen_Mode_KANJI        = 0x8,
+	qrcodegen_Mode_ECI          = 0x7,
+};
+
+
+/* 
+ * A segment of character/binary/control data in a QR Code symbol.
+ * The mid-level way to create a segment is to take the payload data
+ * and call a factory function such as qrcodegen_makeNumeric().
+ * The low-level way to create a segment is to custom-make the bit buffer
+ * and initialize a qrcodegen_Segment struct with appropriate values.
+ * Even in the most favorable conditions, a QR Code can only hold 7089 characters of data.
+ * Any segment longer than this is meaningless for the purpose of generating QR Codes.
+ * Moreover, the maximum allowed bit length is 32767 because
+ * the largest QR Code (version 40) has 31329 modules.
+ */
+struct qrcodegen_Segment {
+	// The mode indicator of this segment.
+	enum qrcodegen_Mode mode;
+	
+	// The length of this segment's unencoded data. Measured in characters for
+	// numeric/alphanumeric/kanji mode, bytes for byte mode, and 0 for ECI mode.
+	// Always zero or positive. Not the same as the data's bit length.
+	int numChars;
+	
+	// The data bits of this segment, packed in bitwise big endian.
+	// Can be null if the bit length is zero.
+	uint8_t *data;
+	
+	// The number of valid data bits used in the buffer. Requires
+	// 0 <= bitLength <= 32767, and bitLength <= (capacity of data array) * 8.
+	// The character count (numChars) must agree with the mode and the bit buffer length.
+	int bitLength;
+};
+
+
+
+/*---- Macro constants and functions ----*/
+
+#define qrcodegen_VERSION_MIN   1  // The minimum version number supported in the QR Code Model 2 standard
+#define qrcodegen_VERSION_MAX  40  // The maximum version number supported in the QR Code Model 2 standard
+
+// Calculates the number of bytes needed to store any QR Code up to and including the given version number,
+// as a compile-time constant. For example, 'uint8_t buffer[qrcodegen_BUFFER_LEN_FOR_VERSION(25)];'
+// can store any single QR Code from version 1 to 25 (inclusive). The result fits in an int (or int16).
+// Requires qrcodegen_VERSION_MIN <= n <= qrcodegen_VERSION_MAX.
+#define qrcodegen_BUFFER_LEN_FOR_VERSION(n)  ((((n) * 4 + 17) * ((n) * 4 + 17) + 7) / 8 + 1)
+
+// The worst-case number of bytes needed to store one QR Code, up to and including
+// version 40. This value equals 3918, which is just under 4 kilobytes.
+// Use this more convenient value to avoid calculating tighter memory bounds for buffers.
+#define qrcodegen_BUFFER_LEN_MAX  qrcodegen_BUFFER_LEN_FOR_VERSION(qrcodegen_VERSION_MAX)
+
+
+
+/*---- Functions (high level) to generate QR Codes ----*/
+
+/* 
+ * Encodes the given text string to a QR Code, returning true if successful.
+ * If the data is too long to fit in any version in the given range
+ * at the given ECC level, then false is returned.
+ * 
+ * The input text must be encoded in UTF-8 and contain no NULs.
+ * Requires 1 <= minVersion <= maxVersion <= 40.
+ * 
+ * The smallest possible QR Code version within the given range is automatically
+ * chosen for the output. Iff boostEcl is true, then the ECC level of the result
+ * may be higher than the ecl argument if it can be done without increasing the
+ * version. The mask is either between qrcodegen_Mask_0 to 7 to force that mask, or
+ * qrcodegen_Mask_AUTO to automatically choose an appropriate mask (which may be slow).
+ * 
+ * About the arrays, letting len = qrcodegen_BUFFER_LEN_FOR_VERSION(maxVersion):
+ * - Before calling the function:
+ *   - The array ranges tempBuffer[0 : len] and qrcode[0 : len] must allow
+ *     reading and writing; hence each array must have a length of at least len.
+ *   - The two ranges must not overlap (aliasing).
+ *   - The initial state of both ranges can be uninitialized
+ *     because the function always writes before reading.
+ * - After the function returns:
+ *   - Both ranges have no guarantee on which elements are initialized and what values are stored.
+ *   - tempBuffer contains no useful data and should be treated as entirely uninitialized.
+ *   - If successful, qrcode can be passed into qrcodegen_getSize() and qrcodegen_getModule().
+ * 
+ * If successful, the resulting QR Code may use numeric,
+ * alphanumeric, or byte mode to encode the text.
+ * 
+ * In the most optimistic case, a QR Code at version 40 with low ECC
+ * can hold any UTF-8 string up to 2953 bytes, or any alphanumeric string
+ * up to 4296 characters, or any digit string up to 7089 characters.
+ * These numbers represent the hard upper limit of the QR Code standard.
+ * 
+ * Please consult the QR Code specification for information on
+ * data capacities per version, ECC level, and text encoding mode.
+ */
+bool qrcodegen_encodeText(const char *text, uint8_t tempBuffer[], uint8_t qrcode[],
+	enum qrcodegen_Ecc ecl, int minVersion, int maxVersion, enum qrcodegen_Mask mask, bool boostEcl);
+
+
+/* 
+ * Encodes the given binary data to a QR Code, returning true if successful.
+ * If the data is too long to fit in any version in the given range
+ * at the given ECC level, then false is returned.
+ * 
+ * Requires 1 <= minVersion <= maxVersion <= 40.
+ * 
+ * The smallest possible QR Code version within the given range is automatically
+ * chosen for the output. Iff boostEcl is true, then the ECC level of the result
+ * may be higher than the ecl argument if it can be done without increasing the
+ * version. The mask is either between qrcodegen_Mask_0 to 7 to force that mask, or
+ * qrcodegen_Mask_AUTO to automatically choose an appropriate mask (which may be slow).
+ * 
+ * About the arrays, letting len = qrcodegen_BUFFER_LEN_FOR_VERSION(maxVersion):
+ * - Before calling the function:
+ *   - The array ranges dataAndTemp[0 : len] and qrcode[0 : len] must allow
+ *     reading and writing; hence each array must have a length of at least len.
+ *   - The two ranges must not overlap (aliasing).
+ *   - The input array range dataAndTemp[0 : dataLen] should normally be
+ *     valid UTF-8 text, but is not required by the QR Code standard.
+ *   - The initial state of dataAndTemp[dataLen : len] and qrcode[0 : len]
+ *     can be uninitialized because the function always writes before reading.
+ * - After the function returns:
+ *   - Both ranges have no guarantee on which elements are initialized and what values are stored.
+ *   - dataAndTemp contains no useful data and should be treated as entirely uninitialized.
+ *   - If successful, qrcode can be passed into qrcodegen_getSize() and qrcodegen_getModule().
+ * 
+ * If successful, the resulting QR Code will use byte mode to encode the data.
+ * 
+ * In the most optimistic case, a QR Code at version 40 with low ECC can hold any byte
+ * sequence up to length 2953. This is the hard upper limit of the QR Code standard.
+ * 
+ * Please consult the QR Code specification for information on
+ * data capacities per version, ECC level, and text encoding mode.
+ */
+bool qrcodegen_encodeBinary(uint8_t dataAndTemp[], size_t dataLen, uint8_t qrcode[],
+	enum qrcodegen_Ecc ecl, int minVersion, int maxVersion, enum qrcodegen_Mask mask, bool boostEcl);
+
+
+/*---- Functions (low level) to generate QR Codes ----*/
+
+/* 
+ * Encodes the given segments to a QR Code, returning true if successful.
+ * If the data is too long to fit in any version at the given ECC level,
+ * then false is returned.
+ * 
+ * The smallest possible QR Code version is automatically chosen for
+ * the output. The ECC level of the result may be higher than the
+ * ecl argument if it can be done without increasing the version.
+ * 
+ * About the byte arrays, letting len = qrcodegen_BUFFER_LEN_FOR_VERSION(qrcodegen_VERSION_MAX):
+ * - Before calling the function:
+ *   - The array ranges tempBuffer[0 : len] and qrcode[0 : len] must allow
+ *     reading and writing; hence each array must have a length of at least len.
+ *   - The two ranges must not overlap (aliasing).
+ *   - The initial state of both ranges can be uninitialized
+ *     because the function always writes before reading.
+ *   - The input array segs can contain segments whose data buffers overlap with tempBuffer.
+ * - After the function returns:
+ *   - Both ranges have no guarantee on which elements are initialized and what values are stored.
+ *   - tempBuffer contains no useful data and should be treated as entirely uninitialized.
+ *   - Any segment whose data buffer overlaps with tempBuffer[0 : len]
+ *     must be treated as having invalid values in that array.
+ *   - If successful, qrcode can be passed into qrcodegen_getSize() and qrcodegen_getModule().
+ * 
+ * Please consult the QR Code specification for information on
+ * data capacities per version, ECC level, and text encoding mode.
+ * 
+ * This function allows the user to create a custom sequence of segments that switches
+ * between modes (such as alphanumeric and byte) to encode text in less space.
+ * This is a low-level API; the high-level API is qrcodegen_encodeText() and qrcodegen_encodeBinary().
+ */
+bool qrcodegen_encodeSegments(const struct qrcodegen_Segment segs[], size_t len,
+	enum qrcodegen_Ecc ecl, uint8_t tempBuffer[], uint8_t qrcode[]);
+
+
+/* 
+ * Encodes the given segments to a QR Code, returning true if successful.
+ * If the data is too long to fit in any version in the given range
+ * at the given ECC level, then false is returned.
+ * 
+ * Requires 1 <= minVersion <= maxVersion <= 40.
+ * 
+ * The smallest possible QR Code version within the given range is automatically
+ * chosen for the output. Iff boostEcl is true, then the ECC level of the result
+ * may be higher than the ecl argument if it can be done without increasing the
+ * version. The mask is either between qrcodegen_Mask_0 to 7 to force that mask, or
+ * qrcodegen_Mask_AUTO to automatically choose an appropriate mask (which may be slow).
+ * 
+ * About the byte arrays, letting len = qrcodegen_BUFFER_LEN_FOR_VERSION(qrcodegen_VERSION_MAX):
+ * - Before calling the function:
+ *   - The array ranges tempBuffer[0 : len] and qrcode[0 : len] must allow
+ *     reading and writing; hence each array must have a length of at least len.
+ *   - The two ranges must not overlap (aliasing).
+ *   - The initial state of both ranges can be uninitialized
+ *     because the function always writes before reading.
+ *   - The input array segs can contain segments whose data buffers overlap with tempBuffer.
+ * - After the function returns:
+ *   - Both ranges have no guarantee on which elements are initialized and what values are stored.
+ *   - tempBuffer contains no useful data and should be treated as entirely uninitialized.
+ *   - Any segment whose data buffer overlaps with tempBuffer[0 : len]
+ *     must be treated as having invalid values in that array.
+ *   - If successful, qrcode can be passed into qrcodegen_getSize() and qrcodegen_getModule().
+ * 
+ * Please consult the QR Code specification for information on
+ * data capacities per version, ECC level, and text encoding mode.
+ * 
+ * This function allows the user to create a custom sequence of segments that switches
+ * between modes (such as alphanumeric and byte) to encode text in less space.
+ * This is a low-level API; the high-level API is qrcodegen_encodeText() and qrcodegen_encodeBinary().
+ */
+bool qrcodegen_encodeSegmentsAdvanced(const struct qrcodegen_Segment segs[], size_t len, enum qrcodegen_Ecc ecl,
+	int minVersion, int maxVersion, enum qrcodegen_Mask mask, bool boostEcl, uint8_t tempBuffer[], uint8_t qrcode[]);
+
+
+/* 
+ * Tests whether the given string can be encoded as a segment in numeric mode.
+ * A string is encodable iff each character is in the range 0 to 9.
+ */
+bool qrcodegen_isNumeric(const char *text);
+
+
+/* 
+ * Tests whether the given string can be encoded as a segment in alphanumeric mode.
+ * A string is encodable iff each character is in the following set: 0 to 9, A to Z
+ * (uppercase only), space, dollar, percent, asterisk, plus, hyphen, period, slash, colon.
+ */
+bool qrcodegen_isAlphanumeric(const char *text);
+
+
+/* 
+ * Returns the number of bytes (uint8_t) needed for the data buffer of a segment
+ * containing the given number of characters using the given mode. Notes:
+ * - Returns SIZE_MAX on failure, i.e. numChars > INT16_MAX or the internal
+ *   calculation of the number of needed bits exceeds INT16_MAX (i.e. 32767).
+ * - Otherwise, all valid results are in the range [0, ceil(INT16_MAX / 8)], i.e. at most 4096.
+ * - It is okay for the user to allocate more bytes for the buffer than needed.
+ * - For byte mode, numChars measures the number of bytes, not Unicode code points.
+ * - For ECI mode, numChars must be 0, and the worst-case number of bytes is returned.
+ *   An actual ECI segment can have shorter data. For non-ECI modes, the result is exact.
+ */
+size_t qrcodegen_calcSegmentBufferSize(enum qrcodegen_Mode mode, size_t numChars);
+
+
+/* 
+ * Returns a segment representing the given binary data encoded in
+ * byte mode. All input byte arrays are acceptable. Any text string
+ * can be converted to UTF-8 bytes and encoded as a byte mode segment.
+ */
+struct qrcodegen_Segment qrcodegen_makeBytes(const uint8_t data[], size_t len, uint8_t buf[]);
+
+
+/* 
+ * Returns a segment representing the given string of decimal digits encoded in numeric mode.
+ */
+struct qrcodegen_Segment qrcodegen_makeNumeric(const char *digits, uint8_t buf[]);
+
+
+/* 
+ * Returns a segment representing the given text string encoded in alphanumeric mode.
+ * The characters allowed are: 0 to 9, A to Z (uppercase only), space,
+ * dollar, percent, asterisk, plus, hyphen, period, slash, colon.
+ */
+struct qrcodegen_Segment qrcodegen_makeAlphanumeric(const char *text, uint8_t buf[]);
+
+
+/* 
+ * Returns a segment representing an Extended Channel Interpretation
+ * (ECI) designator with the given assignment value.
+ */
+struct qrcodegen_Segment qrcodegen_makeEci(long assignVal, uint8_t buf[]);
+
+
+/*---- Functions to extract raw data from QR Codes ----*/
+
+/* 
+ * Returns the side length of the given QR Code, assuming that encoding succeeded.
+ * The result is in the range [21, 177]. Note that the length of the array buffer
+ * is related to the side length - every 'uint8_t qrcode[]' must have length at least
+ * qrcodegen_BUFFER_LEN_FOR_VERSION(version), which equals ceil(size^2 / 8 + 1).
+ */
+int qrcodegen_getSize(const uint8_t qrcode[]);
+
+
+/* 
+ * Returns the color of the module (pixel) at the given coordinates, which is false
+ * for light or true for dark. The top left corner has the coordinates (x=0, y=0).
+ * If the given coordinates are out of bounds, then false (light) is returned.
+ */
+bool qrcodegen_getModule(const uint8_t qrcode[], int x, int y);
+
+
+#ifdef __cplusplus
+}
+#endif

src/http.cpp

@@ -0,0 +1,111 @@
+#include "http.h"
+#include <sstream>
+
+#ifndef CURL_PROGRESSFUNC_CONTINUE
+#define CURL_PROGRESSFUNC_CONTINUE 0x10000001
+#endif
+
+class curl_error : public std::exception {
+public:
+    explicit curl_error(CURLcode c) : code(c) {}
+    const char* what() const noexcept override { return curl_easy_strerror(this->code); }
+
+private:
+    CURLcode code;
+};
+
+/// @brief curl context
+
+HTTP::HTTP() : chunk(nullptr) {
+    this->easy = curl_easy_init();
+
+    curl_easy_setopt(this->easy, CURLOPT_USERAGENT, "curl/" LIBCURL_VERSION);
+    curl_easy_setopt(this->easy, CURLOPT_FOLLOWLOCATION, 1L);
+    // enable all supported built-in compressions
+    curl_easy_setopt(this->easy, CURLOPT_ACCEPT_ENCODING, "");
+    curl_easy_setopt(this->easy, CURLOPT_SSL_VERIFYHOST, 0L);
+    curl_easy_setopt(this->easy, CURLOPT_SSL_VERIFYPEER, 0L);
+
+    curl_easy_setopt(this->easy, CURLOPT_COOKIEJAR, "");
+}
+
+HTTP::~HTTP() {
+    if (this->chunk != nullptr) curl_slist_free_all(this->chunk);
+    if (this->easy != nullptr) curl_easy_cleanup(this->easy);
+}
+
+void HTTP::set_headers(const std::vector<std::string>& headers) {
+    if (this->chunk != nullptr) {
+        curl_slist_free_all(this->chunk);
+        this->chunk = nullptr;
+    }
+    for (auto& h : headers) {
+        this->chunk = curl_slist_append(this->chunk, h.c_str());
+    }
+    curl_easy_setopt(this->easy, CURLOPT_HTTPHEADER, this->chunk);
+}
+
+size_t HTTP::easy_write_cb(char* ptr, size_t size, size_t nmemb, void* userdata) {
+    std::ostream* ctx = reinterpret_cast<std::ostream*>(userdata);
+    size_t count = size * nmemb;
+    ctx->write(ptr, static_cast<std::streamsize>(count));
+    return count;
+}
+
+size_t HTTP::easy_read_cb(char* ptr, size_t size, size_t nmemb, void* userdata) {
+    std::istream* ctx = reinterpret_cast<std::istream*>(userdata);
+    size_t count = size * nmemb;
+    ctx->read(ptr, static_cast<std::streamsize>(count));
+    return ctx->gcount();
+}
+
+int HTTP::perform(std::ostream* body) {
+    curl_easy_setopt(this->easy, CURLOPT_WRITEFUNCTION, easy_write_cb);
+    curl_easy_setopt(this->easy, CURLOPT_WRITEDATA, body);
+
+    CURLcode res = curl_easy_perform(this->easy);
+    if (res != CURLE_OK) {
+        body->clear();
+        throw curl_error(res);
+    }
+    int status_code = 0;
+    curl_easy_getinfo(this->easy, CURLINFO_RESPONSE_CODE, &status_code);
+    return status_code;
+}
+
+std::string HTTP::encode_form(const Form& form) {
+    std::ostringstream ss;
+    char* escaped;
+    for (auto it = form.begin(); it != form.end(); ++it) {
+        if (it != form.begin()) ss << '&';
+        escaped = curl_escape(it->second.c_str(), it->second.size());
+        ss << it->first << '=' << escaped;
+        curl_free(escaped);
+    }
+    return ss.str();
+}
+
+int HTTP::get(const std::string& url, std::ostream* out) {
+    curl_easy_setopt(this->easy, CURLOPT_URL, url.c_str());
+    curl_easy_setopt(this->easy, CURLOPT_HTTPGET, 1L);
+    return this->perform(out);
+}
+
+std::string HTTP::put(const std::string& url, std::istream* data) {
+    std::ostringstream body;
+    curl_easy_setopt(this->easy, CURLOPT_URL, url.c_str());
+    curl_easy_setopt(this->easy, CURLOPT_UPLOAD, 1L);
+    curl_easy_setopt(this->easy, CURLOPT_READFUNCTION, easy_read_cb);
+    curl_easy_setopt(this->easy, CURLOPT_READDATA, data);
+    this->perform(&body);
+    return body.str();
+}
+
+std::string HTTP::post(const std::string& url, const std::string& data) {
+    std::ostringstream body;
+    curl_easy_setopt(this->easy, CURLOPT_URL, url.c_str());
+    curl_easy_setopt(this->easy, CURLOPT_POSTFIELDS, data.c_str());
+    curl_easy_setopt(this->easy, CURLOPT_POSTFIELDSIZE, data.size());
+    this->perform(&body);
+    return body.str();
+}

src/main.cpp

@@ -0,0 +1,25 @@
+#include "http.h"
+#include <qrcodegen/qrcodegen.h>
+
+void printQr(const std::string& text) {
+    int border = 1;
+    std::vector<uint8_t> qrcode(qrcodegen_BUFFER_LEN_MAX), tmpbuf(qrcodegen_BUFFER_LEN_MAX);
+    qrcodegen_encodeText(text.c_str(), tmpbuf.data(), qrcode.data(), qrcodegen_Ecc_LOW, qrcodegen_VERSION_MIN,
+        qrcodegen_VERSION_MAX, qrcodegen_Mask_AUTO, true);
+    int width = qrcodegen_getSize(qrcode.data());
+
+    for (int y = -border; y < width + border; y++) {
+        for (int x = -border; x < width + border; x++) {
+            qrcodegen_getModule(qrcode.data(), x, y) ? printf("\033[40m  \033[0m") : printf("\033[47m  \033[0m");
+        }
+        printf("\n");
+    }
+    printf("\n");
+}
+
+int main(int argc, char* argv[]) {
+    curl_global_init(CURL_GLOBAL_ALL);
+
+    curl_global_cleanup();
+    return 0;
+}

src/misc.cpp

@@ -0,0 +1,52 @@
+#include "drive.h"
+#include <sstream>
+#include <iomanip>
+
+#ifdef __SWITCH__
+#include <switch.h>
+#elif defined(_WIN32)
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#elif defined(__APPLE__)
+#include <SystemConfiguration/SystemConfiguration.h>
+#else
+#include <unistd.h>
+#endif
+
+std::string hex_encode(const unsigned char* data, size_t len) {
+    std::stringstream ss;
+    for (size_t i = 0; i < len; i++) ss << std::hex << std::setw(2) << std::setfill('0') << (int)data[i];
+    return ss.str();
+}
+
+std::string device_name() {
+#ifdef __SWITCH__
+    SetSysDeviceNickName nick;
+    if (R_SUCCEEDED(setsysGetDeviceNickname(&nick))) {
+        return nick.nickname;
+    }
+#elif defined(_WIN32)
+    DWORD nSize = 128;
+    std::vector<WCHAR> buf(nSize);
+    if (GetComputerNameW(buf.data(), &nSize)) {
+        std::string name;
+        name.resize(nSize);
+        WideCharToMultiByte(CP_UTF8, 0, buf.data(), nSize, name.data(), name.size(), nullptr, nullptr);
+        return name;
+    }
+#elif defined(__APPLE__)
+    CFStringRef nameRef = SCDynamicStoreCopyComputerName(nullptr, nullptr);
+    if (nameRef) {
+        std::vector<char> name(CFStringGetLength(nameRef) * 3);
+        CFStringGetCString(nameRef, name.data(), name.size(), kCFStringEncodingUTF8);
+        CFRelease(nameRef);
+        return name.data();
+    }
+#else
+    std::vector<char> buf(128);
+    if (gethostname(buf.data(), buf.size()) == 0) {
+        return buf.data();
+    }
+#endif
+    return "cDrive";
+}