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