@ossiana/node-libcurl 1.0.7-alpha-2 → 1.0.8-alpha-1

package/src/fetch.ts

@@ -1,19 +1,8 @@
-import { LibCurl, LibCurl_HTTP_VERSION } from "./libcurl";
-
-type LibCurlHeadersInfo = [string, string][] | object | string;
-type LibCurlBodyInfo = string | Uint8Array | any;
-type LibCurlCookiesInfo = string | object;
-type LibCurlHttpVersionInfo = LibCurl_HTTP_VERSION;
-
-type LibCurlProxyWithAccountInfo = {
-    proxy: string;
-    username: string;
-    password: string;
-};
-type LibCurlProxyInfo = string | LibCurlProxyWithAccountInfo;
+import { LibCurl, LibCurlBodyInfo, LibCurlMethodInfo, LibCurlHeadersInfo, LibCurlCookiesAttr, LibCurlHttpVersionInfo, LibCurlProxyInfo, LibCurlCookiesInfo } from "./libcurl";
+import { libcurlSetCookies } from "./utils";
 
 interface LibCurlRequestInfo {
-    method?: string;
+    method?: LibCurlMethodInfo;
     headers?: LibCurlHeadersInfo;
     body?: LibCurlBodyInfo;
     redirect?: boolean;
@@ -32,85 +21,48 @@ interface LibCurlResponseInfo {
     arraybuffer: () => Promise<ArrayBuffer>;
     text: () => Promise<string>;
     json: () => Promise<object>;
-    jsonp: (callbackName?: string) => Promise<object>;
     headers: () => Promise<string>;
+    cookies: () => Promise<string>;
+    cookiesMap: () => Promise<LibCurlCookiesAttr>;
 }
 
 export async function fetch(url: string | URL, request: LibCurlRequestInfo = {}): Promise<LibCurlResponseInfo> {
     request.instance ||= new LibCurl();
     const curl = request.instance;
-    return new Promise((resolve, reject) => {
-        const { method = "GET",
-            headers = [], redirect = false, httpVersion = 0,
-            openInnerLog = false, proxy, body, cookies } = request;
-        curl.open(method, url + '', true);
-        if (Array.isArray(headers)) {
-            headers.forEach(([key, value]) => {
-                curl.setRequestHeader(key, value);
-            });
-        } else if (typeof headers == 'object') {
-            Object.keys(headers).forEach((key: string) => {
-                curl.setRequestHeader(key, headers[key]);
-            })
-        } else {
-            curl.setRequestHeaders(headers);
-        }
-        if (redirect) {
-            curl.setRedirect(true);
-        }
-        if (httpVersion) {
-            curl.setHttpVersion(httpVersion);
-        }
-        if (openInnerLog) {
-            curl.printInnerLogger();
-        }
+    const { method = "GET",
+        headers, redirect = false, httpVersion = 0,
+        openInnerLog = false, proxy, body, cookies } = request;
+    curl.open(method, url + '', true);
+    if (headers) {
+        curl.setRequestHeaders(headers);
+    }
+    if (redirect) {
+        curl.setRedirect(true);
+    }
+    if (httpVersion) {
+        curl.setHttpVersion(httpVersion);
+    }
+    if (openInnerLog) {
+        curl.printInnerLogger();
+    }
+    if (cookies) {
+        const { hostname } = new URL(url);
         if (cookies) {
-            const { hostname } = new URL(url);
-            if (typeof cookies == 'string') {
-                cookies.replace(/\s+/g, '')
-                    .split(';')
-                    .reverse()//保证顺序不颠倒
-                    .map(e => e.split('=', 2))
-                    .forEach(([key, value]) => {
-                        curl.setCookie(key, value, hostname)
-                    });
-            } else {
-                Object.keys(cookies).forEach(key => {
-                    curl.setCookie(key, cookies[key], hostname);
-                })
-            }
-        }
-        if (proxy) {
-            if (typeof proxy == "string") {
-                curl.setProxy(proxy);
-            } else {
-                const {
-                    proxy: proxy_,
-                    username,
-                    password,
-                } = proxy;
-                curl.setProxy(proxy_, username, password);
-            }
+            libcurlSetCookies(curl, cookies, hostname);
         }
-        let promise: Promise<undefined>;
-        if (body) {
-            promise = curl.send(body);
-        } else {
-            promise = curl.send();
-        }
-        promise.then(() => {
-
-            resolve(
-                {
-                    status: () => curl.getResponseStatus(),
-                    arraybuffer: async () => curl.getResponseBody().buffer,
-                    text: async () => curl.getResponseString(),
-                    json: async () => curl.getResponseJson(),
-                    jsonp: async (callbackName?: string) => curl.getResponseJsonp(callbackName),
-                    headers: async () => curl.getResponseHeaders(),
-                }
-            )
-        })
+    }
+    if (proxy) {
+        curl.setProxy(proxy);
+    }
+    await curl.send(body);
+    return {
+        status: () => curl.getResponseStatus(),
+        arraybuffer: async () => curl.getResponseBody().buffer,
+        text: async () => curl.getResponseString(),
+        json: async () => curl.getResponseJson(),
+        headers: async () => curl.getResponseHeaders(),
+        cookies: async () => curl.getCookies(),
+        cookiesMap: async () => curl.getCookiesMap(),
+    } as LibCurlResponseInfo;
 
-    })
 }

package/src/libcurl/bao_curl.cpp

@@ -1,9 +1,13 @@
 #include "bao_curl.h"
 
-#define CHECK_CURLOK(e)                                                                        \
-	{                                                                                          \
-		CURLcode code = (e);                                                                   \
-		(code != CURLcode::CURLE_OK) && (printf("CURL Error:%s\n", curl_easy_strerror(code))); \
+#define CHECK_CURLOK(e)                                          \
+	{                                                            \
+		CURLcode code = (e);                                     \
+		this->m_lastCode = code;								 \
+		if (this->m_verbose && code != CURLcode::CURLE_OK)       \
+		{                                                        \
+			printf("CURL Error:%s\n", curl_easy_strerror(code)); \
+		}                                                        \
 	}
 
 size_t write_func(void *ptr, size_t size, size_t nmemb, std::string &stream)
@@ -33,12 +37,14 @@ void BaoCurl::init()
 	CHECK_CURLOK(curl_easy_setopt(this->m_pCURL, CURLOPT_SSL_VERIFYHOST, 0L));
 	CHECK_CURLOK(curl_easy_setopt(this->m_pCURL, CURLOPT_SSL_CIPHER_LIST, "ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-RSA-AES128-SHA:ECDHE-RSA-AES256-SHA:AES128-GCM-SHA256:AES256-GCM-SHA384:DH-RSA-AES128-GCM-SHA256:AES128-SHA:AES256-SHA"));
 	CHECK_CURLOK(curl_easy_setopt(this->m_pCURL, CURLOPT_SSL_EC_CURVES, "X25519:P-256:P-384"));
+	// CHECK_CURLOK(curl_easy_setopt(this->m_pCURL, CURLOPT_SSL_, "X25519:P-256:P-384"));
 	CHECK_CURLOK(curl_easy_setopt(this->m_pCURL, CURLOPT_ACCEPT_ENCODING, ""));
 	CHECK_CURLOK(curl_easy_setopt(this->m_pCURL, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1));
+	CHECK_CURLOK(curl_easy_setopt(this->m_pCURL, CURLOPT_COOKIEFILE, NULL));
 	this->setTimeout(15, 15);
 }
 
-void BaoCurl::open(std::string method, std::string url)
+void BaoCurl::open(std::string &method, std::string &url)
 {
 	this->m_method = method;
 	this->m_stream.header = "";
@@ -63,17 +69,17 @@ void BaoCurl::open(std::string method, std::string url)
 	CHECK_CURLOK(curl_easy_setopt(this->m_pCURL, CURLOPT_CUSTOMREQUEST, method.c_str()));
 }
 
-void BaoCurl::setRequestHeader(std::string key, std::string value)
+void BaoCurl::setRequestHeader(std::string &key, std::string &value)
 {
 	this->m_pHeaders = curl_slist_append(this->m_pHeaders, (key + ": " + value).c_str());
 }
 
-void BaoCurl::setRequestHeader(std::string keyValue)
+void BaoCurl::setRequestHeader(std::string &keyValue)
 {
 	this->m_pHeaders = curl_slist_append(this->m_pHeaders, keyValue.c_str());
 }
 
-void BaoCurl::setRequestHeaders(std::string header)
+void BaoCurl::setRequestHeaders(std::string &header)
 {
 	auto arr = StringSplit(header, "\n");
 	for (auto arr_b = arr.begin(); arr_b != arr.end(); ++arr_b)
@@ -87,14 +93,14 @@ void BaoCurl::setRequestHeaders(std::string header)
 	}
 }
 
