demo/cDrive
1
0
Fork 0
Code Activity

init http framework

Browse Source
This commit is contained in:
dragonflylee
2023-04-25 02:59:59 +00:00
parent f4e7319a44
commit 7b9fc827ca
12 changed files with 1693 additions and 39 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

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

1
.vscode/c_cpp_properties.json vendored
View File

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

41
CMakeLists.txt
View File

@@ -1,43 +1,12 @@
cmake_minimum_required(VERSION 3.15)
include(FetchContent)
set(CMAKE_BUILD_TYPE Release)
FetchContent_Declare(spdlog
URL https://github.com/gabime/spdlog/archive/v1.11.0.tar.gz
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 ()
find_package(mbedtls REQUIRED)
find_package(CURL REQUIRED)
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_link_libraries(${PROJECT_NAME} PRIVATE spdlog mbedtls qrcodegen CURL::libcurl)
target_include_directories(${PROJECT_NAME} PRIVATE include qrcodegen)
target_link_libraries(${PROJECT_NAME} PRIVATE mbedtls CURL::libcurl)

7
Makefile
View File

@@ -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)

13
README.md
View File

@@ -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
```

35
include/drive.h Normal file
View File

@@ -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);

33
include/http.h Normal file
View File

@@ -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;
};

1028
qrcodegen/qrcodegen.c Normal file
View File

File diff suppressed because it is too large Load Diff

385
qrcodegen/qrcodegen.h Normal file
View File

@@ -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

111
src/http.cpp Normal file
View File

@@ -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();
}

25
src/main.cpp Normal file
View File

@@ -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;
}

52
src/misc.cpp Normal file
View File

@@ -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";
}