1baacf047SPaolo Bonzini /* 2baacf047SPaolo Bonzini * Simple C functions to supplement the C library 3baacf047SPaolo Bonzini * 4baacf047SPaolo Bonzini * Copyright (c) 2006 Fabrice Bellard 5baacf047SPaolo Bonzini * 6baacf047SPaolo Bonzini * Permission is hereby granted, free of charge, to any person obtaining a copy 7baacf047SPaolo Bonzini * of this software and associated documentation files (the "Software"), to deal 8baacf047SPaolo Bonzini * in the Software without restriction, including without limitation the rights 9baacf047SPaolo Bonzini * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 10baacf047SPaolo Bonzini * copies of the Software, and to permit persons to whom the Software is 11baacf047SPaolo Bonzini * furnished to do so, subject to the following conditions: 12baacf047SPaolo Bonzini * 13baacf047SPaolo Bonzini * The above copyright notice and this permission notice shall be included in 14baacf047SPaolo Bonzini * all copies or substantial portions of the Software. 15baacf047SPaolo Bonzini * 16baacf047SPaolo Bonzini * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17baacf047SPaolo Bonzini * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18baacf047SPaolo Bonzini * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 19baacf047SPaolo Bonzini * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20baacf047SPaolo Bonzini * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 21baacf047SPaolo Bonzini * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 22baacf047SPaolo Bonzini * THE SOFTWARE. 23baacf047SPaolo Bonzini */ 24aafd7584SPeter Maydell #include "qemu/osdep.h" 25baacf047SPaolo Bonzini #include "qemu-common.h" 26baacf047SPaolo Bonzini #include "qemu/host-utils.h" 27baacf047SPaolo Bonzini #include <math.h> 28baacf047SPaolo Bonzini 29baacf047SPaolo Bonzini #include "qemu/sockets.h" 30baacf047SPaolo Bonzini #include "qemu/iov.h" 314297c8eeSAlexey Kardashevskiy #include "net/net.h" 32f348b6d1SVeronia Bahaa #include "qemu/cutils.h" 33baacf047SPaolo Bonzini 34baacf047SPaolo Bonzini void strpadcpy(char *buf, int buf_size, const char *str, char pad) 35baacf047SPaolo Bonzini { 36baacf047SPaolo Bonzini int len = qemu_strnlen(str, buf_size); 37baacf047SPaolo Bonzini memcpy(buf, str, len); 38baacf047SPaolo Bonzini memset(buf + len, pad, buf_size - len); 39baacf047SPaolo Bonzini } 40baacf047SPaolo Bonzini 41baacf047SPaolo Bonzini void pstrcpy(char *buf, int buf_size, const char *str) 42baacf047SPaolo Bonzini { 43baacf047SPaolo Bonzini int c; 44baacf047SPaolo Bonzini char *q = buf; 45baacf047SPaolo Bonzini 46baacf047SPaolo Bonzini if (buf_size <= 0) 47baacf047SPaolo Bonzini return; 48baacf047SPaolo Bonzini 49baacf047SPaolo Bonzini for(;;) { 50baacf047SPaolo Bonzini c = *str++; 51baacf047SPaolo Bonzini if (c == 0 || q >= buf + buf_size - 1) 52baacf047SPaolo Bonzini break; 53baacf047SPaolo Bonzini *q++ = c; 54baacf047SPaolo Bonzini } 55baacf047SPaolo Bonzini *q = '\0'; 56baacf047SPaolo Bonzini } 57baacf047SPaolo Bonzini 58baacf047SPaolo Bonzini /* strcat and truncate. */ 59baacf047SPaolo Bonzini char *pstrcat(char *buf, int buf_size, const char *s) 60baacf047SPaolo Bonzini { 61baacf047SPaolo Bonzini int len; 62baacf047SPaolo Bonzini len = strlen(buf); 63baacf047SPaolo Bonzini if (len < buf_size) 64baacf047SPaolo Bonzini pstrcpy(buf + len, buf_size - len, s); 65baacf047SPaolo Bonzini return buf; 66baacf047SPaolo Bonzini } 67baacf047SPaolo Bonzini 68baacf047SPaolo Bonzini int strstart(const char *str, const char *val, const char **ptr) 69baacf047SPaolo Bonzini { 70baacf047SPaolo Bonzini const char *p, *q; 71baacf047SPaolo Bonzini p = str; 72baacf047SPaolo Bonzini q = val; 73baacf047SPaolo Bonzini while (*q != '\0') { 74baacf047SPaolo Bonzini if (*p != *q) 75baacf047SPaolo Bonzini return 0; 76baacf047SPaolo Bonzini p++; 77baacf047SPaolo Bonzini q++; 78baacf047SPaolo Bonzini } 79baacf047SPaolo Bonzini if (ptr) 80baacf047SPaolo Bonzini *ptr = p; 81baacf047SPaolo Bonzini return 1; 82baacf047SPaolo Bonzini } 83baacf047SPaolo Bonzini 84baacf047SPaolo Bonzini int stristart(const char *str, const char *val, const char **ptr) 85baacf047SPaolo Bonzini { 86baacf047SPaolo Bonzini const char *p, *q; 87baacf047SPaolo Bonzini p = str; 88baacf047SPaolo Bonzini q = val; 89baacf047SPaolo Bonzini while (*q != '\0') { 90baacf047SPaolo Bonzini if (qemu_toupper(*p) != qemu_toupper(*q)) 91baacf047SPaolo Bonzini return 0; 92baacf047SPaolo Bonzini p++; 93baacf047SPaolo Bonzini q++; 94baacf047SPaolo Bonzini } 95baacf047SPaolo Bonzini if (ptr) 96baacf047SPaolo Bonzini *ptr = p; 97baacf047SPaolo Bonzini return 1; 98baacf047SPaolo Bonzini } 99baacf047SPaolo Bonzini 100baacf047SPaolo Bonzini /* XXX: use host strnlen if available ? */ 101baacf047SPaolo Bonzini int qemu_strnlen(const char *s, int max_len) 102baacf047SPaolo Bonzini { 103baacf047SPaolo Bonzini int i; 104baacf047SPaolo Bonzini 105baacf047SPaolo Bonzini for(i = 0; i < max_len; i++) { 106baacf047SPaolo Bonzini if (s[i] == '\0') { 107baacf047SPaolo Bonzini break; 108baacf047SPaolo Bonzini } 109baacf047SPaolo Bonzini } 110baacf047SPaolo Bonzini return i; 111baacf047SPaolo Bonzini } 112baacf047SPaolo Bonzini 113a38ed811SKevin Wolf char *qemu_strsep(char **input, const char *delim) 114a38ed811SKevin Wolf { 115a38ed811SKevin Wolf char *result = *input; 116a38ed811SKevin Wolf if (result != NULL) { 117a38ed811SKevin Wolf char *p; 118a38ed811SKevin Wolf 119a38ed811SKevin Wolf for (p = result; *p != '\0'; p++) { 120a38ed811SKevin Wolf if (strchr(delim, *p)) { 121a38ed811SKevin Wolf break; 122a38ed811SKevin Wolf } 123a38ed811SKevin Wolf } 124a38ed811SKevin Wolf if (*p == '\0') { 125a38ed811SKevin Wolf *input = NULL; 126a38ed811SKevin Wolf } else { 127a38ed811SKevin Wolf *p = '\0'; 128a38ed811SKevin Wolf *input = p + 1; 129a38ed811SKevin Wolf } 130a38ed811SKevin Wolf } 131a38ed811SKevin Wolf return result; 132a38ed811SKevin Wolf } 133a38ed811SKevin Wolf 134baacf047SPaolo Bonzini time_t mktimegm(struct tm *tm) 135baacf047SPaolo Bonzini { 136baacf047SPaolo Bonzini time_t t; 137baacf047SPaolo Bonzini int y = tm->tm_year + 1900, m = tm->tm_mon + 1, d = tm->tm_mday; 138baacf047SPaolo Bonzini if (m < 3) { 139baacf047SPaolo Bonzini m += 12; 140baacf047SPaolo Bonzini y--; 141baacf047SPaolo Bonzini } 142baacf047SPaolo Bonzini t = 86400ULL * (d + (153 * m - 457) / 5 + 365 * y + y / 4 - y / 100 + 143baacf047SPaolo Bonzini y / 400 - 719469); 144baacf047SPaolo Bonzini t += 3600 * tm->tm_hour + 60 * tm->tm_min + tm->tm_sec; 145baacf047SPaolo Bonzini return t; 146baacf047SPaolo Bonzini } 147baacf047SPaolo Bonzini 148baacf047SPaolo Bonzini /* 149baacf047SPaolo Bonzini * Make sure data goes on disk, but if possible do not bother to 150baacf047SPaolo Bonzini * write out the inode just for timestamp updates. 151baacf047SPaolo Bonzini * 152baacf047SPaolo Bonzini * Unfortunately even in 2009 many operating systems do not support 153baacf047SPaolo Bonzini * fdatasync and have to fall back to fsync. 154baacf047SPaolo Bonzini */ 155baacf047SPaolo Bonzini int qemu_fdatasync(int fd) 156baacf047SPaolo Bonzini { 157baacf047SPaolo Bonzini #ifdef CONFIG_FDATASYNC 158baacf047SPaolo Bonzini return fdatasync(fd); 159baacf047SPaolo Bonzini #else 160baacf047SPaolo Bonzini return fsync(fd); 161baacf047SPaolo Bonzini #endif 162baacf047SPaolo Bonzini } 163baacf047SPaolo Bonzini 164baacf047SPaolo Bonzini #ifndef _WIN32 165baacf047SPaolo Bonzini /* Sets a specific flag */ 166baacf047SPaolo Bonzini int fcntl_setfl(int fd, int flag) 167baacf047SPaolo Bonzini { 168baacf047SPaolo Bonzini int flags; 169baacf047SPaolo Bonzini 170baacf047SPaolo Bonzini flags = fcntl(fd, F_GETFL); 171baacf047SPaolo Bonzini if (flags == -1) 172baacf047SPaolo Bonzini return -errno; 173baacf047SPaolo Bonzini 174baacf047SPaolo Bonzini if (fcntl(fd, F_SETFL, flags | flag) == -1) 175baacf047SPaolo Bonzini return -errno; 176baacf047SPaolo Bonzini 177baacf047SPaolo Bonzini return 0; 178baacf047SPaolo Bonzini } 179baacf047SPaolo Bonzini #endif 180baacf047SPaolo Bonzini 181*466dea14SMarkus Armbruster #define QEMU_STRTOSZ_DEFSUFFIX_EB 'E' 182*466dea14SMarkus Armbruster #define QEMU_STRTOSZ_DEFSUFFIX_PB 'P' 183*466dea14SMarkus Armbruster #define QEMU_STRTOSZ_DEFSUFFIX_TB 'T' 184*466dea14SMarkus Armbruster #define QEMU_STRTOSZ_DEFSUFFIX_GB 'G' 185*466dea14SMarkus Armbruster #define QEMU_STRTOSZ_DEFSUFFIX_MB 'M' 186*466dea14SMarkus Armbruster #define QEMU_STRTOSZ_DEFSUFFIX_KB 'K' 187*466dea14SMarkus Armbruster #define QEMU_STRTOSZ_DEFSUFFIX_B 'B' 188*466dea14SMarkus Armbruster 189baacf047SPaolo Bonzini static int64_t suffix_mul(char suffix, int64_t unit) 190baacf047SPaolo Bonzini { 191baacf047SPaolo Bonzini switch (qemu_toupper(suffix)) { 1924677bb40SMarc-André Lureau case QEMU_STRTOSZ_DEFSUFFIX_B: 193baacf047SPaolo Bonzini return 1; 1944677bb40SMarc-André Lureau case QEMU_STRTOSZ_DEFSUFFIX_KB: 195baacf047SPaolo Bonzini return unit; 1964677bb40SMarc-André Lureau case QEMU_STRTOSZ_DEFSUFFIX_MB: 197baacf047SPaolo Bonzini return unit * unit; 1984677bb40SMarc-André Lureau case QEMU_STRTOSZ_DEFSUFFIX_GB: 199baacf047SPaolo Bonzini return unit * unit * unit; 2004677bb40SMarc-André Lureau case QEMU_STRTOSZ_DEFSUFFIX_TB: 201baacf047SPaolo Bonzini return unit * unit * unit * unit; 2024677bb40SMarc-André Lureau case QEMU_STRTOSZ_DEFSUFFIX_PB: 2035e00984aSKevin Wolf return unit * unit * unit * unit * unit; 2044677bb40SMarc-André Lureau case QEMU_STRTOSZ_DEFSUFFIX_EB: 2055e00984aSKevin Wolf return unit * unit * unit * unit * unit * unit; 206baacf047SPaolo Bonzini } 207baacf047SPaolo Bonzini return -1; 208baacf047SPaolo Bonzini } 209baacf047SPaolo Bonzini 210baacf047SPaolo Bonzini /* 211baacf047SPaolo Bonzini * Convert string to bytes, allowing either B/b for bytes, K/k for KB, 212baacf047SPaolo Bonzini * M/m for MB, G/g for GB or T/t for TB. End pointer will be returned 213baacf047SPaolo Bonzini * in *end, if not NULL. Return -ERANGE on overflow, Return -EINVAL on 214baacf047SPaolo Bonzini * other error. 215baacf047SPaolo Bonzini */ 216d2734d26SMarkus Armbruster static int64_t do_strtosz(const char *nptr, char **end, 217baacf047SPaolo Bonzini const char default_suffix, int64_t unit) 218baacf047SPaolo Bonzini { 219baacf047SPaolo Bonzini int64_t retval = -EINVAL; 220baacf047SPaolo Bonzini char *endptr; 221baacf047SPaolo Bonzini unsigned char c; 222baacf047SPaolo Bonzini int mul_required = 0; 223baacf047SPaolo Bonzini double val, mul, integral, fraction; 224baacf047SPaolo Bonzini 225baacf047SPaolo Bonzini errno = 0; 226baacf047SPaolo Bonzini val = strtod(nptr, &endptr); 227baacf047SPaolo Bonzini if (isnan(val) || endptr == nptr || errno != 0) { 228baacf047SPaolo Bonzini goto fail; 229baacf047SPaolo Bonzini } 230baacf047SPaolo Bonzini fraction = modf(val, &integral); 231baacf047SPaolo Bonzini if (fraction != 0) { 232baacf047SPaolo Bonzini mul_required = 1; 233baacf047SPaolo Bonzini } 234baacf047SPaolo Bonzini c = *endptr; 235baacf047SPaolo Bonzini mul = suffix_mul(c, unit); 236baacf047SPaolo Bonzini if (mul >= 0) { 237baacf047SPaolo Bonzini endptr++; 238baacf047SPaolo Bonzini } else { 239baacf047SPaolo Bonzini mul = suffix_mul(default_suffix, unit); 240baacf047SPaolo Bonzini assert(mul >= 0); 241baacf047SPaolo Bonzini } 242baacf047SPaolo Bonzini if (mul == 1 && mul_required) { 243baacf047SPaolo Bonzini goto fail; 244baacf047SPaolo Bonzini } 245baacf047SPaolo Bonzini if ((val * mul >= INT64_MAX) || val < 0) { 246baacf047SPaolo Bonzini retval = -ERANGE; 247baacf047SPaolo Bonzini goto fail; 248baacf047SPaolo Bonzini } 249baacf047SPaolo Bonzini retval = val * mul; 250baacf047SPaolo Bonzini 251baacf047SPaolo Bonzini fail: 252baacf047SPaolo Bonzini if (end) { 253baacf047SPaolo Bonzini *end = endptr; 254baacf047SPaolo Bonzini } 255baacf047SPaolo Bonzini 256baacf047SPaolo Bonzini return retval; 257baacf047SPaolo Bonzini } 258baacf047SPaolo Bonzini 259*466dea14SMarkus Armbruster int64_t qemu_strtosz(const char *nptr, char **end) 260baacf047SPaolo Bonzini { 261*466dea14SMarkus Armbruster return do_strtosz(nptr, end, QEMU_STRTOSZ_DEFSUFFIX_B, 1024); 262baacf047SPaolo Bonzini } 263baacf047SPaolo Bonzini 264e591591bSMarkus Armbruster int64_t qemu_strtosz_MiB(const char *nptr, char **end) 265baacf047SPaolo Bonzini { 266*466dea14SMarkus Armbruster return do_strtosz(nptr, end, QEMU_STRTOSZ_DEFSUFFIX_MB, 1024); 267baacf047SPaolo Bonzini } 268baacf047SPaolo Bonzini 269d2734d26SMarkus Armbruster int64_t qemu_strtosz_metric(const char *nptr, char **end) 270d2734d26SMarkus Armbruster { 271d2734d26SMarkus Armbruster return do_strtosz(nptr, end, QEMU_STRTOSZ_DEFSUFFIX_B, 1000); 272d2734d26SMarkus Armbruster } 273d2734d26SMarkus Armbruster 274e3f9fe2dSEduardo Habkost /** 275717adf96SMarkus Armbruster * Helper function for error checking after strtol() and the like 276764e0fa4SCarlos L. Torres */ 277717adf96SMarkus Armbruster static int check_strtox_error(const char *nptr, char *ep, 278717adf96SMarkus Armbruster const char **endptr, int libc_errno) 279764e0fa4SCarlos L. Torres { 280717adf96SMarkus Armbruster if (endptr) { 281717adf96SMarkus Armbruster *endptr = ep; 282764e0fa4SCarlos L. Torres } 2834baef267SMarkus Armbruster 2844baef267SMarkus Armbruster /* Turn "no conversion" into an error */ 2854baef267SMarkus Armbruster if (libc_errno == 0 && ep == nptr) { 2864baef267SMarkus Armbruster return -EINVAL; 2874baef267SMarkus Armbruster } 2884baef267SMarkus Armbruster 2894baef267SMarkus Armbruster /* Fail when we're expected to consume the string, but didn't */ 2904baef267SMarkus Armbruster if (!endptr && *ep) { 2914baef267SMarkus Armbruster return -EINVAL; 2924baef267SMarkus Armbruster } 2934baef267SMarkus Armbruster 294717adf96SMarkus Armbruster return -libc_errno; 295764e0fa4SCarlos L. Torres } 296764e0fa4SCarlos L. Torres 297764e0fa4SCarlos L. Torres /** 2984295f879SMarkus Armbruster * Convert string @nptr to a long integer, and store it in @result. 299764e0fa4SCarlos L. Torres * 3004295f879SMarkus Armbruster * This is a wrapper around strtol() that is harder to misuse. 3014295f879SMarkus Armbruster * Semantics of @nptr, @endptr, @base match strtol() with differences 3024295f879SMarkus Armbruster * noted below. 303764e0fa4SCarlos L. Torres * 3044295f879SMarkus Armbruster * @nptr may be null, and no conversion is performed then. 305764e0fa4SCarlos L. Torres * 3064295f879SMarkus Armbruster * If no conversion is performed, store @nptr in *@endptr and return 3074295f879SMarkus Armbruster * -EINVAL. 308764e0fa4SCarlos L. Torres * 3094295f879SMarkus Armbruster * If @endptr is null, and the string isn't fully converted, return 3104295f879SMarkus Armbruster * -EINVAL. This is the case when the pointer that would be stored in 3114295f879SMarkus Armbruster * a non-null @endptr points to a character other than '\0'. 3124295f879SMarkus Armbruster * 3134295f879SMarkus Armbruster * If the conversion overflows @result, store LONG_MAX in @result, 3144295f879SMarkus Armbruster * and return -ERANGE. 3154295f879SMarkus Armbruster * 3164295f879SMarkus Armbruster * If the conversion underflows @result, store LONG_MIN in @result, 3174295f879SMarkus Armbruster * and return -ERANGE. 3184295f879SMarkus Armbruster * 3194295f879SMarkus Armbruster * Else store the converted value in @result, and return zero. 320764e0fa4SCarlos L. Torres */ 321764e0fa4SCarlos L. Torres int qemu_strtol(const char *nptr, const char **endptr, int base, 322764e0fa4SCarlos L. Torres long *result) 323764e0fa4SCarlos L. Torres { 324717adf96SMarkus Armbruster char *ep; 3254baef267SMarkus Armbruster 326764e0fa4SCarlos L. Torres if (!nptr) { 327764e0fa4SCarlos L. Torres if (endptr) { 328764e0fa4SCarlos L. Torres *endptr = nptr; 329764e0fa4SCarlos L. Torres } 3304baef267SMarkus Armbruster return -EINVAL; 3314baef267SMarkus Armbruster } 3324baef267SMarkus Armbruster 333764e0fa4SCarlos L. Torres errno = 0; 334717adf96SMarkus Armbruster *result = strtol(nptr, &ep, base); 3354baef267SMarkus Armbruster return check_strtox_error(nptr, ep, endptr, errno); 336764e0fa4SCarlos L. Torres } 337c817c015SCarlos L. Torres 338c817c015SCarlos L. Torres /** 3394295f879SMarkus Armbruster * Convert string @nptr to an unsigned long, and store it in @result. 340c817c015SCarlos L. Torres * 3414295f879SMarkus Armbruster * This is a wrapper around strtoul() that is harder to misuse. 3424295f879SMarkus Armbruster * Semantics of @nptr, @endptr, @base match strtoul() with differences 3434295f879SMarkus Armbruster * noted below. 344c817c015SCarlos L. Torres * 3454295f879SMarkus Armbruster * @nptr may be null, and no conversion is performed then. 346c817c015SCarlos L. Torres * 3474295f879SMarkus Armbruster * If no conversion is performed, store @nptr in *@endptr and return 3484295f879SMarkus Armbruster * -EINVAL. 3494295f879SMarkus Armbruster * 3504295f879SMarkus Armbruster * If @endptr is null, and the string isn't fully converted, return 3514295f879SMarkus Armbruster * -EINVAL. This is the case when the pointer that would be stored in 3524295f879SMarkus Armbruster * a non-null @endptr points to a character other than '\0'. 3534295f879SMarkus Armbruster * 3544295f879SMarkus Armbruster * If the conversion overflows @result, store ULONG_MAX in @result, 3554295f879SMarkus Armbruster * and return -ERANGE. 3564295f879SMarkus Armbruster * 3574295f879SMarkus Armbruster * Else store the converted value in @result, and return zero. 3584295f879SMarkus Armbruster * 3594295f879SMarkus Armbruster * Note that a number with a leading minus sign gets converted without 3604295f879SMarkus Armbruster * the minus sign, checked for overflow (see above), then negated (in 3614295f879SMarkus Armbruster * @result's type). This is exactly how strtoul() works. 362c817c015SCarlos L. Torres */ 363c817c015SCarlos L. Torres int qemu_strtoul(const char *nptr, const char **endptr, int base, 364c817c015SCarlos L. Torres unsigned long *result) 365c817c015SCarlos L. Torres { 366717adf96SMarkus Armbruster char *ep; 3674baef267SMarkus Armbruster 368c817c015SCarlos L. Torres if (!nptr) { 369c817c015SCarlos L. Torres if (endptr) { 370c817c015SCarlos L. Torres *endptr = nptr; 371c817c015SCarlos L. Torres } 3724baef267SMarkus Armbruster return -EINVAL; 3734baef267SMarkus Armbruster } 3744baef267SMarkus Armbruster 375c817c015SCarlos L. Torres errno = 0; 376717adf96SMarkus Armbruster *result = strtoul(nptr, &ep, base); 37747d4be12SPaolo Bonzini /* Windows returns 1 for negative out-of-range values. */ 37847d4be12SPaolo Bonzini if (errno == ERANGE) { 37947d4be12SPaolo Bonzini *result = -1; 38047d4be12SPaolo Bonzini } 3814baef267SMarkus Armbruster return check_strtox_error(nptr, ep, endptr, errno); 382c817c015SCarlos L. Torres } 383c817c015SCarlos L. Torres 384764e0fa4SCarlos L. Torres /** 3854295f879SMarkus Armbruster * Convert string @nptr to an int64_t. 3868ac4df40SCarlos L. Torres * 3874295f879SMarkus Armbruster * Works like qemu_strtol(), except it stores INT64_MAX on overflow, 3884295f879SMarkus Armbruster * and INT_MIN on underflow. 3898ac4df40SCarlos L. Torres */ 390b30d1886SMarkus Armbruster int qemu_strtoi64(const char *nptr, const char **endptr, int base, 3918ac4df40SCarlos L. Torres int64_t *result) 3928ac4df40SCarlos L. Torres { 393717adf96SMarkus Armbruster char *ep; 3944baef267SMarkus Armbruster 3958ac4df40SCarlos L. Torres if (!nptr) { 3968ac4df40SCarlos L. Torres if (endptr) { 3978ac4df40SCarlos L. Torres *endptr = nptr; 3988ac4df40SCarlos L. Torres } 3994baef267SMarkus Armbruster return -EINVAL; 4004baef267SMarkus Armbruster } 4014baef267SMarkus Armbruster 4028ac4df40SCarlos L. Torres errno = 0; 4034295f879SMarkus Armbruster /* FIXME This assumes int64_t is long long */ 404717adf96SMarkus Armbruster *result = strtoll(nptr, &ep, base); 4054baef267SMarkus Armbruster return check_strtox_error(nptr, ep, endptr, errno); 4068ac4df40SCarlos L. Torres } 4078ac4df40SCarlos L. Torres 4088ac4df40SCarlos L. Torres /** 4094295f879SMarkus Armbruster * Convert string @nptr to an uint64_t. 4103904e6bfSCarlos L. Torres * 4114295f879SMarkus Armbruster * Works like qemu_strtoul(), except it stores UINT64_MAX on overflow. 4123904e6bfSCarlos L. Torres */ 413b30d1886SMarkus Armbruster int qemu_strtou64(const char *nptr, const char **endptr, int base, 4143904e6bfSCarlos L. Torres uint64_t *result) 4153904e6bfSCarlos L. Torres { 416717adf96SMarkus Armbruster char *ep; 4174baef267SMarkus Armbruster 4183904e6bfSCarlos L. Torres if (!nptr) { 4193904e6bfSCarlos L. Torres if (endptr) { 4203904e6bfSCarlos L. Torres *endptr = nptr; 4213904e6bfSCarlos L. Torres } 4224baef267SMarkus Armbruster return -EINVAL; 4234baef267SMarkus Armbruster } 4244baef267SMarkus Armbruster 4253904e6bfSCarlos L. Torres errno = 0; 4264295f879SMarkus Armbruster /* FIXME This assumes uint64_t is unsigned long long */ 427717adf96SMarkus Armbruster *result = strtoull(nptr, &ep, base); 42847d4be12SPaolo Bonzini /* Windows returns 1 for negative out-of-range values. */ 42947d4be12SPaolo Bonzini if (errno == ERANGE) { 43047d4be12SPaolo Bonzini *result = -1; 43147d4be12SPaolo Bonzini } 4324baef267SMarkus Armbruster return check_strtox_error(nptr, ep, endptr, errno); 4333904e6bfSCarlos L. Torres } 4343904e6bfSCarlos L. Torres 4353904e6bfSCarlos L. Torres /** 436e3f9fe2dSEduardo Habkost * parse_uint: 437e3f9fe2dSEduardo Habkost * 438e3f9fe2dSEduardo Habkost * @s: String to parse 439e3f9fe2dSEduardo Habkost * @value: Destination for parsed integer value 440e3f9fe2dSEduardo Habkost * @endptr: Destination for pointer to first character not consumed 441e3f9fe2dSEduardo Habkost * @base: integer base, between 2 and 36 inclusive, or 0 442e3f9fe2dSEduardo Habkost * 443e3f9fe2dSEduardo Habkost * Parse unsigned integer 444e3f9fe2dSEduardo Habkost * 445e3f9fe2dSEduardo Habkost * Parsed syntax is like strtoull()'s: arbitrary whitespace, a single optional 446e3f9fe2dSEduardo Habkost * '+' or '-', an optional "0x" if @base is 0 or 16, one or more digits. 447e3f9fe2dSEduardo Habkost * 448e3f9fe2dSEduardo Habkost * If @s is null, or @base is invalid, or @s doesn't start with an 449e3f9fe2dSEduardo Habkost * integer in the syntax above, set *@value to 0, *@endptr to @s, and 450e3f9fe2dSEduardo Habkost * return -EINVAL. 451e3f9fe2dSEduardo Habkost * 452e3f9fe2dSEduardo Habkost * Set *@endptr to point right beyond the parsed integer (even if the integer 453e3f9fe2dSEduardo Habkost * overflows or is negative, all digits will be parsed and *@endptr will 454e3f9fe2dSEduardo Habkost * point right beyond them). 455e3f9fe2dSEduardo Habkost * 456e3f9fe2dSEduardo Habkost * If the integer is negative, set *@value to 0, and return -ERANGE. 457e3f9fe2dSEduardo Habkost * 458e3f9fe2dSEduardo Habkost * If the integer overflows unsigned long long, set *@value to 459e3f9fe2dSEduardo Habkost * ULLONG_MAX, and return -ERANGE. 460e3f9fe2dSEduardo Habkost * 461e3f9fe2dSEduardo Habkost * Else, set *@value to the parsed integer, and return 0. 462e3f9fe2dSEduardo Habkost */ 463e3f9fe2dSEduardo Habkost int parse_uint(const char *s, unsigned long long *value, char **endptr, 464e3f9fe2dSEduardo Habkost int base) 465e3f9fe2dSEduardo Habkost { 466e3f9fe2dSEduardo Habkost int r = 0; 467e3f9fe2dSEduardo Habkost char *endp = (char *)s; 468e3f9fe2dSEduardo Habkost unsigned long long val = 0; 469e3f9fe2dSEduardo Habkost 470e3f9fe2dSEduardo Habkost if (!s) { 471e3f9fe2dSEduardo Habkost r = -EINVAL; 472e3f9fe2dSEduardo Habkost goto out; 473e3f9fe2dSEduardo Habkost } 474e3f9fe2dSEduardo Habkost 475e3f9fe2dSEduardo Habkost errno = 0; 476e3f9fe2dSEduardo Habkost val = strtoull(s, &endp, base); 477e3f9fe2dSEduardo Habkost if (errno) { 478e3f9fe2dSEduardo Habkost r = -errno; 479e3f9fe2dSEduardo Habkost goto out; 480e3f9fe2dSEduardo Habkost } 481e3f9fe2dSEduardo Habkost 482e3f9fe2dSEduardo Habkost if (endp == s) { 483e3f9fe2dSEduardo Habkost r = -EINVAL; 484e3f9fe2dSEduardo Habkost goto out; 485e3f9fe2dSEduardo Habkost } 486e3f9fe2dSEduardo Habkost 487e3f9fe2dSEduardo Habkost /* make sure we reject negative numbers: */ 488e3f9fe2dSEduardo Habkost while (isspace((unsigned char)*s)) { 489e3f9fe2dSEduardo Habkost s++; 490e3f9fe2dSEduardo Habkost } 491e3f9fe2dSEduardo Habkost if (*s == '-') { 492e3f9fe2dSEduardo Habkost val = 0; 493e3f9fe2dSEduardo Habkost r = -ERANGE; 494e3f9fe2dSEduardo Habkost goto out; 495e3f9fe2dSEduardo Habkost } 496e3f9fe2dSEduardo Habkost 497e3f9fe2dSEduardo Habkost out: 498e3f9fe2dSEduardo Habkost *value = val; 499e3f9fe2dSEduardo Habkost *endptr = endp; 500e3f9fe2dSEduardo Habkost return r; 501e3f9fe2dSEduardo Habkost } 502e3f9fe2dSEduardo Habkost 503e3f9fe2dSEduardo Habkost /** 504e3f9fe2dSEduardo Habkost * parse_uint_full: 505e3f9fe2dSEduardo Habkost * 506e3f9fe2dSEduardo Habkost * @s: String to parse 507e3f9fe2dSEduardo Habkost * @value: Destination for parsed integer value 508e3f9fe2dSEduardo Habkost * @base: integer base, between 2 and 36 inclusive, or 0 509e3f9fe2dSEduardo Habkost * 510e3f9fe2dSEduardo Habkost * Parse unsigned integer from entire string 511e3f9fe2dSEduardo Habkost * 512e3f9fe2dSEduardo Habkost * Have the same behavior of parse_uint(), but with an additional check 513e3f9fe2dSEduardo Habkost * for additional data after the parsed number. If extra characters are present 514e3f9fe2dSEduardo Habkost * after the parsed number, the function will return -EINVAL, and *@v will 515e3f9fe2dSEduardo Habkost * be set to 0. 516e3f9fe2dSEduardo Habkost */ 517e3f9fe2dSEduardo Habkost int parse_uint_full(const char *s, unsigned long long *value, int base) 518e3f9fe2dSEduardo Habkost { 519e3f9fe2dSEduardo Habkost char *endp; 520e3f9fe2dSEduardo Habkost int r; 521e3f9fe2dSEduardo Habkost 522e3f9fe2dSEduardo Habkost r = parse_uint(s, value, &endp, base); 523e3f9fe2dSEduardo Habkost if (r < 0) { 524e3f9fe2dSEduardo Habkost return r; 525e3f9fe2dSEduardo Habkost } 526e3f9fe2dSEduardo Habkost if (*endp) { 527e3f9fe2dSEduardo Habkost *value = 0; 528e3f9fe2dSEduardo Habkost return -EINVAL; 529e3f9fe2dSEduardo Habkost } 530e3f9fe2dSEduardo Habkost 531e3f9fe2dSEduardo Habkost return 0; 532e3f9fe2dSEduardo Habkost } 533e3f9fe2dSEduardo Habkost 534baacf047SPaolo Bonzini int qemu_parse_fd(const char *param) 535baacf047SPaolo Bonzini { 536e9c5c1f4SLaszlo Ersek long fd; 537e9c5c1f4SLaszlo Ersek char *endptr; 538baacf047SPaolo Bonzini 539e9c5c1f4SLaszlo Ersek errno = 0; 540baacf047SPaolo Bonzini fd = strtol(param, &endptr, 10); 541e9c5c1f4SLaszlo Ersek if (param == endptr /* no conversion performed */ || 542e9c5c1f4SLaszlo Ersek errno != 0 /* not representable as long; possibly others */ || 543e9c5c1f4SLaszlo Ersek *endptr != '\0' /* final string not empty */ || 544e9c5c1f4SLaszlo Ersek fd < 0 /* invalid as file descriptor */ || 545e9c5c1f4SLaszlo Ersek fd > INT_MAX /* not representable as int */) { 546baacf047SPaolo Bonzini return -1; 547baacf047SPaolo Bonzini } 548baacf047SPaolo Bonzini return fd; 549baacf047SPaolo Bonzini } 550baacf047SPaolo Bonzini 551baacf047SPaolo Bonzini /* 552baacf047SPaolo Bonzini * Implementation of ULEB128 (http://en.wikipedia.org/wiki/LEB128) 553baacf047SPaolo Bonzini * Input is limited to 14-bit numbers 554baacf047SPaolo Bonzini */ 555baacf047SPaolo Bonzini int uleb128_encode_small(uint8_t *out, uint32_t n) 556baacf047SPaolo Bonzini { 557baacf047SPaolo Bonzini g_assert(n <= 0x3fff); 558baacf047SPaolo Bonzini if (n < 0x80) { 559baacf047SPaolo Bonzini *out++ = n; 560baacf047SPaolo Bonzini return 1; 561baacf047SPaolo Bonzini } else { 562baacf047SPaolo Bonzini *out++ = (n & 0x7f) | 0x80; 563baacf047SPaolo Bonzini *out++ = n >> 7; 564baacf047SPaolo Bonzini return 2; 565baacf047SPaolo Bonzini } 566baacf047SPaolo Bonzini } 567baacf047SPaolo Bonzini 568baacf047SPaolo Bonzini int uleb128_decode_small(const uint8_t *in, uint32_t *n) 569baacf047SPaolo Bonzini { 570baacf047SPaolo Bonzini if (!(*in & 0x80)) { 571baacf047SPaolo Bonzini *n = *in++; 572baacf047SPaolo Bonzini return 1; 573baacf047SPaolo Bonzini } else { 574baacf047SPaolo Bonzini *n = *in++ & 0x7f; 575baacf047SPaolo Bonzini /* we exceed 14 bit number */ 576baacf047SPaolo Bonzini if (*in & 0x80) { 577baacf047SPaolo Bonzini return -1; 578baacf047SPaolo Bonzini } 579baacf047SPaolo Bonzini *n |= *in++ << 7; 580baacf047SPaolo Bonzini return 2; 581baacf047SPaolo Bonzini } 582baacf047SPaolo Bonzini } 583b16352acSAlon Levy 584b16352acSAlon Levy /* 585b16352acSAlon Levy * helper to parse debug environment variables 586b16352acSAlon Levy */ 587b16352acSAlon Levy int parse_debug_env(const char *name, int max, int initial) 588b16352acSAlon Levy { 589b16352acSAlon Levy char *debug_env = getenv(name); 590b16352acSAlon Levy char *inv = NULL; 591cc5d0e04SPaolo Bonzini long debug; 592b16352acSAlon Levy 593b16352acSAlon Levy if (!debug_env) { 594b16352acSAlon Levy return initial; 595b16352acSAlon Levy } 596cc5d0e04SPaolo Bonzini errno = 0; 597b16352acSAlon Levy debug = strtol(debug_env, &inv, 10); 598b16352acSAlon Levy if (inv == debug_env) { 599b16352acSAlon Levy return initial; 600b16352acSAlon Levy } 601cc5d0e04SPaolo Bonzini if (debug < 0 || debug > max || errno != 0) { 602b16352acSAlon Levy fprintf(stderr, "warning: %s not in [0, %d]", name, max); 603b16352acSAlon Levy return initial; 604b16352acSAlon Levy } 605b16352acSAlon Levy return debug; 606b16352acSAlon Levy } 6074297c8eeSAlexey Kardashevskiy 6084297c8eeSAlexey Kardashevskiy /* 6094297c8eeSAlexey Kardashevskiy * Helper to print ethernet mac address 6104297c8eeSAlexey Kardashevskiy */ 6114297c8eeSAlexey Kardashevskiy const char *qemu_ether_ntoa(const MACAddr *mac) 6124297c8eeSAlexey Kardashevskiy { 6134297c8eeSAlexey Kardashevskiy static char ret[18]; 6144297c8eeSAlexey Kardashevskiy 6154297c8eeSAlexey Kardashevskiy snprintf(ret, sizeof(ret), "%02x:%02x:%02x:%02x:%02x:%02x", 6164297c8eeSAlexey Kardashevskiy mac->a[0], mac->a[1], mac->a[2], mac->a[3], mac->a[4], mac->a[5]); 6174297c8eeSAlexey Kardashevskiy 6184297c8eeSAlexey Kardashevskiy return ret; 6194297c8eeSAlexey Kardashevskiy } 620