src/tool_paramhlp.c

   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 http://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 "rawstr.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 buffer[256];
  62   char *ptr;
  63   char *string = NULL;
  64   size_t stringlen = 0;
  65   size_t buflen;
  66
  67   if(file) {
  68     while(fgets(buffer, sizeof(buffer), file)) {
  69       if((ptr = strchr(buffer, '\r')) != NULL)
  70         *ptr = '\0';
  71       if((ptr = strchr(buffer, '\n')) != NULL)
  72         *ptr = '\0';
  73       buflen = strlen(buffer);
  74       if((ptr = realloc(string, stringlen+buflen+1)) == NULL) {
  75         Curl_safefree(string);
  76         return PARAM_NO_MEM;
  77       }
  78       string = ptr;
  79       strcpy(string+stringlen, buffer);
  80       stringlen += buflen;
  81     }
  82   }
  83   *bufp = string;
  84   return PARAM_OK;
  85 }
  86
  87 ParameterError file2memory(char **bufp, size_t *size, FILE *file)
  88 {
  89   char *newbuf;
  90   char *buffer = NULL;
  91   size_t alloc = 512;
  92   size_t nused = 0;
  93   size_t nread;
  94
  95   if(file) {
  96     do {
  97       if(!buffer || (alloc == nused)) {
  98         /* size_t overflow detection for huge files */
  99         if(alloc+1 > ((size_t)-1)/2) {
 100           Curl_safefree(buffer);
 101           return PARAM_NO_MEM;
 102         }
 103         alloc *= 2;
 104         /* allocate an extra char, reserved space, for null termination */
 105         if((newbuf = realloc(buffer, alloc+1)) == NULL) {
 106           Curl_safefree(buffer);
 107           return PARAM_NO_MEM;
 108         }
 109         buffer = newbuf;
 110       }
 111       nread = fread(buffer+nused, 1, alloc-nused, file);
 112       nused += nread;
 113     } while(nread);
 114     /* null terminate the buffer in case it's used as a string later */
 115     buffer[nused] = '\0';
 116     /* free trailing slack space, if possible */
 117     if(alloc != nused) {
 118       if((newbuf = realloc(buffer, nused+1)) == NULL) {
 119         Curl_safefree(buffer);
 120         return PARAM_NO_MEM;
 121       }
 122       buffer = newbuf;
 123     }
 124     /* discard buffer if nothing was read */
 125     if(!nused) {
 126       Curl_safefree(buffer); /* no string */
 127     }
 128   }
 129   *size = nused;
 130   *bufp = buffer;
 131   return PARAM_OK;
 132 }
 133
 134 void cleanarg(char *str)
 135 {
 136 #ifdef HAVE_WRITABLE_ARGV
 137   /* now that GetStr has copied the contents of nextarg, wipe the next
 138    * argument out so that the username:password isn't displayed in the
 139    * system process list */
 140   if(str) {
 141     size_t len = strlen(str);
 142     memset(str, ' ', len);
 143   }
 144 #else
 145   (void)str;
 146 #endif
 147 }
 148
 149 /*
 150  * Parse the string and write the long in the given address. Return PARAM_OK
 151  * on success, otherwise a parameter specific error enum.
 152  *
 153  * Since this function gets called with the 'nextarg' pointer from within the
 154  * getparameter a lot, we must check it for NULL before accessing the str
 155  * data.
 156  */
 157
 158 ParameterError str2num(long *val, const char *str)
 159 {
 160   if(str) {
 161     char *endptr;
 162     long num = strtol(str, &endptr, 10);
 163     if((endptr != str) && (endptr == str + strlen(str))) {
 164       *val = num;
 165       return PARAM_OK;  /* Ok */
 166     }
 167   }
 168   return PARAM_BAD_NUMERIC; /* badness */
 169 }
 170
 171 /*
 172  * Parse the string and write the long in the given address. Return PARAM_OK
 173  * on success, otherwise a parameter error enum. ONLY ACCEPTS POSITIVE NUMBERS!
 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 str2unum(long *val, const char *str)
 181 {
 182   ParameterError result = str2num(val, str);
 183   if(result != PARAM_OK)
 184     return result;
 185   if(*val < 0)
 186     return PARAM_NEGATIVE_NUMERIC;
 187
 188   return PARAM_OK;
 189 }
 190
 191 /*
 192  * Parse the string and write the double in the given address. Return PARAM_OK
 193  * on success, otherwise a parameter specific error enum.
 194  *
 195  * Since this function gets called with the 'nextarg' pointer from within the
 196  * getparameter a lot, we must check it for NULL before accessing the str
 197  * data.
 198  */
 199
 200 ParameterError str2double(double *val, const char *str)
 201 {
 202   if(str) {
 203     char *endptr;
 204     double num = strtod(str, &endptr);
 205     if((endptr != str) && (endptr == str + strlen(str))) {
 206       *val = num;
 207       return PARAM_OK;  /* Ok */
 208     }
 209   }
 210   return PARAM_BAD_NUMERIC; /* badness */
 211 }
 212
 213 /*
 214  * Parse the string and write the double in the given address. Return PARAM_OK
 215  * on success, otherwise a parameter error enum. ONLY ACCEPTS POSITIVE NUMBERS!
 216  *
 217  * Since this function gets called with the 'nextarg' pointer from within the
 218  * getparameter a lot, we must check it for NULL before accessing the str
 219  * data.
 220  */
 221
 222 ParameterError str2udouble(double *val, const char *str)
 223 {
 224   ParameterError result = str2double(val, str);
 225   if(result != PARAM_OK)
 226     return result;
 227   if(*val < 0)
 228     return PARAM_NEGATIVE_NUMERIC;
 229
 230   return PARAM_OK;
 231 }
 232
 233 /*
 234  * Parse the string and modify the long in the given address. Return
 235  * non-zero on failure, zero on success.
 236  *
 237  * The string is a list of protocols
 238  *
 239  * Since this function gets called with the 'nextarg' pointer from within the
 240  * getparameter a lot, we must check it for NULL before accessing the str
 241  * data.
 242  */
 243
 244 long proto2num(struct OperationConfig *config, long *val, const char *str)
 245 {
 246   char *buffer;
 247   const char *sep = ",";
 248   char *token;
 249
 250   static struct sprotos {
 251     const char *name;
 252     long bit;
 253   } const protos[] = {
 254     { "all", CURLPROTO_ALL },
 255     { "http", CURLPROTO_HTTP },
 256     { "https", CURLPROTO_HTTPS },
 257     { "ftp", CURLPROTO_FTP },
 258     { "ftps", CURLPROTO_FTPS },
 259     { "scp", CURLPROTO_SCP },
 260     { "sftp", CURLPROTO_SFTP },
 261     { "telnet", CURLPROTO_TELNET },
 262     { "ldap", CURLPROTO_LDAP },
 263     { "ldaps", CURLPROTO_LDAPS },
 264     { "dict", CURLPROTO_DICT },
 265     { "file", CURLPROTO_FILE },
 266     { "tftp", CURLPROTO_TFTP },
 267     { "imap", CURLPROTO_IMAP },
 268     { "imaps", CURLPROTO_IMAPS },
 269     { "pop3", CURLPROTO_POP3 },
 270     { "pop3s", CURLPROTO_POP3S },
 271     { "smtp", CURLPROTO_SMTP },
 272     { "smtps", CURLPROTO_SMTPS },
 273     { "rtsp", CURLPROTO_RTSP },
 274     { "gopher", CURLPROTO_GOPHER },
 275     { "smb", CURLPROTO_SMB },
 276     { "smbs", CURLPROTO_SMBS },
 277     { NULL, 0 }
 278   };
 279
 280   if(!str)
 281     return 1;
 282
 283   buffer = strdup(str); /* because strtok corrupts it */
 284   if(!buffer)
 285     return 1;
 286
 287   for(token = strtok(buffer, sep);
 288       token;
 289       token = strtok(NULL, sep)) {
 290     enum e_action { allow, deny, set } action = allow;
 291
 292     struct sprotos const *pp;
 293
 294     /* Process token modifiers */
 295     while(!ISALNUM(*token)) { /* may be NULL if token is all modifiers */
 296       switch (*token++) {
 297       case '=':
 298         action = set;
 299         break;
 300       case '-':
 301         action = deny;
 302         break;
 303       case '+':
 304         action = allow;
 305         break;
 306       default: /* Includes case of terminating NULL */
 307         Curl_safefree(buffer);
 308         return 1;
 309       }
 310     }
 311
 312     for(pp=protos; pp->name; pp++) {
 313       if(curlx_raw_equal(token, pp->name)) {
 314         switch (action) {
 315         case deny:
 316           *val &= ~(pp->bit);
 317           break;
 318         case allow:
 319           *val |= pp->bit;
 320           break;
 321         case set:
 322           *val = pp->bit;
 323           break;
 324         }
 325         break;
 326       }
 327     }
 328
 329     if(!(pp->name)) { /* unknown protocol */
 330       /* If they have specified only this protocol, we say treat it as
 331          if no protocols are allowed */
 332       if(action == set)
 333         *val = 0;
 334       warnf(config->global, "unrecognized protocol '%s'\n", token);
 335     }
 336   }
 337   Curl_safefree(buffer);
 338   return 0;
 339 }
 340
 341 /**
 342  * Parses the given string looking for an offset (which may be a
 343  * larger-than-integer value). The offset CANNOT be negative!
 344  *
 345  * @param val  the offset to populate
 346  * @param str  the buffer containing the offset
 347  * @return PARAM_OK if successful, a parameter specific error enum if failure.
 348  */
 349 ParameterError str2offset(curl_off_t *val, const char *str)
 350 {
 351   char *endptr;
 352   if(str[0] == '-')
 353     /* offsets aren't negative, this indicates weird input */
 354     return PARAM_NEGATIVE_NUMERIC;
 355
 356 #if(CURL_SIZEOF_CURL_OFF_T > CURL_SIZEOF_LONG)
 357   *val = curlx_strtoofft(str, &endptr, 0);
 358   if((*val == CURL_OFF_T_MAX || *val == CURL_OFF_T_MIN) && (ERRNO == ERANGE))
 359     return PARAM_BAD_NUMERIC;
 360 #else
 361   *val = strtol(str, &endptr, 0);
 362   if((*val == LONG_MIN || *val == LONG_MAX) && ERRNO == ERANGE)
 363     return PARAM_BAD_NUMERIC;
 364 #endif
 365   if((endptr != str) && (endptr == str + strlen(str)))
 366     return PARAM_OK;
 367
 368   return PARAM_BAD_NUMERIC;
 369 }
 370
 371 static CURLcode checkpasswd(const char *kind, /* for what purpose */
 372                             const size_t i,   /* operation index */
 373                             const bool last,  /* TRUE if last operation */
 374                             char **userpwd)   /* pointer to allocated string */
 375 {
 376   char *psep;
 377   char *osep;
 378
 379   if(!*userpwd)
 380     return CURLE_OK;
 381
 382   /* Attempt to find the password separator */
 383   psep = strchr(*userpwd, ':');
 384
 385   /* Attempt to find the options separator */
 386   osep = strchr(*userpwd, ';');
 387
 388   if(!psep && **userpwd != ';') {
 389     /* no password present, prompt for one */
 390     char passwd[256] = "";
 391     char prompt[256];
 392     size_t passwdlen;
 393     size_t userlen = strlen(*userpwd);
 394     char *passptr;
 395
 396     if(osep)
 397       *osep = '\0';
 398
 399     /* build a nice-looking prompt */
 400     if(!i && last)
 401       curlx_msnprintf(prompt, sizeof(prompt),
 402                       "Enter %s password for user '%s':",
 403                       kind, *userpwd);
 404     else
 405       curlx_msnprintf(prompt, sizeof(prompt),
 406                       "Enter %s password for user '%s' on URL #%"
 407                       CURL_FORMAT_CURL_OFF_TU ":",
 408                       kind, *userpwd, i + 1);
 409
 410     /* get password */
 411     getpass_r(prompt, passwd, sizeof(passwd));
 412     passwdlen = strlen(passwd);
 413
 414     if(osep)
 415       *osep = ';';
 416
 417     /* extend the allocated memory area to fit the password too */
 418     passptr = realloc(*userpwd,
 419                       passwdlen + 1 + /* an extra for the colon */
 420                       userlen + 1);   /* an extra for the zero */
 421     if(!passptr)
 422       return CURLE_OUT_OF_MEMORY;
 423
 424     /* append the password separated with a colon */
 425     passptr[userlen] = ':';
 426     memcpy(&passptr[userlen+1], passwd, passwdlen+1);
 427     *userpwd = passptr;
 428   }
 429
 430   return CURLE_OK;
 431 }
 432
 433 ParameterError add2list(struct curl_slist **list, const char *ptr)
 434 {
 435   struct curl_slist *newlist = curl_slist_append(*list, ptr);
 436   if(newlist)
 437     *list = newlist;
 438   else
 439     return PARAM_NO_MEM;
 440
 441   return PARAM_OK;
 442 }
 443
 444 int ftpfilemethod(struct OperationConfig *config, const char *str)
 445 {
 446   if(curlx_raw_equal("singlecwd", str))
 447     return CURLFTPMETHOD_SINGLECWD;
 448   if(curlx_raw_equal("nocwd", str))
 449     return CURLFTPMETHOD_NOCWD;
 450   if(curlx_raw_equal("multicwd", str))
 451     return CURLFTPMETHOD_MULTICWD;
 452
 453   warnf(config->global, "unrecognized ftp file method '%s', using default\n",
 454         str);
 455
 456   return CURLFTPMETHOD_MULTICWD;
 457 }
 458
 459 int ftpcccmethod(struct OperationConfig *config, const char *str)
 460 {
 461   if(curlx_raw_equal("passive", str))
 462     return CURLFTPSSL_CCC_PASSIVE;
 463   if(curlx_raw_equal("active", str))
 464     return CURLFTPSSL_CCC_ACTIVE;
 465
 466   warnf(config->global, "unrecognized ftp CCC method '%s', using default\n",
 467         str);
 468
 469   return CURLFTPSSL_CCC_PASSIVE;
 470 }
 471
 472 long delegation(struct OperationConfig *config, char *str)
 473 {
 474   if(curlx_raw_equal("none", str))
 475     return CURLGSSAPI_DELEGATION_NONE;
 476   if(curlx_raw_equal("policy", str))
 477     return CURLGSSAPI_DELEGATION_POLICY_FLAG;
 478   if(curlx_raw_equal("always", str))
 479     return CURLGSSAPI_DELEGATION_FLAG;
 480
 481   warnf(config->global, "unrecognized delegation method '%s', using none\n",
 482         str);
 483
 484   return CURLGSSAPI_DELEGATION_NONE;
 485 }
 486
 487 /*
 488  * my_useragent: returns allocated string with default user agent
 489  */
 490 static char *my_useragent(void)
 491 {
 492   return strdup(CURL_NAME "/" CURL_VERSION);
 493 }
 494
 495 CURLcode get_args(struct OperationConfig *config, const size_t i)
 496 {
 497   CURLcode result = CURLE_OK;
 498   bool last = (config->next ? FALSE : TRUE);
 499
 500   /* Check we have a password for the given host user */
 501   if(config->userpwd && !config->xoauth2_bearer) {
 502     result = checkpasswd("host", i, last, &config->userpwd);
 503     if(result)
 504       return result;
 505   }
 506
 507   /* Check we have a password for the given proxy user */
 508   if(config->proxyuserpwd) {
 509     result = checkpasswd("proxy", i, last, &config->proxyuserpwd);
 510     if(result)
 511       return result;
 512   }
 513
 514   /* Check we have a user agent */
 515   if(!config->useragent) {
 516     config->useragent = my_useragent();
 517     if(!config->useragent) {
 518       helpf(config->global->errors, "out of memory\n");
 519       result = CURLE_OUT_OF_MEMORY;
 520     }
 521   }
 522
 523   return result;
 524 }