cutils.c 14.6 KB
Newer Older
B
bellard 已提交
1 2
/*
 * Simple C functions to supplement the C library
3
 *
B
bellard 已提交
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
 * Copyright (c) 2006 Fabrice Bellard
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
P
Peter Maydell 已提交
24
#include "qemu/osdep.h"
P
pbrook 已提交
25
#include "qemu-common.h"
26
#include "qemu/host-utils.h"
27
#include <math.h>
B
bellard 已提交
28

29 30
#include "qemu/sockets.h"
#include "qemu/iov.h"
A
Alexey Kardashevskiy 已提交
31
#include "net/net.h"
32
#include "qemu/cutils.h"
33

D
Dmitry Fleytman 已提交
34 35 36 37 38 39 40
void strpadcpy(char *buf, int buf_size, const char *str, char pad)
{
    int len = qemu_strnlen(str, buf_size);
    memcpy(buf, str, len);
    memset(buf + len, pad, buf_size - len);
}

B
bellard 已提交
41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62
void pstrcpy(char *buf, int buf_size, const char *str)
{
    int c;
    char *q = buf;

    if (buf_size <= 0)
        return;

    for(;;) {
        c = *str++;
        if (c == 0 || q >= buf + buf_size - 1)
            break;
        *q++ = c;
    }
    *q = '\0';
}

/* strcat and truncate. */
char *pstrcat(char *buf, int buf_size, const char *s)
{
    int len;
    len = strlen(buf);
63
    if (len < buf_size)
B
bellard 已提交
64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89
        pstrcpy(buf + len, buf_size - len, s);
    return buf;
}

int strstart(const char *str, const char *val, const char **ptr)
{
    const char *p, *q;
    p = str;
    q = val;
    while (*q != '\0') {
        if (*p != *q)
            return 0;
        p++;
        q++;
    }
    if (ptr)
        *ptr = p;
    return 1;
}

int stristart(const char *str, const char *val, const char **ptr)
{
    const char *p, *q;
    p = str;
    q = val;
    while (*q != '\0') {
90
        if (qemu_toupper(*p) != qemu_toupper(*q))
B
bellard 已提交
91 92 93 94 95 96 97 98
            return 0;
        p++;
        q++;
    }
    if (ptr)
        *ptr = p;
    return 1;
}
B
bellard 已提交
99

B
Blue Swirl 已提交
100 101 102 103 104 105 106 107 108 109 110 111 112
/* XXX: use host strnlen if available ? */
int qemu_strnlen(const char *s, int max_len)
{
    int i;

    for(i = 0; i < max_len; i++) {
        if (s[i] == '\0') {
            break;
        }
    }
    return i;
}

113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133
char *qemu_strsep(char **input, const char *delim)
{
    char *result = *input;
    if (result != NULL) {
        char *p;

        for (p = result; *p != '\0'; p++) {
            if (strchr(delim, *p)) {
                break;
            }
        }
        if (*p == '\0') {
            *input = NULL;
        } else {
            *p = '\0';
            *input = p + 1;
        }
    }
    return result;
}

B
bellard 已提交
134 135 136 137 138 139 140 141
time_t mktimegm(struct tm *tm)
{
    time_t t;
    int y = tm->tm_year + 1900, m = tm->tm_mon + 1, d = tm->tm_mday;
    if (m < 3) {
        m += 12;
        y--;
    }
P
Paolo Bonzini 已提交
142
    t = 86400ULL * (d + (153 * m - 457) / 5 + 365 * y + y / 4 - y / 100 + 
B
bellard 已提交
143 144 145 146
                 y / 400 - 719469);
    t += 3600 * tm->tm_hour + 60 * tm->tm_min + tm->tm_sec;
    return t;
}
A
aliguori 已提交
147

148 149 150 151 152 153 154 155 156
/*
 * Make sure data goes on disk, but if possible do not bother to
 * write out the inode just for timestamp updates.
 *
 * Unfortunately even in 2009 many operating systems do not support
 * fdatasync and have to fall back to fsync.
 */
int qemu_fdatasync(int fd)
{
B
Blue Swirl 已提交
157
#ifdef CONFIG_FDATASYNC
158 159 160 161 162 163
    return fdatasync(fd);
#else
    return fsync(fd);
#endif
}

P
Paolo Bonzini 已提交
164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180
#ifndef _WIN32
/* Sets a specific flag */
int fcntl_setfl(int fd, int flag)
{
    int flags;

    flags = fcntl(fd, F_GETFL);
    if (flags == -1)
        return -errno;

    if (fcntl(fd, F_SETFL, flags | flag) == -1)
        return -errno;

    return 0;
}
#endif