-void BaoCurl::setProxy(std::string proxy)
+void BaoCurl::setProxy(std::string &proxy)
 {
 	CHECK_CURLOK(curl_easy_setopt(this->m_pCURL, CURLOPT_PROXY, proxy.c_str()));
 	this->m_bProxy = true;
 }
 
-void BaoCurl::setProxy(std::string proxy, std::string username,
-					   std::string password)
+void BaoCurl::setProxy(std::string &proxy, std::string &username,
+					   std::string &password)
 {
 	CHECK_CURLOK(curl_easy_setopt(this->m_pCURL, CURLOPT_PROXY, proxy.c_str()));
 	CHECK_CURLOK(curl_easy_setopt(this->m_pCURL, CURLOPT_PROXYUSERPWD, (username + ":" + password).c_str()));
@@ -116,10 +122,10 @@ void BaoCurl::setTimeout(
 
 void BaoCurl::send()
 {
-	BaoCurl::send("");
+	BaoCurl::send(std::string(""));
 }
 
-void BaoCurl::send(std::string data)
+void BaoCurl::send(std::string &data)
 {
 	CHECK_CURLOK(curl_easy_setopt(this->m_pCURL, CURLOPT_HTTPHEADER, this->m_pHeaders));
 	if (this->m_bProxy)
@@ -172,14 +178,14 @@ void BaoCurl::sendByte(const char *data, const int len)
 	this->m_pHeaders = NULL;
 }
 
-void BaoCurl::setCookie(std::string key, std::string value, std::string domain)
+void BaoCurl::setCookie(std::string &key, std::string &value, std::string &domain, std::string &path)
 {
-	CHECK_CURLOK(curl_easy_setopt(this->m_pCURL, CURLOPT_COOKIELIST, StringFormat("%s\tTRUE\t/\tFALSE\t3000000000\t%s\t%s", domain.c_str(), key.c_str(), value.c_str()).c_str()));
+	CHECK_CURLOK(curl_easy_setopt(this->m_pCURL, CURLOPT_COOKIELIST, StringFormat("%s\tFALSE\t%s\tFALSE\t3000000000\t%s\t%s", domain.c_str(), path.c_str(), key.c_str(), value.c_str()).c_str()));
 }
 
-void BaoCurl::removeCookie(std::string key, std::string domain)
+void BaoCurl::deleteCookie(std::string &key, std::string &domain, std::string &path)
 {
-	CHECK_CURLOK(curl_easy_setopt(this->m_pCURL, CURLOPT_COOKIELIST, StringFormat("%s\tTRUE\t/\tFALSE\t0\t%s\t%s", domain.c_str(), key.c_str(), "").c_str()));
+	CHECK_CURLOK(curl_easy_setopt(this->m_pCURL, CURLOPT_COOKIELIST, StringFormat("%s\tFALSE\t%s\tFALSE\t1600000000\t%s\t%s", domain.c_str(), path.c_str(), key.c_str(), "").c_str()));
 }
 
 std::string BaoCurl::getCookies()
@@ -187,6 +193,8 @@ std::string BaoCurl::getCookies()
 	struct curl_slist *cookies = NULL;
 	std::string str;
 	CHECK_CURLOK(curl_easy_getinfo(this->m_pCURL, CURLINFO_COOKIELIST, &cookies));
+	struct curl_slist *cookiesOrign = cookies;
+
 	if (!cookies)
 	{
 		return "";
@@ -197,29 +205,47 @@ std::string BaoCurl::getCookies()
 		str += "\n";
 		cookies = cookies->next;
 	} while (cookies);
+	curl_slist_free_all(cookiesOrign);
 	return str;
 }
 
-std::string BaoCurl::getCookie(std::string key)
+std::string BaoCurl::getCookie(std::string &key, std::string &domain, std::string &path)
 {
 	struct curl_slist *cookies = NULL;
 	std::string str = "";
 	CHECK_CURLOK(curl_easy_getinfo(this->m_pCURL, CURLINFO_COOKIELIST, &cookies));
+	struct curl_slist *cookiesOrign = cookies;
 	if (!cookies)
 	{
 		return "";
 	}
 	do
 	{
-		str = std::string(cookies->data);
-		size_t pos = str.find(key);
-		if (pos != -1)
+		std::vector<std::string> vt = StringSplit(std::string(cookies->data), "\t");
+		if (domain.size() != 0)
+		{
+			if (domain != vt.at(0))
+			{
+				cookies = cookies->next;
+				continue;
+			}
+		}
+		if (path.size() != 0)
 		{
+			if (path != vt.at(2))
+			{
+				cookies = cookies->next;
+				continue;
+			}
+		}
+		if (vt.at(5) == key)
+		{
+			str = vt.at(6);
 			break;
 		}
 		cookies = cookies->next;
 	} while (cookies);
-	curl_slist_free_all(cookies);
+	curl_slist_free_all(cookiesOrign);
 	return str;
 }
 
@@ -260,4 +286,14 @@ void BaoCurl::setHttpVersion(BaoCurl::HttpVersion version)
 		return;
 	}
 	CHECK_CURLOK(curl_easy_setopt(this->m_pCURL, CURLOPT_HTTP_VERSION, temp));
