qemu/util/cutils.c
<<
>>
Prefs
   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#include "qemu/error-report.h"
  34
  35void strpadcpy(char *buf, int buf_size, const char *str, char pad)
  36{
  37    int len = qemu_strnlen(str, buf_size);
  38    memcpy(buf, str, len);
  39    memset(buf + len, pad, buf_size - len);
  40}
  41
  42void pstrcpy(char *buf, int buf_size, const char *str)
  43{
  44    int c;
  45    char *q = buf;
  46
  47    if (buf_size <= 0)
  48        return;
  49
  50    for(;;) {
  51        c = *str++;
  52        if (c == 0 || q >= buf + buf_size - 1)
  53            break;
  54        *q++ = c;
  55    }
  56    *q = '\0';
  57}
  58
  59/* strcat and truncate. */
  60char *pstrcat(char *buf, int buf_size, const char *s)
  61{
  62    int len;
  63    len = strlen(buf);
  64    if (len < buf_size)
  65        pstrcpy(buf + len, buf_size - len, s);
  66    return buf;
  67}
  68
  69int strstart(const char *str, const char *val, const char **ptr)
  70{
  71    const char *p, *q;
  72    p = str;
  73    q = val;
  74    while (*q != '\0') {
  75        if (*p != *q)
  76            return 0;
  77        p++;
  78        q++;
  79    }
  80    if (ptr)
  81        *ptr = p;
  82    return 1;
  83}
  84
  85int stristart(const char *str, const char *val, const char **ptr)
  86{
  87    const char *p, *q;
  88    p = str;
  89    q = val;
  90    while (*q != '\0') {
  91        if (qemu_toupper(*p) != qemu_toupper(*q))
  92            return 0;
  93        p++;
  94        q++;
  95    }
  96    if (ptr)
  97        *ptr = p;
  98    return 1;
  99}
 100
 101/* XXX: use host strnlen if available ? */
 102int qemu_strnlen(const char *s, int max_len)
 103{
 104    int i;
 105
 106    for(i = 0; i < max_len; i++) {
 107        if (s[i] == '\0') {
 108            break;
 109        }
 110    }
 111    return i;
 112}
 113
 114char *qemu_strsep(char **input, const char *delim)
 115{
 116    char *result = *input;
 117    if (result != NULL) {
 118        char *p;
 119
 120        for (p = result; *p != '\0'; p++) {
 121            if (strchr(delim, *p)) {
 122                break;
 123            }
 124        }
 125        if (*p == '\0') {
 126            *input = NULL;
 127        } else {
 128            *p = '\0';
 129            *input = p + 1;
 130        }
 131    }
 132    return result;
 133}
 134
 135time_t mktimegm(struct tm *tm)
 136{
 137    time_t t;
 138    int y = tm->tm_year + 1900, m = tm->tm_mon + 1, d = tm->tm_mday;
 139    if (m < 3) {
 140        m += 12;
 141        y--;
 142    }
 143    t = 86400ULL * (d + (153 * m - 457) / 5 + 365 * y + y / 4 - y / 100 + 
 144                 y / 400 - 719469);
 145    t += 3600 * tm->tm_hour + 60 * tm->tm_min + tm->tm_sec;
 146    return t;
 147}
 148
 149/*
 150 * Make sure data goes on disk, but if possible do not bother to
 151 * write out the inode just for timestamp updates.
 152 *
 153 * Unfortunately even in 2009 many operating systems do not support
 154 * fdatasync and have to fall back to fsync.
 155 */
 156int qemu_fdatasync(int fd)
 157{
 158#ifdef CONFIG_FDATASYNC
 159    return fdatasync(fd);
 160#else
 161    return fsync(fd);
 162#endif
 163}
 164
 165#ifndef _WIN32
 166/* Sets a specific flag */
 167int fcntl_setfl(int fd, int flag)
 168{
 169    int flags;
 170
 171    flags = fcntl(fd, F_GETFL);
 172    if (flags == -1)
 173        return -errno;
 174
 175    if (fcntl(fd, F_SETFL, flags | flag) == -1)
 176        return -errno;
 177
 178    return 0;
 179}
 180#endif
 181
 182static int64_t suffix_mul(char suffix, int64_t unit)
 183{
 184    switch (qemu_toupper(suffix)) {
 185    case 'B':
 186        return 1;
 187    case 'K':
 188        return unit;
 189    case 'M':
 190        return unit * unit;
 191    case 'G':
 192        return unit * unit * unit;
 193    case 'T':
 194        return unit * unit * unit * unit;
 195    case 'P':
 196        return unit * unit * unit * unit * unit;
 197    case 'E':
 198        return unit * unit * unit * unit * unit * unit;
 199    }
 200    return -1;
 201}
 202
 203/*
 204 * Convert string to bytes, allowing either B/b for bytes, K/k for KB,
 205 * M/m for MB, G/g for GB or T/t for TB. End pointer will be returned
 206 * in *end, if not NULL. Return -ERANGE on overflow, Return -EINVAL on
 207 * other error.
 208 */
 209static int do_strtosz(const char *nptr, char **end,
 210                      const char default_suffix, int64_t unit,
 211                      uint64_t *result)
 212{
 213    int retval;
 214    char *endptr;
 215    unsigned char c;
 216    int mul_required = 0;
 217    double val, mul, integral, fraction;
 218
 219    errno = 0;
 220    val = strtod(nptr, &endptr);
 221    if (isnan(val) || endptr == nptr || errno != 0) {
 222        retval = -EINVAL;
 223        goto out;
 224    }
 225    fraction = modf(val, &integral);
 226    if (fraction != 0) {
 227        mul_required = 1;
 228    }
 229    c = *endptr;
 230    mul = suffix_mul(c, unit);
 231    if (mul >= 0) {
 232        endptr++;
 233    } else {
 234        mul = suffix_mul(default_suffix, unit);
 235        assert(mul >= 0);
 236    }
 237    if (mul == 1 && mul_required) {
 238        retval = -EINVAL;
 239        goto out;
 240    }
 241    /*
 242     * Values >= 0xfffffffffffffc00 overflow uint64_t after their trip
 243     * through double (53 bits of precision).
 244     */
 245    if ((val * mul >= 0xfffffffffffffc00) || val < 0) {
 246        retval = -ERANGE;
 247        goto out;
 248    }
 249    *result = val * mul;
 250    retval = 0;
 251
 252out:
 253    if (end) {
 254        *end = endptr;
 255    } else if (*endptr) {
 256        retval = -EINVAL;
 257    }
 258
 259    return retval;
 260}
 261
 262int qemu_strtosz(const char *nptr, char **end, uint64_t *result)
 263{
 264    return do_strtosz(nptr, end, 'B', 1024, result);
 265}
 266
 267int qemu_strtosz_MiB(const char *nptr, char **end, uint64_t *result)
 268{
 269    return do_strtosz(nptr, end, 'M', 1024, result);
 270}
 271
 272int qemu_strtosz_metric(const char *nptr, char **end, uint64_t *result)
 273{
 274    return do_strtosz(nptr, end, 'B', 1000, result);
 275}
 276
 277/**
 278 * Helper function for error checking after strtol() and the like
 279 */
 280static int check_strtox_error(const char *nptr, char *ep,
 281                              const char **endptr, int libc_errno)
 282{
 283    if (endptr) {
 284        *endptr = ep;
 285    }
 286
 287    /* Turn "no conversion" into an error */
 288    if (libc_errno == 0 && ep == nptr) {
 289        return -EINVAL;
 290    }
 291
 292    /* Fail when we're expected to consume the string, but didn't */
 293    if (!endptr && *ep) {
 294        return -EINVAL;
 295    }
 296
 297    return -libc_errno;
 298}
 299
 300/**
 301 * Convert string @nptr to an integer, and store it in @result.
 302 *
 303 * This is a wrapper around strtol() that is harder to misuse.
 304 * Semantics of @nptr, @endptr, @base match strtol() with differences
 305 * noted below.
 306 *
 307 * @nptr may be null, and no conversion is performed then.
 308 *
 309 * If no conversion is performed, store @nptr in *@endptr and return
 310 * -EINVAL.
 311 *
 312 * If @endptr is null, and the string isn't fully converted, return
 313 * -EINVAL.  This is the case when the pointer that would be stored in
 314 * a non-null @endptr points to a character other than '\0'.
 315 *
 316 * If the conversion overflows @result, store INT_MAX in @result,
 317 * and return -ERANGE.
 318 *
 319 * If the conversion underflows @result, store INT_MIN in @result,
 320 * and return -ERANGE.
 321 *
 322 * Else store the converted value in @result, and return zero.
 323 */
 324int qemu_strtoi(const char *nptr, const char **endptr, int base,
 325                int *result)
 326{
 327    char *ep;
 328    long long lresult;
 329
 330    if (!nptr) {
 331        if (endptr) {
 332            *endptr = nptr;
 333        }
 334        return -EINVAL;
 335    }
 336
 337    errno = 0;
 338    lresult = strtoll(nptr, &ep, base);
 339    if (lresult < INT_MIN) {
 340        *result = INT_MIN;
 341        errno = ERANGE;
 342    } else if (lresult > INT_MAX) {
 343        *result = INT_MAX;
 344        errno = ERANGE;
 345    } else {
 346        *result = lresult;
 347    }
 348    return check_strtox_error(nptr, ep, endptr, errno);
 349}
 350
 351/**
 352 * Convert string @nptr to an unsigned integer, and store it in @result.
 353 *
 354 * This is a wrapper around strtoul() that is harder to misuse.
 355 * Semantics of @nptr, @endptr, @base match strtoul() with differences
 356 * noted below.
 357 *
 358 * @nptr may be null, and no conversion is performed then.
 359 *
 360 * If no conversion is performed, store @nptr in *@endptr and return
 361 * -EINVAL.
 362 *
 363 * If @endptr is null, and the string isn't fully converted, return
 364 * -EINVAL.  This is the case when the pointer that would be stored in
 365 * a non-null @endptr points to a character other than '\0'.
 366 *
 367 * If the conversion overflows @result, store UINT_MAX in @result,
 368 * and return -ERANGE.
 369 *
 370 * Else store the converted value in @result, and return zero.
 371 *
 372 * Note that a number with a leading minus sign gets converted without
 373 * the minus sign, checked for overflow (see above), then negated (in
 374 * @result's type).  This is exactly how strtoul() works.
 375 */
 376int qemu_strtoui(const char *nptr, const char **endptr, int base,
 377                 unsigned int *result)
 378{
 379    char *ep;
 380    long long lresult;
 381
 382    if (!nptr) {
 383        if (endptr) {
 384            *endptr = nptr;
 385        }
 386        return -EINVAL;
 387    }
 388
 389    errno = 0;
 390    lresult = strtoull(nptr, &ep, base);
 391
 392    /* Windows returns 1 for negative out-of-range values.  */
 393    if (errno == ERANGE) {
 394        *result = -1;
 395    } else {
 396        if (lresult > UINT_MAX) {
 397            *result = UINT_MAX;
 398            errno = ERANGE;
 399        } else if (lresult < INT_MIN) {
 400            *result = UINT_MAX;
 401            errno = ERANGE;
 402        } else {
 403            *result = lresult;
 404        }
 405    }
 406    return check_strtox_error(nptr, ep, endptr, errno);
 407}
 408
 409/**
 410 * Convert string @nptr to a long integer, and store it in @result.
 411 *
 412 * This is a wrapper around strtol() that is harder to misuse.
 413 * Semantics of @nptr, @endptr, @base match strtol() with differences
 414 * noted below.
 415 *
 416 * @nptr may be null, and no conversion is performed then.
 417 *
 418 * If no conversion is performed, store @nptr in *@endptr and return
 419 * -EINVAL.
 420 *
 421 * If @endptr is null, and the string isn't fully converted, return
 422 * -EINVAL.  This is the case when the pointer that would be stored in
 423 * a non-null @endptr points to a character other than '\0'.
 424 *
 425 * If the conversion overflows @result, store LONG_MAX in @result,
 426 * and return -ERANGE.
 427 *
 428 * If the conversion underflows @result, store LONG_MIN in @result,
 429 * and return -ERANGE.
 430 *
 431 * Else store the converted value in @result, and return zero.
 432 */
 433int qemu_strtol(const char *nptr, const char **endptr, int base,
 434                long *result)
 435{
 436    char *ep;
 437
 438    if (!nptr) {
 439        if (endptr) {
 440            *endptr = nptr;
 441        }
 442        return -EINVAL;
 443    }
 444
 445    errno = 0;
 446    *result = strtol(nptr, &ep, base);
 447    return check_strtox_error(nptr, ep, endptr, errno);
 448}
 449
 450/**
 451 * Convert string @nptr to an unsigned long, and store it in @result.
 452 *
 453 * This is a wrapper around strtoul() that is harder to misuse.
 454 * Semantics of @nptr, @endptr, @base match strtoul() with differences
 455 * noted below.
 456 *
 457 * @nptr may be null, and no conversion is performed then.
 458 *
 459 * If no conversion is performed, store @nptr in *@endptr and return
 460 * -EINVAL.
 461 *
 462 * If @endptr is null, and the string isn't fully converted, return
 463 * -EINVAL.  This is the case when the pointer that would be stored in
 464 * a non-null @endptr points to a character other than '\0'.
 465 *
 466 * If the conversion overflows @result, store ULONG_MAX in @result,
 467 * and return -ERANGE.
 468 *
 469 * Else store the converted value in @result, and return zero.
 470 *
 471 * Note that a number with a leading minus sign gets converted without
 472 * the minus sign, checked for overflow (see above), then negated (in
 473 * @result's type).  This is exactly how strtoul() works.
 474 */
 475int qemu_strtoul(const char *nptr, const char **endptr, int base,
 476                 unsigned long *result)
 477{
 478    char *ep;
 479
 480    if (!nptr) {
 481        if (endptr) {
 482            *endptr = nptr;
 483        }
 484        return -EINVAL;
 485    }
 486
 487    errno = 0;
 488    *result = strtoul(nptr, &ep, base);
 489    /* Windows returns 1 for negative out-of-range values.  */
 490    if (errno == ERANGE) {
 491        *result = -1;
 492    }
 493    return check_strtox_error(nptr, ep, endptr, errno);
 494}
 495
 496/**
 497 * Convert string @nptr to an int64_t.
 498 *
 499 * Works like qemu_strtol(), except it stores INT64_MAX on overflow,
 500 * and INT_MIN on underflow.
 501 */
 502int qemu_strtoi64(const char *nptr, const char **endptr, int base,
 503                 int64_t *result)
 504{
 505    char *ep;
 506
 507    if (!nptr) {
 508        if (endptr) {
 509            *endptr = nptr;
 510        }
 511        return -EINVAL;
 512    }
 513
 514    errno = 0;
 515    /* FIXME This assumes int64_t is long long */
 516    *result = strtoll(nptr, &ep, base);
 517    return check_strtox_error(nptr, ep, endptr, errno);
 518}
 519
 520/**
 521 * Convert string @nptr to an uint64_t.
 522 *
 523 * Works like qemu_strtoul(), except it stores UINT64_MAX on overflow.
 524 */
 525int qemu_strtou64(const char *nptr, const char **endptr, int base,
 526                  uint64_t *result)
 527{
 528    char *ep;
 529
 530    if (!nptr) {
 531        if (endptr) {
 532            *endptr = nptr;
 533        }
 534        return -EINVAL;
 535    }
 536
 537    errno = 0;
 538    /* FIXME This assumes uint64_t is unsigned long long */
 539    *result = strtoull(nptr, &ep, base);
 540    /* Windows returns 1 for negative out-of-range values.  */
 541    if (errno == ERANGE) {
 542        *result = -1;
 543    }
 544    return check_strtox_error(nptr, ep, endptr, errno);
 545}
 546
 547/**
 548 * Searches for the first occurrence of 'c' in 's', and returns a pointer
 549 * to the trailing null byte if none was found.
 550 */
 551#ifndef HAVE_STRCHRNUL
 552const char *qemu_strchrnul(const char *s, int c)
 553{
 554    const char *e = strchr(s, c);
 555    if (!e) {
 556        e = s + strlen(s);
 557    }
 558    return e;
 559}
 560#endif
 561
 562/**
 563 * parse_uint:
 564 *
 565 * @s: String to parse
 566 * @value: Destination for parsed integer value
 567 * @endptr: Destination for pointer to first character not consumed
 568 * @base: integer base, between 2 and 36 inclusive, or 0
 569 *
 570 * Parse unsigned integer
 571 *
 572 * Parsed syntax is like strtoull()'s: arbitrary whitespace, a single optional
 573 * '+' or '-', an optional "0x" if @base is 0 or 16, one or more digits.
 574 *
 575 * If @s is null, or @base is invalid, or @s doesn't start with an
 576 * integer in the syntax above, set *@value to 0, *@endptr to @s, and
 577 * return -EINVAL.
 578 *
 579 * Set *@endptr to point right beyond the parsed integer (even if the integer
 580 * overflows or is negative, all digits will be parsed and *@endptr will
 581 * point right beyond them).
 582 *
 583 * If the integer is negative, set *@value to 0, and return -ERANGE.
 584 *
 585 * If the integer overflows unsigned long long, set *@value to
 586 * ULLONG_MAX, and return -ERANGE.
 587 *
 588 * Else, set *@value to the parsed integer, and return 0.
 589 */
 590int parse_uint(const char *s, unsigned long long *value, char **endptr,
 591               int base)
 592{
 593    int r = 0;
 594    char *endp = (char *)s;
 595    unsigned long long val = 0;
 596
 597    if (!s) {
 598        r = -EINVAL;
 599        goto out;
 600    }
 601
 602    errno = 0;
 603    val = strtoull(s, &endp, base);
 604    if (errno) {
 605        r = -errno;
 606        goto out;
 607    }
 608
 609    if (endp == s) {
 610        r = -EINVAL;
 611        goto out;
 612    }
 613
 614    /* make sure we reject negative numbers: */
 615    while (isspace((unsigned char)*s)) {
 616        s++;
 617    }
 618    if (*s == '-') {
 619        val = 0;
 620        r = -ERANGE;
 621        goto out;
 622    }
 623
 624out:
 625    *value = val;
 626    *endptr = endp;
 627    return r;
 628}
 629
 630/**
 631 * parse_uint_full:
 632 *
 633 * @s: String to parse
 634 * @value: Destination for parsed integer value
 635 * @base: integer base, between 2 and 36 inclusive, or 0
 636 *
 637 * Parse unsigned integer from entire string
 638 *
 639 * Have the same behavior of parse_uint(), but with an additional check
 640 * for additional data after the parsed number. If extra characters are present
 641 * after the parsed number, the function will return -EINVAL, and *@v will
 642 * be set to 0.
 643 */
 644int parse_uint_full(const char *s, unsigned long long *value, int base)
 645{
 646    char *endp;
 647    int r;
 648
 649    r = parse_uint(s, value, &endp, base);
 650    if (r < 0) {
 651        return r;
 652    }
 653    if (*endp) {
 654        *value = 0;
 655        return -EINVAL;
 656    }
 657
 658    return 0;
 659}
 660
 661int qemu_parse_fd(const char *param)
 662{
 663    long fd;
 664    char *endptr;
 665
 666    errno = 0;
 667    fd = strtol(param, &endptr, 10);
 668    if (param == endptr /* no conversion performed */                    ||
 669        errno != 0      /* not representable as long; possibly others */ ||
 670        *endptr != '\0' /* final string not empty */                     ||
 671        fd < 0          /* invalid as file descriptor */                 ||
 672        fd > INT_MAX    /* not representable as int */) {
 673        return -1;
 674    }
 675    return fd;
 676}
 677
 678/*
 679 * Implementation of  ULEB128 (http://en.wikipedia.org/wiki/LEB128)
 680 * Input is limited to 14-bit numbers
 681 */
 682int uleb128_encode_small(uint8_t *out, uint32_t n)
 683{
 684    g_assert(n <= 0x3fff);
 685    if (n < 0x80) {
 686        *out++ = n;
 687        return 1;
 688    } else {
 689        *out++ = (n & 0x7f) | 0x80;
 690        *out++ = n >> 7;
 691        return 2;
 692    }
 693}
 694
 695int uleb128_decode_small(const uint8_t *in, uint32_t *n)
 696{
 697    if (!(*in & 0x80)) {
 698        *n = *in++;
 699        return 1;
 700    } else {
 701        *n = *in++ & 0x7f;
 702        /* we exceed 14 bit number */
 703        if (*in & 0x80) {
 704            return -1;
 705        }
 706        *n |= *in++ << 7;
 707        return 2;
 708    }
 709}
 710
 711/*
 712 * helper to parse debug environment variables
 713 */
 714int parse_debug_env(const char *name, int max, int initial)
 715{
 716    char *debug_env = getenv(name);
 717    char *inv = NULL;
 718    long debug;
 719
 720    if (!debug_env) {
 721        return initial;
 722    }
 723    errno = 0;
 724    debug = strtol(debug_env, &inv, 10);
 725    if (inv == debug_env) {
 726        return initial;
 727    }
 728    if (debug < 0 || debug > max || errno != 0) {
 729        warn_report("%s not in [0, %d]", name, max);
 730        return initial;
 731    }
 732    return debug;
 733}
 734
 735/*
 736 * Helper to print ethernet mac address
 737 */
 738const char *qemu_ether_ntoa(const MACAddr *mac)
 739{
 740    static char ret[18];
 741
 742    snprintf(ret, sizeof(ret), "%02x:%02x:%02x:%02x:%02x:%02x",
 743             mac->a[0], mac->a[1], mac->a[2], mac->a[3], mac->a[4], mac->a[5]);
 744
 745    return ret;
 746}
 747
 748/*
 749 * Return human readable string for size @val.
 750 * @val can be anything that uint64_t allows (no more than "16 EiB").
 751 * Use IEC binary units like KiB, MiB, and so forth.
 752 * Caller is responsible for passing it to g_free().
 753 */
 754char *size_to_str(uint64_t val)
 755{
 756    static const char *suffixes[] = { "", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei" };
 757    unsigned long div;
 758    int i;
 759
 760    /*
 761     * The exponent (returned in i) minus one gives us
 762     * floor(log2(val * 1024 / 1000).  The correction makes us
 763     * switch to the higher power when the integer part is >= 1000.
 764     * (see e41b509d68afb1f for more info)
 765     */
 766    frexp(val / (1000.0 / 1024.0), &i);
 767    i = (i - 1) / 10;
 768    div = 1ULL << (i * 10);
 769
 770    return g_strdup_printf("%0.3g %sB", (double)val / div, suffixes[i]);
 771}
 772
 773int qemu_pstrcmp0(const char **str1, const char **str2)
 774{
 775    return g_strcmp0(*str1, *str2);
 776}
 777