util/cutils.c

   1 /*
   2  * Simple C functions to supplement the C library
   3  *
   4  * Copyright (c) 2006 Fabrice Bellard
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24
  25 #include "qemu/osdep.h"
  26 #include "qemu/host-utils.h"
  27 #include <math.h>
  28
  29 #include "qemu/ctype.h"
  30 #include "qemu/cutils.h"
  31 #include "qemu/error-report.h"
  32
  33 void strpadcpy(char *buf, int buf_size, const char *str, char pad)
  34 {
  35     int len = qemu_strnlen(str, buf_size);
  36     memcpy(buf, str, len);
  37     memset(buf + len, pad, buf_size - len);
  38 }
  39
  40 void pstrcpy(char *buf, int buf_size, const char *str)
  41 {
  42     int c;
  43     char *q = buf;
  44
  45     if (buf_size <= 0)
  46         return;
  47
  48     for(;;) {
  49         c = *str++;
  50         if (c == 0 || q >= buf + buf_size - 1)
  51             break;
  52         *q++ = c;
  53     }
  54     *q = '\0';
  55 }
  56
  57 /* strcat and truncate. */
  58 char *pstrcat(char *buf, int buf_size, const char *s)
  59 {
  60     int len;
  61     len = strlen(buf);
  62     if (len < buf_size)
  63         pstrcpy(buf + len, buf_size - len, s);
  64     return buf;
  65 }
  66
  67 int strstart(const char *str, const char *val, const char **ptr)
  68 {
  69     const char *p, *q;
  70     p = str;
  71     q = val;
  72     while (*q != '\0') {
  73         if (*p != *q)
  74             return 0;
  75         p++;
  76         q++;
  77     }
  78     if (ptr)
  79         *ptr = p;
  80     return 1;
  81 }
  82
  83 int stristart(const char *str, const char *val, const char **ptr)
  84 {
  85     const char *p, *q;
  86     p = str;
  87     q = val;
  88     while (*q != '\0') {
  89         if (qemu_toupper(*p) != qemu_toupper(*q))
  90             return 0;
  91         p++;
  92         q++;
  93     }
  94     if (ptr)
  95         *ptr = p;
  96     return 1;
  97 }
  98
  99 /* XXX: use host strnlen if available ? */
 100 int qemu_strnlen(const char *s, int max_len)
 101 {
 102     int i;
 103
 104     for(i = 0; i < max_len; i++) {
 105         if (s[i] == '\0') {
 106             break;
 107         }
 108     }
 109     return i;
 110 }
 111
 112 char *qemu_strsep(char **input, const char *delim)
 113 {
 114     char *result = *input;
 115     if (result != NULL) {
 116         char *p;
 117
 118         for (p = result; *p != '\0'; p++) {
 119             if (strchr(delim, *p)) {
 120                 break;
 121             }
 122         }
 123         if (*p == '\0') {
 124             *input = NULL;
 125         } else {
 126             *p = '\0';
 127             *input = p + 1;
 128         }
 129     }
 130     return result;
 131 }
 132
 133 time_t mktimegm(struct tm *tm)
 134 {
 135     time_t t;
 136     int y = tm->tm_year + 1900, m = tm->tm_mon + 1, d = tm->tm_mday;
 137     if (m < 3) {
 138         m += 12;
 139         y--;
 140     }
 141     t = 86400ULL * (d + (153 * m - 457) / 5 + 365 * y + y / 4 - y / 100 +
 142                  y / 400 - 719469);
 143     t += 3600 * tm->tm_hour + 60 * tm->tm_min + tm->tm_sec;
 144     return t;
 145 }
 146
 147 /*
 148  * Make sure data goes on disk, but if possible do not bother to
 149  * write out the inode just for timestamp updates.
 150  *
 151  * Unfortunately even in 2009 many operating systems do not support
 152  * fdatasync and have to fall back to fsync.
 153  */
 154 int qemu_fdatasync(int fd)
 155 {
 156 #ifdef CONFIG_FDATASYNC
 157     return fdatasync(fd);
 158 #else
 159     return fsync(fd);
 160 #endif
 161 }
 162
 163 /**
 164  * Sync changes made to the memory mapped file back to the backing
 165  * storage. For POSIX compliant systems this will fallback
 166  * to regular msync call. Otherwise it will trigger whole file sync
 167  * (including the metadata case there is no support to skip that otherwise)
 168  *
 169  * @addr   - start of the memory area to be synced
 170  * @length - length of the are to be synced
 171  * @fd     - file descriptor for the file to be synced
 172  *           (mandatory only for POSIX non-compliant systems)
 173  */
 174 int qemu_msync(void *addr, size_t length, int fd)
 175 {
 176 #ifdef CONFIG_POSIX
 177     size_t align_mask = ~(qemu_real_host_page_size() - 1);
 178
 179     /**
 180      * There are no strict reqs as per the length of mapping
 181      * to be synced. Still the length needs to follow the address
 182      * alignment changes. Additionally - round the size to the multiple
 183      * of PAGE_SIZE
 184      */
 185     length += ((uintptr_t)addr & (qemu_real_host_page_size() - 1));
 186     length = (length + ~align_mask) & align_mask;
 187
 188     addr = (void *)((uintptr_t)addr & align_mask);
 189
 190     return msync(addr, length, MS_SYNC);
 191 #else /* CONFIG_POSIX */
 192     /**
 193      * Perform the sync based on the file descriptor
 194      * The sync range will most probably be wider than the one
 195      * requested - but it will still get the job done
 196      */
 197     return qemu_fdatasync(fd);
 198 #endif /* CONFIG_POSIX */
 199 }
 200
 201 static int64_t suffix_mul(char suffix, int64_t unit)
 202 {
 203     switch (qemu_toupper(suffix)) {
 204     case 'B':
 205         return 1;
 206     case 'K':
 207         return unit;
 208     case 'M':
 209         return unit * unit;
 210     case 'G':
 211         return unit * unit * unit;
 212     case 'T':
 213         return unit * unit * unit * unit;
 214     case 'P':
 215         return unit * unit * unit * unit * unit;
 216     case 'E':
 217         return unit * unit * unit * unit * unit * unit;
 218     }
 219     return -1;
 220 }
 221
 222 /*
 223  * Convert size string to bytes.
 224  *
 225  * The size parsing supports the following syntaxes
 226  * - 12345 - decimal, scale determined by @default_suffix and @unit
 227  * - 12345{bBkKmMgGtTpPeE} - decimal, scale determined by suffix and @unit
 228  * - 12345.678{kKmMgGtTpPeE} - decimal, scale determined by suffix, and
 229  *   fractional portion is truncated to byte
 230  * - 0x7fEE - hexadecimal, unit determined by @default_suffix
 231  *
 232  * The following cause a deprecation warning, and may be removed in the future
 233  * - 0xabc{kKmMgGtTpP} - hex with scaling suffix
 234  *
 235  * The following are intentionally not supported
 236  * - octal, such as 08
 237  * - fractional hex, such as 0x1.8
 238  * - floating point exponents, such as 1e3
 239  *
 240  * The end pointer will be returned in *end, if not NULL.  If there is
 241  * no fraction, the input can be decimal or hexadecimal; if there is a
 242  * fraction, then the input must be decimal and there must be a suffix
 243  * (possibly by @default_suffix) larger than Byte, and the fractional
 244  * portion may suffer from precision loss or rounding.  The input must
 245  * be positive.
 246  *
 247  * Return -ERANGE on overflow (with *@end advanced), and -EINVAL on
 248  * other error (with *@end left unchanged).
 249  */
 250 static int do_strtosz(const char *nptr, const char **end,
 251                       const char default_suffix, int64_t unit,
 252                       uint64_t *result)
 253 {
 254     int retval;
 255     const char *endptr, *f;
 256     unsigned char c;
 257     bool hex = false;
 258     uint64_t val, valf = 0;
 259     int64_t mul;
 260
 261     /* Parse integral portion as decimal. */
 262     retval = qemu_strtou64(nptr, &endptr, 10, &val);
 263     if (retval) {
 264         goto out;
 265     }
 266     if (memchr(nptr, '-', endptr - nptr) != NULL) {
 267         endptr = nptr;
 268         retval = -EINVAL;
 269         goto out;
 270     }
 271     if (val == 0 && (*endptr == 'x' || *endptr == 'X')) {
 272         /* Input looks like hex, reparse, and insist on no fraction. */
 273         retval = qemu_strtou64(nptr, &endptr, 16, &val);
 274         if (retval) {
 275             goto out;
 276         }
 277         if (*endptr == '.') {
 278             endptr = nptr;
 279             retval = -EINVAL;
 280             goto out;
 281         }
 282         hex = true;
 283     } else if (*endptr == '.') {
 284         /*
 285          * Input looks like a fraction.  Make sure even 1.k works
 286          * without fractional digits.  If we see an exponent, treat
 287          * the entire input as invalid instead.
 288          */
 289         double fraction;
 290
 291         f = endptr;
 292         retval = qemu_strtod_finite(f, &endptr, &fraction);
 293         if (retval) {
 294             endptr++;
 295         } else if (memchr(f, 'e', endptr - f) || memchr(f, 'E', endptr - f)) {
 296             endptr = nptr;
 297             retval = -EINVAL;
 298             goto out;
 299         } else {
 300             /* Extract into a 64-bit fixed-point fraction. */
 301             valf = (uint64_t)(fraction * 0x1p64);
 302         }
 303     }
 304     c = *endptr;
 305     mul = suffix_mul(c, unit);
 306     if (mul > 0) {
 307         if (hex) {
 308             warn_report("Using a multiplier suffix on hex numbers "
 309                         "is deprecated: %s", nptr);
 310         }
 311         endptr++;
 312     } else {
 313         mul = suffix_mul(default_suffix, unit);
 314         assert(mul > 0);
 315     }
 316     if (mul == 1) {
 317         /* When a fraction is present, a scale is required. */
 318         if (valf != 0) {
 319             endptr = nptr;
 320             retval = -EINVAL;
 321             goto out;
 322         }
 323     } else {
 324         uint64_t valh, tmp;
 325
 326         /* Compute exact result: 64.64 x 64.0 -> 128.64 fixed point */
 327         mulu64(&val, &valh, val, mul);
 328         mulu64(&valf, &tmp, valf, mul);
 329         val += tmp;
 330         valh += val < tmp;
 331
 332         /* Round 0.5 upward. */
 333         tmp = valf >> 63;
 334         val += tmp;
 335         valh += val < tmp;
 336
 337         /* Report overflow. */
 338         if (valh != 0) {
 339             retval = -ERANGE;
 340             goto out;
 341         }
 342     }
 343
 344     retval = 0;
 345
 346 out:
 347     if (end) {
 348         *end = endptr;
 349     } else if (*endptr) {
 350         retval = -EINVAL;
 351     }
 352     if (retval == 0) {
 353         *result = val;
 354     }
 355
 356     return retval;
 357 }
 358
 359 int qemu_strtosz(const char *nptr, const char **end, uint64_t *result)
 360 {
 361     return do_strtosz(nptr, end, 'B', 1024, result);
 362 }
 363
 364 int qemu_strtosz_MiB(const char *nptr, const char **end, uint64_t *result)
 365 {
 366     return do_strtosz(nptr, end, 'M', 1024, result);
 367 }
 368
 369 int qemu_strtosz_metric(const char *nptr, const char **end, uint64_t *result)
 370 {
 371     return do_strtosz(nptr, end, 'B', 1000, result);
 372 }
 373
 374 /**
 375  * Helper function for error checking after strtol() and the like
 376  */
 377 static int check_strtox_error(const char *nptr, char *ep,
 378                               const char **endptr, bool check_zero,
 379                               int libc_errno)
 380 {
 381     assert(ep >= nptr);
 382
 383     /* Windows has a bug in that it fails to parse 0 from "0x" in base 16 */
 384     if (check_zero && ep == nptr && libc_errno == 0) {
 385         char *tmp;
 386
 387         errno = 0;
 388         if (strtol(nptr, &tmp, 10) == 0 && errno == 0 &&
 389             (*tmp == 'x' || *tmp == 'X')) {
 390             ep = tmp;
 391         }
 392     }
 393
 394     if (endptr) {
 395         *endptr = ep;
 396     }
 397
 398     /* Turn "no conversion" into an error */
 399     if (libc_errno == 0 && ep == nptr) {
 400         return -EINVAL;
 401     }
 402
 403     /* Fail when we're expected to consume the string, but didn't */
 404     if (!endptr && *ep) {
 405         return -EINVAL;
 406     }
 407
 408     return -libc_errno;
 409 }
 410
 411 /**
 412  * Convert string @nptr to an integer, and store it in @result.
 413  *
 414  * This is a wrapper around strtol() that is harder to misuse.
 415  * Semantics of @nptr, @endptr, @base match strtol() with differences
 416  * noted below.
 417  *
 418  * @nptr may be null, and no conversion is performed then.
 419  *
 420  * If no conversion is performed, store @nptr in *@endptr and return
 421  * -EINVAL.
 422  *
 423  * If @endptr is null, and the string isn't fully converted, return
 424  * -EINVAL.  This is the case when the pointer that would be stored in
 425  * a non-null @endptr points to a character other than '\0'.
 426  *
 427  * If the conversion overflows @result, store INT_MAX in @result,
 428  * and return -ERANGE.
 429  *
 430  * If the conversion underflows @result, store INT_MIN in @result,
 431  * and return -ERANGE.
 432  *
 433  * Else store the converted value in @result, and return zero.
 434  */
 435 int qemu_strtoi(const char *nptr, const char **endptr, int base,
 436                 int *result)
 437 {
 438     char *ep;
 439     long long lresult;
 440
 441     assert((unsigned) base <= 36 && base != 1);
 442     if (!nptr) {
 443         if (endptr) {
 444             *endptr = nptr;
 445         }
 446         return -EINVAL;
 447     }
 448
 449     errno = 0;
 450     lresult = strtoll(nptr, &ep, base);
 451     if (lresult < INT_MIN) {
 452         *result = INT_MIN;
 453         errno = ERANGE;
 454     } else if (lresult > INT_MAX) {
 455         *result = INT_MAX;
 456         errno = ERANGE;
 457     } else {
 458         *result = lresult;
 459     }
 460     return check_strtox_error(nptr, ep, endptr, lresult == 0, errno);
 461 }
 462
 463 /**
 464  * Convert string @nptr to an unsigned integer, and store it in @result.
 465  *
 466  * This is a wrapper around strtoul() that is harder to misuse.
 467  * Semantics of @nptr, @endptr, @base match strtoul() with differences
 468  * noted below.
 469  *
 470  * @nptr may be null, and no conversion is performed then.
 471  *
 472  * If no conversion is performed, store @nptr in *@endptr and return
 473  * -EINVAL.
 474  *
 475  * If @endptr is null, and the string isn't fully converted, return
 476  * -EINVAL.  This is the case when the pointer that would be stored in
 477  * a non-null @endptr points to a character other than '\0'.
 478  *
 479  * If the conversion overflows @result, store UINT_MAX in @result,
 480  * and return -ERANGE.
 481  *
 482  * Else store the converted value in @result, and return zero.
 483  *
 484  * Note that a number with a leading minus sign gets converted without
 485  * the minus sign, checked for overflow (see above), then negated (in
 486  * @result's type).  This is exactly how strtoul() works.
 487  */
 488 int qemu_strtoui(const char *nptr, const char **endptr, int base,
 489                  unsigned int *result)
 490 {
 491     char *ep;
 492     long long lresult;
 493
 494     assert((unsigned) base <= 36 && base != 1);
 495     if (!nptr) {
 496         if (endptr) {
 497             *endptr = nptr;
 498         }
 499         return -EINVAL;
 500     }
 501
 502     errno = 0;
 503     lresult = strtoull(nptr, &ep, base);
 504
 505     /* Windows returns 1 for negative out-of-range values.  */
 506     if (errno == ERANGE) {
 507         *result = -1;
 508     } else {
 509         if (lresult > UINT_MAX) {
 510             *result = UINT_MAX;
 511             errno = ERANGE;
 512         } else if (lresult < INT_MIN) {
 513             *result = UINT_MAX;
 514             errno = ERANGE;
 515         } else {
 516             *result = lresult;
 517         }
 518     }
 519     return check_strtox_error(nptr, ep, endptr, lresult == 0, errno);
 520 }
 521
 522 /**
 523  * Convert string @nptr to a long integer, and store it in @result.
 524  *
 525  * This is a wrapper around strtol() that is harder to misuse.
 526  * Semantics of @nptr, @endptr, @base match strtol() with differences
 527  * noted below.
 528  *
 529  * @nptr may be null, and no conversion is performed then.
 530  *
 531  * If no conversion is performed, store @nptr in *@endptr and return
 532  * -EINVAL.
 533  *
 534  * If @endptr is null, and the string isn't fully converted, return
 535  * -EINVAL.  This is the case when the pointer that would be stored in
 536  * a non-null @endptr points to a character other than '\0'.
 537  *
 538  * If the conversion overflows @result, store LONG_MAX in @result,
 539  * and return -ERANGE.
 540  *
 541  * If the conversion underflows @result, store LONG_MIN in @result,
 542  * and return -ERANGE.
 543  *
 544  * Else store the converted value in @result, and return zero.
 545  */
 546 int qemu_strtol(const char *nptr, const char **endptr, int base,
 547                 long *result)
 548 {
 549     char *ep;
 550
 551     assert((unsigned) base <= 36 && base != 1);
 552     if (!nptr) {
 553         if (endptr) {
 554             *endptr = nptr;
 555         }
 556         return -EINVAL;
 557     }
 558
 559     errno = 0;
 560     *result = strtol(nptr, &ep, base);
 561     return check_strtox_error(nptr, ep, endptr, *result == 0, errno);
 562 }
 563
 564 /**
 565  * Convert string @nptr to an unsigned long, and store it in @result.
 566  *
 567  * This is a wrapper around strtoul() that is harder to misuse.
 568  * Semantics of @nptr, @endptr, @base match strtoul() with differences
 569  * noted below.
 570  *
 571  * @nptr may be null, and no conversion is performed then.
 572  *
 573  * If no conversion is performed, store @nptr in *@endptr and return
 574  * -EINVAL.
 575  *
 576  * If @endptr is null, and the string isn't fully converted, return
 577  * -EINVAL.  This is the case when the pointer that would be stored in
 578  * a non-null @endptr points to a character other than '\0'.
 579  *
 580  * If the conversion overflows @result, store ULONG_MAX in @result,
 581  * and return -ERANGE.
 582  *
 583  * Else store the converted value in @result, and return zero.
 584  *
 585  * Note that a number with a leading minus sign gets converted without
 586  * the minus sign, checked for overflow (see above), then negated (in
 587  * @result's type).  This is exactly how strtoul() works.
 588  */
 589 int qemu_strtoul(const char *nptr, const char **endptr, int base,
 590                  unsigned long *result)
 591 {
 592     char *ep;
 593
 594     assert((unsigned) base <= 36 && base != 1);
 595     if (!nptr) {
 596         if (endptr) {
 597             *endptr = nptr;
 598         }
 599         return -EINVAL;
 600     }
 601
 602     errno = 0;
 603     *result = strtoul(nptr, &ep, base);
 604     /* Windows returns 1 for negative out-of-range values.  */
 605     if (errno == ERANGE) {
 606         *result = -1;
 607     }
 608     return check_strtox_error(nptr, ep, endptr, *result == 0, errno);
 609 }
 610
 611 /**
 612  * Convert string @nptr to an int64_t.
 613  *
 614  * Works like qemu_strtol(), except it stores INT64_MAX on overflow,
 615  * and INT64_MIN on underflow.
 616  */
 617 int qemu_strtoi64(const char *nptr, const char **endptr, int base,
 618                  int64_t *result)
 619 {
 620     char *ep;
 621
 622     assert((unsigned) base <= 36 && base != 1);
 623     if (!nptr) {
 624         if (endptr) {
 625             *endptr = nptr;
 626         }
 627         return -EINVAL;
 628     }
 629
 630     /* This assumes int64_t is long long TODO relax */
 631     QEMU_BUILD_BUG_ON(sizeof(int64_t) != sizeof(long long));
 632     errno = 0;
 633     *result = strtoll(nptr, &ep, base);
 634     return check_strtox_error(nptr, ep, endptr, *result == 0, errno);
 635 }
 636
 637 /**
 638  * Convert string @nptr to an uint64_t.
 639  *
 640  * Works like qemu_strtoul(), except it stores UINT64_MAX on overflow.
 641  */
 642 int qemu_strtou64(const char *nptr, const char **endptr, int base,
 643                   uint64_t *result)
 644 {
 645     char *ep;
 646
 647     assert((unsigned) base <= 36 && base != 1);
 648     if (!nptr) {
 649         if (endptr) {
 650             *endptr = nptr;
 651         }
 652         return -EINVAL;
 653     }
 654
 655     /* This assumes uint64_t is unsigned long long TODO relax */
 656     QEMU_BUILD_BUG_ON(sizeof(uint64_t) != sizeof(unsigned long long));
 657     errno = 0;
 658     *result = strtoull(nptr, &ep, base);
 659     /* Windows returns 1 for negative out-of-range values.  */
 660     if (errno == ERANGE) {
 661         *result = -1;
 662     }
 663     return check_strtox_error(nptr, ep, endptr, *result == 0, errno);
 664 }
 665
 666 /**
 667  * Convert string @nptr to a double.
 668   *
 669  * This is a wrapper around strtod() that is harder to misuse.
 670  * Semantics of @nptr and @endptr match strtod() with differences
 671  * noted below.
 672  *
 673  * @nptr may be null, and no conversion is performed then.
 674  *
 675  * If no conversion is performed, store @nptr in *@endptr and return
 676  * -EINVAL.
 677  *
 678  * If @endptr is null, and the string isn't fully converted, return
 679  * -EINVAL. This is the case when the pointer that would be stored in
 680  * a non-null @endptr points to a character other than '\0'.
 681  *
 682  * If the conversion overflows, store +/-HUGE_VAL in @result, depending
 683  * on the sign, and return -ERANGE.
 684  *
 685  * If the conversion underflows, store +/-0.0 in @result, depending on the
 686  * sign, and return -ERANGE.
 687  *
 688  * Else store the converted value in @result, and return zero.
 689  */
 690 int qemu_strtod(const char *nptr, const char **endptr, double *result)
 691 {
 692     char *ep;
 693
 694     if (!nptr) {
 695         if (endptr) {
 696             *endptr = nptr;
 697         }
 698         return -EINVAL;
 699     }
 700
 701     errno = 0;
 702     *result = strtod(nptr, &ep);
 703     return check_strtox_error(nptr, ep, endptr, false, errno);
 704 }
 705
 706 /**
 707  * Convert string @nptr to a finite double.
 708  *
 709  * Works like qemu_strtod(), except that "NaN" and "inf" are rejected
 710  * with -EINVAL and no conversion is performed.
 711  */
 712 int qemu_strtod_finite(const char *nptr, const char **endptr, double *result)
 713 {
 714     double tmp;
 715     int ret;
 716
 717     ret = qemu_strtod(nptr, endptr, &tmp);
 718     if (!ret && !isfinite(tmp)) {
 719         if (endptr) {
 720             *endptr = nptr;
 721         }
 722         ret = -EINVAL;
 723     }
 724
 725     if (ret != -EINVAL) {
 726         *result = tmp;
 727     }
 728     return ret;
 729 }
 730
 731 /**
 732  * Searches for the first occurrence of 'c' in 's', and returns a pointer
 733  * to the trailing null byte if none was found.
 734  */
 735 #ifndef HAVE_STRCHRNUL
 736 const char *qemu_strchrnul(const char *s, int c)
 737 {
 738     const char *e = strchr(s, c);
 739     if (!e) {
 740         e = s + strlen(s);
 741     }
 742     return e;
 743 }
 744 #endif
 745
 746 /**
 747  * parse_uint:
 748  *
 749  * @s: String to parse
 750  * @value: Destination for parsed integer value
 751  * @endptr: Destination for pointer to first character not consumed
 752  * @base: integer base, between 2 and 36 inclusive, or 0
 753  *
 754  * Parse unsigned integer
 755  *
 756  * Parsed syntax is like strtoull()'s: arbitrary whitespace, a single optional
 757  * '+' or '-', an optional "0x" if @base is 0 or 16, one or more digits.
 758  *
 759  * If @s is null, or @base is invalid, or @s doesn't start with an
 760  * integer in the syntax above, set *@value to 0, *@endptr to @s, and
 761  * return -EINVAL.
 762  *
 763  * Set *@endptr to point right beyond the parsed integer (even if the integer
 764  * overflows or is negative, all digits will be parsed and *@endptr will
 765  * point right beyond them).
 766  *
 767  * If the integer is negative, set *@value to 0, and return -ERANGE.
 768  *
 769  * If the integer overflows unsigned long long, set *@value to
 770  * ULLONG_MAX, and return -ERANGE.
 771  *
 772  * Else, set *@value to the parsed integer, and return 0.
 773  */
 774 int parse_uint(const char *s, unsigned long long *value, char **endptr,
 775                int base)
 776 {
 777     int r = 0;
 778     char *endp = (char *)s;
 779     unsigned long long val = 0;
 780
 781     assert((unsigned) base <= 36 && base != 1);
 782     if (!s) {
 783         r = -EINVAL;
 784         goto out;
 785     }
 786
 787     errno = 0;
 788     val = strtoull(s, &endp, base);
 789     if (errno) {
 790         r = -errno;
 791         goto out;
 792     }
 793
 794     if (endp == s) {
 795         r = -EINVAL;
 796         goto out;
 797     }
 798
 799     /* make sure we reject negative numbers: */
 800     while (qemu_isspace(*s)) {
 801         s++;
 802     }
 803     if (*s == '-') {
 804         val = 0;
 805         r = -ERANGE;
 806         goto out;
 807     }
 808
 809 out:
 810     *value = val;
 811     *endptr = endp;
 812     return r;
 813 }
 814
 815 /**
 816  * parse_uint_full:
 817  *
 818  * @s: String to parse
 819  * @value: Destination for parsed integer value
 820  * @base: integer base, between 2 and 36 inclusive, or 0
 821  *
 822  * Parse unsigned integer from entire string
 823  *
 824  * Have the same behavior of parse_uint(), but with an additional check
 825  * for additional data after the parsed number. If extra characters are present
 826  * after the parsed number, the function will return -EINVAL, and *@v will
 827  * be set to 0.
 828  */
 829 int parse_uint_full(const char *s, unsigned long long *value, int base)
 830 {
 831     char *endp;
 832     int r;
 833
 834     r = parse_uint(s, value, &endp, base);
 835     if (r < 0) {
 836         return r;
 837     }
 838     if (*endp) {
 839         *value = 0;
 840         return -EINVAL;
 841     }
 842
 843     return 0;
 844 }
 845
 846 int qemu_parse_fd(const char *param)
 847 {
 848     long fd;
 849     char *endptr;
 850
 851     errno = 0;
 852     fd = strtol(param, &endptr, 10);
 853     if (param == endptr /* no conversion performed */                    ||
 854         errno != 0      /* not representable as long; possibly others */ ||
 855         *endptr != '\0' /* final string not empty */                     ||
 856         fd < 0          /* invalid as file descriptor */                 ||
 857         fd > INT_MAX    /* not representable as int */) {
 858         return -1;
 859     }
 860     return fd;
 861 }
 862
 863 /*
 864  * Implementation of  ULEB128 (http://en.wikipedia.org/wiki/LEB128)
 865  * Input is limited to 14-bit numbers
 866  */
 867 int uleb128_encode_small(uint8_t *out, uint32_t n)
 868 {
 869     g_assert(n <= 0x3fff);
 870     if (n < 0x80) {
 871         *out = n;
 872         return 1;
 873     } else {
 874         *out++ = (n & 0x7f) | 0x80;
 875         *out = n >> 7;
 876         return 2;
 877     }
 878 }
 879
 880 int uleb128_decode_small(const uint8_t *in, uint32_t *n)
 881 {
 882     if (!(*in & 0x80)) {
 883         *n = *in;
 884         return 1;
 885     } else {
 886         *n = *in++ & 0x7f;
 887         /* we exceed 14 bit number */
 888         if (*in & 0x80) {
 889             return -1;
 890         }
 891         *n |= *in << 7;
 892         return 2;
 893     }
 894 }
 895
 896 /*
 897  * helper to parse debug environment variables
 898  */
 899 int parse_debug_env(const char *name, int max, int initial)
 900 {
 901     char *debug_env = getenv(name);
 902     char *inv = NULL;
 903     long debug;
 904
 905     if (!debug_env) {
 906         return initial;
 907     }
 908     errno = 0;
 909     debug = strtol(debug_env, &inv, 10);
 910     if (inv == debug_env) {
 911         return initial;
 912     }
 913     if (debug < 0 || debug > max || errno != 0) {
 914         warn_report("%s not in [0, %d]", name, max);
 915         return initial;
 916     }
 917     return debug;
 918 }
 919
 920 /*
 921  * Return human readable string for size @val.
 922  * @val can be anything that uint64_t allows (no more than "16 EiB").
 923  * Use IEC binary units like KiB, MiB, and so forth.
 924  * Caller is responsible for passing it to g_free().
 925  */
 926 char *size_to_str(uint64_t val)
 927 {
 928     static const char *suffixes[] = { "", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei" };
 929     uint64_t div;
 930     int i;
 931
 932     /*
 933      * The exponent (returned in i) minus one gives us
 934      * floor(log2(val * 1024 / 1000).  The correction makes us
 935      * switch to the higher power when the integer part is >= 1000.
 936      * (see e41b509d68afb1f for more info)
 937      */
 938     frexp(val / (1000.0 / 1024.0), &i);
 939     i = (i - 1) / 10;
 940     div = 1ULL << (i * 10);
 941
 942     return g_strdup_printf("%0.3g %sB", (double)val / div, suffixes[i]);
 943 }
 944
 945 char *freq_to_str(uint64_t freq_hz)
 946 {
 947     static const char *const suffixes[] = { "", "K", "M", "G", "T", "P", "E" };
 948     double freq = freq_hz;
 949     size_t idx = 0;
 950
 951     while (freq >= 1000.0) {
 952         freq /= 1000.0;
 953         idx++;
 954     }
 955     assert(idx < ARRAY_SIZE(suffixes));
 956
 957     return g_strdup_printf("%0.3g %sHz", freq, suffixes[idx]);
 958 }
 959
 960 int qemu_pstrcmp0(const char **str1, const char **str2)
 961 {
 962     return g_strcmp0(*str1, *str2);
 963 }
 964
 965 static inline bool starts_with_prefix(const char *dir)
 966 {
 967     size_t prefix_len = strlen(CONFIG_PREFIX);
 968     return !memcmp(dir, CONFIG_PREFIX, prefix_len) &&
 969         (!dir[prefix_len] || G_IS_DIR_SEPARATOR(dir[prefix_len]));
 970 }
 971
 972 /* Return the next path component in dir, and store its length in *p_len.  */
 973 static inline const char *next_component(const char *dir, int *p_len)
 974 {
 975     int len;
 976     while ((*dir && G_IS_DIR_SEPARATOR(*dir)) ||
 977            (*dir == '.' && (G_IS_DIR_SEPARATOR(dir[1]) || dir[1] == '\0'))) {
 978         dir++;
 979     }
 980     len = 0;
 981     while (dir[len] && !G_IS_DIR_SEPARATOR(dir[len])) {
 982         len++;
 983     }
 984     *p_len = len;
 985     return dir;
 986 }
 987
 988 char *get_relocated_path(const char *dir)
 989 {
 990     size_t prefix_len = strlen(CONFIG_PREFIX);
 991     const char *bindir = CONFIG_BINDIR;
 992     const char *exec_dir = qemu_get_exec_dir();
 993     GString *result;
 994     int len_dir, len_bindir;
 995
 996     /* Fail if qemu_init_exec_dir was not called.  */
 997     assert(exec_dir[0]);
 998     if (!starts_with_prefix(dir) || !starts_with_prefix(bindir)) {
 999         return g_strdup(dir);
1000     }
1001
1002     result = g_string_new(exec_dir);
1003
1004     /* Advance over common components.  */
1005     len_dir = len_bindir = prefix_len;
1006     do {
1007         dir += len_dir;
1008         bindir += len_bindir;
1009         dir = next_component(dir, &len_dir);
1010         bindir = next_component(bindir, &len_bindir);
1011     } while (len_dir && len_dir == len_bindir && !memcmp(dir, bindir, len_dir));
1012
1013     /* Ascend from bindir to the common prefix with dir.  */
1014     while (len_bindir) {
1015         bindir += len_bindir;
1016         g_string_append(result, "/..");
1017         bindir = next_component(bindir, &len_bindir);
1018     }
1019
1020     if (*dir) {
1021         assert(G_IS_DIR_SEPARATOR(dir[-1]));
1022         g_string_append(result, dir - 1);
1023     }
1024     return g_string_free(result, false);
1025 }