GitHub ci (#1)

* add docker build yaml * add curl script files * update workflow to upload a release * remove release folder * tidy up gitignore * debug why zip isnt grabbing curl ext * properly grab release (../)
author: sappho <sappho@sappho.io> 2023-07-14 03:01:32 -0400
committer: GitHub <noreply@github.com> 2023-07-14 03:01:32 -0400
commit: 581d1e994692f9ce4e5d8071e8edba1e71412bac (patch)
tree: 02ae7622378e2bc4e6380ac2f6328bb4b0bc42a5
parent: 95ac30070823bea03da6610db2b0684fd96e1f7e (diff)
6 files changed, 2635 insertions, 0 deletions
diff --git a/.github/workflows/docker_build.yml b/.github/workflows/docker_build.yml
new file mode 100644
index 0000000..1ba2b60
--- /dev/null
+++ b/.github/workflows/docker_build.yml
@@ -0,0 +1,57 @@
+on:
+  push
+jobs:
+    compile:
+        name: Compile extension in docker
+        runs-on: ubuntu-latest
+        steps:
+          - name: Check out the repo
+            uses: actions/checkout@v2
+
+          - name: Run the build process with Docker
+            uses: addnab/docker-run-action@v3
+            with:
+                image: registry.gitlab.steamos.cloud/steamrt/sniper/sdk:latest
+                options: -v ${{ github.workspace }}:/mnt/curl
+                run: |
+                    bash /mnt/curl/ci/_docker_script.sh
+
+          - name: Zip packages
+            run: |
+              pwd
+              ls -la
+              mkdir build
+              cd build
+              mkdir scripting/include -p
+              mkdir extensions
+              mkdir plugins
+              cp ../Release/curl.ext.so extensions/ -v
+              7za a -r build/sm-neocurl.zip scripting/ plugins/ extensions/
+              ls -la
+              pwd
+
+          - name: Set Commit Hash
+            id: commit_info
+            run: echo "::set-output name=sha_short::$(git rev-parse --short HEAD)"
+
+          - name: Create Release
+            id: create_release
+            uses: actions/create-release@v1
+            env:
+              GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+            with:
+              tag_name: ${{ github.ref }}
+              release_name: ${{ github.ref }}
+              draft: false
+              prerelease: false
+
+          - name: Upload Release Asset
+            id: upload-release-asset
+            uses: actions/upload-release-asset@v1
+            env:
+              GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+            with:
+              upload_url: ${{ steps.create_release.outputs.upload_url }} # This pulls from the CREATE RELEASE step above, referencing it's ID to get its outputs object, which include a `upload_url`. See this blog post for more info: https://jasonet.co/posts/new-features-of-github-actions/#passing-data-to-future-steps
+              asset_path: ./build/stac.zip
+              asset_name: stac.zip
+              asset_content_type: application/zip
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..692abaa
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,6 @@
+.vs
+sm-*
+mm-*
+test*
+Release/
+Debug/
diff --git a/Release/curl.ext.so b/Release/curl.ext.so
deleted file mode 100644
index d9a6f47..0000000
--- a/Release/curl.ext.so
+++ /dev/null
diff --git a/scripting/curl_self_test.sp b/scripting/curl_self_test.sp
new file mode 100644
index 0000000..cf7bb43
--- /dev/null
+++ b/scripting/curl_self_test.sp
@@ -0,0 +1,801 @@
+/**
+ * vim: set ts=4 :
+ * =============================================================================
+ * cURL Self Test
+ * 
+ * =============================================================================
+ *
+ * This program is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License, version 3.0, as published by the
+ * Free Software Foundation.
+ * 
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * As a special exception, AlliedModders LLC gives you permission to link the
+ * code of this program (as well as its derivative works) to "Half-Life 2," the
+ * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software
+ * by the Valve Corporation.  You must obey the GNU General Public License in
+ * all respects for all other code used.  Additionally, AlliedModders LLC grants
+ * this exception to all derivative works.  AlliedModders LLC defines further
+ * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),
+ * or <http://www.sourcemod.net/license.php>.
+ *
+ * Version: $Id$
+ */
+
+
+/*
+Usage:
+curl_self_test
+curl_hash_test
+
+All output test files in addons/sourcemod/data/curl_test
+Test #1 Get cURL version & supported protocols
+Test #2 Get a web page
+Test #3 Get ca-bundle.crt for #4
+Test #4 Verify a https website using ca-bundle.crt
+Test #5 Get a web page body & header content to file
+Test #6 Download a image for #7
+Test #7 Upload image using curl_httppost() & get the uploaded image url
+Test #8 Download a file using ftps://
+
+*/
+
+#pragma semicolon 1
+#include <sourcemod>
+#include <regex>
+#include <cURL>
+
+public Plugin:myinfo = 
+{
+	name = "cURL self test",
+	author = "Raydan",
+	description = "cURL self test",
+	version = "1.1.0.0",
+	url = "http://www.ZombieX2.net/"
+};
+
+
+#define USE_THREAD				1
+#define TEST_FOLDER				"data/curl_test"
+
+#define TOTAL_TEST_CASE			8
+
+#define TEST_3_CERT_URL			"http://curl.haxx.se/ca/cacert.pem"
+#define TEST_3_CERT_FILE		"ca-bundle.crt"
+
+#define TEST_4_VERIFY_SITE		"https://encrypted.google.com/search?q=sourcemod"
+
+#define TEST_6_UPLOAD_FILE		"test_6_for_upload.png"
+#define TEST_6_IMAGE_URL		"http://www.google.com/images/logos/ps_logo2.png"
+
+#define TEST_6_UPLOAD_URL		"http://www.image-upload.net/upload.php"
+#define TEST_7_OUT_FILE			"test_7_output.html"
+#define TEST_7_REGEX			" ?<a href=\"http://www.image-upload.net/viewer.php\\?file=([a-zA-Z0-9.]+)\">"
+#define TEST_7_TARGET_URL		"http://www.image-upload.net/images"
+
+/* http://www.secureftp-test.com/ */
+#define TEST_8_FTPS_USERPW		"test:test"
+#define TEST_8_FTPS_URL			"ftps://ftp.secureftp-test.com:990/bookstore.xml"
+#define TEST_8_FILE				"test_8_bookstore.xml"
+
+
+
+new CURL_Default_opt[][2] = {
+#if USE_THREAD
+	{_:CURLOPT_NOSIGNAL,1},
+#endif
+	{_:CURLOPT_NOPROGRESS,1},
+	{_:CURLOPT_TIMEOUT,30},
+	{_:CURLOPT_CONNECTTIMEOUT,60},
+	{_:CURLOPT_VERBOSE,0}
+};
+
+#define CURL_DEFAULT_OPT(%1) curl_easy_setopt_int_array(%1, CURL_Default_opt, sizeof(CURL_Default_opt))
+
+#define TESTCASE_CLOSEHANDLE(%1) if(%1 != INVALID_HANDLE) { CloseHandle(%1); %1 = INVALID_HANDLE; }
+
+new bool:g_test_running = false;
+new g_testcase_runned;
+
+
+new String:curl_test_path[512];
+
+
+
+/* static data */
+static String:test_md5[][] = {
+	"",
+	"a",
+	"abc",
+	"message digest",
+	"abcdefghijklmnopqrstuvwxyz",
+	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
+	"12345678901234567890123456789012345678901234567890123456789012345678901234567890"
+};
+
+static String:ret_md5[][] = {
+	"d41d8cd98f00b204e9800998ecf8427e",
+	"0cc175b9c0f1b6a831c399e269772661",
+	"900150983cd24fb0d6963f7d28e17f72",
+	"f96b697d7cb7938d525a2f31aaf161d0",
+	"c3fcd3d76192e4007dfb496cca67e13b",
+	"d174ab98d277d9f5a5611c2c9f419d9f",
+	"57edf4a22be3c955ac49da2e2107b67a"
+};
+	
+static String:test_md4[][] = {
+	"",
+	"a",
+	"abc",
+	"message digest",
+	"abcdefghijklmnopqrstuvwxyz",
+	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
+	"12345678901234567890123456789012345678901234567890123456789012345678901234567890"
+};
+
+static String:ret_md4[][] = {
+	"31d6cfe0d16ae931b73c59d7e0c089c0",
+	"bde52cb31de33e46245e05fbdbd6fb24",
+	"a448017aaf21d8525fc10ae87aa6729d",
+	"d9130a8164549fe818874806e1c7014b",
+	"d79e1c308aa5bbcdeea8ed63df412da9",
+	"043f8582f241db351ce627e153e7f0e4",
+	"e33b4ddc9c38f2199c3e7b164fcc0536"
+};
+
+static String:test_md2[][] = {
+	"",
+	"a",
+	"abc",
+	"message digest",
+	"abcdefghijklmnopqrstuvwxyz",
+	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
+	"12345678901234567890123456789012345678901234567890123456789012345678901234567890"
+};
+
+static String:ret_md2[][] = {
+	"8350e5a3e24c153df2275c9f80692773",
+	"32ec01ec4a6dac72c0ab96fb34c0b5d1",
+	"da853b0d3f88d99b30283a69e6ded6bb",
+	"ab4f496bfb2a530b219ff33031fe06b0",
+	"4e8ddff3650292ab5a4108c3aa47940b",
+	"da33def2a42df13975352846c30338cd",
+	"d5976f79d83d3a0dc9806c3c66f3efd8"
+};
+
+static String:test_sha[][] = {
+	"abc",
+	"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
+};
+
+static String:ret_sha[][] = {
+	"0164b8a914cd2a5e74c4f7ff082c4d97f1edf880",
+	"d2516ee1acfa5baf33dfc1c471e438449ef134c8"
+};
+
+static String:test_sha1[][] = {
+	"abc",
+	"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
+};
+
+static String:ret_sha1[][] = {
+	"a9993e364706816aba3e25717850c26c9cd0d89d",
+	"84983e441c3bd26ebaae4aa1f95129e5e54670f1"
+};
+
+
+static String:test_sha224_to_512[][] = {
+	"",
+	"a",
+	"abc",
+	"message digest",
+	"abcdefghijklmnopqrstuvwxyz",
+	"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
+	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
+	"12345678901234567890123456789012345678901234567890123456789012345678901234567890"
+};
+
+static String:ret_sha224[][] = {
+	"d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f",
+	"abd37534c7d9a2efb9465de931cd7055ffdb8879563ae98078d6d6d5",
+	"23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7",
+	"2cb21c83ae2f004de7e81c3c7019cbcb65b71ab656b22d6d0c39b8eb",
+	"45a5f72c39c5cff2522eb3429799e49e5f44b356ef926bcf390dccc2",
+	"75388b16512776cc5dba5da1fd890150b0c6455cb4f58b1952522525",
+	"bff72b4fcb7d75e5632900ac5f90d219e05e97a7bde72e740db393d9",
+	"b50aecbe4e9bb0b57bc5f3ae760a8e01db24f203fb3cdcd13148046e"
+};
+
+static String:ret_sha256[][] = {
+	"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+	"ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb",
+	"ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad",
+	"f7846f55cf23e14eebeab5b4e1550cad5b509e3348fbc4efa3a1413d393cb650",
+	"71c480df93d6ae2f1efad1447c66c9525e316218cf51fc8d9ed832f2daf18b73",
+	"248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1",
+	"db4bfcbd4da0cd85a60c3c37d3fbd8805c77f15fc6b1fdfe614ee0a7c8fdb4c0",
+	"f371bc4a311f2b009eef952dd83ca80e2b60026c8e935592d0f9c308453c813e"
+};
+
+static String:ret_sha384[][] = {
+	"38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b",
+	"54a59b9f22b0b80880d8427e548b7c23abd873486e1f035dce9cd697e85175033caa88e6d57bc35efae0b5afd3145f31",
+	"cb00753f45a35e8bb5a03d699ac65007272c32ab0eded1631a8b605a43ff5bed8086072ba1e7cc2358baeca134c825a7",
+	"473ed35167ec1f5d8e550368a3db39be54639f828868e9454c239fc8b52e3c61dbd0d8b4de1390c256dcbb5d5fd99cd5",
+	"feb67349df3db6f5924815d6c3dc133f091809213731fe5c7b5f4999e463479ff2877f5f2936fa63bb43784b12f3ebb4",
+	"3391fdddfc8dc7393707a65b1b4709397cf8b1d162af05abfe8f450de5f36bc6b0455a8520bc4e6f5fe95b1fe3c8452b",
+	"1761336e3f7cbfe51deb137f026f89e01a448e3b1fafa64039c1464ee8732f11a5341a6f41e0c202294736ed64db1a84",
+	"b12932b0627d1c060942f5447764155655bd4da0c9afa6dd9b9ef53129af1b8fb0195996d2de9ca0df9d821ffee67026"
+};
+
+static String:ret_sha512[][] = {
+	"cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e",
+	"1f40fc92da241694750979ee6cf582f2d5d7d28e18335de05abc54d0560e0f5302860c652bf08d560252aa5e74210546f369fbbbce8c12cfc7957b2652fe9a75",
+	"ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f",
+	"107dbf389d9e9f71a3a95f6c055b9251bc5268c2be16d6c13492ea45b0199f3309e16455ab1e96118e8a905d5597b72038ddb372a89826046de66687bb420e7c",
+	"4dbff86cc2ca1bae1e16468a05cb9881c97f1753bce3619034898faa1aabe429955a1bf8ec483d7421fe3c1646613a59ed5441fb0f321389f77f48a879c7b1f1",
+	"204a8fc6dda82f0a0ced7beb8e08a41657c16ef468b228a8279be331a703c33596fd15c13b1b07f9aa1d3bea57789ca031ad85c7a71dd70354ec631238ca3445",
+	"1e07be23c26a86ea37ea810c8ec7809352515a970e9253c26f536cfc7a9996c45c8370583e0a78fa4a90041d71a4ceab7423f19c71b9d5a3e01249f0bebd5894",
+	"72ec1ef1124a45b047e8b7c75a932195135bb61de24ec0d1914042246e0aec3a2354e093d76f3048b456764346900cb130d2a4fd5dd16abb5e30bcb850dee843"
+};
+
+static String:test_ripemd160[][] = {
+	"",
+	"a",
+	"abc",
+	"message digest",
+	"abcdefghijklmnopqrstuvwxyz",
+	"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
+	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
+	"12345678901234567890123456789012345678901234567890123456789012345678901234567890"
+};
+
+static String:ret_ripemd160[][] = {
+	"9c1185a5c5e9fc54612808977ee8f548b2258d31",
+	"0bdc9d2d256b3ee9daae347be6f4dc835a467ffe",
+	"8eb208f7e05d987a9b044a8e98c6b087f15a0bfc",
+	"5d0689ef49d2fae572b881b123a85ffa21595f36",
+	"f71c27109c692c1b56bbdceb5b9d2865b3708dbc",
+	"12a053384a9c0c88e405a06c27dcf49ada62eb2b",
+	"b0e20b6e3116640286ed3a87a5713079b21f5189",
+	"9b752e45573d4b39f4dbd3323cab82bf63326bfb"
+};
+
+
+
+new Handle:test_3_file = INVALID_HANDLE;
+
+new Handle:test_5_file_body = INVALID_HANDLE;
+new Handle:test_5_file_header = INVALID_HANDLE;
+
+new Handle:test_6_file = INVALID_HANDLE;
+
+new Handle:test_7_form = INVALID_HANDLE;
+new Handle:test_7_file = INVALID_HANDLE;
+
+new Handle:test_8_file = INVALID_HANDLE;
+
+
+/* Plugin Start */
+
+public OnPluginStart()
+{
+	PluginInit();
+	
+	RegConsoleCmd("curl_self_test", curl_self_test);
+	RegConsoleCmd("curl_hash_test", curl_hash_test);
+	g_test_running = false;
+}
+
+public PluginInit()
+{
+	g_testcase_runned = 0;
+	BuildPath(Path_SM, curl_test_path, sizeof(curl_test_path), TEST_FOLDER);
+	new Handle:test_folder_handle = OpenDirectory(curl_test_path);
+	if(test_folder_handle == INVALID_HANDLE)
+	{
+		if(!CreateDirectory(curl_test_path, 557))
+		{
+			SetFailState("Unable Create folder %s",TEST_FOLDER);
+			return;
+		}
+	} else {
+		new String:buffer[128];
+		new String:path[512];
+		new FileType:type;
+		while(ReadDirEntry(test_folder_handle, buffer, sizeof(buffer), type))
+		{
+			if(type != FileType_File)
+				continue;
+			
+			BuildPath(Path_SM, path, sizeof(path), "%s/%s", TEST_FOLDER, buffer);
+			DeleteFile(path);
+		}
+		CloseHandle(test_folder_handle);
+	}
+}
+
+
+/* Test Case */
+public Test_1()
+{
+	new current_test = 1;
+	new String:version[256];
+	new String:protocols[256];
+	curl_version(version,sizeof(version));
+	curl_protocols(protocols, sizeof(protocols));
+	PrintTestCaseDebug(current_test,"Get cUrl Version");
+	PrintTestCaseDebug(current_test, "Version: %s",version);
+	PrintTestCaseDebug(current_test, "Protocols: %s",protocols);
+	
+	onComplete(INVALID_HANDLE, CURLE_OK, current_test);
+}
+
+public Test_2()
+{
+	new current_test = 2;
+	PrintTestCaseDebug(current_test,"simple get a remote web page");
+	new Handle:curl = curl_easy_init();
+	if(curl != INVALID_HANDLE)
+	{
+		CURL_DEFAULT_OPT(curl);
+		curl_easy_setopt_string(curl, CURLOPT_URL, "http://www.google.com");
+		ExecCURL(curl,current_test);
+	} else {
+		PrintCreatecUrlError(current_test);
+	}
+}
+
+public Test_3()
+{
+	new current_test = 3;
+	PrintTestCaseDebug(current_test,"download %s for test #4",TEST_3_CERT_URL);
+	new Handle:curl = curl_easy_init();
+	if(curl != INVALID_HANDLE)
+	{
+		test_3_file = CreateTestFile(TEST_3_CERT_FILE, "w");
+		CURL_DEFAULT_OPT(curl);
+		curl_easy_setopt_handle(curl, CURLOPT_WRITEDATA, test_3_file);
+		curl_easy_setopt_string(curl, CURLOPT_URL, TEST_3_CERT_URL);
+		ExecCURL(curl,current_test);
+	} else {
+		PrintCreatecUrlError(current_test);
+	}
+}
+public Test_4()
+{
+	new current_test = 4;
+	PrintTestCaseDebug(current_test,"using #3 cert file to verify %s", TEST_4_VERIFY_SITE);
+	new Handle:curl = curl_easy_init();
+	if(curl != INVALID_HANDLE)
+	{
+		new String:path[512];
+		BuildPath(Path_SM, path, sizeof(path), "%s/%s", TEST_FOLDER, TEST_3_CERT_FILE);
+		CURL_DEFAULT_OPT(curl);
+		curl_easy_setopt_string(curl,CURLOPT_CAINFO, path);
+		curl_easy_setopt_int(curl, CURLOPT_SSL_VERIFYPEER, 1);
+		curl_easy_setopt_int(curl, CURLOPT_SSL_VERIFYHOST, 2);
+		curl_easy_setopt_string(curl, CURLOPT_URL, TEST_4_VERIFY_SITE);
+		ExecCURL(curl, current_test);
+	} else {
+		PrintCreatecUrlError(current_test);
+	}
+}
+
+public Test_5()
+{
+	new current_test = 5;
+	PrintTestCaseDebug(current_test,"download a web page & header");
+	new Handle:curl = curl_easy_init();
+	if(curl != INVALID_HANDLE)
+	{
+		CURL_DEFAULT_OPT(curl);
+		test_5_file_body = CreateTestFile("test5_body.txt", "w");
+		test_5_file_header = CreateTestFile("test5_header.txt", "w");
+		curl_easy_setopt_handle(curl, CURLOPT_WRITEDATA, test_5_file_body);
+		curl_easy_setopt_handle(curl, CURLOPT_HEADERDATA, test_5_file_header);
+		curl_easy_setopt_string(curl, CURLOPT_URL, "http://www.google.co.uk/index.html");
+		ExecCURL(curl,current_test);
+	} else {
+		PrintCreatecUrlError(current_test);
+	}
+}
+
+public Test_6()
+{
+	new current_test = 6;
+	PrintTestCaseDebug(current_test,"download google logo for test #7");
+	new Handle:curl = curl_easy_init();
+	if(curl != INVALID_HANDLE)
+	{
+		CURL_DEFAULT_OPT(curl);
+		test_6_file = CreateTestFile(TEST_6_UPLOAD_FILE, "wb");
+		curl_easy_setopt_handle(curl, CURLOPT_WRITEDATA, test_6_file);
+		curl_easy_setopt_string(curl, CURLOPT_URL, TEST_6_IMAGE_URL);
+		ExecCURL(curl, current_test);
+	} else {
+		PrintCreatecUrlError(current_test);
+	}
+}
+
+
+public Test_7()
+{
+	new current_test = 7;
+	PrintTestCaseDebug(current_test,"upload test #6 image to image-upload.net");
+	new Handle:curl = curl_easy_init();
+	if(curl != INVALID_HANDLE)
+	{
+		CURL_DEFAULT_OPT(curl);
+		new String:path[512];
+		BuildPath(Path_SM, path, sizeof(path), "%s/%s", TEST_FOLDER, TEST_6_UPLOAD_FILE);
+		test_7_form = curl_httppost();
+		curl_formadd(test_7_form, CURLFORM_COPYNAME, "userfile[]", CURLFORM_FILE, path, CURLFORM_END);
+		curl_formadd(test_7_form, CURLFORM_COPYNAME, "private_upload", CURLFORM_COPYCONTENTS, "0", CURLFORM_END);
+		curl_easy_setopt_handle(curl, CURLOPT_HTTPPOST, test_7_form);
+		
+		test_7_file = CreateTestFile(TEST_7_OUT_FILE, "w");
+		curl_easy_setopt_handle(curl, CURLOPT_WRITEDATA, test_7_file);
+		curl_easy_setopt_string(curl, CURLOPT_URL, TEST_6_UPLOAD_URL);
+
+		ExecCURL(curl, current_test);
+	} else {
+		PrintCreatecUrlError(current_test);
+	}
+}
+
+
+public Test_8()
+{
+	new current_test = 8;
+	PrintTestCaseDebug(current_test,"sftp test - %s",TEST_8_FTPS_URL);
+	new Handle:curl = curl_easy_init();
+	if(curl != INVALID_HANDLE)
+	{
+		CURL_DEFAULT_OPT(curl);
+		test_8_file = CreateTestFile(TEST_8_FILE, "w");
+		curl_easy_setopt_handle(curl, CURLOPT_WRITEDATA, test_8_file);
+		curl_easy_setopt_int(curl, CURLOPT_SSL_VERIFYPEER, 0);
+		curl_easy_setopt_int(curl, CURLOPT_SSL_VERIFYHOST, 2);
+		curl_easy_setopt_string(curl, CURLOPT_USERPWD, TEST_8_FTPS_USERPW);
+		curl_easy_setopt_string(curl, CURLOPT_URL, TEST_8_FTPS_URL);
+		ExecCURL(curl, current_test);
+	} else {
+		PrintCreatecUrlError(current_test);
+	}
+}
+
+public onComplete(Handle:hndl, CURLcode: code, any:data)
+{
+	new current_test = data;
+	if(hndl != INVALID_HANDLE && code != CURLE_OK)
+	{
+		new String:error_buffer[256];
+		curl_easy_strerror(code, error_buffer, sizeof(error_buffer));
+		PrintTestCaseDebug(current_test, "FAIL - %s", error_buffer);
+		CloseHandle(hndl);
+		g_test_running = false;
+		return;
+	}
+	
+	PrintTestCaseDebug(current_test, "*Passed*");
+	
+	TestCaseEndPreClose(current_test);
+	
+	TESTCASE_CLOSEHANDLE(hndl)
+
+	TestCaseEndPostClose(current_test);
+	
+	g_testcase_runned++;
+	
+	if(g_testcase_runned == TOTAL_TEST_CASE)
+	{
+		PrintTestMessage("YA! Passed All Test~");
+		g_test_running = false;
+	}
+	
+	#if !USE_THREAD
+	switch(g_testcase_runned)
+	{
+		case 1: Test_2();
+		case 2: Test_3();
+			//case 4: Test_4();
+		case 4: Test_5();
+		case 5: Test_6();
+			//case 7: Test_7();
+		case 7: Test_8();
+	}
+	#endif
+}
+
+public Action:curl_self_test(client, args)
+{
+	if(g_test_running)
+	{
+		PrintTestMessage("cURL Test is running, Please wait...");
+		return Plugin_Handled;
+	}
+	
+	g_test_running = true;
+	g_testcase_runned = 0;
+	
+#if USE_THREAD
+	Test_1();
+	Test_2();
+	Test_3();
+		//Test_4();
+	Test_5();
+	Test_6();
+		//Test_7();
+	Test_8();
+#else
+	Test_1();
+#endif
+	
+	return Plugin_Handled;
+}
+
+stock ExecCURL(Handle:curl, current_test)
+{
+#if USE_THREAD
+	curl_easy_perform_thread(curl, onComplete, current_test);
+#else
+	new CURLcode:code = curl_load_opt(curl);
+	if(code != CURLE_OK) {
+		PrintTestCaseDebug(current_test, "curl_load_opt Error");
+		PrintcUrlError(code);
+		CloseHandle(curl);
+		return;
+	}
+	
+	code = curl_easy_perform(curl);
+	
+	onComplete(curl, code, current_test);
+
+#endif
+}
+
+public TestCaseEndPreClose(current_test)
+{
+
+}
+
+public TestCaseEndPostClose(current_test)
+{
+	switch(current_test)
+	{
+		case 3:
+		{
+			TESTCASE_CLOSEHANDLE(test_3_file)
+			Test_4();
+		}
+		case 5:
+		{
+			TESTCASE_CLOSEHANDLE(test_5_file_body)
+			TESTCASE_CLOSEHANDLE(test_5_file_header)
+		}
+		case 6:
+		{
+			TESTCASE_CLOSEHANDLE(test_6_file)
+			Test_7();
+		}
+		case 7:
+		{
+			TESTCASE_CLOSEHANDLE(test_7_form)
+			TESTCASE_CLOSEHANDLE(test_7_file)
+			Test_7_Action();
+		}
+		case 8:
+		{
+			TESTCASE_CLOSEHANDLE(test_8_file)
+		}
+	}
+}
+
+public Test_7_Action()
+{
+	new Handle:regex = CompileRegex(TEST_7_REGEX);
+	if(regex == INVALID_HANDLE)
+	{
+		PrintTestCaseDebug(7, "WARNING - unable create regex");
+		return;
+	}
+	new String:file_path[512];
+	Format(file_path, sizeof(file_path),"%s/%s",curl_test_path, TEST_7_OUT_FILE);
+	new Handle:file = OpenFile(file_path,"r");
+	if(file == INVALID_HANDLE)
+	{
+		CloseHandle(regex);
+		PrintTestCaseDebug(7, "WARNING - %s not found",TEST_7_OUT_FILE);
+		return;
+	}
+	
+	new bool:found = false;
+	new String:buffer[1024];
+	while(ReadFileLine(file, buffer, sizeof(buffer)))
+	{
+		new RegexError:ret;
+		new pos = MatchRegex(regex, buffer, ret);
+		if(ret == REGEX_ERROR_NONE && pos == 2)
+		{
+			new String:the_image[64];
+			GetRegexSubString(regex, 1, the_image, sizeof(the_image));
+			PrintTestCaseDebug(7, "Uploaded image - %s/%s", TEST_7_TARGET_URL,the_image);
+			found = true;
+			break;
+		}
+	}
+	
+	if(!found)
+	{
+		PrintTestCaseDebug(7, "WARNING - upload may be fail...");
+	}
+	
+	CloseHandle(regex);
+	CloseHandle(file);
+}
+
+
+public Action:curl_hash_test(client, args)
+{
+	for(new i=0;i<sizeof(test_md5);i++)
+	{
+		if(!CheckHash(test_md5[i],Openssl_Hash_MD5,ret_md5[i]))
+			return Plugin_Handled;
+		PrintHashTestDebug("md5 #%d Pass",i+1);
+	}
+	
+	for(new i=0;i<sizeof(test_md4);i++)
+	{
+		if(!CheckHash(test_md4[i],Openssl_Hash_MD4,ret_md4[i]))
+			return Plugin_Handled;
+		PrintHashTestDebug("md4 #%d Pass",i+1);
+	}
+	
+	for(new i=0;i<sizeof(test_md2);i++)
+	{
+		if(!CheckHash(test_md2[i],Openssl_Hash_MD2,ret_md2[i]))
+			return Plugin_Handled;
+		PrintHashTestDebug("md2 #%d Pass",i+1);
+	}
+	
+	for(new i=0;i<sizeof(test_sha);i++)
+	{
+		if(!CheckHash(test_sha[i],Openssl_Hash_SHA,ret_sha[i]))
+			return Plugin_Handled;
+		PrintHashTestDebug("sha #%d Pass",i+1);
+	}
+	
+	for(new i=0;i<sizeof(test_sha1);i++)
+	{
+		if(!CheckHash(test_sha1[i],Openssl_Hash_SHA1,ret_sha1[i]))
+			return Plugin_Handled;
+		PrintHashTestDebug("sha1 #%d Pass",i+1);
+	}
+	
+	for(new i=0;i<sizeof(test_sha224_to_512);i++)
+	{
+		if(!CheckHash(test_sha224_to_512[i],Openssl_Hash_SHA224,ret_sha224[i]))
+			return Plugin_Handled;
+		PrintHashTestDebug("sha224 #%d Pass",i+1);
+	}
+	
+	for(new i=0;i<sizeof(test_sha224_to_512);i++)
+	{
+		if(!CheckHash(test_sha224_to_512[i],Openssl_Hash_SHA256,ret_sha256[i]))
+			return Plugin_Handled;
+		PrintHashTestDebug("sha256 #%d Pass",i+1);
+	}
+	
+	for(new i=0;i<sizeof(test_sha224_to_512);i++)
+	{
+		if(!CheckHash(test_sha224_to_512[i],Openssl_Hash_SHA384,ret_sha384[i]))
+			return Plugin_Handled;
+		PrintHashTestDebug("sha384 #%d Pass",i+1);
+	}
+	
+	for(new i=0;i<sizeof(test_sha224_to_512);i++)
+	{
+		if(!CheckHash(test_sha224_to_512[i],Openssl_Hash_SHA512,ret_sha512[i]))
+			return Plugin_Handled;
+		PrintHashTestDebug("sha512 #%d Pass",i+1);
+	}
+	
+	for(new i=0;i<sizeof(test_ripemd160);i++)
+	{
+		if(!CheckHash(test_ripemd160[i],Openssl_Hash_RIPEMD160,ret_ripemd160[i]))
+			return Plugin_Handled;
+		PrintHashTestDebug("ripemd160 #%d Pass",i+1);
+	}
+	
+	PrintHashTestDebug("Try hash bin/server.dll");
+	curl_hash_file("bin/server.dll",Openssl_Hash_MD5, hash_complete_callback);
+	
+	return Plugin_Handled;
+}
+
+public hash_complete_callback(const bool:success, const String:buffer[])
+{
+	if(!success)
+	{
+		PrintHashTestDebug("Hash Fail: ubale hash server.dll");
+		return;
+	}
+	PrintHashTestDebug("server.dll MD5: %s",buffer);
+	PrintHashTestDebug("All Hash Test Pass!!");
+}
+
+public bool:CheckHash(const String:data[], Openssl_Hash:type, const String:ret[])
+{
+	static String:hash_type[][16] = {
+		"md5",
+		"md4",
+		"md2",
+		"sha",
+		"sha1",
+		"sha224",
+		"sha256",
+		"sha384",
+		"sha512",
+		"ripemd160"
+	};
+	new String:buffer[256];
+	curl_hash_string(data,strlen(data), type, buffer, sizeof(buffer));
+	
+	if(strcmp(buffer, ret, false) != 0)
+	{
+		PrintHashTestDebug("Hash FAIL: %s : %s",hash_type[type], data);
+		return false;
+	}
+	return true;
+}
+
+
+public Handle:CreateTestFile(const String:path[], const String:mode[])
+{
+	new String:file_path[512];
+	Format(file_path, sizeof(file_path),"%s/%s",curl_test_path, path);
+	return curl_OpenFile(file_path, mode);
+}
+
+stock PrintCreatecUrlError(index)
+{
+	PrintToServer("[CURL Test #%d] curl_easy_init Fail",index);
+	g_test_running = false;
+}
+
+stock PrintTestCaseDebug(index, const String:format[], any:...)
+{
+	decl String:buffer[256];
+	VFormat(buffer, sizeof(buffer), format, 3);
+	PrintToServer("[CURL Test #%d] %s",index, buffer);
+}
+
+stock PrintTestMessage(const String:format[], any:...)
+{
+	decl String:buffer[256];
+	VFormat(buffer, sizeof(buffer), format, 2);
+	PrintToServer("[CURL Test] %s", buffer);
+}
+
+stock PrintcUrlError(CURLcode: code)
+{
+	new String:buffer[512];
+	curl_easy_strerror(code, buffer, sizeof(buffer));
+	PrintToServer("[CURL Test ERROR] %s",buffer);
+}
+
+
+stock PrintHashTestDebug(const String:format[], any:...)
+{
+	decl String:buffer[256];
+	VFormat(buffer, sizeof(buffer), format, 2);
+	PrintToServer("[CURL Hash Test] %s", buffer);
+}
diff --git a/scripting/include/cURL.inc b/scripting/include/cURL.inc
new file mode 100644
index 0000000..1d79093
--- /dev/null
+++ b/scripting/include/cURL.inc
@@ -0,0 +1,565 @@
+
+#if defined _cURL_included
+  #endinput
+#endif
+#define _cURL_included
+
+#include <cURL_header>
+
+
+/*
+========================================
+The Following CURLOPT_* NOT support 
+ERRORBUFFER              // use curl_get_error_buffer
+WRITEINFO                // ???
+PROGRESSFUNCTION         // unused
+PROGRESSDATA             // same
+HEADERFUNCTION           // unused
+DEBUGFUNCTION            // unused
+DEBUGDATA                // same
+SHARE                    // unsupport
+PRIVATE                  // unsupport
+SSL_CTX_FUNC             // unused
+SSL_CTX_DATA             // same
+IOCTLFUNCTION            // unused
+IOCTLDATA                // same
+CONV_FROM_NETWORK_FUNC   // unused
+CONV_TO_NETWORK_FUNC     // unused
+CONV_FROM_UTF8_FUNC      // unused
+SOCKOPTFUNCTION          // unused
+SOCKOPTDATA              // unused
+OPENSOCKETFUNCTION       // used
+OPENSOCKETDATA           // used
+COPYPOSTFIELDS           // unsupport
+SEEKFUNCTION             // unused
+SEEKDATA                 // unused
+SOCKS5_GSSAPI_SERVICE    // unsupport
+SOCKS5_GSSAPI_NEC        // unsupport
+SSH_KEYFUNCTION          // unsupport
+SSH_KEYDATA              // unsupport
+INTERLEAVEFUNCTION       // unsupport
+CHUNK_BGN_FUNC           // unsupport
+CHUNK_END_FUNC           // unsupport
+FNMATCH_FUNC             // unsupport
+CHUNK_DATA               // unsupport
+FNMATCH_DATA             // unsupport
+TLSAUTH_USERNAME         // unsupport, require tls-srp
+TLSAUTH_PASSWORD         // unsupport, require tls-srp
+TLSAUTH_TYPE             // unsupport, require tls-srp
+CLOSESOCKETFUNCTION      // unsupport
+CLOSESOCKETDATA          // unsupport
+========================================*/
+
+/*
+========================================
+The Following CURLOPT_* supports the "file //" notation.
+COOKIEFILE
+COOKIEJAR
+RANDOM_FILE
+EGDSOCKET
+SSLKEY
+CAPATH
+NETRC_FILE
+SSH_PUBLIC_KEYFILE
+SSH_PRIVATE_KEYFILE
+_CRLFILE
+ISSUERCERT
+SSH_KNOWNHOSTS
+
+========================================*/
+
+/*
+========================================
+The Following CURLINFO_* NOT support 
+CURLINFO_SLIST
+
+========================================*/
+
+/*
+========================================
+The Following CURLFORM_* NOT support 
+CURLFORM_PTRNAME
+CURLFORM_PTRCONTENTS
+CURLFORM_ARRAY
+CURLFORM_BUFFER
+CURLFORM_BUFFERPTR
+CURLFORM_BUFFERLENGTH
+CURLFORM_STREAM
+
+========================================*/
+
+
+
+
+/*************************************************************************************************/
+/******************************************** OPTIONS ********************************************/
+/*************************************************************************************************/
+
+
+/**
+ * The Send & Receive Action
+ * Using on CURL_OnSend, CURL_OnReceive
+ * SendRecv_Act_GOTO_SEND = go to send
+ * SendRecv_Act_GOTO_RECV = go to receive
+ * SendRecv_Act_GOTO_WAIT = go to wait
+ * SendRecv_Act_GOTO_END = end the connection
+ * SendRecv_Act_GOTO_SEND_NO_WAIT = go to send but no select
+ * SendRecv_Act_GOTO_RECV_NO_WAIT = go to receive but no select
+ * To see how it work? see curl_echo_test.sp & curl_rcon_test.sp examples
+ */
+enum SendRecv_Act {
+	SendRecv_Act_NOTHING = 0,
+
+	SendRecv_Act_GOTO_SEND,
+	SendRecv_Act_GOTO_RECV,
+	SendRecv_Act_GOTO_WAIT,
+	SendRecv_Act_GOTO_END,
+	SendRecv_Act_GOTO_SEND_NO_WAIT,
+	SendRecv_Act_GOTO_RECV_NO_WAIT,
+
+	SendRecv_Act_LAST,
+};
+
+/**
+ * Hash type for curl_hash_file, curl_hash_string
+ */
+enum Openssl_Hash {
+	Openssl_Hash_MD5 = 0,
+	Openssl_Hash_MD4,
+	Openssl_Hash_MD2,
+	Openssl_Hash_SHA,
+	Openssl_Hash_SHA1,
+	Openssl_Hash_SHA224,
+	Openssl_Hash_SHA256,
+	Openssl_Hash_SHA384,
+	Openssl_Hash_SHA512,
+	Openssl_Hash_RIPEMD160,
+};
+
+
+/*************************************************************************************************/
+/******************************************* CALLBACKS *******************************************/
+/*************************************************************************************************/
+
+
+/**
+ * called if curl_easy_perform_thread() or curl_easy_send_recv() Complete
+ * @ param Handle	hndl		The curl handle
+ * @ param CURLcode	code		The CURLcode code, see cURL_header.inc
+ * @ param any		data		Data passed to curl_easy_perform_thread()
+ * @ noreturn
+ */
+typeset CURL_OnComplete
+{
+	function void (Handle hndl, CURLcode code);
+	function void (Handle hndl, CURLcode code , any data);
+};
+
+/**
+ * called if curl_easy_send_recv() before sending data
+ * @ param Handle	hndl				The curl handle
+ * @ param CURLcode	code				The last CURLcode code, see cURL_header.inc
+ * @ param cell_t	last_sent_dataSize	The last sent datasize
+ * @ param any		data				Data passed to curl_easy_send_recv()
+ * @ return 								SendRecv_Act
+ */
+typeset CURL_OnSend
+{
+	function SendRecv_Act (Handle hndl, CURLcode code, const int last_sent_dataSize);
+	function SendRecv_Act (Handle hndl, CURLcode code, const int last_sent_dataSize, any data);
+}
+
+/**
+ * called if curl_easy_send_recv() after received data
+ * @ param Handle	hndl		The curl handle
+ * @ param CURLcode	code		The CURLcode code, see cURL_header.inc
+ * @ param String	dataSize	The received datasize
+ * @ param any		data		Data passed to curl_easy_send_recv()
+ * @ return 						SendRecv_Act
+ */
+typeset CURL_OnReceive
+{
+	function SendRecv_Act (Handle hndl, CURLcode code, const char[] receiveData, const int dataSize);
+	function SendRecv_Act (Handle hndl, CURLcode code, const char[] receiveData, const int dataSize, any data);
+}
+
+/**
+ * called if Openssl_Hash_file() after hashed the file
+ * @ param bool		success		True on success, false if hash file fail
+ * @ param String	buffer		The hash string
+ * @ param any		data		Data passed to Openssl_Hash_file()
+ * @ noreturn
+ */
+typeset Openssl_Hash_Complete
+{
+	function void (const bool success, const char[] buffer);
+	function void (const bool success, const char[] buffer, any data);
+}
+
+
+typeset CURL_Function_CB
+{
+	// CURLOPT_WRITEFUNCTION
+	function void (Handle hndl, const char[] buffer, const int bytes, const int nmemb);
+	function void (Handle hndl, const char[] buffer, const int bytes, const int nmemb, any data);
+	
+	// CURLOPT_READFUNCTION
+	function void (Handle hndl, const int bytes, const int nmemb);
+	function void (Handle hndl, const int bytes, const int nmemb, any data);
+}
+
+/*************************************************************************************************/
+/******************************************** NATIVES ********************************************/
+/*************************************************************************************************/
+
+
+/**
+ * Create a curl handle
+ * @ return Handle				The curl handle. Returns INVALID_HANDLE on failure
+ */
+native Handle curl_easy_init();
+
+/**
+ * Set a curl option for CURLOPTTYPE_OBJECTPOINT type
+ *
+ * @ param Handle		hndl	The handle of the curl to be used. May be INVALID_HANDLE if not essential.
+ * @ param CURLoption	opt		The option to add (see enum CURLoption for details).
+ * @ param String		buffer	The value to set the option to.
+ * @ return bool				1 on success. 0 = The option not accept string or unsupport.
+ */
+native bool curl_easy_setopt_string(Handle hndl, CURLoption opt, const char[] buffer);
+
+/**
+ * Set a curl option for CURLOPTTYPE_LONG type
+ *
+ * @ param Handle		hndl	The handle of the curl to be used. May be INVALID_HANDLE if not essential.
+ * @ param CURLoption	opt		The option to add (see enum CURLoption for details).
+ * @ param cell_t		value	The value to set the option to.
+ * @ return bool				1 on success. 0 = The option not accept integer or unsupport.
+ */
+native bool curl_easy_setopt_int(Handle hndl, CURLoption opt, int value);
+
+/**
+ * Set a curl option for CURLOPTTYPE_LONG type
+ * @ example"
+	new opt[][2] = {
+		{_ CURLOPT_NOPROGRESS,1},
+		{_ CURLOPT_VERBOSE,0}
+	};
+ *
+ * @ param Handle		hndl		The handle of the curl to be used. May be INVALID_HANDLE if not essential.
+ * @ param cell_t		array		The option array to add (see enum CURLoption for details).
+ * @ param cell_t		array_size	The array size.
+ * @ return bool					1 on success. 0 = The option not accept integer or unsupport.
+ */
+native bool curl_easy_setopt_int_array(Handle hndl, int[][] array, int array_size); // int array[][2]
+
+/**
+ * Set a curl option for CURLOPTTYPE_OFF_T type
+ *
+ * @ param Handle		hndl	The handle of the curl to be used. May be INVALID_HANDLE if not essential.
+ * @ param CURLoption	opt		The option to add (see enum CURLoption for details).
+ * @ param String		buffer	The value to set the option to.
+ * @ return bool				1 on success. 0 = The option not accept string or unsupport.
+ */
+native bool curl_easy_setopt_int64(Handle hndl, CURLoption opt, const char buffer);
+
+/**
+ * Set a curl option for CURLOPTTYPE_OBJECTPOINT type
+ * @ note only accept the following handle type
+ 	curl_OpenFile()
+ 	curl_httppost()
+ 	curl_slist()
+ *
+ * @ param Handle		hndl		The handle of the curl to be used. May be INVALID_HANDLE if not essential.
+ * @ param CURLoption	opt			The option to add (see enum CURLoption for details).
+ * @ param Handle		other_hndl	The other handle to set the option to.
+ * @ return bool					1 on success. 0 = The option not accept string or unsupport.
+ */
+native bool curl_easy_setopt_handle(Handle hndl, CURLoption opt, Handle other_hndl);
+
+/**
+ * Set a curl option for CURLOPTTYPE_FUNCTIONPOINT type
+ *
+ * @ param Handle				hndl		The handle of the curl to be used. May be INVALID_HANDLE if not essential.
+ * @ param CURLoption			opt			The option to add (see enum CURLoption for details).
+ * @ param CURL_Function_CB		callback	The value to set the option to.
+ * @ param cell_t				value		Value to set.
+ * @ return bool							1 on success. 0 = The option unsupport or invalid callback function.
+ */
+native bool curl_easy_setopt_function(Handle hndl, CURLoption opt, CURL_Function_CB callback, any value=0);
+
+/**
+ * Load all CURLoption to curl Handle
+ * @ note
+ * 		Using curl_easy_perform_thread() will load option in thread
+ * 		Use this on curl_easy_perform or check all CURLoption are valid or not
+ * 		Only can use one time for each curl handle
+ * @ return 		The CURLcode code, see cURL_header.inc
+ */
+native CURLcode curl_load_opt(Handle hndl);
+
+/**
+ * Perform a file transfer
+ * @ return 		The CURLcode code, see cURL_header.inc
+ */
+native CURLcode curl_easy_perform(Handle hndl);
+
+/**
+ * Perform a file transfer, using thread
+ * @ param Handle			hndl				The handle of the curl to be used. May be INVALID_HANDLE if not essential.
+ * @ param CURL_OnComplete	perform_callback	The complete callback.
+ * @ param cell_t			value				Value to set.
+ * @ noreturn
+ */
+native void curl_easy_perform_thread(Handle hndl, CURL_OnComplete perform_callback, any value=0);
+
+/**
+ * Create a send & receive function for a connected curl handle
+ * @ param Handle			hndl				The handle of the curl to be used.
+ * @ param CURL_OnSend		send_callback		The send callback.
+ * @ param CURL_OnReceive	receive_callback	The receive callback.
+ * @ param CURL_OnComplete	complete_callback	The complete callback.
+ * @ param SendRecv_Act		act 				The first SendRecv_Act action
+ * @ param cell_t			send_timeout 		Send timeout value in milliseconds.
+ * @ param cell_t			recv_timeout 		Receive timeout value in milliseconds.
+ * @ param cenn_t			recv_buffer_Size	Receive buffer size.
+ * @ param cell_t			value				Value to set.
+ * @ noreturn
+ */
+native void curl_easy_send_recv(Handle hndl, CURL_OnSend send_callback, CURL_OnReceive receive_callback, CURL_OnComplete complete_callback, SendRecv_Act act, int send_timeout, int recv_timeout, int recv_buffer_Size = 1024, any value=0);
+
+/**
+ * Send a signal to a send & receive curl handle 
+ * @ param Handle			hndl			The handle of the send & receive curl to be used.
+ * @ param SendRecv_Act		act				The SendRecv_Act action after the singal
+ * @ return bool							1 on success. 0 = not a curl_easy_send_recv() curl, or not running/waiting
+ */
+native bool curl_send_recv_Signal(Handle hndl, SendRecv_Act act);
+
+/**
+ * Check send & receive curl handle is Waiting or not
+ * @ param Handle			hndl			The handle of the send & receive curl to be used.
+ * @ return bool		1 = is waiting. 0 = not a curl_easy_send_recv() curl, or not running/waiting
+ */
+native bool curl_send_recv_IsWaiting(Handle hndl);
+
+/**
+ * Send the send buffer for send & receive curl handle
+ * @ param Handle			hndl			The handle of the send & receive curl to be used.
+ * @ param cell_t			data			The data to send
+ * @ param cell_t			size			if specified the \0 terminator will not be included
+ * @ noreturn
+ */
+native void curl_set_send_buffer(Handle hndl, const char[] data, int size=-1);
+
+/**
+ * Send the receive data size for send & receive curl handle
+ * @ param Handle			hndl			The handle of the send & receive curl to be used.
+ * @ param cell_t			size			The receive size
+ * @ noreturn
+ */
+native void curl_set_receive_size(Handle hndl, int size);
+
+/**
+ * Set send timeout for curl_easy_send_recv()
+ * @ param Handle			hndl			The handle of the send & receive curl to be used.
+ * @ param cell_t			timeout			How long will try to send data before it timeout (milliseconds).
+ * @ noreturn
+ */
+native void curl_set_send_timeout(Handle hndl, int timeout);
+
+/**
+ * Set receive timeout for curl_easy_send_recv()
+ * @ param Handle			hndl			The handle of the send & receive curl to be used.
+ * @ param cell_t			timeout			How long will try to receive data before it timeout (milliseconds).
+ * @ noreturn
+ */
+native void curl_set_recv_timeout(Handle hndl, int timeout);
+
+/**
+ * Get CURLOPT_ERRORBUFFER error string in curl handle
+ * @ param Handle		hndl		The handle of the curl to be used.
+ * @ param String		buffer		Destination string buffer to copy to.
+ * @ param cell_t		maxlen		Destination buffer length (includes null terminator).
+ * @ noreturn
+ */
+native void curl_get_error_buffer(Handle hndl, char[] buffer, int maxlen);
+
+/**
+ * Extract information from a curl handle. (CURLINFO_STRING only)
+ * @ param Handle		hndl		The handle of the curl to be used.
+ * @ param CURLINFO		info		The enum CURLINFO, see cURL_header.inc
+ * @ param String		buffer		Destination string buffer to copy to.
+ * @ param cell_t		maxlen		Destination buffer length (includes null terminator).
+ * @ return 						The CURLcode code, see cURL_header.inc
+ */
+native CURLcode curl_easy_getinfo_string(Handle hndl, CURLINFO info, char[] buffer, int maxlen);
+
+/**
+ * Extract information from a curl handle. (CURLINFO_LONG, CURLINFO_DOUBLE only)
+ * @ param Handle		hndl		The handle of the curl to be used.
+ * @ param CURLINFO		info		The enum CURLINFO, see cURL_header.inc
+ * @ param 				value		Variable to store the value.
+ * @ return 						The CURLcode code, see cURL_header.inc
+ */
+native CURLcode curl_easy_getinfo_int(Handle hndl, CURLINFO info, any &value);
+
+/**
+ * URL encodes the given string 
+ * @ param Handle		hndl		The handle of the curl to be used.
+ * @ param String		url			The string to encodes.
+ * @ param String		buffer		Destination string buffer to copy to.
+ * @ param cell_t		maxlen		Destination buffer length (includes null terminator).
+ * @ return 						1 on success.
+ */
+native bool curl_easy_escape(Handle hndl, const char[] url, char[] buffer, int maxlen);
+
+/**
+ * URL decodes the given string 
+ * @ param Handle		hndl		The handle of the curl to be used.
+ * @ param String		url			The string to dencodes.
+ * @ param String		buffer		Destination string buffer to copy to.
+ * @ param cell_t		maxlen		Destination buffer length (includes null terminator).
+ * @ return 						The output length.
+ */
+native int curl_easy_unescape(Handle hndl, const char[] url, char[] buffer, int maxlen);
+
+/**
+ * Return string describing error code
+ * @ param CURLcode		code		The CURLcode code, see cURL_header.inc
+ * @ param String		buffer		Destination string buffer to copy to.
+ * @ param cell_t		maxlen		Destination buffer length (includes null terminator).
+ * @ noreturn
+ */
+native void curl_easy_strerror(CURLcode code, char[] buffer, int maxlen);
+
+/**
+ * Returns the libcurl version string
+ * @ param String		buffer		Destination string buffer to copy to.
+ * @ param cell_t		maxlen		Destination buffer length (includes null terminator).
+ * @ noreturn
+ */
+native void curl_version(char[] buffer, int maxlen);
+
+/**
+ * Returns the libcurl supported protocols string
+ * @ param String		buffer		Destination string buffer to copy to.
+ * @ param cell_t		maxlen		Destination buffer length (includes null terminator).
+ * @ noreturn
+ */
+native void curl_protocols(char[] buffer, int maxlen);
+
+/**
+ * Returns the libcurl supported features
+ * @ return			The currently features bits. see CURL_VERSION_*
+ */
+native int curl_features();
+
+/**
+ * This funcitopn same as Sourcemod OpenFile()
+ * For the following CUROPT_* only
+ * 		CURLOPT_WRITEDATA
+ *		CURLOPT_HEADERDATA
+ *		CURLOPT_READDATA
+ *		CURLOPT_STDERR
+ *		CURLOPT_INTERLEAVEDATA
+ *
+ * @ note
+ * 		Should not share to another threaded curl handle.
+ *
+ * @ param file			File to open.
+ * @ param mode			Open mode.
+ * @ return				A Handle to the file, INVALID_HANDLE on open error.
+ */
+native Handle curl_OpenFile(const char[] file, const char[] mode);
+
+
+/**
+ * Create a curl_httppost struct
+ * For the following CUROPT_* only
+ * 		CURLOPT_HTTPPOST
+ * @ note
+ * 		Should not share to another threaded curl handle.
+ *
+ * @ return				A Handle to the curl_httppost, INVALID_HANDLE on error.
+ */
+native Handle curl_httppost();
+
+/**
+ * Add a section to a multipart/formdata HTTP POST
+ * @ note
+ *		Check enum CURLformoption (cURL_head.inc) to see which option supported
+ *
+ * @ param Handle		hndl		The handle of the curl_httppost to be used.
+ * @ param 				...			Variable number of format parameters.
+ * @ return 						The CURLFORMcode code, see cURL_header.inc
+ */
+native CURLFORMcode curl_formadd(Handle handl, any ...);
+
+/**
+ * Create a curl_slist struct
+ * For the following CUROPT_* only
+ * 		CURLOPT_QUOTE
+ *		CURLOPT_HTTPHEADER
+ *		CURLOPT_POSTQUOTE
+ *		CURLOPT_TELNETOPTIONS
+ *		CURLOPT_PREQUOTE
+ *		CURLOPT_HTTP200ALIASES
+ *		CURLOPT_MAIL_RCPT
+ *		CURLOPT_RESOLVE
+ *
+ * @ note
+ * 		Should not share to another threaded curl handle.
+ *
+ * @ return				A Handle to the curl_slist, INVALID_HANDLE on error.
+ */
+native Handle curl_slist();
+
+/**
+ *  Add a string to an slist
+ * @ param Handle		hndl		The handle of the curl_slist to be used.
+ * @ param String		buffer		The string to add
+ * @ noreturn
+ */
+native void curl_slist_append(Handle hndl, const char[] buffer);
+
+/**
+ * Hash a file
+ * @ parma String					file 				The file path. supports the "file //" notation.
+ * @ param Openssl_Hash				algorithm			Hash Algorithm.
+ * @ param Openssl_Hash_Complete	complete_callback	The complete callback.
+ * @ param cell_t					value				Value to set.
+ * @ noreturn
+ */
+native void curl_hash_file(const char[] file, Openssl_Hash algorithm, Openssl_Hash_Complete complete_callback, any value=0);
+
+/**
+ * Hash a string
+ * @ parma String			input			The string to hash.
+ * @ param cell_t			dataSize		The input string size.
+ * @ param Openssl_Hash		algorithm		Hash Algorithm.
+ * @ param String			buffer			Destination string buffer to copy to.
+ * @ param cell_t			maxlen			Destination buffer length (includes null terminator).
+ * @ return									1 on success
+ */
+native bool curl_hash_string(const char[] input, int dataSize, Openssl_Hash algorithm, char[] buffer, int maxlength);
+
+
+/**
+ * Do not edit below this line!
+ */
+public Extension __ext_curl = {
+	name = "curl",
+	file = "curl.ext",
+#if defined AUTOLOAD_EXTENSIONS
+	autoload = 1,
+#else
+	autoload = 0,
+#endif
+#if defined REQUIRE_EXTENSIONS
+	required = 1,
+#else
+	required = 0,
+#endif
+};
diff --git a/scripting/include/cURL_header.inc b/scripting/include/cURL_header.inc
new file mode 100644
index 0000000..cf51cf1
--- /dev/null
+++ b/scripting/include/cURL_header.inc
@@ -0,0 +1,1206 @@
+#if defined _cURL_header_included
+  #endinput
+#endif
+#define _cURL_header_included
+
+
+/* SourceMod */
+#define LONG 					CURLOPTTYPE_LONG
+#define OBJECTPOINT 			CURLOPTTYPE_OBJECTPOINT
+#define FUNCTIONPOINT 			CURLOPTTYPE_FUNCTIONPOINT
+#define OFF_T 					CURLOPTTYPE_OFF_T
+	
+
+#define CURL_MAX_WRITE_SIZE 16384
+
+#define CURL_VERSION_IPV6      (1<<0)  /* IPv6-enabled */
+#define CURL_VERSION_KERBEROS4 (1<<1)  /* kerberos auth is supported */
+#define CURL_VERSION_SSL       (1<<2)  /* SSL options are present */
+#define CURL_VERSION_LIBZ      (1<<3)  /* libz features are present */
+#define CURL_VERSION_NTLM      (1<<4)  /* NTLM auth is supported */
+#define CURL_VERSION_GSSNEGOTIATE (1<<5) /* Negotiate auth support */
+#define CURL_VERSION_DEBUG     (1<<6)  /* built with debug capabilities */
+#define CURL_VERSION_ASYNCHDNS (1<<7)  /* asynchronous dns resolves */
+#define CURL_VERSION_SPNEGO    (1<<8)  /* SPNEGO auth */
+#define CURL_VERSION_LARGEFILE (1<<9)  /* supports files bigger than 2GB */
+#define CURL_VERSION_IDN       (1<<10) /* International Domain Names support */
+#define CURL_VERSION_SSPI      (1<<11) /* SSPI is supported */
+#define CURL_VERSION_CONV      (1<<12) /* character conversions supported */
+#define CURL_VERSION_CURLDEBUG (1<<13) /* debug memory tracking supported */
+#define CURL_VERSION_TLSAUTH_SRP (1<<14) /* TLS-SRP auth is supported */
+#define CURL_VERSION_NTLM_WB   (1<<15) /* NTLM delegating to winbind helper */
+
+
+#define CURLOPTTYPE_LONG          0
+#define CURLOPTTYPE_OBJECTPOINT   10000
+#define CURLOPTTYPE_FUNCTIONPOINT 20000
+#define CURLOPTTYPE_OFF_T         30000
+
+#define CINIT(%1,%2,%3) CURLOPT_%1 = %2 + %3
+
+  /* three convenient "aliases" that follow the name scheme better */
+#define CURLOPT_WRITEDATA CURLOPT_FILE
+#define CURLOPT_READDATA  CURLOPT_INFILE
+#define CURLOPT_HEADERDATA CURLOPT_WRITEHEADER
+#define CURLOPT_RTSPHEADER CURLOPT_HTTPHEADER
+
+/* This was added in version 7.19.1 */
+#define CURLOPT_POST301 CURLOPT_POSTREDIR
+
+/* The following were added in 7.17.0 */
+#define CURLOPT_SSLKEYPASSWD CURLOPT_KEYPASSWD
+#define CURLOPT_FTPAPPEND CURLOPT_APPEND
+#define CURLOPT_FTPLISTONLY CURLOPT_DIRLISTONLY
+#define CURLOPT_FTP_SSL CURLOPT_USE_SSL
+
+/* The following were added earlier */
+
+#define CURLOPT_SSLCERTPASSWD CURLOPT_KEYPASSWD
+#define CURLOPT_KRB4LEVEL CURLOPT_KRBLEVEL
+
+enum CURLoption {
+  /* This is the FILE * or void * the regular output should be written to. */
+  CINIT(FILE, OBJECTPOINT, 1),
+
+  /* The full URL to get/put */
+  CINIT(URL,  OBJECTPOINT, 2),
+
+  /* Port number to connect to, if other than default. */
+  CINIT(PORT, LONG, 3),
+
+  /* Name of proxy to use. */
+  CINIT(PROXY, OBJECTPOINT, 4),
+
+  /* "name:password" to use when fetching. */
+  CINIT(USERPWD, OBJECTPOINT, 5),
+
+  /* "name:password" to use with proxy. */
+  CINIT(PROXYUSERPWD, OBJECTPOINT, 6),
+
+  /* Range to get, specified as an ASCII string. */
+  CINIT(RANGE, OBJECTPOINT, 7),
+
+  /* not used */
+
+  /* Specified file stream to upload from (use as input): */
+  CINIT(INFILE, OBJECTPOINT, 9),
+
+  /* Buffer to receive error messages in, must be at least CURL_ERROR_SIZE
+   * bytes big. If this is not used, error messages go to stderr instead: */
+  CINIT(ERRORBUFFER, OBJECTPOINT, 10),
+
+  /* Function that will be called to store the output (instead of fwrite). The
+   * parameters will use fwrite() syntax, make sure to follow them. */
+  CINIT(WRITEFUNCTION, FUNCTIONPOINT, 11),
+
+  /* Function that will be called to read the input (instead of fread). The
+   * parameters will use fread() syntax, make sure to follow them. */
+  CINIT(READFUNCTION, FUNCTIONPOINT, 12),
+
+  /* Time-out the read operation after this amount of seconds */
+  CINIT(TIMEOUT, LONG, 13),
+
+  /* If the CURLOPT_INFILE is used, this can be used to inform libcurl about
+   * how large the file being sent really is. That allows better error
+   * checking and better verifies that the upload was successful. -1 means
+   * unknown size.
+   *
+   * For large file support, there is also a _LARGE version of the key
+   * which takes an OFF_T type, allowing platforms with larger OFF_T
+   * sizes to handle larger files.  See below for INFILESIZE_LARGE.
+   */
+  CINIT(INFILESIZE, LONG, 14),
+
+  /* POST static input fields. */
+  CINIT(POSTFIELDS, OBJECTPOINT, 15),
+
+  /* Set the referrer page (needed by some CGIs) */
+  CINIT(REFERER, OBJECTPOINT, 16),
+
+  /* Set the FTP PORT string (interface name, named or numerical IP address)
+     Use i.e '-' to use default address. */
+  CINIT(FTPPORT, OBJECTPOINT, 17),
+
+  /* Set the User-Agent string (examined by some CGIs) */
+  CINIT(USERAGENT, OBJECTPOINT, 18),
+
+  /* If the download receives less than "low speed limit" bytes/second
+   * during "low speed time" seconds, the operations is aborted.
+   * You could i.e if you have a pretty high speed connection, abort if
+   * it is less than 2000 bytes/sec during 20 seconds.
+   */
+
+  /* Set the "low speed limit" */
+  CINIT(LOW_SPEED_LIMIT, LONG, 19),
+
+  /* Set the "low speed time" */
+  CINIT(LOW_SPEED_TIME, LONG, 20),
+
+  /* Set the continuation offset.
+   *
+   * Note there is also a _LARGE version of this key which uses
+   * OFF_T types, allowing for large file offsets on platforms which
+   * use larger-than-32-bit OFF_T's.  Look below for RESUME_FROM_LARGE.
+   */
+  CINIT(RESUME_FROM, LONG, 21),
+
+  /* Set cookie in request: */
+  CINIT(COOKIE, OBJECTPOINT, 22),
+
+  /* This points to a linked list of headers, struct curl_slist kind */
+  CINIT(HTTPHEADER, OBJECTPOINT, 23),
+
+  /* This points to a linked list of post entries, struct curl_httppost */
+  CINIT(HTTPPOST, OBJECTPOINT, 24),
+
+  /* name of the file keeping your private SSL-certificate */
+  CINIT(SSLCERT, OBJECTPOINT, 25),
+
+  /* password for the SSL or SSH private key */
+  CINIT(KEYPASSWD, OBJECTPOINT, 26),
+
+  /* send TYPE parameter? */
+  CINIT(CRLF, LONG, 27),
+
+  /* send linked-list of QUOTE commands */
+  CINIT(QUOTE, OBJECTPOINT, 28),
+
+  /* send FILE * or void * to store headers to, if you use a callback it
+     is simply passed to the callback unmodified */
+  CINIT(WRITEHEADER, OBJECTPOINT, 29),
+
+  /* point to a file to read the initial cookies from, also enables
+     "cookie awareness" */
+  CINIT(COOKIEFILE, OBJECTPOINT, 31),
+
+  /* What version to specifically try to use.
+     See CURL_SSLVERSION defines below. */
+  CINIT(SSLVERSION, LONG, 32),
+
+  /* What kind of HTTP time condition to use, see defines */
+  CINIT(TIMECONDITION, LONG, 33),
+
+  /* Time to use with the above condition. Specified in number of seconds
+     since 1 Jan 1970 */
+  CINIT(TIMEVALUE, LONG, 34),
+
+  /* 35 = OBSOLETE */
+
+  /* Custom request, for customizing the get command like
+     HTTP: DELETE, TRACE and others
+     FTP: to use a different list command
+     */
+  CINIT(CUSTOMREQUEST, OBJECTPOINT, 36),
+
+  /* HTTP request, for odd commands like DELETE, TRACE and others */
+  CINIT(STDERR, OBJECTPOINT, 37),
+
+  /* 38 is not used */
+
+  /* send linked-list of post-transfer QUOTE commands */
+  CINIT(POSTQUOTE, OBJECTPOINT, 39),
+
+  /* Pass a pointer to string of the output using full variable-replacement
+     as described elsewhere. */
+  CINIT(WRITEINFO, OBJECTPOINT, 40), /* DEPRECATED, do not use! */
+
+  CINIT(VERBOSE, LONG, 41),      /* talk a lot */
+  CINIT(HEADER, LONG, 42),       /* throw the header out too */
+  CINIT(NOPROGRESS, LONG, 43),   /* shut off the progress meter */
+  CINIT(NOBODY, LONG, 44),       /* use HEAD to get http document */
+  CINIT(FAILONERROR, LONG, 45),  /* no output on http error codes >= 300 */
+  CINIT(UPLOAD, LONG, 46),       /* this is an upload */
+  CINIT(POST, LONG, 47),         /* HTTP POST method */
+  CINIT(DIRLISTONLY, LONG, 48),  /* bare names when listing directories */
+
+  CINIT(APPEND, LONG, 50),       /* Append instead of overwrite on upload! */
+
+  /* Specify whether to read the user+password from the .netrc or the URL.
+   * This must be one of the CURL_NETRC_* enums below. */
+  CINIT(NETRC, LONG, 51),
+
+  CINIT(FOLLOWLOCATION, LONG, 52),  /* use Location: Luke! */
+
+  CINIT(TRANSFERTEXT, LONG, 53), /* transfer data in text/ASCII format */
+  CINIT(PUT, LONG, 54),          /* HTTP PUT */
+
+  /* 55 = OBSOLETE */
+
+  /* Function that will be called instead of the internal progress display
+   * function. This function should be defined as the curl_progress_callback
+   * prototype defines. */
+  CINIT(PROGRESSFUNCTION, FUNCTIONPOINT, 56),
+
+  /* Data passed to the progress callback */
+  CINIT(PROGRESSDATA, OBJECTPOINT, 57),
+
+  /* We want the referrer field set automatically when following locations */
+  CINIT(AUTOREFERER, LONG, 58),
+
+  /* Port of the proxy, can be set in the proxy string as well with:
+     "[host]:[port]" */
+  CINIT(PROXYPORT, LONG, 59),
+
+  /* size of the POST input data, if strlen() is not good to use */
+  CINIT(POSTFIELDSIZE, LONG, 60),
+
+  /* tunnel non-http operations through a HTTP proxy */
+  CINIT(HTTPPROXYTUNNEL, LONG, 61),
+
+  /* Set the interface string to use as outgoing network interface */
+  CINIT(INTERFACE, OBJECTPOINT, 62),
+
+  /* Set the krb4/5 security level, this also enables krb4/5 awareness.  This
+   * is a string, 'clear', 'safe', 'confidential' or 'private'.  If the string
+   * is set but doesn't match one of these, 'private' will be used.  */
+  CINIT(KRBLEVEL, OBJECTPOINT, 63),
+
+  /* Set if we should verify the peer in ssl handshake, set 1 to verify. */
+  CINIT(SSL_VERIFYPEER, LONG, 64),
+
+  /* The CApath or CAfile used to validate the peer certificate
+     this option is used only if SSL_VERIFYPEER is true */
+  CINIT(CAINFO, OBJECTPOINT, 65),
+
+  /* 66 = OBSOLETE */
+  /* 67 = OBSOLETE */
+
+  /* Maximum number of http redirects to follow */
+  CINIT(MAXREDIRS, LONG, 68),
+
+  /* Pass a LONG set to 1 to get the date of the requested document (if
+     possible)! Pass a zero to shut it off. */
+  CINIT(FILETIME, LONG, 69),
+
+  /* This points to a linked list of telnet options */
+  CINIT(TELNETOPTIONS, OBJECTPOINT, 70),
+
+  /* Max amount of cached alive connections */
+  CINIT(MAXCONNECTS, LONG, 71),
+
+  CINIT(CLOSEPOLICY, LONG, 72), /* DEPRECATED, do not use! */
+
+  /* 73 = OBSOLETE */
+
+  /* Set to explicitly use a new connection for the upcoming transfer.
+     Do not use this unless you're absolutely sure of this, as it makes the
+     operation slower and is less friendly for the network. */
+  CINIT(FRESH_CONNECT, LONG, 74),
+
+  /* Set to explicitly forbid the upcoming transfer's connection to be re-used
+     when done. Do not use this unless you're absolutely sure of this, as it
+     makes the operation slower and is less friendly for the network. */
+  CINIT(FORBID_REUSE, LONG, 75),
+
+  /* Set to a file name that contains random data for libcurl to use to
+     seed the random engine when doing SSL connects. */
+  CINIT(RANDOM_FILE, OBJECTPOINT, 76),
+
+  /* Set to the Entropy Gathering Daemon socket pathname */
+  CINIT(EGDSOCKET, OBJECTPOINT, 77),
+
+  /* Time-out connect operations after this amount of seconds, if connects
+     are OK within this time, then fine... This only aborts the connect
+     phase. [Only works on unix-style/SIGALRM operating systems] */
+  CINIT(CONNECTTIMEOUT, LONG, 78),
+
+  /* Function that will be called to store headers (instead of fwrite). The
+   * parameters will use fwrite() syntax, make sure to follow them. */
+  CINIT(HEADERFUNCTION, FUNCTIONPOINT, 79),
+
+  /* Set this to force the HTTP request to get back to GET. Only really usable
+     if POST, PUT or a custom request have been used first.
+   */
+  CINIT(HTTPGET, LONG, 80),
+
+  /* Set if we should verify the Common name from the peer certificate in ssl
+   * handshake, set 1 to check existence, 2 to ensure that it matches the
+   * provided hostname. */
+  CINIT(SSL_VERIFYHOST, LONG, 81),
+
+  /* Specify which file name to write all known cookies in after completed
+     operation. Set file name to "-" (dash) to make it go to stdout. */
+  CINIT(COOKIEJAR, OBJECTPOINT, 82),
+
+  /* Specify which SSL ciphers to use */
+  CINIT(SSL_CIPHER_LIST, OBJECTPOINT, 83),
+
+  /* Specify which HTTP version to use! This must be set to one of the
+     CURL_HTTP_VERSION* enums set below. */
+  CINIT(HTTP_VERSION, LONG, 84),
+
+  /* Specifically switch on or off the FTP engine's use of the EPSV command. By
+     default, that one will always be attempted before the more traditional
+     PASV command. */
+  CINIT(FTP_USE_EPSV, LONG, 85),
+
+  /* type of the file keeping your SSL-certificate ("DER", "PEM", "ENG") */
+  CINIT(SSLCERTTYPE, OBJECTPOINT, 86),
+
+  /* name of the file keeping your private SSL-key */
+  CINIT(SSLKEY, OBJECTPOINT, 87),
+
+  /* type of the file keeping your private SSL-key ("DER", "PEM", "ENG") */
+  CINIT(SSLKEYTYPE, OBJECTPOINT, 88),
+
+  /* crypto engine for the SSL-sub system */
+  CINIT(SSLENGINE, OBJECTPOINT, 89),
+
+  /* set the crypto engine for the SSL-sub system as default
+     the param has no meaning...
+   */
+  CINIT(SSLENGINE_DEFAULT, LONG, 90),
+
+  /* Non-zero value means to use the global dns cache */
+  CINIT(DNS_USE_GLOBAL_CACHE, LONG, 91), /* DEPRECATED, do not use! */
+
+  /* DNS cache timeout */
+  CINIT(DNS_CACHE_TIMEOUT, LONG, 92),
+
+  /* send linked-list of pre-transfer QUOTE commands */
+  CINIT(PREQUOTE, OBJECTPOINT, 93),
+
+  /* set the debug function */
+  CINIT(DEBUGFUNCTION, FUNCTIONPOINT, 94),
+
+  /* set the data for the debug function */
+  CINIT(DEBUGDATA, OBJECTPOINT, 95),
+
+  /* mark this as start of a cookie session */
+  CINIT(COOKIESESSION, LONG, 96),
+
+  /* The CApath directory used to validate the peer certificate
+     this option is used only if SSL_VERIFYPEER is true */
+  CINIT(CAPATH, OBJECTPOINT, 97),
+
+  /* Instruct libcurl to use a smaller receive buffer */
+  CINIT(BUFFERSIZE, LONG, 98),
+
+  /* Instruct libcurl to not use any signal/alarm handlers, even when using
+     timeouts. This option is useful for multi-threaded applications.
+     See libcurl-the-guide for more background information. */
+  CINIT(NOSIGNAL, LONG, 99),
+
+  /* Provide a CURLShare for mutexing non-ts data */
+  CINIT(SHARE, OBJECTPOINT, 100),
+
+  /* indicates type of proxy. accepted values are CURLPROXY_HTTP (default),
+     CURLPROXY_SOCKS4, CURLPROXY_SOCKS4A and CURLPROXY_SOCKS5. */
+  CINIT(PROXYTYPE, LONG, 101),
+
+  /* Set the Accept-Encoding string. Use this to tell a server you would like
+     the response to be compressed. Before 7.21.6, this was known as
+     CURLOPT_ENCODING */
+  CINIT(ACCEPT_ENCODING, OBJECTPOINT, 102),
+
+  /* Set pointer to private data */
+  CINIT(PRIVATE, OBJECTPOINT, 103),
+
+  /* Set aliases for HTTP 200 in the HTTP Response header */
+  CINIT(HTTP200ALIASES, OBJECTPOINT, 104),
+
+  /* Continue to send authentication (user+password) when following locations,
+     even when hostname changed. This can potentially send off the name
+     and password to whatever host the server decides. */
+  CINIT(UNRESTRICTED_AUTH, LONG, 105),
+
+  /* Specifically switch on or off the FTP engine's use of the EPRT command (
+     it also disables the LPRT attempt). By default, those ones will always be
+     attempted before the good old traditional PORT command. */
+  CINIT(FTP_USE_EPRT, LONG, 106),
+
+  /* Set this to a bitmask value to enable the particular authentications
+     methods you like. Use this in combination with CURLOPT_USERPWD.
+     Note that setting multiple bits may cause extra network round-trips. */
+  CINIT(HTTPAUTH, LONG, 107),
+
+  /* Set the ssl context callback function, currently only for OpenSSL ssl_ctx
+     in second argument. The function must be matching the
+     curl_ssl_ctx_callback proto. */
+  CINIT(SSL_CTX_FUNC, FUNCTIONPOINT, 108),
+
+  /* Set the userdata for the ssl context callback function's third
+     argument */
+  CINIT(SSL_CTX_DATA, OBJECTPOINT, 109),
+
+  /* FTP Option that causes missing dirs to be created on the remote server.
+     In 7.19.4 we introduced the convenience enums for this option using the
+     CURLFTP_CREATE_DIR prefix.
+  */
+  CINIT(FTP_CREATE_MISSING_DIRS, LONG, 110),
+
+  /* Set this to a bitmask value to enable the particular authentications
+     methods you like. Use this in combination with CURLOPT_PROXYUSERPWD.
+     Note that setting multiple bits may cause extra network round-trips. */
+  CINIT(PROXYAUTH, LONG, 111),
+
+  /* FTP option that changes the timeout, in seconds, associated with
+     getting a response.  This is different from transfer timeout time and
+     essentially places a demand on the FTP server to acknowledge commands
+     in a timely manner. */
+  CINIT(FTP_RESPONSE_TIMEOUT, LONG, 112),
+#define CURLOPT_SERVER_RESPONSE_TIMEOUT CURLOPT_FTP_RESPONSE_TIMEOUT
+
+  /* Set this option to one of the CURL_IPRESOLVE_* defines (see below) to
+     tell libcurl to resolve names to those IP versions only. This only has
+     affect on systems with support for more than one, i.e IPv4 _and_ IPv6. */
+  CINIT(IPRESOLVE, LONG, 113),
+
+  /* Set this option to limit the size of a file that will be downloaded from
+     an HTTP or FTP server.
+
+     Note there is also _LARGE version which adds large file support for
+     platforms which have larger OFF_T sizes.  See MAXFILESIZE_LARGE below. */
+  CINIT(MAXFILESIZE, LONG, 114),
+
+  /* See the comment for INFILESIZE above, but in short, specifies
+   * the size of the file being uploaded.  -1 means unknown.
+   */
+  CINIT(INFILESIZE_LARGE, OFF_T, 115),
+
+  /* Sets the continuation offset.  There is also a LONG version of this;
+   * look above for RESUME_FROM.
+   */
+  CINIT(RESUME_FROM_LARGE, OFF_T, 116),
+
+  /* Sets the maximum size of data that will be downloaded from
+   * an HTTP or FTP server.  See MAXFILESIZE above for the LONG version.
+   */
+  CINIT(MAXFILESIZE_LARGE, OFF_T, 117),
+
+  /* Set this option to the file name of your .netrc file you want libcurl
+     to parse (using the CURLOPT_NETRC option). If not set, libcurl will do
+     a poor attempt to find the user's home directory and check for a .netrc
+     file in there. */
+  CINIT(NETRC_FILE, OBJECTPOINT, 118),
+
+  /* Enable SSL/TLS for FTP, pick one of:
+     CURLFTPSSL_TRY     - try using SSL, proceed anyway otherwise
+     CURLFTPSSL_CONTROL - SSL for the control connection or fail
+     CURLFTPSSL_ALL     - SSL for all communication or fail
+  */
+  CINIT(USE_SSL, LONG, 119),
+
+  /* The _LARGE version of the standard POSTFIELDSIZE option */
+  CINIT(POSTFIELDSIZE_LARGE, OFF_T, 120),
+
+  /* Enable/disable the TCP Nagle algorithm */
+  CINIT(TCP_NODELAY, LONG, 121),
+
+  /* 122 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */
+  /* 123 OBSOLETE. Gone in 7.16.0 */
+  /* 124 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */
+  /* 125 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */
+  /* 126 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */
+  /* 127 OBSOLETE. Gone in 7.16.0 */
+  /* 128 OBSOLETE. Gone in 7.16.0 */
+
+  /* When FTP over SSL/TLS is selected (with CURLOPT_USE_SSL), this option
+     can be used to change libcurl's default action which is to first try
+     "AUTH SSL" and then "AUTH TLS" in this order, and proceed when a OK
+     response has been received.
+
+     Available parameters are:
+     CURLFTPAUTH_DEFAULT - let libcurl decide
+     CURLFTPAUTH_SSL     - try "AUTH SSL" first, then TLS
+     CURLFTPAUTH_TLS     - try "AUTH TLS" first, then SSL
+  */
+  CINIT(FTPSSLAUTH, LONG, 129),
+
+  CINIT(IOCTLFUNCTION, FUNCTIONPOINT, 130),
+  CINIT(IOCTLDATA, OBJECTPOINT, 131),
+
+  /* 132 OBSOLETE. Gone in 7.16.0 */
+  /* 133 OBSOLETE. Gone in 7.16.0 */
+
+  /* zero terminated string for pass on to the FTP server when asked for
+     "account" info */
+  CINIT(FTP_ACCOUNT, OBJECTPOINT, 134),
+
+  /* feed cookies into cookie engine */
+  CINIT(COOKIELIST, OBJECTPOINT, 135),
+
+  /* ignore Content-Length */
+  CINIT(IGNORE_CONTENT_LENGTH, LONG, 136),
+
+  /* Set to non-zero to skip the IP address received in a 227 PASV FTP server
+     response. Typically used for FTP-SSL purposes but is not restricted to
+     that. libcurl will then instead use the same IP address it used for the
+     control connection. */
+  CINIT(FTP_SKIP_PASV_IP, LONG, 137),
+
+  /* Select "file method" to use when doing FTP, see the curl_ftpmethod
+     above. */
+  CINIT(FTP_FILEMETHOD, LONG, 138),
+
+  /* Local port number to bind the socket to */
+  CINIT(LOCALPORT, LONG, 139),
+
+  /* Number of ports to try, including the first one set with LOCALPORT.
+     Thus, setting it to 1 will make no additional attempts but the first.
+  */
+  CINIT(LOCALPORTRANGE, LONG, 140),
+
+  /* no transfer, set up connection and let application use the socket by
+     extracting it with CURLINFO_LASTSOCKET */
+  CINIT(CONNECT_ONLY, LONG, 141),
+
+  /* Function that will be called to convert from the
+     network encoding (instead of using the iconv calls in libcurl) */
+  CINIT(CONV_FROM_NETWORK_FUNC, FUNCTIONPOINT, 142),
+
+  /* Function that will be called to convert to the
+     network encoding (instead of using the iconv calls in libcurl) */
+  CINIT(CONV_TO_NETWORK_FUNC, FUNCTIONPOINT, 143),
+
+  /* Function that will be called to convert from UTF8
+     (instead of using the iconv calls in libcurl)
+     Note that this is used only for SSL certificate processing */
+  CINIT(CONV_FROM_UTF8_FUNC, FUNCTIONPOINT, 144),
+
+  /* if the connection proceeds too quickly then need to slow it down */
+  /* limit-rate: maximum number of bytes per second to send or receive */
+  CINIT(MAX_SEND_SPEED_LARGE, OFF_T, 145),
+  CINIT(MAX_RECV_SPEED_LARGE, OFF_T, 146),
+
+  /* Pointer to command string to send if USER/PASS fails. */
+  CINIT(FTP_ALTERNATIVE_TO_USER, OBJECTPOINT, 147),
+
+  /* callback function for setting socket options */
+  CINIT(SOCKOPTFUNCTION, FUNCTIONPOINT, 148),
+  CINIT(SOCKOPTDATA, OBJECTPOINT, 149),
+
+  /* set to 0 to disable session ID re-use for this transfer, default is
+     enabled (== 1) */
+  CINIT(SSL_SESSIONID_CACHE, LONG, 150),
+
+  /* allowed SSH authentication methods */
+  CINIT(SSH_AUTH_TYPES, LONG, 151),
+
+  /* Used by scp/sftp to do public/private key authentication */
+  CINIT(SSH_PUBLIC_KEYFILE, OBJECTPOINT, 152),
+  CINIT(SSH_PRIVATE_KEYFILE, OBJECTPOINT, 153),
+
+  /* Send CCC (Clear Command Channel) after authentication */
+  CINIT(FTP_SSL_CCC, LONG, 154),
+
+  /* Same as TIMEOUT and CONNECTTIMEOUT, but with ms resolution */
+  CINIT(TIMEOUT_MS, LONG, 155),
+  CINIT(CONNECTTIMEOUT_MS, LONG, 156),
+
+  /* set to zero to disable the libcurl's decoding and thus pass the raw body
+     data to the application even when it is encoded/compressed */
+  CINIT(HTTP_TRANSFER_DECODING, LONG, 157),
+  CINIT(HTTP_CONTENT_DECODING, LONG, 158),
+
+  /* Permission used when creating new files and directories on the remote
+     server for protocols that support it, SFTP/SCP/FILE */
+  CINIT(NEW_FILE_PERMS, LONG, 159),
+  CINIT(NEW_DIRECTORY_PERMS, LONG, 160),
+
+  /* Set the behaviour of POST when redirecting. Values must be set to one
+     of CURL_REDIR* defines below. This used to be called CURLOPT_POST301 */
+  CINIT(POSTREDIR, LONG, 161),
+
+  /* used by scp/sftp to verify the host's public key */
+  CINIT(SSH_HOST_PUBLIC_KEY_MD5, OBJECTPOINT, 162),
+
+  /* Callback function for opening socket (instead of socket(2)). Optionally,
+     callback is able change the address or refuse to connect returning
+     CURL_SOCKET_BAD.  The callback should have type
+     curl_opensocket_callback */
+  CINIT(OPENSOCKETFUNCTION, FUNCTIONPOINT, 163),
+  CINIT(OPENSOCKETDATA, OBJECTPOINT, 164),
+
+  /* POST volatile input fields. */
+  CINIT(COPYPOSTFIELDS, OBJECTPOINT, 165),
+
+  /* set transfer mode (;type=<a|i>) when doing FTP via an HTTP proxy */
+  CINIT(PROXY_TRANSFER_MODE, LONG, 166),
+
+  /* Callback function for seeking in the input stream */
+  CINIT(SEEKFUNCTION, FUNCTIONPOINT, 167),
+  CINIT(SEEKDATA, OBJECTPOINT, 168),
+
+  /* CRL file */
+  CINIT(CRLFILE, OBJECTPOINT, 169),
+
+  /* Issuer certificate */
+  CINIT(ISSUERCERT, OBJECTPOINT, 170),
+
+  /* (IPv6) Address scope */
+  CINIT(ADDRESS_SCOPE, LONG, 171),
+
+  /* Collect certificate chain info and allow it to get retrievable with
+     CURLINFO_CERTINFO after the transfer is complete. (Unfortunately) only
+     working with OpenSSL-powered builds. */
+  CINIT(CERTINFO, LONG, 172),
+
+  /* "name" and "pwd" to use when fetching. */
+  CINIT(USERNAME, OBJECTPOINT, 173),
+  CINIT(PASSWORD, OBJECTPOINT, 174),
+
+    /* "name" and "pwd" to use with Proxy when fetching. */
+  CINIT(PROXYUSERNAME, OBJECTPOINT, 175),
+  CINIT(PROXYPASSWORD, OBJECTPOINT, 176),
+
+  /* Comma separated list of hostnames defining no-proxy zones. These should
+     match both hostnames directly, and hostnames within a domain. For
+     example, local.com will match local.com and www.local.com, but NOT
+     notlocal.com or www.notlocal.com. For compatibility with other
+     implementations of this, .local.com will be considered to be the same as
+     local.com. A single * is the only valid wildcard, and effectively
+     disables the use of proxy. */
+  CINIT(NOPROXY, OBJECTPOINT, 177),
+
+  /* block size for TFTP transfers */
+  CINIT(TFTP_BLKSIZE, LONG, 178),
+
+  /* Socks Service */
+  CINIT(SOCKS5_GSSAPI_SERVICE, OBJECTPOINT, 179),
+
+  /* Socks Service */
+  CINIT(SOCKS5_GSSAPI_NEC, LONG, 180),
+
+  /* set the bitmask for the protocols that are allowed to be used for the
+     transfer, which thus helps the app which takes URLs from users or other
+     external inputs and want to restrict what protocol(s) to deal
+     with. Defaults to CURLPROTO_ALL. */
+  CINIT(PROTOCOLS, LONG, 181),
+
+  /* set the bitmask for the protocols that libcurl is allowed to follow to,
+     as a subset of the CURLOPT_PROTOCOLS ones. That means the protocol needs
+     to be set in both bitmasks to be allowed to get redirected to. Defaults
+     to all protocols except FILE and SCP. */
+  CINIT(REDIR_PROTOCOLS, LONG, 182),
+
+  /* set the SSH knownhost file name to use */
+  CINIT(SSH_KNOWNHOSTS, OBJECTPOINT, 183),
+
+  /* set the SSH host key callback, must point to a curl_sshkeycallback
+     function */
+  CINIT(SSH_KEYFUNCTION, FUNCTIONPOINT, 184),
+
+  /* set the SSH host key callback custom pointer */
+  CINIT(SSH_KEYDATA, OBJECTPOINT, 185),
+
+  /* set the SMTP mail originator */
+  CINIT(MAIL_FROM, OBJECTPOINT, 186),
+
+  /* set the SMTP mail receiver(s) */
+  CINIT(MAIL_RCPT, OBJECTPOINT, 187),
+
+  /* FTP: send PRET before PASV */
+  CINIT(FTP_USE_PRET, LONG, 188),
+
+  /* RTSP request method (OPTIONS, SETUP, PLAY, etc...) */
+  CINIT(RTSP_REQUEST, LONG, 189),
+
+  /* The RTSP session identifier */
+  CINIT(RTSP_SESSION_ID, OBJECTPOINT, 190),
+
+  /* The RTSP stream URI */
+  CINIT(RTSP_STREAM_URI, OBJECTPOINT, 191),
+
+  /* The Transport: header to use in RTSP requests */
+  CINIT(RTSP_TRANSPORT, OBJECTPOINT, 192),
+
+  /* Manually initialize the client RTSP CSeq for this handle */
+  CINIT(RTSP_CLIENT_CSEQ, LONG, 193),
+
+  /* Manually initialize the server RTSP CSeq for this handle */
+  CINIT(RTSP_SERVER_CSEQ, LONG, 194),
+
+  /* The stream to pass to INTERLEAVEFUNCTION. */
+  CINIT(INTERLEAVEDATA, OBJECTPOINT, 195),
+
+  /* Let the application define a custom write method for RTP data */
+  CINIT(INTERLEAVEFUNCTION, FUNCTIONPOINT, 196),
+
+  /* Turn on wildcard matching */
+  CINIT(WILDCARDMATCH, LONG, 197),
+
+  /* Directory matching callback called before downloading of an
+     individual file (chunk) started */
+  CINIT(CHUNK_BGN_FUNC, FUNCTIONPOINT, 198),
+
+  /* Directory matching callback called after the file (chunk)
+     was downloaded, or skipped */
+  CINIT(CHUNK_END_FUNC, FUNCTIONPOINT, 199),
+
+  /* Change match (fnmatch-like) callback for wildcard matching */
+  CINIT(FNMATCH_FUNC, FUNCTIONPOINT, 200),
+
+  /* Let the application define custom chunk data pointer */
+  CINIT(CHUNK_DATA, OBJECTPOINT, 201),
+
+  /* FNMATCH_FUNC user pointer */
+  CINIT(FNMATCH_DATA, OBJECTPOINT, 202),
+
+  /* send linked-list of name:port:address sets */
+  CINIT(RESOLVE, OBJECTPOINT, 203),
+
+  /* Set a username for authenticated TLS */
+  CINIT(TLSAUTH_USERNAME, OBJECTPOINT, 204),
+
+  /* Set a password for authenticated TLS */
+  CINIT(TLSAUTH_PASSWORD, OBJECTPOINT, 205),
+
+  /* Set authentication type for authenticated TLS */
+  CINIT(TLSAUTH_TYPE, OBJECTPOINT, 206),
+
+ /* Set to 1 to enable the "TE:" header in HTTP requests to ask for
+     compressed transfer-encoded responses. Set to 0 to disable the use of TE:
+     in outgoing requests. The current default is 0, but it might change in a
+     future libcurl release.
+
+     libcurl will ask for the compressed methods it knows of, and if that
+     isn't any, it will not ask for transfer-encoding at all even if this
+     option is set to 1.
+
+  */
+  CINIT(TRANSFER_ENCODING, LONG, 207),
+
+  /* Callback function for closing socket (instead of close(2)). The callback
+     should have type curl_closesocket_callback */
+  CINIT(CLOSESOCKETFUNCTION, FUNCTIONPOINT, 208),
+  CINIT(CLOSESOCKETDATA, OBJECTPOINT, 209),
+
+  /* allow GSSAPI credential delegation */
+  CINIT(GSSAPI_DELEGATION, LONG, 210),
+
+  CURLOPT_LASTENTRY /* the last unused */
+};
+
+
+enum CURLcode {
+  CURLE_OK = 0,
+  CURLE_UNSUPPORTED_PROTOCOL,    /* 1 */
+  CURLE_FAILED_INIT,             /* 2 */
+  CURLE_URL_MALFORMAT,           /* 3 */
+  CURLE_NOT_BUILT_IN,            /* 4 - [was obsoleted in August 2007 for
+                                    7.17.0, reused in April 2011 for 7.21.5] */
+  CURLE_COULDNT_RESOLVE_PROXY,   /* 5 */
+  CURLE_COULDNT_RESOLVE_HOST,    /* 6 */
+  CURLE_COULDNT_CONNECT,         /* 7 */
+  CURLE_FTP_WEIRD_SERVER_REPLY,  /* 8 */
+  CURLE_REMOTE_ACCESS_DENIED,    /* 9 a service was denied by the server
+                                    due to lack of access - when login fails
+                                    this is not returned. */
+  CURLE_OBSOLETE10,              /* 10 - NOT USED */
+  CURLE_FTP_WEIRD_PASS_REPLY,    /* 11 */
+  CURLE_OBSOLETE12,              /* 12 - NOT USED */
+  CURLE_FTP_WEIRD_PASV_REPLY,    /* 13 */
+  CURLE_FTP_WEIRD_227_FORMAT,    /* 14 */
+  CURLE_FTP_CANT_GET_HOST,       /* 15 */
+  CURLE_OBSOLETE16,              /* 16 - NOT USED */
+  CURLE_FTP_COULDNT_SET_TYPE,    /* 17 */
+  CURLE_PARTIAL_FILE,            /* 18 */
+  CURLE_FTP_COULDNT_RETR_FILE,   /* 19 */
+  CURLE_OBSOLETE20,              /* 20 - NOT USED */
+  CURLE_QUOTE_ERROR,             /* 21 - quote command failure */
+  CURLE_HTTP_RETURNED_ERROR,     /* 22 */
+  CURLE_WRITE_ERROR,             /* 23 */
+  CURLE_OBSOLETE24,              /* 24 - NOT USED */
+  CURLE_UPLOAD_FAILED,           /* 25 - failed upload "command" */
+  CURLE_READ_ERROR,              /* 26 - couldn't open/read from file */
+  CURLE_OUT_OF_MEMORY,           /* 27 */
+  /* Note: CURLE_OUT_OF_MEMORY may sometimes indicate a conversion error
+           instead of a memory allocation error if CURL_DOES_CONVERSIONS
+           is defined
+  */
+  CURLE_OPERATION_TIMEDOUT,      /* 28 - the timeout time was reached */
+  CURLE_OBSOLETE29,              /* 29 - NOT USED */
+  CURLE_FTP_PORT_FAILED,         /* 30 - FTP PORT operation failed */
+  CURLE_FTP_COULDNT_USE_REST,    /* 31 - the REST command failed */
+  CURLE_OBSOLETE32,              /* 32 - NOT USED */
+  CURLE_RANGE_ERROR,             /* 33 - RANGE "command" didn't work */
+  CURLE_HTTP_POST_ERROR,         /* 34 */
+  CURLE_SSL_CONNECT_ERROR,       /* 35 - wrong when connecting with SSL */
+  CURLE_BAD_DOWNLOAD_RESUME,     /* 36 - couldn't resume download */
+  CURLE_FILE_COULDNT_READ_FILE,  /* 37 */
+  CURLE_LDAP_CANNOT_BIND,        /* 38 */
+  CURLE_LDAP_SEARCH_FAILED,      /* 39 */
+  CURLE_OBSOLETE40,              /* 40 - NOT USED */
+  CURLE_FUNCTION_NOT_FOUND,      /* 41 */
+  CURLE_ABORTED_BY_CALLBACK,     /* 42 */
+  CURLE_BAD_FUNCTION_ARGUMENT,   /* 43 */
+  CURLE_OBSOLETE44,              /* 44 - NOT USED */
+  CURLE_INTERFACE_FAILED,        /* 45 - CURLOPT_INTERFACE failed */
+  CURLE_OBSOLETE46,              /* 46 - NOT USED */
+  CURLE_TOO_MANY_REDIRECTS ,     /* 47 - catch endless re-direct loops */
+  CURLE_UNKNOWN_OPTION,          /* 48 - User specified an unknown option */
+  CURLE_TELNET_OPTION_SYNTAX ,   /* 49 - Malformed telnet option */
+  CURLE_OBSOLETE50,              /* 50 - NOT USED */
+  CURLE_PEER_FAILED_VERIFICATION, /* 51 - peer's certificate or fingerprint
+                                     wasn't verified fine */
+  CURLE_GOT_NOTHING,             /* 52 - when this is a specific error */
+  CURLE_SSL_ENGINE_NOTFOUND,     /* 53 - SSL crypto engine not found */
+  CURLE_SSL_ENGINE_SETFAILED,    /* 54 - can not set SSL crypto engine as
+                                    default */
+  CURLE_SEND_ERROR,              /* 55 - failed sending network data */
+  CURLE_RECV_ERROR,              /* 56 - failure in receiving network data */
+  CURLE_OBSOLETE57,              /* 57 - NOT IN USE */
+  CURLE_SSL_CERTPROBLEM,         /* 58 - problem with the local certificate */
+  CURLE_SSL_CIPHER,              /* 59 - couldn't use specified cipher */
+  CURLE_SSL_CACERT,              /* 60 - problem with the CA cert (path?) */
+  CURLE_BAD_CONTENT_ENCODING,    /* 61 - Unrecognized/bad encoding */
+  CURLE_LDAP_INVALID_URL,        /* 62 - Invalid LDAP URL */
+  CURLE_FILESIZE_EXCEEDED,       /* 63 - Maximum file size exceeded */
+  CURLE_USE_SSL_FAILED,          /* 64 - Requested FTP SSL level failed */
+  CURLE_SEND_FAIL_REWIND,        /* 65 - Sending the data requires a rewind
+                                    that failed */
+  CURLE_SSL_ENGINE_INITFAILED,   /* 66 - failed to initialise ENGINE */
+  CURLE_LOGIN_DENIED,            /* 67 - user, password or similar was not
+                                    accepted and we failed to login */
+  CURLE_TFTP_NOTFOUND,           /* 68 - file not found on server */
+  CURLE_TFTP_PERM,               /* 69 - permission problem on server */
+  CURLE_REMOTE_DISK_FULL,        /* 70 - out of disk space on server */
+  CURLE_TFTP_ILLEGAL,            /* 71 - Illegal TFTP operation */
+  CURLE_TFTP_UNKNOWNID,          /* 72 - Unknown transfer ID */
+  CURLE_REMOTE_FILE_EXISTS,      /* 73 - File already exists */
+  CURLE_TFTP_NOSUCHUSER,         /* 74 - No such user */
+  CURLE_CONV_FAILED,             /* 75 - conversion failed */
+  CURLE_CONV_REQD,               /* 76 - caller must register conversion
+                                    callbacks using curl_easy_setopt options
+                                    CURLOPT_CONV_FROM_NETWORK_FUNCTION,
+                                    CURLOPT_CONV_TO_NETWORK_FUNCTION, and
+                                    CURLOPT_CONV_FROM_UTF8_FUNCTION */
+  CURLE_SSL_CACERT_BADFILE,      /* 77 - could not load CACERT file, missing
+                                    or wrong format */
+  CURLE_REMOTE_FILE_NOT_FOUND,   /* 78 - remote file not found */
+  CURLE_SSH,                     /* 79 - error from the SSH layer, somewhat
+                                    generic so the error message will be of
+                                    interest when this has happened */
+
+  CURLE_SSL_SHUTDOWN_FAILED,     /* 80 - Failed to shut down the SSL
+                                    connection */
+  CURLE_AGAIN,                   /* 81 - socket is not ready for send/recv,
+                                    wait till it's ready and try again (Added
+                                    in 7.18.2) */
+  CURLE_SSL_CRL_BADFILE,         /* 82 - could not load CRL file, missing or
+                                    wrong format (Added in 7.19.0) */
+  CURLE_SSL_ISSUER_ERROR,        /* 83 - Issuer check failed.  (Added in
+                                    7.19.0) */
+  CURLE_FTP_PRET_FAILED,         /* 84 - a PRET command failed */
+  CURLE_RTSP_CSEQ_ERROR,         /* 85 - mismatch of RTSP CSeq numbers */
+  CURLE_RTSP_SESSION_ERROR,      /* 86 - mismatch of RTSP Session Ids */
+  CURLE_FTP_BAD_FILE_LIST,       /* 87 - unable to parse FTP file list */
+  CURLE_CHUNK_FAILED,            /* 88 - chunk callback reported error */
+
+  CURL_LAST /* never use! */
+};
+
+/*  compatibility with older names */
+#define CURLOPT_ENCODING CURLOPT_ACCEPT_ENCODING
+
+/* The following were added in 7.21.5, April 2011 */
+#define CURLE_UNKNOWN_TELNET_OPTION CURLE_UNKNOWN_OPTION
+
+enum curl_TimeCond {
+  CURL_TIMECOND_NONE,
+
+  CURL_TIMECOND_IFMODSINCE,
+  CURL_TIMECOND_IFUNMODSINCE,
+  CURL_TIMECOND_LASTMOD,
+
+  CURL_TIMECOND_LAST
+};
+
+/* These enums are for use with the CURLOPT_NETRC option. */
+enum CURL_NETRC_OPTION {
+  CURL_NETRC_IGNORED,     /* The .netrc will never be read.
+                           * This is the default. */
+  CURL_NETRC_OPTIONAL,    /* A user:password in the URL will be preferred
+                           * to one in the .netrc. */
+  CURL_NETRC_REQUIRED,    /* A user:password in the URL will be ignored.
+                           * Unless one is set programmatically, the .netrc
+                           * will be queried. */
+  CURL_NETRC_LAST
+};
+
+enum curl_closepolicy {
+  CURLCLOSEPOLICY_NONE, /* first, never use this */
+
+  CURLCLOSEPOLICY_OLDEST,
+  CURLCLOSEPOLICY_LEAST_RECENTLY, // CURLCLOSEPOLICY_LEAST_RECENTLY_USED
+  CURLCLOSEPOLICY_LEAST_TRAFFIC,
+  CURLCLOSEPOLICY_SLOWEST,
+  CURLCLOSEPOLICY_CALLBACK,
+
+  CURLCLOSEPOLICY_LAST /* last, never use this */
+};
+
+enum {
+  CURL_HTTP_VERSION_NONE, /* setting this means we don't care, and that we'd
+                             like the library to choose the best possible
+                             for us! */
+  CURL_HTTP_VERSION_1_0,  /* please use HTTP 1.0 in the request */
+  CURL_HTTP_VERSION_1_1,  /* please use HTTP 1.1 in the request */
+
+  CURL_HTTP_VERSION_LAST /* *ILLEGAL* http version */
+};
+
+
+#define CURLAUTH_NONE         0       /* nothing */
+#define CURLAUTH_BASIC        (1<<0)  /* Basic (default) */
+#define CURLAUTH_DIGEST       (1<<1)  /* Digest */
+#define CURLAUTH_GSSNEGOTIATE (1<<2)  /* GSS-Negotiate */
+#define CURLAUTH_NTLM         (1<<3)  /* NTLM */
+#define CURLAUTH_DIGEST_IE    (1<<4)  /* Digest with IE flavour */
+#define CURLAUTH_NTLM_WB      (1<<5)  /* NTLM delegating to winbind helper */
+#define CURLAUTH_ONLY         (1<<31) /* used together with a single other
+                                         type to force no auth or just that
+                                         single type */
+#define CURLAUTH_ANY (~CURLAUTH_DIGEST_IE)  /* all fine types set */
+#define CURLAUTH_ANYSAFE (~(CURLAUTH_BASIC|CURLAUTH_DIGEST_IE))
+
+
+/* parameter for the CURLOPT_FTP_CREATE_MISSING_DIRS option */
+enum curl_ftpcreatedir {
+  CURLFTP_CREATE_DIR_NONE,  /* do NOT create missing dirs! */
+  CURLFTP_CREATE_DIR,       /* (FTP/SFTP) if CWD fails, try MKD and then CWD
+                               again if MKD succeeded, for SFTP this does
+                               similar magic */
+  CURLFTP_CREATE_DIR_RETRY, /* (FTP only) if CWD fails, try MKD and then CWD
+                               again even if MKD failed! */
+  CURLFTP_CREATE_DIR_LAST   /* not an option, never use */
+};
+
+
+  /* Below here follows defines for the CURLOPT_IPRESOLVE option. If a host
+     name resolves addresses using more than one IP protocol version, this
+     option might be handy to force libcurl to use a specific IP version. */
+#define CURL_IPRESOLVE_WHATEVER 0 /* default, resolves addresses to all IP
+                                     versions that your system allows */
+#define CURL_IPRESOLVE_V4       1 /* resolve to ipv4 addresses */
+#define CURL_IPRESOLVE_V6       2 /* resolve to ipv6 addresses */
+
+
+/* parameter for the CURLOPT_USE_SSL option */
+enum curl_usessl {
+  CURLUSESSL_NONE,    /* do not attempt to use SSL */
+  CURLUSESSL_TRY,     /* try using SSL, proceed anyway otherwise */
+  CURLUSESSL_CONTROL, /* SSL for the control connection or fail */
+  CURLUSESSL_ALL,     /* SSL for all communication or fail */
+  CURLUSESSL_LAST     /* not an option, never use */
+};
+
+
+enum {
+  CURL_SSLVERSION_DEFAULT,
+  CURL_SSLVERSION_TLSv1,
+  CURL_SSLVERSION_SSLv2,
+  CURL_SSLVERSION_SSLv3,
+
+  CURL_SSLVERSION_LAST /* never use, keep last */
+};
+
+
+/* parameter for the CURLOPT_FTPSSLAUTH option */
+enum curl_ftpauth {
+  CURLFTPAUTH_DEFAULT, /* let libcurl decide */
+  CURLFTPAUTH_SSL,     /* use "AUTH SSL" */
+  CURLFTPAUTH_TLS,     /* use "AUTH TLS" */
+  CURLFTPAUTH_LAST /* not an option, never use */
+};
+
+
+enum curl_ftpfile {
+  FTPFILE_MULTICWD  = 1, /* as defined by RFC1738 */
+  FTPFILE_NOCWD     = 2, /* use SIZE / RETR / STOR on the full path */
+  FTPFILE_SINGLECWD = 3  /* make one CWD, then SIZE / RETR / STOR on the file */
+};
+
+
+#define CURLSSH_AUTH_ANY       ~0     /* all types supported by the server */
+#define CURLSSH_AUTH_NONE      0      /* none allowed, silly but complete */
+#define CURLSSH_AUTH_PUBLICKEY (1<<0) /* public/private key files */
+#define CURLSSH_AUTH_PASSWORD  (1<<1) /* password */
+#define CURLSSH_AUTH_HOST      (1<<2) /* host key files */
+#define CURLSSH_AUTH_KEYBOARD  (1<<3) /* keyboard interactive */
+#define CURLSSH_AUTH_DEFAULT CURLSSH_AUTH_ANY
+
+#define CURLGSSAPI_DELEGATION_NONE        0      /* no delegation (default) */
+#define CURLGSSAPI_DELEGATION_POLICY_FLAG (1<<0) /* if permitted by policy */
+#define CURLGSSAPI_DELEGATION_FLAG        (1<<1) /* delegate always */
+
+
+/* parameter for the CURLOPT_FTP_SSL_CCC option */
+enum curl_ftpccc {
+  CURLFTPSSL_CCC_NONE,    /* do not send CCC */
+  CURLFTPSSL_CCC_PASSIVE, /* Let the server initiate the shutdown */
+  CURLFTPSSL_CCC_ACTIVE,  /* Initiate the shutdown */
+  CURLFTPSSL_CCC_LAST     /* not an option, never use */
+};
+
+
+/* symbols to use with CURLOPT_POSTREDIR.
+   CURL_REDIR_POST_301 and CURL_REDIR_POST_302 can be bitwise ORed so that
+   CURL_REDIR_POST_301 | CURL_REDIR_POST_302 == CURL_REDIR_POST_ALL */
+
+#define CURL_REDIR_GET_ALL  0
+#define CURL_REDIR_POST_301 1
+#define CURL_REDIR_POST_302 2
+#define CURL_REDIR_POST_ALL (CURL_REDIR_POST_301|CURL_REDIR_POST_302)
+
+
+/* CURLPROTO_ defines are for the CURLOPT_*PROTOCOLS options */
+#define CURLPROTO_HTTP   (1<<0)
+#define CURLPROTO_HTTPS  (1<<1)
+#define CURLPROTO_FTP    (1<<2)
+#define CURLPROTO_FTPS   (1<<3)
+#define CURLPROTO_SCP    (1<<4)
+#define CURLPROTO_SFTP   (1<<5)
+#define CURLPROTO_TELNET (1<<6)
+#define CURLPROTO_LDAP   (1<<7)
+#define CURLPROTO_LDAPS  (1<<8)
+#define CURLPROTO_DICT   (1<<9)
+#define CURLPROTO_FILE   (1<<10)
+#define CURLPROTO_TFTP   (1<<11)
+#define CURLPROTO_IMAP   (1<<12)
+#define CURLPROTO_IMAPS  (1<<13)
+#define CURLPROTO_POP3   (1<<14)
+#define CURLPROTO_POP3S  (1<<15)
+#define CURLPROTO_SMTP   (1<<16)
+#define CURLPROTO_SMTPS  (1<<17)
+#define CURLPROTO_RTSP   (1<<18)
+#define CURLPROTO_RTMP   (1<<19)
+#define CURLPROTO_RTMPT  (1<<20)
+#define CURLPROTO_RTMPE  (1<<21)
+#define CURLPROTO_RTMPTE (1<<22)
+#define CURLPROTO_RTMPS  (1<<23)
+#define CURLPROTO_RTMPTS (1<<24)
+#define CURLPROTO_GOPHER (1<<25)
+#define CURLPROTO_ALL    (~0) /* enable everything */
+
+
+/*
+ * Public API enums for RTSP requests
+ */
+enum {
+    CURL_RTSPREQ_NONE, /* first in list */
+    CURL_RTSPREQ_OPTIONS,
+    CURL_RTSPREQ_DESCRIBE,
+    CURL_RTSPREQ_ANNOUNCE,
+    CURL_RTSPREQ_SETUP,
+    CURL_RTSPREQ_PLAY,
+    CURL_RTSPREQ_PAUSE,
+    CURL_RTSPREQ_TEARDOWN,
+    CURL_RTSPREQ_GET_PARAMETER,
+    CURL_RTSPREQ_SET_PARAMETER,
+    CURL_RTSPREQ_RECORD,
+    CURL_RTSPREQ_RECEIVE,
+    CURL_RTSPREQ_LAST /* last in list */
+};
+
+
+
+#define CURLINFO_STRING   0x100000
+#define CURLINFO_LONG     0x200000
+#define CURLINFO_DOUBLE   0x300000
+#define CURLINFO_SLIST    0x400000
+#define CURLINFO_MASK     0x0fffff
+#define CURLINFO_TYPEMASK 0xf00000
+	
+enum CURLINFO {
+  CURLINFO_NONE, /* first, never use this */
+  CURLINFO_EFFECTIVE_URL    = CURLINFO_STRING + 1,
+  CURLINFO_RESPONSE_CODE    = CURLINFO_LONG   + 2,
+  CURLINFO_TOTAL_TIME       = CURLINFO_DOUBLE + 3,
+  CURLINFO_NAMELOOKUP_TIME  = CURLINFO_DOUBLE + 4,
+  CURLINFO_CONNECT_TIME     = CURLINFO_DOUBLE + 5,
+  CURLINFO_PRETRANSFER_TIME = CURLINFO_DOUBLE + 6,
+  CURLINFO_SIZE_UPLOAD      = CURLINFO_DOUBLE + 7,
+  CURLINFO_SIZE_DOWNLOAD    = CURLINFO_DOUBLE + 8,
+  CURLINFO_SPEED_DOWNLOAD   = CURLINFO_DOUBLE + 9,
+  CURLINFO_SPEED_UPLOAD     = CURLINFO_DOUBLE + 10,
+  CURLINFO_HEADER_SIZE      = CURLINFO_LONG   + 11,
+  CURLINFO_REQUEST_SIZE     = CURLINFO_LONG   + 12,
+  CURLINFO_SSL_VERIFYRESULT = CURLINFO_LONG   + 13,
+  CURLINFO_FILETIME         = CURLINFO_LONG   + 14,
+  CURLINFO_CONTENT_LEN_DOWNLOAD   = CURLINFO_DOUBLE + 15,
+  CURLINFO_CONTENT_LEN_UPLOAD     = CURLINFO_DOUBLE + 16,
+  CURLINFO_STARTTRANSFER_TIME = CURLINFO_DOUBLE + 17,
+  CURLINFO_CONTENT_TYPE     = CURLINFO_STRING + 18,
+  CURLINFO_REDIRECT_TIME    = CURLINFO_DOUBLE + 19,
+  CURLINFO_REDIRECT_COUNT   = CURLINFO_LONG   + 20,
+  CURLINFO_PRIVATE          = CURLINFO_STRING + 21,
+  CURLINFO_HTTP_CONNECTCODE = CURLINFO_LONG   + 22,
+  CURLINFO_HTTPAUTH_AVAIL   = CURLINFO_LONG   + 23,
+  CURLINFO_PROXYAUTH_AVAIL  = CURLINFO_LONG   + 24,
+  CURLINFO_OS_ERRNO         = CURLINFO_LONG   + 25,
+  CURLINFO_NUM_CONNECTS     = CURLINFO_LONG   + 26,
+  CURLINFO_SSL_ENGINES      = CURLINFO_SLIST  + 27,
+  CURLINFO_COOKIELIST       = CURLINFO_SLIST  + 28,
+  CURLINFO_LASTSOCKET       = CURLINFO_LONG   + 29,
+  CURLINFO_FTP_ENTRY_PATH   = CURLINFO_STRING + 30,
+  CURLINFO_REDIRECT_URL     = CURLINFO_STRING + 31,
+  CURLINFO_PRIMARY_IP       = CURLINFO_STRING + 32,
+  CURLINFO_APPCONNECT_TIME  = CURLINFO_DOUBLE + 33,
+  CURLINFO_CERTINFO         = CURLINFO_SLIST  + 34,
+  CURLINFO_CONDITION_UNMET  = CURLINFO_LONG   + 35,
+  CURLINFO_RTSP_SESSION_ID  = CURLINFO_STRING + 36,
+  CURLINFO_RTSP_CLIENT_CSEQ = CURLINFO_LONG   + 37,
+  CURLINFO_RTSP_SERVER_CSEQ = CURLINFO_LONG   + 38,
+  CURLINFO_RTSP_CSEQ_RECV   = CURLINFO_LONG   + 39,
+  CURLINFO_PRIMARY_PORT     = CURLINFO_LONG   + 40,
+  CURLINFO_LOCAL_IP         = CURLINFO_STRING + 41,
+  CURLINFO_LOCAL_PORT       = CURLINFO_LONG   + 42,
+  /* Fill in new entries below here! */
+
+  CURLINFO_LASTONE          = 42
+};
+
+
+enum curl_proxytype {
+  CURLPROXY_HTTP = 0,   /* added in 7.10, new in 7.19.4 default is to use
+                           CONNECT HTTP/1.1 */
+  CURLPROXY_HTTP_1_0 = 1,   /* added in 7.19.4, force to use CONNECT
+                               HTTP/1.0  */
+  CURLPROXY_SOCKS4 = 4, /* support added in 7.15.2, enum existed already
+                           in 7.10 */
+  CURLPROXY_SOCKS5 = 5, /* added in 7.10 */
+  CURLPROXY_SOCKS4A = 6, /* added in 7.18.0 */
+  CURLPROXY_SOCKS5_HOSTNAME = 7 /* Use the SOCKS5 protocol but pass along the
+                                   host name rather than the IP address. added
+                                   in 7.18.0 */
+};
+
+
+enum CURLformoption {
+  CURLFORM_NOTHING,        /********* the first one is unused ************/
+  /*  */
+  CURLFORM_COPYNAME,       // char
+  CURLFORM_PTRNAME,        // not support
+  CURLFORM_NAMELENGTH,     // long
+  CURLFORM_COPYCONTENTS,   // char
+  CURLFORM_PTRCONTENTS,    // not support
+  CURLFORM_CONTENTSLENGTH, // long
+  CURLFORM_FILECONTENT,    // char
+  CURLFORM_ARRAY,          // not support
+  CURLFORM_OBSOLETE,
+  CURLFORM_FILE,           // char
+  CURLFORM_BUFFER,         // not support
+  CURLFORM_BUFFERPTR,      // not support
+  CURLFORM_BUFFERLENGTH,   // not support
+  CURLFORM_CONTENTTYPE,    // char 
+  CURLFORM_CONTENTHEADER,  // curl_slist
+  CURLFORM_FILENAME,       // char
+  CURLFORM_END,            // !!
+  CURLFORM_OBSOLETE2,
+  CURLFORM_STREAM,         // not support
+  CURLFORM_LASTENTRY /* the last unused */
+};
+
+enum CURLFORMcode {
+  CURL_FORMADD_OK, /* first, no error */
+  CURL_FORMADD_MEMORY,
+  CURL_FORMADD_OPTION_TWICE,
+  CURL_FORMADD_NULL,
+  CURL_FORMADD_UNKNOWN_OPTION,
+  CURL_FORMADD_INCOMPLETE,
+  CURL_FORMADD_ILLEGAL_ARRAY,
+  CURL_FORMADD_DISABLED, /* libcurl was built with this disabled */
+  CURL_FORMADD_LAST /* last */
+};
author	sappho <sappho@sappho.io>	2023-07-14 03:01:32 -0400
committer	GitHub <noreply@github.com>	2023-07-14 03:01:32 -0400
commit	581d1e994692f9ce4e5d8071e8edba1e71412bac (patch)
tree	02ae7622378e2bc4e6380ac2f6328bb4b0bc42a5
parent	95ac30070823bea03da6610db2b0684fd96e1f7e (diff)