181 182 183
static int64_t suffix_mul(char suffix, int64_t unit)
{
    switch (qemu_toupper(suffix)) {
184
    case QEMU_STRTOSZ_DEFSUFFIX_B:
185
        return 1;
186
    case QEMU_STRTOSZ_DEFSUFFIX_KB:
187
        return unit;
188
    case QEMU_STRTOSZ_DEFSUFFIX_MB:
189
        return unit * unit;
190
    case QEMU_STRTOSZ_DEFSUFFIX_GB:
191
        return unit * unit * unit;
192
    case QEMU_STRTOSZ_DEFSUFFIX_TB:
193
        return unit * unit * unit * unit;
194
    case QEMU_STRTOSZ_DEFSUFFIX_PB:
195
        return unit * unit * unit * unit * unit;
196
    case QEMU_STRTOSZ_DEFSUFFIX_EB:
197
        return unit * unit * unit * unit * unit * unit;
198 199 200 201
    }
    return -1;
}

202 203
/*
 * Convert string to bytes, allowing either B/b for bytes, K/k for KB,
204
 * M/m for MB, G/g for GB or T/t for TB. End pointer will be returned
205 206
 * in *end, if not NULL. Return -ERANGE on overflow, Return -EINVAL on
 * other error.
207
 */
208
int64_t qemu_strtosz_suffix_unit(const char *nptr, char **end,
209
                            const char default_suffix, int64_t unit)
210
{
211
    int64_t retval = -EINVAL;
212
    char *endptr;
213
    unsigned char c;
214 215 216 217 218 219 220 221
    int mul_required = 0;
    double val, mul, integral, fraction;

    errno = 0;
    val = strtod(nptr, &endptr);
    if (isnan(val) || endptr == nptr || errno != 0) {
        goto fail;
    }
222 223
    fraction = modf(val, &integral);
    if (fraction != 0) {
224 225 226
        mul_required = 1;
    }
    c = *endptr;
227 228 229 230 231 232
    mul = suffix_mul(c, unit);
    if (mul >= 0) {
        endptr++;
    } else {
        mul = suffix_mul(default_suffix, unit);
        assert(mul >= 0);
233
    }
234
    if (mul == 1 && mul_required) {
235 236
        goto fail;
    }
237
    if ((val * mul >= INT64_MAX) || val < 0) {
238
        retval = -ERANGE;
239 240 241 242 243 244 245 246 247 248 249
        goto fail;
    }
    retval = val * mul;

fail:
    if (end) {
        *end = endptr;
    }

    return retval;
}
J
Jes Sorensen 已提交
250

251 252
int64_t qemu_strtosz_suffix(const char *nptr, char **end,
                            const char default_suffix)
253
{
254
    return qemu_strtosz_suffix_unit(nptr, end, default_suffix, 1024);
255 256
}

257
int64_t qemu_strtosz(const char *nptr, char **end)
J
Jes Sorensen 已提交
258
{
259
    return qemu_strtosz_suffix(nptr, end, QEMU_STRTOSZ_DEFSUFFIX_MB);
J
Jes Sorensen 已提交
260
}
261

262
/**
263
 * Helper function for error checking after strtol() and the like
264
 */
265 266
static int check_strtox_error(const char *nptr, char *ep,
                              const char **endptr, int libc_errno)
267
{
268 269 270 271 272
    if (endptr) {
        *endptr = ep;
    }

    /* Turn "no conversion" into an error */
273
    if (libc_errno == 0 && ep == nptr) {
274
        return -EINVAL;
275
    }
276 277

    /* Fail when we're expected to consume the string, but didn't */
278
    if (!endptr && *ep) {
279 280
        return -EINVAL;
    }
281

282
    return -libc_errno;
283 284 285
}

/**
286
 * Convert string @nptr to a long integer, and store it in @result.
287
 *
288 289 290
 * This is a wrapper around strtol() that is harder to misuse.
 * Semantics of @nptr, @endptr, @base match strtol() with differences
 * noted below.
291
 *
292
 * @nptr may be null, and no conversion is performed then.
293
 *
294 295
 * If no conversion is performed, store @nptr in *@endptr and return
 * -EINVAL.
296
 *
297 298 299 300 301 302 303 304 305 306 307
 * If @endptr is null, and the string isn't fully converted, return
 * -EINVAL.  This is the case when the pointer that would be stored in
 * a non-null @endptr points to a character other than '\0'.
 *
 * If the conversion overflows @result, store LONG_MAX in @result,
 * and return -ERANGE.
 *
 * If the conversion underflows @result, store LONG_MIN in @result,
 * and return -ERANGE.
 *
 * Else store the converted value in @result, and return zero.
308 309 310 311
 */
