Return to strtoofft.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / curl / lib

curl

    1: /***************************************************************************
    2:  *                                  _   _ ____  _
    3:  *  Project                     ___| | | |  _ \| |
    4:  *                             / __| | | | |_) | |
    5:  *                            | (__| |_| |  _ <| |___
    6:  *                             \___|\___/|_| \_\_____|
    7:  *
    8:  * Copyright (C) 1998 - 2019, 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: 
   23: #include <errno.h>
   24: #include "curl_setup.h"
   25: 
   26: #include "strtoofft.h"
   27: 
   28: /*
   29:  * NOTE:
   30:  *
   31:  * In the ISO C standard (IEEE Std 1003.1), there is a strtoimax() function we
   32:  * could use in case strtoll() doesn't exist...  See
   33:  * https://www.opengroup.org/onlinepubs/009695399/functions/strtoimax.html
   34:  */
   35: 
   36: #if (SIZEOF_CURL_OFF_T > SIZEOF_LONG)
   37: #  ifdef HAVE_STRTOLL
   38: #    define strtooff strtoll
   39: #  else
   40: #    if defined(_MSC_VER) && (_MSC_VER >= 1300) && (_INTEGRAL_MAX_BITS >= 64)
   41: #      if defined(_SAL_VERSION)
   42:          _Check_return_ _CRTIMP __int64 __cdecl _strtoi64(
   43:              _In_z_ const char *_String,
   44:              _Out_opt_ _Deref_post_z_ char **_EndPtr, _In_ int _Radix);
   45: #      else
   46:          _CRTIMP __int64 __cdecl _strtoi64(const char *_String,
   47:                                            char **_EndPtr, int _Radix);
   48: #      endif
   49: #      define strtooff _strtoi64
   50: #    else
   51: #      define PRIVATE_STRTOOFF 1
   52: #    endif
   53: #  endif
   54: #else
   55: #  define strtooff strtol
   56: #endif
   57: 
   58: #ifdef PRIVATE_STRTOOFF
   59: 
   60: /* Range tests can be used for alphanum decoding if characters are consecutive,
   61:    like in ASCII. Else an array is scanned. Determine this condition now. */
   62: 
   63: #if('9' - '0') != 9 || ('Z' - 'A') != 25 || ('z' - 'a') != 25
   64: 
   65: #define NO_RANGE_TEST
   66: 
   67: static const char valchars[] =
   68:             "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
   69: #endif
   70: 
   71: static int get_char(char c, int base);
   72: 
   73: /**
   74:  * Custom version of the strtooff function.  This extracts a curl_off_t
   75:  * value from the given input string and returns it.
   76:  */
   77: static curl_off_t strtooff(const char *nptr, char **endptr, int base)
   78: {
   79:   char *end;
   80:   int is_negative = 0;
   81:   int overflow;
   82:   int i;
   83:   curl_off_t value = 0;
   84:   curl_off_t newval;
   85: 
   86:   /* Skip leading whitespace. */
   87:   end = (char *)nptr;
   88:   while(ISSPACE(end[0])) {
   89:     end++;
   90:   }
   91: 
   92:   /* Handle the sign, if any. */
   93:   if(end[0] == '-') {
   94:     is_negative = 1;
   95:     end++;
   96:   }
   97:   else if(end[0] == '+') {
   98:     end++;
   99:   }
  100:   else if(end[0] == '\0') {
  101:     /* We had nothing but perhaps some whitespace -- there was no number. */
  102:     if(endptr) {
  103:       *endptr = end;
  104:     }
  105:     return 0;
  106:   }
  107: 
  108:   /* Handle special beginnings, if present and allowed. */
  109:   if(end[0] == '0' && end[1] == 'x') {
  110:     if(base == 16 || base == 0) {
  111:       end += 2;
  112:       base = 16;
  113:     }
  114:   }
  115:   else if(end[0] == '0') {
  116:     if(base == 8 || base == 0) {
  117:       end++;
  118:       base = 8;
  119:     }
  120:   }
  121: 
  122:   /* Matching strtol, if the base is 0 and it doesn't look like
  123:    * the number is octal or hex, we assume it's base 10.
  124:    */
  125:   if(base == 0) {
  126:     base = 10;
  127:   }
  128: 
  129:   /* Loop handling digits. */
  130:   value = 0;
  131:   overflow = 0;
  132:   for(i = get_char(end[0], base);
  133:       i != -1;
  134:       end++, i = get_char(end[0], base)) {
  135:     newval = base * value + i;
  136:     if(newval < value) {
  137:       /* We've overflowed. */
  138:       overflow = 1;
  139:       break;
  140:     }
  141:     else
  142:       value = newval;
  143:   }
  144: 
  145:   if(!overflow) {
  146:     if(is_negative) {
  147:       /* Fix the sign. */
  148:       value *= -1;
  149:     }
  150:   }
  151:   else {
  152:     if(is_negative)
  153:       value = CURL_OFF_T_MIN;
  154:     else
  155:       value = CURL_OFF_T_MAX;
  156: 
  157:     errno = ERANGE;
  158:   }
  159: 
  160:   if(endptr)
  161:     *endptr = end;
  162: 
  163:   return value;
  164: }
  165: 
  166: /**
  167:  * Returns the value of c in the given base, or -1 if c cannot
  168:  * be interpreted properly in that base (i.e., is out of range,
  169:  * is a null, etc.).
  170:  *
  171:  * @param c     the character to interpret according to base
  172:  * @param base  the base in which to interpret c
  173:  *
  174:  * @return  the value of c in base, or -1 if c isn't in range
  175:  */
  176: static int get_char(char c, int base)
  177: {
  178: #ifndef NO_RANGE_TEST
  179:   int value = -1;
  180:   if(c <= '9' && c >= '0') {
  181:     value = c - '0';
  182:   }
  183:   else if(c <= 'Z' && c >= 'A') {
  184:     value = c - 'A' + 10;
  185:   }
  186:   else if(c <= 'z' && c >= 'a') {
  187:     value = c - 'a' + 10;
  188:   }
  189: #else
  190:   const char *cp;
  191:   int value;
  192: 
  193:   cp = memchr(valchars, c, 10 + 26 + 26);
  194: 
  195:   if(!cp)
  196:     return -1;
  197: 
  198:   value = cp - valchars;
  199: 
  200:   if(value >= 10 + 26)
  201:     value -= 26;                /* Lowercase. */
  202: #endif
  203: 
  204:   if(value >= base) {
  205:     value = -1;
  206:   }
  207: 
  208:   return value;
  209: }
  210: #endif  /* Only present if we need strtoll, but don't have it. */
  211: 
  212: /*
  213:  * Parse a *positive* up to 64 bit number written in ascii.
  214:  */
  215: CURLofft curlx_strtoofft(const char *str, char **endp, int base,
  216:                          curl_off_t *num)
  217: {
  218:   char *end;
  219:   curl_off_t number;
  220:   errno = 0;
  221:   *num = 0; /* clear by default */
  222: 
  223:   while(*str && ISSPACE(*str))
  224:     str++;
  225:   if('-' == *str) {
  226:     if(endp)
  227:       *endp = (char *)str; /* didn't actually move */
  228:     return CURL_OFFT_INVAL; /* nothing parsed */
  229:   }
  230:   number = strtooff(str, &end, base);
  231:   if(endp)
  232:     *endp = end;
  233:   if(errno == ERANGE)
  234:     /* overflow/underflow */
  235:     return CURL_OFFT_FLOW;
  236:   else if(str == end)
  237:     /* nothing parsed */
  238:     return CURL_OFFT_INVAL;
  239: 
  240:   *num = number;
  241:   return CURL_OFFT_OK;
  242: }