Annotation of embedaddon/curl/src/tool_paramhlp.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: #include "strcase.h"
! 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_getparam.h"
! 32: #include "tool_getpass.h"
! 33: #include "tool_homedir.h"
! 34: #include "tool_msgs.h"
! 35: #include "tool_paramhlp.h"
! 36: #include "tool_version.h"
! 37:
! 38: #include "memdebug.h" /* keep this as LAST include */
! 39:
! 40: struct getout *new_getout(struct OperationConfig *config)
! 41: {
! 42: struct getout *node = calloc(1, sizeof(struct getout));
! 43: struct getout *last = config->url_last;
! 44: if(node) {
! 45: /* append this new node last in the list */
! 46: if(last)
! 47: last->next = node;
! 48: else
! 49: config->url_list = node; /* first node */
! 50:
! 51: /* move the last pointer */
! 52: config->url_last = node;
! 53:
! 54: node->flags = config->default_node_flags;
! 55: }
! 56: return node;
! 57: }
! 58:
! 59: ParameterError file2string(char **bufp, FILE *file)
! 60: {
! 61: char *string = NULL;
! 62: if(file) {
! 63: char *ptr;
! 64: size_t alloc = 512;
! 65: size_t alloc_needed;
! 66: char buffer[256];
! 67: size_t stringlen = 0;
! 68: string = calloc(1, alloc);
! 69: if(!string)
! 70: return PARAM_NO_MEM;
! 71:
! 72: while(fgets(buffer, sizeof(buffer), file)) {
! 73: size_t buflen;
! 74: ptr = strchr(buffer, '\r');
! 75: if(ptr)
! 76: *ptr = '\0';
! 77: ptr = strchr(buffer, '\n');
! 78: if(ptr)
! 79: *ptr = '\0';
! 80: buflen = strlen(buffer);
! 81: alloc_needed = stringlen + buflen + 1;
! 82: if(alloc < alloc_needed) {
! 83: #if SIZEOF_SIZE_T < 8
! 84: if(alloc >= (size_t)SIZE_T_MAX/2) {
! 85: Curl_safefree(string);
! 86: return PARAM_NO_MEM;
! 87: }
! 88: #endif
! 89: /* doubling is enough since the string to add is always max 256 bytes
! 90: and the alloc size start at 512 */
! 91: alloc *= 2;
! 92: ptr = realloc(string, alloc);
! 93: if(!ptr) {
! 94: Curl_safefree(string);
! 95: return PARAM_NO_MEM;
! 96: }
! 97: string = ptr;
! 98: }
! 99: strcpy(string + stringlen, buffer);
! 100: stringlen += buflen;
! 101: }
! 102: }
! 103: *bufp = string;
! 104: return PARAM_OK;
! 105: }
! 106:
! 107: ParameterError file2memory(char **bufp, size_t *size, FILE *file)
! 108: {
! 109: char *newbuf;
! 110: char *buffer = NULL;
! 111: size_t nused = 0;
! 112:
! 113: if(file) {
! 114: size_t nread;
! 115: size_t alloc = 512;
! 116: do {
! 117: if(!buffer || (alloc == nused)) {
! 118: /* size_t overflow detection for huge files */
! 119: if(alloc + 1 > ((size_t)-1)/2) {
! 120: Curl_safefree(buffer);
! 121: return PARAM_NO_MEM;
! 122: }
! 123: alloc *= 2;
! 124: /* allocate an extra char, reserved space, for null termination */
! 125: newbuf = realloc(buffer, alloc + 1);
! 126: if(!newbuf) {
! 127: Curl_safefree(buffer);
! 128: return PARAM_NO_MEM;
! 129: }
! 130: buffer = newbuf;
! 131: }
! 132: nread = fread(buffer + nused, 1, alloc-nused, file);
! 133: nused += nread;
! 134: } while(nread);
! 135: /* null terminate the buffer in case it's used as a string later */
! 136: buffer[nused] = '\0';
! 137: /* free trailing slack space, if possible */
! 138: if(alloc != nused) {
! 139: newbuf = realloc(buffer, nused + 1);
! 140: if(!newbuf) {
! 141: Curl_safefree(buffer);
! 142: return PARAM_NO_MEM;
! 143: }
! 144: buffer = newbuf;
! 145: }
! 146: /* discard buffer if nothing was read */
! 147: if(!nused) {
! 148: Curl_safefree(buffer); /* no string */
! 149: }
! 150: }
! 151: *size = nused;
! 152: *bufp = buffer;
! 153: return PARAM_OK;
! 154: }
! 155:
! 156: void cleanarg(char *str)
! 157: {
! 158: #ifdef HAVE_WRITABLE_ARGV
! 159: /* now that GetStr has copied the contents of nextarg, wipe the next
! 160: * argument out so that the username:password isn't displayed in the
! 161: * system process list */
! 162: if(str) {
! 163: size_t len = strlen(str);
! 164: memset(str, ' ', len);
! 165: }
! 166: #else
! 167: (void)str;
! 168: #endif
! 169: }
! 170:
! 171: /*
! 172: * Parse the string and write the long in the given address. Return PARAM_OK
! 173: * on success, otherwise a parameter specific error enum.
! 174: *
! 175: * Since this function gets called with the 'nextarg' pointer from within the
! 176: * getparameter a lot, we must check it for NULL before accessing the str
! 177: * data.
! 178: */
! 179:
! 180: ParameterError str2num(long *val, const char *str)
! 181: {
! 182: if(str) {
! 183: char *endptr;
! 184: long num;
! 185: errno = 0;
! 186: num = strtol(str, &endptr, 10);
! 187: if(errno == ERANGE)
! 188: return PARAM_NUMBER_TOO_LARGE;
! 189: if((endptr != str) && (endptr == str + strlen(str))) {
! 190: *val = num;
! 191: return PARAM_OK; /* Ok */
! 192: }
! 193: }
! 194: return PARAM_BAD_NUMERIC; /* badness */
! 195: }
! 196:
! 197: /*
! 198: * Parse the string and write the long in the given address. Return PARAM_OK
! 199: * on success, otherwise a parameter error enum. ONLY ACCEPTS POSITIVE NUMBERS!
! 200: *
! 201: * Since this function gets called with the 'nextarg' pointer from within the
! 202: * getparameter a lot, we must check it for NULL before accessing the str
! 203: * data.
! 204: */
! 205:
! 206: ParameterError str2unum(long *val, const char *str)
! 207: {
! 208: ParameterError result = str2num(val, str);
! 209: if(result != PARAM_OK)
! 210: return result;
! 211: if(*val < 0)
! 212: return PARAM_NEGATIVE_NUMERIC;
! 213:
! 214: return PARAM_OK;
! 215: }
! 216:
! 217: /*
! 218: * Parse the string and write the long in the given address if it is below the
! 219: * maximum allowed value. Return PARAM_OK on success, otherwise a parameter
! 220: * error enum. ONLY ACCEPTS POSITIVE NUMBERS!
! 221: *
! 222: * Since this function gets called with the 'nextarg' pointer from within the
! 223: * getparameter a lot, we must check it for NULL before accessing the str
! 224: * data.
! 225: */
! 226:
! 227: ParameterError str2unummax(long *val, const char *str, long max)
! 228: {
! 229: ParameterError result = str2unum(val, str);
! 230: if(result != PARAM_OK)
! 231: return result;
! 232: if(*val > max)
! 233: return PARAM_NUMBER_TOO_LARGE;
! 234:
! 235: return PARAM_OK;
! 236: }
! 237:
! 238:
! 239: /*
! 240: * Parse the string and write the double in the given address. Return PARAM_OK
! 241: * on success, otherwise a parameter specific error enum.
! 242: *
! 243: * The 'max' argument is the maximum value allowed, as the numbers are often
! 244: * multiplied when later used.
! 245: *
! 246: * Since this function gets called with the 'nextarg' pointer from within the
! 247: * getparameter a lot, we must check it for NULL before accessing the str
! 248: * data.
! 249: */
! 250:
! 251: static ParameterError str2double(double *val, const char *str, long max)
! 252: {
! 253: if(str) {
! 254: char *endptr;
! 255: double num;
! 256: errno = 0;
! 257: num = strtod(str, &endptr);
! 258: if(errno == ERANGE)
! 259: return PARAM_NUMBER_TOO_LARGE;
! 260: if(num > max) {
! 261: /* too large */
! 262: return PARAM_NUMBER_TOO_LARGE;
! 263: }
! 264: if((endptr != str) && (endptr == str + strlen(str))) {
! 265: *val = num;
! 266: return PARAM_OK; /* Ok */
! 267: }
! 268: }
! 269: return PARAM_BAD_NUMERIC; /* badness */
! 270: }
! 271:
! 272: /*
! 273: * Parse the string and write the double in the given address. Return PARAM_OK
! 274: * on success, otherwise a parameter error enum. ONLY ACCEPTS POSITIVE NUMBERS!
! 275: *
! 276: * The 'max' argument is the maximum value allowed, as the numbers are often
! 277: * multiplied when later used.
! 278: *
! 279: * Since this function gets called with the 'nextarg' pointer from within the
! 280: * getparameter a lot, we must check it for NULL before accessing the str
! 281: * data.
! 282: */
! 283:
! 284: ParameterError str2udouble(double *valp, const char *str, long max)
! 285: {
! 286: double value;
! 287: ParameterError result = str2double(&value, str, max);
! 288: if(result != PARAM_OK)
! 289: return result;
! 290: if(value < 0)
! 291: return PARAM_NEGATIVE_NUMERIC;
! 292:
! 293: *valp = value;
! 294: return PARAM_OK;
! 295: }
! 296:
! 297: /*
! 298: * Parse the string and modify the long in the given address. Return
! 299: * non-zero on failure, zero on success.
! 300: *
! 301: * The string is a list of protocols
! 302: *
! 303: * Since this function gets called with the 'nextarg' pointer from within the
! 304: * getparameter a lot, we must check it for NULL before accessing the str
! 305: * data.
! 306: */
! 307:
! 308: long proto2num(struct OperationConfig *config, long *val, const char *str)
! 309: {
! 310: char *buffer;
! 311: const char *sep = ",";
! 312: char *token;
! 313:
! 314: static struct sprotos {
! 315: const char *name;
! 316: long bit;
! 317: } const protos[] = {
! 318: { "all", CURLPROTO_ALL },
! 319: { "http", CURLPROTO_HTTP },
! 320: { "https", CURLPROTO_HTTPS },
! 321: { "ftp", CURLPROTO_FTP },
! 322: { "ftps", CURLPROTO_FTPS },
! 323: { "scp", CURLPROTO_SCP },
! 324: { "sftp", CURLPROTO_SFTP },
! 325: { "telnet", CURLPROTO_TELNET },
! 326: { "ldap", CURLPROTO_LDAP },
! 327: { "ldaps", CURLPROTO_LDAPS },
! 328: { "dict", CURLPROTO_DICT },
! 329: { "file", CURLPROTO_FILE },
! 330: { "tftp", CURLPROTO_TFTP },
! 331: { "imap", CURLPROTO_IMAP },
! 332: { "imaps", CURLPROTO_IMAPS },
! 333: { "pop3", CURLPROTO_POP3 },
! 334: { "pop3s", CURLPROTO_POP3S },
! 335: { "smtp", CURLPROTO_SMTP },
! 336: { "smtps", CURLPROTO_SMTPS },
! 337: { "rtsp", CURLPROTO_RTSP },
! 338: { "gopher", CURLPROTO_GOPHER },
! 339: { "smb", CURLPROTO_SMB },
! 340: { "smbs", CURLPROTO_SMBS },
! 341: { NULL, 0 }
! 342: };
! 343:
! 344: if(!str)
! 345: return 1;
! 346:
! 347: buffer = strdup(str); /* because strtok corrupts it */
! 348: if(!buffer)
! 349: return 1;
! 350:
! 351: /* Allow strtok() here since this isn't used threaded */
! 352: /* !checksrc! disable BANNEDFUNC 2 */
! 353: for(token = strtok(buffer, sep);
! 354: token;
! 355: token = strtok(NULL, sep)) {
! 356: enum e_action { allow, deny, set } action = allow;
! 357:
! 358: struct sprotos const *pp;
! 359:
! 360: /* Process token modifiers */
! 361: while(!ISALNUM(*token)) { /* may be NULL if token is all modifiers */
! 362: switch (*token++) {
! 363: case '=':
! 364: action = set;
! 365: break;
! 366: case '-':
! 367: action = deny;
! 368: break;
! 369: case '+':
! 370: action = allow;
! 371: break;
! 372: default: /* Includes case of terminating NULL */
! 373: Curl_safefree(buffer);
! 374: return 1;
! 375: }
! 376: }
! 377:
! 378: for(pp = protos; pp->name; pp++) {
! 379: if(curl_strequal(token, pp->name)) {
! 380: switch(action) {
! 381: case deny:
! 382: *val &= ~(pp->bit);
! 383: break;
! 384: case allow:
! 385: *val |= pp->bit;
! 386: break;
! 387: case set:
! 388: *val = pp->bit;
! 389: break;
! 390: }
! 391: break;
! 392: }
! 393: }
! 394:
! 395: if(!(pp->name)) { /* unknown protocol */
! 396: /* If they have specified only this protocol, we say treat it as
! 397: if no protocols are allowed */
! 398: if(action == set)
! 399: *val = 0;
! 400: warnf(config->global, "unrecognized protocol '%s'\n", token);
! 401: }
! 402: }
! 403: Curl_safefree(buffer);
! 404: return 0;
! 405: }
! 406:
! 407: /**
! 408: * Check if the given string is a protocol supported by libcurl
! 409: *
! 410: * @param str the protocol name
! 411: * @return PARAM_OK protocol supported
! 412: * @return PARAM_LIBCURL_UNSUPPORTED_PROTOCOL protocol not supported
! 413: * @return PARAM_REQUIRES_PARAMETER missing parameter
! 414: */
! 415: int check_protocol(const char *str)
! 416: {
! 417: const char * const *pp;
! 418: const curl_version_info_data *curlinfo = curl_version_info(CURLVERSION_NOW);
! 419: if(!str)
! 420: return PARAM_REQUIRES_PARAMETER;
! 421: for(pp = curlinfo->protocols; *pp; pp++) {
! 422: if(curl_strequal(*pp, str))
! 423: return PARAM_OK;
! 424: }
! 425: return PARAM_LIBCURL_UNSUPPORTED_PROTOCOL;
! 426: }
! 427:
! 428: /**
! 429: * Parses the given string looking for an offset (which may be a
! 430: * larger-than-integer value). The offset CANNOT be negative!
! 431: *
! 432: * @param val the offset to populate
! 433: * @param str the buffer containing the offset
! 434: * @return PARAM_OK if successful, a parameter specific error enum if failure.
! 435: */
! 436: ParameterError str2offset(curl_off_t *val, const char *str)
! 437: {
! 438: char *endptr;
! 439: if(str[0] == '-')
! 440: /* offsets aren't negative, this indicates weird input */
! 441: return PARAM_NEGATIVE_NUMERIC;
! 442:
! 443: #if(SIZEOF_CURL_OFF_T > SIZEOF_LONG)
! 444: {
! 445: CURLofft offt = curlx_strtoofft(str, &endptr, 0, val);
! 446: if(CURL_OFFT_FLOW == offt)
! 447: return PARAM_NUMBER_TOO_LARGE;
! 448: else if(CURL_OFFT_INVAL == offt)
! 449: return PARAM_BAD_NUMERIC;
! 450: }
! 451: #else
! 452: errno = 0;
! 453: *val = strtol(str, &endptr, 0);
! 454: if((*val == LONG_MIN || *val == LONG_MAX) && errno == ERANGE)
! 455: return PARAM_NUMBER_TOO_LARGE;
! 456: #endif
! 457: if((endptr != str) && (endptr == str + strlen(str)))
! 458: return PARAM_OK;
! 459:
! 460: return PARAM_BAD_NUMERIC;
! 461: }
! 462:
! 463: static CURLcode checkpasswd(const char *kind, /* for what purpose */
! 464: const size_t i, /* operation index */
! 465: const bool last, /* TRUE if last operation */
! 466: char **userpwd) /* pointer to allocated string */
! 467: {
! 468: char *psep;
! 469: char *osep;
! 470:
! 471: if(!*userpwd)
! 472: return CURLE_OK;
! 473:
! 474: /* Attempt to find the password separator */
! 475: psep = strchr(*userpwd, ':');
! 476:
! 477: /* Attempt to find the options separator */
! 478: osep = strchr(*userpwd, ';');
! 479:
! 480: if(!psep && **userpwd != ';') {
! 481: /* no password present, prompt for one */
! 482: char passwd[256] = "";
! 483: char prompt[256];
! 484: size_t passwdlen;
! 485: size_t userlen = strlen(*userpwd);
! 486: char *passptr;
! 487:
! 488: if(osep)
! 489: *osep = '\0';
! 490:
! 491: /* build a nice-looking prompt */
! 492: if(!i && last)
! 493: curlx_msnprintf(prompt, sizeof(prompt),
! 494: "Enter %s password for user '%s':",
! 495: kind, *userpwd);
! 496: else
! 497: curlx_msnprintf(prompt, sizeof(prompt),
! 498: "Enter %s password for user '%s' on URL #%zu:",
! 499: kind, *userpwd, i + 1);
! 500:
! 501: /* get password */
! 502: getpass_r(prompt, passwd, sizeof(passwd));
! 503: passwdlen = strlen(passwd);
! 504:
! 505: if(osep)
! 506: *osep = ';';
! 507:
! 508: /* extend the allocated memory area to fit the password too */
! 509: passptr = realloc(*userpwd,
! 510: passwdlen + 1 + /* an extra for the colon */
! 511: userlen + 1); /* an extra for the zero */
! 512: if(!passptr)
! 513: return CURLE_OUT_OF_MEMORY;
! 514:
! 515: /* append the password separated with a colon */
! 516: passptr[userlen] = ':';
! 517: memcpy(&passptr[userlen + 1], passwd, passwdlen + 1);
! 518: *userpwd = passptr;
! 519: }
! 520:
! 521: return CURLE_OK;
! 522: }
! 523:
! 524: ParameterError add2list(struct curl_slist **list, const char *ptr)
! 525: {
! 526: struct curl_slist *newlist = curl_slist_append(*list, ptr);
! 527: if(newlist)
! 528: *list = newlist;
! 529: else
! 530: return PARAM_NO_MEM;
! 531:
! 532: return PARAM_OK;
! 533: }
! 534:
! 535: int ftpfilemethod(struct OperationConfig *config, const char *str)
! 536: {
! 537: if(curl_strequal("singlecwd", str))
! 538: return CURLFTPMETHOD_SINGLECWD;
! 539: if(curl_strequal("nocwd", str))
! 540: return CURLFTPMETHOD_NOCWD;
! 541: if(curl_strequal("multicwd", str))
! 542: return CURLFTPMETHOD_MULTICWD;
! 543:
! 544: warnf(config->global, "unrecognized ftp file method '%s', using default\n",
! 545: str);
! 546:
! 547: return CURLFTPMETHOD_MULTICWD;
! 548: }
! 549:
! 550: int ftpcccmethod(struct OperationConfig *config, const char *str)
! 551: {
! 552: if(curl_strequal("passive", str))
! 553: return CURLFTPSSL_CCC_PASSIVE;
! 554: if(curl_strequal("active", str))
! 555: return CURLFTPSSL_CCC_ACTIVE;
! 556:
! 557: warnf(config->global, "unrecognized ftp CCC method '%s', using default\n",
! 558: str);
! 559:
! 560: return CURLFTPSSL_CCC_PASSIVE;
! 561: }
! 562:
! 563: long delegation(struct OperationConfig *config, const char *str)
! 564: {
! 565: if(curl_strequal("none", str))
! 566: return CURLGSSAPI_DELEGATION_NONE;
! 567: if(curl_strequal("policy", str))
! 568: return CURLGSSAPI_DELEGATION_POLICY_FLAG;
! 569: if(curl_strequal("always", str))
! 570: return CURLGSSAPI_DELEGATION_FLAG;
! 571:
! 572: warnf(config->global, "unrecognized delegation method '%s', using none\n",
! 573: str);
! 574:
! 575: return CURLGSSAPI_DELEGATION_NONE;
! 576: }
! 577:
! 578: /*
! 579: * my_useragent: returns allocated string with default user agent
! 580: */
! 581: static char *my_useragent(void)
! 582: {
! 583: return strdup(CURL_NAME "/" CURL_VERSION);
! 584: }
! 585:
! 586: CURLcode get_args(struct OperationConfig *config, const size_t i)
! 587: {
! 588: CURLcode result = CURLE_OK;
! 589: bool last = (config->next ? FALSE : TRUE);
! 590:
! 591: /* Check we have a password for the given host user */
! 592: if(config->userpwd && !config->oauth_bearer) {
! 593: result = checkpasswd("host", i, last, &config->userpwd);
! 594: if(result)
! 595: return result;
! 596: }
! 597:
! 598: /* Check we have a password for the given proxy user */
! 599: if(config->proxyuserpwd) {
! 600: result = checkpasswd("proxy", i, last, &config->proxyuserpwd);
! 601: if(result)
! 602: return result;
! 603: }
! 604:
! 605: /* Check we have a user agent */
! 606: if(!config->useragent) {
! 607: config->useragent = my_useragent();
! 608: if(!config->useragent) {
! 609: errorf(config->global, "out of memory\n");
! 610: result = CURLE_OUT_OF_MEMORY;
! 611: }
! 612: }
! 613:
! 614: return result;
! 615: }
! 616:
! 617: /*
! 618: * Parse the string and modify ssl_version in the val argument. Return PARAM_OK
! 619: * on success, otherwise a parameter error enum. ONLY ACCEPTS POSITIVE NUMBERS!
! 620: *
! 621: * Since this function gets called with the 'nextarg' pointer from within the
! 622: * getparameter a lot, we must check it for NULL before accessing the str
! 623: * data.
! 624: */
! 625:
! 626: ParameterError str2tls_max(long *val, const char *str)
! 627: {
! 628: static struct s_tls_max {
! 629: const char *tls_max_str;
! 630: long tls_max;
! 631: } const tls_max_array[] = {
! 632: { "default", CURL_SSLVERSION_MAX_DEFAULT },
! 633: { "1.0", CURL_SSLVERSION_MAX_TLSv1_0 },
! 634: { "1.1", CURL_SSLVERSION_MAX_TLSv1_1 },
! 635: { "1.2", CURL_SSLVERSION_MAX_TLSv1_2 },
! 636: { "1.3", CURL_SSLVERSION_MAX_TLSv1_3 }
! 637: };
! 638: size_t i = 0;
! 639: if(!str)
! 640: return PARAM_REQUIRES_PARAMETER;
! 641: for(i = 0; i < sizeof(tls_max_array)/sizeof(tls_max_array[0]); i++) {
! 642: if(!strcmp(str, tls_max_array[i].tls_max_str)) {
! 643: *val = tls_max_array[i].tls_max;
! 644: return PARAM_OK;
! 645: }
! 646: }
! 647: return PARAM_BAD_USE;
! 648: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to tool_paramhlp.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