int qemu_strtol(const char *nptr, const char **endptr, int base,
                long *result)
{
312
    char *ep;
313

314 315 316 317
    if (!nptr) {
        if (endptr) {
            *endptr = nptr;
        }
318
        return -EINVAL;
319
    }
320 321 322 323

    errno = 0;
    *result = strtol(nptr, &ep, base);
    return check_strtox_error(nptr, ep, endptr, errno);
324
}
325 326

/**
327 328 329 330 331 332 333 334 335 336 337 338 339 340
 * Convert string @nptr to an unsigned long, and store it in @result.
 *
 * This is a wrapper around strtoul() that is harder to misuse.
 * Semantics of @nptr, @endptr, @base match strtoul() with differences
 * noted below.
 *
 * @nptr may be null, and no conversion is performed then.
 *
 * If no conversion is performed, store @nptr in *@endptr and return
 * -EINVAL.
 *
 * If @endptr is null, and the string isn't fully converted, return
 * -EINVAL.  This is the case when the pointer that would be stored in
 * a non-null @endptr points to a character other than '\0'.
341
 *
342 343
 * If the conversion overflows @result, store ULONG_MAX in @result,
 * and return -ERANGE.
344
 *
345
 * Else store the converted value in @result, and return zero.
346
 *
347 348 349
 * Note that a number with a leading minus sign gets converted without
 * the minus sign, checked for overflow (see above), then negated (in
 * @result's type).  This is exactly how strtoul() works.
350 351 352 353
 */
int qemu_strtoul(const char *nptr, const char **endptr, int base,
                 unsigned long *result)
{
354
    char *ep;
355

356 357 358 359
    if (!nptr) {
        if (endptr) {
            *endptr = nptr;
        }
360 361 362 363 364 365 366 367
        return -EINVAL;
    }

    errno = 0;
    *result = strtoul(nptr, &ep, base);
    /* Windows returns 1 for negative out-of-range values.  */
    if (errno == ERANGE) {
        *result = -1;
368
    }
369
    return check_strtox_error(nptr, ep, endptr, errno);
370 371
}

372
/**
373
 * Convert string @nptr to an int64_t.
374
 *
375 376
 * Works like qemu_strtol(), except it stores INT64_MAX on overflow,
 * and INT_MIN on underflow.
377
 */
378
int qemu_strtoi64(const char *nptr, const char **endptr, int base,
379 380
                 int64_t *result)
{
381
    char *ep;
382

383 384 385 386
    if (!nptr) {
        if (endptr) {
            *endptr = nptr;
        }
387
        return -EINVAL;
388
    }
389 390 391 392 393

    errno = 0;
    /* FIXME This assumes int64_t is long long */
    *result = strtoll(nptr, &ep, base);
    return check_strtox_error(nptr, ep, endptr, errno);
394 395
}

396
/**
397
 * Convert string @nptr to an uint64_t.
398
 *
399
 * Works like qemu_strtoul(), except it stores UINT64_MAX on overflow.
400
 */
401
int qemu_strtou64(const char *nptr, const char **endptr, int base,
402 403
                  uint64_t *result)
{
404
    char *ep;
405

406 407 408 409
    if (!nptr) {
        if (endptr) {
            *endptr = nptr;
        }
410 411 412 413 414 415 416 417 418
        return -EINVAL;
    }

    errno = 0;
    /* FIXME This assumes uint64_t is unsigned long long */
    *result = strtoull(nptr, &ep, base);
    /* Windows returns 1 for negative out-of-range values.  */
    if (errno == ERANGE) {
        *result = -1;
419
    }
420
    return check_strtox_error(nptr, ep, endptr, errno);
421 422
}

423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521
/**
 * parse_uint:
 *
 * @s: String to parse
 * @value: Destination for parsed integer value
 * @endptr: Destination for pointer to first character not consumed
 * @base: integer base, between 2 and 36 inclusive, or 0
 *
 * Parse unsigned integer
 *
 * Parsed syntax is like strtoull()'s: arbitrary whitespace, a single optional
 * '+' or '-', an optional "0x" if @base is 0 or 16, one or more digits.
 *
 * If @s is null, or @base is invalid, or @s doesn't start with an
 * integer in the syntax above, set *@value to 0, *@endptr to @s, and
 * return -EINVAL.
 *
 * Set *@endptr to point right beyond the parsed integer (even if the integer
 * overflows or is negative, all digits will be parsed and *@endptr will
 * point right beyond them).
 *
 * If the integer is negative, set *@value to 0, and return -ERANGE.
 *
 * If the integer overflows unsigned long long, set *@value to
 * ULLONG_MAX, and return -ERANGE.
 *
 * Else, set *@value to the parsed integer, and return 0.
 */
