Annotation of embedaddon/curl/src/tool_setopt.c, revision 1.1
1.1 ! misho 1: /***************************************************************************
! 2: * _ _ ____ _
! 3: * Project ___| | | | _ \| |
! 4: * / __| | | | |_) | |
! 5: * | (__| |_| | _ <| |___
! 6: * \___|\___/|_| \_\_____|
! 7: *
! 8: * Copyright (C) 1998 - 2020, 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: #include "tool_convert.h"
! 34:
! 35: #include "memdebug.h" /* keep this as LAST include */
! 36:
! 37: /* Lookup tables for converting setopt values back to symbols */
! 38: /* For enums, values may be in any order. */
! 39: /* For bit masks, put combinations first, then single bits, */
! 40: /* and finally any "NONE" value. */
! 41:
! 42: #define NV(e) {#e, e}
! 43: #define NV1(e, v) {#e, (v)}
! 44: #define NVEND {NULL, 0} /* sentinel to mark end of list */
! 45:
! 46: const NameValue setopt_nv_CURLPROXY[] = {
! 47: NV(CURLPROXY_HTTP),
! 48: NV(CURLPROXY_HTTP_1_0),
! 49: NV(CURLPROXY_HTTPS),
! 50: NV(CURLPROXY_SOCKS4),
! 51: NV(CURLPROXY_SOCKS5),
! 52: NV(CURLPROXY_SOCKS4A),
! 53: NV(CURLPROXY_SOCKS5_HOSTNAME),
! 54: NVEND,
! 55: };
! 56:
! 57: const NameValue setopt_nv_CURL_SOCKS_PROXY[] = {
! 58: NV(CURLPROXY_SOCKS4),
! 59: NV(CURLPROXY_SOCKS5),
! 60: NV(CURLPROXY_SOCKS4A),
! 61: NV(CURLPROXY_SOCKS5_HOSTNAME),
! 62: NVEND,
! 63: };
! 64:
! 65: const NameValueUnsigned setopt_nv_CURLAUTH[] = {
! 66: NV(CURLAUTH_ANY), /* combination */
! 67: NV(CURLAUTH_ANYSAFE), /* combination */
! 68: NV(CURLAUTH_BASIC),
! 69: NV(CURLAUTH_DIGEST),
! 70: NV(CURLAUTH_GSSNEGOTIATE),
! 71: NV(CURLAUTH_NTLM),
! 72: NV(CURLAUTH_DIGEST_IE),
! 73: NV(CURLAUTH_NTLM_WB),
! 74: NV(CURLAUTH_ONLY),
! 75: NV(CURLAUTH_NONE),
! 76: NVEND,
! 77: };
! 78:
! 79: const NameValue setopt_nv_CURL_HTTP_VERSION[] = {
! 80: NV(CURL_HTTP_VERSION_NONE),
! 81: NV(CURL_HTTP_VERSION_1_0),
! 82: NV(CURL_HTTP_VERSION_1_1),
! 83: NV(CURL_HTTP_VERSION_2_0),
! 84: NV(CURL_HTTP_VERSION_2TLS),
! 85: NV(CURL_HTTP_VERSION_3),
! 86: NVEND,
! 87: };
! 88:
! 89: const NameValue setopt_nv_CURL_SSLVERSION[] = {
! 90: NV(CURL_SSLVERSION_DEFAULT),
! 91: NV(CURL_SSLVERSION_TLSv1),
! 92: NV(CURL_SSLVERSION_SSLv2),
! 93: NV(CURL_SSLVERSION_SSLv3),
! 94: NV(CURL_SSLVERSION_TLSv1_0),
! 95: NV(CURL_SSLVERSION_TLSv1_1),
! 96: NV(CURL_SSLVERSION_TLSv1_2),
! 97: NV(CURL_SSLVERSION_TLSv1_3),
! 98: NVEND,
! 99: };
! 100:
! 101: const NameValue setopt_nv_CURL_TIMECOND[] = {
! 102: NV(CURL_TIMECOND_IFMODSINCE),
! 103: NV(CURL_TIMECOND_IFUNMODSINCE),
! 104: NV(CURL_TIMECOND_LASTMOD),
! 105: NV(CURL_TIMECOND_NONE),
! 106: NVEND,
! 107: };
! 108:
! 109: const NameValue setopt_nv_CURLFTPSSL_CCC[] = {
! 110: NV(CURLFTPSSL_CCC_NONE),
! 111: NV(CURLFTPSSL_CCC_PASSIVE),
! 112: NV(CURLFTPSSL_CCC_ACTIVE),
! 113: NVEND,
! 114: };
! 115:
! 116: const NameValue setopt_nv_CURLUSESSL[] = {
! 117: NV(CURLUSESSL_NONE),
! 118: NV(CURLUSESSL_TRY),
! 119: NV(CURLUSESSL_CONTROL),
! 120: NV(CURLUSESSL_ALL),
! 121: NVEND,
! 122: };
! 123:
! 124: const NameValueUnsigned setopt_nv_CURLSSLOPT[] = {
! 125: NV(CURLSSLOPT_ALLOW_BEAST),
! 126: NV(CURLSSLOPT_NO_REVOKE),
! 127: NV(CURLSSLOPT_NO_PARTIALCHAIN),
! 128: NV(CURLSSLOPT_REVOKE_BEST_EFFORT),
! 129: NVEND,
! 130: };
! 131:
! 132: const NameValue setopt_nv_CURL_NETRC[] = {
! 133: NV(CURL_NETRC_IGNORED),
! 134: NV(CURL_NETRC_OPTIONAL),
! 135: NV(CURL_NETRC_REQUIRED),
! 136: NVEND,
! 137: };
! 138:
! 139: /* These mappings essentially triplicated - see
! 140: * tool_libinfo.c and tool_paramhlp.c */
! 141: const NameValue setopt_nv_CURLPROTO[] = {
! 142: NV(CURLPROTO_ALL), /* combination */
! 143: NV(CURLPROTO_DICT),
! 144: NV(CURLPROTO_FILE),
! 145: NV(CURLPROTO_FTP),
! 146: NV(CURLPROTO_FTPS),
! 147: NV(CURLPROTO_GOPHER),
! 148: NV(CURLPROTO_HTTP),
! 149: NV(CURLPROTO_HTTPS),
! 150: NV(CURLPROTO_IMAP),
! 151: NV(CURLPROTO_IMAPS),
! 152: NV(CURLPROTO_LDAP),
! 153: NV(CURLPROTO_LDAPS),
! 154: NV(CURLPROTO_POP3),
! 155: NV(CURLPROTO_POP3S),
! 156: NV(CURLPROTO_RTSP),
! 157: NV(CURLPROTO_SCP),
! 158: NV(CURLPROTO_SFTP),
! 159: NV(CURLPROTO_SMB),
! 160: NV(CURLPROTO_SMBS),
! 161: NV(CURLPROTO_SMTP),
! 162: NV(CURLPROTO_SMTPS),
! 163: NV(CURLPROTO_TELNET),
! 164: NV(CURLPROTO_TFTP),
! 165: NVEND,
! 166: };
! 167:
! 168: /* These options have non-zero default values. */
! 169: static const NameValue setopt_nv_CURLNONZERODEFAULTS[] = {
! 170: NV1(CURLOPT_SSL_VERIFYPEER, 1),
! 171: NV1(CURLOPT_SSL_VERIFYHOST, 1),
! 172: NV1(CURLOPT_SSL_ENABLE_NPN, 1),
! 173: NV1(CURLOPT_SSL_ENABLE_ALPN, 1),
! 174: NV1(CURLOPT_TCP_NODELAY, 1),
! 175: NV1(CURLOPT_PROXY_SSL_VERIFYPEER, 1),
! 176: NV1(CURLOPT_PROXY_SSL_VERIFYHOST, 1),
! 177: NV1(CURLOPT_SOCKS5_AUTH, 1),
! 178: NVEND
! 179: };
! 180:
! 181: /* Format and add code; jump to nomem on malloc error */
! 182: #define ADD(args) do { \
! 183: ret = easysrc_add args; \
! 184: if(ret) \
! 185: goto nomem; \
! 186: } while(0)
! 187: #define ADDF(args) do { \
! 188: ret = easysrc_addf args; \
! 189: if(ret) \
! 190: goto nomem; \
! 191: } while(0)
! 192: #define NULL_CHECK(p) do { \
! 193: if(!p) { \
! 194: ret = CURLE_OUT_OF_MEMORY; \
! 195: goto nomem; \
! 196: } \
! 197: } while(0)
! 198:
! 199: #define DECL0(s) ADD((&easysrc_decl, s))
! 200: #define DECL1(f,a) ADDF((&easysrc_decl, f,a))
! 201:
! 202: #define DATA0(s) ADD((&easysrc_data, s))
! 203: #define DATA1(f,a) ADDF((&easysrc_data, f,a))
! 204: #define DATA2(f,a,b) ADDF((&easysrc_data, f,a,b))
! 205: #define DATA3(f,a,b,c) ADDF((&easysrc_data, f,a,b,c))
! 206:
! 207: #define CODE0(s) ADD((&easysrc_code, s))
! 208: #define CODE1(f,a) ADDF((&easysrc_code, f,a))
! 209: #define CODE2(f,a,b) ADDF((&easysrc_code, f,a,b))
! 210: #define CODE3(f,a,b,c) ADDF((&easysrc_code, f,a,b,c))
! 211:
! 212: #define CLEAN0(s) ADD((&easysrc_clean, s))
! 213: #define CLEAN1(f,a) ADDF((&easysrc_clean, f,a))
! 214:
! 215: #define REM0(s) ADD((&easysrc_toohard, s))
! 216: #define REM1(f,a) ADDF((&easysrc_toohard, f,a))
! 217: #define REM2(f,a,b) ADDF((&easysrc_toohard, f,a,b))
! 218:
! 219: /* Escape string to C string syntax. Return NULL if out of memory.
! 220: * Is this correct for those wacky EBCDIC guys? */
! 221: static char *c_escape(const char *str, size_t len)
! 222: {
! 223: const char *s;
! 224: unsigned char c;
! 225: char *escaped, *e;
! 226:
! 227: if(len == CURL_ZERO_TERMINATED)
! 228: len = strlen(str);
! 229:
! 230: /* Check for possible overflow. */
! 231: if(len > (~(size_t) 0) / 4)
! 232: return NULL;
! 233:
! 234: /* Allocate space based on worst-case */
! 235: escaped = malloc(4 * len + 1);
! 236: if(!escaped)
! 237: return NULL;
! 238:
! 239: e = escaped;
! 240: for(s = str; (c = *s) != '\0'; s++) {
! 241: if(c == '\n') {
! 242: strcpy(e, "\\n");
! 243: e += 2;
! 244: }
! 245: else if(c == '\r') {
! 246: strcpy(e, "\\r");
! 247: e += 2;
! 248: }
! 249: else if(c == '\t') {
! 250: strcpy(e, "\\t");
! 251: e += 2;
! 252: }
! 253: else if(c == '\\') {
! 254: strcpy(e, "\\\\");
! 255: e += 2;
! 256: }
! 257: else if(c == '"') {
! 258: strcpy(e, "\\\"");
! 259: e += 2;
! 260: }
! 261: else if(! isprint(c)) {
! 262: msnprintf(e, 5, "\\%03o", (unsigned)c);
! 263: e += 4;
! 264: }
! 265: else
! 266: *e++ = c;
! 267: }
! 268: *e = '\0';
! 269: return escaped;
! 270: }
! 271:
! 272: /* setopt wrapper for enum types */
! 273: CURLcode tool_setopt_enum(CURL *curl, struct GlobalConfig *config,
! 274: const char *name, CURLoption tag,
! 275: const NameValue *nvlist, long lval)
! 276: {
! 277: CURLcode ret = CURLE_OK;
! 278: bool skip = FALSE;
! 279:
! 280: ret = curl_easy_setopt(curl, tag, lval);
! 281: if(!lval)
! 282: skip = TRUE;
! 283:
! 284: if(config->libcurl && !skip && !ret) {
! 285: /* we only use this for real if --libcurl was used */
! 286: const NameValue *nv = NULL;
! 287: for(nv = nvlist; nv->name; nv++) {
! 288: if(nv->value == lval)
! 289: break; /* found it */
! 290: }
! 291: if(! nv->name) {
! 292: /* If no definition was found, output an explicit value.
! 293: * This could happen if new values are defined and used
! 294: * but the NameValue list is not updated. */
! 295: CODE2("curl_easy_setopt(hnd, %s, %ldL);", name, lval);
! 296: }
! 297: else {
! 298: CODE2("curl_easy_setopt(hnd, %s, (long)%s);", name, nv->name);
! 299: }
! 300: }
! 301:
! 302: nomem:
! 303: return ret;
! 304: }
! 305:
! 306: /* setopt wrapper for flags */
! 307: CURLcode tool_setopt_flags(CURL *curl, struct GlobalConfig *config,
! 308: const char *name, CURLoption tag,
! 309: const NameValue *nvlist, long lval)
! 310: {
! 311: CURLcode ret = CURLE_OK;
! 312: bool skip = FALSE;
! 313:
! 314: ret = curl_easy_setopt(curl, tag, lval);
! 315: if(!lval)
! 316: skip = TRUE;
! 317:
! 318: if(config->libcurl && !skip && !ret) {
! 319: /* we only use this for real if --libcurl was used */
! 320: char preamble[80]; /* should accommodate any symbol name */
! 321: long rest = lval; /* bits not handled yet */
! 322: const NameValue *nv = NULL;
! 323: msnprintf(preamble, sizeof(preamble),
! 324: "curl_easy_setopt(hnd, %s, ", name);
! 325: for(nv = nvlist; nv->name; nv++) {
! 326: if((nv->value & ~ rest) == 0) {
! 327: /* all value flags contained in rest */
! 328: rest &= ~ nv->value; /* remove bits handled here */
! 329: CODE3("%s(long)%s%s",
! 330: preamble, nv->name, rest ? " |" : ");");
! 331: if(!rest)
! 332: break; /* handled them all */
! 333: /* replace with all spaces for continuation line */
! 334: msnprintf(preamble, sizeof(preamble), "%*s", strlen(preamble), "");
! 335: }
! 336: }
! 337: /* If any bits have no definition, output an explicit value.
! 338: * This could happen if new bits are defined and used
! 339: * but the NameValue list is not updated. */
! 340: if(rest)
! 341: CODE2("%s%ldL);", preamble, rest);
! 342: }
! 343:
! 344: nomem:
! 345: return ret;
! 346: }
! 347:
! 348: /* setopt wrapper for bitmasks */
! 349: CURLcode tool_setopt_bitmask(CURL *curl, struct GlobalConfig *config,
! 350: const char *name, CURLoption tag,
! 351: const NameValueUnsigned *nvlist,
! 352: long lval)
! 353: {
! 354: CURLcode ret = CURLE_OK;
! 355: bool skip = FALSE;
! 356:
! 357: ret = curl_easy_setopt(curl, tag, lval);
! 358: if(!lval)
! 359: skip = TRUE;
! 360:
! 361: if(config->libcurl && !skip && !ret) {
! 362: /* we only use this for real if --libcurl was used */
! 363: char preamble[80];
! 364: unsigned long rest = (unsigned long)lval;
! 365: const NameValueUnsigned *nv = NULL;
! 366: msnprintf(preamble, sizeof(preamble),
! 367: "curl_easy_setopt(hnd, %s, ", name);
! 368: for(nv = nvlist; nv->name; nv++) {
! 369: if((nv->value & ~ rest) == 0) {
! 370: /* all value flags contained in rest */
! 371: rest &= ~ nv->value; /* remove bits handled here */
! 372: CODE3("%s(long)%s%s",
! 373: preamble, nv->name, rest ? " |" : ");");
! 374: if(!rest)
! 375: break; /* handled them all */
! 376: /* replace with all spaces for continuation line */
! 377: msnprintf(preamble, sizeof(preamble), "%*s", strlen(preamble), "");
! 378: }
! 379: }
! 380: /* If any bits have no definition, output an explicit value.
! 381: * This could happen if new bits are defined and used
! 382: * but the NameValue list is not updated. */
! 383: if(rest)
! 384: CODE2("%s%luUL);", preamble, rest);
! 385: }
! 386:
! 387: nomem:
! 388: return ret;
! 389: }
! 390:
! 391: /* Generate code for a struct curl_slist. */
! 392: static CURLcode libcurl_generate_slist(struct curl_slist *slist, int *slistno)
! 393: {
! 394: CURLcode ret = CURLE_OK;
! 395: char *escaped = NULL;
! 396:
! 397: /* May need several slist variables, so invent name */
! 398: *slistno = ++easysrc_slist_count;
! 399:
! 400: DECL1("struct curl_slist *slist%d;", *slistno);
! 401: DATA1("slist%d = NULL;", *slistno);
! 402: CLEAN1("curl_slist_free_all(slist%d);", *slistno);
! 403: CLEAN1("slist%d = NULL;", *slistno);
! 404: for(; slist; slist = slist->next) {
! 405: Curl_safefree(escaped);
! 406: escaped = c_escape(slist->data, CURL_ZERO_TERMINATED);
! 407: if(!escaped)
! 408: return CURLE_OUT_OF_MEMORY;
! 409: DATA3("slist%d = curl_slist_append(slist%d, \"%s\");",
! 410: *slistno, *slistno, escaped);
! 411: }
! 412:
! 413: nomem:
! 414: Curl_safefree(escaped);
! 415: return ret;
! 416: }
! 417:
! 418: static CURLcode libcurl_generate_mime(CURL *curl,
! 419: struct GlobalConfig *config,
! 420: tool_mime *toolmime,
! 421: int *mimeno); /* Forward. */
! 422:
! 423: /* Wrapper to generate source code for a mime part. */
! 424: static CURLcode libcurl_generate_mime_part(CURL *curl,
! 425: struct GlobalConfig *config,
! 426: tool_mime *part,
! 427: int mimeno)
! 428: {
! 429: CURLcode ret = CURLE_OK;
! 430: int submimeno = 0;
! 431: char *escaped = NULL;
! 432: const char *data = NULL;
! 433: const char *filename = part->filename;
! 434:
! 435: /* Parts are linked in reverse order. */
! 436: if(part->prev) {
! 437: ret = libcurl_generate_mime_part(curl, config, part->prev, mimeno);
! 438: if(ret)
! 439: return ret;
! 440: }
! 441:
! 442: /* Create the part. */
! 443: CODE2("part%d = curl_mime_addpart(mime%d);", mimeno, mimeno);
! 444:
! 445: switch(part->kind) {
! 446: case TOOLMIME_PARTS:
! 447: ret = libcurl_generate_mime(curl, config, part, &submimeno);
! 448: if(!ret) {
! 449: CODE2("curl_mime_subparts(part%d, mime%d);", mimeno, submimeno);
! 450: CODE1("mime%d = NULL;", submimeno); /* Avoid freeing in CLEAN. */
! 451: }
! 452: break;
! 453:
! 454: case TOOLMIME_DATA:
! 455: #ifdef CURL_DOES_CONVERSIONS
! 456: /* Data will be set in ASCII, thus issue a comment with clear text. */
! 457: escaped = c_escape(part->data, CURL_ZERO_TERMINATED);
! 458: NULL_CHECK(escaped);
! 459: CODE1("/* \"%s\" */", escaped);
! 460:
! 461: /* Our data is always textual: convert it to ASCII. */
! 462: {
! 463: size_t size = strlen(part->data);
! 464: char *cp = malloc(size + 1);
! 465:
! 466: NULL_CHECK(cp);
! 467: memcpy(cp, part->data, size + 1);
! 468: ret = convert_to_network(cp, size);
! 469: data = cp;
! 470: }
! 471: #else
! 472: data = part->data;
! 473: #endif
! 474: if(!ret) {
! 475: Curl_safefree(escaped);
! 476: escaped = c_escape(data, CURL_ZERO_TERMINATED);
! 477: NULL_CHECK(escaped);
! 478: CODE2("curl_mime_data(part%d, \"%s\", CURL_ZERO_TERMINATED);",
! 479: mimeno, escaped);
! 480: }
! 481: break;
! 482:
! 483: case TOOLMIME_FILE:
! 484: case TOOLMIME_FILEDATA:
! 485: escaped = c_escape(part->data, CURL_ZERO_TERMINATED);
! 486: NULL_CHECK(escaped);
! 487: CODE2("curl_mime_filedata(part%d, \"%s\");", mimeno, escaped);
! 488: if(part->kind == TOOLMIME_FILEDATA && !filename) {
! 489: CODE1("curl_mime_filename(part%d, NULL);", mimeno);
! 490: }
! 491: break;
! 492:
! 493: case TOOLMIME_STDIN:
! 494: if(!filename)
! 495: filename = "-";
! 496: /* FALLTHROUGH */
! 497: case TOOLMIME_STDINDATA:
! 498: /* Can only be reading stdin in the current context. */
! 499: CODE1("curl_mime_data_cb(part%d, -1, (curl_read_callback) fread, \\",
! 500: mimeno);
! 501: CODE0(" (curl_seek_callback) fseek, NULL, stdin);");
! 502: break;
! 503: default:
! 504: /* Other cases not possible in this context. */
! 505: break;
! 506: }
! 507:
! 508: if(!ret && part->encoder) {
! 509: Curl_safefree(escaped);
! 510: escaped = c_escape(part->encoder, CURL_ZERO_TERMINATED);
! 511: NULL_CHECK(escaped);
! 512: CODE2("curl_mime_encoder(part%d, \"%s\");", mimeno, escaped);
! 513: }
! 514:
! 515: if(!ret && filename) {
! 516: Curl_safefree(escaped);
! 517: escaped = c_escape(filename, CURL_ZERO_TERMINATED);
! 518: NULL_CHECK(escaped);
! 519: CODE2("curl_mime_filename(part%d, \"%s\");", mimeno, escaped);
! 520: }
! 521:
! 522: if(!ret && part->name) {
! 523: Curl_safefree(escaped);
! 524: escaped = c_escape(part->name, CURL_ZERO_TERMINATED);
! 525: NULL_CHECK(escaped);
! 526: CODE2("curl_mime_name(part%d, \"%s\");", mimeno, escaped);
! 527: }
! 528:
! 529: if(!ret && part->type) {
! 530: Curl_safefree(escaped);
! 531: escaped = c_escape(part->type, CURL_ZERO_TERMINATED);
! 532: NULL_CHECK(escaped);
! 533: CODE2("curl_mime_type(part%d, \"%s\");", mimeno, escaped);
! 534: }
! 535:
! 536: if(!ret && part->headers) {
! 537: int slistno;
! 538:
! 539: ret = libcurl_generate_slist(part->headers, &slistno);
! 540: if(!ret) {
! 541: CODE2("curl_mime_headers(part%d, slist%d, 1);", mimeno, slistno);
! 542: CODE1("slist%d = NULL;", slistno); /* Prevent CLEANing. */
! 543: }
! 544: }
! 545:
! 546: nomem:
! 547: #ifdef CURL_DOES_CONVERSIONS
! 548: if(data)
! 549: free((char *) data);
! 550: #endif
! 551:
! 552: Curl_safefree(escaped);
! 553: return ret;
! 554: }
! 555:
! 556: /* Wrapper to generate source code for a mime structure. */
! 557: static CURLcode libcurl_generate_mime(CURL *curl,
! 558: struct GlobalConfig *config,
! 559: tool_mime *toolmime,
! 560: int *mimeno)
! 561: {
! 562: CURLcode ret = CURLE_OK;
! 563:
! 564: /* May need several mime variables, so invent name. */
! 565: *mimeno = ++easysrc_mime_count;
! 566: DECL1("curl_mime *mime%d;", *mimeno);
! 567: DATA1("mime%d = NULL;", *mimeno);
! 568: CODE1("mime%d = curl_mime_init(hnd);", *mimeno);
! 569: CLEAN1("curl_mime_free(mime%d);", *mimeno);
! 570: CLEAN1("mime%d = NULL;", *mimeno);
! 571:
! 572: if(toolmime->subparts) {
! 573: DECL1("curl_mimepart *part%d;", *mimeno);
! 574: ret = libcurl_generate_mime_part(curl, config,
! 575: toolmime->subparts, *mimeno);
! 576: }
! 577:
! 578: nomem:
! 579: return ret;
! 580: }
! 581:
! 582: /* setopt wrapper for CURLOPT_MIMEPOST */
! 583: CURLcode tool_setopt_mimepost(CURL *curl, struct GlobalConfig *config,
! 584: const char *name, CURLoption tag,
! 585: curl_mime *mimepost)
! 586: {
! 587: CURLcode ret = curl_easy_setopt(curl, tag, mimepost);
! 588: int mimeno = 0;
! 589:
! 590: if(!ret && config->libcurl) {
! 591: ret = libcurl_generate_mime(curl, config,
! 592: config->current->mimeroot, &mimeno);
! 593:
! 594: if(!ret)
! 595: CODE2("curl_easy_setopt(hnd, %s, mime%d);", name, mimeno);
! 596: }
! 597:
! 598: nomem:
! 599: return ret;
! 600: }
! 601:
! 602: /* setopt wrapper for curl_slist options */
! 603: CURLcode tool_setopt_slist(CURL *curl, struct GlobalConfig *config,
! 604: const char *name, CURLoption tag,
! 605: struct curl_slist *list)
! 606: {
! 607: CURLcode ret = CURLE_OK;
! 608:
! 609: ret = curl_easy_setopt(curl, tag, list);
! 610:
! 611: if(config->libcurl && list && !ret) {
! 612: int i;
! 613:
! 614: ret = libcurl_generate_slist(list, &i);
! 615: if(!ret)
! 616: CODE2("curl_easy_setopt(hnd, %s, slist%d);", name, i);
! 617: }
! 618:
! 619: nomem:
! 620: return ret;
! 621: }
! 622:
! 623: /* generic setopt wrapper for all other options.
! 624: * Some type information is encoded in the tag value. */
! 625: CURLcode tool_setopt(CURL *curl, bool str, struct GlobalConfig *config,
! 626: const char *name, CURLoption tag, ...)
! 627: {
! 628: va_list arg;
! 629: char buf[256];
! 630: const char *value = NULL;
! 631: bool remark = FALSE;
! 632: bool skip = FALSE;
! 633: bool escape = FALSE;
! 634: char *escaped = NULL;
! 635: CURLcode ret = CURLE_OK;
! 636:
! 637: va_start(arg, tag);
! 638:
! 639: if(tag < CURLOPTTYPE_OBJECTPOINT) {
! 640: /* Value is expected to be a long */
! 641: long lval = va_arg(arg, long);
! 642: long defval = 0L;
! 643: const NameValue *nv = NULL;
! 644: for(nv = setopt_nv_CURLNONZERODEFAULTS; nv->name; nv++) {
! 645: if(!strcmp(name, nv->name)) {
! 646: defval = nv->value;
! 647: break; /* found it */
! 648: }
! 649: }
! 650:
! 651: msnprintf(buf, sizeof(buf), "%ldL", lval);
! 652: value = buf;
! 653: ret = curl_easy_setopt(curl, tag, lval);
! 654: if(lval == defval)
! 655: skip = TRUE;
! 656: }
! 657: else if(tag < CURLOPTTYPE_OFF_T) {
! 658: /* Value is some sort of object pointer */
! 659: void *pval = va_arg(arg, void *);
! 660:
! 661: /* function pointers are never printable */
! 662: if(tag >= CURLOPTTYPE_FUNCTIONPOINT) {
! 663: if(pval) {
! 664: value = "functionpointer";
! 665: remark = TRUE;
! 666: }
! 667: else
! 668: skip = TRUE;
! 669: }
! 670:
! 671: else if(pval && str) {
! 672: value = (char *)pval;
! 673: escape = TRUE;
! 674: }
! 675: else if(pval) {
! 676: value = "objectpointer";
! 677: remark = TRUE;
! 678: }
! 679: else
! 680: skip = TRUE;
! 681:
! 682: ret = curl_easy_setopt(curl, tag, pval);
! 683:
! 684: }
! 685: else {
! 686: /* Value is expected to be curl_off_t */
! 687: curl_off_t oval = va_arg(arg, curl_off_t);
! 688: msnprintf(buf, sizeof(buf),
! 689: "(curl_off_t)%" CURL_FORMAT_CURL_OFF_T, oval);
! 690: value = buf;
! 691: ret = curl_easy_setopt(curl, tag, oval);
! 692:
! 693: if(!oval)
! 694: skip = TRUE;
! 695: }
! 696:
! 697: va_end(arg);
! 698:
! 699: if(config->libcurl && !skip && !ret) {
! 700: /* we only use this for real if --libcurl was used */
! 701:
! 702: if(remark)
! 703: REM2("%s set to a %s", name, value);
! 704: else {
! 705: if(escape) {
! 706: escaped = c_escape(value, CURL_ZERO_TERMINATED);
! 707: NULL_CHECK(escaped);
! 708: CODE2("curl_easy_setopt(hnd, %s, \"%s\");", name, escaped);
! 709: }
! 710: else
! 711: CODE2("curl_easy_setopt(hnd, %s, %s);", name, value);
! 712: }
! 713: }
! 714:
! 715: nomem:
! 716: Curl_safefree(escaped);
! 717: return ret;
! 718: }
! 719:
! 720: #else /* CURL_DISABLE_LIBCURL_OPTION */
! 721:
! 722: #include "tool_cfgable.h"
! 723: #include "tool_setopt.h"
! 724:
! 725: #endif /* CURL_DISABLE_LIBCURL_OPTION */
! 726:
! 727: /*
! 728: * tool_setopt_skip() allows the curl tool code to avoid setopt options that
! 729: * are explicitly disabled in the build.
! 730: */
! 731: bool tool_setopt_skip(CURLoption tag)
! 732: {
! 733: #ifdef CURL_DISABLE_PROXY
! 734: #define USED_TAG
! 735: switch(tag) {
! 736: case CURLOPT_HAPROXYPROTOCOL:
! 737: case CURLOPT_HTTPPROXYTUNNEL:
! 738: case CURLOPT_NOPROXY:
! 739: case CURLOPT_PRE_PROXY:
! 740: case CURLOPT_PROXY:
! 741: case CURLOPT_PROXYAUTH:
! 742: case CURLOPT_PROXY_CAINFO:
! 743: case CURLOPT_PROXY_CAPATH:
! 744: case CURLOPT_PROXY_CRLFILE:
! 745: case CURLOPT_PROXYHEADER:
! 746: case CURLOPT_PROXY_KEYPASSWD:
! 747: case CURLOPT_PROXYPASSWORD:
! 748: case CURLOPT_PROXY_PINNEDPUBLICKEY:
! 749: case CURLOPT_PROXYPORT:
! 750: case CURLOPT_PROXY_SERVICE_NAME:
! 751: case CURLOPT_PROXY_SSLCERT:
! 752: case CURLOPT_PROXY_SSLCERTTYPE:
! 753: case CURLOPT_PROXY_SSL_CIPHER_LIST:
! 754: case CURLOPT_PROXY_SSLKEY:
! 755: case CURLOPT_PROXY_SSLKEYTYPE:
! 756: case CURLOPT_PROXY_SSL_OPTIONS:
! 757: case CURLOPT_PROXY_SSL_VERIFYHOST:
! 758: case CURLOPT_PROXY_SSL_VERIFYPEER:
! 759: case CURLOPT_PROXY_SSLVERSION:
! 760: case CURLOPT_PROXY_TLS13_CIPHERS:
! 761: case CURLOPT_PROXY_TLSAUTH_PASSWORD:
! 762: case CURLOPT_PROXY_TLSAUTH_TYPE:
! 763: case CURLOPT_PROXY_TLSAUTH_USERNAME:
! 764: case CURLOPT_PROXY_TRANSFER_MODE:
! 765: case CURLOPT_PROXYTYPE:
! 766: case CURLOPT_PROXYUSERNAME:
! 767: case CURLOPT_PROXYUSERPWD:
! 768: return TRUE;
! 769: default:
! 770: break;
! 771: }
! 772: #endif
! 773: #ifdef CURL_DISABLE_FTP
! 774: #define USED_TAG
! 775: switch(tag) {
! 776: case CURLOPT_FTPPORT:
! 777: case CURLOPT_FTP_ACCOUNT:
! 778: case CURLOPT_FTP_ALTERNATIVE_TO_USER:
! 779: case CURLOPT_FTP_FILEMETHOD:
! 780: case CURLOPT_FTP_SKIP_PASV_IP:
! 781: case CURLOPT_FTP_USE_EPRT:
! 782: case CURLOPT_FTP_USE_EPSV:
! 783: case CURLOPT_FTP_USE_PRET:
! 784: case CURLOPT_KRBLEVEL:
! 785: return TRUE;
! 786: default:
! 787: break;
! 788: }
! 789: #endif
! 790: #ifdef CURL_DISABLE_RTSP
! 791: #define USED_TAG
! 792: switch(tag) {
! 793: case CURLOPT_INTERLEAVEDATA:
! 794: return TRUE;
! 795: default:
! 796: break;
! 797: }
! 798: #endif
! 799: #if defined(CURL_DISABLE_HTTP) || defined(CURL_DISABLE_COOKIES)
! 800: #define USED_TAG
! 801: switch(tag) {
! 802: case CURLOPT_COOKIE:
! 803: case CURLOPT_COOKIEFILE:
! 804: case CURLOPT_COOKIEJAR:
! 805: case CURLOPT_COOKIESESSION:
! 806: return TRUE;
! 807: default:
! 808: break;
! 809: }
! 810: #endif
! 811: #if defined(CURL_DISABLE_TELNET)
! 812: #define USED_TAG
! 813: switch(tag) {
! 814: case CURLOPT_TELNETOPTIONS:
! 815: return TRUE;
! 816: default:
! 817: break;
! 818: }
! 819: #endif
! 820: #ifdef CURL_DISABLE_TFTP
! 821: #define USED_TAG
! 822: switch(tag) {
! 823: case CURLOPT_TFTP_BLKSIZE:
! 824: case CURLOPT_TFTP_NO_OPTIONS:
! 825: return TRUE;
! 826: default:
! 827: break;
! 828: }
! 829: #endif
! 830: #ifdef CURL_DISABLE_NETRC
! 831: #define USED_TAG
! 832: switch(tag) {
! 833: case CURLOPT_NETRC:
! 834: case CURLOPT_NETRC_FILE:
! 835: return TRUE;
! 836: default:
! 837: break;
! 838: }
! 839: #endif
! 840:
! 841: #ifndef USED_TAG
! 842: (void)tag;
! 843: #endif
! 844: return FALSE;
! 845: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to tool_setopt.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / curl / src