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 29a8d25326SMarkus Armbruster #include "qemu-common.h" 30baacf047SPaolo Bonzini #include "qemu/sockets.h" 31baacf047SPaolo Bonzini #include "qemu/iov.h" 324297c8eeSAlexey Kardashevskiy #include "net/net.h" 33856dfd8aSMarkus Armbruster #include "qemu/ctype.h" 34f348b6d1SVeronia Bahaa #include "qemu/cutils.h" 3505cb8ed5SAlistair Francis #include "qemu/error-report.h" 36baacf047SPaolo Bonzini 37baacf047SPaolo Bonzini void strpadcpy(char *buf, int buf_size, const char *str, char pad) 38baacf047SPaolo Bonzini { 39baacf047SPaolo Bonzini int len = qemu_strnlen(str, buf_size); 40baacf047SPaolo Bonzini memcpy(buf, str, len); 41baacf047SPaolo Bonzini memset(buf + len, pad, buf_size - len); 42baacf047SPaolo Bonzini } 43baacf047SPaolo Bonzini 44baacf047SPaolo Bonzini void pstrcpy(char *buf, int buf_size, const char *str) 45baacf047SPaolo Bonzini { 46baacf047SPaolo Bonzini int c; 47baacf047SPaolo Bonzini char *q = buf; 48baacf047SPaolo Bonzini 49baacf047SPaolo Bonzini if (buf_size <= 0) 50baacf047SPaolo Bonzini return; 51baacf047SPaolo Bonzini 52baacf047SPaolo Bonzini for(;;) { 53baacf047SPaolo Bonzini c = *str++; 54baacf047SPaolo Bonzini if (c == 0 || q >= buf + buf_size - 1) 55baacf047SPaolo Bonzini break; 56baacf047SPaolo Bonzini *q++ = c; 57baacf047SPaolo Bonzini } 58baacf047SPaolo Bonzini *q = '\0'; 59baacf047SPaolo Bonzini } 60baacf047SPaolo Bonzini 61baacf047SPaolo Bonzini /* strcat and truncate. */ 62baacf047SPaolo Bonzini char *pstrcat(char *buf, int buf_size, const char *s) 63baacf047SPaolo Bonzini { 64baacf047SPaolo Bonzini int len; 65baacf047SPaolo Bonzini len = strlen(buf); 66baacf047SPaolo Bonzini if (len < buf_size) 67baacf047SPaolo Bonzini pstrcpy(buf + len, buf_size - len, s); 68baacf047SPaolo Bonzini return buf; 69baacf047SPaolo Bonzini } 70baacf047SPaolo Bonzini 71baacf047SPaolo Bonzini int strstart(const char *str, const char *val, const char **ptr) 72baacf047SPaolo Bonzini { 73baacf047SPaolo Bonzini const char *p, *q; 74baacf047SPaolo Bonzini p = str; 75baacf047SPaolo Bonzini q = val; 76baacf047SPaolo Bonzini while (*q != '\0') { 77baacf047SPaolo Bonzini if (*p != *q) 78baacf047SPaolo Bonzini return 0; 79baacf047SPaolo Bonzini p++; 80baacf047SPaolo Bonzini q++; 81baacf047SPaolo Bonzini } 82baacf047SPaolo Bonzini if (ptr) 83baacf047SPaolo Bonzini *ptr = p; 84baacf047SPaolo Bonzini return 1; 85baacf047SPaolo Bonzini } 86baacf047SPaolo Bonzini 87baacf047SPaolo Bonzini int stristart(const char *str, const char *val, const char **ptr) 88baacf047SPaolo Bonzini { 89baacf047SPaolo Bonzini const char *p, *q; 90baacf047SPaolo Bonzini p = str; 91baacf047SPaolo Bonzini q = val; 92baacf047SPaolo Bonzini while (*q != '\0') { 93baacf047SPaolo Bonzini if (qemu_toupper(*p) != qemu_toupper(*q)) 94baacf047SPaolo Bonzini return 0; 95baacf047SPaolo Bonzini p++; 96baacf047SPaolo Bonzini q++; 97baacf047SPaolo Bonzini } 98baacf047SPaolo Bonzini if (ptr) 99baacf047SPaolo Bonzini *ptr = p; 100baacf047SPaolo Bonzini return 1; 101baacf047SPaolo Bonzini } 102baacf047SPaolo Bonzini 103baacf047SPaolo Bonzini /* XXX: use host strnlen if available ? */ 104baacf047SPaolo Bonzini int qemu_strnlen(const char *s, int max_len) 105baacf047SPaolo Bonzini { 106baacf047SPaolo Bonzini int i; 107baacf047SPaolo Bonzini 108baacf047SPaolo Bonzini for(i = 0; i < max_len; i++) { 109baacf047SPaolo Bonzini if (s[i] == '\0') { 110baacf047SPaolo Bonzini break; 111baacf047SPaolo Bonzini } 112baacf047SPaolo Bonzini } 113baacf047SPaolo Bonzini return i; 114baacf047SPaolo Bonzini } 115baacf047SPaolo Bonzini 116a38ed811SKevin Wolf char *qemu_strsep(char **input, const char *delim) 117a38ed811SKevin Wolf { 118a38ed811SKevin Wolf char *result = *input; 119a38ed811SKevin Wolf if (result != NULL) { 120a38ed811SKevin Wolf char *p; 121a38ed811SKevin Wolf 122a38ed811SKevin Wolf for (p = result; *p != '\0'; p++) { 123a38ed811SKevin Wolf if (strchr(delim, *p)) { 124a38ed811SKevin Wolf break; 125a38ed811SKevin Wolf } 126a38ed811SKevin Wolf } 127a38ed811SKevin Wolf if (*p == '\0') { 128a38ed811SKevin Wolf *input = NULL; 129a38ed811SKevin Wolf } else { 130a38ed811SKevin Wolf *p = '\0'; 131a38ed811SKevin Wolf *input = p + 1; 132a38ed811SKevin Wolf } 133a38ed811SKevin Wolf } 134a38ed811SKevin Wolf return result; 135a38ed811SKevin Wolf } 136a38ed811SKevin Wolf 137baacf047SPaolo Bonzini time_t mktimegm(struct tm *tm) 138baacf047SPaolo Bonzini { 139baacf047SPaolo Bonzini time_t t; 140baacf047SPaolo Bonzini int y = tm->tm_year + 1900, m = tm->tm_mon + 1, d = tm->tm_mday; 141baacf047SPaolo Bonzini if (m < 3) { 142baacf047SPaolo Bonzini m += 12; 143baacf047SPaolo Bonzini y--; 144baacf047SPaolo Bonzini } 145baacf047SPaolo Bonzini t = 86400ULL * (d + (153 * m - 457) / 5 + 365 * y + y / 4 - y / 100 + 146baacf047SPaolo Bonzini y / 400 - 719469); 147baacf047SPaolo Bonzini t += 3600 * tm->tm_hour + 60 * tm->tm_min + tm->tm_sec; 148baacf047SPaolo Bonzini return t; 149baacf047SPaolo Bonzini } 150baacf047SPaolo Bonzini 151baacf047SPaolo Bonzini /* 152baacf047SPaolo Bonzini * Make sure data goes on disk, but if possible do not bother to 153baacf047SPaolo Bonzini * write out the inode just for timestamp updates. 154baacf047SPaolo Bonzini * 155baacf047SPaolo Bonzini * Unfortunately even in 2009 many operating systems do not support 156baacf047SPaolo Bonzini * fdatasync and have to fall back to fsync. 157baacf047SPaolo Bonzini */ 158baacf047SPaolo Bonzini int qemu_fdatasync(int fd) 159baacf047SPaolo Bonzini { 160baacf047SPaolo Bonzini #ifdef CONFIG_FDATASYNC 161baacf047SPaolo Bonzini return fdatasync(fd); 162baacf047SPaolo Bonzini #else 163baacf047SPaolo Bonzini return fsync(fd); 164baacf047SPaolo Bonzini #endif 165baacf047SPaolo Bonzini } 166baacf047SPaolo Bonzini 16761c490e2SBeata Michalska /** 16861c490e2SBeata Michalska * Sync changes made to the memory mapped file back to the backing 16961c490e2SBeata Michalska * storage. For POSIX compliant systems this will fallback 17061c490e2SBeata Michalska * to regular msync call. Otherwise it will trigger whole file sync 17161c490e2SBeata Michalska * (including the metadata case there is no support to skip that otherwise) 17261c490e2SBeata Michalska * 17361c490e2SBeata Michalska * @addr - start of the memory area to be synced 17461c490e2SBeata Michalska * @length - length of the are to be synced 17561c490e2SBeata Michalska * @fd - file descriptor for the file to be synced 17661c490e2SBeata Michalska * (mandatory only for POSIX non-compliant systems) 17761c490e2SBeata Michalska */ 17861c490e2SBeata Michalska int qemu_msync(void *addr, size_t length, int fd) 17961c490e2SBeata Michalska { 18061c490e2SBeata Michalska #ifdef CONFIG_POSIX 18161c490e2SBeata Michalska size_t align_mask = ~(qemu_real_host_page_size - 1); 18261c490e2SBeata Michalska 18361c490e2SBeata Michalska /** 18461c490e2SBeata Michalska * There are no strict reqs as per the length of mapping 18561c490e2SBeata Michalska * to be synced. Still the length needs to follow the address 18661c490e2SBeata Michalska * alignment changes. Additionally - round the size to the multiple 18761c490e2SBeata Michalska * of PAGE_SIZE 18861c490e2SBeata Michalska */ 18961c490e2SBeata Michalska length += ((uintptr_t)addr & (qemu_real_host_page_size - 1)); 19061c490e2SBeata Michalska length = (length + ~align_mask) & align_mask; 19161c490e2SBeata Michalska 19261c490e2SBeata Michalska addr = (void *)((uintptr_t)addr & align_mask); 19361c490e2SBeata Michalska 19461c490e2SBeata Michalska return msync(addr, length, MS_SYNC); 19561c490e2SBeata Michalska #else /* CONFIG_POSIX */ 19661c490e2SBeata Michalska /** 19761c490e2SBeata Michalska * Perform the sync based on the file descriptor 19861c490e2SBeata Michalska * The sync range will most probably be wider than the one 19961c490e2SBeata Michalska * requested - but it will still get the job done 20061c490e2SBeata Michalska */ 20161c490e2SBeata Michalska return qemu_fdatasync(fd); 20261c490e2SBeata Michalska #endif /* CONFIG_POSIX */ 20361c490e2SBeata Michalska } 20461c490e2SBeata Michalska 205baacf047SPaolo Bonzini #ifndef _WIN32 206baacf047SPaolo Bonzini /* Sets a specific flag */ 207baacf047SPaolo Bonzini int fcntl_setfl(int fd, int flag) 208baacf047SPaolo Bonzini { 209baacf047SPaolo Bonzini int flags; 210baacf047SPaolo Bonzini 211baacf047SPaolo Bonzini flags = fcntl(fd, F_GETFL); 212baacf047SPaolo Bonzini if (flags == -1) 213baacf047SPaolo Bonzini return -errno; 214baacf047SPaolo Bonzini 215baacf047SPaolo Bonzini if (fcntl(fd, F_SETFL, flags | flag) == -1) 216baacf047SPaolo Bonzini return -errno; 217baacf047SPaolo Bonzini 218baacf047SPaolo Bonzini return 0; 219baacf047SPaolo Bonzini } 220baacf047SPaolo Bonzini #endif 221baacf047SPaolo Bonzini 222baacf047SPaolo Bonzini static int64_t suffix_mul(char suffix, int64_t unit) 223baacf047SPaolo Bonzini { 224baacf047SPaolo Bonzini switch (qemu_toupper(suffix)) { 22517f94256SMarkus Armbruster case 'B': 226baacf047SPaolo Bonzini return 1; 22717f94256SMarkus Armbruster case 'K': 228baacf047SPaolo Bonzini return unit; 22917f94256SMarkus Armbruster case 'M': 230baacf047SPaolo Bonzini return unit * unit; 23117f94256SMarkus Armbruster case 'G': 232baacf047SPaolo Bonzini return unit * unit * unit; 23317f94256SMarkus Armbruster case 'T': 234baacf047SPaolo Bonzini return unit * unit * unit * unit; 23517f94256SMarkus Armbruster case 'P': 2365e00984aSKevin Wolf return unit * unit * unit * unit * unit; 23717f94256SMarkus Armbruster case 'E': 2385e00984aSKevin Wolf return unit * unit * unit * unit * unit * unit; 239baacf047SPaolo Bonzini } 240baacf047SPaolo Bonzini return -1; 241baacf047SPaolo Bonzini } 242baacf047SPaolo Bonzini 243baacf047SPaolo Bonzini /* 244baacf047SPaolo Bonzini * Convert string to bytes, allowing either B/b for bytes, K/k for KB, 245baacf047SPaolo Bonzini * M/m for MB, G/g for GB or T/t for TB. End pointer will be returned 246af02f4c5SDavid Hildenbrand * in *end, if not NULL. Return -ERANGE on overflow, and -EINVAL on 247baacf047SPaolo Bonzini * other error. 248baacf047SPaolo Bonzini */ 249af02f4c5SDavid Hildenbrand static int do_strtosz(const char *nptr, const char **end, 250f17fd4fdSMarkus Armbruster const char default_suffix, int64_t unit, 251f46bfdbfSMarkus Armbruster uint64_t *result) 252baacf047SPaolo Bonzini { 253f17fd4fdSMarkus Armbruster int retval; 254af02f4c5SDavid Hildenbrand const char *endptr; 255baacf047SPaolo Bonzini unsigned char c; 256baacf047SPaolo Bonzini int mul_required = 0; 257baacf047SPaolo Bonzini double val, mul, integral, fraction; 258baacf047SPaolo Bonzini 259af02f4c5SDavid Hildenbrand retval = qemu_strtod_finite(nptr, &endptr, &val); 260af02f4c5SDavid Hildenbrand if (retval) { 2614fcdf65aSMarkus Armbruster goto out; 262baacf047SPaolo Bonzini } 263baacf047SPaolo Bonzini fraction = modf(val, &integral); 264baacf047SPaolo Bonzini if (fraction != 0) { 265baacf047SPaolo Bonzini mul_required = 1; 266baacf047SPaolo Bonzini } 267baacf047SPaolo Bonzini c = *endptr; 268baacf047SPaolo Bonzini mul = suffix_mul(c, unit); 269baacf047SPaolo Bonzini if (mul >= 0) { 270baacf047SPaolo Bonzini endptr++; 271baacf047SPaolo Bonzini } else { 272baacf047SPaolo Bonzini mul = suffix_mul(default_suffix, unit); 273baacf047SPaolo Bonzini assert(mul >= 0); 274baacf047SPaolo Bonzini } 275baacf047SPaolo Bonzini if (mul == 1 && mul_required) { 2764fcdf65aSMarkus Armbruster retval = -EINVAL; 2774fcdf65aSMarkus Armbruster goto out; 278baacf047SPaolo Bonzini } 279f46bfdbfSMarkus Armbruster /* 28025f74087SFangrui Song * Values near UINT64_MAX overflow to 2**64 when converting to double 28125f74087SFangrui Song * precision. Compare against the maximum representable double precision 28225f74087SFangrui Song * value below 2**64, computed as "the next value after 2**64 (0x1p64) in 28325f74087SFangrui Song * the direction of 0". 284f46bfdbfSMarkus Armbruster */ 28525f74087SFangrui Song if ((val * mul > nextafter(0x1p64, 0)) || val < 0) { 286baacf047SPaolo Bonzini retval = -ERANGE; 2874fcdf65aSMarkus Armbruster goto out; 288baacf047SPaolo Bonzini } 289f17fd4fdSMarkus Armbruster *result = val * mul; 290f17fd4fdSMarkus Armbruster retval = 0; 291baacf047SPaolo Bonzini 2924fcdf65aSMarkus Armbruster out: 293baacf047SPaolo Bonzini if (end) { 294baacf047SPaolo Bonzini *end = endptr; 2954fcdf65aSMarkus Armbruster } else if (*endptr) { 2964fcdf65aSMarkus Armbruster retval = -EINVAL; 297baacf047SPaolo Bonzini } 298baacf047SPaolo Bonzini 299baacf047SPaolo Bonzini return retval; 300baacf047SPaolo Bonzini } 301baacf047SPaolo Bonzini 302af02f4c5SDavid Hildenbrand int qemu_strtosz(const char *nptr, const char **end, uint64_t *result) 303baacf047SPaolo Bonzini { 304f17fd4fdSMarkus Armbruster return do_strtosz(nptr, end, 'B', 1024, result); 305baacf047SPaolo Bonzini } 306baacf047SPaolo Bonzini 307af02f4c5SDavid Hildenbrand int qemu_strtosz_MiB(const char *nptr, const char **end, uint64_t *result) 308baacf047SPaolo Bonzini { 309f17fd4fdSMarkus Armbruster return do_strtosz(nptr, end, 'M', 1024, result); 310baacf047SPaolo Bonzini } 311baacf047SPaolo Bonzini 312af02f4c5SDavid Hildenbrand int qemu_strtosz_metric(const char *nptr, const char **end, uint64_t *result) 313d2734d26SMarkus Armbruster { 314f17fd4fdSMarkus Armbruster return do_strtosz(nptr, end, 'B', 1000, result); 315d2734d26SMarkus Armbruster } 316d2734d26SMarkus Armbruster 317e3f9fe2dSEduardo Habkost /** 318717adf96SMarkus Armbruster * Helper function for error checking after strtol() and the like 319764e0fa4SCarlos L. Torres */ 320717adf96SMarkus Armbruster static int check_strtox_error(const char *nptr, char *ep, 321717adf96SMarkus Armbruster const char **endptr, int libc_errno) 322764e0fa4SCarlos L. Torres { 32353a90b97SEric Blake assert(ep >= nptr); 324717adf96SMarkus Armbruster if (endptr) { 325717adf96SMarkus Armbruster *endptr = ep; 326764e0fa4SCarlos L. Torres } 3274baef267SMarkus Armbruster 3284baef267SMarkus Armbruster /* Turn "no conversion" into an error */ 3294baef267SMarkus Armbruster if (libc_errno == 0 && ep == nptr) { 3304baef267SMarkus Armbruster return -EINVAL; 3314baef267SMarkus Armbruster } 3324baef267SMarkus Armbruster 3334baef267SMarkus Armbruster /* Fail when we're expected to consume the string, but didn't */ 3344baef267SMarkus Armbruster if (!endptr && *ep) { 3354baef267SMarkus Armbruster return -EINVAL; 3364baef267SMarkus Armbruster } 3374baef267SMarkus Armbruster 338717adf96SMarkus Armbruster return -libc_errno; 339764e0fa4SCarlos L. Torres } 340764e0fa4SCarlos L. Torres 341764e0fa4SCarlos L. Torres /** 342473a2a33SDaniel P. Berrange * Convert string @nptr to an integer, and store it in @result. 343473a2a33SDaniel P. Berrange * 344473a2a33SDaniel P. Berrange * This is a wrapper around strtol() that is harder to misuse. 345473a2a33SDaniel P. Berrange * Semantics of @nptr, @endptr, @base match strtol() with differences 346473a2a33SDaniel P. Berrange * noted below. 347473a2a33SDaniel P. Berrange * 348473a2a33SDaniel P. Berrange * @nptr may be null, and no conversion is performed then. 349473a2a33SDaniel P. Berrange * 350473a2a33SDaniel P. Berrange * If no conversion is performed, store @nptr in *@endptr and return 351473a2a33SDaniel P. Berrange * -EINVAL. 352473a2a33SDaniel P. Berrange * 353473a2a33SDaniel P. Berrange * If @endptr is null, and the string isn't fully converted, return 354473a2a33SDaniel P. Berrange * -EINVAL. This is the case when the pointer that would be stored in 355473a2a33SDaniel P. Berrange * a non-null @endptr points to a character other than '\0'. 356473a2a33SDaniel P. Berrange * 357473a2a33SDaniel P. Berrange * If the conversion overflows @result, store INT_MAX in @result, 358473a2a33SDaniel P. Berrange * and return -ERANGE. 359473a2a33SDaniel P. Berrange * 360473a2a33SDaniel P. Berrange * If the conversion underflows @result, store INT_MIN in @result, 361473a2a33SDaniel P. Berrange * and return -ERANGE. 362473a2a33SDaniel P. Berrange * 363473a2a33SDaniel P. Berrange * Else store the converted value in @result, and return zero. 364473a2a33SDaniel P. Berrange */ 365473a2a33SDaniel P. Berrange int qemu_strtoi(const char *nptr, const char **endptr, int base, 366473a2a33SDaniel P. Berrange int *result) 367473a2a33SDaniel P. Berrange { 368473a2a33SDaniel P. Berrange char *ep; 369473a2a33SDaniel P. Berrange long long lresult; 370473a2a33SDaniel P. Berrange 37153a90b97SEric Blake assert((unsigned) base <= 36 && base != 1); 372473a2a33SDaniel P. Berrange if (!nptr) { 373473a2a33SDaniel P. Berrange if (endptr) { 374473a2a33SDaniel P. Berrange *endptr = nptr; 375473a2a33SDaniel P. Berrange } 376473a2a33SDaniel P. Berrange return -EINVAL; 377473a2a33SDaniel P. Berrange } 378473a2a33SDaniel P. Berrange 379473a2a33SDaniel P. Berrange errno = 0; 380473a2a33SDaniel P. Berrange lresult = strtoll(nptr, &ep, base); 381473a2a33SDaniel P. Berrange if (lresult < INT_MIN) { 382473a2a33SDaniel P. Berrange *result = INT_MIN; 383473a2a33SDaniel P. Berrange errno = ERANGE; 384473a2a33SDaniel P. Berrange } else if (lresult > INT_MAX) { 385473a2a33SDaniel P. Berrange *result = INT_MAX; 386473a2a33SDaniel P. Berrange errno = ERANGE; 387473a2a33SDaniel P. Berrange } else { 388473a2a33SDaniel P. Berrange *result = lresult; 389473a2a33SDaniel P. Berrange } 390473a2a33SDaniel P. Berrange return check_strtox_error(nptr, ep, endptr, errno); 391473a2a33SDaniel P. Berrange } 392473a2a33SDaniel P. Berrange 393473a2a33SDaniel P. Berrange /** 394473a2a33SDaniel P. Berrange * Convert string @nptr to an unsigned integer, and store it in @result. 395473a2a33SDaniel P. Berrange * 396473a2a33SDaniel P. Berrange * This is a wrapper around strtoul() that is harder to misuse. 397473a2a33SDaniel P. Berrange * Semantics of @nptr, @endptr, @base match strtoul() with differences 398473a2a33SDaniel P. Berrange * noted below. 399473a2a33SDaniel P. Berrange * 400473a2a33SDaniel P. Berrange * @nptr may be null, and no conversion is performed then. 401473a2a33SDaniel P. Berrange * 402473a2a33SDaniel P. Berrange * If no conversion is performed, store @nptr in *@endptr and return 403473a2a33SDaniel P. Berrange * -EINVAL. 404473a2a33SDaniel P. Berrange * 405473a2a33SDaniel P. Berrange * If @endptr is null, and the string isn't fully converted, return 406473a2a33SDaniel P. Berrange * -EINVAL. This is the case when the pointer that would be stored in 407473a2a33SDaniel P. Berrange * a non-null @endptr points to a character other than '\0'. 408473a2a33SDaniel P. Berrange * 409473a2a33SDaniel P. Berrange * If the conversion overflows @result, store UINT_MAX in @result, 410473a2a33SDaniel P. Berrange * and return -ERANGE. 411473a2a33SDaniel P. Berrange * 412473a2a33SDaniel P. Berrange * Else store the converted value in @result, and return zero. 413473a2a33SDaniel P. Berrange * 414473a2a33SDaniel P. Berrange * Note that a number with a leading minus sign gets converted without 415473a2a33SDaniel P. Berrange * the minus sign, checked for overflow (see above), then negated (in 416473a2a33SDaniel P. Berrange * @result's type). This is exactly how strtoul() works. 417473a2a33SDaniel P. Berrange */ 418473a2a33SDaniel P. Berrange int qemu_strtoui(const char *nptr, const char **endptr, int base, 419473a2a33SDaniel P. Berrange unsigned int *result) 420473a2a33SDaniel P. Berrange { 421473a2a33SDaniel P. Berrange char *ep; 422473a2a33SDaniel P. Berrange long long lresult; 423473a2a33SDaniel P. Berrange 42453a90b97SEric Blake assert((unsigned) base <= 36 && base != 1); 425473a2a33SDaniel P. Berrange if (!nptr) { 426473a2a33SDaniel P. Berrange if (endptr) { 427473a2a33SDaniel P. Berrange *endptr = nptr; 428473a2a33SDaniel P. Berrange } 429473a2a33SDaniel P. Berrange return -EINVAL; 430473a2a33SDaniel P. Berrange } 431473a2a33SDaniel P. Berrange 432473a2a33SDaniel P. Berrange errno = 0; 433473a2a33SDaniel P. Berrange lresult = strtoull(nptr, &ep, base); 434473a2a33SDaniel P. Berrange 435473a2a33SDaniel P. Berrange /* Windows returns 1 for negative out-of-range values. */ 436473a2a33SDaniel P. Berrange if (errno == ERANGE) { 437473a2a33SDaniel P. Berrange *result = -1; 438473a2a33SDaniel P. Berrange } else { 439473a2a33SDaniel P. Berrange if (lresult > UINT_MAX) { 440473a2a33SDaniel P. Berrange *result = UINT_MAX; 441473a2a33SDaniel P. Berrange errno = ERANGE; 442473a2a33SDaniel P. Berrange } else if (lresult < INT_MIN) { 443473a2a33SDaniel P. Berrange *result = UINT_MAX; 444473a2a33SDaniel P. Berrange errno = ERANGE; 445473a2a33SDaniel P. Berrange } else { 446473a2a33SDaniel P. Berrange *result = lresult; 447473a2a33SDaniel P. Berrange } 448473a2a33SDaniel P. Berrange } 449473a2a33SDaniel P. Berrange return check_strtox_error(nptr, ep, endptr, errno); 450473a2a33SDaniel P. Berrange } 451473a2a33SDaniel P. Berrange 452473a2a33SDaniel P. Berrange /** 4534295f879SMarkus Armbruster * Convert string @nptr to a long integer, and store it in @result. 454764e0fa4SCarlos L. Torres * 4554295f879SMarkus Armbruster * This is a wrapper around strtol() that is harder to misuse. 4564295f879SMarkus Armbruster * Semantics of @nptr, @endptr, @base match strtol() with differences 4574295f879SMarkus Armbruster * noted below. 458764e0fa4SCarlos L. Torres * 4594295f879SMarkus Armbruster * @nptr may be null, and no conversion is performed then. 460764e0fa4SCarlos L. Torres * 4614295f879SMarkus Armbruster * If no conversion is performed, store @nptr in *@endptr and return 4624295f879SMarkus Armbruster * -EINVAL. 463764e0fa4SCarlos L. Torres * 4644295f879SMarkus Armbruster * If @endptr is null, and the string isn't fully converted, return 4654295f879SMarkus Armbruster * -EINVAL. This is the case when the pointer that would be stored in 4664295f879SMarkus Armbruster * a non-null @endptr points to a character other than '\0'. 4674295f879SMarkus Armbruster * 4684295f879SMarkus Armbruster * If the conversion overflows @result, store LONG_MAX in @result, 4694295f879SMarkus Armbruster * and return -ERANGE. 4704295f879SMarkus Armbruster * 4714295f879SMarkus Armbruster * If the conversion underflows @result, store LONG_MIN in @result, 4724295f879SMarkus Armbruster * and return -ERANGE. 4734295f879SMarkus Armbruster * 4744295f879SMarkus Armbruster * Else store the converted value in @result, and return zero. 475764e0fa4SCarlos L. Torres */ 476764e0fa4SCarlos L. Torres int qemu_strtol(const char *nptr, const char **endptr, int base, 477764e0fa4SCarlos L. Torres long *result) 478764e0fa4SCarlos L. Torres { 479717adf96SMarkus Armbruster char *ep; 4804baef267SMarkus Armbruster 48153a90b97SEric Blake assert((unsigned) base <= 36 && base != 1); 482764e0fa4SCarlos L. Torres if (!nptr) { 483764e0fa4SCarlos L. Torres if (endptr) { 484764e0fa4SCarlos L. Torres *endptr = nptr; 485764e0fa4SCarlos L. Torres } 4864baef267SMarkus Armbruster return -EINVAL; 4874baef267SMarkus Armbruster } 4884baef267SMarkus Armbruster 489764e0fa4SCarlos L. Torres errno = 0; 490717adf96SMarkus Armbruster *result = strtol(nptr, &ep, base); 4914baef267SMarkus Armbruster return check_strtox_error(nptr, ep, endptr, errno); 492764e0fa4SCarlos L. Torres } 493c817c015SCarlos L. Torres 494c817c015SCarlos L. Torres /** 4954295f879SMarkus Armbruster * Convert string @nptr to an unsigned long, and store it in @result. 496c817c015SCarlos L. Torres * 4974295f879SMarkus Armbruster * This is a wrapper around strtoul() that is harder to misuse. 4984295f879SMarkus Armbruster * Semantics of @nptr, @endptr, @base match strtoul() with differences 4994295f879SMarkus Armbruster * noted below. 500c817c015SCarlos L. Torres * 5014295f879SMarkus Armbruster * @nptr may be null, and no conversion is performed then. 502c817c015SCarlos L. Torres * 5034295f879SMarkus Armbruster * If no conversion is performed, store @nptr in *@endptr and return 5044295f879SMarkus Armbruster * -EINVAL. 5054295f879SMarkus Armbruster * 5064295f879SMarkus Armbruster * If @endptr is null, and the string isn't fully converted, return 5074295f879SMarkus Armbruster * -EINVAL. This is the case when the pointer that would be stored in 5084295f879SMarkus Armbruster * a non-null @endptr points to a character other than '\0'. 5094295f879SMarkus Armbruster * 5104295f879SMarkus Armbruster * If the conversion overflows @result, store ULONG_MAX in @result, 5114295f879SMarkus Armbruster * and return -ERANGE. 5124295f879SMarkus Armbruster * 5134295f879SMarkus Armbruster * Else store the converted value in @result, and return zero. 5144295f879SMarkus Armbruster * 5154295f879SMarkus Armbruster * Note that a number with a leading minus sign gets converted without 5164295f879SMarkus Armbruster * the minus sign, checked for overflow (see above), then negated (in 5174295f879SMarkus Armbruster * @result's type). This is exactly how strtoul() works. 518c817c015SCarlos L. Torres */ 519c817c015SCarlos L. Torres int qemu_strtoul(const char *nptr, const char **endptr, int base, 520c817c015SCarlos L. Torres unsigned long *result) 521c817c015SCarlos L. Torres { 522717adf96SMarkus Armbruster char *ep; 5234baef267SMarkus Armbruster 52453a90b97SEric Blake assert((unsigned) base <= 36 && base != 1); 525c817c015SCarlos L. Torres if (!nptr) { 526c817c015SCarlos L. Torres if (endptr) { 527c817c015SCarlos L. Torres *endptr = nptr; 528c817c015SCarlos L. Torres } 5294baef267SMarkus Armbruster return -EINVAL; 5304baef267SMarkus Armbruster } 5314baef267SMarkus Armbruster 532c817c015SCarlos L. Torres errno = 0; 533717adf96SMarkus Armbruster *result = strtoul(nptr, &ep, base); 53447d4be12SPaolo Bonzini /* Windows returns 1 for negative out-of-range values. */ 53547d4be12SPaolo Bonzini if (errno == ERANGE) { 53647d4be12SPaolo Bonzini *result = -1; 53747d4be12SPaolo Bonzini } 5384baef267SMarkus Armbruster return check_strtox_error(nptr, ep, endptr, errno); 539c817c015SCarlos L. Torres } 540c817c015SCarlos L. Torres 541764e0fa4SCarlos L. Torres /** 5424295f879SMarkus Armbruster * Convert string @nptr to an int64_t. 5438ac4df40SCarlos L. Torres * 5444295f879SMarkus Armbruster * Works like qemu_strtol(), except it stores INT64_MAX on overflow, 545369276ebSMarkus Armbruster * and INT64_MIN on underflow. 5468ac4df40SCarlos L. Torres */ 547b30d1886SMarkus Armbruster int qemu_strtoi64(const char *nptr, const char **endptr, int base, 5488ac4df40SCarlos L. Torres int64_t *result) 5498ac4df40SCarlos L. Torres { 550717adf96SMarkus Armbruster char *ep; 5514baef267SMarkus Armbruster 55253a90b97SEric Blake assert((unsigned) base <= 36 && base != 1); 5538ac4df40SCarlos L. Torres if (!nptr) { 5548ac4df40SCarlos L. Torres if (endptr) { 5558ac4df40SCarlos L. Torres *endptr = nptr; 5568ac4df40SCarlos L. Torres } 5574baef267SMarkus Armbruster return -EINVAL; 5584baef267SMarkus Armbruster } 5594baef267SMarkus Armbruster 560369276ebSMarkus Armbruster /* This assumes int64_t is long long TODO relax */ 561369276ebSMarkus Armbruster QEMU_BUILD_BUG_ON(sizeof(int64_t) != sizeof(long long)); 5628ac4df40SCarlos L. Torres errno = 0; 563717adf96SMarkus Armbruster *result = strtoll(nptr, &ep, base); 5644baef267SMarkus Armbruster return check_strtox_error(nptr, ep, endptr, errno); 5658ac4df40SCarlos L. Torres } 5668ac4df40SCarlos L. Torres 5678ac4df40SCarlos L. Torres /** 5684295f879SMarkus Armbruster * Convert string @nptr to an uint64_t. 5693904e6bfSCarlos L. Torres * 5704295f879SMarkus Armbruster * Works like qemu_strtoul(), except it stores UINT64_MAX on overflow. 5713904e6bfSCarlos L. Torres */ 572b30d1886SMarkus Armbruster int qemu_strtou64(const char *nptr, const char **endptr, int base, 5733904e6bfSCarlos L. Torres uint64_t *result) 5743904e6bfSCarlos L. Torres { 575717adf96SMarkus Armbruster char *ep; 5764baef267SMarkus Armbruster 57753a90b97SEric Blake assert((unsigned) base <= 36 && base != 1); 5783904e6bfSCarlos L. Torres if (!nptr) { 5793904e6bfSCarlos L. Torres if (endptr) { 5803904e6bfSCarlos L. Torres *endptr = nptr; 5813904e6bfSCarlos L. Torres } 5824baef267SMarkus Armbruster return -EINVAL; 5834baef267SMarkus Armbruster } 5844baef267SMarkus Armbruster 585369276ebSMarkus Armbruster /* This assumes uint64_t is unsigned long long TODO relax */ 586369276ebSMarkus Armbruster QEMU_BUILD_BUG_ON(sizeof(uint64_t) != sizeof(unsigned long long)); 5873904e6bfSCarlos L. Torres errno = 0; 588717adf96SMarkus Armbruster *result = strtoull(nptr, &ep, base); 58947d4be12SPaolo Bonzini /* Windows returns 1 for negative out-of-range values. */ 59047d4be12SPaolo Bonzini if (errno == ERANGE) { 59147d4be12SPaolo Bonzini *result = -1; 59247d4be12SPaolo Bonzini } 5934baef267SMarkus Armbruster return check_strtox_error(nptr, ep, endptr, errno); 5943904e6bfSCarlos L. Torres } 5953904e6bfSCarlos L. Torres 5963904e6bfSCarlos L. Torres /** 597ca28f548SDavid Hildenbrand * Convert string @nptr to a double. 598ca28f548SDavid Hildenbrand * 599ca28f548SDavid Hildenbrand * This is a wrapper around strtod() that is harder to misuse. 600ca28f548SDavid Hildenbrand * Semantics of @nptr and @endptr match strtod() with differences 601ca28f548SDavid Hildenbrand * noted below. 602ca28f548SDavid Hildenbrand * 603ca28f548SDavid Hildenbrand * @nptr may be null, and no conversion is performed then. 604ca28f548SDavid Hildenbrand * 605ca28f548SDavid Hildenbrand * If no conversion is performed, store @nptr in *@endptr and return 606ca28f548SDavid Hildenbrand * -EINVAL. 607ca28f548SDavid Hildenbrand * 608ca28f548SDavid Hildenbrand * If @endptr is null, and the string isn't fully converted, return 609ca28f548SDavid Hildenbrand * -EINVAL. This is the case when the pointer that would be stored in 610ca28f548SDavid Hildenbrand * a non-null @endptr points to a character other than '\0'. 611ca28f548SDavid Hildenbrand * 612ca28f548SDavid Hildenbrand * If the conversion overflows, store +/-HUGE_VAL in @result, depending 613ca28f548SDavid Hildenbrand * on the sign, and return -ERANGE. 614ca28f548SDavid Hildenbrand * 615ca28f548SDavid Hildenbrand * If the conversion underflows, store +/-0.0 in @result, depending on the 616ca28f548SDavid Hildenbrand * sign, and return -ERANGE. 617ca28f548SDavid Hildenbrand * 618ca28f548SDavid Hildenbrand * Else store the converted value in @result, and return zero. 619ca28f548SDavid Hildenbrand */ 620ca28f548SDavid Hildenbrand int qemu_strtod(const char *nptr, const char **endptr, double *result) 621ca28f548SDavid Hildenbrand { 622ca28f548SDavid Hildenbrand char *ep; 623ca28f548SDavid Hildenbrand 624ca28f548SDavid Hildenbrand if (!nptr) { 625ca28f548SDavid Hildenbrand if (endptr) { 626ca28f548SDavid Hildenbrand *endptr = nptr; 627ca28f548SDavid Hildenbrand } 628ca28f548SDavid Hildenbrand return -EINVAL; 629ca28f548SDavid Hildenbrand } 630ca28f548SDavid Hildenbrand 631ca28f548SDavid Hildenbrand errno = 0; 632ca28f548SDavid Hildenbrand *result = strtod(nptr, &ep); 633ca28f548SDavid Hildenbrand return check_strtox_error(nptr, ep, endptr, errno); 634ca28f548SDavid Hildenbrand } 635ca28f548SDavid Hildenbrand 636ca28f548SDavid Hildenbrand /** 637ca28f548SDavid Hildenbrand * Convert string @nptr to a finite double. 638ca28f548SDavid Hildenbrand * 639ca28f548SDavid Hildenbrand * Works like qemu_strtod(), except that "NaN" and "inf" are rejected 640ca28f548SDavid Hildenbrand * with -EINVAL and no conversion is performed. 641ca28f548SDavid Hildenbrand */ 642ca28f548SDavid Hildenbrand int qemu_strtod_finite(const char *nptr, const char **endptr, double *result) 643ca28f548SDavid Hildenbrand { 644ca28f548SDavid Hildenbrand double tmp; 645ca28f548SDavid Hildenbrand int ret; 646ca28f548SDavid Hildenbrand 647ca28f548SDavid Hildenbrand ret = qemu_strtod(nptr, endptr, &tmp); 648ca28f548SDavid Hildenbrand if (!ret && !isfinite(tmp)) { 649ca28f548SDavid Hildenbrand if (endptr) { 650ca28f548SDavid Hildenbrand *endptr = nptr; 651ca28f548SDavid Hildenbrand } 652ca28f548SDavid Hildenbrand ret = -EINVAL; 653ca28f548SDavid Hildenbrand } 654ca28f548SDavid Hildenbrand 655ca28f548SDavid Hildenbrand if (ret != -EINVAL) { 656ca28f548SDavid Hildenbrand *result = tmp; 657ca28f548SDavid Hildenbrand } 658ca28f548SDavid Hildenbrand return ret; 659ca28f548SDavid Hildenbrand } 660ca28f548SDavid Hildenbrand 661ca28f548SDavid Hildenbrand /** 6625c99fa37SKeno Fischer * Searches for the first occurrence of 'c' in 's', and returns a pointer 6635c99fa37SKeno Fischer * to the trailing null byte if none was found. 6645c99fa37SKeno Fischer */ 6655c99fa37SKeno Fischer #ifndef HAVE_STRCHRNUL 6665c99fa37SKeno Fischer const char *qemu_strchrnul(const char *s, int c) 6675c99fa37SKeno Fischer { 6685c99fa37SKeno Fischer const char *e = strchr(s, c); 6695c99fa37SKeno Fischer if (!e) { 6705c99fa37SKeno Fischer e = s + strlen(s); 6715c99fa37SKeno Fischer } 6725c99fa37SKeno Fischer return e; 6735c99fa37SKeno Fischer } 6745c99fa37SKeno Fischer #endif 6755c99fa37SKeno Fischer 6765c99fa37SKeno Fischer /** 677e3f9fe2dSEduardo Habkost * parse_uint: 678e3f9fe2dSEduardo Habkost * 679e3f9fe2dSEduardo Habkost * @s: String to parse 680e3f9fe2dSEduardo Habkost * @value: Destination for parsed integer value 681e3f9fe2dSEduardo Habkost * @endptr: Destination for pointer to first character not consumed 682e3f9fe2dSEduardo Habkost * @base: integer base, between 2 and 36 inclusive, or 0 683e3f9fe2dSEduardo Habkost * 684e3f9fe2dSEduardo Habkost * Parse unsigned integer 685e3f9fe2dSEduardo Habkost * 686e3f9fe2dSEduardo Habkost * Parsed syntax is like strtoull()'s: arbitrary whitespace, a single optional 687e3f9fe2dSEduardo Habkost * '+' or '-', an optional "0x" if @base is 0 or 16, one or more digits. 688e3f9fe2dSEduardo Habkost * 689e3f9fe2dSEduardo Habkost * If @s is null, or @base is invalid, or @s doesn't start with an 690e3f9fe2dSEduardo Habkost * integer in the syntax above, set *@value to 0, *@endptr to @s, and 691e3f9fe2dSEduardo Habkost * return -EINVAL. 692e3f9fe2dSEduardo Habkost * 693e3f9fe2dSEduardo Habkost * Set *@endptr to point right beyond the parsed integer (even if the integer 694e3f9fe2dSEduardo Habkost * overflows or is negative, all digits will be parsed and *@endptr will 695e3f9fe2dSEduardo Habkost * point right beyond them). 696e3f9fe2dSEduardo Habkost * 697e3f9fe2dSEduardo Habkost * If the integer is negative, set *@value to 0, and return -ERANGE. 698e3f9fe2dSEduardo Habkost * 699e3f9fe2dSEduardo Habkost * If the integer overflows unsigned long long, set *@value to 700e3f9fe2dSEduardo Habkost * ULLONG_MAX, and return -ERANGE. 701e3f9fe2dSEduardo Habkost * 702e3f9fe2dSEduardo Habkost * Else, set *@value to the parsed integer, and return 0. 703e3f9fe2dSEduardo Habkost */ 704e3f9fe2dSEduardo Habkost int parse_uint(const char *s, unsigned long long *value, char **endptr, 705e3f9fe2dSEduardo Habkost int base) 706e3f9fe2dSEduardo Habkost { 707e3f9fe2dSEduardo Habkost int r = 0; 708e3f9fe2dSEduardo Habkost char *endp = (char *)s; 709e3f9fe2dSEduardo Habkost unsigned long long val = 0; 710e3f9fe2dSEduardo Habkost 71153a90b97SEric Blake assert((unsigned) base <= 36 && base != 1); 712e3f9fe2dSEduardo Habkost if (!s) { 713e3f9fe2dSEduardo Habkost r = -EINVAL; 714e3f9fe2dSEduardo Habkost goto out; 715e3f9fe2dSEduardo Habkost } 716e3f9fe2dSEduardo Habkost 717e3f9fe2dSEduardo Habkost errno = 0; 718e3f9fe2dSEduardo Habkost val = strtoull(s, &endp, base); 719e3f9fe2dSEduardo Habkost if (errno) { 720e3f9fe2dSEduardo Habkost r = -errno; 721e3f9fe2dSEduardo Habkost goto out; 722e3f9fe2dSEduardo Habkost } 723e3f9fe2dSEduardo Habkost 724e3f9fe2dSEduardo Habkost if (endp == s) { 725e3f9fe2dSEduardo Habkost r = -EINVAL; 726e3f9fe2dSEduardo Habkost goto out; 727e3f9fe2dSEduardo Habkost } 728e3f9fe2dSEduardo Habkost 729e3f9fe2dSEduardo Habkost /* make sure we reject negative numbers: */ 730db3d11eeSMarkus Armbruster while (qemu_isspace(*s)) { 731e3f9fe2dSEduardo Habkost s++; 732e3f9fe2dSEduardo Habkost } 733e3f9fe2dSEduardo Habkost if (*s == '-') { 734e3f9fe2dSEduardo Habkost val = 0; 735e3f9fe2dSEduardo Habkost r = -ERANGE; 736e3f9fe2dSEduardo Habkost goto out; 737e3f9fe2dSEduardo Habkost } 738e3f9fe2dSEduardo Habkost 739e3f9fe2dSEduardo Habkost out: 740e3f9fe2dSEduardo Habkost *value = val; 741e3f9fe2dSEduardo Habkost *endptr = endp; 742e3f9fe2dSEduardo Habkost return r; 743e3f9fe2dSEduardo Habkost } 744e3f9fe2dSEduardo Habkost 745e3f9fe2dSEduardo Habkost /** 746e3f9fe2dSEduardo Habkost * parse_uint_full: 747e3f9fe2dSEduardo Habkost * 748e3f9fe2dSEduardo Habkost * @s: String to parse 749e3f9fe2dSEduardo Habkost * @value: Destination for parsed integer value 750e3f9fe2dSEduardo Habkost * @base: integer base, between 2 and 36 inclusive, or 0 751e3f9fe2dSEduardo Habkost * 752e3f9fe2dSEduardo Habkost * Parse unsigned integer from entire string 753e3f9fe2dSEduardo Habkost * 754e3f9fe2dSEduardo Habkost * Have the same behavior of parse_uint(), but with an additional check 755e3f9fe2dSEduardo Habkost * for additional data after the parsed number. If extra characters are present 756e3f9fe2dSEduardo Habkost * after the parsed number, the function will return -EINVAL, and *@v will 757e3f9fe2dSEduardo Habkost * be set to 0. 758e3f9fe2dSEduardo Habkost */ 759e3f9fe2dSEduardo Habkost int parse_uint_full(const char *s, unsigned long long *value, int base) 760e3f9fe2dSEduardo Habkost { 761e3f9fe2dSEduardo Habkost char *endp; 762e3f9fe2dSEduardo Habkost int r; 763e3f9fe2dSEduardo Habkost 764e3f9fe2dSEduardo Habkost r = parse_uint(s, value, &endp, base); 765e3f9fe2dSEduardo Habkost if (r < 0) { 766e3f9fe2dSEduardo Habkost return r; 767e3f9fe2dSEduardo Habkost } 768e3f9fe2dSEduardo Habkost if (*endp) { 769e3f9fe2dSEduardo Habkost *value = 0; 770e3f9fe2dSEduardo Habkost return -EINVAL; 771e3f9fe2dSEduardo Habkost } 772e3f9fe2dSEduardo Habkost 773e3f9fe2dSEduardo Habkost return 0; 774e3f9fe2dSEduardo Habkost } 775e3f9fe2dSEduardo Habkost 776baacf047SPaolo Bonzini int qemu_parse_fd(const char *param) 777baacf047SPaolo Bonzini { 778e9c5c1f4SLaszlo Ersek long fd; 779e9c5c1f4SLaszlo Ersek char *endptr; 780baacf047SPaolo Bonzini 781e9c5c1f4SLaszlo Ersek errno = 0; 782baacf047SPaolo Bonzini fd = strtol(param, &endptr, 10); 783e9c5c1f4SLaszlo Ersek if (param == endptr /* no conversion performed */ || 784e9c5c1f4SLaszlo Ersek errno != 0 /* not representable as long; possibly others */ || 785e9c5c1f4SLaszlo Ersek *endptr != '\0' /* final string not empty */ || 786e9c5c1f4SLaszlo Ersek fd < 0 /* invalid as file descriptor */ || 787e9c5c1f4SLaszlo Ersek fd > INT_MAX /* not representable as int */) { 788baacf047SPaolo Bonzini return -1; 789baacf047SPaolo Bonzini } 790baacf047SPaolo Bonzini return fd; 791baacf047SPaolo Bonzini } 792baacf047SPaolo Bonzini 793baacf047SPaolo Bonzini /* 794baacf047SPaolo Bonzini * Implementation of ULEB128 (http://en.wikipedia.org/wiki/LEB128) 795baacf047SPaolo Bonzini * Input is limited to 14-bit numbers 796baacf047SPaolo Bonzini */ 797baacf047SPaolo Bonzini int uleb128_encode_small(uint8_t *out, uint32_t n) 798baacf047SPaolo Bonzini { 799baacf047SPaolo Bonzini g_assert(n <= 0x3fff); 800baacf047SPaolo Bonzini if (n < 0x80) { 8017c960d61SWei Yang *out = n; 802baacf047SPaolo Bonzini return 1; 803baacf047SPaolo Bonzini } else { 804baacf047SPaolo Bonzini *out++ = (n & 0x7f) | 0x80; 8057c960d61SWei Yang *out = n >> 7; 806baacf047SPaolo Bonzini return 2; 807baacf047SPaolo Bonzini } 808baacf047SPaolo Bonzini } 809baacf047SPaolo Bonzini 810baacf047SPaolo Bonzini int uleb128_decode_small(const uint8_t *in, uint32_t *n) 811baacf047SPaolo Bonzini { 812baacf047SPaolo Bonzini if (!(*in & 0x80)) { 8137c960d61SWei Yang *n = *in; 814baacf047SPaolo Bonzini return 1; 815baacf047SPaolo Bonzini } else { 816baacf047SPaolo Bonzini *n = *in++ & 0x7f; 817baacf047SPaolo Bonzini /* we exceed 14 bit number */ 818baacf047SPaolo Bonzini if (*in & 0x80) { 819baacf047SPaolo Bonzini return -1; 820baacf047SPaolo Bonzini } 8217c960d61SWei Yang *n |= *in << 7; 822baacf047SPaolo Bonzini return 2; 823baacf047SPaolo Bonzini } 824baacf047SPaolo Bonzini } 825b16352acSAlon Levy 826b16352acSAlon Levy /* 827b16352acSAlon Levy * helper to parse debug environment variables 828b16352acSAlon Levy */ 829b16352acSAlon Levy int parse_debug_env(const char *name, int max, int initial) 830b16352acSAlon Levy { 831b16352acSAlon Levy char *debug_env = getenv(name); 832b16352acSAlon Levy char *inv = NULL; 833cc5d0e04SPaolo Bonzini long debug; 834b16352acSAlon Levy 835b16352acSAlon Levy if (!debug_env) { 836b16352acSAlon Levy return initial; 837b16352acSAlon Levy } 838cc5d0e04SPaolo Bonzini errno = 0; 839b16352acSAlon Levy debug = strtol(debug_env, &inv, 10); 840b16352acSAlon Levy if (inv == debug_env) { 841b16352acSAlon Levy return initial; 842b16352acSAlon Levy } 843cc5d0e04SPaolo Bonzini if (debug < 0 || debug > max || errno != 0) { 84405cb8ed5SAlistair Francis warn_report("%s not in [0, %d]", name, max); 845b16352acSAlon Levy return initial; 846b16352acSAlon Levy } 847b16352acSAlon Levy return debug; 848b16352acSAlon Levy } 8494297c8eeSAlexey Kardashevskiy 8504297c8eeSAlexey Kardashevskiy /* 8514297c8eeSAlexey Kardashevskiy * Helper to print ethernet mac address 8524297c8eeSAlexey Kardashevskiy */ 8534297c8eeSAlexey Kardashevskiy const char *qemu_ether_ntoa(const MACAddr *mac) 8544297c8eeSAlexey Kardashevskiy { 8554297c8eeSAlexey Kardashevskiy static char ret[18]; 8564297c8eeSAlexey Kardashevskiy 8574297c8eeSAlexey Kardashevskiy snprintf(ret, sizeof(ret), "%02x:%02x:%02x:%02x:%02x:%02x", 8584297c8eeSAlexey Kardashevskiy mac->a[0], mac->a[1], mac->a[2], mac->a[3], mac->a[4], mac->a[5]); 8594297c8eeSAlexey Kardashevskiy 8604297c8eeSAlexey Kardashevskiy return ret; 8614297c8eeSAlexey Kardashevskiy } 86222951aaaSPeter Xu 86322951aaaSPeter Xu /* 86422951aaaSPeter Xu * Return human readable string for size @val. 86522951aaaSPeter Xu * @val can be anything that uint64_t allows (no more than "16 EiB"). 86622951aaaSPeter Xu * Use IEC binary units like KiB, MiB, and so forth. 86722951aaaSPeter Xu * Caller is responsible for passing it to g_free(). 86822951aaaSPeter Xu */ 86922951aaaSPeter Xu char *size_to_str(uint64_t val) 87022951aaaSPeter Xu { 87122951aaaSPeter Xu static const char *suffixes[] = { "", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei" }; 872754da867SEric Blake uint64_t div; 87322951aaaSPeter Xu int i; 87422951aaaSPeter Xu 87522951aaaSPeter Xu /* 87622951aaaSPeter Xu * The exponent (returned in i) minus one gives us 87722951aaaSPeter Xu * floor(log2(val * 1024 / 1000). The correction makes us 87822951aaaSPeter Xu * switch to the higher power when the integer part is >= 1000. 87922951aaaSPeter Xu * (see e41b509d68afb1f for more info) 88022951aaaSPeter Xu */ 88122951aaaSPeter Xu frexp(val / (1000.0 / 1024.0), &i); 88222951aaaSPeter Xu i = (i - 1) / 10; 88322951aaaSPeter Xu div = 1ULL << (i * 10); 88422951aaaSPeter Xu 88522951aaaSPeter Xu return g_strdup_printf("%0.3g %sB", (double)val / div, suffixes[i]); 88622951aaaSPeter Xu } 88785e33a28SMarc-André Lureau 888709616c7SPhilippe Mathieu-Daudé char *freq_to_str(uint64_t freq_hz) 889709616c7SPhilippe Mathieu-Daudé { 890709616c7SPhilippe Mathieu-Daudé static const char *const suffixes[] = { "", "K", "M", "G", "T", "P", "E" }; 891709616c7SPhilippe Mathieu-Daudé double freq = freq_hz; 892709616c7SPhilippe Mathieu-Daudé size_t idx = 0; 893709616c7SPhilippe Mathieu-Daudé 894709616c7SPhilippe Mathieu-Daudé while (freq >= 1000.0 && idx < ARRAY_SIZE(suffixes)) { 895709616c7SPhilippe Mathieu-Daudé freq /= 1000.0; 896709616c7SPhilippe Mathieu-Daudé idx++; 897709616c7SPhilippe Mathieu-Daudé } 898709616c7SPhilippe Mathieu-Daudé 899709616c7SPhilippe Mathieu-Daudé return g_strdup_printf("%0.3g %sHz", freq, suffixes[idx]); 900709616c7SPhilippe Mathieu-Daudé } 901709616c7SPhilippe Mathieu-Daudé 90285e33a28SMarc-André Lureau int qemu_pstrcmp0(const char **str1, const char **str2) 90385e33a28SMarc-André Lureau { 90485e33a28SMarc-André Lureau return g_strcmp0(*str1, *str2); 90585e33a28SMarc-André Lureau } 906f4f5ed2cSPaolo Bonzini 907f4f5ed2cSPaolo Bonzini static inline bool starts_with_prefix(const char *dir) 908f4f5ed2cSPaolo Bonzini { 909f4f5ed2cSPaolo Bonzini size_t prefix_len = strlen(CONFIG_PREFIX); 910f4f5ed2cSPaolo Bonzini return !memcmp(dir, CONFIG_PREFIX, prefix_len) && 911f4f5ed2cSPaolo Bonzini (!dir[prefix_len] || G_IS_DIR_SEPARATOR(dir[prefix_len])); 912f4f5ed2cSPaolo Bonzini } 913f4f5ed2cSPaolo Bonzini 914f4f5ed2cSPaolo Bonzini /* Return the next path component in dir, and store its length in *p_len. */ 915f4f5ed2cSPaolo Bonzini static inline const char *next_component(const char *dir, int *p_len) 916f4f5ed2cSPaolo Bonzini { 917f4f5ed2cSPaolo Bonzini int len; 918f4f5ed2cSPaolo Bonzini while (*dir && G_IS_DIR_SEPARATOR(*dir)) { 919f4f5ed2cSPaolo Bonzini dir++; 920f4f5ed2cSPaolo Bonzini } 921f4f5ed2cSPaolo Bonzini len = 0; 922f4f5ed2cSPaolo Bonzini while (dir[len] && !G_IS_DIR_SEPARATOR(dir[len])) { 923f4f5ed2cSPaolo Bonzini len++; 924f4f5ed2cSPaolo Bonzini } 925f4f5ed2cSPaolo Bonzini *p_len = len; 926f4f5ed2cSPaolo Bonzini return dir; 927f4f5ed2cSPaolo Bonzini } 928f4f5ed2cSPaolo Bonzini 929f4f5ed2cSPaolo Bonzini char *get_relocated_path(const char *dir) 930f4f5ed2cSPaolo Bonzini { 931f4f5ed2cSPaolo Bonzini size_t prefix_len = strlen(CONFIG_PREFIX); 932f4f5ed2cSPaolo Bonzini const char *bindir = CONFIG_BINDIR; 933f4f5ed2cSPaolo Bonzini const char *exec_dir = qemu_get_exec_dir(); 934f4f5ed2cSPaolo Bonzini GString *result; 935f4f5ed2cSPaolo Bonzini int len_dir, len_bindir; 936f4f5ed2cSPaolo Bonzini 937f4f5ed2cSPaolo Bonzini /* Fail if qemu_init_exec_dir was not called. */ 938f4f5ed2cSPaolo Bonzini assert(exec_dir[0]); 939f4f5ed2cSPaolo Bonzini if (!starts_with_prefix(dir) || !starts_with_prefix(bindir)) { 940*090afdc5SPaolo Bonzini return g_strdup(dir); 941f4f5ed2cSPaolo Bonzini } 942f4f5ed2cSPaolo Bonzini 943f4f5ed2cSPaolo Bonzini result = g_string_new(exec_dir); 944f4f5ed2cSPaolo Bonzini 945f4f5ed2cSPaolo Bonzini /* Advance over common components. */ 946f4f5ed2cSPaolo Bonzini len_dir = len_bindir = prefix_len; 947f4f5ed2cSPaolo Bonzini do { 948f4f5ed2cSPaolo Bonzini dir += len_dir; 949f4f5ed2cSPaolo Bonzini bindir += len_bindir; 950f4f5ed2cSPaolo Bonzini dir = next_component(dir, &len_dir); 951f4f5ed2cSPaolo Bonzini bindir = next_component(bindir, &len_bindir); 9527a3b7f6bSSunil Muthuswamy } while (len_dir && len_dir == len_bindir && !memcmp(dir, bindir, len_dir)); 953f4f5ed2cSPaolo Bonzini 954f4f5ed2cSPaolo Bonzini /* Ascend from bindir to the common prefix with dir. */ 955f4f5ed2cSPaolo Bonzini while (len_bindir) { 956f4f5ed2cSPaolo Bonzini bindir += len_bindir; 957f4f5ed2cSPaolo Bonzini g_string_append(result, "/.."); 958f4f5ed2cSPaolo Bonzini bindir = next_component(bindir, &len_bindir); 959f4f5ed2cSPaolo Bonzini } 960f4f5ed2cSPaolo Bonzini 961f4f5ed2cSPaolo Bonzini if (*dir) { 962f4f5ed2cSPaolo Bonzini assert(G_IS_DIR_SEPARATOR(dir[-1])); 963f4f5ed2cSPaolo Bonzini g_string_append(result, dir - 1); 964f4f5ed2cSPaolo Bonzini } 965f4f5ed2cSPaolo Bonzini return result->str; 966f4f5ed2cSPaolo Bonzini } 967