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