1 /***************************************************************************
2 * _ _ ____ _
3 * Project ___| | | | _ \| |
4 * / __| | | | |_) | |
5 * | (__| |_| | _ <| |___
6 * \___|\___/|_| \_\_____|
7 *
8 * Copyright (C) 1998 - 2015, Daniel Stenberg, <daniel@haxx.se>, et al.
9 *
10 * This software is licensed as described in the file COPYING, which
11 * you should have received as part of this distribution. The terms
12 * are also available at https://curl.haxx.se/docs/copyright.html.
13 *
14 * You may opt to use, copy, modify, merge, publish, distribute and/or sell
15 * copies of the Software, and permit persons to whom the Software is
16 * furnished to do so, under the terms of the COPYING file.
17 *
18 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
19 * KIND, either express or implied.
20 *
21 ***************************************************************************/
22 #include "tool_setup.h"
23
24 #ifndef CURL_DISABLE_LIBCURL_OPTION
25
26 #define ENABLE_CURLX_PRINTF
27 /* use our own printf() functions */
28 #include "curlx.h"
29
30 #include "tool_cfgable.h"
31 #include "tool_easysrc.h"
32 #include "tool_setopt.h"
33
34 #include "memdebug.h" /* keep this as LAST include */
35
36 /* Lookup tables for converting setopt values back to symbols */
37 /* For enums, values may be in any order. */
38 /* For bit masks, put combinations first, then single bits, */
39 /* and finally any "NONE" value. */
40
41 #define NV(e) {#e, e}
42 #define NV1(e, v) {#e, (v)}
43 #define NVEND {NULL, 0} /* sentinel to mark end of list */
44
45 const NameValue setopt_nv_CURLPROXY[] = {
46 NV(CURLPROXY_HTTP),
47 NV(CURLPROXY_HTTP_1_0),
48 NV(CURLPROXY_SOCKS4),
49 NV(CURLPROXY_SOCKS5),
50 NV(CURLPROXY_SOCKS4A),
51 NV(CURLPROXY_SOCKS5_HOSTNAME),
52 NVEND,
53 };
54
55 const NameValueUnsigned setopt_nv_CURLAUTH[] = {
56 NV(CURLAUTH_ANY), /* combination */
57 NV(CURLAUTH_ANYSAFE), /* combination */
58 NV(CURLAUTH_BASIC),
59 NV(CURLAUTH_DIGEST),
60 NV(CURLAUTH_GSSNEGOTIATE),
61 NV(CURLAUTH_NTLM),
62 NV(CURLAUTH_DIGEST_IE),
63 NV(CURLAUTH_NTLM_WB),
64 NV(CURLAUTH_ONLY),
65 NV(CURLAUTH_NONE),
66 NVEND,
67 };
68
69 const NameValue setopt_nv_CURL_HTTP_VERSION[] = {
70 NV(CURL_HTTP_VERSION_NONE),
71 NV(CURL_HTTP_VERSION_1_0),
72 NV(CURL_HTTP_VERSION_1_1),
73 NV(CURL_HTTP_VERSION_2_0),
74 NV(CURL_HTTP_VERSION_2TLS),
75 NVEND,
76 };
77
78 const NameValue setopt_nv_CURL_SSLVERSION[] = {
79 NV(CURL_SSLVERSION_DEFAULT),
80 NV(CURL_SSLVERSION_TLSv1),
81 NV(CURL_SSLVERSION_SSLv2),
82 NV(CURL_SSLVERSION_SSLv3),
83 NV(CURL_SSLVERSION_TLSv1_0),
84 NV(CURL_SSLVERSION_TLSv1_1),
85 NV(CURL_SSLVERSION_TLSv1_2),
86 NVEND,
87 };
88
89 const NameValue setopt_nv_CURL_TIMECOND[] = {
90 NV(CURL_TIMECOND_IFMODSINCE),
91 NV(CURL_TIMECOND_IFUNMODSINCE),
92 NV(CURL_TIMECOND_LASTMOD),
93 NV(CURL_TIMECOND_NONE),
94 NVEND,
95 };
96
97 const NameValue setopt_nv_CURLFTPSSL_CCC[] = {
98 NV(CURLFTPSSL_CCC_NONE),
99 NV(CURLFTPSSL_CCC_PASSIVE),
100 NV(CURLFTPSSL_CCC_ACTIVE),
101 NVEND,
102 };
103
104 const NameValue setopt_nv_CURLUSESSL[] = {
105 NV(CURLUSESSL_NONE),
106 NV(CURLUSESSL_TRY),
107 NV(CURLUSESSL_CONTROL),
108 NV(CURLUSESSL_ALL),
109 NVEND,
110 };
111
112 const NameValueUnsigned setopt_nv_CURLSSLOPT[] = {
113 NV(CURLSSLOPT_ALLOW_BEAST),
114 NV(CURLSSLOPT_NO_REVOKE),
115 NVEND,
116 };
117
118 const NameValue setopt_nv_CURL_NETRC[] = {
119 NV(CURL_NETRC_IGNORED),
120 NV(CURL_NETRC_OPTIONAL),
121 NV(CURL_NETRC_REQUIRED),
122 NVEND,
123 };
124
125 /* These mappings essentially triplicated - see
126 * tool_libinfo.c and tool_paramhlp.c */
127 const NameValue setopt_nv_CURLPROTO[] = {
128 NV(CURLPROTO_ALL), /* combination */
129 NV(CURLPROTO_DICT),
130 NV(CURLPROTO_FILE),
131 NV(CURLPROTO_FTP),
132 NV(CURLPROTO_FTPS),
133 NV(CURLPROTO_GOPHER),
134 NV(CURLPROTO_HTTP),
135 NV(CURLPROTO_HTTPS),
136 NV(CURLPROTO_IMAP),
137 NV(CURLPROTO_IMAPS),
138 NV(CURLPROTO_LDAP),
139 NV(CURLPROTO_LDAPS),
140 NV(CURLPROTO_POP3),
141 NV(CURLPROTO_POP3S),
142 NV(CURLPROTO_RTSP),
143 NV(CURLPROTO_SCP),
144 NV(CURLPROTO_SFTP),
145 NV(CURLPROTO_SMB),
146 NV(CURLPROTO_SMBS),
147 NV(CURLPROTO_SMTP),
148 NV(CURLPROTO_SMTPS),
149 NV(CURLPROTO_TELNET),
150 NV(CURLPROTO_TFTP),
151 NVEND,
152 };
153
154 /* These options have non-zero default values. */
155 static const NameValue setopt_nv_CURLNONZERODEFAULTS[] = {
156 NV1(CURLOPT_SSL_VERIFYPEER, 1),
157 NV1(CURLOPT_SSL_VERIFYHOST, 1),
158 NV1(CURLOPT_SSL_ENABLE_NPN, 1),
159 NV1(CURLOPT_SSL_ENABLE_ALPN, 1),
160 NVEND
161 };
162
163 /* Format and add code; jump to nomem on malloc error */
164 #define ADD(args) do { \
165 ret = easysrc_add args; \
166 if(ret) \
167 goto nomem; \
168 } WHILE_FALSE
169 #define ADDF(args) do { \
170 ret = easysrc_addf args; \
171 if(ret) \
172 goto nomem; \
173 } WHILE_FALSE
174
175 #define DECL0(s) ADD((&easysrc_decl, s))
176 #define DECL1(f,a) ADDF((&easysrc_decl, f,a))
177
178 #define DATA0(s) ADD((&easysrc_data, s))
179 #define DATA1(f,a) ADDF((&easysrc_data, f,a))
180 #define DATA2(f,a,b) ADDF((&easysrc_data, f,a,b))
181 #define DATA3(f,a,b,c) ADDF((&easysrc_data, f,a,b,c))
182
183 #define CODE0(s) ADD((&easysrc_code, s))
184 #define CODE1(f,a) ADDF((&easysrc_code, f,a))
185 #define CODE2(f,a,b) ADDF((&easysrc_code, f,a,b))
186 #define CODE3(f,a,b,c) ADDF((&easysrc_code, f,a,b,c))
187
188 #define CLEAN0(s) ADD((&easysrc_clean, s))
189 #define CLEAN1(f,a) ADDF((&easysrc_clean, f,a))
190
191 #define REM0(s) ADD((&easysrc_toohard, s))
192 #define REM1(f,a) ADDF((&easysrc_toohard, f,a))
193 #define REM2(f,a,b) ADDF((&easysrc_toohard, f,a,b))
194
195 /* Escape string to C string syntax. Return NULL if out of memory.
196 * Is this correct for those wacky EBCDIC guys? */
c_escape(const char * str)197 static char *c_escape(const char *str)
198 {
199 size_t len = 0;
200 const char *s;
201 unsigned char c;
202 char *escaped, *e;
203 /* Allocate space based on worst-case */
204 len = strlen(str);
205 escaped = malloc(4 * len + 1);
206 if(!escaped)
207 return NULL;
208
209 e = escaped;
210 for(s=str; (c=*s) != '\0'; s++) {
211 if(c=='\n') {
212 strcpy(e, "\\n");
213 e += 2;
214 }
215 else if(c=='\r') {
216 strcpy(e, "\\r");
217 e += 2;
218 }
219 else if(c=='\t') {
220 strcpy(e, "\\t");
221 e += 2;
222 }
223 else if(c=='\\') {
224 strcpy(e, "\\\\");
225 e += 2;
226 }
227 else if(c=='"') {
228 strcpy(e, "\\\"");
229 e += 2;
230 }
231 else if(! isprint(c)) {
232 snprintf(e, 5, "\\%03o", (unsigned)c);
233 e += 4;
234 }
235 else
236 *e++ = c;
237 }
238 *e = '\0';
239 return escaped;
240 }
241
242 /* setopt wrapper for enum types */
tool_setopt_enum(CURL * curl,struct GlobalConfig * config,const char * name,CURLoption tag,const NameValue * nvlist,long lval)243 CURLcode tool_setopt_enum(CURL *curl, struct GlobalConfig *config,
244 const char *name, CURLoption tag,
245 const NameValue *nvlist, long lval)
246 {
247 CURLcode ret = CURLE_OK;
248 bool skip = FALSE;
249
250 ret = curl_easy_setopt(curl, tag, lval);
251 if(!lval)
252 skip = TRUE;
253
254 if(config->libcurl && !skip && !ret) {
255 /* we only use this for real if --libcurl was used */
256 const NameValue *nv = NULL;
257 for(nv=nvlist; nv->name; nv++) {
258 if(nv->value == lval) break; /* found it */
259 }
260 if(! nv->name) {
261 /* If no definition was found, output an explicit value.
262 * This could happen if new values are defined and used
263 * but the NameValue list is not updated. */
264 CODE2("curl_easy_setopt(hnd, %s, %ldL);", name, lval);
265 }
266 else {
267 CODE2("curl_easy_setopt(hnd, %s, (long)%s);", name, nv->name);
268 }
269 }
270
271 nomem:
272 return ret;
273 }
274
275 /* setopt wrapper for flags */
tool_setopt_flags(CURL * curl,struct GlobalConfig * config,const char * name,CURLoption tag,const NameValue * nvlist,long lval)276 CURLcode tool_setopt_flags(CURL *curl, struct GlobalConfig *config,
277 const char *name, CURLoption tag,
278 const NameValue *nvlist, long lval)
279 {
280 CURLcode ret = CURLE_OK;
281 bool skip = FALSE;
282
283 ret = curl_easy_setopt(curl, tag, lval);
284 if(!lval)
285 skip = TRUE;
286
287 if(config->libcurl && !skip && !ret) {
288 /* we only use this for real if --libcurl was used */
289 char preamble[80]; /* should accommodate any symbol name */
290 long rest = lval; /* bits not handled yet */
291 const NameValue *nv = NULL;
292 snprintf(preamble, sizeof(preamble),
293 "curl_easy_setopt(hnd, %s, ", name);
294 for(nv=nvlist; nv->name; nv++) {
295 if((nv->value & ~ rest) == 0) {
296 /* all value flags contained in rest */
297 rest &= ~ nv->value; /* remove bits handled here */
298 CODE3("%s(long)%s%s",
299 preamble, nv->name, rest ? " |" : ");");
300 if(!rest)
301 break; /* handled them all */
302 /* replace with all spaces for continuation line */
303 snprintf(preamble, sizeof(preamble), "%*s", strlen(preamble), "");
304 }
305 }
306 /* If any bits have no definition, output an explicit value.
307 * This could happen if new bits are defined and used
308 * but the NameValue list is not updated. */
309 if(rest)
310 CODE2("%s%ldL);", preamble, rest);
311 }
312
313 nomem:
314 return ret;
315 }
316
317 /* setopt wrapper for bitmasks */
tool_setopt_bitmask(CURL * curl,struct GlobalConfig * config,const char * name,CURLoption tag,const NameValueUnsigned * nvlist,long lval)318 CURLcode tool_setopt_bitmask(CURL *curl, struct GlobalConfig *config,
319 const char *name, CURLoption tag,
320 const NameValueUnsigned *nvlist,
321 long lval)
322 {
323 CURLcode ret = CURLE_OK;
324 bool skip = FALSE;
325
326 ret = curl_easy_setopt(curl, tag, lval);
327 if(!lval)
328 skip = TRUE;
329
330 if(config->libcurl && !skip && !ret) {
331 /* we only use this for real if --libcurl was used */
332 char preamble[80];
333 unsigned long rest = (unsigned long)lval;
334 const NameValueUnsigned *nv = NULL;
335 snprintf(preamble, sizeof(preamble),
336 "curl_easy_setopt(hnd, %s, ", name);
337 for(nv=nvlist; nv->name; nv++) {
338 if((nv->value & ~ rest) == 0) {
339 /* all value flags contained in rest */
340 rest &= ~ nv->value; /* remove bits handled here */
341 CODE3("%s(long)%s%s",
342 preamble, nv->name, rest ? " |" : ");");
343 if(!rest)
344 break; /* handled them all */
345 /* replace with all spaces for continuation line */
346 snprintf(preamble, sizeof(preamble), "%*s", strlen(preamble), "");
347 }
348 }
349 /* If any bits have no definition, output an explicit value.
350 * This could happen if new bits are defined and used
351 * but the NameValue list is not updated. */
352 if(rest)
353 CODE2("%s%luUL);", preamble, rest);
354 }
355
356 nomem:
357 return ret;
358 }
359
360 /* setopt wrapper for CURLOPT_HTTPPOST */
tool_setopt_httppost(CURL * curl,struct GlobalConfig * config,const char * name,CURLoption tag,struct curl_httppost * post)361 CURLcode tool_setopt_httppost(CURL *curl, struct GlobalConfig *config,
362 const char *name, CURLoption tag,
363 struct curl_httppost *post)
364 {
365 CURLcode ret = CURLE_OK;
366 char *escaped = NULL;
367 bool skip = FALSE;
368
369 ret = curl_easy_setopt(curl, tag, post);
370 if(!post)
371 skip = TRUE;
372
373 if(config->libcurl && !skip && !ret) {
374 struct curl_httppost *pp, *p;
375 int i;
376 /* May use several httppost lists, if multiple POST actions */
377 i = ++ easysrc_form_count;
378 DECL1("struct curl_httppost *post%d;", i);
379 DATA1("post%d = NULL;", i);
380 CLEAN1("curl_formfree(post%d);", i);
381 CLEAN1("post%d = NULL;", i);
382 if(i == 1)
383 DECL0("struct curl_httppost *postend;");
384 DATA0("postend = NULL;");
385 for(p=post; p; p=p->next) {
386 DATA1("curl_formadd(&post%d, &postend,", i);
387 DATA1(" CURLFORM_COPYNAME, \"%s\",", p->name);
388 for(pp=p; pp; pp=pp->more) {
389 /* May be several files uploaded for one name;
390 * these are linked through the 'more' pointer */
391 Curl_safefree(escaped);
392 escaped = c_escape(pp->contents);
393 if(!escaped) {
394 ret = CURLE_OUT_OF_MEMORY;
395 goto nomem;
396 }
397 if(pp->flags & CURL_HTTPPOST_FILENAME) {
398 /* file upload as for -F @filename */
399 DATA1(" CURLFORM_FILE, \"%s\",", escaped);
400 }
401 else if(pp->flags & CURL_HTTPPOST_READFILE) {
402 /* content from file as for -F <filename */
403 DATA1(" CURLFORM_FILECONTENT, \"%s\",", escaped);
404 }
405 else
406 DATA1(" CURLFORM_COPYCONTENTS, \"%s\",", escaped);
407 if(pp->showfilename) {
408 Curl_safefree(escaped);
409 escaped = c_escape(pp->showfilename);
410 if(!escaped) {
411 ret = CURLE_OUT_OF_MEMORY;
412 goto nomem;
413 }
414 DATA1(" CURLFORM_FILENAME, \"%s\",", escaped);
415 }
416 if(pp->contenttype) {
417 Curl_safefree(escaped);
418 escaped = c_escape(pp->contenttype);
419 if(!escaped) {
420 ret = CURLE_OUT_OF_MEMORY;
421 goto nomem;
422 }
423 DATA1(" CURLFORM_CONTENTTYPE, \"%s\",", escaped);
424 }
425 }
426 DATA0(" CURLFORM_END);");
427 }
428 CODE2("curl_easy_setopt(hnd, %s, post%d);", name, i);
429 }
430
431 nomem:
432 Curl_safefree(escaped);
433 return ret;
434 }
435
436 /* setopt wrapper for curl_slist options */
tool_setopt_slist(CURL * curl,struct GlobalConfig * config,const char * name,CURLoption tag,struct curl_slist * list)437 CURLcode tool_setopt_slist(CURL *curl, struct GlobalConfig *config,
438 const char *name, CURLoption tag,
439 struct curl_slist *list)
440 {
441 CURLcode ret = CURLE_OK;
442 char *escaped = NULL;
443 bool skip = FALSE;
444
445 ret = curl_easy_setopt(curl, tag, list);
446 if(!list)
447 skip = TRUE;
448
449 if(config->libcurl && !skip && !ret) {
450 struct curl_slist *s;
451 int i;
452 /* May need several slist variables, so invent name */
453 i = ++ easysrc_slist_count;
454 DECL1("struct curl_slist *slist%d;", i);
455 DATA1("slist%d = NULL;", i);
456 CLEAN1("curl_slist_free_all(slist%d);", i);
457 CLEAN1("slist%d = NULL;", i);
458 for(s=list; s; s=s->next) {
459 Curl_safefree(escaped);
460 escaped = c_escape(s->data);
461 if(!escaped) {
462 ret = CURLE_OUT_OF_MEMORY;
463 goto nomem;
464 }
465 DATA3("slist%d = curl_slist_append(slist%d, \"%s\");", i, i, escaped);
466 }
467 CODE2("curl_easy_setopt(hnd, %s, slist%d);", name, i);
468 }
469
470 nomem:
471 Curl_safefree(escaped);
472 return ret;
473 }
474
475 /* generic setopt wrapper for all other options.
476 * Some type information is encoded in the tag value. */
tool_setopt(CURL * curl,bool str,struct GlobalConfig * config,const char * name,CURLoption tag,...)477 CURLcode tool_setopt(CURL *curl, bool str, struct GlobalConfig *config,
478 const char *name, CURLoption tag, ...)
479 {
480 va_list arg;
481 char buf[256];
482 const char *value = NULL;
483 bool remark = FALSE;
484 bool skip = FALSE;
485 bool escape = FALSE;
486 char *escaped = NULL;
487 CURLcode ret = CURLE_OK;
488
489 va_start(arg, tag);
490
491 if(tag < CURLOPTTYPE_OBJECTPOINT) {
492 /* Value is expected to be a long */
493 long lval = va_arg(arg, long);
494 long defval = 0L;
495 const NameValue *nv = NULL;
496 for(nv=setopt_nv_CURLNONZERODEFAULTS; nv->name; nv++) {
497 if(!strcmp(name, nv->name)) {
498 defval = nv->value;
499 break; /* found it */
500 }
501 }
502
503 snprintf(buf, sizeof(buf), "%ldL", lval);
504 value = buf;
505 ret = curl_easy_setopt(curl, tag, lval);
506 if(lval == defval)
507 skip = TRUE;
508 }
509 else if(tag < CURLOPTTYPE_OFF_T) {
510 /* Value is some sort of object pointer */
511 void *pval = va_arg(arg, void *);
512
513 /* function pointers are never printable */
514 if(tag >= CURLOPTTYPE_FUNCTIONPOINT) {
515 if(pval) {
516 value = "functionpointer";
517 remark = TRUE;
518 }
519 else
520 skip = TRUE;
521 }
522
523 else if(pval && str) {
524 value = (char *)pval;
525 escape = TRUE;
526 }
527 else if(pval) {
528 value = "objectpointer";
529 remark = TRUE;
530 }
531 else
532 skip = TRUE;
533
534 ret = curl_easy_setopt(curl, tag, pval);
535
536 }
537 else {
538 /* Value is expected to be curl_off_t */
539 curl_off_t oval = va_arg(arg, curl_off_t);
540 snprintf(buf, sizeof(buf),
541 "(curl_off_t)%" CURL_FORMAT_CURL_OFF_T, oval);
542 value = buf;
543 ret = curl_easy_setopt(curl, tag, oval);
544
545 if(!oval)
546 skip = TRUE;
547 }
548
549 va_end(arg);
550
551 if(config->libcurl && !skip && !ret) {
552 /* we only use this for real if --libcurl was used */
553
554 if(remark)
555 REM2("%s set to a %s", name, value);
556 else {
557 if(escape) {
558 escaped = c_escape(value);
559 if(!escaped) {
560 ret = CURLE_OUT_OF_MEMORY;
561 goto nomem;
562 }
563 CODE2("curl_easy_setopt(hnd, %s, \"%s\");", name, escaped);
564 }
565 else
566 CODE2("curl_easy_setopt(hnd, %s, %s);", name, value);
567 }
568 }
569
570 nomem:
571 Curl_safefree(escaped);
572 return ret;
573 }
574
575 #endif /* CURL_DISABLE_LIBCURL_OPTION */
576