+}
+
+unsigned int BaoCurl::getLastCurlCode()
+{
+	return this->m_lastCode;
+}
+
+const char* BaoCurl::getLastCurlCodeError()
+{
+	return curl_easy_strerror(this->m_lastCode);
 }

package/src/libcurl/bao_curl_node_addon.cpp

@@ -32,7 +32,7 @@ private:
 	Napi::Value setProxy(const Napi::CallbackInfo &info);
 	Napi::Value setTimeout(const Napi::CallbackInfo &info);
 	Napi::Value setCookie(const Napi::CallbackInfo &info);
-	Napi::Value removeCookie(const Napi::CallbackInfo &info);
+	Napi::Value deleteCookie(const Napi::CallbackInfo &info);
 	Napi::Value getCookies(const Napi::CallbackInfo &info);
 	Napi::Value getCookie(const Napi::CallbackInfo &info);
 	Napi::Value getResponseStatus(const Napi::CallbackInfo &info);
@@ -51,7 +51,7 @@ Napi::Object BaoLibCurlWarp::Init(Napi::Env env, Napi::Object exports)
 {
 	// This method is used to hook the accessor and method callbacks
 	std::vector<Napi::ClassPropertyDescriptor<BaoLibCurlWarp>> methodList = {
-		InstanceMethod<&BaoLibCurlWarp::open>("open", static_cast<napi_property_attributes>(napi_writable | napi_configurable)), InstanceMethod<&BaoLibCurlWarp::setRequestHeader>("setRequestHeader", static_cast<napi_property_attributes>(napi_writable | napi_configurable)), InstanceMethod<&BaoLibCurlWarp::setRequestHeaders>("setRequestHeaders", static_cast<napi_property_attributes>(napi_writable | napi_configurable)), InstanceMethod<&BaoLibCurlWarp::setProxy>("setProxy", static_cast<napi_property_attributes>(napi_writable | napi_configurable)), InstanceMethod<&BaoLibCurlWarp::setTimeout>("setTimeout", static_cast<napi_property_attributes>(napi_writable | napi_configurable)), InstanceMethod<&BaoLibCurlWarp::setCookie>("setCookie", static_cast<napi_property_attributes>(napi_writable | napi_configurable)), InstanceMethod<&BaoLibCurlWarp::removeCookie>("removeCookie", static_cast<napi_property_attributes>(napi_writable | napi_configurable)), InstanceMethod<&BaoLibCurlWarp::getCookies>("getCookies", static_cast<napi_property_attributes>(napi_writable | napi_configurable)), InstanceMethod<&BaoLibCurlWarp::getCookie>("getCookie", static_cast<napi_property_attributes>(napi_writable | napi_configurable)), InstanceMethod<&BaoLibCurlWarp::getResponseStatus>("getResponseStatus", static_cast<napi_property_attributes>(napi_writable | napi_configurable)), InstanceMethod<&BaoLibCurlWarp::reset>("reset", static_cast<napi_property_attributes>(napi_writable | napi_configurable)), InstanceMethod<&BaoLibCurlWarp::setRedirect>("setRedirect", static_cast<napi_property_attributes>(napi_writable | napi_configurable)), InstanceMethod<&BaoLibCurlWarp::printInnerLogger>("printInnerLogger", static_cast<napi_property_attributes>(napi_writable | napi_configurable)), InstanceMethod<&BaoLibCurlWarp::setHttpVersion>("setHttpVersion", static_cast<napi_property_attributes>(napi_writable | napi_configurable)), InstanceMethod<&BaoLibCurlWarp::send>("send", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+		InstanceMethod<&BaoLibCurlWarp::open>("open", static_cast<napi_property_attributes>(napi_writable | napi_configurable)), InstanceMethod<&BaoLibCurlWarp::setRequestHeader>("setRequestHeader", static_cast<napi_property_attributes>(napi_writable | napi_configurable)), InstanceMethod<&BaoLibCurlWarp::setRequestHeaders>("setRequestHeaders", static_cast<napi_property_attributes>(napi_writable | napi_configurable)), InstanceMethod<&BaoLibCurlWarp::setProxy>("setProxy", static_cast<napi_property_attributes>(napi_writable | napi_configurable)), InstanceMethod<&BaoLibCurlWarp::setTimeout>("setTimeout", static_cast<napi_property_attributes>(napi_writable | napi_configurable)), InstanceMethod<&BaoLibCurlWarp::setCookie>("setCookie", static_cast<napi_property_attributes>(napi_writable | napi_configurable)), InstanceMethod<&BaoLibCurlWarp::deleteCookie>("deleteCookie", static_cast<napi_property_attributes>(napi_writable | napi_configurable)), InstanceMethod<&BaoLibCurlWarp::getCookies>("getCookies", static_cast<napi_property_attributes>(napi_writable | napi_configurable)), InstanceMethod<&BaoLibCurlWarp::getCookie>("getCookie", static_cast<napi_property_attributes>(napi_writable | napi_configurable)), InstanceMethod<&BaoLibCurlWarp::getResponseStatus>("getResponseStatus", static_cast<napi_property_attributes>(napi_writable | napi_configurable)), InstanceMethod<&BaoLibCurlWarp::reset>("reset", static_cast<napi_property_attributes>(napi_writable | napi_configurable)), InstanceMethod<&BaoLibCurlWarp::setRedirect>("setRedirect", static_cast<napi_property_attributes>(napi_writable | napi_configurable)), InstanceMethod<&BaoLibCurlWarp::printInnerLogger>("printInnerLogger", static_cast<napi_property_attributes>(napi_writable | napi_configurable)), InstanceMethod<&BaoLibCurlWarp::setHttpVersion>("setHttpVersion", static_cast<napi_property_attributes>(napi_writable | napi_configurable)), InstanceMethod<&BaoLibCurlWarp::send>("send", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
 		InstanceMethod<&BaoLibCurlWarp::getResponseBody>("getResponseBody", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
 		InstanceMethod<&BaoLibCurlWarp::getResponseString>("getResponseString", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
 		InstanceMethod<&BaoLibCurlWarp::sendAsync>("sendAsync", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
@@ -182,28 +182,31 @@ Napi::Value BaoLibCurlWarp::setCookie(const Napi::CallbackInfo &info)
 {
 	Napi::Env env = info.Env();
 	size_t argsLen = info.Length();
-	REQUEST_TLS_METHOD_ARGS_CHECK(env, "BaoCurl", "setCookie", 3, argsLen)
+	REQUEST_TLS_METHOD_ARGS_CHECK(env, "BaoCurl", "setCookie", 4, argsLen)
 	REQUEST_TLS_METHOD_CHECK(env, info[0].IsString(), "argument 0 is not a string")
 	REQUEST_TLS_METHOD_CHECK(env, info[1].IsString(), "argument 1 is not a string")
 	REQUEST_TLS_METHOD_CHECK(env, info[2].IsString(), "argument 2 is not a string")
+	REQUEST_TLS_METHOD_CHECK(env, info[3].IsString(), "argument 3 is not a string")
 	string key = info[0].As<Napi::String>().Utf8Value();
 	string value = info[1].As<Napi::String>().Utf8Value();
 	string domain = info[2].As<Napi::String>().Utf8Value();
-	this->m_curl.setCookie(key, value, domain);
+	string path = info[3].As<Napi::String>().Utf8Value();
+	this->m_curl.setCookie(key, value, domain,path);
 	return env.Undefined();
 }
 
 /*
-	removeCookie(key, domain)
+	deleteCookie(key, domain)
 */
-Napi::Value BaoLibCurlWarp::removeCookie(const Napi::CallbackInfo &info)
+Napi::Value BaoLibCurlWarp::deleteCookie(const Napi::CallbackInfo &info)
 {
 	Napi::Env env = info.Env();
 	size_t argsLen = info.Length();
-	REQUEST_TLS_METHOD_ARGS_CHECK(env, "BaoCurl", "removeCookie", 2, argsLen)
+	REQUEST_TLS_METHOD_ARGS_CHECK(env, "BaoCurl", "deleteCookie", 3, argsLen)
 	string key = info[0].As<Napi::String>().Utf8Value();
 	string domain = info[1].As<Napi::String>().Utf8Value();
-	this->m_curl.removeCookie(key, domain);
+	string path = info[2].As<Napi::String>().Utf8Value();
+	this->m_curl.deleteCookie(key, domain, path);
 	return env.Undefined();
 }
 
@@ -225,10 +228,14 @@ Napi::Value BaoLibCurlWarp::getCookie(const Napi::CallbackInfo &info)
 {
 	Napi::Env env = info.Env();
 	size_t argsLen = info.Length();
-	REQUEST_TLS_METHOD_ARGS_CHECK(env, "BaoCurl", "getCookie", 1, argsLen);
+	REQUEST_TLS_METHOD_ARGS_CHECK(env, "BaoCurl", "getCookie", 3, argsLen)
 	REQUEST_TLS_METHOD_CHECK(env, info[0].IsString(), "argument 0 is not a string")
-	return Napi::String::New(env, this->m_curl.getCookie(
-									  info[0].As<Napi::String>().Utf8Value()));
+	REQUEST_TLS_METHOD_CHECK(env, info[1].IsString(), "argument 1 is not a string")
+	REQUEST_TLS_METHOD_CHECK(env, info[2].IsString(), "argument 2 is not a string")
+	std::string key = info[0].As<Napi::String>().Utf8Value();
+	std::string domain = info[1].As<Napi::String>().Utf8Value();
+	std::string path = info[2].As<Napi::String>().Utf8Value();
+	return Napi::String::New(env, this->m_curl.getCookie(key, domain, path));
 }
 
 /*
@@ -370,7 +377,7 @@ Napi::Value BaoLibCurlWarp::sendAsync(const Napi::CallbackInfo &info)
 		size_t strLen = str.size();
 		Napi::Uint8Array u8buffer = Napi::Uint8Array::New(env, strLen);
 		memcpy(u8buffer.Data(), str.c_str(), strLen);
-		workerPtr = new curlAsyncWorker(info[1].As<Napi::Function>(), this->m_curl, (const char *)u8buffer.Data(),u8buffer.ElementLength());
+		workerPtr = new curlAsyncWorker(info[1].As<Napi::Function>(), this->m_curl, (const char *)u8buffer.Data(), u8buffer.ElementLength());
 		workerPtr->Queue();
 		return env.Undefined();
 	}
@@ -379,7 +386,7 @@ Napi::Value BaoLibCurlWarp::sendAsync(const Napi::CallbackInfo &info)
 	size_t strLen = jsonStr.size();
 	Napi::Uint8Array u8buffer = Napi::Uint8Array::New(env, strLen);
 	memcpy(u8buffer.Data(), jsonStr.c_str(), strLen);
-	workerPtr = new curlAsyncWorker(info[1].As<Napi::Function>(), this->m_curl, (const char *)u8buffer.Data(),u8buffer.ElementLength());
+	workerPtr = new curlAsyncWorker(info[1].As<Napi::Function>(), this->m_curl, (const char *)u8buffer.Data(), u8buffer.ElementLength());
 	workerPtr->Queue();
 	return env.Undefined();
 }

package/src/libcurl/curlAsyncWorker.cpp

@@ -20,6 +20,8 @@ curlAsyncWorker::~curlAsyncWorker()
 void curlAsyncWorker::Execute()
 {
     this->m_baoCurlInstance.sendByte(this->m_sendBody, this->m_bodySize);
+    this->m_lastCurlCode = this->m_baoCurlInstance.getLastCurlCode();
+    this->m_lastCurlCodeError = this->m_baoCurlInstance.getLastCurlCodeError();
 }
 
 // Executed when the async work is complete
@@ -27,12 +29,14 @@ void curlAsyncWorker::Execute()
 // so it is safe to use JS engine data again
 void curlAsyncWorker::OnOK()
 {
-    Napi::HandleScope scope(Env());
+    Napi::Env env = Env();
+    Napi::HandleScope scope(env);
     /* std::string str = this->m_baoCurlInstance.getResponseBody();
     size_t strLen = str.size();
     Napi::Uint8Array u8buffer = Napi::Uint8Array::New(Env(), strLen);
     memcpy(u8buffer.Data(), strLen, str.c_str(), strLen); */
     Callback().Call({
-        /* u8buffer */
+        Napi::Number::New(env,this->m_lastCurlCode),
+        Napi::String::New(env,this->m_lastCurlCodeError),
     });
 }

package/src/libcurl/include/bao_curl.h

@@ -2,79 +2,82 @@
 #ifndef _CURL_H
 #define _CURL_H
 
-
-
 #include "curl/curl.h"
 #include "utils.h"
 
-
-struct Stream_st {
+struct Stream_st
+{
 	std::string header;
 	std::string responseText;
 };
 
-class BaoCurl {
+class BaoCurl
+{
 public:
 	BaoCurl();
 	~BaoCurl();
-	void open(std::string, std::string);
-	void setRequestHeader(std::string, std::string);
-	void setRequestHeader(std::string);
-	void setRequestHeaders(std::string);
+	void open(std::string &, std::string &);
+	void setRequestHeader(std::string &, std::string &);
+	void setRequestHeader(std::string &);
+	void setRequestHeaders(std::string &);
 	/*
-	* setProxy必须在open后 send前设置
-	* 在send后失效 需重新设置
-	*/
-	void setProxy(std::string);
-	void setProxy(std::string, std::string,
-		std::string
-	);
+	 * setProxy必须在open后 send前设置
+	 * 在send后失效 需重新设置
+	 */
+	void setProxy(std::string &);
+	void setProxy(std::string &, std::string &,
+				  std::string &);
 	/*
-	* setTimeout必须在open后 send前设置
-	* 在send后失效 需重新设置
-	* 单位:秒   例子:setTimeout(10,10);
-	*/
+	 * setTimeout必须在open后 send前设置
+	 * 在send后失效 需重新设置
+	 * 单位:秒   例子:setTimeout(10,10);
+	 */
 	void setTimeout(
 		int connectTime,
-		int sendTime
-	);
+		int sendTime);
 	/*
-	* 设置单条Cookie
-	*/
-	void setCookie(std::string key, std::string value, std::string domain);
+	 * 设置单条Cookie
+	 */
+	void setCookie(std::string &key, std::string &value, std::string &domain, std::string &path);
 	/*
-	* 移除单条Cookie
-	*/
-	void removeCookie(std::string key, std::string domain);
+	 * 移除单条Cookie
+	 */
+	void deleteCookie(std::string &key, std::string &domain, std::string &path);
 	void send();
-	void send(std::string);
-	void sendByte(const char*,const int);
+	void send(std::string &);
+	void sendByte(const char *, const int);
 	/*
-	* 重置Curl 此前的操作全部失效
-	*/
+	 * 重置Curl 此前的操作全部失效
+	 */
 	void reset();
 
 	std::string getCookies();
-	std::string getCookie(std::string key);
+	std::string getCookie(std::string &key, std::string &domain, std::string &path);
 	std::string getResponseHeaders() { return this->m_stream.header; };
 	std::string getResponseBody() { return this->m_stream.responseText; };
 	long getResponseStatus();
-	void setRedirect(bool isAllow);//重定向
-	void printInnerLogger();//打印内部日志
+	void setRedirect(bool isAllow); // 重定向
+	void printInnerLogger();		// 打印内部日志
 
-	enum HttpVersion {
+	enum HttpVersion
+	{
 		http1_1,
 		http2,
 	};
 	void setHttpVersion(HttpVersion);
+	unsigned int getLastCurlCode();
+	const char *getLastCurlCodeError();
+
 private:
-	CURL* m_pCURL = NULL;
-	struct curl_slist* m_pHeaders = NULL;
+	CURL *m_pCURL = NULL;
+	struct curl_slist *m_pHeaders = NULL;
 	std::string m_method = "GET";
 	struct Stream_st m_stream;
 	// struct curl_slist* m_cookies = NULL;
 	bool m_bProxy = false;
 	bool m_bIsHttps = false;
+	bool m_verbose = false;
+	CURLcode m_lastCode;
 
 	void init();
 };

package/src/libcurl/include/curlAysncWorker.h

@@ -13,4 +13,6 @@ private:
     BaoCurl &m_baoCurlInstance;
     char* m_sendBody = nullptr;
     size_t m_bodySize;
+    unsigned int m_lastCurlCode = 0;
+    const char* m_lastCurlCodeError = "";
 };