bellard | 18607dc | 2007-01-07 22:04:40 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Simple C functions to supplement the C library |
ths | 5fafdf2 | 2007-09-16 21:08:06 +0000 | [diff] [blame] | 3 | * |
bellard | 18607dc | 2007-01-07 22:04:40 +0000 | [diff] [blame] | 4 | * Copyright (c) 2006 Fabrice Bellard |
| 5 | * |
| 6 | * Permission is hereby granted, free of charge, to any person obtaining a copy |
| 7 | * of this software and associated documentation files (the "Software"), to deal |
| 8 | * in the Software without restriction, including without limitation the rights |
| 9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
| 10 | * copies of the Software, and to permit persons to whom the Software is |
| 11 | * furnished to do so, subject to the following conditions: |
| 12 | * |
| 13 | * The above copyright notice and this permission notice shall be included in |
| 14 | * all copies or substantial portions of the Software. |
| 15 | * |
| 16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| 17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| 18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
| 19 | * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| 20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| 21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
| 22 | * THE SOFTWARE. |
| 23 | */ |
Peter Maydell | aafd758 | 2016-01-29 17:49:55 +0000 | [diff] [blame] | 24 | #include "qemu/osdep.h" |
pbrook | faf0796 | 2007-11-11 02:51:17 +0000 | [diff] [blame] | 25 | #include "qemu-common.h" |
Paolo Bonzini | 1de7afc | 2012-12-17 18:20:00 +0100 | [diff] [blame] | 26 | #include "qemu/host-utils.h" |
Jes Sorensen | 9f9b17a | 2010-10-21 17:15:46 +0200 | [diff] [blame] | 27 | #include <math.h> |
bellard | 18607dc | 2007-01-07 22:04:40 +0000 | [diff] [blame] | 28 | |
Paolo Bonzini | 1de7afc | 2012-12-17 18:20:00 +0100 | [diff] [blame] | 29 | #include "qemu/sockets.h" |
| 30 | #include "qemu/iov.h" |
Alexey Kardashevskiy | 4297c8e | 2014-03-11 10:42:26 +1100 | [diff] [blame] | 31 | #include "net/net.h" |
Veronia Bahaa | f348b6d | 2016-03-20 19:16:19 +0200 | [diff] [blame] | 32 | #include "qemu/cutils.h" |
Paolo Bonzini | 8c5135f | 2011-09-08 13:46:25 +0200 | [diff] [blame] | 33 | |
Dmitry Fleytman | 2a025ae | 2012-07-09 08:50:43 +0200 | [diff] [blame] | 34 | void strpadcpy(char *buf, int buf_size, const char *str, char pad) |
| 35 | { |
| 36 | int len = qemu_strnlen(str, buf_size); |
| 37 | memcpy(buf, str, len); |
| 38 | memset(buf + len, pad, buf_size - len); |
| 39 | } |
| 40 | |
bellard | 18607dc | 2007-01-07 22:04:40 +0000 | [diff] [blame] | 41 | void pstrcpy(char *buf, int buf_size, const char *str) |
| 42 | { |
| 43 | int c; |
| 44 | char *q = buf; |
| 45 | |
| 46 | if (buf_size <= 0) |
| 47 | return; |
| 48 | |
| 49 | for(;;) { |
| 50 | c = *str++; |
| 51 | if (c == 0 || q >= buf + buf_size - 1) |
| 52 | break; |
| 53 | *q++ = c; |
| 54 | } |
| 55 | *q = '\0'; |
| 56 | } |
| 57 | |
| 58 | /* strcat and truncate. */ |
| 59 | char *pstrcat(char *buf, int buf_size, const char *s) |
| 60 | { |
| 61 | int len; |
| 62 | len = strlen(buf); |
ths | 5fafdf2 | 2007-09-16 21:08:06 +0000 | [diff] [blame] | 63 | if (len < buf_size) |
bellard | 18607dc | 2007-01-07 22:04:40 +0000 | [diff] [blame] | 64 | pstrcpy(buf + len, buf_size - len, s); |
| 65 | return buf; |
| 66 | } |
| 67 | |
| 68 | int strstart(const char *str, const char *val, const char **ptr) |
| 69 | { |
| 70 | const char *p, *q; |
| 71 | p = str; |
| 72 | q = val; |
| 73 | while (*q != '\0') { |
| 74 | if (*p != *q) |
| 75 | return 0; |
| 76 | p++; |
| 77 | q++; |
| 78 | } |
| 79 | if (ptr) |
| 80 | *ptr = p; |
| 81 | return 1; |
| 82 | } |
| 83 | |
| 84 | int stristart(const char *str, const char *val, const char **ptr) |
| 85 | { |
| 86 | const char *p, *q; |
| 87 | p = str; |
| 88 | q = val; |
| 89 | while (*q != '\0') { |
blueswir1 | cd39008 | 2008-11-16 13:53:32 +0000 | [diff] [blame] | 90 | if (qemu_toupper(*p) != qemu_toupper(*q)) |
bellard | 18607dc | 2007-01-07 22:04:40 +0000 | [diff] [blame] | 91 | return 0; |
| 92 | p++; |
| 93 | q++; |
| 94 | } |
| 95 | if (ptr) |
| 96 | *ptr = p; |
| 97 | return 1; |
| 98 | } |
bellard | 3c6b208 | 2007-11-10 19:36:39 +0000 | [diff] [blame] | 99 | |
Blue Swirl | d43277c | 2009-07-01 18:24:44 +0000 | [diff] [blame] | 100 | /* XXX: use host strnlen if available ? */ |
| 101 | int qemu_strnlen(const char *s, int max_len) |
| 102 | { |
| 103 | int i; |
| 104 | |
| 105 | for(i = 0; i < max_len; i++) { |
| 106 | if (s[i] == '\0') { |
| 107 | break; |
| 108 | } |
| 109 | } |
| 110 | return i; |
| 111 | } |
| 112 | |
Kevin Wolf | a38ed81 | 2013-06-05 14:19:35 +0200 | [diff] [blame] | 113 | char *qemu_strsep(char **input, const char *delim) |
| 114 | { |
| 115 | char *result = *input; |
| 116 | if (result != NULL) { |
| 117 | char *p; |
| 118 | |
| 119 | for (p = result; *p != '\0'; p++) { |
| 120 | if (strchr(delim, *p)) { |
| 121 | break; |
| 122 | } |
| 123 | } |
| 124 | if (*p == '\0') { |
| 125 | *input = NULL; |
| 126 | } else { |
| 127 | *p = '\0'; |
| 128 | *input = p + 1; |
| 129 | } |
| 130 | } |
| 131 | return result; |
| 132 | } |
| 133 | |
bellard | 3c6b208 | 2007-11-10 19:36:39 +0000 | [diff] [blame] | 134 | time_t mktimegm(struct tm *tm) |
| 135 | { |
| 136 | time_t t; |
| 137 | int y = tm->tm_year + 1900, m = tm->tm_mon + 1, d = tm->tm_mday; |
| 138 | if (m < 3) { |
| 139 | m += 12; |
| 140 | y--; |
| 141 | } |
Paolo Bonzini | b6db4ac | 2012-10-01 14:22:06 +0200 | [diff] [blame] | 142 | t = 86400ULL * (d + (153 * m - 457) / 5 + 365 * y + y / 4 - y / 100 + |
bellard | 3c6b208 | 2007-11-10 19:36:39 +0000 | [diff] [blame] | 143 | y / 400 - 719469); |
| 144 | t += 3600 * tm->tm_hour + 60 * tm->tm_min + tm->tm_sec; |
| 145 | return t; |
| 146 | } |
aliguori | b39ade8 | 2008-12-04 19:19:45 +0000 | [diff] [blame] | 147 | |
Christoph Hellwig | 6f1953c | 2009-09-04 19:01:32 +0200 | [diff] [blame] | 148 | /* |
| 149 | * Make sure data goes on disk, but if possible do not bother to |
| 150 | * write out the inode just for timestamp updates. |
| 151 | * |
| 152 | * Unfortunately even in 2009 many operating systems do not support |
| 153 | * fdatasync and have to fall back to fsync. |
| 154 | */ |
| 155 | int qemu_fdatasync(int fd) |
| 156 | { |
Blue Swirl | 5f6b9e8 | 2009-09-20 06:56:26 +0000 | [diff] [blame] | 157 | #ifdef CONFIG_FDATASYNC |
Christoph Hellwig | 6f1953c | 2009-09-04 19:01:32 +0200 | [diff] [blame] | 158 | return fdatasync(fd); |
| 159 | #else |
| 160 | return fsync(fd); |
| 161 | #endif |
| 162 | } |
| 163 | |
Paolo Bonzini | db1a497 | 2010-03-10 11:38:55 +0100 | [diff] [blame] | 164 | #ifndef _WIN32 |
| 165 | /* Sets a specific flag */ |
| 166 | int fcntl_setfl(int fd, int flag) |
| 167 | { |
| 168 | int flags; |
| 169 | |
| 170 | flags = fcntl(fd, F_GETFL); |
| 171 | if (flags == -1) |
| 172 | return -errno; |
| 173 | |
| 174 | if (fcntl(fd, F_SETFL, flags | flag) == -1) |
| 175 | return -errno; |
| 176 | |
| 177 | return 0; |
| 178 | } |
| 179 | #endif |
| 180 | |
Markus Armbruster | eba90e4 | 2011-11-22 09:46:06 +0100 | [diff] [blame] | 181 | static int64_t suffix_mul(char suffix, int64_t unit) |
| 182 | { |
| 183 | switch (qemu_toupper(suffix)) { |
Markus Armbruster | 17f9425 | 2017-02-21 21:14:01 +0100 | [diff] [blame] | 184 | case 'B': |
Markus Armbruster | eba90e4 | 2011-11-22 09:46:06 +0100 | [diff] [blame] | 185 | return 1; |
Markus Armbruster | 17f9425 | 2017-02-21 21:14:01 +0100 | [diff] [blame] | 186 | case 'K': |
Markus Armbruster | eba90e4 | 2011-11-22 09:46:06 +0100 | [diff] [blame] | 187 | return unit; |
Markus Armbruster | 17f9425 | 2017-02-21 21:14:01 +0100 | [diff] [blame] | 188 | case 'M': |
Markus Armbruster | eba90e4 | 2011-11-22 09:46:06 +0100 | [diff] [blame] | 189 | return unit * unit; |
Markus Armbruster | 17f9425 | 2017-02-21 21:14:01 +0100 | [diff] [blame] | 190 | case 'G': |
Markus Armbruster | eba90e4 | 2011-11-22 09:46:06 +0100 | [diff] [blame] | 191 | return unit * unit * unit; |
Markus Armbruster | 17f9425 | 2017-02-21 21:14:01 +0100 | [diff] [blame] | 192 | case 'T': |
Markus Armbruster | eba90e4 | 2011-11-22 09:46:06 +0100 | [diff] [blame] | 193 | return unit * unit * unit * unit; |
Markus Armbruster | 17f9425 | 2017-02-21 21:14:01 +0100 | [diff] [blame] | 194 | case 'P': |
Kevin Wolf | 5e00984 | 2013-06-05 14:19:27 +0200 | [diff] [blame] | 195 | return unit * unit * unit * unit * unit; |
Markus Armbruster | 17f9425 | 2017-02-21 21:14:01 +0100 | [diff] [blame] | 196 | case 'E': |
Kevin Wolf | 5e00984 | 2013-06-05 14:19:27 +0200 | [diff] [blame] | 197 | return unit * unit * unit * unit * unit * unit; |
Markus Armbruster | eba90e4 | 2011-11-22 09:46:06 +0100 | [diff] [blame] | 198 | } |
| 199 | return -1; |
| 200 | } |
| 201 | |
Jes Sorensen | 9f9b17a | 2010-10-21 17:15:46 +0200 | [diff] [blame] | 202 | /* |
| 203 | * Convert string to bytes, allowing either B/b for bytes, K/k for KB, |
Markus Armbruster | 8dddfb5 | 2011-11-22 09:46:01 +0100 | [diff] [blame] | 204 | * M/m for MB, G/g for GB or T/t for TB. End pointer will be returned |
liguang | 37edbf7 | 2012-12-17 09:49:22 +0800 | [diff] [blame] | 205 | * in *end, if not NULL. Return -ERANGE on overflow, Return -EINVAL on |
| 206 | * other error. |
Jes Sorensen | 9f9b17a | 2010-10-21 17:15:46 +0200 | [diff] [blame] | 207 | */ |
Markus Armbruster | f17fd4f | 2017-02-21 21:14:06 +0100 | [diff] [blame] | 208 | static int do_strtosz(const char *nptr, char **end, |
| 209 | const char default_suffix, int64_t unit, |
Markus Armbruster | f46bfdb | 2017-02-21 21:14:07 +0100 | [diff] [blame] | 210 | uint64_t *result) |
Jes Sorensen | 9f9b17a | 2010-10-21 17:15:46 +0200 | [diff] [blame] | 211 | { |
Markus Armbruster | f17fd4f | 2017-02-21 21:14:06 +0100 | [diff] [blame] | 212 | int retval; |
Jes Sorensen | f3bd362 | 2011-01-24 16:33:28 +0100 | [diff] [blame] | 213 | char *endptr; |
Markus Armbruster | eba90e4 | 2011-11-22 09:46:06 +0100 | [diff] [blame] | 214 | unsigned char c; |
Jes Sorensen | 9f9b17a | 2010-10-21 17:15:46 +0200 | [diff] [blame] | 215 | int mul_required = 0; |
| 216 | double val, mul, integral, fraction; |
| 217 | |
| 218 | errno = 0; |
| 219 | val = strtod(nptr, &endptr); |
| 220 | if (isnan(val) || endptr == nptr || errno != 0) { |
Markus Armbruster | 4fcdf65 | 2017-02-21 21:14:05 +0100 | [diff] [blame] | 221 | retval = -EINVAL; |
| 222 | goto out; |
Jes Sorensen | 9f9b17a | 2010-10-21 17:15:46 +0200 | [diff] [blame] | 223 | } |
Jes Sorensen | 7eb0534 | 2011-01-24 16:33:30 +0100 | [diff] [blame] | 224 | fraction = modf(val, &integral); |
| 225 | if (fraction != 0) { |
Jes Sorensen | 9f9b17a | 2010-10-21 17:15:46 +0200 | [diff] [blame] | 226 | mul_required = 1; |
| 227 | } |
Jes Sorensen | 9f9b17a | 2010-10-21 17:15:46 +0200 | [diff] [blame] | 228 | c = *endptr; |
Markus Armbruster | eba90e4 | 2011-11-22 09:46:06 +0100 | [diff] [blame] | 229 | mul = suffix_mul(c, unit); |
| 230 | if (mul >= 0) { |
Jes Sorensen | 9f9b17a | 2010-10-21 17:15:46 +0200 | [diff] [blame] | 231 | endptr++; |
Markus Armbruster | eba90e4 | 2011-11-22 09:46:06 +0100 | [diff] [blame] | 232 | } else { |
| 233 | mul = suffix_mul(default_suffix, unit); |
| 234 | assert(mul >= 0); |
| 235 | } |
| 236 | if (mul == 1 && mul_required) { |
Markus Armbruster | 4fcdf65 | 2017-02-21 21:14:05 +0100 | [diff] [blame] | 237 | retval = -EINVAL; |
| 238 | goto out; |
Jes Sorensen | 9f9b17a | 2010-10-21 17:15:46 +0200 | [diff] [blame] | 239 | } |
Markus Armbruster | f46bfdb | 2017-02-21 21:14:07 +0100 | [diff] [blame] | 240 | /* |
| 241 | * Values >= 0xfffffffffffffc00 overflow uint64_t after their trip |
| 242 | * through double (53 bits of precision). |
| 243 | */ |
| 244 | if ((val * mul >= 0xfffffffffffffc00) || val < 0) { |
liguang | 37edbf7 | 2012-12-17 09:49:22 +0800 | [diff] [blame] | 245 | retval = -ERANGE; |
Markus Armbruster | 4fcdf65 | 2017-02-21 21:14:05 +0100 | [diff] [blame] | 246 | goto out; |
Jes Sorensen | 9f9b17a | 2010-10-21 17:15:46 +0200 | [diff] [blame] | 247 | } |
Markus Armbruster | f17fd4f | 2017-02-21 21:14:06 +0100 | [diff] [blame] | 248 | *result = val * mul; |
| 249 | retval = 0; |
Jes Sorensen | 9f9b17a | 2010-10-21 17:15:46 +0200 | [diff] [blame] | 250 | |
Markus Armbruster | 4fcdf65 | 2017-02-21 21:14:05 +0100 | [diff] [blame] | 251 | out: |
Jes Sorensen | 9f9b17a | 2010-10-21 17:15:46 +0200 | [diff] [blame] | 252 | if (end) { |
| 253 | *end = endptr; |
Markus Armbruster | 4fcdf65 | 2017-02-21 21:14:05 +0100 | [diff] [blame] | 254 | } else if (*endptr) { |
| 255 | retval = -EINVAL; |
Jes Sorensen | 9f9b17a | 2010-10-21 17:15:46 +0200 | [diff] [blame] | 256 | } |
| 257 | |
| 258 | return retval; |
| 259 | } |
Jes Sorensen | d842700 | 2010-12-09 14:17:24 +0100 | [diff] [blame] | 260 | |
Markus Armbruster | f46bfdb | 2017-02-21 21:14:07 +0100 | [diff] [blame] | 261 | int qemu_strtosz(const char *nptr, char **end, uint64_t *result) |
Joerg Roedel | a732e1b | 2011-07-07 16:13:11 +0200 | [diff] [blame] | 262 | { |
Markus Armbruster | f17fd4f | 2017-02-21 21:14:06 +0100 | [diff] [blame] | 263 | return do_strtosz(nptr, end, 'B', 1024, result); |
Joerg Roedel | a732e1b | 2011-07-07 16:13:11 +0200 | [diff] [blame] | 264 | } |
| 265 | |
Markus Armbruster | f46bfdb | 2017-02-21 21:14:07 +0100 | [diff] [blame] | 266 | int qemu_strtosz_MiB(const char *nptr, char **end, uint64_t *result) |
Jes Sorensen | d842700 | 2010-12-09 14:17:24 +0100 | [diff] [blame] | 267 | { |
Markus Armbruster | f17fd4f | 2017-02-21 21:14:06 +0100 | [diff] [blame] | 268 | return do_strtosz(nptr, end, 'M', 1024, result); |
Jes Sorensen | d842700 | 2010-12-09 14:17:24 +0100 | [diff] [blame] | 269 | } |
Stefan Berger | 443916d | 2011-09-28 06:41:32 -0400 | [diff] [blame] | 270 | |
Markus Armbruster | f46bfdb | 2017-02-21 21:14:07 +0100 | [diff] [blame] | 271 | int qemu_strtosz_metric(const char *nptr, char **end, uint64_t *result) |
Markus Armbruster | d2734d2 | 2017-02-21 21:13:58 +0100 | [diff] [blame] | 272 | { |
Markus Armbruster | f17fd4f | 2017-02-21 21:14:06 +0100 | [diff] [blame] | 273 | return do_strtosz(nptr, end, 'B', 1000, result); |
Markus Armbruster | d2734d2 | 2017-02-21 21:13:58 +0100 | [diff] [blame] | 274 | } |
| 275 | |
Eduardo Habkost | e3f9fe2 | 2013-02-04 16:27:45 -0200 | [diff] [blame] | 276 | /** |
Markus Armbruster | 717adf9 | 2017-02-21 21:13:51 +0100 | [diff] [blame] | 277 | * Helper function for error checking after strtol() and the like |
Carlos L. Torres | 764e0fa | 2015-07-19 18:02:17 -0500 | [diff] [blame] | 278 | */ |
Markus Armbruster | 717adf9 | 2017-02-21 21:13:51 +0100 | [diff] [blame] | 279 | static int check_strtox_error(const char *nptr, char *ep, |
| 280 | const char **endptr, int libc_errno) |
Carlos L. Torres | 764e0fa | 2015-07-19 18:02:17 -0500 | [diff] [blame] | 281 | { |
Markus Armbruster | 717adf9 | 2017-02-21 21:13:51 +0100 | [diff] [blame] | 282 | if (endptr) { |
| 283 | *endptr = ep; |
Carlos L. Torres | 764e0fa | 2015-07-19 18:02:17 -0500 | [diff] [blame] | 284 | } |
Markus Armbruster | 4baef26 | 2017-02-21 21:13:52 +0100 | [diff] [blame] | 285 | |
| 286 | /* Turn "no conversion" into an error */ |
| 287 | if (libc_errno == 0 && ep == nptr) { |
| 288 | return -EINVAL; |
| 289 | } |
| 290 | |
| 291 | /* Fail when we're expected to consume the string, but didn't */ |
| 292 | if (!endptr && *ep) { |
| 293 | return -EINVAL; |
| 294 | } |
| 295 | |
Markus Armbruster | 717adf9 | 2017-02-21 21:13:51 +0100 | [diff] [blame] | 296 | return -libc_errno; |
Carlos L. Torres | 764e0fa | 2015-07-19 18:02:17 -0500 | [diff] [blame] | 297 | } |
| 298 | |
| 299 | /** |
Markus Armbruster | 4295f87 | 2017-02-21 21:13:49 +0100 | [diff] [blame] | 300 | * Convert string @nptr to a long integer, and store it in @result. |
Carlos L. Torres | 764e0fa | 2015-07-19 18:02:17 -0500 | [diff] [blame] | 301 | * |
Markus Armbruster | 4295f87 | 2017-02-21 21:13:49 +0100 | [diff] [blame] | 302 | * This is a wrapper around strtol() that is harder to misuse. |
| 303 | * Semantics of @nptr, @endptr, @base match strtol() with differences |
| 304 | * noted below. |
Carlos L. Torres | 764e0fa | 2015-07-19 18:02:17 -0500 | [diff] [blame] | 305 | * |
Markus Armbruster | 4295f87 | 2017-02-21 21:13:49 +0100 | [diff] [blame] | 306 | * @nptr may be null, and no conversion is performed then. |
Carlos L. Torres | 764e0fa | 2015-07-19 18:02:17 -0500 | [diff] [blame] | 307 | * |
Markus Armbruster | 4295f87 | 2017-02-21 21:13:49 +0100 | [diff] [blame] | 308 | * If no conversion is performed, store @nptr in *@endptr and return |
| 309 | * -EINVAL. |
Carlos L. Torres | 764e0fa | 2015-07-19 18:02:17 -0500 | [diff] [blame] | 310 | * |
Markus Armbruster | 4295f87 | 2017-02-21 21:13:49 +0100 | [diff] [blame] | 311 | * If @endptr is null, and the string isn't fully converted, return |
| 312 | * -EINVAL. This is the case when the pointer that would be stored in |
| 313 | * a non-null @endptr points to a character other than '\0'. |
| 314 | * |
| 315 | * If the conversion overflows @result, store LONG_MAX in @result, |
| 316 | * and return -ERANGE. |
| 317 | * |
| 318 | * If the conversion underflows @result, store LONG_MIN in @result, |
| 319 | * and return -ERANGE. |
| 320 | * |
| 321 | * Else store the converted value in @result, and return zero. |
Carlos L. Torres | 764e0fa | 2015-07-19 18:02:17 -0500 | [diff] [blame] | 322 | */ |
| 323 | int qemu_strtol(const char *nptr, const char **endptr, int base, |
| 324 | long *result) |
| 325 | { |
Markus Armbruster | 717adf9 | 2017-02-21 21:13:51 +0100 | [diff] [blame] | 326 | char *ep; |
Markus Armbruster | 4baef26 | 2017-02-21 21:13:52 +0100 | [diff] [blame] | 327 | |
Carlos L. Torres | 764e0fa | 2015-07-19 18:02:17 -0500 | [diff] [blame] | 328 | if (!nptr) { |
| 329 | if (endptr) { |
| 330 | *endptr = nptr; |
| 331 | } |
Markus Armbruster | 4baef26 | 2017-02-21 21:13:52 +0100 | [diff] [blame] | 332 | return -EINVAL; |
Carlos L. Torres | 764e0fa | 2015-07-19 18:02:17 -0500 | [diff] [blame] | 333 | } |
Markus Armbruster | 4baef26 | 2017-02-21 21:13:52 +0100 | [diff] [blame] | 334 | |
| 335 | errno = 0; |
| 336 | *result = strtol(nptr, &ep, base); |
| 337 | return check_strtox_error(nptr, ep, endptr, errno); |
Carlos L. Torres | 764e0fa | 2015-07-19 18:02:17 -0500 | [diff] [blame] | 338 | } |
Carlos L. Torres | c817c01 | 2015-07-19 18:02:18 -0500 | [diff] [blame] | 339 | |
| 340 | /** |
Markus Armbruster | 4295f87 | 2017-02-21 21:13:49 +0100 | [diff] [blame] | 341 | * Convert string @nptr to an unsigned long, and store it in @result. |
Carlos L. Torres | c817c01 | 2015-07-19 18:02:18 -0500 | [diff] [blame] | 342 | * |
Markus Armbruster | 4295f87 | 2017-02-21 21:13:49 +0100 | [diff] [blame] | 343 | * This is a wrapper around strtoul() that is harder to misuse. |
| 344 | * Semantics of @nptr, @endptr, @base match strtoul() with differences |
| 345 | * noted below. |
Carlos L. Torres | c817c01 | 2015-07-19 18:02:18 -0500 | [diff] [blame] | 346 | * |
Markus Armbruster | 4295f87 | 2017-02-21 21:13:49 +0100 | [diff] [blame] | 347 | * @nptr may be null, and no conversion is performed then. |
Carlos L. Torres | c817c01 | 2015-07-19 18:02:18 -0500 | [diff] [blame] | 348 | * |
Markus Armbruster | 4295f87 | 2017-02-21 21:13:49 +0100 | [diff] [blame] | 349 | * If no conversion is performed, store @nptr in *@endptr and return |
| 350 | * -EINVAL. |
| 351 | * |
| 352 | * If @endptr is null, and the string isn't fully converted, return |
| 353 | * -EINVAL. This is the case when the pointer that would be stored in |
| 354 | * a non-null @endptr points to a character other than '\0'. |
| 355 | * |
| 356 | * If the conversion overflows @result, store ULONG_MAX in @result, |
| 357 | * and return -ERANGE. |
| 358 | * |
| 359 | * Else store the converted value in @result, and return zero. |
| 360 | * |
| 361 | * Note that a number with a leading minus sign gets converted without |
| 362 | * the minus sign, checked for overflow (see above), then negated (in |
| 363 | * @result's type). This is exactly how strtoul() works. |
Carlos L. Torres | c817c01 | 2015-07-19 18:02:18 -0500 | [diff] [blame] | 364 | */ |
| 365 | int qemu_strtoul(const char *nptr, const char **endptr, int base, |
| 366 | unsigned long *result) |
| 367 | { |
Markus Armbruster | 717adf9 | 2017-02-21 21:13:51 +0100 | [diff] [blame] | 368 | char *ep; |
Markus Armbruster | 4baef26 | 2017-02-21 21:13:52 +0100 | [diff] [blame] | 369 | |
Carlos L. Torres | c817c01 | 2015-07-19 18:02:18 -0500 | [diff] [blame] | 370 | if (!nptr) { |
| 371 | if (endptr) { |
| 372 | *endptr = nptr; |
| 373 | } |
Markus Armbruster | 4baef26 | 2017-02-21 21:13:52 +0100 | [diff] [blame] | 374 | return -EINVAL; |
Carlos L. Torres | c817c01 | 2015-07-19 18:02:18 -0500 | [diff] [blame] | 375 | } |
Markus Armbruster | 4baef26 | 2017-02-21 21:13:52 +0100 | [diff] [blame] | 376 | |
| 377 | errno = 0; |
| 378 | *result = strtoul(nptr, &ep, base); |
| 379 | /* Windows returns 1 for negative out-of-range values. */ |
| 380 | if (errno == ERANGE) { |
| 381 | *result = -1; |
| 382 | } |
| 383 | return check_strtox_error(nptr, ep, endptr, errno); |
Carlos L. Torres | c817c01 | 2015-07-19 18:02:18 -0500 | [diff] [blame] | 384 | } |
| 385 | |
Carlos L. Torres | 764e0fa | 2015-07-19 18:02:17 -0500 | [diff] [blame] | 386 | /** |
Markus Armbruster | 4295f87 | 2017-02-21 21:13:49 +0100 | [diff] [blame] | 387 | * Convert string @nptr to an int64_t. |
Carlos L. Torres | 8ac4df4 | 2015-07-19 18:02:19 -0500 | [diff] [blame] | 388 | * |
Markus Armbruster | 4295f87 | 2017-02-21 21:13:49 +0100 | [diff] [blame] | 389 | * Works like qemu_strtol(), except it stores INT64_MAX on overflow, |
| 390 | * and INT_MIN on underflow. |
Carlos L. Torres | 8ac4df4 | 2015-07-19 18:02:19 -0500 | [diff] [blame] | 391 | */ |
Markus Armbruster | b30d188 | 2017-02-21 21:13:50 +0100 | [diff] [blame] | 392 | int qemu_strtoi64(const char *nptr, const char **endptr, int base, |
Carlos L. Torres | 8ac4df4 | 2015-07-19 18:02:19 -0500 | [diff] [blame] | 393 | int64_t *result) |
| 394 | { |
Markus Armbruster | 717adf9 | 2017-02-21 21:13:51 +0100 | [diff] [blame] | 395 | char *ep; |
Markus Armbruster | 4baef26 | 2017-02-21 21:13:52 +0100 | [diff] [blame] | 396 | |
Carlos L. Torres | 8ac4df4 | 2015-07-19 18:02:19 -0500 | [diff] [blame] | 397 | if (!nptr) { |
| 398 | if (endptr) { |
| 399 | *endptr = nptr; |
| 400 | } |
Markus Armbruster | 4baef26 | 2017-02-21 21:13:52 +0100 | [diff] [blame] | 401 | return -EINVAL; |
Carlos L. Torres | 8ac4df4 | 2015-07-19 18:02:19 -0500 | [diff] [blame] | 402 | } |
Markus Armbruster | 4baef26 | 2017-02-21 21:13:52 +0100 | [diff] [blame] | 403 | |
| 404 | errno = 0; |
| 405 | /* FIXME This assumes int64_t is long long */ |
| 406 | *result = strtoll(nptr, &ep, base); |
| 407 | return check_strtox_error(nptr, ep, endptr, errno); |
Carlos L. Torres | 8ac4df4 | 2015-07-19 18:02:19 -0500 | [diff] [blame] | 408 | } |
| 409 | |
| 410 | /** |
Markus Armbruster | 4295f87 | 2017-02-21 21:13:49 +0100 | [diff] [blame] | 411 | * Convert string @nptr to an uint64_t. |
Carlos L. Torres | 3904e6b | 2015-07-19 18:02:20 -0500 | [diff] [blame] | 412 | * |
Markus Armbruster | 4295f87 | 2017-02-21 21:13:49 +0100 | [diff] [blame] | 413 | * Works like qemu_strtoul(), except it stores UINT64_MAX on overflow. |
Carlos L. Torres | 3904e6b | 2015-07-19 18:02:20 -0500 | [diff] [blame] | 414 | */ |
Markus Armbruster | b30d188 | 2017-02-21 21:13:50 +0100 | [diff] [blame] | 415 | int qemu_strtou64(const char *nptr, const char **endptr, int base, |
Carlos L. Torres | 3904e6b | 2015-07-19 18:02:20 -0500 | [diff] [blame] | 416 | uint64_t *result) |
| 417 | { |
Markus Armbruster | 717adf9 | 2017-02-21 21:13:51 +0100 | [diff] [blame] | 418 | char *ep; |
Markus Armbruster | 4baef26 | 2017-02-21 21:13:52 +0100 | [diff] [blame] | 419 | |
Carlos L. Torres | 3904e6b | 2015-07-19 18:02:20 -0500 | [diff] [blame] | 420 | if (!nptr) { |
| 421 | if (endptr) { |
| 422 | *endptr = nptr; |
| 423 | } |
Markus Armbruster | 4baef26 | 2017-02-21 21:13:52 +0100 | [diff] [blame] | 424 | return -EINVAL; |
Carlos L. Torres | 3904e6b | 2015-07-19 18:02:20 -0500 | [diff] [blame] | 425 | } |
Markus Armbruster | 4baef26 | 2017-02-21 21:13:52 +0100 | [diff] [blame] | 426 | |
| 427 | errno = 0; |
| 428 | /* FIXME This assumes uint64_t is unsigned long long */ |
| 429 | *result = strtoull(nptr, &ep, base); |
| 430 | /* Windows returns 1 for negative out-of-range values. */ |
| 431 | if (errno == ERANGE) { |
| 432 | *result = -1; |
| 433 | } |
| 434 | return check_strtox_error(nptr, ep, endptr, errno); |
Carlos L. Torres | 3904e6b | 2015-07-19 18:02:20 -0500 | [diff] [blame] | 435 | } |
| 436 | |
| 437 | /** |
Eduardo Habkost | e3f9fe2 | 2013-02-04 16:27:45 -0200 | [diff] [blame] | 438 | * parse_uint: |
| 439 | * |
| 440 | * @s: String to parse |
| 441 | * @value: Destination for parsed integer value |
| 442 | * @endptr: Destination for pointer to first character not consumed |
| 443 | * @base: integer base, between 2 and 36 inclusive, or 0 |
| 444 | * |
| 445 | * Parse unsigned integer |
| 446 | * |
| 447 | * Parsed syntax is like strtoull()'s: arbitrary whitespace, a single optional |
| 448 | * '+' or '-', an optional "0x" if @base is 0 or 16, one or more digits. |
| 449 | * |
| 450 | * If @s is null, or @base is invalid, or @s doesn't start with an |
| 451 | * integer in the syntax above, set *@value to 0, *@endptr to @s, and |
| 452 | * return -EINVAL. |
| 453 | * |
| 454 | * Set *@endptr to point right beyond the parsed integer (even if the integer |
| 455 | * overflows or is negative, all digits will be parsed and *@endptr will |
| 456 | * point right beyond them). |
| 457 | * |
| 458 | * If the integer is negative, set *@value to 0, and return -ERANGE. |
| 459 | * |
| 460 | * If the integer overflows unsigned long long, set *@value to |
| 461 | * ULLONG_MAX, and return -ERANGE. |
| 462 | * |
| 463 | * Else, set *@value to the parsed integer, and return 0. |
| 464 | */ |
| 465 | int parse_uint(const char *s, unsigned long long *value, char **endptr, |
| 466 | int base) |
| 467 | { |
| 468 | int r = 0; |
| 469 | char *endp = (char *)s; |
| 470 | unsigned long long val = 0; |
| 471 | |
| 472 | if (!s) { |
| 473 | r = -EINVAL; |
| 474 | goto out; |
| 475 | } |
| 476 | |
| 477 | errno = 0; |
| 478 | val = strtoull(s, &endp, base); |
| 479 | if (errno) { |
| 480 | r = -errno; |
| 481 | goto out; |
| 482 | } |
| 483 | |
| 484 | if (endp == s) { |
| 485 | r = -EINVAL; |
| 486 | goto out; |
| 487 | } |
| 488 | |
| 489 | /* make sure we reject negative numbers: */ |
| 490 | while (isspace((unsigned char)*s)) { |
| 491 | s++; |
| 492 | } |
| 493 | if (*s == '-') { |
| 494 | val = 0; |
| 495 | r = -ERANGE; |
| 496 | goto out; |
| 497 | } |
| 498 | |
| 499 | out: |
| 500 | *value = val; |
| 501 | *endptr = endp; |
| 502 | return r; |
| 503 | } |
| 504 | |
| 505 | /** |
| 506 | * parse_uint_full: |
| 507 | * |
| 508 | * @s: String to parse |
| 509 | * @value: Destination for parsed integer value |
| 510 | * @base: integer base, between 2 and 36 inclusive, or 0 |
| 511 | * |
| 512 | * Parse unsigned integer from entire string |
| 513 | * |
| 514 | * Have the same behavior of parse_uint(), but with an additional check |
| 515 | * for additional data after the parsed number. If extra characters are present |
| 516 | * after the parsed number, the function will return -EINVAL, and *@v will |
| 517 | * be set to 0. |
| 518 | */ |
| 519 | int parse_uint_full(const char *s, unsigned long long *value, int base) |
| 520 | { |
| 521 | char *endp; |
| 522 | int r; |
| 523 | |
| 524 | r = parse_uint(s, value, &endp, base); |
| 525 | if (r < 0) { |
| 526 | return r; |
| 527 | } |
| 528 | if (*endp) { |
| 529 | *value = 0; |
| 530 | return -EINVAL; |
| 531 | } |
| 532 | |
| 533 | return 0; |
| 534 | } |
| 535 | |
Stefan Berger | 443916d | 2011-09-28 06:41:32 -0400 | [diff] [blame] | 536 | int qemu_parse_fd(const char *param) |
| 537 | { |
Laszlo Ersek | e9c5c1f | 2014-04-10 10:24:30 +0200 | [diff] [blame] | 538 | long fd; |
| 539 | char *endptr; |
Stefan Berger | 443916d | 2011-09-28 06:41:32 -0400 | [diff] [blame] | 540 | |
Laszlo Ersek | e9c5c1f | 2014-04-10 10:24:30 +0200 | [diff] [blame] | 541 | errno = 0; |
Stefan Berger | 443916d | 2011-09-28 06:41:32 -0400 | [diff] [blame] | 542 | fd = strtol(param, &endptr, 10); |
Laszlo Ersek | e9c5c1f | 2014-04-10 10:24:30 +0200 | [diff] [blame] | 543 | if (param == endptr /* no conversion performed */ || |
| 544 | errno != 0 /* not representable as long; possibly others */ || |
| 545 | *endptr != '\0' /* final string not empty */ || |
| 546 | fd < 0 /* invalid as file descriptor */ || |
| 547 | fd > INT_MAX /* not representable as int */) { |
Stefan Berger | 443916d | 2011-09-28 06:41:32 -0400 | [diff] [blame] | 548 | return -1; |
| 549 | } |
| 550 | return fd; |
| 551 | } |
Orit Wasserman | 9fb2664 | 2012-08-06 21:42:50 +0300 | [diff] [blame] | 552 | |
Orit Wasserman | e6546bb | 2012-08-06 21:42:51 +0300 | [diff] [blame] | 553 | /* |
| 554 | * Implementation of ULEB128 (http://en.wikipedia.org/wiki/LEB128) |
| 555 | * Input is limited to 14-bit numbers |
| 556 | */ |
| 557 | int uleb128_encode_small(uint8_t *out, uint32_t n) |
| 558 | { |
| 559 | g_assert(n <= 0x3fff); |
| 560 | if (n < 0x80) { |
| 561 | *out++ = n; |
| 562 | return 1; |
| 563 | } else { |
| 564 | *out++ = (n & 0x7f) | 0x80; |
| 565 | *out++ = n >> 7; |
| 566 | return 2; |
| 567 | } |
| 568 | } |
| 569 | |
| 570 | int uleb128_decode_small(const uint8_t *in, uint32_t *n) |
| 571 | { |
| 572 | if (!(*in & 0x80)) { |
| 573 | *n = *in++; |
| 574 | return 1; |
| 575 | } else { |
| 576 | *n = *in++ & 0x7f; |
| 577 | /* we exceed 14 bit number */ |
| 578 | if (*in & 0x80) { |
| 579 | return -1; |
| 580 | } |
| 581 | *n |= *in++ << 7; |
| 582 | return 2; |
| 583 | } |
| 584 | } |
Alon Levy | b16352a | 2013-03-04 18:41:28 +0200 | [diff] [blame] | 585 | |
| 586 | /* |
| 587 | * helper to parse debug environment variables |
| 588 | */ |
| 589 | int parse_debug_env(const char *name, int max, int initial) |
| 590 | { |
| 591 | char *debug_env = getenv(name); |
| 592 | char *inv = NULL; |
Paolo Bonzini | cc5d0e0 | 2015-02-11 12:30:43 +0100 | [diff] [blame] | 593 | long debug; |
Alon Levy | b16352a | 2013-03-04 18:41:28 +0200 | [diff] [blame] | 594 | |
| 595 | if (!debug_env) { |
| 596 | return initial; |
| 597 | } |
Paolo Bonzini | cc5d0e0 | 2015-02-11 12:30:43 +0100 | [diff] [blame] | 598 | errno = 0; |
Alon Levy | b16352a | 2013-03-04 18:41:28 +0200 | [diff] [blame] | 599 | debug = strtol(debug_env, &inv, 10); |
| 600 | if (inv == debug_env) { |
| 601 | return initial; |
| 602 | } |
Paolo Bonzini | cc5d0e0 | 2015-02-11 12:30:43 +0100 | [diff] [blame] | 603 | if (debug < 0 || debug > max || errno != 0) { |
Alon Levy | b16352a | 2013-03-04 18:41:28 +0200 | [diff] [blame] | 604 | fprintf(stderr, "warning: %s not in [0, %d]", name, max); |
| 605 | return initial; |
| 606 | } |
| 607 | return debug; |
| 608 | } |
Alexey Kardashevskiy | 4297c8e | 2014-03-11 10:42:26 +1100 | [diff] [blame] | 609 | |
| 610 | /* |
| 611 | * Helper to print ethernet mac address |
| 612 | */ |
| 613 | const char *qemu_ether_ntoa(const MACAddr *mac) |
| 614 | { |
| 615 | static char ret[18]; |
| 616 | |
| 617 | snprintf(ret, sizeof(ret), "%02x:%02x:%02x:%02x:%02x:%02x", |
| 618 | mac->a[0], mac->a[1], mac->a[2], mac->a[3], mac->a[4], mac->a[5]); |
| 619 | |
| 620 | return ret; |
| 621 | } |
Peter Xu | 22951aa | 2017-05-12 12:17:40 +0800 | [diff] [blame] | 622 | |
| 623 | /* |
| 624 | * Return human readable string for size @val. |
| 625 | * @val can be anything that uint64_t allows (no more than "16 EiB"). |
| 626 | * Use IEC binary units like KiB, MiB, and so forth. |
| 627 | * Caller is responsible for passing it to g_free(). |
| 628 | */ |
| 629 | char *size_to_str(uint64_t val) |
| 630 | { |
| 631 | static const char *suffixes[] = { "", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei" }; |
| 632 | unsigned long div; |
| 633 | int i; |
| 634 | |
| 635 | /* |
| 636 | * The exponent (returned in i) minus one gives us |
| 637 | * floor(log2(val * 1024 / 1000). The correction makes us |
| 638 | * switch to the higher power when the integer part is >= 1000. |
| 639 | * (see e41b509d68afb1f for more info) |
| 640 | */ |
| 641 | frexp(val / (1000.0 / 1024.0), &i); |
| 642 | i = (i - 1) / 10; |
| 643 | div = 1ULL << (i * 10); |
| 644 | |
| 645 | return g_strdup_printf("%0.3g %sB", (double)val / div, suffixes[i]); |
| 646 | } |