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 */ 24856dfd8aSMarkus Armbruster 25aafd7584SPeter Maydell #include "qemu/osdep.h" 26baacf047SPaolo Bonzini #include "qemu/host-utils.h" 27baacf047SPaolo Bonzini #include <math.h> 28baacf047SPaolo Bonzini 2906680b15SMarc-André Lureau #ifdef __FreeBSD__ 3006680b15SMarc-André Lureau #include <sys/sysctl.h> 3106680b15SMarc-André Lureau #include <sys/user.h> 3206680b15SMarc-André Lureau #endif 3306680b15SMarc-André Lureau 3406680b15SMarc-André Lureau #ifdef __NetBSD__ 3506680b15SMarc-André Lureau #include <sys/sysctl.h> 3606680b15SMarc-André Lureau #endif 3706680b15SMarc-André Lureau 380a979a13SThomas Huth #ifdef __HAIKU__ 390a979a13SThomas Huth #include <kernel/image.h> 400a979a13SThomas Huth #endif 410a979a13SThomas Huth 424311682eSPhilippe Mathieu-Daudé #ifdef __APPLE__ 434311682eSPhilippe Mathieu-Daudé #include <mach-o/dyld.h> 444311682eSPhilippe Mathieu-Daudé #endif 454311682eSPhilippe Mathieu-Daudé 46cf60ccc3SAkihiko Odaki #ifdef G_OS_WIN32 47cf60ccc3SAkihiko Odaki #include <pathcch.h> 48cf60ccc3SAkihiko Odaki #include <wchar.h> 49cf60ccc3SAkihiko Odaki #endif 50cf60ccc3SAkihiko Odaki 51856dfd8aSMarkus Armbruster #include "qemu/ctype.h" 52f348b6d1SVeronia Bahaa #include "qemu/cutils.h" 5305cb8ed5SAlistair Francis #include "qemu/error-report.h" 54baacf047SPaolo Bonzini 55baacf047SPaolo Bonzini void strpadcpy(char *buf, int buf_size, const char *str, char pad) 56baacf047SPaolo Bonzini { 57baacf047SPaolo Bonzini int len = qemu_strnlen(str, buf_size); 58baacf047SPaolo Bonzini memcpy(buf, str, len); 59baacf047SPaolo Bonzini memset(buf + len, pad, buf_size - len); 60baacf047SPaolo Bonzini } 61baacf047SPaolo Bonzini 62baacf047SPaolo Bonzini void pstrcpy(char *buf, int buf_size, const char *str) 63baacf047SPaolo Bonzini { 64baacf047SPaolo Bonzini int c; 65baacf047SPaolo Bonzini char *q = buf; 66baacf047SPaolo Bonzini 67baacf047SPaolo Bonzini if (buf_size <= 0) 68baacf047SPaolo Bonzini return; 69baacf047SPaolo Bonzini 70baacf047SPaolo Bonzini for(;;) { 71baacf047SPaolo Bonzini c = *str++; 72baacf047SPaolo Bonzini if (c == 0 || q >= buf + buf_size - 1) 73baacf047SPaolo Bonzini break; 74baacf047SPaolo Bonzini *q++ = c; 75baacf047SPaolo Bonzini } 76baacf047SPaolo Bonzini *q = '\0'; 77baacf047SPaolo Bonzini } 78baacf047SPaolo Bonzini 79baacf047SPaolo Bonzini /* strcat and truncate. */ 80baacf047SPaolo Bonzini char *pstrcat(char *buf, int buf_size, const char *s) 81baacf047SPaolo Bonzini { 82baacf047SPaolo Bonzini int len; 83baacf047SPaolo Bonzini len = strlen(buf); 84baacf047SPaolo Bonzini if (len < buf_size) 85baacf047SPaolo Bonzini pstrcpy(buf + len, buf_size - len, s); 86baacf047SPaolo Bonzini return buf; 87baacf047SPaolo Bonzini } 88baacf047SPaolo Bonzini 89baacf047SPaolo Bonzini int strstart(const char *str, const char *val, const char **ptr) 90baacf047SPaolo Bonzini { 91baacf047SPaolo Bonzini const char *p, *q; 92baacf047SPaolo Bonzini p = str; 93baacf047SPaolo Bonzini q = val; 94baacf047SPaolo Bonzini while (*q != '\0') { 95baacf047SPaolo Bonzini if (*p != *q) 96baacf047SPaolo Bonzini return 0; 97baacf047SPaolo Bonzini p++; 98baacf047SPaolo Bonzini q++; 99baacf047SPaolo Bonzini } 100baacf047SPaolo Bonzini if (ptr) 101baacf047SPaolo Bonzini *ptr = p; 102baacf047SPaolo Bonzini return 1; 103baacf047SPaolo Bonzini } 104baacf047SPaolo Bonzini 105baacf047SPaolo Bonzini int stristart(const char *str, const char *val, const char **ptr) 106baacf047SPaolo Bonzini { 107baacf047SPaolo Bonzini const char *p, *q; 108baacf047SPaolo Bonzini p = str; 109baacf047SPaolo Bonzini q = val; 110baacf047SPaolo Bonzini while (*q != '\0') { 111baacf047SPaolo Bonzini if (qemu_toupper(*p) != qemu_toupper(*q)) 112baacf047SPaolo Bonzini return 0; 113baacf047SPaolo Bonzini p++; 114baacf047SPaolo Bonzini q++; 115baacf047SPaolo Bonzini } 116baacf047SPaolo Bonzini if (ptr) 117baacf047SPaolo Bonzini *ptr = p; 118baacf047SPaolo Bonzini return 1; 119baacf047SPaolo Bonzini } 120baacf047SPaolo Bonzini 121baacf047SPaolo Bonzini /* XXX: use host strnlen if available ? */ 122baacf047SPaolo Bonzini int qemu_strnlen(const char *s, int max_len) 123baacf047SPaolo Bonzini { 124baacf047SPaolo Bonzini int i; 125baacf047SPaolo Bonzini 126baacf047SPaolo Bonzini for(i = 0; i < max_len; i++) { 127baacf047SPaolo Bonzini if (s[i] == '\0') { 128baacf047SPaolo Bonzini break; 129baacf047SPaolo Bonzini } 130baacf047SPaolo Bonzini } 131baacf047SPaolo Bonzini return i; 132baacf047SPaolo Bonzini } 133baacf047SPaolo Bonzini 134a38ed811SKevin Wolf char *qemu_strsep(char **input, const char *delim) 135a38ed811SKevin Wolf { 136a38ed811SKevin Wolf char *result = *input; 137a38ed811SKevin Wolf if (result != NULL) { 138a38ed811SKevin Wolf char *p; 139a38ed811SKevin Wolf 140a38ed811SKevin Wolf for (p = result; *p != '\0'; p++) { 141a38ed811SKevin Wolf if (strchr(delim, *p)) { 142a38ed811SKevin Wolf break; 143a38ed811SKevin Wolf } 144a38ed811SKevin Wolf } 145a38ed811SKevin Wolf if (*p == '\0') { 146a38ed811SKevin Wolf *input = NULL; 147a38ed811SKevin Wolf } else { 148a38ed811SKevin Wolf *p = '\0'; 149a38ed811SKevin Wolf *input = p + 1; 150a38ed811SKevin Wolf } 151a38ed811SKevin Wolf } 152a38ed811SKevin Wolf return result; 153a38ed811SKevin Wolf } 154a38ed811SKevin Wolf 155baacf047SPaolo Bonzini time_t mktimegm(struct tm *tm) 156baacf047SPaolo Bonzini { 157baacf047SPaolo Bonzini time_t t; 158baacf047SPaolo Bonzini int y = tm->tm_year + 1900, m = tm->tm_mon + 1, d = tm->tm_mday; 159baacf047SPaolo Bonzini if (m < 3) { 160baacf047SPaolo Bonzini m += 12; 161baacf047SPaolo Bonzini y--; 162baacf047SPaolo Bonzini } 163baacf047SPaolo Bonzini t = 86400ULL * (d + (153 * m - 457) / 5 + 365 * y + y / 4 - y / 100 + 164baacf047SPaolo Bonzini y / 400 - 719469); 165baacf047SPaolo Bonzini t += 3600 * tm->tm_hour + 60 * tm->tm_min + tm->tm_sec; 166baacf047SPaolo Bonzini return t; 167baacf047SPaolo Bonzini } 168baacf047SPaolo Bonzini 169baacf047SPaolo Bonzini static int64_t suffix_mul(char suffix, int64_t unit) 170baacf047SPaolo Bonzini { 171baacf047SPaolo Bonzini switch (qemu_toupper(suffix)) { 17217f94256SMarkus Armbruster case 'B': 173baacf047SPaolo Bonzini return 1; 17417f94256SMarkus Armbruster case 'K': 175baacf047SPaolo Bonzini return unit; 17617f94256SMarkus Armbruster case 'M': 177baacf047SPaolo Bonzini return unit * unit; 17817f94256SMarkus Armbruster case 'G': 179baacf047SPaolo Bonzini return unit * unit * unit; 18017f94256SMarkus Armbruster case 'T': 181baacf047SPaolo Bonzini return unit * unit * unit * unit; 18217f94256SMarkus Armbruster case 'P': 1835e00984aSKevin Wolf return unit * unit * unit * unit * unit; 18417f94256SMarkus Armbruster case 'E': 1855e00984aSKevin Wolf return unit * unit * unit * unit * unit * unit; 186baacf047SPaolo Bonzini } 187baacf047SPaolo Bonzini return -1; 188baacf047SPaolo Bonzini } 189baacf047SPaolo Bonzini 190baacf047SPaolo Bonzini /* 191cf923b78SEric Blake * Convert size string to bytes. 192cf923b78SEric Blake * 193cf923b78SEric Blake * The size parsing supports the following syntaxes 194cf923b78SEric Blake * - 12345 - decimal, scale determined by @default_suffix and @unit 195cf923b78SEric Blake * - 12345{bBkKmMgGtTpPeE} - decimal, scale determined by suffix and @unit 196cf923b78SEric Blake * - 12345.678{kKmMgGtTpPeE} - decimal, scale determined by suffix, and 197cf923b78SEric Blake * fractional portion is truncated to byte 198cf923b78SEric Blake * - 0x7fEE - hexadecimal, unit determined by @default_suffix 199cf923b78SEric Blake * 200cf923b78SEric Blake * The following are intentionally not supported 2018b902e3dSPaolo Bonzini * - hex with scaling suffix, such as 0x20M 202cf923b78SEric Blake * - octal, such as 08 203cf923b78SEric Blake * - fractional hex, such as 0x1.8 204b87ac966SEric Blake * - negative values, including -0 205cf923b78SEric Blake * - floating point exponents, such as 1e3 206cf923b78SEric Blake * 207cf923b78SEric Blake * The end pointer will be returned in *end, if not NULL. If there is 208cf923b78SEric Blake * no fraction, the input can be decimal or hexadecimal; if there is a 209896fbd90SEric Blake * non-zero fraction, then the input must be decimal and there must be 210896fbd90SEric Blake * a suffix (possibly by @default_suffix) larger than Byte, and the 211896fbd90SEric Blake * fractional portion may suffer from precision loss or rounding. The 212896fbd90SEric Blake * input must be positive. 213cf923b78SEric Blake * 214cf923b78SEric Blake * Return -ERANGE on overflow (with *@end advanced), and -EINVAL on 215896fbd90SEric Blake * other error (with *@end at @nptr). Unlike strtoull, *@result is 216896fbd90SEric Blake * set to 0 on all errors, as returning UINT64_MAX on overflow is less 217896fbd90SEric Blake * likely to be usable as a size. 218baacf047SPaolo Bonzini */ 219af02f4c5SDavid Hildenbrand static int do_strtosz(const char *nptr, const char **end, 220f17fd4fdSMarkus Armbruster const char default_suffix, int64_t unit, 221f46bfdbfSMarkus Armbruster uint64_t *result) 222baacf047SPaolo Bonzini { 223f17fd4fdSMarkus Armbruster int retval; 224cf923b78SEric Blake const char *endptr, *f; 225baacf047SPaolo Bonzini unsigned char c; 2267625a1edSRichard Henderson uint64_t val, valf = 0; 227cf923b78SEric Blake int64_t mul; 228baacf047SPaolo Bonzini 229cf923b78SEric Blake /* Parse integral portion as decimal. */ 230b87ac966SEric Blake retval = parse_uint(nptr, &endptr, 10, &val); 231af02f4c5SDavid Hildenbrand if (retval) { 2324fcdf65aSMarkus Armbruster goto out; 233baacf047SPaolo Bonzini } 234cf923b78SEric Blake if (val == 0 && (*endptr == 'x' || *endptr == 'X')) { 2358b902e3dSPaolo Bonzini /* Input looks like hex; reparse, and insist on no fraction or suffix. */ 236cf923b78SEric Blake retval = qemu_strtou64(nptr, &endptr, 16, &val); 237cf923b78SEric Blake if (retval) { 238cf923b78SEric Blake goto out; 239cf923b78SEric Blake } 2408b902e3dSPaolo Bonzini if (*endptr == '.' || suffix_mul(*endptr, unit) > 0) { 241cf923b78SEric Blake endptr = nptr; 242cf923b78SEric Blake retval = -EINVAL; 243cf923b78SEric Blake goto out; 244cf923b78SEric Blake } 245cf923b78SEric Blake } else if (*endptr == '.') { 246f46bfdbfSMarkus Armbruster /* 247cf923b78SEric Blake * Input looks like a fraction. Make sure even 1.k works 248cf923b78SEric Blake * without fractional digits. If we see an exponent, treat 249cf923b78SEric Blake * the entire input as invalid instead. 250f46bfdbfSMarkus Armbruster */ 2517625a1edSRichard Henderson double fraction; 2527625a1edSRichard Henderson 253cf923b78SEric Blake f = endptr; 254cf923b78SEric Blake retval = qemu_strtod_finite(f, &endptr, &fraction); 255cf923b78SEric Blake if (retval) { 256cf923b78SEric Blake endptr++; 257cf923b78SEric Blake } else if (memchr(f, 'e', endptr - f) || memchr(f, 'E', endptr - f)) { 258cf923b78SEric Blake endptr = nptr; 259cf923b78SEric Blake retval = -EINVAL; 260cf923b78SEric Blake goto out; 2617625a1edSRichard Henderson } else { 2627625a1edSRichard Henderson /* Extract into a 64-bit fixed-point fraction. */ 2637625a1edSRichard Henderson valf = (uint64_t)(fraction * 0x1p64); 264cf923b78SEric Blake } 265cf923b78SEric Blake } 266cf923b78SEric Blake c = *endptr; 267cf923b78SEric Blake mul = suffix_mul(c, unit); 268cf923b78SEric Blake if (mul > 0) { 269cf923b78SEric Blake endptr++; 270cf923b78SEric Blake } else { 271cf923b78SEric Blake mul = suffix_mul(default_suffix, unit); 272cf923b78SEric Blake assert(mul > 0); 273cf923b78SEric Blake } 2747625a1edSRichard Henderson if (mul == 1) { 2757625a1edSRichard Henderson /* When a fraction is present, a scale is required. */ 2767625a1edSRichard Henderson if (valf != 0) { 277cf923b78SEric Blake endptr = nptr; 278cf923b78SEric Blake retval = -EINVAL; 279cf923b78SEric Blake goto out; 280cf923b78SEric Blake } 2817625a1edSRichard Henderson } else { 2827625a1edSRichard Henderson uint64_t valh, tmp; 2837625a1edSRichard Henderson 2847625a1edSRichard Henderson /* Compute exact result: 64.64 x 64.0 -> 128.64 fixed point */ 2857625a1edSRichard Henderson mulu64(&val, &valh, val, mul); 2867625a1edSRichard Henderson mulu64(&valf, &tmp, valf, mul); 2877625a1edSRichard Henderson val += tmp; 2887625a1edSRichard Henderson valh += val < tmp; 2897625a1edSRichard Henderson 2907625a1edSRichard Henderson /* Round 0.5 upward. */ 2917625a1edSRichard Henderson tmp = valf >> 63; 2927625a1edSRichard Henderson val += tmp; 2937625a1edSRichard Henderson valh += val < tmp; 2947625a1edSRichard Henderson 2957625a1edSRichard Henderson /* Report overflow. */ 2967625a1edSRichard Henderson if (valh != 0) { 297baacf047SPaolo Bonzini retval = -ERANGE; 2984fcdf65aSMarkus Armbruster goto out; 299baacf047SPaolo Bonzini } 3007625a1edSRichard Henderson } 3017625a1edSRichard Henderson 302f17fd4fdSMarkus Armbruster retval = 0; 303baacf047SPaolo Bonzini 3044fcdf65aSMarkus Armbruster out: 305baacf047SPaolo Bonzini if (end) { 306baacf047SPaolo Bonzini *end = endptr; 307f49371ecSEric Blake } else if (nptr && *endptr) { 3084fcdf65aSMarkus Armbruster retval = -EINVAL; 309baacf047SPaolo Bonzini } 310061d7909SEric Blake if (retval == 0) { 311061d7909SEric Blake *result = val; 312896fbd90SEric Blake } else { 313896fbd90SEric Blake *result = 0; 314896fbd90SEric Blake if (end && retval == -EINVAL) { 315896fbd90SEric Blake *end = nptr; 316896fbd90SEric Blake } 317061d7909SEric Blake } 318baacf047SPaolo Bonzini 319baacf047SPaolo Bonzini return retval; 320baacf047SPaolo Bonzini } 321baacf047SPaolo Bonzini 322af02f4c5SDavid Hildenbrand int qemu_strtosz(const char *nptr, const char **end, uint64_t *result) 323baacf047SPaolo Bonzini { 324f17fd4fdSMarkus Armbruster return do_strtosz(nptr, end, 'B', 1024, result); 325baacf047SPaolo Bonzini } 326baacf047SPaolo Bonzini 327af02f4c5SDavid Hildenbrand int qemu_strtosz_MiB(const char *nptr, const char **end, uint64_t *result) 328baacf047SPaolo Bonzini { 329f17fd4fdSMarkus Armbruster return do_strtosz(nptr, end, 'M', 1024, result); 330baacf047SPaolo Bonzini } 331baacf047SPaolo Bonzini 332af02f4c5SDavid Hildenbrand int qemu_strtosz_metric(const char *nptr, const char **end, uint64_t *result) 333d2734d26SMarkus Armbruster { 334f17fd4fdSMarkus Armbruster return do_strtosz(nptr, end, 'B', 1000, result); 335d2734d26SMarkus Armbruster } 336d2734d26SMarkus Armbruster 337e3f9fe2dSEduardo Habkost /** 338717adf96SMarkus Armbruster * Helper function for error checking after strtol() and the like 339764e0fa4SCarlos L. Torres */ 340717adf96SMarkus Armbruster static int check_strtox_error(const char *nptr, char *ep, 3416162f7daSEric Blake const char **endptr, bool check_zero, 3426162f7daSEric Blake int libc_errno) 343764e0fa4SCarlos L. Torres { 34453a90b97SEric Blake assert(ep >= nptr); 3456162f7daSEric Blake 3466162f7daSEric Blake /* Windows has a bug in that it fails to parse 0 from "0x" in base 16 */ 3476162f7daSEric Blake if (check_zero && ep == nptr && libc_errno == 0) { 3486162f7daSEric Blake char *tmp; 3496162f7daSEric Blake 3506162f7daSEric Blake errno = 0; 3516162f7daSEric Blake if (strtol(nptr, &tmp, 10) == 0 && errno == 0 && 3526162f7daSEric Blake (*tmp == 'x' || *tmp == 'X')) { 3536162f7daSEric Blake ep = tmp; 3546162f7daSEric Blake } 3556162f7daSEric Blake } 3566162f7daSEric Blake 357717adf96SMarkus Armbruster if (endptr) { 358717adf96SMarkus Armbruster *endptr = ep; 359764e0fa4SCarlos L. Torres } 3604baef267SMarkus Armbruster 3614baef267SMarkus Armbruster /* Turn "no conversion" into an error */ 3624baef267SMarkus Armbruster if (libc_errno == 0 && ep == nptr) { 3634baef267SMarkus Armbruster return -EINVAL; 3644baef267SMarkus Armbruster } 3654baef267SMarkus Armbruster 3664baef267SMarkus Armbruster /* Fail when we're expected to consume the string, but didn't */ 3674baef267SMarkus Armbruster if (!endptr && *ep) { 3684baef267SMarkus Armbruster return -EINVAL; 3694baef267SMarkus Armbruster } 3704baef267SMarkus Armbruster 371717adf96SMarkus Armbruster return -libc_errno; 372764e0fa4SCarlos L. Torres } 373764e0fa4SCarlos L. Torres 374764e0fa4SCarlos L. Torres /** 375473a2a33SDaniel P. Berrange * Convert string @nptr to an integer, and store it in @result. 376473a2a33SDaniel P. Berrange * 377473a2a33SDaniel P. Berrange * This is a wrapper around strtol() that is harder to misuse. 378473a2a33SDaniel P. Berrange * Semantics of @nptr, @endptr, @base match strtol() with differences 379473a2a33SDaniel P. Berrange * noted below. 380473a2a33SDaniel P. Berrange * 381473a2a33SDaniel P. Berrange * @nptr may be null, and no conversion is performed then. 382473a2a33SDaniel P. Berrange * 3833c5f2467SEric Blake * If no conversion is performed, store @nptr in *@endptr, 0 in 3843c5f2467SEric Blake * @result, and return -EINVAL. 385473a2a33SDaniel P. Berrange * 386473a2a33SDaniel P. Berrange * If @endptr is null, and the string isn't fully converted, return 3873c5f2467SEric Blake * -EINVAL with @result set to the parsed value. This is the case 3883c5f2467SEric Blake * when the pointer that would be stored in a non-null @endptr points 3893c5f2467SEric Blake * to a character other than '\0'. 390473a2a33SDaniel P. Berrange * 391473a2a33SDaniel P. Berrange * If the conversion overflows @result, store INT_MAX in @result, 392473a2a33SDaniel P. Berrange * and return -ERANGE. 393473a2a33SDaniel P. Berrange * 394473a2a33SDaniel P. Berrange * If the conversion underflows @result, store INT_MIN in @result, 395473a2a33SDaniel P. Berrange * and return -ERANGE. 396473a2a33SDaniel P. Berrange * 397473a2a33SDaniel P. Berrange * Else store the converted value in @result, and return zero. 39856ddafdeSEric Blake * 39956ddafdeSEric Blake * This matches the behavior of strtol() on 32-bit platforms, even on 40056ddafdeSEric Blake * platforms where long is 64-bits. 401473a2a33SDaniel P. Berrange */ 402473a2a33SDaniel P. Berrange int qemu_strtoi(const char *nptr, const char **endptr, int base, 403473a2a33SDaniel P. Berrange int *result) 404473a2a33SDaniel P. Berrange { 405473a2a33SDaniel P. Berrange char *ep; 406473a2a33SDaniel P. Berrange long long lresult; 407473a2a33SDaniel P. Berrange 40853a90b97SEric Blake assert((unsigned) base <= 36 && base != 1); 409473a2a33SDaniel P. Berrange if (!nptr) { 4103c5f2467SEric Blake *result = 0; 411473a2a33SDaniel P. Berrange if (endptr) { 412473a2a33SDaniel P. Berrange *endptr = nptr; 413473a2a33SDaniel P. Berrange } 414473a2a33SDaniel P. Berrange return -EINVAL; 415473a2a33SDaniel P. Berrange } 416473a2a33SDaniel P. Berrange 417473a2a33SDaniel P. Berrange errno = 0; 418473a2a33SDaniel P. Berrange lresult = strtoll(nptr, &ep, base); 419473a2a33SDaniel P. Berrange if (lresult < INT_MIN) { 420473a2a33SDaniel P. Berrange *result = INT_MIN; 421473a2a33SDaniel P. Berrange errno = ERANGE; 422473a2a33SDaniel P. Berrange } else if (lresult > INT_MAX) { 423473a2a33SDaniel P. Berrange *result = INT_MAX; 424473a2a33SDaniel P. Berrange errno = ERANGE; 425473a2a33SDaniel P. Berrange } else { 426473a2a33SDaniel P. Berrange *result = lresult; 427473a2a33SDaniel P. Berrange } 4286162f7daSEric Blake return check_strtox_error(nptr, ep, endptr, lresult == 0, errno); 429473a2a33SDaniel P. Berrange } 430473a2a33SDaniel P. Berrange 431473a2a33SDaniel P. Berrange /** 432473a2a33SDaniel P. Berrange * Convert string @nptr to an unsigned integer, and store it in @result. 433473a2a33SDaniel P. Berrange * 434473a2a33SDaniel P. Berrange * This is a wrapper around strtoul() that is harder to misuse. 435473a2a33SDaniel P. Berrange * Semantics of @nptr, @endptr, @base match strtoul() with differences 436473a2a33SDaniel P. Berrange * noted below. 437473a2a33SDaniel P. Berrange * 438473a2a33SDaniel P. Berrange * @nptr may be null, and no conversion is performed then. 439473a2a33SDaniel P. Berrange * 4403c5f2467SEric Blake * If no conversion is performed, store @nptr in *@endptr, 0 in 4413c5f2467SEric Blake * @result, and return -EINVAL. 442473a2a33SDaniel P. Berrange * 443473a2a33SDaniel P. Berrange * If @endptr is null, and the string isn't fully converted, return 4443c5f2467SEric Blake * -EINVAL with @result set to the parsed value. This is the case 4453c5f2467SEric Blake * when the pointer that would be stored in a non-null @endptr points 4463c5f2467SEric Blake * to a character other than '\0'. 447473a2a33SDaniel P. Berrange * 448473a2a33SDaniel P. Berrange * If the conversion overflows @result, store UINT_MAX in @result, 449473a2a33SDaniel P. Berrange * and return -ERANGE. 450473a2a33SDaniel P. Berrange * 451473a2a33SDaniel P. Berrange * Else store the converted value in @result, and return zero. 452473a2a33SDaniel P. Berrange * 453473a2a33SDaniel P. Berrange * Note that a number with a leading minus sign gets converted without 454473a2a33SDaniel P. Berrange * the minus sign, checked for overflow (see above), then negated (in 45556ddafdeSEric Blake * @result's type). This matches the behavior of strtoul() on 32-bit 45656ddafdeSEric Blake * platforms, even on platforms where long is 64-bits. 457473a2a33SDaniel P. Berrange */ 458473a2a33SDaniel P. Berrange int qemu_strtoui(const char *nptr, const char **endptr, int base, 459473a2a33SDaniel P. Berrange unsigned int *result) 460473a2a33SDaniel P. Berrange { 461473a2a33SDaniel P. Berrange char *ep; 46256ddafdeSEric Blake unsigned long long lresult; 46356ddafdeSEric Blake bool neg; 464473a2a33SDaniel P. Berrange 46553a90b97SEric Blake assert((unsigned) base <= 36 && base != 1); 466473a2a33SDaniel P. Berrange if (!nptr) { 4673c5f2467SEric Blake *result = 0; 468473a2a33SDaniel P. Berrange if (endptr) { 469473a2a33SDaniel P. Berrange *endptr = nptr; 470473a2a33SDaniel P. Berrange } 471473a2a33SDaniel P. Berrange return -EINVAL; 472473a2a33SDaniel P. Berrange } 473473a2a33SDaniel P. Berrange 474473a2a33SDaniel P. Berrange errno = 0; 475473a2a33SDaniel P. Berrange lresult = strtoull(nptr, &ep, base); 476473a2a33SDaniel P. Berrange 477473a2a33SDaniel P. Berrange /* Windows returns 1 for negative out-of-range values. */ 478473a2a33SDaniel P. Berrange if (errno == ERANGE) { 479473a2a33SDaniel P. Berrange *result = -1; 480473a2a33SDaniel P. Berrange } else { 48156ddafdeSEric Blake /* 48256ddafdeSEric Blake * Note that platforms with 32-bit strtoul only accept input 48356ddafdeSEric Blake * in the range [-4294967295, 4294967295]; but we used 64-bit 48456ddafdeSEric Blake * strtoull which wraps -18446744073709551615 to 1 instead of 48556ddafdeSEric Blake * declaring overflow. So we must check if '-' was parsed, 48656ddafdeSEric Blake * and if so, undo the negation before doing our bounds check. 48756ddafdeSEric Blake */ 48856ddafdeSEric Blake neg = memchr(nptr, '-', ep - nptr) != NULL; 48956ddafdeSEric Blake if (neg) { 49056ddafdeSEric Blake lresult = -lresult; 49156ddafdeSEric Blake } 492473a2a33SDaniel P. Berrange if (lresult > UINT_MAX) { 493473a2a33SDaniel P. Berrange *result = UINT_MAX; 494473a2a33SDaniel P. Berrange errno = ERANGE; 495473a2a33SDaniel P. Berrange } else { 49656ddafdeSEric Blake *result = neg ? -lresult : lresult; 497473a2a33SDaniel P. Berrange } 498473a2a33SDaniel P. Berrange } 4996162f7daSEric Blake return check_strtox_error(nptr, ep, endptr, lresult == 0, errno); 500473a2a33SDaniel P. Berrange } 501473a2a33SDaniel P. Berrange 502473a2a33SDaniel P. Berrange /** 5034295f879SMarkus Armbruster * Convert string @nptr to a long integer, and store it in @result. 504764e0fa4SCarlos L. Torres * 5054295f879SMarkus Armbruster * This is a wrapper around strtol() that is harder to misuse. 5064295f879SMarkus Armbruster * Semantics of @nptr, @endptr, @base match strtol() with differences 5074295f879SMarkus Armbruster * noted below. 508764e0fa4SCarlos L. Torres * 5094295f879SMarkus Armbruster * @nptr may be null, and no conversion is performed then. 510764e0fa4SCarlos L. Torres * 5113c5f2467SEric Blake * If no conversion is performed, store @nptr in *@endptr, 0 in 5123c5f2467SEric Blake * @result, and return -EINVAL. 513764e0fa4SCarlos L. Torres * 5144295f879SMarkus Armbruster * If @endptr is null, and the string isn't fully converted, return 5153c5f2467SEric Blake * -EINVAL with @result set to the parsed value. This is the case 5163c5f2467SEric Blake * when the pointer that would be stored in a non-null @endptr points 5173c5f2467SEric Blake * to a character other than '\0'. 5184295f879SMarkus Armbruster * 5194295f879SMarkus Armbruster * If the conversion overflows @result, store LONG_MAX in @result, 5204295f879SMarkus Armbruster * and return -ERANGE. 5214295f879SMarkus Armbruster * 5224295f879SMarkus Armbruster * If the conversion underflows @result, store LONG_MIN in @result, 5234295f879SMarkus Armbruster * and return -ERANGE. 5244295f879SMarkus Armbruster * 5254295f879SMarkus Armbruster * Else store the converted value in @result, and return zero. 526764e0fa4SCarlos L. Torres */ 527764e0fa4SCarlos L. Torres int qemu_strtol(const char *nptr, const char **endptr, int base, 528764e0fa4SCarlos L. Torres long *result) 529764e0fa4SCarlos L. Torres { 530717adf96SMarkus Armbruster char *ep; 5314baef267SMarkus Armbruster 53253a90b97SEric Blake assert((unsigned) base <= 36 && base != 1); 533764e0fa4SCarlos L. Torres if (!nptr) { 5343c5f2467SEric Blake *result = 0; 535764e0fa4SCarlos L. Torres if (endptr) { 536764e0fa4SCarlos L. Torres *endptr = nptr; 537764e0fa4SCarlos L. Torres } 5384baef267SMarkus Armbruster return -EINVAL; 5394baef267SMarkus Armbruster } 5404baef267SMarkus Armbruster 541764e0fa4SCarlos L. Torres errno = 0; 542717adf96SMarkus Armbruster *result = strtol(nptr, &ep, base); 5436162f7daSEric Blake return check_strtox_error(nptr, ep, endptr, *result == 0, errno); 544764e0fa4SCarlos L. Torres } 545c817c015SCarlos L. Torres 546c817c015SCarlos L. Torres /** 5474295f879SMarkus Armbruster * Convert string @nptr to an unsigned long, and store it in @result. 548c817c015SCarlos L. Torres * 5494295f879SMarkus Armbruster * This is a wrapper around strtoul() that is harder to misuse. 5504295f879SMarkus Armbruster * Semantics of @nptr, @endptr, @base match strtoul() with differences 5514295f879SMarkus Armbruster * noted below. 552c817c015SCarlos L. Torres * 5534295f879SMarkus Armbruster * @nptr may be null, and no conversion is performed then. 554c817c015SCarlos L. Torres * 5553c5f2467SEric Blake * If no conversion is performed, store @nptr in *@endptr, 0 in 5563c5f2467SEric Blake * @result, and return -EINVAL. 5574295f879SMarkus Armbruster * 5584295f879SMarkus Armbruster * If @endptr is null, and the string isn't fully converted, return 5593c5f2467SEric Blake * -EINVAL with @result set to the parsed value. This is the case 5603c5f2467SEric Blake * when the pointer that would be stored in a non-null @endptr points 5613c5f2467SEric Blake * to a character other than '\0'. 5624295f879SMarkus Armbruster * 5634295f879SMarkus Armbruster * If the conversion overflows @result, store ULONG_MAX in @result, 5644295f879SMarkus Armbruster * and return -ERANGE. 5654295f879SMarkus Armbruster * 5664295f879SMarkus Armbruster * Else store the converted value in @result, and return zero. 5674295f879SMarkus Armbruster * 5684295f879SMarkus Armbruster * Note that a number with a leading minus sign gets converted without 5694295f879SMarkus Armbruster * the minus sign, checked for overflow (see above), then negated (in 5704295f879SMarkus Armbruster * @result's type). This is exactly how strtoul() works. 571c817c015SCarlos L. Torres */ 572c817c015SCarlos L. Torres int qemu_strtoul(const char *nptr, const char **endptr, int base, 573c817c015SCarlos L. Torres unsigned long *result) 574c817c015SCarlos L. Torres { 575717adf96SMarkus Armbruster char *ep; 5764baef267SMarkus Armbruster 57753a90b97SEric Blake assert((unsigned) base <= 36 && base != 1); 578c817c015SCarlos L. Torres if (!nptr) { 5793c5f2467SEric Blake *result = 0; 580c817c015SCarlos L. Torres if (endptr) { 581c817c015SCarlos L. Torres *endptr = nptr; 582c817c015SCarlos L. Torres } 5834baef267SMarkus Armbruster return -EINVAL; 5844baef267SMarkus Armbruster } 5854baef267SMarkus Armbruster 586c817c015SCarlos L. Torres errno = 0; 587717adf96SMarkus Armbruster *result = strtoul(nptr, &ep, base); 58847d4be12SPaolo Bonzini /* Windows returns 1 for negative out-of-range values. */ 58947d4be12SPaolo Bonzini if (errno == ERANGE) { 59047d4be12SPaolo Bonzini *result = -1; 59147d4be12SPaolo Bonzini } 5926162f7daSEric Blake return check_strtox_error(nptr, ep, endptr, *result == 0, errno); 593c817c015SCarlos L. Torres } 594c817c015SCarlos L. Torres 595764e0fa4SCarlos L. Torres /** 5964295f879SMarkus Armbruster * Convert string @nptr to an int64_t. 5978ac4df40SCarlos L. Torres * 5984295f879SMarkus Armbruster * Works like qemu_strtol(), except it stores INT64_MAX on overflow, 599369276ebSMarkus Armbruster * and INT64_MIN on underflow. 6008ac4df40SCarlos L. Torres */ 601b30d1886SMarkus Armbruster int qemu_strtoi64(const char *nptr, const char **endptr, int base, 6028ac4df40SCarlos L. Torres int64_t *result) 6038ac4df40SCarlos L. Torres { 604717adf96SMarkus Armbruster char *ep; 6054baef267SMarkus Armbruster 60653a90b97SEric Blake assert((unsigned) base <= 36 && base != 1); 6078ac4df40SCarlos L. Torres if (!nptr) { 6083c5f2467SEric Blake *result = 0; 6098ac4df40SCarlos L. Torres if (endptr) { 6108ac4df40SCarlos L. Torres *endptr = nptr; 6118ac4df40SCarlos L. Torres } 6124baef267SMarkus Armbruster return -EINVAL; 6134baef267SMarkus Armbruster } 6144baef267SMarkus Armbruster 615369276ebSMarkus Armbruster /* This assumes int64_t is long long TODO relax */ 616369276ebSMarkus Armbruster QEMU_BUILD_BUG_ON(sizeof(int64_t) != sizeof(long long)); 6178ac4df40SCarlos L. Torres errno = 0; 618717adf96SMarkus Armbruster *result = strtoll(nptr, &ep, base); 6196162f7daSEric Blake return check_strtox_error(nptr, ep, endptr, *result == 0, errno); 6208ac4df40SCarlos L. Torres } 6218ac4df40SCarlos L. Torres 6228ac4df40SCarlos L. Torres /** 6234295f879SMarkus Armbruster * Convert string @nptr to an uint64_t. 6243904e6bfSCarlos L. Torres * 6254295f879SMarkus Armbruster * Works like qemu_strtoul(), except it stores UINT64_MAX on overflow. 62684760bbcSEric Blake * (If you want to prohibit negative numbers that wrap around to 62784760bbcSEric Blake * positive, use parse_uint()). 6283904e6bfSCarlos L. Torres */ 629b30d1886SMarkus Armbruster int qemu_strtou64(const char *nptr, const char **endptr, int base, 6303904e6bfSCarlos L. Torres uint64_t *result) 6313904e6bfSCarlos L. Torres { 632717adf96SMarkus Armbruster char *ep; 6334baef267SMarkus Armbruster 63453a90b97SEric Blake assert((unsigned) base <= 36 && base != 1); 6353904e6bfSCarlos L. Torres if (!nptr) { 6363c5f2467SEric Blake *result = 0; 6373904e6bfSCarlos L. Torres if (endptr) { 6383904e6bfSCarlos L. Torres *endptr = nptr; 6393904e6bfSCarlos L. Torres } 6404baef267SMarkus Armbruster return -EINVAL; 6414baef267SMarkus Armbruster } 6424baef267SMarkus Armbruster 643369276ebSMarkus Armbruster /* This assumes uint64_t is unsigned long long TODO relax */ 644369276ebSMarkus Armbruster QEMU_BUILD_BUG_ON(sizeof(uint64_t) != sizeof(unsigned long long)); 6453904e6bfSCarlos L. Torres errno = 0; 646717adf96SMarkus Armbruster *result = strtoull(nptr, &ep, base); 64747d4be12SPaolo Bonzini /* Windows returns 1 for negative out-of-range values. */ 64847d4be12SPaolo Bonzini if (errno == ERANGE) { 64947d4be12SPaolo Bonzini *result = -1; 65047d4be12SPaolo Bonzini } 6516162f7daSEric Blake return check_strtox_error(nptr, ep, endptr, *result == 0, errno); 6523904e6bfSCarlos L. Torres } 6533904e6bfSCarlos L. Torres 6543904e6bfSCarlos L. Torres /** 655ca28f548SDavid Hildenbrand * Convert string @nptr to a double. 656ca28f548SDavid Hildenbrand * 657ca28f548SDavid Hildenbrand * This is a wrapper around strtod() that is harder to misuse. 658ca28f548SDavid Hildenbrand * Semantics of @nptr and @endptr match strtod() with differences 659ca28f548SDavid Hildenbrand * noted below. 660ca28f548SDavid Hildenbrand * 661ca28f548SDavid Hildenbrand * @nptr may be null, and no conversion is performed then. 662ca28f548SDavid Hildenbrand * 663c25b1683SEric Blake * If no conversion is performed, store @nptr in *@endptr, +0.0 in 664c25b1683SEric Blake * @result, and return -EINVAL. 665ca28f548SDavid Hildenbrand * 666ca28f548SDavid Hildenbrand * If @endptr is null, and the string isn't fully converted, return 667c25b1683SEric Blake * -EINVAL with @result set to the parsed value. This is the case 668c25b1683SEric Blake * when the pointer that would be stored in a non-null @endptr points 669c25b1683SEric Blake * to a character other than '\0'. 670ca28f548SDavid Hildenbrand * 671ca28f548SDavid Hildenbrand * If the conversion overflows, store +/-HUGE_VAL in @result, depending 672ca28f548SDavid Hildenbrand * on the sign, and return -ERANGE. 673ca28f548SDavid Hildenbrand * 674ca28f548SDavid Hildenbrand * If the conversion underflows, store +/-0.0 in @result, depending on the 675ca28f548SDavid Hildenbrand * sign, and return -ERANGE. 676ca28f548SDavid Hildenbrand * 677ca28f548SDavid Hildenbrand * Else store the converted value in @result, and return zero. 678ca28f548SDavid Hildenbrand */ 679ca28f548SDavid Hildenbrand int qemu_strtod(const char *nptr, const char **endptr, double *result) 680ca28f548SDavid Hildenbrand { 681ca28f548SDavid Hildenbrand char *ep; 682ca28f548SDavid Hildenbrand 683ca28f548SDavid Hildenbrand if (!nptr) { 684c25b1683SEric Blake *result = 0.0; 685ca28f548SDavid Hildenbrand if (endptr) { 686ca28f548SDavid Hildenbrand *endptr = nptr; 687ca28f548SDavid Hildenbrand } 688ca28f548SDavid Hildenbrand return -EINVAL; 689ca28f548SDavid Hildenbrand } 690ca28f548SDavid Hildenbrand 691ca28f548SDavid Hildenbrand errno = 0; 692ca28f548SDavid Hildenbrand *result = strtod(nptr, &ep); 6936162f7daSEric Blake return check_strtox_error(nptr, ep, endptr, false, errno); 694ca28f548SDavid Hildenbrand } 695ca28f548SDavid Hildenbrand 696ca28f548SDavid Hildenbrand /** 697ca28f548SDavid Hildenbrand * Convert string @nptr to a finite double. 698ca28f548SDavid Hildenbrand * 699c25b1683SEric Blake * Works like qemu_strtod(), except that "NaN", "inf", and strings 700c25b1683SEric Blake * that cause ERANGE overflow errors are rejected with -EINVAL as if 701c25b1683SEric Blake * no conversion is performed, storing 0.0 into @result regardless of 702c25b1683SEric Blake * any sign. -ERANGE failures for underflow still preserve the parsed 703c25b1683SEric Blake * sign. 704ca28f548SDavid Hildenbrand */ 705ca28f548SDavid Hildenbrand int qemu_strtod_finite(const char *nptr, const char **endptr, double *result) 706ca28f548SDavid Hildenbrand { 707c25b1683SEric Blake const char *tmp; 708ca28f548SDavid Hildenbrand int ret; 709ca28f548SDavid Hildenbrand 710c25b1683SEric Blake ret = qemu_strtod(nptr, &tmp, result); 711c25b1683SEric Blake if (!isfinite(*result)) { 712ca28f548SDavid Hildenbrand if (endptr) { 713ca28f548SDavid Hildenbrand *endptr = nptr; 714ca28f548SDavid Hildenbrand } 715c25b1683SEric Blake *result = 0.0; 716ca28f548SDavid Hildenbrand ret = -EINVAL; 717c25b1683SEric Blake } else if (endptr) { 718c25b1683SEric Blake *endptr = tmp; 719c25b1683SEric Blake } else if (*tmp) { 720c25b1683SEric Blake ret = -EINVAL; 721ca28f548SDavid Hildenbrand } 722ca28f548SDavid Hildenbrand return ret; 723ca28f548SDavid Hildenbrand } 724ca28f548SDavid Hildenbrand 725ca28f548SDavid Hildenbrand /** 7265c99fa37SKeno Fischer * Searches for the first occurrence of 'c' in 's', and returns a pointer 7275c99fa37SKeno Fischer * to the trailing null byte if none was found. 7285c99fa37SKeno Fischer */ 7295c99fa37SKeno Fischer #ifndef HAVE_STRCHRNUL 7305c99fa37SKeno Fischer const char *qemu_strchrnul(const char *s, int c) 7315c99fa37SKeno Fischer { 7325c99fa37SKeno Fischer const char *e = strchr(s, c); 7335c99fa37SKeno Fischer if (!e) { 7345c99fa37SKeno Fischer e = s + strlen(s); 7355c99fa37SKeno Fischer } 7365c99fa37SKeno Fischer return e; 7375c99fa37SKeno Fischer } 7385c99fa37SKeno Fischer #endif 7395c99fa37SKeno Fischer 7405c99fa37SKeno Fischer /** 741e3f9fe2dSEduardo Habkost * parse_uint: 742e3f9fe2dSEduardo Habkost * 743e3f9fe2dSEduardo Habkost * @s: String to parse 74452d606aaSEric Blake * @endptr: Destination for pointer to first character not consumed 745e3f9fe2dSEduardo Habkost * @base: integer base, between 2 and 36 inclusive, or 0 746bd1386ccSEric Blake * @value: Destination for parsed integer value 747e3f9fe2dSEduardo Habkost * 748e3f9fe2dSEduardo Habkost * Parse unsigned integer 749e3f9fe2dSEduardo Habkost * 750e3f9fe2dSEduardo Habkost * Parsed syntax is like strtoull()'s: arbitrary whitespace, a single optional 751e3f9fe2dSEduardo Habkost * '+' or '-', an optional "0x" if @base is 0 or 16, one or more digits. 752e3f9fe2dSEduardo Habkost * 75384760bbcSEric Blake * If @s is null, or @s doesn't start with an integer in the syntax 75484760bbcSEric Blake * above, set *@value to 0, *@endptr to @s, and return -EINVAL. 755e3f9fe2dSEduardo Habkost * 756e3f9fe2dSEduardo Habkost * Set *@endptr to point right beyond the parsed integer (even if the integer 757e3f9fe2dSEduardo Habkost * overflows or is negative, all digits will be parsed and *@endptr will 75852d606aaSEric Blake * point right beyond them). If @endptr is %NULL, any trailing character 75952d606aaSEric Blake * instead causes a result of -EINVAL with *@value of 0. 760e3f9fe2dSEduardo Habkost * 761e3f9fe2dSEduardo Habkost * If the integer is negative, set *@value to 0, and return -ERANGE. 76284760bbcSEric Blake * (If you want to allow negative numbers that wrap around within 76384760bbcSEric Blake * bounds, use qemu_strtou64()). 764e3f9fe2dSEduardo Habkost * 765e3f9fe2dSEduardo Habkost * If the integer overflows unsigned long long, set *@value to 766e3f9fe2dSEduardo Habkost * ULLONG_MAX, and return -ERANGE. 767e3f9fe2dSEduardo Habkost * 768e3f9fe2dSEduardo Habkost * Else, set *@value to the parsed integer, and return 0. 769e3f9fe2dSEduardo Habkost */ 770bd1386ccSEric Blake int parse_uint(const char *s, const char **endptr, int base, uint64_t *value) 771e3f9fe2dSEduardo Habkost { 772e3f9fe2dSEduardo Habkost int r = 0; 773e3f9fe2dSEduardo Habkost char *endp = (char *)s; 774e3f9fe2dSEduardo Habkost unsigned long long val = 0; 775e3f9fe2dSEduardo Habkost 77653a90b97SEric Blake assert((unsigned) base <= 36 && base != 1); 777e3f9fe2dSEduardo Habkost if (!s) { 778e3f9fe2dSEduardo Habkost r = -EINVAL; 779e3f9fe2dSEduardo Habkost goto out; 780e3f9fe2dSEduardo Habkost } 781e3f9fe2dSEduardo Habkost 782e3f9fe2dSEduardo Habkost errno = 0; 783e3f9fe2dSEduardo Habkost val = strtoull(s, &endp, base); 784e3f9fe2dSEduardo Habkost if (errno) { 785e3f9fe2dSEduardo Habkost r = -errno; 786e3f9fe2dSEduardo Habkost goto out; 787e3f9fe2dSEduardo Habkost } 788e3f9fe2dSEduardo Habkost 789e3f9fe2dSEduardo Habkost if (endp == s) { 790e3f9fe2dSEduardo Habkost r = -EINVAL; 791e3f9fe2dSEduardo Habkost goto out; 792e3f9fe2dSEduardo Habkost } 793e3f9fe2dSEduardo Habkost 794e3f9fe2dSEduardo Habkost /* make sure we reject negative numbers: */ 795db3d11eeSMarkus Armbruster while (qemu_isspace(*s)) { 796e3f9fe2dSEduardo Habkost s++; 797e3f9fe2dSEduardo Habkost } 798e3f9fe2dSEduardo Habkost if (*s == '-') { 799e3f9fe2dSEduardo Habkost val = 0; 800e3f9fe2dSEduardo Habkost r = -ERANGE; 801e3f9fe2dSEduardo Habkost goto out; 802e3f9fe2dSEduardo Habkost } 803e3f9fe2dSEduardo Habkost 804e3f9fe2dSEduardo Habkost out: 805e3f9fe2dSEduardo Habkost *value = val; 80652d606aaSEric Blake if (endptr) { 807e3f9fe2dSEduardo Habkost *endptr = endp; 80852d606aaSEric Blake } else if (s && *endp) { 80952d606aaSEric Blake r = -EINVAL; 81052d606aaSEric Blake *value = 0; 81152d606aaSEric Blake } 812e3f9fe2dSEduardo Habkost return r; 813e3f9fe2dSEduardo Habkost } 814e3f9fe2dSEduardo Habkost 815e3f9fe2dSEduardo Habkost /** 816e3f9fe2dSEduardo Habkost * parse_uint_full: 817e3f9fe2dSEduardo Habkost * 818e3f9fe2dSEduardo Habkost * @s: String to parse 819e3f9fe2dSEduardo Habkost * @base: integer base, between 2 and 36 inclusive, or 0 820bd1386ccSEric Blake * @value: Destination for parsed integer value 821e3f9fe2dSEduardo Habkost * 82252d606aaSEric Blake * Parse unsigned integer from entire string, rejecting any trailing slop. 823e3f9fe2dSEduardo Habkost * 82452d606aaSEric Blake * Shorthand for parse_uint(s, NULL, base, value). 825e3f9fe2dSEduardo Habkost */ 826bd1386ccSEric Blake int parse_uint_full(const char *s, int base, uint64_t *value) 827e3f9fe2dSEduardo Habkost { 82852d606aaSEric Blake return parse_uint(s, NULL, base, value); 829e3f9fe2dSEduardo Habkost } 830e3f9fe2dSEduardo Habkost 831baacf047SPaolo Bonzini int qemu_parse_fd(const char *param) 832baacf047SPaolo Bonzini { 833e9c5c1f4SLaszlo Ersek long fd; 834e9c5c1f4SLaszlo Ersek char *endptr; 835baacf047SPaolo Bonzini 836e9c5c1f4SLaszlo Ersek errno = 0; 837baacf047SPaolo Bonzini fd = strtol(param, &endptr, 10); 838e9c5c1f4SLaszlo Ersek if (param == endptr /* no conversion performed */ || 839e9c5c1f4SLaszlo Ersek errno != 0 /* not representable as long; possibly others */ || 840e9c5c1f4SLaszlo Ersek *endptr != '\0' /* final string not empty */ || 841e9c5c1f4SLaszlo Ersek fd < 0 /* invalid as file descriptor */ || 842e9c5c1f4SLaszlo Ersek fd > INT_MAX /* not representable as int */) { 843baacf047SPaolo Bonzini return -1; 844baacf047SPaolo Bonzini } 845baacf047SPaolo Bonzini return fd; 846baacf047SPaolo Bonzini } 847baacf047SPaolo Bonzini 848baacf047SPaolo Bonzini /* 849baacf047SPaolo Bonzini * Implementation of ULEB128 (http://en.wikipedia.org/wiki/LEB128) 850baacf047SPaolo Bonzini * Input is limited to 14-bit numbers 851baacf047SPaolo Bonzini */ 852baacf047SPaolo Bonzini int uleb128_encode_small(uint8_t *out, uint32_t n) 853baacf047SPaolo Bonzini { 854baacf047SPaolo Bonzini g_assert(n <= 0x3fff); 855baacf047SPaolo Bonzini if (n < 0x80) { 8567c960d61SWei Yang *out = n; 857baacf047SPaolo Bonzini return 1; 858baacf047SPaolo Bonzini } else { 859baacf047SPaolo Bonzini *out++ = (n & 0x7f) | 0x80; 8607c960d61SWei Yang *out = n >> 7; 861baacf047SPaolo Bonzini return 2; 862baacf047SPaolo Bonzini } 863baacf047SPaolo Bonzini } 864baacf047SPaolo Bonzini 865baacf047SPaolo Bonzini int uleb128_decode_small(const uint8_t *in, uint32_t *n) 866baacf047SPaolo Bonzini { 867baacf047SPaolo Bonzini if (!(*in & 0x80)) { 8687c960d61SWei Yang *n = *in; 869baacf047SPaolo Bonzini return 1; 870baacf047SPaolo Bonzini } else { 871baacf047SPaolo Bonzini *n = *in++ & 0x7f; 872baacf047SPaolo Bonzini /* we exceed 14 bit number */ 873baacf047SPaolo Bonzini if (*in & 0x80) { 874baacf047SPaolo Bonzini return -1; 875baacf047SPaolo Bonzini } 8767c960d61SWei Yang *n |= *in << 7; 877baacf047SPaolo Bonzini return 2; 878baacf047SPaolo Bonzini } 879baacf047SPaolo Bonzini } 880b16352acSAlon Levy 881b16352acSAlon Levy /* 882b16352acSAlon Levy * helper to parse debug environment variables 883b16352acSAlon Levy */ 884b16352acSAlon Levy int parse_debug_env(const char *name, int max, int initial) 885b16352acSAlon Levy { 886b16352acSAlon Levy char *debug_env = getenv(name); 887b16352acSAlon Levy char *inv = NULL; 888cc5d0e04SPaolo Bonzini long debug; 889b16352acSAlon Levy 890b16352acSAlon Levy if (!debug_env) { 891b16352acSAlon Levy return initial; 892b16352acSAlon Levy } 893cc5d0e04SPaolo Bonzini errno = 0; 894b16352acSAlon Levy debug = strtol(debug_env, &inv, 10); 895b16352acSAlon Levy if (inv == debug_env) { 896b16352acSAlon Levy return initial; 897b16352acSAlon Levy } 898cc5d0e04SPaolo Bonzini if (debug < 0 || debug > max || errno != 0) { 89905cb8ed5SAlistair Francis warn_report("%s not in [0, %d]", name, max); 900b16352acSAlon Levy return initial; 901b16352acSAlon Levy } 902b16352acSAlon Levy return debug; 903b16352acSAlon Levy } 9044297c8eeSAlexey Kardashevskiy 905cfb34489SPaolo Bonzini const char *si_prefix(unsigned int exp10) 906cfb34489SPaolo Bonzini { 907cfb34489SPaolo Bonzini static const char *prefixes[] = { 908cfb34489SPaolo Bonzini "a", "f", "p", "n", "u", "m", "", "K", "M", "G", "T", "P", "E" 909cfb34489SPaolo Bonzini }; 910cfb34489SPaolo Bonzini 911cfb34489SPaolo Bonzini exp10 += 18; 912cfb34489SPaolo Bonzini assert(exp10 % 3 == 0 && exp10 / 3 < ARRAY_SIZE(prefixes)); 913cfb34489SPaolo Bonzini return prefixes[exp10 / 3]; 914cfb34489SPaolo Bonzini } 915cfb34489SPaolo Bonzini 916cfb34489SPaolo Bonzini const char *iec_binary_prefix(unsigned int exp2) 917cfb34489SPaolo Bonzini { 918cfb34489SPaolo Bonzini static const char *prefixes[] = { "", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei" }; 919cfb34489SPaolo Bonzini 920cfb34489SPaolo Bonzini assert(exp2 % 10 == 0 && exp2 / 10 < ARRAY_SIZE(prefixes)); 921cfb34489SPaolo Bonzini return prefixes[exp2 / 10]; 922cfb34489SPaolo Bonzini } 923cfb34489SPaolo Bonzini 9244297c8eeSAlexey Kardashevskiy /* 92522951aaaSPeter Xu * Return human readable string for size @val. 92622951aaaSPeter Xu * @val can be anything that uint64_t allows (no more than "16 EiB"). 92722951aaaSPeter Xu * Use IEC binary units like KiB, MiB, and so forth. 92822951aaaSPeter Xu * Caller is responsible for passing it to g_free(). 92922951aaaSPeter Xu */ 93022951aaaSPeter Xu char *size_to_str(uint64_t val) 93122951aaaSPeter Xu { 932754da867SEric Blake uint64_t div; 93322951aaaSPeter Xu int i; 93422951aaaSPeter Xu 93522951aaaSPeter Xu /* 93622951aaaSPeter Xu * The exponent (returned in i) minus one gives us 93722951aaaSPeter Xu * floor(log2(val * 1024 / 1000). The correction makes us 93822951aaaSPeter Xu * switch to the higher power when the integer part is >= 1000. 93922951aaaSPeter Xu * (see e41b509d68afb1f for more info) 94022951aaaSPeter Xu */ 94122951aaaSPeter Xu frexp(val / (1000.0 / 1024.0), &i); 942cfb34489SPaolo Bonzini i = (i - 1) / 10 * 10; 943cfb34489SPaolo Bonzini div = 1ULL << i; 94422951aaaSPeter Xu 945cfb34489SPaolo Bonzini return g_strdup_printf("%0.3g %sB", (double)val / div, iec_binary_prefix(i)); 94622951aaaSPeter Xu } 94785e33a28SMarc-André Lureau 948709616c7SPhilippe Mathieu-Daudé char *freq_to_str(uint64_t freq_hz) 949709616c7SPhilippe Mathieu-Daudé { 950709616c7SPhilippe Mathieu-Daudé double freq = freq_hz; 951cfb34489SPaolo Bonzini size_t exp10 = 0; 952709616c7SPhilippe Mathieu-Daudé 9536d7ccc57SPhilippe Mathieu-Daudé while (freq >= 1000.0) { 954709616c7SPhilippe Mathieu-Daudé freq /= 1000.0; 955cfb34489SPaolo Bonzini exp10 += 3; 956709616c7SPhilippe Mathieu-Daudé } 957709616c7SPhilippe Mathieu-Daudé 958cfb34489SPaolo Bonzini return g_strdup_printf("%0.3g %sHz", freq, si_prefix(exp10)); 959709616c7SPhilippe Mathieu-Daudé } 960709616c7SPhilippe Mathieu-Daudé 96185e33a28SMarc-André Lureau int qemu_pstrcmp0(const char **str1, const char **str2) 96285e33a28SMarc-André Lureau { 96385e33a28SMarc-André Lureau return g_strcmp0(*str1, *str2); 96485e33a28SMarc-André Lureau } 965f4f5ed2cSPaolo Bonzini 966f4f5ed2cSPaolo Bonzini static inline bool starts_with_prefix(const char *dir) 967f4f5ed2cSPaolo Bonzini { 968f4f5ed2cSPaolo Bonzini size_t prefix_len = strlen(CONFIG_PREFIX); 969f4f5ed2cSPaolo Bonzini return !memcmp(dir, CONFIG_PREFIX, prefix_len) && 970f4f5ed2cSPaolo Bonzini (!dir[prefix_len] || G_IS_DIR_SEPARATOR(dir[prefix_len])); 971f4f5ed2cSPaolo Bonzini } 972f4f5ed2cSPaolo Bonzini 973f4f5ed2cSPaolo Bonzini /* Return the next path component in dir, and store its length in *p_len. */ 974f4f5ed2cSPaolo Bonzini static inline const char *next_component(const char *dir, int *p_len) 975f4f5ed2cSPaolo Bonzini { 976f4f5ed2cSPaolo Bonzini int len; 977342e3a4fSStefan Weil while ((*dir && G_IS_DIR_SEPARATOR(*dir)) || 978342e3a4fSStefan Weil (*dir == '.' && (G_IS_DIR_SEPARATOR(dir[1]) || dir[1] == '\0'))) { 979f4f5ed2cSPaolo Bonzini dir++; 980f4f5ed2cSPaolo Bonzini } 981f4f5ed2cSPaolo Bonzini len = 0; 982f4f5ed2cSPaolo Bonzini while (dir[len] && !G_IS_DIR_SEPARATOR(dir[len])) { 983f4f5ed2cSPaolo Bonzini len++; 984f4f5ed2cSPaolo Bonzini } 985f4f5ed2cSPaolo Bonzini *p_len = len; 986f4f5ed2cSPaolo Bonzini return dir; 987f4f5ed2cSPaolo Bonzini } 988f4f5ed2cSPaolo Bonzini 98906680b15SMarc-André Lureau static const char *exec_dir; 99006680b15SMarc-André Lureau 99106680b15SMarc-André Lureau void qemu_init_exec_dir(const char *argv0) 99206680b15SMarc-André Lureau { 99306680b15SMarc-André Lureau #ifdef G_OS_WIN32 99406680b15SMarc-André Lureau char *p; 99506680b15SMarc-André Lureau char buf[MAX_PATH]; 99606680b15SMarc-André Lureau DWORD len; 99706680b15SMarc-André Lureau 99806680b15SMarc-André Lureau if (exec_dir) { 99906680b15SMarc-André Lureau return; 100006680b15SMarc-André Lureau } 100106680b15SMarc-André Lureau 100206680b15SMarc-André Lureau len = GetModuleFileName(NULL, buf, sizeof(buf) - 1); 100306680b15SMarc-André Lureau if (len == 0) { 100406680b15SMarc-André Lureau return; 100506680b15SMarc-André Lureau } 100606680b15SMarc-André Lureau 100706680b15SMarc-André Lureau buf[len] = 0; 100806680b15SMarc-André Lureau p = buf + len - 1; 100906680b15SMarc-André Lureau while (p != buf && *p != '\\') { 101006680b15SMarc-André Lureau p--; 101106680b15SMarc-André Lureau } 101206680b15SMarc-André Lureau *p = 0; 101306680b15SMarc-André Lureau if (access(buf, R_OK) == 0) { 101406680b15SMarc-André Lureau exec_dir = g_strdup(buf); 101506680b15SMarc-André Lureau } else { 101606680b15SMarc-André Lureau exec_dir = CONFIG_BINDIR; 101706680b15SMarc-André Lureau } 101806680b15SMarc-André Lureau #else 101906680b15SMarc-André Lureau char *p = NULL; 102006680b15SMarc-André Lureau char buf[PATH_MAX]; 102106680b15SMarc-André Lureau 102206680b15SMarc-André Lureau if (exec_dir) { 102306680b15SMarc-André Lureau return; 102406680b15SMarc-André Lureau } 102506680b15SMarc-André Lureau 102606680b15SMarc-André Lureau #if defined(__linux__) 102706680b15SMarc-André Lureau { 102806680b15SMarc-André Lureau int len; 102906680b15SMarc-André Lureau len = readlink("/proc/self/exe", buf, sizeof(buf) - 1); 103006680b15SMarc-André Lureau if (len > 0) { 103106680b15SMarc-André Lureau buf[len] = 0; 103206680b15SMarc-André Lureau p = buf; 103306680b15SMarc-André Lureau } 103406680b15SMarc-André Lureau } 103506680b15SMarc-André Lureau #elif defined(__FreeBSD__) \ 103606680b15SMarc-André Lureau || (defined(__NetBSD__) && defined(KERN_PROC_PATHNAME)) 103706680b15SMarc-André Lureau { 103806680b15SMarc-André Lureau #if defined(__FreeBSD__) 103906680b15SMarc-André Lureau static int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1}; 104006680b15SMarc-André Lureau #else 104106680b15SMarc-André Lureau static int mib[4] = {CTL_KERN, KERN_PROC_ARGS, -1, KERN_PROC_PATHNAME}; 104206680b15SMarc-André Lureau #endif 104306680b15SMarc-André Lureau size_t len = sizeof(buf) - 1; 104406680b15SMarc-André Lureau 104506680b15SMarc-André Lureau *buf = '\0'; 104606680b15SMarc-André Lureau if (!sysctl(mib, ARRAY_SIZE(mib), buf, &len, NULL, 0) && 104706680b15SMarc-André Lureau *buf) { 104806680b15SMarc-André Lureau buf[sizeof(buf) - 1] = '\0'; 104906680b15SMarc-André Lureau p = buf; 105006680b15SMarc-André Lureau } 105106680b15SMarc-André Lureau } 105206680b15SMarc-André Lureau #elif defined(__APPLE__) 105306680b15SMarc-André Lureau { 105406680b15SMarc-André Lureau char fpath[PATH_MAX]; 105506680b15SMarc-André Lureau uint32_t len = sizeof(fpath); 105606680b15SMarc-André Lureau if (_NSGetExecutablePath(fpath, &len) == 0) { 105706680b15SMarc-André Lureau p = realpath(fpath, buf); 105806680b15SMarc-André Lureau if (!p) { 105906680b15SMarc-André Lureau return; 106006680b15SMarc-André Lureau } 106106680b15SMarc-André Lureau } 106206680b15SMarc-André Lureau } 106306680b15SMarc-André Lureau #elif defined(__HAIKU__) 106406680b15SMarc-André Lureau { 106506680b15SMarc-André Lureau image_info ii; 106606680b15SMarc-André Lureau int32_t c = 0; 106706680b15SMarc-André Lureau 106806680b15SMarc-André Lureau *buf = '\0'; 106906680b15SMarc-André Lureau while (get_next_image_info(0, &c, &ii) == B_OK) { 107006680b15SMarc-André Lureau if (ii.type == B_APP_IMAGE) { 107106680b15SMarc-André Lureau strncpy(buf, ii.name, sizeof(buf)); 107206680b15SMarc-André Lureau buf[sizeof(buf) - 1] = 0; 107306680b15SMarc-André Lureau p = buf; 107406680b15SMarc-André Lureau break; 107506680b15SMarc-André Lureau } 107606680b15SMarc-André Lureau } 107706680b15SMarc-André Lureau } 107806680b15SMarc-André Lureau #endif 107906680b15SMarc-André Lureau /* If we don't have any way of figuring out the actual executable 108006680b15SMarc-André Lureau location then try argv[0]. */ 108106680b15SMarc-André Lureau if (!p && argv0) { 108206680b15SMarc-André Lureau p = realpath(argv0, buf); 108306680b15SMarc-André Lureau } 108406680b15SMarc-André Lureau if (p) { 108506680b15SMarc-André Lureau exec_dir = g_path_get_dirname(p); 108606680b15SMarc-André Lureau } else { 108706680b15SMarc-André Lureau exec_dir = CONFIG_BINDIR; 108806680b15SMarc-André Lureau } 108906680b15SMarc-André Lureau #endif 109006680b15SMarc-André Lureau } 109106680b15SMarc-André Lureau 109206680b15SMarc-André Lureau const char *qemu_get_exec_dir(void) 109306680b15SMarc-André Lureau { 109406680b15SMarc-André Lureau return exec_dir; 109506680b15SMarc-André Lureau } 109606680b15SMarc-André Lureau 1097f4f5ed2cSPaolo Bonzini char *get_relocated_path(const char *dir) 1098f4f5ed2cSPaolo Bonzini { 1099f4f5ed2cSPaolo Bonzini size_t prefix_len = strlen(CONFIG_PREFIX); 1100f4f5ed2cSPaolo Bonzini const char *bindir = CONFIG_BINDIR; 1101f4f5ed2cSPaolo Bonzini const char *exec_dir = qemu_get_exec_dir(); 1102f4f5ed2cSPaolo Bonzini GString *result; 1103f4f5ed2cSPaolo Bonzini int len_dir, len_bindir; 1104f4f5ed2cSPaolo Bonzini 1105f4f5ed2cSPaolo Bonzini /* Fail if qemu_init_exec_dir was not called. */ 1106f4f5ed2cSPaolo Bonzini assert(exec_dir[0]); 1107f4f5ed2cSPaolo Bonzini 1108f4f5ed2cSPaolo Bonzini result = g_string_new(exec_dir); 1109cf60ccc3SAkihiko Odaki g_string_append(result, "/qemu-bundle"); 1110cf60ccc3SAkihiko Odaki if (access(result->str, R_OK) == 0) { 1111cf60ccc3SAkihiko Odaki #ifdef G_OS_WIN32 1112cf60ccc3SAkihiko Odaki size_t size = mbsrtowcs(NULL, &dir, 0, &(mbstate_t){0}) + 1; 1113cf60ccc3SAkihiko Odaki PWSTR wdir = g_new(WCHAR, size); 1114cf60ccc3SAkihiko Odaki mbsrtowcs(wdir, &dir, size, &(mbstate_t){0}); 1115cf60ccc3SAkihiko Odaki 1116cf60ccc3SAkihiko Odaki PCWSTR wdir_skipped_root; 1117cf60ccc3SAkihiko Odaki PathCchSkipRoot(wdir, &wdir_skipped_root); 1118cf60ccc3SAkihiko Odaki 1119cf60ccc3SAkihiko Odaki size = wcsrtombs(NULL, &wdir_skipped_root, 0, &(mbstate_t){0}); 1120cf60ccc3SAkihiko Odaki char *cursor = result->str + result->len; 1121cf60ccc3SAkihiko Odaki g_string_set_size(result, result->len + size); 1122cf60ccc3SAkihiko Odaki wcsrtombs(cursor, &wdir_skipped_root, size + 1, &(mbstate_t){0}); 1123cf60ccc3SAkihiko Odaki g_free(wdir); 1124cf60ccc3SAkihiko Odaki #else 1125cf60ccc3SAkihiko Odaki g_string_append(result, dir); 1126cf60ccc3SAkihiko Odaki #endif 1127cf60ccc3SAkihiko Odaki } else if (!starts_with_prefix(dir) || !starts_with_prefix(bindir)) { 1128cf60ccc3SAkihiko Odaki g_string_assign(result, dir); 1129cf60ccc3SAkihiko Odaki } else { 1130cf60ccc3SAkihiko Odaki g_string_assign(result, exec_dir); 1131f4f5ed2cSPaolo Bonzini 1132f4f5ed2cSPaolo Bonzini /* Advance over common components. */ 1133f4f5ed2cSPaolo Bonzini len_dir = len_bindir = prefix_len; 1134f4f5ed2cSPaolo Bonzini do { 1135f4f5ed2cSPaolo Bonzini dir += len_dir; 1136f4f5ed2cSPaolo Bonzini bindir += len_bindir; 1137f4f5ed2cSPaolo Bonzini dir = next_component(dir, &len_dir); 1138f4f5ed2cSPaolo Bonzini bindir = next_component(bindir, &len_bindir); 11397a3b7f6bSSunil Muthuswamy } while (len_dir && len_dir == len_bindir && !memcmp(dir, bindir, len_dir)); 1140f4f5ed2cSPaolo Bonzini 1141f4f5ed2cSPaolo Bonzini /* Ascend from bindir to the common prefix with dir. */ 1142f4f5ed2cSPaolo Bonzini while (len_bindir) { 1143f4f5ed2cSPaolo Bonzini bindir += len_bindir; 1144f4f5ed2cSPaolo Bonzini g_string_append(result, "/.."); 1145f4f5ed2cSPaolo Bonzini bindir = next_component(bindir, &len_bindir); 1146f4f5ed2cSPaolo Bonzini } 1147f4f5ed2cSPaolo Bonzini 1148f4f5ed2cSPaolo Bonzini if (*dir) { 1149f4f5ed2cSPaolo Bonzini assert(G_IS_DIR_SEPARATOR(dir[-1])); 1150f4f5ed2cSPaolo Bonzini g_string_append(result, dir - 1); 1151f4f5ed2cSPaolo Bonzini } 1152cf60ccc3SAkihiko Odaki } 1153cf60ccc3SAkihiko Odaki 1154b6d003dbSStefano Garzarella return g_string_free(result, false); 1155f4f5ed2cSPaolo Bonzini } 1156