zfs/lib/libuutil/uu_strtoint.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License, Version 1.0 only
   6  * (the "License").  You may not use this file except in compliance
   7  * with the License.
   8  *
   9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  10  * or http://www.opensolaris.org/os/licensing.
  11  * See the License for the specific language governing permissions
  12  * and limitations under the License.
  13  *
  14  * When distributing Covered Code, include this CDDL HEADER in each
  15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  16  * If applicable, add the following below this CDDL HEADER, with the
  17  * fields enclosed by brackets "[]" replaced with your own identifying
  18  * information: Portions Copyright [yyyy] [name of copyright owner]
  19  *
  20  * CDDL HEADER END
  21  */
  22 /*
  23  * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 #pragma ident   "%Z%%M% %I%     %E% SMI"
  28
  29 #include "libuutil_common.h"
  30
  31 #include <limits.h>
  32 #include <ctype.h>
  33
  34 #define MAX_BASE        36
  35
  36 #define IS_DIGIT(x)     ((x) >= '0' && (x) <= '9')
  37
  38 #define CTOI(x) (((x) >= '0' && (x) <= '9') ? (x) - '0' : \
  39             ((x) >= 'a' && (x) <= 'z') ? (x) + 10 - 'a' : (x) + 10 - 'A')
  40
  41 static int
  42 strtoint(const char *s_arg, uint64_t *out, uint32_t base, int sign)
  43 {
  44         const unsigned char *s = (const unsigned char *)s_arg;
  45
  46         uint64_t val = 0;
  47         uint64_t multmax;
  48
  49         unsigned c, i;
  50
  51         int neg = 0;
  52
  53         int bad_digit = 0;
  54         int bad_char = 0;
  55         int overflow = 0;
  56
  57         if (s == NULL || base == 1 || base > MAX_BASE) {
  58                 uu_set_error(UU_ERROR_INVALID_ARGUMENT);
  59                 return (-1);
  60         }
  61
  62         while ((c = *s) != 0 && isspace(c))
  63                 s++;
  64
  65         switch (c) {
  66         case '-':
  67                 if (!sign)
  68                         overflow = 1;           /* becomes underflow below */
  69                 neg = 1;
  70                 /*FALLTHRU*/
  71         case '+':
  72                 c = *++s;
  73                 break;
  74         default:
  75                 break;
  76         }
  77
  78         if (c == '\0') {
  79                 uu_set_error(UU_ERROR_EMPTY);
  80                 return (-1);
  81         }
  82
  83         if (base == 0) {
  84                 if (c != '0')
  85                         base = 10;
  86                 else if (s[1] == 'x' || s[1] == 'X')
  87                         base = 16;
  88                 else
  89                         base = 8;
  90         }
  91
  92         if (base == 16 && c == '0' && (s[1] == 'x' || s[1] == 'X'))
  93                 c = *(s += 2);
  94
  95         if ((val = CTOI(c)) >= base) {
  96                 if (IS_DIGIT(c))
  97                         bad_digit = 1;
  98                 else
  99                         bad_char = 1;
 100                 val = 0;
 101         }
 102
 103         multmax = (uint64_t)UINT64_MAX / (uint64_t)base;
 104
 105         for (c = *++s; c != '\0'; c = *++s) {
 106                 if ((i = CTOI(c)) >= base) {
 107                         if (isspace(c))
 108                                 break;
 109                         if (IS_DIGIT(c))
 110                                 bad_digit = 1;
 111                         else
 112                                 bad_char = 1;
 113                         i = 0;
 114                 }
 115
 116                 if (val > multmax)
 117                         overflow = 1;
 118
 119                 val *= base;
 120                 if ((uint64_t)UINT64_MAX - val < (uint64_t)i)
 121                         overflow = 1;
 122
 123                 val += i;
 124         }
 125
 126         while ((c = *s) != 0) {
 127                 if (!isspace(c))
 128                         bad_char = 1;
 129                 s++;
 130         }
 131
 132         if (sign) {
 133                 if (neg) {
 134                         if (val > -(uint64_t)INT64_MIN)
 135                                 overflow = 1;
 136                 } else {
 137                         if (val > INT64_MAX)
 138                                 overflow = 1;
 139                 }
 140         }
 141
 142         if (neg)
 143                 val = -val;
 144
 145         if (bad_char | bad_digit | overflow) {
 146                 if (bad_char)
 147                         uu_set_error(UU_ERROR_INVALID_CHAR);
 148                 else if (bad_digit)
 149                         uu_set_error(UU_ERROR_INVALID_DIGIT);
 150                 else if (overflow) {
 151                         if (neg)
 152                                 uu_set_error(UU_ERROR_UNDERFLOW);
 153                         else
 154                                 uu_set_error(UU_ERROR_OVERFLOW);
 155                 }
 156                 return (-1);
 157         }
 158
 159         *out = val;
 160         return (0);
 161 }
 162
 163 int
 164 uu_strtoint(const char *s, void *v, size_t sz, int base,
 165     int64_t min, int64_t max)
 166 {
 167         uint64_t val_u;
 168         int64_t val;
 169
 170         if (min > max)
 171                 goto bad_argument;
 172
 173         switch (sz) {
 174         case 1:
 175                 if (max > INT8_MAX || min < INT8_MIN)
 176                         goto bad_argument;
 177                 break;
 178         case 2:
 179                 if (max > INT16_MAX || min < INT16_MIN)
 180                         goto bad_argument;
 181                 break;
 182         case 4:
 183                 if (max > INT32_MAX || min < INT32_MIN)
 184                         goto bad_argument;
 185                 break;
 186         case 8:
 187                 if (max > INT64_MAX || min < INT64_MIN)
 188                         goto bad_argument;
 189                 break;
 190         default:
 191                 goto bad_argument;
 192         }
 193
 194         if (min == 0 && max == 0) {
 195                 min = -(1ULL << (8 * sz - 1));
 196                 max = (1ULL << (8 * sz - 1)) - 1;
 197         }
 198
 199         if (strtoint(s, &val_u, base, 1) == -1)
 200                 return (-1);
 201
 202         val = (int64_t)val_u;
 203
 204         if (val < min) {
 205                 uu_set_error(UU_ERROR_UNDERFLOW);
 206                 return (-1);
 207         } else if (val > max) {
 208                 uu_set_error(UU_ERROR_OVERFLOW);
 209                 return (-1);
 210         }
 211
 212         switch (sz) {
 213         case 1:
 214                 *(int8_t *)v = val;
 215                 return (0);
 216         case 2:
 217                 *(int16_t *)v = val;
 218                 return (0);
 219         case 4:
 220                 *(int32_t *)v = val;
 221                 return (0);
 222         case 8:
 223                 *(int64_t *)v = val;
 224                 return (0);
 225         default:
 226                 break;          /* fall through to bad_argument */
 227         }
 228
 229 bad_argument:
 230         uu_set_error(UU_ERROR_INVALID_ARGUMENT);
 231         return (-1);
 232 }
 233
 234 int
 235 uu_strtouint(const char *s, void *v, size_t sz, int base,
 236     uint64_t min, uint64_t max)
 237 {
 238         uint64_t val;
 239
 240         if (min > max)
 241                 goto bad_argument;
 242
 243         switch (sz) {
 244         case 1:
 245                 if (max > UINT8_MAX)
 246                         goto bad_argument;
 247                 break;
 248         case 2:
 249                 if (max > UINT16_MAX)
 250                         goto bad_argument;
 251                 break;
 252         case 4:
 253                 if (max > UINT32_MAX)
 254                         goto bad_argument;
 255                 break;
 256         case 8:
 257                 if (max > UINT64_MAX)
 258                         goto bad_argument;
 259                 break;
 260         default:
 261                 goto bad_argument;
 262         }
 263
 264         if (min == 0 && max == 0) {
 265                 /* we have to be careful, since << can overflow */
 266                 max = (1ULL << (8 * sz - 1)) * 2 - 1;
 267         }
 268
 269         if (strtoint(s, &val, base, 0) == -1)
 270                 return (-1);
 271
 272         if (val < min) {
 273                 uu_set_error(UU_ERROR_UNDERFLOW);
 274                 return (-1);
 275         } else if (val > max) {
 276                 uu_set_error(UU_ERROR_OVERFLOW);
 277                 return (-1);
 278         }
 279
 280         switch (sz) {
 281         case 1:
 282                 *(uint8_t *)v = val;
 283                 return (0);
 284         case 2:
 285                 *(uint16_t *)v = val;
 286                 return (0);
 287         case 4:
 288                 *(uint32_t *)v = val;
 289                 return (0);
 290         case 8:
 291                 *(uint64_t *)v = val;
 292                 return (0);
 293         default:
 294                 break;          /* shouldn't happen, fall through */
 295         }
 296
 297 bad_argument:
 298         uu_set_error(UU_ERROR_INVALID_ARGUMENT);
 299         return (-1);
 300 }