Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 1 | /*************************************************************************** |
| 2 | * _ _ ____ _ |
| 3 | * Project ___| | | | _ \| | |
| 4 | * / __| | | | |_) | | |
| 5 | * | (__| |_| | _ <| |___ |
| 6 | * \___|\___/|_| \_\_____| |
| 7 | * |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 8 | * Copyright (C) 1998 - 2017, Daniel Stenberg, <daniel@haxx.se>, et al. |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 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 |
Alex Deymo | 8f1a214 | 2016-06-28 14:49:26 -0700 | [diff] [blame] | 12 | * are also available at https://curl.haxx.se/docs/copyright.html. |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 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 | |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 23 | #include <errno.h> |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 24 | #include "curl_setup.h" |
| 25 | |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 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 |
Elliott Hughes | 82be86d | 2017-09-20 17:00:17 -0700 | [diff] [blame] | 33 | * https://www.opengroup.org/onlinepubs/009695399/functions/strtoimax.html |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 34 | */ |
| 35 | |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 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 |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 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 |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 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 | /** |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 74 | * Custom version of the strtooff function. This extracts a curl_off_t |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 75 | * value from the given input string and returns it. |
| 76 | */ |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 77 | static curl_off_t strtooff(const char *nptr, char **endptr, int base) |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 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; |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 132 | for(i = get_char(end[0], base); |
| 133 | i != -1; |
| 134 | end++, i = get_char(end[0], base)) { |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 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) |
Lucas Eckels | 9bd90e6 | 2012-08-06 15:07:02 -0700 | [diff] [blame] | 153 | value = CURL_OFF_T_MIN; |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 154 | else |
Lucas Eckels | 9bd90e6 | 2012-08-06 15:07:02 -0700 | [diff] [blame] | 155 | value = CURL_OFF_T_MAX; |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 156 | |
Elliott Hughes | 82be86d | 2017-09-20 17:00:17 -0700 | [diff] [blame] | 157 | errno = ERANGE; |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 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 |
Elliott Hughes | cee0338 | 2017-06-23 12:17:18 -0700 | [diff] [blame] | 190 | const char *cp; |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 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. */ |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 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 | |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 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 | } |