int parse_uint(const char *s, unsigned long long *value, char **endptr,
               int base)
{
    int r = 0;
    char *endp = (char *)s;
    unsigned long long val = 0;

    if (!s) {
        r = -EINVAL;
        goto out;
    }

    errno = 0;
    val = strtoull(s, &endp, base);
    if (errno) {
        r = -errno;
        goto out;
    }

    if (endp == s) {
        r = -EINVAL;
        goto out;
    }

    /* make sure we reject negative numbers: */
    while (isspace((unsigned char)*s)) {
        s++;
    }
    if (*s == '-') {
        val = 0;
        r = -ERANGE;
        goto out;
    }

out:
    *value = val;
    *endptr = endp;
    return r;
}

/**
 * parse_uint_full:
 *
 * @s: String to parse
 * @value: Destination for parsed integer value
 * @base: integer base, between 2 and 36 inclusive, or 0
 *
 * Parse unsigned integer from entire string
 *
 * Have the same behavior of parse_uint(), but with an additional check
 * for additional data after the parsed number. If extra characters are present
 * after the parsed number, the function will return -EINVAL, and *@v will
 * be set to 0.
 */
int parse_uint_full(const char *s, unsigned long long *value, int base)
{
    char *endp;
    int r;

    r = parse_uint(s, value, &endp, base);
    if (r < 0) {
        return r;
    }
    if (*endp) {
        *value = 0;
        return -EINVAL;
    }

    return 0;
}

522 523
int qemu_parse_fd(const char *param)
{
L
Laszlo Ersek 已提交
524 525
    long fd;
    char *endptr;
526

L
Laszlo Ersek 已提交
527
    errno = 0;
528
    fd = strtol(param, &endptr, 10);
L
Laszlo Ersek 已提交
529 530 531 532 533
    if (param == endptr /* no conversion performed */                    ||
        errno != 0      /* not representable as long; possibly others */ ||
        *endptr != '\0' /* final string not empty */                     ||
        fd < 0          /* invalid as file descriptor */                 ||
        fd > INT_MAX    /* not representable as int */) {
534 535 536 537
        return -1;
    }
    return fd;
}
O
Orit Wasserman 已提交
538

539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570
/*
 * Implementation of  ULEB128 (http://en.wikipedia.org/wiki/LEB128)
 * Input is limited to 14-bit numbers
 */
int uleb128_encode_small(uint8_t *out, uint32_t n)
{
    g_assert(n <= 0x3fff);
    if (n < 0x80) {
        *out++ = n;
        return 1;
    } else {
        *out++ = (n & 0x7f) | 0x80;
        *out++ = n >> 7;
        return 2;
    }
}

int uleb128_decode_small(const uint8_t *in, uint32_t *n)
{
    if (!(*in & 0x80)) {
        *n = *in++;
        return 1;
    } else {
        *n = *in++ & 0x7f;
        /* we exceed 14 bit number */
        if (*in & 0x80) {
            return -1;
        }
        *n |= *in++ << 7;
        return 2;
    }
}
571 572 573 574 575 576 577 578

/*
 * helper to parse debug environment variables
 */
int parse_debug_env(const char *name, int max, int initial)
{
    char *debug_env = getenv(name);
    char *inv = NULL;
579
    long debug;
580 581 582 583

    if (!debug_env) {
        return initial;
    }
584
    errno = 0;
585 586 587 588
    debug = strtol(debug_env, &inv, 10);
    if (inv == debug_env) {
        return initial;
    }
589
    if (debug < 0 || debug > max || errno != 0) {
590 591 592 593 594
        fprintf(stderr, "warning: %s not in [0, %d]", name, max);
        return initial;
    }
    return debug;
}
A
Alexey Kardashevskiy 已提交
595 596 597 598 599 600 601 602 603 604 605 606 607

/*
 * Helper to print ethernet mac address
 */
const char *qemu_ether_ntoa(const MACAddr *mac)
{
    static char ret[18];

    snprintf(ret, sizeof(ret), "%02x:%02x:%02x:%02x:%02x:%02x",
             mac->a[0], mac->a[1], mac->a[2], mac->a[3], mac->a[4], mac->a[5]);

    return ret;
}