ruby-curl 0.0.0 → 1.0.2
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +4 -4
- data/LICENSE.txt +21 -0
- data/README.md +48 -0
- data/ext/curl.c +394 -0
- data/ext/curl.h +34 -0
- data/ext/easy.c +539 -0
- data/ext/easy.h +30 -0
- data/ext/extconf.rb +26 -0
- data/lib/ruby-curl.rb +4 -1
- data/lib/ruby-curl/version.rb +3 -0
- data/ruby-curl.gemspec +36 -0
- metadata +54 -12
checksums.yaml
CHANGED
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
---
|
|
2
2
|
SHA256:
|
|
3
|
-
metadata.gz:
|
|
4
|
-
data.tar.gz:
|
|
3
|
+
metadata.gz: 13f93a17df3585dd60eebdd91ebd2595a3278b3076a86eadc9324ddb3c952d73
|
|
4
|
+
data.tar.gz: 950c69c1206777280e5baea3eedf80df8d5ca2c54852b9d4e57ae8ecaecb15ea
|
|
5
5
|
SHA512:
|
|
6
|
-
metadata.gz:
|
|
7
|
-
data.tar.gz:
|
|
6
|
+
metadata.gz: 0b75b69a4b95aeec5d42d29f196162fde96ea0ba647bce18626f96b9c6545dfa97e4c3de7609c818a48508533c575deda4da870120a8dccdb8ac237cff2ffefa
|
|
7
|
+
data.tar.gz: 0e39eb0dca94ba1101a21a126dae4d94419dd890d6e1fc627234c5f93a8c6e4ecc95199fac0056f5e6dbdb5e2b590f8c43ae82f496a5c2d9dffdc0ba2d98af11
|
data/LICENSE.txt
ADDED
|
@@ -0,0 +1,21 @@
|
|
|
1
|
+
The MIT License (MIT)
|
|
2
|
+
|
|
3
|
+
Copyright (c) 2019 Vijayakumar Ramachandran
|
|
4
|
+
|
|
5
|
+
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
6
|
+
of this software and associated documentation files (the "Software"), to deal
|
|
7
|
+
in the Software without restriction, including without limitation the rights
|
|
8
|
+
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
9
|
+
copies of the Software, and to permit persons to whom the Software is
|
|
10
|
+
furnished to do so, subject to the following conditions:
|
|
11
|
+
|
|
12
|
+
The above copyright notice and this permission notice shall be included in
|
|
13
|
+
all copies or substantial portions of the Software.
|
|
14
|
+
|
|
15
|
+
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
16
|
+
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
17
|
+
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
18
|
+
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
19
|
+
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
20
|
+
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
21
|
+
THE SOFTWARE.
|
data/README.md
ADDED
|
@@ -0,0 +1,48 @@
|
|
|
1
|
+
[](https://badge.fury.io/rb/ruby-curl)
|
|
2
|
+
|
|
3
|
+
|
|
4
|
+
# Introduction
|
|
5
|
+
|
|
6
|
+
Ruby-curl aims to be a true libcurl binding for Ruby. Currently, ruby-curl offers full support for the HTTP protocol over libcurl’s easy interface. Just like libcurl, when using ruby-curl you init your easy-session and get a handle, which you use as input to the following interface functions you use.
|
|
7
|
+
|
|
8
|
+
|
|
9
|
+
|
|
10
|
+
# Requirements
|
|
11
|
+
|
|
12
|
+
```
|
|
13
|
+
Ruby 1.9.3 or higher
|
|
14
|
+
|
|
15
|
+
Libcurl 7.19.0 or higher
|
|
16
|
+
```
|
|
17
|
+
|
|
18
|
+
|
|
19
|
+
# Installation
|
|
20
|
+
|
|
21
|
+
Bundler:
|
|
22
|
+
```
|
|
23
|
+
Gem ‘ruby-curl’
|
|
24
|
+
```
|
|
25
|
+
|
|
26
|
+
Manual:
|
|
27
|
+
```
|
|
28
|
+
Gem install ruby-curl
|
|
29
|
+
```
|
|
30
|
+
|
|
31
|
+
|
|
32
|
+
|
|
33
|
+
# Usage:
|
|
34
|
+
|
|
35
|
+
```
|
|
36
|
+
require 'ruby-curl'
|
|
37
|
+
|
|
38
|
+
curl = Curl::Easy.new
|
|
39
|
+
curl.setopt(Curl::Opt::URL, "https://example.com")
|
|
40
|
+
|
|
41
|
+
res = curl.perform
|
|
42
|
+
# <!doctype html>...
|
|
43
|
+
|
|
44
|
+
res
|
|
45
|
+
# => 0 # CURLE_OK
|
|
46
|
+
|
|
47
|
+
curl.cleanup
|
|
48
|
+
```
|
data/ext/curl.c
ADDED
|
@@ -0,0 +1,394 @@
|
|
|
1
|
+
#include "curl.h"
|
|
2
|
+
|
|
3
|
+
VALUE rb_mCurl;
|
|
4
|
+
|
|
5
|
+
void Init_curl() {
|
|
6
|
+
VALUE rb_mOpt, rb_mInfo, rb_mProxy, rb_mAuth, rb_mProto, rb_mError;
|
|
7
|
+
|
|
8
|
+
rb_mCurl = rb_define_module("Curl");
|
|
9
|
+
rb_mOpt = rb_define_module_under(rb_mCurl, "Opt");
|
|
10
|
+
rb_mInfo = rb_define_module_under(rb_mCurl, "Info");
|
|
11
|
+
rb_mProxy = rb_define_module_under(rb_mCurl, "Proxy");
|
|
12
|
+
rb_mAuth = rb_define_module_under(rb_mCurl, "Auth");
|
|
13
|
+
rb_mProto = rb_define_module_under(rb_mCurl, "Proto");
|
|
14
|
+
rb_mError = rb_define_module_under(rb_mCurl, "Error");
|
|
15
|
+
|
|
16
|
+
curl_global_init(CURL_GLOBAL_ALL);
|
|
17
|
+
|
|
18
|
+
/* Curl constants */
|
|
19
|
+
RB_DEFINE_M_CURL_CONST("HTTP_VERSION_NONE", CURL_HTTP_VERSION_NONE);
|
|
20
|
+
RB_DEFINE_M_CURL_CONST("HTTP_VERSION_1_0", CURL_HTTP_VERSION_1_0);
|
|
21
|
+
RB_DEFINE_M_CURL_CONST("HTTP_VERSION_1_1", CURL_HTTP_VERSION_1_1);
|
|
22
|
+
#if LIBCURL_VERSION_NUM >= 0x072100 /* Available since 7.33.0 */
|
|
23
|
+
RB_DEFINE_M_CURL_CONST("HTTP_VERSION_2_0", CURL_HTTP_VERSION_2_0);
|
|
24
|
+
#endif
|
|
25
|
+
#if LIBCURL_VERSION_NUM >= 0x072f00 /* Available since 7.47.0 */
|
|
26
|
+
RB_DEFINE_M_CURL_CONST("HTTP_VERSION_2TLS", CURL_HTTP_VERSION_2TLS);
|
|
27
|
+
#endif
|
|
28
|
+
#if LIBCURL_VERSION_NUM >= 0x073100 /* Available since 7.49.0 */
|
|
29
|
+
RB_DEFINE_M_CURL_CONST("HTTP_VERSION_2_PRIOR_KNOWLEDGE", CURL_HTTP_VERSION_2_PRIOR_KNOWLEDGE);
|
|
30
|
+
#endif
|
|
31
|
+
RB_DEFINE_M_CURL_CONST("SSLVERSION_DEFAULT", CURL_SSLVERSION_DEFAULT);
|
|
32
|
+
RB_DEFINE_M_CURL_CONST("SSLVERSION_TLSv1", CURL_SSLVERSION_TLSv1);
|
|
33
|
+
RB_DEFINE_M_CURL_CONST("SSLVERSION_SSLv2", CURL_SSLVERSION_SSLv2);
|
|
34
|
+
RB_DEFINE_M_CURL_CONST("SSLVERSION_SSLv3", CURL_SSLVERSION_SSLv3);
|
|
35
|
+
#if LIBCURL_VERSION_NUM >= 0x072200 /* Available since 7.34.0 */
|
|
36
|
+
RB_DEFINE_M_CURL_CONST("SSLVERSION_TLSv1_0", CURL_SSLVERSION_TLSv1_0);
|
|
37
|
+
RB_DEFINE_M_CURL_CONST("SSLVERSION_TLSv1_1", CURL_SSLVERSION_TLSv1_1);
|
|
38
|
+
RB_DEFINE_M_CURL_CONST("SSLVERSION_TLSv1_2", CURL_SSLVERSION_TLSv1_2);
|
|
39
|
+
#endif
|
|
40
|
+
RB_DEFINE_M_CURL_CONST("SSLVERSION_TLSv1_3", CURL_SSLVERSION_TLSv1_3);
|
|
41
|
+
RB_DEFINE_M_CURL_CONST("SSLVERSION_MAX_DEFAULT", CURL_SSLVERSION_MAX_DEFAULT);
|
|
42
|
+
RB_DEFINE_M_CURL_CONST("SSLVERSION_MAX_TLSv1_0", CURL_SSLVERSION_MAX_TLSv1_0);
|
|
43
|
+
RB_DEFINE_M_CURL_CONST("SSLVERSION_MAX_TLSv1_1", CURL_SSLVERSION_MAX_TLSv1_1);
|
|
44
|
+
RB_DEFINE_M_CURL_CONST("SSLVERSION_MAX_TLSv1_2", CURL_SSLVERSION_MAX_TLSv1_2);
|
|
45
|
+
RB_DEFINE_M_CURL_CONST("SSLVERSION_MAX_TLSv1_3", CURL_SSLVERSION_MAX_TLSv1_3);
|
|
46
|
+
RB_DEFINE_M_CURL_CONST("TIMECOND_IFMODSINCE", CURL_TIMECOND_IFMODSINCE);
|
|
47
|
+
RB_DEFINE_M_CURL_CONST("TIMECOND_IFUNMODSINCE", CURL_TIMECOND_IFUNMODSINCE);
|
|
48
|
+
RB_DEFINE_M_CURL_CONST("TIMECOND_LASTMOD", CURL_TIMECOND_LASTMOD);
|
|
49
|
+
RB_DEFINE_M_CURL_CONST("TIMECOND_NONE", CURL_TIMECOND_NONE);
|
|
50
|
+
RB_DEFINE_M_CURL_CONST("NETRC_OPTIONAL", CURL_NETRC_OPTIONAL);
|
|
51
|
+
RB_DEFINE_M_CURL_CONST("NETRC_IGNORED", CURL_NETRC_IGNORED);
|
|
52
|
+
RB_DEFINE_M_CURL_CONST("NETRC_REQUIRED", CURL_NETRC_REQUIRED);
|
|
53
|
+
#if LIBCURL_VERSION_NUM >= 0x071301 /* Available since 7.19.1 */
|
|
54
|
+
RB_DEFINE_M_CURL_CONST("REDIR_POST_301", CURL_REDIR_POST_301);
|
|
55
|
+
RB_DEFINE_M_CURL_CONST("REDIR_POST_302", CURL_REDIR_POST_302);
|
|
56
|
+
RB_DEFINE_M_CURL_CONST("REDIR_POST_ALL", CURL_REDIR_POST_ALL);
|
|
57
|
+
#endif
|
|
58
|
+
#if LIBCURL_VERSION_NUM >= 0x071901 /* Available since 7.25.1 */
|
|
59
|
+
RB_DEFINE_M_CURL_CONST("REDIR_POST_303", CURL_REDIR_POST_303);
|
|
60
|
+
#endif
|
|
61
|
+
#if LIBCURL_VERSION_NUM >= 0x070a08 /* Available since 7.10.8 */
|
|
62
|
+
RB_DEFINE_M_CURL_CONST("IPRESOLVE_WHATEVER", CURL_IPRESOLVE_WHATEVER);
|
|
63
|
+
RB_DEFINE_M_CURL_CONST("IPRESOLVE_V4", CURL_IPRESOLVE_V4);
|
|
64
|
+
RB_DEFINE_M_CURL_CONST("IPRESOLVE_V6", CURL_IPRESOLVE_V6);
|
|
65
|
+
#endif
|
|
66
|
+
|
|
67
|
+
/* Curl::Opt constants */
|
|
68
|
+
RB_DEFINE_M_OPT_CONST("URL", CURLOPT_URL);
|
|
69
|
+
RB_DEFINE_M_OPT_CONST("POST", CURLOPT_POST);
|
|
70
|
+
RB_DEFINE_M_OPT_CONST("TIMEOUT", CURLOPT_TIMEOUT);
|
|
71
|
+
RB_DEFINE_M_OPT_CONST("WRITEFUNCTION", CURLOPT_WRITEFUNCTION);
|
|
72
|
+
RB_DEFINE_M_OPT_CONST("WRITEDATA", CURLOPT_WRITEDATA);
|
|
73
|
+
RB_DEFINE_M_OPT_CONST("HEADERFUNCTION", CURLOPT_HEADERFUNCTION);
|
|
74
|
+
RB_DEFINE_M_OPT_CONST("HEADERDATA", CURLOPT_HEADERDATA);
|
|
75
|
+
RB_DEFINE_M_OPT_CONST("READFUNCTION", CURLOPT_READFUNCTION);
|
|
76
|
+
RB_DEFINE_M_OPT_CONST("READDATA", CURLOPT_READDATA);
|
|
77
|
+
RB_DEFINE_M_OPT_CONST("FOLLOWLOCATION", CURLOPT_FOLLOWLOCATION);
|
|
78
|
+
RB_DEFINE_M_OPT_CONST("MAXREDIRS", CURLOPT_MAXREDIRS);
|
|
79
|
+
RB_DEFINE_M_OPT_CONST("PUT", CURLOPT_PUT);
|
|
80
|
+
RB_DEFINE_M_OPT_CONST("HTTPGET", CURLOPT_HTTPGET);
|
|
81
|
+
RB_DEFINE_M_OPT_CONST("UPLOAD", CURLOPT_UPLOAD);
|
|
82
|
+
RB_DEFINE_M_OPT_CONST("VERBOSE", CURLOPT_VERBOSE);
|
|
83
|
+
RB_DEFINE_M_OPT_CONST("POSTFIELDS", CURLOPT_POSTFIELDS);
|
|
84
|
+
RB_DEFINE_M_OPT_CONST("USERAGENT", CURLOPT_USERAGENT);
|
|
85
|
+
RB_DEFINE_M_OPT_CONST("USERPWD", CURLOPT_USERPWD);
|
|
86
|
+
#if LIBCURL_VERSION_NUM >= 0x070b00 /* Available since 7.11.0 */
|
|
87
|
+
RB_DEFINE_M_OPT_CONST("NETRC_FILE", CURLOPT_NETRC_FILE);
|
|
88
|
+
#endif
|
|
89
|
+
#if LIBCURL_VERSION_NUM >= 0x070b02 /* Available since 7.11.2 */
|
|
90
|
+
RB_DEFINE_M_OPT_CONST("TCP_NODELAY", CURLOPT_TCP_NODELAY);
|
|
91
|
+
#endif
|
|
92
|
+
#if LIBCURL_VERSION_NUM >= 0x070e01 /* Available since 7.14.1 */
|
|
93
|
+
RB_DEFINE_M_OPT_CONST("COOKIELIST", CURLOPT_COOKIELIST);
|
|
94
|
+
RB_DEFINE_M_OPT_CONST("IGNORE_CONTENT_LENGTH", CURLOPT_IGNORE_CONTENT_LENGTH);
|
|
95
|
+
#endif
|
|
96
|
+
#if LIBCURL_VERSION_NUM >= 0x070f02 /* Available since 7.15.2 */
|
|
97
|
+
RB_DEFINE_M_OPT_CONST("CONNECT_ONLY", CURLOPT_CONNECT_ONLY);
|
|
98
|
+
RB_DEFINE_M_OPT_CONST("LOCALPORT", CURLOPT_LOCALPORT);
|
|
99
|
+
#endif
|
|
100
|
+
#if LIBCURL_VERSION_NUM >= 0x070f05 /* Available since 7.15.5 */
|
|
101
|
+
RB_DEFINE_M_OPT_CONST("MAX_RECV_SPEED_LARGE", CURLOPT_MAX_RECV_SPEED_LARGE);
|
|
102
|
+
RB_DEFINE_M_OPT_CONST("MAX_SEND_SPEED_LARGE", CURLOPT_MAX_SEND_SPEED_LARGE);
|
|
103
|
+
#endif
|
|
104
|
+
#if LIBCURL_VERSION_NUM >= 0x071000 /* Available since 7.16.0 */
|
|
105
|
+
RB_DEFINE_M_OPT_CONST("SSL_SESSIONID_CACHE", CURLOPT_SSL_SESSIONID_CACHE);
|
|
106
|
+
#endif
|
|
107
|
+
#if LIBCURL_VERSION_NUM >= 0x071002 /* Available since 7.16.2 */
|
|
108
|
+
RB_DEFINE_M_OPT_CONST("CONNECTTIMEOUT_MS", CURLOPT_CONNECTTIMEOUT_MS);
|
|
109
|
+
RB_DEFINE_M_OPT_CONST("HTTP_CONTENT_DECODING", CURLOPT_HTTP_CONTENT_DECODING);
|
|
110
|
+
RB_DEFINE_M_OPT_CONST("HTTP_TRANSFER_DECODING", CURLOPT_HTTP_TRANSFER_DECODING);
|
|
111
|
+
RB_DEFINE_M_OPT_CONST("TIMEOUT_MS", CURLOPT_TIMEOUT_MS);
|
|
112
|
+
#endif
|
|
113
|
+
#if LIBCURL_VERSION_NUM >= 0x071004 /* Available since 7.16.4 */
|
|
114
|
+
RB_DEFINE_M_OPT_CONST("KRBLEVEL", CURLOPT_KRBLEVEL);
|
|
115
|
+
#endif
|
|
116
|
+
#if LIBCURL_VERSION_NUM >= 0x071300 /* Available since 7.19.0 */
|
|
117
|
+
RB_DEFINE_M_OPT_CONST("ADDRESS_SCOPE", CURLOPT_ADDRESS_SCOPE);
|
|
118
|
+
RB_DEFINE_M_OPT_CONST("CRLFILE", CURLOPT_CRLFILE);
|
|
119
|
+
RB_DEFINE_M_OPT_CONST("ISSUERCERT", CURLOPT_ISSUERCERT);
|
|
120
|
+
RB_DEFINE_M_OPT_CONST("KEYPASSWD", CURLOPT_KEYPASSWD);
|
|
121
|
+
#endif
|
|
122
|
+
#if LIBCURL_VERSION_NUM >= 0x071301 /* Available since 7.19.1 */
|
|
123
|
+
RB_DEFINE_M_OPT_CONST("CERTINFO", CURLOPT_CERTINFO);
|
|
124
|
+
RB_DEFINE_M_OPT_CONST("PASSWORD", CURLOPT_PASSWORD);
|
|
125
|
+
RB_DEFINE_M_OPT_CONST("POSTREDIR", CURLOPT_POSTREDIR);
|
|
126
|
+
RB_DEFINE_M_OPT_CONST("USERNAME", CURLOPT_USERNAME);
|
|
127
|
+
#endif
|
|
128
|
+
#if LIBCURL_VERSION_NUM >= 0x071304 /* Available since 7.19.4 */
|
|
129
|
+
RB_DEFINE_M_OPT_CONST("NOPROXY", CURLOPT_NOPROXY);
|
|
130
|
+
RB_DEFINE_M_OPT_CONST("PROTOCOLS", CURLOPT_PROTOCOLS);
|
|
131
|
+
RB_DEFINE_M_OPT_CONST("REDIR_PROTOCOLS", CURLOPT_REDIR_PROTOCOLS);
|
|
132
|
+
RB_DEFINE_M_OPT_CONST("SOCKS5_GSSAPI_NEC", CURLOPT_SOCKS5_GSSAPI_NEC);
|
|
133
|
+
RB_DEFINE_M_OPT_CONST("SOCKS5_GSSAPI_SERVICE", CURLOPT_SOCKS5_GSSAPI_SERVICE);
|
|
134
|
+
#endif
|
|
135
|
+
#if LIBCURL_VERSION_NUM >= 0x071504 /* Available since 7.21.4 */
|
|
136
|
+
RB_DEFINE_M_OPT_CONST("TLSAUTH_PASSWORD", CURLOPT_TLSAUTH_PASSWORD);
|
|
137
|
+
RB_DEFINE_M_OPT_CONST("TLSAUTH_TYPE", CURLOPT_TLSAUTH_TYPE);
|
|
138
|
+
#endif
|
|
139
|
+
#if LIBCURL_VERSION_NUM >= 0x071600 /* Available since 7.22.0 */
|
|
140
|
+
RB_DEFINE_M_OPT_CONST("GSSAPI_DELEGATION", CURLOPT_GSSAPI_DELEGATION);
|
|
141
|
+
#endif
|
|
142
|
+
#if LIBCURL_VERSION_NUM >= 0x072800 /* Available since 7.40.0 */
|
|
143
|
+
RB_DEFINE_M_OPT_CONST("UNIX_SOCKET_PATH", CURLOPT_UNIX_SOCKET_PATH);
|
|
144
|
+
#endif
|
|
145
|
+
#if LIBCURL_VERSION_NUM >= 0x072a00 /* Available since 7.42.0 */
|
|
146
|
+
RB_DEFINE_M_OPT_CONST("PATH_AS_IS", CURLOPT_PATH_AS_IS);
|
|
147
|
+
#endif
|
|
148
|
+
#if LIBCURL_VERSION_NUM >= 0x072b00 /* Available since 7.43.0 */
|
|
149
|
+
RB_DEFINE_M_OPT_CONST("PIPEWAIT", CURLOPT_PIPEWAIT);
|
|
150
|
+
#endif
|
|
151
|
+
#if LIBCURL_VERSION_NUM >= 0x070a06 /* Available since 7.10.6 */
|
|
152
|
+
RB_DEFINE_M_OPT_CONST("HTTPAUTH", CURLOPT_HTTPAUTH);
|
|
153
|
+
#endif
|
|
154
|
+
#if LIBCURL_VERSION_NUM >= 0x070a07 /* Available since 7.10.7 */
|
|
155
|
+
RB_DEFINE_M_OPT_CONST("PROXYAUTH", CURLOPT_PROXYAUTH);
|
|
156
|
+
#endif
|
|
157
|
+
#if LIBCURL_VERSION_NUM >= 0x070a08 /* Available since 7.10.8 */
|
|
158
|
+
RB_DEFINE_M_OPT_CONST("IPRESOLVE", CURLOPT_IPRESOLVE);
|
|
159
|
+
RB_DEFINE_M_OPT_CONST("MAXFILESIZE", CURLOPT_MAXFILESIZE);
|
|
160
|
+
#endif
|
|
161
|
+
RB_DEFINE_M_OPT_CONST("AUTOREFERER", CURLOPT_AUTOREFERER);
|
|
162
|
+
RB_DEFINE_M_OPT_CONST("BUFFERSIZE", CURLOPT_BUFFERSIZE);
|
|
163
|
+
RB_DEFINE_M_OPT_CONST("CAINFO", CURLOPT_CAINFO);
|
|
164
|
+
RB_DEFINE_M_OPT_CONST("CAPATH", CURLOPT_CAPATH);
|
|
165
|
+
RB_DEFINE_M_OPT_CONST("CONNECTTIMEOUT", CURLOPT_CONNECTTIMEOUT);
|
|
166
|
+
RB_DEFINE_M_OPT_CONST("COOKIE", CURLOPT_COOKIE);
|
|
167
|
+
RB_DEFINE_M_OPT_CONST("COOKIEFILE", CURLOPT_COOKIEFILE);
|
|
168
|
+
RB_DEFINE_M_OPT_CONST("COOKIEJAR", CURLOPT_COOKIEJAR);
|
|
169
|
+
RB_DEFINE_M_OPT_CONST("COOKIESESSION", CURLOPT_COOKIESESSION);
|
|
170
|
+
RB_DEFINE_M_OPT_CONST("CRLF", CURLOPT_CRLF);
|
|
171
|
+
RB_DEFINE_M_OPT_CONST("CUSTOMREQUEST", CURLOPT_CUSTOMREQUEST);
|
|
172
|
+
RB_DEFINE_M_OPT_CONST("DNS_CACHE_TIMEOUT", CURLOPT_DNS_CACHE_TIMEOUT);
|
|
173
|
+
RB_DEFINE_M_OPT_CONST("DNS_USE_GLOBAL_CACHE", CURLOPT_DNS_USE_GLOBAL_CACHE);
|
|
174
|
+
RB_DEFINE_M_OPT_CONST("EGDSOCKET", CURLOPT_EGDSOCKET);
|
|
175
|
+
RB_DEFINE_M_OPT_CONST("ENCODING", CURLOPT_ENCODING);
|
|
176
|
+
RB_DEFINE_M_OPT_CONST("FAILONERROR", CURLOPT_FAILONERROR);
|
|
177
|
+
RB_DEFINE_M_OPT_CONST("FILETIME", CURLOPT_FILETIME);
|
|
178
|
+
RB_DEFINE_M_OPT_CONST("FORBID_REUSE", CURLOPT_FORBID_REUSE);
|
|
179
|
+
RB_DEFINE_M_OPT_CONST("FRESH_CONNECT", CURLOPT_FRESH_CONNECT);
|
|
180
|
+
RB_DEFINE_M_OPT_CONST("HEADER", CURLOPT_HEADER);
|
|
181
|
+
RB_DEFINE_M_OPT_CONST("HTTP200ALIASES", CURLOPT_HTTP200ALIASES);
|
|
182
|
+
RB_DEFINE_M_OPT_CONST("HTTPHEADER", CURLOPT_HTTPHEADER);
|
|
183
|
+
RB_DEFINE_M_OPT_CONST("HTTPPROXYTUNNEL", CURLOPT_HTTPPROXYTUNNEL);
|
|
184
|
+
RB_DEFINE_M_OPT_CONST("HTTP_VERSION", CURLOPT_HTTP_VERSION);
|
|
185
|
+
RB_DEFINE_M_OPT_CONST("INFILESIZE", CURLOPT_INFILESIZE);
|
|
186
|
+
RB_DEFINE_M_OPT_CONST("INTERFACE", CURLOPT_INTERFACE);
|
|
187
|
+
RB_DEFINE_M_OPT_CONST("LOW_SPEED_LIMIT", CURLOPT_LOW_SPEED_LIMIT);
|
|
188
|
+
RB_DEFINE_M_OPT_CONST("LOW_SPEED_TIME", CURLOPT_LOW_SPEED_TIME);
|
|
189
|
+
RB_DEFINE_M_OPT_CONST("MAXCONNECTS", CURLOPT_MAXCONNECTS);
|
|
190
|
+
RB_DEFINE_M_OPT_CONST("NETRC", CURLOPT_NETRC);
|
|
191
|
+
RB_DEFINE_M_OPT_CONST("NOBODY", CURLOPT_NOBODY);
|
|
192
|
+
RB_DEFINE_M_OPT_CONST("NOPROGRESS", CURLOPT_NOPROGRESS);
|
|
193
|
+
RB_DEFINE_M_OPT_CONST("NOSIGNAL", CURLOPT_NOSIGNAL);
|
|
194
|
+
RB_DEFINE_M_OPT_CONST("PORT", CURLOPT_PORT);
|
|
195
|
+
RB_DEFINE_M_OPT_CONST("PRIVATE", CURLOPT_PRIVATE);
|
|
196
|
+
RB_DEFINE_M_OPT_CONST("PROXY", CURLOPT_PROXY);
|
|
197
|
+
RB_DEFINE_M_OPT_CONST("PROXYPORT", CURLOPT_PROXYPORT);
|
|
198
|
+
RB_DEFINE_M_OPT_CONST("PROXYTYPE", CURLOPT_PROXYTYPE);
|
|
199
|
+
RB_DEFINE_M_OPT_CONST("PROXYUSERPWD", CURLOPT_PROXYUSERPWD);
|
|
200
|
+
RB_DEFINE_M_OPT_CONST("RANDOM_FILE", CURLOPT_RANDOM_FILE);
|
|
201
|
+
RB_DEFINE_M_OPT_CONST("RANGE", CURLOPT_RANGE);
|
|
202
|
+
RB_DEFINE_M_OPT_CONST("REFERER", CURLOPT_REFERER);
|
|
203
|
+
RB_DEFINE_M_OPT_CONST("RESUME_FROM", CURLOPT_RESUME_FROM);
|
|
204
|
+
RB_DEFINE_M_OPT_CONST("SSLCERT", CURLOPT_SSLCERT);
|
|
205
|
+
RB_DEFINE_M_OPT_CONST("SSLCERTTYPE", CURLOPT_SSLCERTTYPE);
|
|
206
|
+
RB_DEFINE_M_OPT_CONST("SSLENGINE", CURLOPT_SSLENGINE);
|
|
207
|
+
RB_DEFINE_M_OPT_CONST("SSLENGINE_DEFAULT", CURLOPT_SSLENGINE_DEFAULT);
|
|
208
|
+
RB_DEFINE_M_OPT_CONST("SSLKEY", CURLOPT_SSLKEY);
|
|
209
|
+
RB_DEFINE_M_OPT_CONST("SSLKEYTYPE", CURLOPT_SSLKEYTYPE);
|
|
210
|
+
RB_DEFINE_M_OPT_CONST("SSLVERSION", CURLOPT_SSLVERSION);
|
|
211
|
+
RB_DEFINE_M_OPT_CONST("SSL_CIPHER_LIST", CURLOPT_SSL_CIPHER_LIST);
|
|
212
|
+
RB_DEFINE_M_OPT_CONST("SSL_VERIFYHOST", CURLOPT_SSL_VERIFYHOST);
|
|
213
|
+
RB_DEFINE_M_OPT_CONST("SSL_VERIFYPEER", CURLOPT_SSL_VERIFYPEER);
|
|
214
|
+
RB_DEFINE_M_OPT_CONST("TIMECONDITION", CURLOPT_TIMECONDITION);
|
|
215
|
+
RB_DEFINE_M_OPT_CONST("TIMEVALUE", CURLOPT_TIMEVALUE);
|
|
216
|
+
RB_DEFINE_M_OPT_CONST("TRANSFERTEXT", CURLOPT_TRANSFERTEXT);
|
|
217
|
+
RB_DEFINE_M_OPT_CONST("UNRESTRICTED_AUTH", CURLOPT_UNRESTRICTED_AUTH);
|
|
218
|
+
#if LIBCURL_VERSION_NUM >= 0x071503 /* Available since 7.21.3 */
|
|
219
|
+
RB_DEFINE_M_OPT_CONST("RESOLVE", CURLOPT_RESOLVE);
|
|
220
|
+
#endif
|
|
221
|
+
#if LIBCURL_VERSION_NUM >= 0x072500 /* Available since 7.37.0 */
|
|
222
|
+
RB_DEFINE_M_OPT_CONST("PROXYHEADER", CURLOPT_PROXYHEADER);
|
|
223
|
+
#endif
|
|
224
|
+
|
|
225
|
+
/* Curl::Info constants */
|
|
226
|
+
RB_DEFINE_M_INFO_CONST("EFFECTIVE_URL", CURLINFO_EFFECTIVE_URL);
|
|
227
|
+
RB_DEFINE_M_INFO_CONST("FILETIME", CURLINFO_FILETIME);
|
|
228
|
+
RB_DEFINE_M_INFO_CONST("TOTAL_TIME", CURLINFO_TOTAL_TIME);
|
|
229
|
+
RB_DEFINE_M_INFO_CONST("NAMELOOKUP_TIME", CURLINFO_NAMELOOKUP_TIME);
|
|
230
|
+
RB_DEFINE_M_INFO_CONST("CONNECT_TIME", CURLINFO_CONNECT_TIME);
|
|
231
|
+
RB_DEFINE_M_INFO_CONST("PRETRANSFER_TIME", CURLINFO_PRETRANSFER_TIME);
|
|
232
|
+
RB_DEFINE_M_INFO_CONST("STARTTRANSFER_TIME", CURLINFO_STARTTRANSFER_TIME);
|
|
233
|
+
RB_DEFINE_M_INFO_CONST("REDIRECT_TIME", CURLINFO_REDIRECT_TIME);
|
|
234
|
+
RB_DEFINE_M_INFO_CONST("REDIRECT_COUNT", CURLINFO_REDIRECT_COUNT);
|
|
235
|
+
RB_DEFINE_M_INFO_CONST("SIZE_UPLOAD", CURLINFO_SIZE_UPLOAD);
|
|
236
|
+
RB_DEFINE_M_INFO_CONST("SIZE_DOWNLOAD", CURLINFO_SIZE_DOWNLOAD);
|
|
237
|
+
RB_DEFINE_M_INFO_CONST("SPEED_UPLOAD", CURLINFO_SPEED_UPLOAD);
|
|
238
|
+
RB_DEFINE_M_INFO_CONST("SPEED_DOWNLOAD", CURLINFO_SPEED_DOWNLOAD);
|
|
239
|
+
RB_DEFINE_M_INFO_CONST("HEADER_SIZE", CURLINFO_HEADER_SIZE);
|
|
240
|
+
RB_DEFINE_M_INFO_CONST("REQUEST_SIZE", CURLINFO_REQUEST_SIZE);
|
|
241
|
+
RB_DEFINE_M_INFO_CONST("SSL_VERIFYRESULT", CURLINFO_SSL_VERIFYRESULT);
|
|
242
|
+
RB_DEFINE_M_INFO_CONST("CONTENT_TYPE", CURLINFO_CONTENT_TYPE);
|
|
243
|
+
RB_DEFINE_M_INFO_CONST("LASTSOCKET", CURLINFO_LASTSOCKET);
|
|
244
|
+
RB_DEFINE_M_INFO_CONST("CONTENT_LENGTH_DOWNLOAD", CURLINFO_CONTENT_LENGTH_DOWNLOAD);
|
|
245
|
+
RB_DEFINE_M_INFO_CONST("CONTENT_LENGTH_UPLOAD", CURLINFO_CONTENT_LENGTH_UPLOAD);
|
|
246
|
+
/* Curl::Info constants (Available since 7.10.7) */
|
|
247
|
+
RB_DEFINE_M_INFO_CONST("HTTP_CONNECTCODE", CURLINFO_HTTP_CONNECTCODE);
|
|
248
|
+
/* Curl::Info constants (Available since 7.10.8) */
|
|
249
|
+
RB_DEFINE_M_INFO_CONST("HTTPAUTH_AVAIL", CURLINFO_HTTPAUTH_AVAIL);
|
|
250
|
+
RB_DEFINE_M_INFO_CONST("RESPONSE_CODE", CURLINFO_RESPONSE_CODE);
|
|
251
|
+
RB_DEFINE_M_INFO_CONST("PROXYAUTH_AVAIL", CURLINFO_PROXYAUTH_AVAIL);
|
|
252
|
+
/* Curl::Info constants (Available since 7.12.2) */
|
|
253
|
+
RB_DEFINE_M_INFO_CONST("OS_ERRNO", CURLINFO_OS_ERRNO);
|
|
254
|
+
/* Curl::Info constants (Available since 7.12.3) */
|
|
255
|
+
RB_DEFINE_M_INFO_CONST("NUM_CONNECTS", CURLINFO_NUM_CONNECTS);
|
|
256
|
+
RB_DEFINE_M_INFO_CONST("SSL_ENGINES", CURLINFO_SSL_ENGINES);
|
|
257
|
+
/* Curl::Info constants (Available since 7.14.1) */
|
|
258
|
+
RB_DEFINE_M_INFO_CONST("COOKIELIST", CURLINFO_COOKIELIST);
|
|
259
|
+
#if LIBCURL_VERSION_NUM >= 0x071202 /* Curl::Info constants (Available since 7.18.2) */
|
|
260
|
+
RB_DEFINE_M_INFO_CONST("REDIRECT_URL", CURLINFO_REDIRECT_URL);
|
|
261
|
+
#endif
|
|
262
|
+
#if LIBCURL_VERSION_NUM >= 0x071300 /* Curl::Info constants (Available since 7.19.0) */
|
|
263
|
+
RB_DEFINE_M_INFO_CONST("PRIMARY_IP", CURLINFO_PRIMARY_IP);
|
|
264
|
+
#endif
|
|
265
|
+
#if LIBCURL_VERSION_NUM >= 0x071301 /* Curl::Info constants (Available since 7.19.1) */
|
|
266
|
+
RB_DEFINE_M_INFO_CONST("CERTINFO", CURLINFO_CERTINFO);
|
|
267
|
+
#endif
|
|
268
|
+
#if LIBCURL_VERSION_NUM >= 0x071500 /* Curl::Info constants (Available since 7.21.0) */
|
|
269
|
+
RB_DEFINE_M_INFO_CONST("LOCAL_IP", CURLINFO_LOCAL_IP);
|
|
270
|
+
RB_DEFINE_M_INFO_CONST("LOCAL_PORT", CURLINFO_LOCAL_PORT);
|
|
271
|
+
RB_DEFINE_M_INFO_CONST("PRIMARY_PORT", CURLINFO_PRIMARY_PORT);
|
|
272
|
+
#endif
|
|
273
|
+
#if LIBCURL_VERSION_NUM >= 0x073200 /* Curl::Info constants (Available since 7.50.0) */
|
|
274
|
+
RB_DEFINE_M_INFO_CONST("HTTP_VERSION", CURLINFO_HTTP_VERSION);
|
|
275
|
+
#endif
|
|
276
|
+
#if LIBCURL_VERSION_NUM >= 0x073400 /* Curl::Info constants (Available since 7.52.0) */
|
|
277
|
+
RB_DEFINE_M_INFO_CONST("PROTOCOL", CURLINFO_PROTOCOL);
|
|
278
|
+
RB_DEFINE_M_INFO_CONST("PROXY_SSL_VERIFYRESULT", CURLINFO_PROXY_SSL_VERIFYRESULT);
|
|
279
|
+
RB_DEFINE_M_INFO_CONST("SCHEME", CURLINFO_SCHEME);
|
|
280
|
+
#endif
|
|
281
|
+
|
|
282
|
+
/* Curl::Auth constants */
|
|
283
|
+
#if LIBCURL_VERSION_NUM >= 0x071303 /* Available since 7.19.3 */
|
|
284
|
+
RB_DEFINE_M_AUTH_CONST("DIGEST_IE", CURLAUTH_DIGEST_IE);
|
|
285
|
+
#endif
|
|
286
|
+
#if LIBCURL_VERSION_NUM >= 0x073d00 /* Available since 7.61.0 */
|
|
287
|
+
RB_DEFINE_M_AUTH_CONST("BEARER", CURLAUTH_BEARER);
|
|
288
|
+
#endif
|
|
289
|
+
#if LIBCURL_VERSION_NUM >= 0x072600 /* Available since 7.38.0 */
|
|
290
|
+
RB_DEFINE_M_AUTH_CONST("NEGOTIATE", CURLAUTH_NEGOTIATE);
|
|
291
|
+
#endif
|
|
292
|
+
#if LIBCURL_VERSION_NUM >= 0x071600 /* Available since 7.22.0 */
|
|
293
|
+
RB_DEFINE_M_AUTH_CONST("NTLM_WB", CURLAUTH_NTLM_WB);
|
|
294
|
+
#endif
|
|
295
|
+
#if LIBCURL_VERSION_NUM >= 0x070a06 /* Available since 7.10.6 */
|
|
296
|
+
RB_DEFINE_M_AUTH_CONST("ANY", CURLAUTH_ANY);
|
|
297
|
+
RB_DEFINE_M_AUTH_CONST("ANYSAFE", CURLAUTH_ANYSAFE);
|
|
298
|
+
RB_DEFINE_M_AUTH_CONST("BASIC", CURLAUTH_BASIC);
|
|
299
|
+
RB_DEFINE_M_AUTH_CONST("DIGEST", CURLAUTH_DIGEST);
|
|
300
|
+
RB_DEFINE_M_AUTH_CONST("NTLM", CURLAUTH_NTLM);
|
|
301
|
+
#endif
|
|
302
|
+
#if LIBCURL_VERSION_NUM >= 0x071503 /* Available since 7.21.3 */
|
|
303
|
+
RB_DEFINE_M_AUTH_CONST("ONLY", CURLAUTH_ONLY);
|
|
304
|
+
#endif
|
|
305
|
+
|
|
306
|
+
/* Curl::Proto constants */
|
|
307
|
+
RB_DEFINE_M_PROTO_CONST("DICT", CURLPROTO_DICT);
|
|
308
|
+
RB_DEFINE_M_PROTO_CONST("FILE", CURLPROTO_FILE);
|
|
309
|
+
RB_DEFINE_M_PROTO_CONST("FTP", CURLPROTO_FTP);
|
|
310
|
+
RB_DEFINE_M_PROTO_CONST("FTPS", CURLPROTO_FTPS);
|
|
311
|
+
RB_DEFINE_M_PROTO_CONST("GOPHER", CURLPROTO_GOPHER);
|
|
312
|
+
RB_DEFINE_M_PROTO_CONST("HTTP", CURLPROTO_HTTP);
|
|
313
|
+
RB_DEFINE_M_PROTO_CONST("HTTPS", CURLPROTO_HTTPS);
|
|
314
|
+
RB_DEFINE_M_PROTO_CONST("IMAP", CURLPROTO_IMAP);
|
|
315
|
+
RB_DEFINE_M_PROTO_CONST("IMAPS", CURLPROTO_IMAPS);
|
|
316
|
+
RB_DEFINE_M_PROTO_CONST("LDAP", CURLPROTO_LDAP);
|
|
317
|
+
RB_DEFINE_M_PROTO_CONST("LDAPS", CURLPROTO_LDAPS);
|
|
318
|
+
RB_DEFINE_M_PROTO_CONST("POP3", CURLPROTO_POP3);
|
|
319
|
+
RB_DEFINE_M_PROTO_CONST("POP3S", CURLPROTO_POP3S);
|
|
320
|
+
RB_DEFINE_M_PROTO_CONST("RTMP", CURLPROTO_RTMP);
|
|
321
|
+
RB_DEFINE_M_PROTO_CONST("RTMPE", CURLPROTO_RTMPE);
|
|
322
|
+
RB_DEFINE_M_PROTO_CONST("RTMPS", CURLPROTO_RTMPS);
|
|
323
|
+
RB_DEFINE_M_PROTO_CONST("RTMPT", CURLPROTO_RTMPT);
|
|
324
|
+
RB_DEFINE_M_PROTO_CONST("RTMPTE", CURLPROTO_RTMPTE);
|
|
325
|
+
RB_DEFINE_M_PROTO_CONST("RTMPTS", CURLPROTO_RTMPTS);
|
|
326
|
+
RB_DEFINE_M_PROTO_CONST("RTSP", CURLPROTO_RTSP);
|
|
327
|
+
RB_DEFINE_M_PROTO_CONST("SCP", CURLPROTO_SCP);
|
|
328
|
+
RB_DEFINE_M_PROTO_CONST("SFTP", CURLPROTO_SFTP);
|
|
329
|
+
RB_DEFINE_M_PROTO_CONST("SMB", CURLPROTO_SMB);
|
|
330
|
+
RB_DEFINE_M_PROTO_CONST("SMBS", CURLPROTO_SMBS);
|
|
331
|
+
RB_DEFINE_M_PROTO_CONST("SMTP", CURLPROTO_SMTP);
|
|
332
|
+
RB_DEFINE_M_PROTO_CONST("SMTPS", CURLPROTO_SMTPS);
|
|
333
|
+
RB_DEFINE_M_PROTO_CONST("TELNET", CURLPROTO_TELNET);
|
|
334
|
+
RB_DEFINE_M_PROTO_CONST("TFTP", CURLPROTO_TFTP);
|
|
335
|
+
|
|
336
|
+
/* Curl::Proxy constants */
|
|
337
|
+
RB_DEFINE_M_PROXY_CONST("HTTP", CURLPROXY_HTTP);
|
|
338
|
+
RB_DEFINE_M_PROXY_CONST("HTTPS", CURLPROXY_HTTPS);
|
|
339
|
+
RB_DEFINE_M_PROXY_CONST("HTTP_1_0", CURLPROXY_HTTP_1_0);
|
|
340
|
+
RB_DEFINE_M_PROXY_CONST("SOCKS4", CURLPROXY_SOCKS4);
|
|
341
|
+
RB_DEFINE_M_PROXY_CONST("SOCKS4A", CURLPROXY_SOCKS4A);
|
|
342
|
+
RB_DEFINE_M_PROXY_CONST("SOCKS5", CURLPROXY_SOCKS5);
|
|
343
|
+
RB_DEFINE_M_PROXY_CONST("SOCKS5_HOSTNAME", CURLPROXY_SOCKS5_HOSTNAME);
|
|
344
|
+
|
|
345
|
+
/* Curl::Error constants */
|
|
346
|
+
RB_DEFINE_M_ERROR_CONST("OK", CURLE_OK);
|
|
347
|
+
RB_DEFINE_M_ERROR_CONST("UNSUPPORTED_PROTOCOL", CURLE_UNSUPPORTED_PROTOCOL);
|
|
348
|
+
RB_DEFINE_M_ERROR_CONST("FAILED_INIT", CURLE_FAILED_INIT);
|
|
349
|
+
RB_DEFINE_M_ERROR_CONST("URL_MALFORMAT", CURLE_URL_MALFORMAT);
|
|
350
|
+
RB_DEFINE_M_ERROR_CONST("NOT_BUILT_IN", CURLE_NOT_BUILT_IN);
|
|
351
|
+
RB_DEFINE_M_ERROR_CONST("COULDNT_RESOLVE_PROXY", CURLE_COULDNT_RESOLVE_PROXY);
|
|
352
|
+
RB_DEFINE_M_ERROR_CONST("COULDNT_RESOLVE_HOST", CURLE_COULDNT_RESOLVE_HOST);
|
|
353
|
+
RB_DEFINE_M_ERROR_CONST("COULDNT_CONNECT", CURLE_COULDNT_CONNECT);
|
|
354
|
+
RB_DEFINE_M_ERROR_CONST("REMOTE_ACCESS_DENIED", CURLE_REMOTE_ACCESS_DENIED);
|
|
355
|
+
RB_DEFINE_M_ERROR_CONST("HTTP2", CURLE_HTTP2);
|
|
356
|
+
RB_DEFINE_M_ERROR_CONST("HTTP_RETURNED_ERROR", CURLE_HTTP_RETURNED_ERROR);
|
|
357
|
+
RB_DEFINE_M_ERROR_CONST("WRITE_ERROR", CURLE_WRITE_ERROR);
|
|
358
|
+
RB_DEFINE_M_ERROR_CONST("UPLOAD_FAILED", CURLE_UPLOAD_FAILED);
|
|
359
|
+
RB_DEFINE_M_ERROR_CONST("READ_ERROR", CURLE_READ_ERROR);
|
|
360
|
+
RB_DEFINE_M_ERROR_CONST("OUT_OF_MEMORY", CURLE_OUT_OF_MEMORY);
|
|
361
|
+
RB_DEFINE_M_ERROR_CONST("OPERATION_TIMEDOUT", CURLE_OPERATION_TIMEDOUT);
|
|
362
|
+
RB_DEFINE_M_ERROR_CONST("RANGE_ERROR", CURLE_RANGE_ERROR);
|
|
363
|
+
RB_DEFINE_M_ERROR_CONST("HTTP_POST_ERROR", CURLE_HTTP_POST_ERROR);
|
|
364
|
+
RB_DEFINE_M_ERROR_CONST("SSL_CONNECT_ERROR", CURLE_SSL_CONNECT_ERROR);
|
|
365
|
+
RB_DEFINE_M_ERROR_CONST("BAD_DOWNLOAD_RESUME", CURLE_BAD_DOWNLOAD_RESUME);
|
|
366
|
+
RB_DEFINE_M_ERROR_CONST("FILE_COULDNT_READ_FILE", CURLE_FILE_COULDNT_READ_FILE);
|
|
367
|
+
RB_DEFINE_M_ERROR_CONST("FUNCTION_NOT_FOUND", CURLE_FUNCTION_NOT_FOUND);
|
|
368
|
+
RB_DEFINE_M_ERROR_CONST("ABORTED_BY_CALLBACK", CURLE_ABORTED_BY_CALLBACK);
|
|
369
|
+
RB_DEFINE_M_ERROR_CONST("BAD_FUNCTION_ARGUMENT", CURLE_BAD_FUNCTION_ARGUMENT);
|
|
370
|
+
RB_DEFINE_M_ERROR_CONST("INTERFACE_FAILED", CURLE_INTERFACE_FAILED);
|
|
371
|
+
RB_DEFINE_M_ERROR_CONST("TOO_MANY_REDIRECTS", CURLE_TOO_MANY_REDIRECTS);
|
|
372
|
+
RB_DEFINE_M_ERROR_CONST("UNKNOWN_OPTION", CURLE_UNKNOWN_OPTION);
|
|
373
|
+
RB_DEFINE_M_ERROR_CONST("GOT_NOTHING", CURLE_GOT_NOTHING);
|
|
374
|
+
RB_DEFINE_M_ERROR_CONST("SSL_ENGINE_NOTFOUND", CURLE_SSL_ENGINE_NOTFOUND);
|
|
375
|
+
RB_DEFINE_M_ERROR_CONST("SSL_ENGINE_SETFAILED", CURLE_SSL_ENGINE_SETFAILED);
|
|
376
|
+
RB_DEFINE_M_ERROR_CONST("SEND_ERROR", CURLE_SEND_ERROR);
|
|
377
|
+
RB_DEFINE_M_ERROR_CONST("RECV_ERROR", CURLE_RECV_ERROR);
|
|
378
|
+
RB_DEFINE_M_ERROR_CONST("SSL_CERTPROBLEM", CURLE_SSL_CERTPROBLEM);
|
|
379
|
+
RB_DEFINE_M_ERROR_CONST("SSL_CIPHER", CURLE_SSL_CIPHER);
|
|
380
|
+
RB_DEFINE_M_ERROR_CONST("PEER_FAILED_VERIFICATION", CURLE_PEER_FAILED_VERIFICATION);
|
|
381
|
+
RB_DEFINE_M_ERROR_CONST("BAD_CONTENT_ENCODING", CURLE_BAD_CONTENT_ENCODING);
|
|
382
|
+
RB_DEFINE_M_ERROR_CONST("FILESIZE_EXCEEDED", CURLE_FILESIZE_EXCEEDED);
|
|
383
|
+
RB_DEFINE_M_ERROR_CONST("SEND_FAIL_REWIND", CURLE_SEND_FAIL_REWIND);
|
|
384
|
+
RB_DEFINE_M_ERROR_CONST("SSL_ENGINE_INITFAILED", CURLE_SSL_ENGINE_INITFAILED);
|
|
385
|
+
RB_DEFINE_M_ERROR_CONST("LOGIN_DENIED", CURLE_LOGIN_DENIED);
|
|
386
|
+
RB_DEFINE_M_ERROR_CONST("SSL_CACERT_BADFILE", CURLE_SSL_CACERT_BADFILE);
|
|
387
|
+
RB_DEFINE_M_ERROR_CONST("AGAIN", CURLE_AGAIN);
|
|
388
|
+
RB_DEFINE_M_ERROR_CONST("SSL_CRL_BADFILE", CURLE_SSL_CRL_BADFILE);
|
|
389
|
+
RB_DEFINE_M_ERROR_CONST("SSL_ISSUER_ERROR", CURLE_SSL_ISSUER_ERROR);
|
|
390
|
+
RB_DEFINE_M_ERROR_CONST("CHUNK_FAILED", CURLE_CHUNK_FAILED);
|
|
391
|
+
RB_DEFINE_M_ERROR_CONST("HTTP2_STREAM", CURLE_HTTP2_STREAM);
|
|
392
|
+
|
|
393
|
+
Init_easy();
|
|
394
|
+
}
|
data/ext/curl.h
ADDED
|
@@ -0,0 +1,34 @@
|
|
|
1
|
+
#ifndef RUBY_CURL_H
|
|
2
|
+
#define RUBY_CURL_H
|
|
3
|
+
|
|
4
|
+
#include <ruby.h>
|
|
5
|
+
#include <curl/curl.h>
|
|
6
|
+
|
|
7
|
+
#include "easy.h"
|
|
8
|
+
|
|
9
|
+
#define RB_DEFINE_M_CURL_CONST(name, curl_const_name) \
|
|
10
|
+
rb_define_const(rb_mCurl, name, LONG2NUM(curl_const_name))
|
|
11
|
+
|
|
12
|
+
#define RB_DEFINE_M_OPT_CONST(name, curl_opt_name) \
|
|
13
|
+
rb_define_const(rb_mOpt, name, LONG2NUM(curl_opt_name))
|
|
14
|
+
|
|
15
|
+
#define RB_DEFINE_M_INFO_CONST(name, curl_info_name) \
|
|
16
|
+
rb_define_const(rb_mInfo, name, LONG2NUM(curl_info_name))
|
|
17
|
+
|
|
18
|
+
#define RB_DEFINE_M_PROXY_CONST(name, curl_proxy_name) \
|
|
19
|
+
rb_define_const(rb_mProxy, name, LONG2NUM(curl_proxy_name))
|
|
20
|
+
|
|
21
|
+
#define RB_DEFINE_M_AUTH_CONST(name, curl_auth_name) \
|
|
22
|
+
rb_define_const(rb_mAuth, name, LONG2NUM(curl_auth_name))
|
|
23
|
+
|
|
24
|
+
#define RB_DEFINE_M_PROTO_CONST(name, curl_proto_name) \
|
|
25
|
+
rb_define_const(rb_mProto, name, LONG2NUM(curl_proto_name))
|
|
26
|
+
|
|
27
|
+
#define RB_DEFINE_M_ERROR_CONST(name, curl_error_name) \
|
|
28
|
+
rb_define_const(rb_mError, name, LONG2NUM(curl_error_name))
|
|
29
|
+
|
|
30
|
+
extern VALUE rb_mCurl;
|
|
31
|
+
|
|
32
|
+
void Init_curl();
|
|
33
|
+
|
|
34
|
+
#endif
|
data/ext/easy.c
ADDED
|
@@ -0,0 +1,539 @@
|
|
|
1
|
+
#include "easy.h"
|
|
2
|
+
|
|
3
|
+
extern VALUE rb_mCurl;
|
|
4
|
+
|
|
5
|
+
VALUE rb_cEasy;
|
|
6
|
+
|
|
7
|
+
static VALUE rb_curl_easy_strerror(VALUE self, VALUE errornum) {
|
|
8
|
+
const char *error_str;
|
|
9
|
+
|
|
10
|
+
error_str = curl_easy_strerror(NUM2LONG(errornum));
|
|
11
|
+
|
|
12
|
+
return rb_str_new2(error_str);
|
|
13
|
+
}
|
|
14
|
+
|
|
15
|
+
static inline struct curl_slist *rb_array_to_curl_slist(VALUE arr, struct curl_slist *slist) {
|
|
16
|
+
long arr_len;
|
|
17
|
+
VALUE arr_ele;
|
|
18
|
+
|
|
19
|
+
if(TYPE(arr) == T_ARRAY) {
|
|
20
|
+
arr_len = RARRAY_LEN(arr);
|
|
21
|
+
curl_slist_free_all(slist);
|
|
22
|
+
|
|
23
|
+
for (long i = 0; i < arr_len; i++) {
|
|
24
|
+
arr_ele = RARRAY_AREF(arr, i);
|
|
25
|
+
slist = curl_slist_append(slist, StringValueCStr(arr_ele));
|
|
26
|
+
if (!slist) {
|
|
27
|
+
//Handle Error here.
|
|
28
|
+
}
|
|
29
|
+
}
|
|
30
|
+
}
|
|
31
|
+
else {
|
|
32
|
+
rb_raise(rb_eTypeError, "Array is required.");
|
|
33
|
+
}
|
|
34
|
+
|
|
35
|
+
return slist;
|
|
36
|
+
}
|
|
37
|
+
|
|
38
|
+
static inline VALUE curl_slist_to_rb_array(struct curl_slist *slist) {
|
|
39
|
+
VALUE arr = rb_ary_new();
|
|
40
|
+
|
|
41
|
+
while (slist) {
|
|
42
|
+
rb_ary_push(arr, rb_str_new_cstr(slist->data));
|
|
43
|
+
slist = slist->next;
|
|
44
|
+
}
|
|
45
|
+
|
|
46
|
+
return arr;
|
|
47
|
+
}
|
|
48
|
+
|
|
49
|
+
void rb_curl_mark(rb_curl_easy *rb_ch) {
|
|
50
|
+
rb_gc_mark(rb_ch->self);
|
|
51
|
+
rb_gc_mark(rb_ch->write_data);
|
|
52
|
+
rb_gc_mark(rb_ch->write_header_data);
|
|
53
|
+
rb_gc_mark(rb_ch->read_data);
|
|
54
|
+
}
|
|
55
|
+
|
|
56
|
+
void rb_curl_free(rb_curl_easy *rb_ch) {
|
|
57
|
+
curl_slist_free_all(rb_ch->curl_httpheader_slist);
|
|
58
|
+
curl_slist_free_all(rb_ch->curl_http200aliases_slist);
|
|
59
|
+
curl_slist_free_all(rb_ch->curl_hosts_slist);
|
|
60
|
+
curl_slist_free_all(rb_ch->curl_headers_slist);
|
|
61
|
+
free(rb_ch);
|
|
62
|
+
}
|
|
63
|
+
|
|
64
|
+
static void rb_curl_zero_state(rb_curl_easy *rb_ch) {
|
|
65
|
+
rb_ch->ch = NULL;
|
|
66
|
+
rb_ch->write_function = NULL;
|
|
67
|
+
rb_ch->write_header_function = NULL;
|
|
68
|
+
rb_ch->read_function = NULL;
|
|
69
|
+
rb_ch->write_data = Qnil;
|
|
70
|
+
rb_ch->write_header_data = Qnil;
|
|
71
|
+
rb_ch->read_data = Qnil;
|
|
72
|
+
rb_ch->curl_httpheader_slist = NULL;
|
|
73
|
+
rb_ch->curl_http200aliases_slist = NULL;
|
|
74
|
+
rb_ch->curl_hosts_slist = NULL;
|
|
75
|
+
rb_ch->curl_headers_slist = NULL;
|
|
76
|
+
}
|
|
77
|
+
|
|
78
|
+
static VALUE rb_curl_easy_allocate(VALUE klass) {
|
|
79
|
+
rb_curl_easy *rb_ch;
|
|
80
|
+
|
|
81
|
+
rb_ch = ALLOC(rb_curl_easy);
|
|
82
|
+
rb_curl_zero_state(rb_ch);
|
|
83
|
+
|
|
84
|
+
return Data_Wrap_Struct(klass, rb_curl_mark, rb_curl_free, rb_ch);
|
|
85
|
+
}
|
|
86
|
+
|
|
87
|
+
static char* rb_normalized_str(VALUE str) {
|
|
88
|
+
|
|
89
|
+
if (rb_type(str) == T_SYMBOL)
|
|
90
|
+
str = rb_sym_to_s(str);
|
|
91
|
+
|
|
92
|
+
return StringValueCStr(str);
|
|
93
|
+
}
|
|
94
|
+
|
|
95
|
+
static size_t rb_curl_write(char *buffer, size_t size, size_t nmemb, rb_curl_easy *rb_ch) {
|
|
96
|
+
VALUE ret_val, buf, buf_io;
|
|
97
|
+
|
|
98
|
+
buf = rb_str_new(buffer, size * nmemb);
|
|
99
|
+
buf_io = rb_funcall(rb_const_get(rb_cObject, rb_intern("StringIO")), rb_intern("new"), 2, buf, rb_str_new2("rb"));
|
|
100
|
+
ret_val = rb_funcall(rb_ch->self, rb_intern(rb_ch->write_function), 4, buf_io, INT2NUM(size), INT2NUM(nmemb), rb_ch->write_data);
|
|
101
|
+
rb_funcall(buf_io, rb_intern("close"), 0);
|
|
102
|
+
|
|
103
|
+
return FIX2LONG(ret_val);
|
|
104
|
+
}
|
|
105
|
+
|
|
106
|
+
static size_t rb_curl_write_header(char *buffer, size_t size, size_t nmemb, rb_curl_easy *rb_ch) {
|
|
107
|
+
VALUE ret_val, buf, buf_io;
|
|
108
|
+
|
|
109
|
+
buf = rb_str_new(buffer, size * nmemb);
|
|
110
|
+
buf_io = rb_funcall(rb_const_get(rb_cObject, rb_intern("StringIO")), rb_intern("new"), 2, buf, rb_str_new2("rb"));
|
|
111
|
+
ret_val = rb_funcall(rb_ch->self, rb_intern(rb_ch->write_header_function), 4, buf_io, INT2NUM(size), INT2NUM(nmemb), rb_ch->write_header_data);
|
|
112
|
+
rb_funcall(buf_io, rb_intern("close"), 0);
|
|
113
|
+
|
|
114
|
+
return FIX2LONG(ret_val);
|
|
115
|
+
}
|
|
116
|
+
|
|
117
|
+
static size_t rb_curl_read(char *buffer, size_t size, size_t nmemb, rb_curl_easy *rb_ch) {
|
|
118
|
+
VALUE ret_val, buf, buf_io;
|
|
119
|
+
long ret_val_l;
|
|
120
|
+
|
|
121
|
+
buf = rb_str_new2("");
|
|
122
|
+
buf_io = rb_funcall(rb_const_get(rb_cObject, rb_intern("StringIO")), rb_intern("new"), 2, buf, rb_str_new2("wb"));
|
|
123
|
+
ret_val = rb_funcall(rb_ch->self, rb_intern(rb_ch->read_function), 4, buf_io, INT2NUM(size), INT2NUM(nmemb), rb_ch->read_data);
|
|
124
|
+
rb_funcall(buf_io, rb_intern("close"), 0);
|
|
125
|
+
|
|
126
|
+
ret_val_l = FIX2LONG(ret_val);
|
|
127
|
+
|
|
128
|
+
if (ret_val_l > 0) {
|
|
129
|
+
memcpy(buffer, RSTRING_PTR(buf), RSTRING_LEN(buf));
|
|
130
|
+
}
|
|
131
|
+
|
|
132
|
+
return ret_val_l;
|
|
133
|
+
}
|
|
134
|
+
|
|
135
|
+
static VALUE rb_curl_create_certinfo(struct curl_certinfo *curl_certinfo_chain) {
|
|
136
|
+
int i;
|
|
137
|
+
VALUE listcode = rb_ary_new();
|
|
138
|
+
|
|
139
|
+
if (curl_certinfo_chain) {
|
|
140
|
+
for (i=0; i < curl_certinfo_chain->num_of_certs; i++) {
|
|
141
|
+
struct curl_slist *slist;
|
|
142
|
+
|
|
143
|
+
for (slist = curl_certinfo_chain->certinfo[i]; slist; slist = slist->next) {
|
|
144
|
+
rb_ary_push(listcode, rb_str_new2(slist->data));
|
|
145
|
+
}
|
|
146
|
+
}
|
|
147
|
+
}
|
|
148
|
+
|
|
149
|
+
return listcode;
|
|
150
|
+
}
|
|
151
|
+
|
|
152
|
+
static VALUE rb_curl_easy_initialize(int argc, VALUE *argv, VALUE self) {
|
|
153
|
+
VALUE url;
|
|
154
|
+
rb_curl_easy *rb_ch;
|
|
155
|
+
|
|
156
|
+
rb_scan_args(argc, argv, "01", &url);
|
|
157
|
+
|
|
158
|
+
Data_Get_Struct(self, rb_curl_easy, rb_ch);
|
|
159
|
+
|
|
160
|
+
rb_ch->ch = curl_easy_init();
|
|
161
|
+
if (!rb_ch->ch) {
|
|
162
|
+
rb_raise(rb_eRuntimeError, "Failed to initialize easy handle");
|
|
163
|
+
}
|
|
164
|
+
|
|
165
|
+
rb_ch->self = self;
|
|
166
|
+
|
|
167
|
+
if (url != Qnil)
|
|
168
|
+
curl_easy_setopt(rb_ch->ch, CURLOPT_URL, StringValueCStr(url));
|
|
169
|
+
|
|
170
|
+
return self;
|
|
171
|
+
}
|
|
172
|
+
|
|
173
|
+
static VALUE rb_curl_easy_getinfo(VALUE self, VALUE info) {
|
|
174
|
+
CURLcode c_err_code;
|
|
175
|
+
rb_curl_easy *rb_ch;
|
|
176
|
+
VALUE info_val = Qnil, ret_val = rb_ary_new();
|
|
177
|
+
long information = NUM2LONG(info);
|
|
178
|
+
|
|
179
|
+
char *s_var;
|
|
180
|
+
long l_var;
|
|
181
|
+
double d_var;
|
|
182
|
+
struct curl_slist *curl_list_var = NULL;
|
|
183
|
+
struct curl_certinfo *curl_certinfo_chain = NULL;
|
|
184
|
+
|
|
185
|
+
Data_Get_Struct(self, rb_curl_easy, rb_ch);
|
|
186
|
+
|
|
187
|
+
switch (information) {
|
|
188
|
+
/* pointer to a char pointer */
|
|
189
|
+
#if LIBCURL_VERSION_NUM >= 0x071202 /* Curl::Info constants (Available since 7.18.2) */
|
|
190
|
+
case CURLINFO_REDIRECT_URL:
|
|
191
|
+
#endif
|
|
192
|
+
#if LIBCURL_VERSION_NUM >= 0x071300 /* Curl::Info constants (Available since 7.19.0) */
|
|
193
|
+
case CURLINFO_PRIMARY_IP:
|
|
194
|
+
#endif
|
|
195
|
+
case CURLINFO_CONTENT_TYPE:
|
|
196
|
+
#if LIBCURL_VERSION_NUM >= 0x071500 /* Curl::Info constants (Available since 7.21.0) */
|
|
197
|
+
case CURLINFO_LOCAL_IP:
|
|
198
|
+
#endif
|
|
199
|
+
#if LIBCURL_VERSION_NUM >= 0x073400 /* Curl::Info constants (Available since 7.52.0) */
|
|
200
|
+
case CURLINFO_SCHEME:
|
|
201
|
+
#endif
|
|
202
|
+
case CURLINFO_EFFECTIVE_URL:
|
|
203
|
+
c_err_code = curl_easy_getinfo(rb_ch->ch, information, &s_var);
|
|
204
|
+
if (c_err_code == CURLE_OK)
|
|
205
|
+
info_val = rb_str_new2(s_var);
|
|
206
|
+
break;
|
|
207
|
+
/* pointer to a long */
|
|
208
|
+
#if LIBCURL_VERSION_NUM >= 0x071500 /* Curl::Info constants (Available since 7.21.0) */
|
|
209
|
+
case CURLINFO_LOCAL_PORT:
|
|
210
|
+
case CURLINFO_PRIMARY_PORT:
|
|
211
|
+
#endif
|
|
212
|
+
#if LIBCURL_VERSION_NUM >= 0x073200 /* Curl::Info constants (Available since 7.50.0) */
|
|
213
|
+
case CURLINFO_HTTP_VERSION:
|
|
214
|
+
#endif
|
|
215
|
+
#if LIBCURL_VERSION_NUM >= 0x073400 /* Curl::Info constants (Available since 7.52.0) */
|
|
216
|
+
case CURLINFO_PROTOCOL:
|
|
217
|
+
case CURLINFO_PROXY_SSL_VERIFYRESULT:
|
|
218
|
+
#endif
|
|
219
|
+
case CURLINFO_RESPONSE_CODE:
|
|
220
|
+
case CURLINFO_HTTP_CONNECTCODE:
|
|
221
|
+
case CURLINFO_FILETIME:
|
|
222
|
+
case CURLINFO_REDIRECT_COUNT:
|
|
223
|
+
case CURLINFO_HEADER_SIZE:
|
|
224
|
+
case CURLINFO_REQUEST_SIZE:
|
|
225
|
+
case CURLINFO_SSL_VERIFYRESULT:
|
|
226
|
+
case CURLINFO_HTTPAUTH_AVAIL:
|
|
227
|
+
case CURLINFO_PROXYAUTH_AVAIL:
|
|
228
|
+
case CURLINFO_OS_ERRNO:
|
|
229
|
+
case CURLINFO_NUM_CONNECTS:
|
|
230
|
+
case CURLINFO_LASTSOCKET:
|
|
231
|
+
c_err_code = curl_easy_getinfo(rb_ch->ch, information, &l_var);
|
|
232
|
+
if (c_err_code == CURLE_OK)
|
|
233
|
+
info_val = INT2FIX(l_var);
|
|
234
|
+
break;
|
|
235
|
+
/* pointer to a double */
|
|
236
|
+
case CURLINFO_TOTAL_TIME:
|
|
237
|
+
case CURLINFO_NAMELOOKUP_TIME:
|
|
238
|
+
case CURLINFO_CONNECT_TIME:
|
|
239
|
+
case CURLINFO_PRETRANSFER_TIME:
|
|
240
|
+
case CURLINFO_STARTTRANSFER_TIME:
|
|
241
|
+
case CURLINFO_REDIRECT_TIME:
|
|
242
|
+
case CURLINFO_SIZE_UPLOAD:
|
|
243
|
+
case CURLINFO_SIZE_DOWNLOAD:
|
|
244
|
+
case CURLINFO_SPEED_UPLOAD:
|
|
245
|
+
case CURLINFO_SPEED_DOWNLOAD:
|
|
246
|
+
case CURLINFO_CONTENT_LENGTH_DOWNLOAD:
|
|
247
|
+
case CURLINFO_CONTENT_LENGTH_UPLOAD:
|
|
248
|
+
c_err_code = curl_easy_getinfo(rb_ch->ch, information, &d_var);
|
|
249
|
+
if (c_err_code == CURLE_OK)
|
|
250
|
+
info_val = DBL2NUM(d_var);
|
|
251
|
+
break;
|
|
252
|
+
/* pointer to a 'struct curl_certinfo *' */
|
|
253
|
+
#if LIBCURL_VERSION_NUM >= 0x071301 /* Curl::Info constants (Available since 7.19.1) */
|
|
254
|
+
case CURLINFO_CERTINFO:
|
|
255
|
+
c_err_code = curl_easy_getinfo(rb_ch->ch, information, &curl_certinfo_chain);
|
|
256
|
+
if (c_err_code == CURLE_OK)
|
|
257
|
+
info_val = rb_curl_create_certinfo(curl_certinfo_chain);
|
|
258
|
+
break;
|
|
259
|
+
#endif
|
|
260
|
+
/* address of a 'struct curl_slist *' */
|
|
261
|
+
case CURLINFO_SSL_ENGINES:
|
|
262
|
+
case CURLINFO_COOKIELIST:
|
|
263
|
+
c_err_code = curl_easy_getinfo(rb_ch->ch, information, &curl_list_var);
|
|
264
|
+
if (c_err_code == CURLE_OK) {
|
|
265
|
+
info_val = curl_slist_to_rb_array(curl_list_var);
|
|
266
|
+
curl_slist_free_all(curl_list_var);
|
|
267
|
+
}
|
|
268
|
+
break;
|
|
269
|
+
default:
|
|
270
|
+
rb_raise(rb_eTypeError, "Unsupported information.");
|
|
271
|
+
}
|
|
272
|
+
rb_ary_push(ret_val, info_val);
|
|
273
|
+
rb_ary_push(ret_val, LONG2NUM(c_err_code));
|
|
274
|
+
|
|
275
|
+
return ret_val;
|
|
276
|
+
}
|
|
277
|
+
|
|
278
|
+
|
|
279
|
+
static VALUE rb_curl_easy_setopt(VALUE self, VALUE opt, VALUE val) {
|
|
280
|
+
CURLcode c_err_code;
|
|
281
|
+
rb_curl_easy *rb_ch;
|
|
282
|
+
long option = NUM2LONG(opt);
|
|
283
|
+
|
|
284
|
+
Data_Get_Struct(self, rb_curl_easy, rb_ch);
|
|
285
|
+
|
|
286
|
+
switch (option) {
|
|
287
|
+
case CURLOPT_TIMEOUT:
|
|
288
|
+
case CURLOPT_FOLLOWLOCATION:
|
|
289
|
+
case CURLOPT_MAXREDIRS:
|
|
290
|
+
case CURLOPT_POST:
|
|
291
|
+
case CURLOPT_PUT:
|
|
292
|
+
case CURLOPT_HTTPGET:
|
|
293
|
+
case CURLOPT_UPLOAD:
|
|
294
|
+
case CURLOPT_VERBOSE:
|
|
295
|
+
#if LIBCURL_VERSION_NUM >= 0x070b02 /* Available since 7.11.2 */
|
|
296
|
+
case CURLOPT_TCP_NODELAY:
|
|
297
|
+
#endif
|
|
298
|
+
#if LIBCURL_VERSION_NUM >= 0x070e01 /* Available since 7.14.1 */
|
|
299
|
+
case CURLOPT_IGNORE_CONTENT_LENGTH:
|
|
300
|
+
#endif
|
|
301
|
+
#if LIBCURL_VERSION_NUM >= 0x070f02 /* Available since 7.15.2 */
|
|
302
|
+
case CURLOPT_CONNECT_ONLY:
|
|
303
|
+
case CURLOPT_LOCALPORT:
|
|
304
|
+
#endif
|
|
305
|
+
#if LIBCURL_VERSION_NUM >= 0x071000 /* Available since 7.16.0 */
|
|
306
|
+
case CURLOPT_SSL_SESSIONID_CACHE:
|
|
307
|
+
#endif
|
|
308
|
+
#if LIBCURL_VERSION_NUM >= 0x071002 /* Available since 7.16.2 */
|
|
309
|
+
case CURLOPT_CONNECTTIMEOUT_MS:
|
|
310
|
+
case CURLOPT_HTTP_CONTENT_DECODING:
|
|
311
|
+
case CURLOPT_HTTP_TRANSFER_DECODING:
|
|
312
|
+
case CURLOPT_TIMEOUT_MS:
|
|
313
|
+
#endif
|
|
314
|
+
#if LIBCURL_VERSION_NUM >= 0x071300 /* Available since 7.19.0 */
|
|
315
|
+
case CURLOPT_ADDRESS_SCOPE:
|
|
316
|
+
#endif
|
|
317
|
+
#if LIBCURL_VERSION_NUM >= 0x071301 /* Available since 7.19.1 */
|
|
318
|
+
case CURLOPT_CERTINFO:
|
|
319
|
+
case CURLOPT_POSTREDIR:
|
|
320
|
+
#endif
|
|
321
|
+
#if LIBCURL_VERSION_NUM >= 0x071600 /* Available since 7.22.0 */
|
|
322
|
+
case CURLOPT_GSSAPI_DELEGATION:
|
|
323
|
+
#endif
|
|
324
|
+
#if LIBCURL_VERSION_NUM >= 0x072a00 /* Available since 7.42.0 */
|
|
325
|
+
case CURLOPT_PATH_AS_IS:
|
|
326
|
+
#endif
|
|
327
|
+
#if LIBCURL_VERSION_NUM >= 0x072b00 /* Available since 7.43.0 */
|
|
328
|
+
case CURLOPT_PIPEWAIT:
|
|
329
|
+
#endif
|
|
330
|
+
#if LIBCURL_VERSION_NUM >= 0x070a06 /* Available since 7.10.6 */
|
|
331
|
+
case CURLOPT_HTTPAUTH:
|
|
332
|
+
#endif
|
|
333
|
+
#if LIBCURL_VERSION_NUM >= 0x070a07 /* Available since 7.10.7 */
|
|
334
|
+
case CURLOPT_PROXYAUTH:
|
|
335
|
+
#endif
|
|
336
|
+
#if LIBCURL_VERSION_NUM >= 0x070a08 /* Available since 7.10.8 */
|
|
337
|
+
case CURLOPT_IPRESOLVE:
|
|
338
|
+
case CURLOPT_MAXFILESIZE:
|
|
339
|
+
#endif
|
|
340
|
+
case CURLOPT_AUTOREFERER:
|
|
341
|
+
case CURLOPT_BUFFERSIZE:
|
|
342
|
+
case CURLOPT_CONNECTTIMEOUT:
|
|
343
|
+
case CURLOPT_COOKIESESSION:
|
|
344
|
+
case CURLOPT_CRLF:
|
|
345
|
+
case CURLOPT_DNS_CACHE_TIMEOUT:
|
|
346
|
+
case CURLOPT_DNS_USE_GLOBAL_CACHE:
|
|
347
|
+
case CURLOPT_FAILONERROR:
|
|
348
|
+
case CURLOPT_FILETIME:
|
|
349
|
+
case CURLOPT_FORBID_REUSE:
|
|
350
|
+
case CURLOPT_FRESH_CONNECT:
|
|
351
|
+
case CURLOPT_HEADER:
|
|
352
|
+
case CURLOPT_HTTPPROXYTUNNEL:
|
|
353
|
+
case CURLOPT_HTTP_VERSION:
|
|
354
|
+
case CURLOPT_INFILESIZE:
|
|
355
|
+
case CURLOPT_LOW_SPEED_LIMIT:
|
|
356
|
+
case CURLOPT_LOW_SPEED_TIME:
|
|
357
|
+
case CURLOPT_MAXCONNECTS:
|
|
358
|
+
case CURLOPT_NETRC:
|
|
359
|
+
case CURLOPT_NOBODY:
|
|
360
|
+
case CURLOPT_NOPROGRESS:
|
|
361
|
+
case CURLOPT_NOSIGNAL:
|
|
362
|
+
case CURLOPT_PORT:
|
|
363
|
+
case CURLOPT_PROXYPORT:
|
|
364
|
+
case CURLOPT_PROXYTYPE:
|
|
365
|
+
case CURLOPT_RESUME_FROM:
|
|
366
|
+
case CURLOPT_SSLENGINE_DEFAULT:
|
|
367
|
+
case CURLOPT_SSLVERSION:
|
|
368
|
+
case CURLOPT_SSL_VERIFYHOST:
|
|
369
|
+
case CURLOPT_SSL_VERIFYPEER:
|
|
370
|
+
case CURLOPT_TIMECONDITION:
|
|
371
|
+
case CURLOPT_TIMEVALUE:
|
|
372
|
+
case CURLOPT_UNRESTRICTED_AUTH:
|
|
373
|
+
#if LIBCURL_VERSION_NUM >= 0x071304 /* Available since 7.19.4 */
|
|
374
|
+
case CURLOPT_PROTOCOLS:
|
|
375
|
+
case CURLOPT_REDIR_PROTOCOLS:
|
|
376
|
+
case CURLOPT_SOCKS5_GSSAPI_NEC:
|
|
377
|
+
#endif
|
|
378
|
+
c_err_code = curl_easy_setopt(rb_ch->ch, option, NUM2LONG(val));
|
|
379
|
+
break;
|
|
380
|
+
case CURLOPT_URL:
|
|
381
|
+
#if LIBCURL_VERSION_NUM >= 0x071301 /* Available since 7.19.1 */
|
|
382
|
+
case CURLOPT_PASSWORD:
|
|
383
|
+
case CURLOPT_USERNAME:
|
|
384
|
+
#endif
|
|
385
|
+
#if LIBCURL_VERSION_NUM >= 0x071304 /* Available since 7.19.4 */
|
|
386
|
+
case CURLOPT_SOCKS5_GSSAPI_SERVICE:
|
|
387
|
+
#endif
|
|
388
|
+
case CURLOPT_CAINFO:
|
|
389
|
+
case CURLOPT_SSLCERTTYPE:
|
|
390
|
+
case CURLOPT_SSLKEYTYPE:
|
|
391
|
+
c_err_code = curl_easy_setopt(rb_ch->ch, option, StringValueCStr(val));
|
|
392
|
+
break;
|
|
393
|
+
case CURLOPT_POSTFIELDS:
|
|
394
|
+
case CURLOPT_USERAGENT:
|
|
395
|
+
case CURLOPT_USERPWD:
|
|
396
|
+
#if LIBCURL_VERSION_NUM >= 0x070b00 /* Available since 7.11.0 */
|
|
397
|
+
case CURLOPT_NETRC_FILE:
|
|
398
|
+
#endif
|
|
399
|
+
#if LIBCURL_VERSION_NUM >= 0x070e01 /* Available since 7.14.1 */
|
|
400
|
+
case CURLOPT_COOKIELIST:
|
|
401
|
+
#endif
|
|
402
|
+
#if LIBCURL_VERSION_NUM >= 0x071004 /* Available since 7.16.4 */
|
|
403
|
+
case CURLOPT_KRBLEVEL:
|
|
404
|
+
#endif
|
|
405
|
+
#if LIBCURL_VERSION_NUM >= 0x071300 /* Available since 7.19.0 */
|
|
406
|
+
case CURLOPT_CRLFILE:
|
|
407
|
+
case CURLOPT_ISSUERCERT:
|
|
408
|
+
case CURLOPT_KEYPASSWD:
|
|
409
|
+
#endif
|
|
410
|
+
#if LIBCURL_VERSION_NUM >= 0x071304 /* Available since 7.19.4 */
|
|
411
|
+
case CURLOPT_NOPROXY:
|
|
412
|
+
#endif
|
|
413
|
+
#if LIBCURL_VERSION_NUM >= 0x071504 /* Available since 7.21.4 */
|
|
414
|
+
case CURLOPT_TLSAUTH_PASSWORD:
|
|
415
|
+
case CURLOPT_TLSAUTH_TYPE:
|
|
416
|
+
#endif
|
|
417
|
+
case CURLOPT_TLSAUTH_USERNAME:
|
|
418
|
+
#if LIBCURL_VERSION_NUM >= 0x072800 /* Available since 7.40.0 */
|
|
419
|
+
case CURLOPT_UNIX_SOCKET_PATH:
|
|
420
|
+
#endif
|
|
421
|
+
case CURLOPT_CAPATH:
|
|
422
|
+
case CURLOPT_COOKIE:
|
|
423
|
+
case CURLOPT_COOKIEFILE:
|
|
424
|
+
case CURLOPT_COOKIEJAR:
|
|
425
|
+
case CURLOPT_CUSTOMREQUEST:
|
|
426
|
+
case CURLOPT_EGDSOCKET:
|
|
427
|
+
case CURLOPT_ENCODING:
|
|
428
|
+
case CURLOPT_INTERFACE:
|
|
429
|
+
case CURLOPT_PROXY:
|
|
430
|
+
case CURLOPT_PROXYUSERPWD:
|
|
431
|
+
case CURLOPT_RANDOM_FILE:
|
|
432
|
+
case CURLOPT_RANGE:
|
|
433
|
+
case CURLOPT_REFERER:
|
|
434
|
+
case CURLOPT_SSLCERT:
|
|
435
|
+
case CURLOPT_SSLENGINE:
|
|
436
|
+
case CURLOPT_SSLKEY:
|
|
437
|
+
case CURLOPT_SSL_CIPHER_LIST:
|
|
438
|
+
c_err_code = curl_easy_setopt(rb_ch->ch, option, NIL_P(val) ? NULL : StringValueCStr(val));
|
|
439
|
+
break;
|
|
440
|
+
case CURLOPT_WRITEFUNCTION:
|
|
441
|
+
rb_ch->write_function = NIL_P(val) ? NULL : rb_normalized_str(val);
|
|
442
|
+
curl_easy_setopt(rb_ch->ch, CURLOPT_WRITEDATA, rb_ch);
|
|
443
|
+
c_err_code = curl_easy_setopt(rb_ch->ch, CURLOPT_WRITEFUNCTION, rb_curl_write);
|
|
444
|
+
break;
|
|
445
|
+
case CURLOPT_WRITEDATA:
|
|
446
|
+
rb_ch->write_data = val;
|
|
447
|
+
c_err_code = curl_easy_setopt(rb_ch->ch, CURLOPT_WRITEDATA, rb_ch);
|
|
448
|
+
break;
|
|
449
|
+
case CURLOPT_HEADERFUNCTION:
|
|
450
|
+
rb_ch->write_header_function = NIL_P(val) ? NULL : rb_normalized_str(val);
|
|
451
|
+
curl_easy_setopt(rb_ch->ch, CURLOPT_HEADERDATA, rb_ch);
|
|
452
|
+
c_err_code = curl_easy_setopt(rb_ch->ch, CURLOPT_HEADERFUNCTION, rb_curl_write_header);
|
|
453
|
+
break;
|
|
454
|
+
case CURLOPT_HEADERDATA:
|
|
455
|
+
rb_ch->write_header_data = val;
|
|
456
|
+
c_err_code = curl_easy_setopt(rb_ch->ch, CURLOPT_HEADERDATA, rb_ch);
|
|
457
|
+
break;
|
|
458
|
+
case CURLOPT_READFUNCTION:
|
|
459
|
+
rb_ch->read_function = NIL_P(val) ? NULL : rb_normalized_str(val);
|
|
460
|
+
curl_easy_setopt(rb_ch->ch, CURLOPT_READDATA, rb_ch);
|
|
461
|
+
c_err_code = curl_easy_setopt(rb_ch->ch, CURLOPT_READFUNCTION, rb_curl_read);
|
|
462
|
+
break;
|
|
463
|
+
case CURLOPT_READDATA:
|
|
464
|
+
rb_ch->read_data = val;
|
|
465
|
+
c_err_code = curl_easy_setopt(rb_ch->ch, CURLOPT_READDATA, rb_ch);
|
|
466
|
+
break;
|
|
467
|
+
#if LIBCURL_VERSION_NUM >= 0x070f02 /* Available since 7.15.2 */
|
|
468
|
+
case CURLOPT_MAX_RECV_SPEED_LARGE:
|
|
469
|
+
case CURLOPT_MAX_SEND_SPEED_LARGE:
|
|
470
|
+
c_err_code = curl_easy_setopt(rb_ch->ch, option, (curl_off_t) NUM2LL(val));
|
|
471
|
+
break;
|
|
472
|
+
#endif
|
|
473
|
+
case CURLOPT_HTTP200ALIASES:
|
|
474
|
+
rb_ch->curl_http200aliases_slist = rb_array_to_curl_slist(val, rb_ch->curl_http200aliases_slist);
|
|
475
|
+
c_err_code = curl_easy_setopt(rb_ch->ch, CURLOPT_HTTP200ALIASES, rb_ch->curl_http200aliases_slist);
|
|
476
|
+
break;
|
|
477
|
+
case CURLOPT_HTTPHEADER:
|
|
478
|
+
rb_ch->curl_httpheader_slist = rb_array_to_curl_slist(val, rb_ch->curl_httpheader_slist);
|
|
479
|
+
c_err_code = curl_easy_setopt(rb_ch->ch, CURLOPT_HTTPHEADER, rb_ch->curl_httpheader_slist);
|
|
480
|
+
break;
|
|
481
|
+
#if LIBCURL_VERSION_NUM >= 0x071503 /* Available since 7.21.3 */
|
|
482
|
+
case CURLOPT_RESOLVE:
|
|
483
|
+
rb_ch->curl_hosts_slist = rb_array_to_curl_slist(val, rb_ch->curl_hosts_slist);
|
|
484
|
+
c_err_code = curl_easy_setopt(rb_ch->ch, CURLOPT_RESOLVE, rb_ch->curl_hosts_slist);
|
|
485
|
+
break;
|
|
486
|
+
#endif
|
|
487
|
+
#if LIBCURL_VERSION_NUM >= 0x072500 /* Available since 7.37.0 */
|
|
488
|
+
case CURLOPT_PROXYHEADER:
|
|
489
|
+
rb_ch->curl_headers_slist = rb_array_to_curl_slist(val, rb_ch->curl_headers_slist);
|
|
490
|
+
c_err_code = curl_easy_setopt(rb_ch->ch, CURLOPT_PROXYHEADER, rb_ch->curl_headers_slist);
|
|
491
|
+
break;
|
|
492
|
+
#endif
|
|
493
|
+
default:
|
|
494
|
+
rb_raise(rb_eTypeError, "Unsupported option.");
|
|
495
|
+
}
|
|
496
|
+
|
|
497
|
+
return LONG2NUM(c_err_code);
|
|
498
|
+
}
|
|
499
|
+
|
|
500
|
+
static VALUE rb_curl_easy_perform(VALUE self) {
|
|
501
|
+
CURLcode c_err_code;
|
|
502
|
+
rb_curl_easy *rb_ch;
|
|
503
|
+
|
|
504
|
+
Data_Get_Struct(self, rb_curl_easy, rb_ch);
|
|
505
|
+
c_err_code = curl_easy_perform(rb_ch->ch);
|
|
506
|
+
|
|
507
|
+
return LONG2NUM(c_err_code);
|
|
508
|
+
}
|
|
509
|
+
|
|
510
|
+
static VALUE rb_curl_easy_cleanup(VALUE self) {
|
|
511
|
+
rb_curl_easy *rb_ch;
|
|
512
|
+
|
|
513
|
+
Data_Get_Struct(self, rb_curl_easy, rb_ch);
|
|
514
|
+
curl_easy_cleanup(rb_ch->ch);
|
|
515
|
+
|
|
516
|
+
return Qnil;
|
|
517
|
+
}
|
|
518
|
+
|
|
519
|
+
static VALUE rb_curl_easy_reset(VALUE self) {
|
|
520
|
+
rb_curl_easy *rb_ch;
|
|
521
|
+
|
|
522
|
+
Data_Get_Struct(self, rb_curl_easy, rb_ch);
|
|
523
|
+
curl_easy_reset(rb_ch->ch);
|
|
524
|
+
rb_curl_zero_state(rb_ch);
|
|
525
|
+
|
|
526
|
+
return Qnil;
|
|
527
|
+
}
|
|
528
|
+
|
|
529
|
+
void Init_easy() {
|
|
530
|
+
rb_cEasy = rb_define_class_under(rb_mCurl, "Easy", rb_cObject);
|
|
531
|
+
rb_define_alloc_func(rb_cEasy, rb_curl_easy_allocate);
|
|
532
|
+
rb_define_singleton_method(rb_cEasy, "strerror", rb_curl_easy_strerror, 1);
|
|
533
|
+
rb_define_method(rb_cEasy, "initialize", rb_curl_easy_initialize, -1);
|
|
534
|
+
rb_define_method(rb_cEasy, "setopt", rb_curl_easy_setopt, 2);
|
|
535
|
+
rb_define_method(rb_cEasy, "getinfo", rb_curl_easy_getinfo, 1);
|
|
536
|
+
rb_define_method(rb_cEasy, "perform", rb_curl_easy_perform, 0);
|
|
537
|
+
rb_define_method(rb_cEasy, "cleanup", rb_curl_easy_cleanup, 0);
|
|
538
|
+
rb_define_method(rb_cEasy, "reset", rb_curl_easy_reset, 0);
|
|
539
|
+
}
|
data/ext/easy.h
ADDED
|
@@ -0,0 +1,30 @@
|
|
|
1
|
+
#ifndef RUBY_CURL_EASY_H
|
|
2
|
+
#define RUBY_CURL_EASY_H
|
|
3
|
+
|
|
4
|
+
#include <ruby.h>
|
|
5
|
+
#include <curl/curl.h>
|
|
6
|
+
#include <curl/easy.h>
|
|
7
|
+
|
|
8
|
+
typedef struct {
|
|
9
|
+
CURL *ch;
|
|
10
|
+
VALUE self;
|
|
11
|
+
|
|
12
|
+
char *write_function;
|
|
13
|
+
char *write_header_function;
|
|
14
|
+
char *read_function;
|
|
15
|
+
|
|
16
|
+
VALUE write_data;
|
|
17
|
+
VALUE write_header_data;
|
|
18
|
+
VALUE read_data;
|
|
19
|
+
|
|
20
|
+
struct curl_slist *curl_httpheader_slist;
|
|
21
|
+
struct curl_slist *curl_http200aliases_slist;
|
|
22
|
+
struct curl_slist *curl_hosts_slist;
|
|
23
|
+
struct curl_slist *curl_headers_slist;
|
|
24
|
+
} rb_curl_easy;
|
|
25
|
+
|
|
26
|
+
extern VALUE rb_cEasy;
|
|
27
|
+
|
|
28
|
+
extern void Init_easy();
|
|
29
|
+
|
|
30
|
+
#endif
|
data/ext/extconf.rb
ADDED
|
@@ -0,0 +1,26 @@
|
|
|
1
|
+
require 'mkmf'
|
|
2
|
+
|
|
3
|
+
dir_config('curl')
|
|
4
|
+
|
|
5
|
+
if find_executable('curl-config')
|
|
6
|
+
$CFLAGS << " #{`curl-config --cflags`.strip} -g"
|
|
7
|
+
if ENV['STATIC_BUILD']
|
|
8
|
+
$LIBS << " #{`curl-config --static-libs`.strip}"
|
|
9
|
+
else
|
|
10
|
+
$LIBS << " #{`curl-config --libs`.strip}"
|
|
11
|
+
end
|
|
12
|
+
ca_bundle_path=`curl-config --ca`.strip
|
|
13
|
+
if !ca_bundle_path.nil? and ca_bundle_path != ''
|
|
14
|
+
$defs.push( %{-D HAVE_CURL_CONFIG_CA} )
|
|
15
|
+
$defs.push( %{-D CURL_CONFIG_CA='#{ca_bundle_path.inspect}'} )
|
|
16
|
+
end
|
|
17
|
+
elsif !have_library('curl') or !have_header('curl/curl.h')
|
|
18
|
+
fail <<-EOM
|
|
19
|
+
Can't find libcurl or curl/curl.h
|
|
20
|
+
|
|
21
|
+
Try passing --with-curl-dir or --with-curl-lib and --with-curl-include
|
|
22
|
+
options to extconf.
|
|
23
|
+
EOM
|
|
24
|
+
end
|
|
25
|
+
|
|
26
|
+
create_makefile('curl')
|
data/lib/ruby-curl.rb
CHANGED
data/ruby-curl.gemspec
ADDED
|
@@ -0,0 +1,36 @@
|
|
|
1
|
+
# coding: utf-8
|
|
2
|
+
lib = File.expand_path("../lib", __FILE__)
|
|
3
|
+
$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
|
|
4
|
+
require "ruby-curl/version"
|
|
5
|
+
|
|
6
|
+
Gem::Specification.new do |spec|
|
|
7
|
+
spec.name = 'ruby-curl'
|
|
8
|
+
spec.version = Curl::VERSION
|
|
9
|
+
spec.summary = %q{}
|
|
10
|
+
spec.description = %q{True Ruby binding for cURL.}
|
|
11
|
+
spec.authors = ["Vijayakumar Ramachandran", "Shivam Singh"]
|
|
12
|
+
spec.email = ["vijayrepomailzbox@gmail.com", "singhshivam.172@gmail.com"]
|
|
13
|
+
spec.homepage = "https://github.com/vijayrsv/ruby-curl"
|
|
14
|
+
spec.license = "MIT"
|
|
15
|
+
spec.required_ruby_version = ">= 1.9.3"
|
|
16
|
+
|
|
17
|
+
# Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
|
|
18
|
+
# to allow pushing to a single host or delete this section to allow pushing to any host.
|
|
19
|
+
if spec.respond_to?(:metadata)
|
|
20
|
+
spec.metadata["allowed_push_host"] = "https://rubygems.org"
|
|
21
|
+
else
|
|
22
|
+
raise "RubyGems 2.0 or newer is required to protect against " \
|
|
23
|
+
"public gem pushes."
|
|
24
|
+
end
|
|
25
|
+
|
|
26
|
+
spec.files = `git ls-files -z`.split("\x0").reject do |f|
|
|
27
|
+
f.match(%r{^(test|spec|features)/})
|
|
28
|
+
end
|
|
29
|
+
spec.bindir = "exe"
|
|
30
|
+
spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
|
|
31
|
+
spec.extensions = %w[ext/extconf.rb]
|
|
32
|
+
spec.require_paths = ["lib"]
|
|
33
|
+
|
|
34
|
+
spec.add_development_dependency "bundler", "~> 1.15"
|
|
35
|
+
spec.add_development_dependency "rake", "~> 10.0"
|
|
36
|
+
end
|
metadata
CHANGED
|
@@ -1,26 +1,68 @@
|
|
|
1
1
|
--- !ruby/object:Gem::Specification
|
|
2
2
|
name: ruby-curl
|
|
3
3
|
version: !ruby/object:Gem::Version
|
|
4
|
-
version:
|
|
4
|
+
version: 1.0.2
|
|
5
5
|
platform: ruby
|
|
6
6
|
authors:
|
|
7
|
-
-
|
|
7
|
+
- Vijayakumar Ramachandran
|
|
8
|
+
- Shivam Singh
|
|
8
9
|
autorequire:
|
|
9
|
-
bindir:
|
|
10
|
+
bindir: exe
|
|
10
11
|
cert_chain: []
|
|
11
|
-
date: 2019-
|
|
12
|
-
dependencies:
|
|
13
|
-
|
|
14
|
-
|
|
12
|
+
date: 2019-04-27 00:00:00.000000000 Z
|
|
13
|
+
dependencies:
|
|
14
|
+
- !ruby/object:Gem::Dependency
|
|
15
|
+
name: bundler
|
|
16
|
+
requirement: !ruby/object:Gem::Requirement
|
|
17
|
+
requirements:
|
|
18
|
+
- - "~>"
|
|
19
|
+
- !ruby/object:Gem::Version
|
|
20
|
+
version: '1.15'
|
|
21
|
+
type: :development
|
|
22
|
+
prerelease: false
|
|
23
|
+
version_requirements: !ruby/object:Gem::Requirement
|
|
24
|
+
requirements:
|
|
25
|
+
- - "~>"
|
|
26
|
+
- !ruby/object:Gem::Version
|
|
27
|
+
version: '1.15'
|
|
28
|
+
- !ruby/object:Gem::Dependency
|
|
29
|
+
name: rake
|
|
30
|
+
requirement: !ruby/object:Gem::Requirement
|
|
31
|
+
requirements:
|
|
32
|
+
- - "~>"
|
|
33
|
+
- !ruby/object:Gem::Version
|
|
34
|
+
version: '10.0'
|
|
35
|
+
type: :development
|
|
36
|
+
prerelease: false
|
|
37
|
+
version_requirements: !ruby/object:Gem::Requirement
|
|
38
|
+
requirements:
|
|
39
|
+
- - "~>"
|
|
40
|
+
- !ruby/object:Gem::Version
|
|
41
|
+
version: '10.0'
|
|
42
|
+
description: True Ruby binding for cURL.
|
|
43
|
+
email:
|
|
44
|
+
- vijayrepomailzbox@gmail.com
|
|
45
|
+
- singhshivam.172@gmail.com
|
|
15
46
|
executables: []
|
|
16
|
-
extensions:
|
|
47
|
+
extensions:
|
|
48
|
+
- ext/extconf.rb
|
|
17
49
|
extra_rdoc_files: []
|
|
18
50
|
files:
|
|
51
|
+
- LICENSE.txt
|
|
52
|
+
- README.md
|
|
53
|
+
- ext/curl.c
|
|
54
|
+
- ext/curl.h
|
|
55
|
+
- ext/easy.c
|
|
56
|
+
- ext/easy.h
|
|
57
|
+
- ext/extconf.rb
|
|
19
58
|
- lib/ruby-curl.rb
|
|
20
|
-
|
|
59
|
+
- lib/ruby-curl/version.rb
|
|
60
|
+
- ruby-curl.gemspec
|
|
61
|
+
homepage: https://github.com/vijayrsv/ruby-curl
|
|
21
62
|
licenses:
|
|
22
63
|
- MIT
|
|
23
|
-
metadata:
|
|
64
|
+
metadata:
|
|
65
|
+
allowed_push_host: https://rubygems.org
|
|
24
66
|
post_install_message:
|
|
25
67
|
rdoc_options: []
|
|
26
68
|
require_paths:
|
|
@@ -29,7 +71,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
|
|
|
29
71
|
requirements:
|
|
30
72
|
- - ">="
|
|
31
73
|
- !ruby/object:Gem::Version
|
|
32
|
-
version:
|
|
74
|
+
version: 1.9.3
|
|
33
75
|
required_rubygems_version: !ruby/object:Gem::Requirement
|
|
34
76
|
requirements:
|
|
35
77
|
- - ">="
|
|
@@ -40,5 +82,5 @@ rubyforge_project:
|
|
|
40
82
|
rubygems_version: 2.7.8
|
|
41
83
|
signing_key:
|
|
42
84
|
specification_version: 4
|
|
43
|
-
summary:
|
|
85
|
+
summary: ''
|
|
44
86
|
test_files: []
|