src/basic/parse-util.c

   1 /***
   2   This file is part of systemd.
   3
   4   Copyright 2010 Lennart Poettering
   5
   6   systemd is free software; you can redistribute it and/or modify it
   7   under the terms of the GNU Lesser General Public License as published by
   8   the Free Software Foundation; either version 2.1 of the License, or
   9   (at your option) any later version.
  10
  11   systemd is distributed in the hope that it will be useful, but
  12   WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14   Lesser General Public License for more details.
  15
  16   You should have received a copy of the GNU Lesser General Public License
  17   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  18 ***/
  19
  20 #include <errno.h>
  21 #include <inttypes.h>
  22 #include <locale.h>
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <xlocale.h>
  27
  28 #include "alloc-util.h"
  29 //#include "extract-word.h"
  30 #include "macro.h"
  31 #include "parse-util.h"
  32 #include "string-util.h"
  33
  34 int parse_boolean(const char *v) {
  35         assert(v);
  36
  37         if (streq(v, "1") || strcaseeq(v, "yes") || strcaseeq(v, "y") || strcaseeq(v, "true") || strcaseeq(v, "t") || strcaseeq(v, "on"))
  38                 return 1;
  39         else if (streq(v, "0") || strcaseeq(v, "no") || strcaseeq(v, "n") || strcaseeq(v, "false") || strcaseeq(v, "f") || strcaseeq(v, "off"))
  40                 return 0;
  41
  42         return -EINVAL;
  43 }
  44
  45 int parse_pid(const char *s, pid_t* ret_pid) {
  46         unsigned long ul = 0;
  47         pid_t pid;
  48         int r;
  49
  50         assert(s);
  51         assert(ret_pid);
  52
  53         r = safe_atolu(s, &ul);
  54         if (r < 0)
  55                 return r;
  56
  57         pid = (pid_t) ul;
  58
  59         if ((unsigned long) pid != ul)
  60                 return -ERANGE;
  61
  62         if (pid <= 0)
  63                 return -ERANGE;
  64
  65         *ret_pid = pid;
  66         return 0;
  67 }
  68
  69 int parse_mode(const char *s, mode_t *ret) {
  70         char *x;
  71         long l;
  72
  73         assert(s);
  74         assert(ret);
  75
  76         s += strspn(s, WHITESPACE);
  77         if (s[0] == '-')
  78                 return -ERANGE;
  79
  80         errno = 0;
  81         l = strtol(s, &x, 8);
  82         if (errno > 0)
  83                 return -errno;
  84         if (!x || x == s || *x)
  85                 return -EINVAL;
  86         if (l < 0 || l  > 07777)
  87                 return -ERANGE;
  88
  89         *ret = (mode_t) l;
  90         return 0;
  91 }
  92
  93 int parse_ifindex(const char *s, int *ret) {
  94         int ifi, r;
  95
  96         r = safe_atoi(s, &ifi);
  97         if (r < 0)
  98                 return r;
  99         if (ifi <= 0)
 100                 return -EINVAL;
 101
 102         *ret = ifi;
 103         return 0;
 104 }
 105
 106 int parse_size(const char *t, uint64_t base, uint64_t *size) {
 107
 108         /* Soo, sometimes we want to parse IEC binary suffixes, and
 109          * sometimes SI decimal suffixes. This function can parse
 110          * both. Which one is the right way depends on the
 111          * context. Wikipedia suggests that SI is customary for
 112          * hardware metrics and network speeds, while IEC is
 113          * customary for most data sizes used by software and volatile
 114          * (RAM) memory. Hence be careful which one you pick!
 115          *
 116          * In either case we use just K, M, G as suffix, and not Ki,
 117          * Mi, Gi or so (as IEC would suggest). That's because that's
 118          * frickin' ugly. But this means you really need to make sure
 119          * to document which base you are parsing when you use this
 120          * call. */
 121
 122         struct table {
 123                 const char *suffix;
 124                 unsigned long long factor;
 125         };
 126
 127         static const struct table iec[] = {
 128                 { "E", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
 129                 { "P", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
 130                 { "T", 1024ULL*1024ULL*1024ULL*1024ULL },
 131                 { "G", 1024ULL*1024ULL*1024ULL },
 132                 { "M", 1024ULL*1024ULL },
 133                 { "K", 1024ULL },
 134                 { "B", 1ULL },
 135                 { "",  1ULL },
 136         };
 137
 138         static const struct table si[] = {
 139                 { "E", 1000ULL*1000ULL*1000ULL*1000ULL*1000ULL*1000ULL },
 140                 { "P", 1000ULL*1000ULL*1000ULL*1000ULL*1000ULL },
 141                 { "T", 1000ULL*1000ULL*1000ULL*1000ULL },
 142                 { "G", 1000ULL*1000ULL*1000ULL },
 143                 { "M", 1000ULL*1000ULL },
 144                 { "K", 1000ULL },
 145                 { "B", 1ULL },
 146                 { "",  1ULL },
 147         };
 148
 149         const struct table *table;
 150         const char *p;
 151         unsigned long long r = 0;
 152         unsigned n_entries, start_pos = 0;
 153
 154         assert(t);
 155         assert(base == 1000 || base == 1024);
 156         assert(size);
 157
 158         if (base == 1000) {
 159                 table = si;
 160                 n_entries = ELEMENTSOF(si);
 161         } else {
 162                 table = iec;
 163                 n_entries = ELEMENTSOF(iec);
 164         }
 165
 166         p = t;
 167         do {
 168                 unsigned long long l, tmp;
 169                 double frac = 0;
 170                 char *e;
 171                 unsigned i;
 172
 173                 p += strspn(p, WHITESPACE);
 174
 175                 errno = 0;
 176                 l = strtoull(p, &e, 10);
 177                 if (errno > 0)
 178                         return -errno;
 179                 if (e == p)
 180                         return -EINVAL;
 181                 if (*p == '-')
 182                         return -ERANGE;
 183
 184                 if (*e == '.') {
 185                         e++;
 186
 187                         /* strtoull() itself would accept space/+/- */
 188                         if (*e >= '0' && *e <= '9') {
 189                                 unsigned long long l2;
 190                                 char *e2;
 191
 192                                 l2 = strtoull(e, &e2, 10);
 193                                 if (errno > 0)
 194                                         return -errno;
 195
 196                                 /* Ignore failure. E.g. 10.M is valid */
 197                                 frac = l2;
 198                                 for (; e < e2; e++)
 199                                         frac /= 10;
 200                         }
 201                 }
 202
 203                 e += strspn(e, WHITESPACE);
 204
 205                 for (i = start_pos; i < n_entries; i++)
 206                         if (startswith(e, table[i].suffix))
 207                                 break;
 208
 209                 if (i >= n_entries)
 210                         return -EINVAL;
 211
 212                 if (l + (frac > 0) > ULLONG_MAX / table[i].factor)
 213                         return -ERANGE;
 214
 215                 tmp = l * table[i].factor + (unsigned long long) (frac * table[i].factor);
 216                 if (tmp > ULLONG_MAX - r)
 217                         return -ERANGE;
 218
 219                 r += tmp;
 220                 if ((unsigned long long) (uint64_t) r != r)
 221                         return -ERANGE;
 222
 223                 p = e + strlen(table[i].suffix);
 224
 225                 start_pos = i + 1;
 226
 227         } while (*p);
 228
 229         *size = r;
 230
 231         return 0;
 232 }
 233
 234 #if 0 /// UNNEEDED by elogind
 235 int parse_range(const char *t, unsigned *lower, unsigned *upper) {
 236         _cleanup_free_ char *word = NULL;
 237         unsigned l, u;
 238         int r;
 239
 240         assert(lower);
 241         assert(upper);
 242
 243         /* Extract the lower bound. */
 244         r = extract_first_word(&t, &word, "-", EXTRACT_DONT_COALESCE_SEPARATORS);
 245         if (r < 0)
 246                 return r;
 247         if (r == 0)
 248                 return -EINVAL;
 249
 250         r = safe_atou(word, &l);
 251         if (r < 0)
 252                 return r;
 253
 254         /* Check for the upper bound and extract it if needed */
 255         if (!t)
 256                 /* Single number with no dashes. */
 257                 u = l;
 258         else if (!*t)
 259                 /* Trailing dash is an error. */
 260                 return -EINVAL;
 261         else {
 262                 r = safe_atou(t, &u);
 263                 if (r < 0)
 264                         return r;
 265         }
 266
 267         *lower = l;
 268         *upper = u;
 269         return 0;
 270 }
 271
 272 char *format_bytes(char *buf, size_t l, uint64_t t) {
 273         unsigned i;
 274
 275         /* This only does IEC units so far */
 276
 277         static const struct {
 278                 const char *suffix;
 279                 uint64_t factor;
 280         } table[] = {
 281                 { "E", UINT64_C(1024)*UINT64_C(1024)*UINT64_C(1024)*UINT64_C(1024)*UINT64_C(1024)*UINT64_C(1024) },
 282                 { "P", UINT64_C(1024)*UINT64_C(1024)*UINT64_C(1024)*UINT64_C(1024)*UINT64_C(1024) },
 283                 { "T", UINT64_C(1024)*UINT64_C(1024)*UINT64_C(1024)*UINT64_C(1024) },
 284                 { "G", UINT64_C(1024)*UINT64_C(1024)*UINT64_C(1024) },
 285                 { "M", UINT64_C(1024)*UINT64_C(1024) },
 286                 { "K", UINT64_C(1024) },
 287         };
 288
 289         if (t == (uint64_t) -1)
 290                 return NULL;
 291
 292         for (i = 0; i < ELEMENTSOF(table); i++) {
 293
 294                 if (t >= table[i].factor) {
 295                         snprintf(buf, l,
 296                                  "%" PRIu64 ".%" PRIu64 "%s",
 297                                  t / table[i].factor,
 298                                  ((t*UINT64_C(10)) / table[i].factor) % UINT64_C(10),
 299                                  table[i].suffix);
 300
 301                         goto finish;
 302                 }
 303         }
 304
 305         snprintf(buf, l, "%" PRIu64 "B", t);
 306
 307 finish:
 308         buf[l-1] = 0;
 309         return buf;
 310
 311 }
 312 #endif // 0
 313
 314 int safe_atou(const char *s, unsigned *ret_u) {
 315         char *x = NULL;
 316         unsigned long l;
 317
 318         assert(s);
 319         assert(ret_u);
 320
 321         /* strtoul() is happy to parse negative values, and silently
 322          * converts them to unsigned values without generating an
 323          * error. We want a clean error, hence let's look for the "-"
 324          * prefix on our own, and generate an error. But let's do so
 325          * only after strtoul() validated that the string is clean
 326          * otherwise, so that we return EINVAL preferably over
 327          * ERANGE. */
 328
 329         s += strspn(s, WHITESPACE);
 330
 331         errno = 0;
 332         l = strtoul(s, &x, 0);
 333         if (errno > 0)
 334                 return -errno;
 335         if (!x || x == s || *x)
 336                 return -EINVAL;
 337         if (s[0] == '-')
 338                 return -ERANGE;
 339         if ((unsigned long) (unsigned) l != l)
 340                 return -ERANGE;
 341
 342         *ret_u = (unsigned) l;
 343         return 0;
 344 }
 345
 346 int safe_atoi(const char *s, int *ret_i) {
 347         char *x = NULL;
 348         long l;
 349
 350         assert(s);
 351         assert(ret_i);
 352
 353         errno = 0;
 354         l = strtol(s, &x, 0);
 355         if (errno > 0)
 356                 return -errno;
 357         if (!x || x == s || *x)
 358                 return -EINVAL;
 359         if ((long) (int) l != l)
 360                 return -ERANGE;
 361
 362         *ret_i = (int) l;
 363         return 0;
 364 }
 365
 366 int safe_atollu(const char *s, long long unsigned *ret_llu) {
 367         char *x = NULL;
 368         unsigned long long l;
 369
 370         assert(s);
 371         assert(ret_llu);
 372
 373         s += strspn(s, WHITESPACE);
 374
 375         errno = 0;
 376         l = strtoull(s, &x, 0);
 377         if (errno > 0)
 378                 return -errno;
 379         if (!x || x == s || *x)
 380                 return -EINVAL;
 381         if (*s == '-')
 382                 return -ERANGE;
 383
 384         *ret_llu = l;
 385         return 0;
 386 }
 387
 388 int safe_atolli(const char *s, long long int *ret_lli) {
 389         char *x = NULL;
 390         long long l;
 391
 392         assert(s);
 393         assert(ret_lli);
 394
 395         errno = 0;
 396         l = strtoll(s, &x, 0);
 397         if (errno > 0)
 398                 return -errno;
 399         if (!x || x == s || *x)
 400                 return -EINVAL;
 401
 402         *ret_lli = l;
 403         return 0;
 404 }
 405
 406 int safe_atou8(const char *s, uint8_t *ret) {
 407         char *x = NULL;
 408         unsigned long l;
 409
 410         assert(s);
 411         assert(ret);
 412
 413         s += strspn(s, WHITESPACE);
 414
 415         errno = 0;
 416         l = strtoul(s, &x, 0);
 417         if (errno > 0)
 418                 return -errno;
 419         if (!x || x == s || *x)
 420                 return -EINVAL;
 421         if (s[0] == '-')
 422                 return -ERANGE;
 423         if ((unsigned long) (uint8_t) l != l)
 424                 return -ERANGE;
 425
 426         *ret = (uint8_t) l;
 427         return 0;
 428 }
 429
 430 int safe_atou16(const char *s, uint16_t *ret) {
 431         char *x = NULL;
 432         unsigned long l;
 433
 434         assert(s);
 435         assert(ret);
 436
 437         s += strspn(s, WHITESPACE);
 438
 439         errno = 0;
 440         l = strtoul(s, &x, 0);
 441         if (errno > 0)
 442                 return -errno;
 443         if (!x || x == s || *x)
 444                 return -EINVAL;
 445         if (s[0] == '-')
 446                 return -ERANGE;
 447         if ((unsigned long) (uint16_t) l != l)
 448                 return -ERANGE;
 449
 450         *ret = (uint16_t) l;
 451         return 0;
 452 }
 453
 454 int safe_atoi16(const char *s, int16_t *ret) {
 455         char *x = NULL;
 456         long l;
 457
 458         assert(s);
 459         assert(ret);
 460
 461         errno = 0;
 462         l = strtol(s, &x, 0);
 463         if (errno > 0)
 464                 return -errno;
 465         if (!x || x == s || *x)
 466                 return -EINVAL;
 467         if ((long) (int16_t) l != l)
 468                 return -ERANGE;
 469
 470         *ret = (int16_t) l;
 471         return 0;
 472 }
 473
 474 int safe_atod(const char *s, double *ret_d) {
 475         char *x = NULL;
 476         double d = 0;
 477         locale_t loc;
 478
 479         assert(s);
 480         assert(ret_d);
 481
 482         loc = newlocale(LC_NUMERIC_MASK, "C", (locale_t) 0);
 483         if (loc == (locale_t) 0)
 484                 return -errno;
 485
 486         errno = 0;
 487         d = strtod_l(s, &x, loc);
 488         if (errno > 0) {
 489                 freelocale(loc);
 490                 return -errno;
 491         }
 492         if (!x || x == s || *x) {
 493                 freelocale(loc);
 494                 return -EINVAL;
 495         }
 496
 497         freelocale(loc);
 498         *ret_d = (double) d;
 499         return 0;
 500 }
 501
 502 int parse_fractional_part_u(const char **p, size_t digits, unsigned *res) {
 503         size_t i;
 504         unsigned val = 0;
 505         const char *s;
 506
 507         s = *p;
 508
 509         /* accept any number of digits, strtoull is limted to 19 */
 510         for(i=0; i < digits; i++,s++) {
 511                 if (*s < '0' || *s > '9') {
 512                         if (i == 0)
 513                                 return -EINVAL;
 514
 515                         /* too few digits, pad with 0 */
 516                         for (; i < digits; i++)
 517                                 val *= 10;
 518
 519                         break;
 520                 }
 521
 522                 val *= 10;
 523                 val += *s - '0';
 524         }
 525
 526         /* maybe round up */
 527         if (*s >= '5' && *s <= '9')
 528                 val++;
 529
 530         s += strspn(s, DIGITS);
 531
 532         *p = s;
 533         *res = val;
 534
 535         return 0;
 536 }