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 #include "qemu/osdep.h"
  25 #include "qemu-common.h"
  26 #include "qemu/host-utils.h"
  27 #include <math.h>
  28
  29 #include "qemu/sockets.h"
  30 #include "qemu/iov.h"
  31 #include "net/net.h"
  32 #include "qemu/cutils.h"
  33
  34 void strpadcpy(char *buf, int buf_size, const char *str, char pad)
  35 {
  36     int len = qemu_strnlen(str, buf_size);
  37     memcpy(buf, str, len);
  38     memset(buf + len, pad, buf_size - len);
  39 }
  40
  41 void pstrcpy(char *buf, int buf_size, const char *str)
  42 {
  43     int c;
  44     char *q = buf;
  45
  46     if (buf_size <= 0)
  47         return;
  48
  49     for(;;) {
  50         c = *str++;
  51         if (c == 0 || q >= buf + buf_size - 1)
  52             break;
  53         *q++ = c;
  54     }
  55     *q = '\0';
  56 }
  57
  58 /* strcat and truncate. */
  59 char *pstrcat(char *buf, int buf_size, const char *s)
  60 {
  61     int len;
  62     len = strlen(buf);
  63     if (len < buf_size)
  64         pstrcpy(buf + len, buf_size - len, s);
  65     return buf;
  66 }
  67
  68 int strstart(const char *str, const char *val, const char **ptr)
  69 {
  70     const char *p, *q;
  71     p = str;
  72     q = val;
  73     while (*q != '\0') {
  74         if (*p != *q)
  75             return 0;
  76         p++;
  77         q++;
  78     }
  79     if (ptr)
  80         *ptr = p;
  81     return 1;
  82 }
  83
  84 int stristart(const char *str, const char *val, const char **ptr)
  85 {
  86     const char *p, *q;
  87     p = str;
  88     q = val;
  89     while (*q != '\0') {
  90         if (qemu_toupper(*p) != qemu_toupper(*q))
  91             return 0;
  92         p++;
  93         q++;
  94     }
  95     if (ptr)
  96         *ptr = p;
  97     return 1;
  98 }
  99
 100 /* XXX: use host strnlen if available ? */
 101 int qemu_strnlen(const char *s, int max_len)
 102 {
 103     int i;
 104
 105     for(i = 0; i < max_len; i++) {
 106         if (s[i] == '\0') {
 107             break;
 108         }
 109     }
 110     return i;
 111 }
 112
 113 char *qemu_strsep(char **input, const char *delim)
 114 {
 115     char *result = *input;
 116     if (result != NULL) {
 117         char *p;
 118
 119         for (p = result; *p != '\0'; p++) {
 120             if (strchr(delim, *p)) {
 121                 break;
 122             }
 123         }
 124         if (*p == '\0') {
 125             *input = NULL;
 126         } else {
 127             *p = '\0';
 128             *input = p + 1;
 129         }
 130     }
 131     return result;
 132 }
 133
 134 time_t mktimegm(struct tm *tm)
 135 {
 136     time_t t;
 137     int y = tm->tm_year + 1900, m = tm->tm_mon + 1, d = tm->tm_mday;
 138     if (m < 3) {
 139         m += 12;
 140         y--;
 141     }
 142     t = 86400ULL * (d + (153 * m - 457) / 5 + 365 * y + y / 4 - y / 100 +
 143                  y / 400 - 719469);
 144     t += 3600 * tm->tm_hour + 60 * tm->tm_min + tm->tm_sec;
 145     return t;
 146 }
 147
 148 /*
 149  * Make sure data goes on disk, but if possible do not bother to
 150  * write out the inode just for timestamp updates.
 151  *
 152  * Unfortunately even in 2009 many operating systems do not support
 153  * fdatasync and have to fall back to fsync.
 154  */
 155 int qemu_fdatasync(int fd)
 156 {
 157 #ifdef CONFIG_FDATASYNC
 158     return fdatasync(fd);
 159 #elif defined(_WIN64)
 160     /* TODO: Implement fsync for w64, too. */
 161     return NOERROR;
 162 #else
 163     return fsync(fd);
 164 #endif
 165 }
 166
 167 /* vector definitions */
 168 #ifdef __ALTIVEC__
 169 #include <altivec.h>
 170 /* The altivec.h header says we're allowed to undef these for
 171  * C++ compatibility.  Here we don't care about C++, but we
 172  * undef them anyway to avoid namespace pollution.
 173  */
 174 #undef vector
 175 #undef pixel
 176 #undef bool
 177 #define VECTYPE        __vector unsigned char
 178 #define SPLAT(p)       vec_splat(vec_ld(0, p), 0)
 179 #define ALL_EQ(v1, v2) vec_all_eq(v1, v2)
 180 #define VEC_OR(v1, v2) ((v1) | (v2))
 181 /* altivec.h may redefine the bool macro as vector type.
 182  * Reset it to POSIX semantics. */
 183 #define bool _Bool
 184 #elif defined __SSE2__
 185 #include <emmintrin.h>
 186 #define VECTYPE        __m128i
 187 #define SPLAT(p)       _mm_set1_epi8(*(p))
 188 #define ALL_EQ(v1, v2) (_mm_movemask_epi8(_mm_cmpeq_epi8(v1, v2)) == 0xFFFF)
 189 #define VEC_OR(v1, v2) (_mm_or_si128(v1, v2))
 190 #else
 191 #define VECTYPE        unsigned long
 192 #define SPLAT(p)       (*(p) * (~0UL / 255))
 193 #define ALL_EQ(v1, v2) ((v1) == (v2))
 194 #define VEC_OR(v1, v2) ((v1) | (v2))
 195 #endif
 196
 197 #define BUFFER_FIND_NONZERO_OFFSET_UNROLL_FACTOR 8
 198
 199 static bool
 200 can_use_buffer_find_nonzero_offset_inner(const void *buf, size_t len)
 201 {
 202     return (len % (BUFFER_FIND_NONZERO_OFFSET_UNROLL_FACTOR
 203                    * sizeof(VECTYPE)) == 0
 204             && ((uintptr_t) buf) % sizeof(VECTYPE) == 0);
 205 }
 206
 207 /*
 208  * Searches for an area with non-zero content in a buffer
 209  *
 210  * Attention! The len must be a multiple of
 211  * BUFFER_FIND_NONZERO_OFFSET_UNROLL_FACTOR * sizeof(VECTYPE)
 212  * and addr must be a multiple of sizeof(VECTYPE) due to
 213  * restriction of optimizations in this function.
 214  *
 215  * can_use_buffer_find_nonzero_offset_inner() can be used to
 216  * check these requirements.
 217  *
 218  * The return value is the offset of the non-zero area rounded
 219  * down to a multiple of sizeof(VECTYPE) for the first
 220  * BUFFER_FIND_NONZERO_OFFSET_UNROLL_FACTOR chunks and down to
 221  * BUFFER_FIND_NONZERO_OFFSET_UNROLL_FACTOR * sizeof(VECTYPE)
 222  * afterwards.
 223  *
 224  * If the buffer is all zero the return value is equal to len.
 225  */
 226
 227 static size_t buffer_find_nonzero_offset_inner(const void *buf, size_t len)
 228 {
 229     const VECTYPE *p = buf;
 230     const VECTYPE zero = (VECTYPE){0};
 231     size_t i;
 232
 233     assert(can_use_buffer_find_nonzero_offset_inner(buf, len));
 234
 235     if (!len) {
 236         return 0;
 237     }
 238
 239     for (i = 0; i < BUFFER_FIND_NONZERO_OFFSET_UNROLL_FACTOR; i++) {
 240         if (!ALL_EQ(p[i], zero)) {
 241             return i * sizeof(VECTYPE);
 242         }
 243     }
 244
 245     for (i = BUFFER_FIND_NONZERO_OFFSET_UNROLL_FACTOR;
 246          i < len / sizeof(VECTYPE);
 247          i += BUFFER_FIND_NONZERO_OFFSET_UNROLL_FACTOR) {
 248         VECTYPE tmp0 = VEC_OR(p[i + 0], p[i + 1]);
 249         VECTYPE tmp1 = VEC_OR(p[i + 2], p[i + 3]);
 250         VECTYPE tmp2 = VEC_OR(p[i + 4], p[i + 5]);
 251         VECTYPE tmp3 = VEC_OR(p[i + 6], p[i + 7]);
 252         VECTYPE tmp01 = VEC_OR(tmp0, tmp1);
 253         VECTYPE tmp23 = VEC_OR(tmp2, tmp3);
 254         if (!ALL_EQ(VEC_OR(tmp01, tmp23), zero)) {
 255             break;
 256         }
 257     }
 258
 259     return i * sizeof(VECTYPE);
 260 }
 261
 262 /*
 263  * GCC before version 4.9 has a bug which will cause the target
 264  * attribute work incorrectly and failed to compile in some case,
 265  * restrict the gcc version to 4.9+ to prevent the failure.
 266  */
 267
 268 #if defined CONFIG_AVX2_OPT && QEMU_GNUC_PREREQ(4, 9)
 269 #pragma GCC push_options
 270 #pragma GCC target("avx2")
 271 #include <cpuid.h>
 272 #include <immintrin.h>
 273
 274 #define AVX2_VECTYPE        __m256i
 275 #define AVX2_SPLAT(p)       _mm256_set1_epi8(*(p))
 276 #define AVX2_ALL_EQ(v1, v2) \
 277     (_mm256_movemask_epi8(_mm256_cmpeq_epi8(v1, v2)) == 0xFFFFFFFF)
 278 #define AVX2_VEC_OR(v1, v2) (_mm256_or_si256(v1, v2))
 279
 280 static bool
 281 can_use_buffer_find_nonzero_offset_avx2(const void *buf, size_t len)
 282 {
 283     return (len % (BUFFER_FIND_NONZERO_OFFSET_UNROLL_FACTOR
 284                    * sizeof(AVX2_VECTYPE)) == 0
 285             && ((uintptr_t) buf) % sizeof(AVX2_VECTYPE) == 0);
 286 }
 287
 288 static size_t buffer_find_nonzero_offset_avx2(const void *buf, size_t len)
 289 {
 290     const AVX2_VECTYPE *p = buf;
 291     const AVX2_VECTYPE zero = (AVX2_VECTYPE){0};
 292     size_t i;
 293
 294     assert(can_use_buffer_find_nonzero_offset_avx2(buf, len));
 295
 296     if (!len) {
 297         return 0;
 298     }
 299
 300     for (i = 0; i < BUFFER_FIND_NONZERO_OFFSET_UNROLL_FACTOR; i++) {
 301         if (!AVX2_ALL_EQ(p[i], zero)) {
 302             return i * sizeof(AVX2_VECTYPE);
 303         }
 304     }
 305
 306     for (i = BUFFER_FIND_NONZERO_OFFSET_UNROLL_FACTOR;
 307          i < len / sizeof(AVX2_VECTYPE);
 308          i += BUFFER_FIND_NONZERO_OFFSET_UNROLL_FACTOR) {
 309         AVX2_VECTYPE tmp0 = AVX2_VEC_OR(p[i + 0], p[i + 1]);
 310         AVX2_VECTYPE tmp1 = AVX2_VEC_OR(p[i + 2], p[i + 3]);
 311         AVX2_VECTYPE tmp2 = AVX2_VEC_OR(p[i + 4], p[i + 5]);
 312         AVX2_VECTYPE tmp3 = AVX2_VEC_OR(p[i + 6], p[i + 7]);
 313         AVX2_VECTYPE tmp01 = AVX2_VEC_OR(tmp0, tmp1);
 314         AVX2_VECTYPE tmp23 = AVX2_VEC_OR(tmp2, tmp3);
 315         if (!AVX2_ALL_EQ(AVX2_VEC_OR(tmp01, tmp23), zero)) {
 316             break;
 317         }
 318     }
 319
 320     return i * sizeof(AVX2_VECTYPE);
 321 }
 322
 323 static bool avx2_support(void)
 324 {
 325     int a, b, c, d;
 326
 327     if (__get_cpuid_max(0, NULL) < 7) {
 328         return false;
 329     }
 330
 331     __cpuid_count(7, 0, a, b, c, d);
 332
 333     return b & bit_AVX2;
 334 }
 335
 336 bool can_use_buffer_find_nonzero_offset(const void *buf, size_t len) \
 337          __attribute__ ((ifunc("can_use_buffer_find_nonzero_offset_ifunc")));
 338 size_t buffer_find_nonzero_offset(const void *buf, size_t len) \
 339          __attribute__ ((ifunc("buffer_find_nonzero_offset_ifunc")));
 340
 341 static void *buffer_find_nonzero_offset_ifunc(void)
 342 {
 343     typeof(buffer_find_nonzero_offset) *func = (avx2_support()) ?
 344         buffer_find_nonzero_offset_avx2 : buffer_find_nonzero_offset_inner;
 345
 346     return func;
 347 }
 348
 349 static void *can_use_buffer_find_nonzero_offset_ifunc(void)
 350 {
 351     typeof(can_use_buffer_find_nonzero_offset) *func = (avx2_support()) ?
 352         can_use_buffer_find_nonzero_offset_avx2 :
 353         can_use_buffer_find_nonzero_offset_inner;
 354
 355     return func;
 356 }
 357 #pragma GCC pop_options
 358 #else
 359 bool can_use_buffer_find_nonzero_offset(const void *buf, size_t len)
 360 {
 361     return can_use_buffer_find_nonzero_offset_inner(buf, len);
 362 }
 363
 364 size_t buffer_find_nonzero_offset(const void *buf, size_t len)
 365 {
 366     return buffer_find_nonzero_offset_inner(buf, len);
 367 }
 368 #endif
 369
 370 /*
 371  * Checks if a buffer is all zeroes
 372  *
 373  * Attention! The len must be a multiple of 4 * sizeof(long) due to
 374  * restriction of optimizations in this function.
 375  */
 376 bool buffer_is_zero(const void *buf, size_t len)
 377 {
 378     /*
 379      * Use long as the biggest available internal data type that fits into the
 380      * CPU register and unroll the loop to smooth out the effect of memory
 381      * latency.
 382      */
 383
 384     size_t i;
 385     long d0, d1, d2, d3;
 386     const long * const data = buf;
 387
 388     /* use vector optimized zero check if possible */
 389     if (can_use_buffer_find_nonzero_offset(buf, len)) {
 390         return buffer_find_nonzero_offset(buf, len) == len;
 391     }
 392
 393     assert(len % (4 * sizeof(long)) == 0);
 394     len /= sizeof(long);
 395
 396     for (i = 0; i < len; i += 4) {
 397         d0 = data[i + 0];
 398         d1 = data[i + 1];
 399         d2 = data[i + 2];
 400         d3 = data[i + 3];
 401
 402         if (d0 || d1 || d2 || d3) {
 403             return false;
 404         }
 405     }
 406
 407     return true;
 408 }
 409
 410 #ifndef _WIN32
 411 /* Sets a specific flag */
 412 int fcntl_setfl(int fd, int flag)
 413 {
 414     int flags;
 415
 416     flags = fcntl(fd, F_GETFL);
 417     if (flags == -1)
 418         return -errno;
 419
 420     if (fcntl(fd, F_SETFL, flags | flag) == -1)
 421         return -errno;
 422
 423     return 0;
 424 }
 425 #endif
 426
 427 static int64_t suffix_mul(char suffix, int64_t unit)
 428 {
 429     switch (qemu_toupper(suffix)) {
 430     case QEMU_STRTOSZ_DEFSUFFIX_B:
 431         return 1;
 432     case QEMU_STRTOSZ_DEFSUFFIX_KB:
 433         return unit;
 434     case QEMU_STRTOSZ_DEFSUFFIX_MB:
 435         return unit * unit;
 436     case QEMU_STRTOSZ_DEFSUFFIX_GB:
 437         return unit * unit * unit;
 438     case QEMU_STRTOSZ_DEFSUFFIX_TB:
 439         return unit * unit * unit * unit;
 440     case QEMU_STRTOSZ_DEFSUFFIX_PB:
 441         return unit * unit * unit * unit * unit;
 442     case QEMU_STRTOSZ_DEFSUFFIX_EB:
 443         return unit * unit * unit * unit * unit * unit;
 444     }
 445     return -1;
 446 }
 447
 448 /*
 449  * Convert string to bytes, allowing either B/b for bytes, K/k for KB,
 450  * M/m for MB, G/g for GB or T/t for TB. End pointer will be returned
 451  * in *end, if not NULL. Return -ERANGE on overflow, Return -EINVAL on
 452  * other error.
 453  */
 454 int64_t qemu_strtosz_suffix_unit(const char *nptr, char **end,
 455                             const char default_suffix, int64_t unit)
 456 {
 457     int64_t retval = -EINVAL;
 458     char *endptr;
 459     unsigned char c;
 460     int mul_required = 0;
 461     double val, mul, integral, fraction;
 462
 463     errno = 0;
 464     val = strtod(nptr, &endptr);
 465     if (isnan(val) || endptr == nptr || errno != 0) {
 466         goto fail;
 467     }
 468     fraction = modf(val, &integral);
 469     if (fraction != 0) {
 470         mul_required = 1;
 471     }
 472     c = *endptr;
 473     mul = suffix_mul(c, unit);
 474     if (mul >= 0) {
 475         endptr++;
 476     } else {
 477         mul = suffix_mul(default_suffix, unit);
 478         assert(mul >= 0);
 479     }
 480     if (mul == 1 && mul_required) {
 481         goto fail;
 482     }
 483     if ((val * mul >= INT64_MAX) || val < 0) {
 484         retval = -ERANGE;
 485         goto fail;
 486     }
 487     retval = val * mul;
 488
 489 fail:
 490     if (end) {
 491         *end = endptr;
 492     }
 493
 494     return retval;
 495 }
 496
 497 int64_t qemu_strtosz_suffix(const char *nptr, char **end,
 498                             const char default_suffix)
 499 {
 500     return qemu_strtosz_suffix_unit(nptr, end, default_suffix, 1024);
 501 }
 502
 503 int64_t qemu_strtosz(const char *nptr, char **end)
 504 {
 505     return qemu_strtosz_suffix(nptr, end, QEMU_STRTOSZ_DEFSUFFIX_MB);
 506 }
 507
 508 /**
 509  * Helper function for qemu_strto*l() functions.
 510  */
 511 static int check_strtox_error(const char *p, char *endptr, const char **next,
 512                               int err)
 513 {
 514     /* If no conversion was performed, prefer BSD behavior over glibc
 515      * behavior.
 516      */
 517     if (err == 0 && endptr == p) {
 518         err = EINVAL;
 519     }
 520     if (!next && *endptr) {
 521         return -EINVAL;
 522     }
 523     if (next) {
 524         *next = endptr;
 525     }
 526     return -err;
 527 }
 528
 529 /**
 530  * QEMU wrappers for strtol(), strtoll(), strtoul(), strotull() C functions.
 531  *
 532  * Convert ASCII string @nptr to a long integer value
 533  * from the given @base. Parameters @nptr, @endptr, @base
 534  * follows same semantics as strtol() C function.
 535  *
 536  * Unlike from strtol() function, if @endptr is not NULL, this
 537  * function will return -EINVAL whenever it cannot fully convert
 538  * the string in @nptr with given @base to a long. This function returns
 539  * the result of the conversion only through the @result parameter.
 540  *
 541  * If NULL is passed in @endptr, then the whole string in @ntpr
 542  * is a number otherwise it returns -EINVAL.
 543  *
 544  * RETURN VALUE
 545  * Unlike from strtol() function, this wrapper returns either
 546  * -EINVAL or the errno set by strtol() function (e.g -ERANGE).
 547  * If the conversion overflows, -ERANGE is returned, and @result
 548  * is set to the max value of the desired type
 549  * (e.g. LONG_MAX, LLONG_MAX, ULONG_MAX, ULLONG_MAX). If the case
 550  * of underflow, -ERANGE is returned, and @result is set to the min
 551  * value of the desired type. For strtol(), strtoll(), @result is set to
 552  * LONG_MIN, LLONG_MIN, respectively, and for strtoul(), strtoull() it
 553  * is set to 0.
 554  */
 555 int qemu_strtol(const char *nptr, const char **endptr, int base,
 556                 long *result)
 557 {
 558     char *p;
 559     int err = 0;
 560     if (!nptr) {
 561         if (endptr) {
 562             *endptr = nptr;
 563         }
 564         err = -EINVAL;
 565     } else {
 566         errno = 0;
 567         *result = strtol(nptr, &p, base);
 568         err = check_strtox_error(nptr, p, endptr, errno);
 569     }
 570     return err;
 571 }
 572
 573 /**
 574  * Converts ASCII string to an unsigned long integer.
 575  *
 576  * If string contains a negative number, value will be converted to
 577  * the unsigned representation of the signed value, unless the original
 578  * (nonnegated) value would overflow, in this case, it will set @result
 579  * to ULONG_MAX, and return ERANGE.
 580  *
 581  * The same behavior holds, for qemu_strtoull() but sets @result to
 582  * ULLONG_MAX instead of ULONG_MAX.
 583  *
 584  * See qemu_strtol() documentation for more info.
 585  */
 586 int qemu_strtoul(const char *nptr, const char **endptr, int base,
 587                  unsigned long *result)
 588 {
 589     char *p;
 590     int err = 0;
 591     if (!nptr) {
 592         if (endptr) {
 593             *endptr = nptr;
 594         }
 595         err = -EINVAL;
 596     } else {
 597         errno = 0;
 598         *result = strtoul(nptr, &p, base);
 599         /* Windows returns 1 for negative out-of-range values.  */
 600         if (errno == ERANGE) {
 601             *result = -1;
 602         }
 603         err = check_strtox_error(nptr, p, endptr, errno);
 604     }
 605     return err;
 606 }
 607
 608 /**
 609  * Converts ASCII string to a long long integer.
 610  *
 611  * See qemu_strtol() documentation for more info.
 612  */
 613 int qemu_strtoll(const char *nptr, const char **endptr, int base,
 614                  int64_t *result)
 615 {
 616     char *p;
 617     int err = 0;
 618     if (!nptr) {
 619         if (endptr) {
 620             *endptr = nptr;
 621         }
 622         err = -EINVAL;
 623     } else {
 624         errno = 0;
 625         *result = strtoll(nptr, &p, base);
 626         err = check_strtox_error(nptr, p, endptr, errno);
 627     }
 628     return err;
 629 }
 630
 631 /**
 632  * Converts ASCII string to an unsigned long long integer.
 633  *
 634  * See qemu_strtol() documentation for more info.
 635  */
 636 int qemu_strtoull(const char *nptr, const char **endptr, int base,
 637                   uint64_t *result)
 638 {
 639     char *p;
 640     int err = 0;
 641     if (!nptr) {
 642         if (endptr) {
 643             *endptr = nptr;
 644         }
 645         err = -EINVAL;
 646     } else {
 647         errno = 0;
 648         *result = strtoull(nptr, &p, base);
 649         /* Windows returns 1 for negative out-of-range values.  */
 650         if (errno == ERANGE) {
 651             *result = -1;
 652         }
 653         err = check_strtox_error(nptr, p, endptr, errno);
 654     }
 655     return err;
 656 }
 657
 658 /**
 659  * parse_uint:
 660  *
 661  * @s: String to parse
 662  * @value: Destination for parsed integer value
 663  * @endptr: Destination for pointer to first character not consumed
 664  * @base: integer base, between 2 and 36 inclusive, or 0
 665  *
 666  * Parse unsigned integer
 667  *
 668  * Parsed syntax is like strtoull()'s: arbitrary whitespace, a single optional
 669  * '+' or '-', an optional "0x" if @base is 0 or 16, one or more digits.
 670  *
 671  * If @s is null, or @base is invalid, or @s doesn't start with an
 672  * integer in the syntax above, set *@value to 0, *@endptr to @s, and
 673  * return -EINVAL.
 674  *
 675  * Set *@endptr to point right beyond the parsed integer (even if the integer
 676  * overflows or is negative, all digits will be parsed and *@endptr will
 677  * point right beyond them).
 678  *
 679  * If the integer is negative, set *@value to 0, and return -ERANGE.
 680  *
 681  * If the integer overflows unsigned long long, set *@value to
 682  * ULLONG_MAX, and return -ERANGE.
 683  *
 684  * Else, set *@value to the parsed integer, and return 0.
 685  */
 686 int parse_uint(const char *s, unsigned long long *value, char **endptr,
 687                int base)
 688 {
 689     int r = 0;
 690     char *endp = (char *)s;
 691     unsigned long long val = 0;
 692
 693     if (!s) {
 694         r = -EINVAL;
 695         goto out;
 696     }
 697
 698     errno = 0;
 699     val = strtoull(s, &endp, base);
 700     if (errno) {
 701         r = -errno;
 702         goto out;
 703     }
 704
 705     if (endp == s) {
 706         r = -EINVAL;
 707         goto out;
 708     }
 709
 710     /* make sure we reject negative numbers: */
 711     while (isspace((unsigned char)*s)) {
 712         s++;
 713     }
 714     if (*s == '-') {
 715         val = 0;
 716         r = -ERANGE;
 717         goto out;
 718     }
 719
 720 out:
 721     *value = val;
 722     *endptr = endp;
 723     return r;
 724 }
 725
 726 /**
 727  * parse_uint_full:
 728  *
 729  * @s: String to parse
 730  * @value: Destination for parsed integer value
 731  * @base: integer base, between 2 and 36 inclusive, or 0
 732  *
 733  * Parse unsigned integer from entire string
 734  *
 735  * Have the same behavior of parse_uint(), but with an additional check
 736  * for additional data after the parsed number. If extra characters are present
 737  * after the parsed number, the function will return -EINVAL, and *@v will
 738  * be set to 0.
 739  */
 740 int parse_uint_full(const char *s, unsigned long long *value, int base)
 741 {
 742     char *endp;
 743     int r;
 744
 745     r = parse_uint(s, value, &endp, base);
 746     if (r < 0) {
 747         return r;
 748     }
 749     if (*endp) {
 750         *value = 0;
 751         return -EINVAL;
 752     }
 753
 754     return 0;
 755 }
 756
 757 int qemu_parse_fd(const char *param)
 758 {
 759     long fd;
 760     char *endptr;
 761
 762     errno = 0;
 763     fd = strtol(param, &endptr, 10);
 764     if (param == endptr /* no conversion performed */                    ||
 765         errno != 0      /* not representable as long; possibly others */ ||
 766         *endptr != '\0' /* final string not empty */                     ||
 767         fd < 0          /* invalid as file descriptor */                 ||
 768         fd > INT_MAX    /* not representable as int */) {
 769         return -1;
 770     }
 771     return fd;
 772 }
 773
 774 /*
 775  * Implementation of  ULEB128 (http://en.wikipedia.org/wiki/LEB128)
 776  * Input is limited to 14-bit numbers
 777  */
 778 int uleb128_encode_small(uint8_t *out, uint32_t n)
 779 {
 780     g_assert(n <= 0x3fff);
 781     if (n < 0x80) {
 782         *out++ = n;
 783         return 1;
 784     } else {
 785         *out++ = (n & 0x7f) | 0x80;
 786         *out++ = n >> 7;
 787         return 2;
 788     }
 789 }
 790
 791 int uleb128_decode_small(const uint8_t *in, uint32_t *n)
 792 {
 793     if (!(*in & 0x80)) {
 794         *n = *in++;
 795         return 1;
 796     } else {
 797         *n = *in++ & 0x7f;
 798         /* we exceed 14 bit number */
 799         if (*in & 0x80) {
 800             return -1;
 801         }
 802         *n |= *in++ << 7;
 803         return 2;
 804     }
 805 }
 806
 807 /*
 808  * helper to parse debug environment variables
 809  */
 810 int parse_debug_env(const char *name, int max, int initial)
 811 {
 812     char *debug_env = getenv(name);
 813     char *inv = NULL;
 814     long debug;
 815
 816     if (!debug_env) {
 817         return initial;
 818     }
 819     errno = 0;
 820     debug = strtol(debug_env, &inv, 10);
 821     if (inv == debug_env) {
 822         return initial;
 823     }
 824     if (debug < 0 || debug > max || errno != 0) {
 825         fprintf(stderr, "warning: %s not in [0, %d]", name, max);
 826         return initial;
 827     }
 828     return debug;
 829 }
 830
 831 /*
 832  * Helper to print ethernet mac address
 833  */
 834 const char *qemu_ether_ntoa(const MACAddr *mac)
 835 {
 836     static char ret[18];
 837
 838     snprintf(ret, sizeof(ret), "%02x:%02x:%02x:%02x:%02x:%02x",
 839              mac->a[0], mac->a[1], mac->a[2], mac->a[3], mac->a[4], mac->a[5]);
 840
 841     return ret;
 842 }