1 /* 2 * Copyright (c) 2000-2001 Proofpoint, Inc. and its suppliers. 3 * All rights reserved. 4 * Copyright (c) 1992 5 * The Regents of the University of California. All rights reserved. 6 * 7 * By using this file, you agree to the terms and conditions set 8 * forth in the LICENSE file which can be found at the top level of 9 * the sendmail distribution. 10 */ 11 12 #include <sm/gen.h> 13 SM_IDSTR(id, "@(#)$Id: strto.c,v 1.19 2013-11-22 20:51:43 ca Exp $") 14 15 #include <sys/param.h> 16 #include <sys/types.h> 17 #include <stdlib.h> 18 #include <ctype.h> 19 #include <errno.h> 20 #include <sm/limits.h> 21 #include <sm/conf.h> 22 #include <sm/string.h> 23 24 /* 25 ** SM_STRTOLL -- Convert a string to a (signed) long long integer. 26 ** 27 ** Ignores `locale' stuff. Assumes that the upper and lower case 28 ** alphabets and digits are each contiguous. 29 ** 30 ** Parameters: 31 ** nptr -- string containing number 32 ** endptr -- location of first invalid character 33 ** base -- numeric base that 'nptr' number is based in 34 ** 35 ** Returns: 36 ** Failure: on underflow LLONG_MIN is returned; on overflow 37 ** LLONG_MAX is returned and errno is set. 38 ** When 'endptr' == '\0' then the entire string 'nptr' 39 ** was valid. 40 ** Success: returns the converted number 41 */ 42 43 LONGLONG_T 44 sm_strtoll(nptr, endptr, base) 45 const char *nptr; 46 char **endptr; 47 register int base; 48 { 49 register bool neg; 50 register const char *s; 51 register LONGLONG_T acc, cutoff; 52 register int c; 53 register int any, cutlim; 54 55 /* 56 ** Skip white space and pick up leading +/- sign if any. 57 ** If base is 0, allow 0x for hex and 0 for octal, else 58 ** assume decimal; if base is already 16, allow 0x. 59 */ 60 61 s = nptr; 62 do 63 { 64 c = (unsigned char) *s++; 65 } while (isascii(c) && isspace(c)); 66 if (c == '-') 67 { 68 neg = true; 69 c = *s++; 70 } 71 else 72 { 73 neg = false; 74 if (c == '+') 75 c = *s++; 76 } 77 if ((base == 0 || base == 16) && 78 c == '0' && (*s == 'x' || *s == 'X')) 79 { 80 c = s[1]; 81 s += 2; 82 base = 16; 83 } 84 if (base == 0) 85 base = c == '0' ? 8 : 10; 86 87 /* 88 ** Compute the cutoff value between legal numbers and illegal 89 ** numbers. That is the largest legal value, divided by the 90 ** base. An input number that is greater than this value, if 91 ** followed by a legal input character, is too big. One that 92 ** is equal to this value may be valid or not; the limit 93 ** between valid and invalid numbers is then based on the last 94 ** digit. For instance, if the range for long-long's is 95 ** [-9223372036854775808..9223372036854775807] and the input base 96 ** is 10, cutoff will be set to 922337203685477580 and cutlim to 97 ** either 7 (!neg) or 8 (neg), meaning that if we have 98 ** accumulated a value > 922337203685477580, or equal but the 99 ** next digit is > 7 (or 8), the number is too big, and we will 100 ** return a range error. 101 ** 102 ** Set any if any `digits' consumed; make it negative to indicate 103 ** overflow. 104 */ 105 106 cutoff = neg ? LLONG_MIN : LLONG_MAX; 107 cutlim = cutoff % base; 108 cutoff /= base; 109 if (neg) 110 { 111 if (cutlim > 0) 112 { 113 cutlim -= base; 114 cutoff += 1; 115 } 116 cutlim = -cutlim; 117 } 118 for (acc = 0, any = 0;; c = (unsigned char) *s++) 119 { 120 if (isascii(c) && isdigit(c)) 121 c -= '0'; 122 else if (isascii(c) && isalpha(c)) 123 c -= isupper(c) ? 'A' - 10 : 'a' - 10; 124 else 125 break; 126 if (c >= base) 127 break; 128 if (any < 0) 129 continue; 130 if (neg) 131 { 132 if (acc < cutoff || (acc == cutoff && c > cutlim)) 133 { 134 any = -1; 135 acc = LLONG_MIN; 136 errno = ERANGE; 137 } 138 else 139 { 140 any = 1; 141 acc *= base; 142 acc -= c; 143 } 144 } 145 else 146 { 147 if (acc > cutoff || (acc == cutoff && c > cutlim)) 148 { 149 any = -1; 150 acc = LLONG_MAX; 151 errno = ERANGE; 152 } 153 else 154 { 155 any = 1; 156 acc *= base; 157 acc += c; 158 } 159 } 160 } 161 if (endptr != 0) 162 *endptr = (char *) (any ? s - 1 : nptr); 163 return acc; 164 } 165 166 /* 167 ** SM_STRTOULL -- Convert a string to an unsigned long long integer. 168 ** 169 ** Ignores `locale' stuff. Assumes that the upper and lower case 170 ** alphabets and digits are each contiguous. 171 ** 172 ** Parameters: 173 ** nptr -- string containing (unsigned) number 174 ** endptr -- location of first invalid character 175 ** base -- numeric base that 'nptr' number is based in 176 ** 177 ** Returns: 178 ** Failure: on overflow ULLONG_MAX is returned and errno is set. 179 ** When 'endptr' == '\0' then the entire string 'nptr' 180 ** was valid. 181 ** Success: returns the converted number 182 */ 183 184 ULONGLONG_T 185 sm_strtoull(nptr, endptr, base) 186 const char *nptr; 187 char **endptr; 188 register int base; 189 { 190 register const char *s; 191 register ULONGLONG_T acc, cutoff; 192 register int c; 193 register bool neg; 194 register int any, cutlim; 195 196 /* See sm_strtoll for comments as to the logic used. */ 197 s = nptr; 198 do 199 { 200 c = (unsigned char) *s++; 201 } while (isascii(c) && isspace(c)); 202 neg = (c == '-'); 203 if (neg) 204 { 205 c = *s++; 206 } 207 else 208 { 209 if (c == '+') 210 c = *s++; 211 } 212 if ((base == 0 || base == 16) && 213 c == '0' && (*s == 'x' || *s == 'X')) 214 { 215 c = s[1]; 216 s += 2; 217 base = 16; 218 } 219 if (base == 0) 220 base = c == '0' ? 8 : 10; 221 222 cutoff = ULLONG_MAX / (ULONGLONG_T)base; 223 cutlim = ULLONG_MAX % (ULONGLONG_T)base; 224 for (acc = 0, any = 0;; c = (unsigned char) *s++) 225 { 226 if (isascii(c) && isdigit(c)) 227 c -= '0'; 228 else if (isascii(c) && isalpha(c)) 229 c -= isupper(c) ? 'A' - 10 : 'a' - 10; 230 else 231 break; 232 if (c >= base) 233 break; 234 if (any < 0) 235 continue; 236 if (acc > cutoff || (acc == cutoff && c > cutlim)) 237 { 238 any = -1; 239 acc = ULLONG_MAX; 240 errno = ERANGE; 241 } 242 else 243 { 244 any = 1; 245 acc *= (ULONGLONG_T)base; 246 acc += c; 247 } 248 } 249 if (neg && any > 0) 250 acc = -((LONGLONG_T) acc); 251 if (endptr != 0) 252 *endptr = (char *) (any ? s - 1 : nptr); 253 return acc; 254 } 255