]>
Commit | Line | Data |
---|---|---|
18607dcb FB |
1 | /* |
2 | * Simple C functions to supplement the C library | |
5fafdf24 | 3 | * |
18607dcb FB |
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 | */ | |
856dfd8a | 24 | |
aafd7584 | 25 | #include "qemu/osdep.h" |
1de7afc9 | 26 | #include "qemu/host-utils.h" |
9f9b17a4 | 27 | #include <math.h> |
18607dcb | 28 | |
a8d25326 | 29 | #include "qemu-common.h" |
1de7afc9 PB |
30 | #include "qemu/sockets.h" |
31 | #include "qemu/iov.h" | |
4297c8ee | 32 | #include "net/net.h" |
856dfd8a | 33 | #include "qemu/ctype.h" |
f348b6d1 | 34 | #include "qemu/cutils.h" |
05cb8ed5 | 35 | #include "qemu/error-report.h" |
8c5135f9 | 36 | |
2a025ae4 DF |
37 | void strpadcpy(char *buf, int buf_size, const char *str, char pad) |
38 | { | |
39 | int len = qemu_strnlen(str, buf_size); | |
40 | memcpy(buf, str, len); | |
41 | memset(buf + len, pad, buf_size - len); | |
42 | } | |
43 | ||
18607dcb FB |
44 | void pstrcpy(char *buf, int buf_size, const char *str) |
45 | { | |
46 | int c; | |
47 | char *q = buf; | |
48 | ||
49 | if (buf_size <= 0) | |
50 | return; | |
51 | ||
52 | for(;;) { | |
53 | c = *str++; | |
54 | if (c == 0 || q >= buf + buf_size - 1) | |
55 | break; | |
56 | *q++ = c; | |
57 | } | |
58 | *q = '\0'; | |
59 | } | |
60 | ||
61 | /* strcat and truncate. */ | |
62 | char *pstrcat(char *buf, int buf_size, const char *s) | |
63 | { | |
64 | int len; | |
65 | len = strlen(buf); | |
5fafdf24 | 66 | if (len < buf_size) |
18607dcb FB |
67 | pstrcpy(buf + len, buf_size - len, s); |
68 | return buf; | |
69 | } | |
70 | ||
71 | int strstart(const char *str, const char *val, const char **ptr) | |
72 | { | |
73 | const char *p, *q; | |
74 | p = str; | |
75 | q = val; | |
76 | while (*q != '\0') { | |
77 | if (*p != *q) | |
78 | return 0; | |
79 | p++; | |
80 | q++; | |
81 | } | |
82 | if (ptr) | |
83 | *ptr = p; | |
84 | return 1; | |
85 | } | |
86 | ||
87 | int stristart(const char *str, const char *val, const char **ptr) | |
88 | { | |
89 | const char *p, *q; | |
90 | p = str; | |
91 | q = val; | |
92 | while (*q != '\0') { | |
cd390083 | 93 | if (qemu_toupper(*p) != qemu_toupper(*q)) |
18607dcb FB |
94 | return 0; |
95 | p++; | |
96 | q++; | |
97 | } | |
98 | if (ptr) | |
99 | *ptr = p; | |
100 | return 1; | |
101 | } | |
3c6b2088 | 102 | |
d43277c5 BS |
103 | /* XXX: use host strnlen if available ? */ |
104 | int qemu_strnlen(const char *s, int max_len) | |
105 | { | |
106 | int i; | |
107 | ||
108 | for(i = 0; i < max_len; i++) { | |
109 | if (s[i] == '\0') { | |
110 | break; | |
111 | } | |
112 | } | |
113 | return i; | |
114 | } | |
115 | ||
a38ed811 KW |
116 | char *qemu_strsep(char **input, const char *delim) |
117 | { | |
118 | char *result = *input; | |
119 | if (result != NULL) { | |
120 | char *p; | |
121 | ||
122 | for (p = result; *p != '\0'; p++) { | |
123 | if (strchr(delim, *p)) { | |
124 | break; | |
125 | } | |
126 | } | |
127 | if (*p == '\0') { | |
128 | *input = NULL; | |
129 | } else { | |
130 | *p = '\0'; | |
131 | *input = p + 1; | |
132 | } | |
133 | } | |
134 | return result; | |
135 | } | |
136 | ||
3c6b2088 FB |
137 | time_t mktimegm(struct tm *tm) |
138 | { | |
139 | time_t t; | |
140 | int y = tm->tm_year + 1900, m = tm->tm_mon + 1, d = tm->tm_mday; | |
141 | if (m < 3) { | |
142 | m += 12; | |
143 | y--; | |
144 | } | |
b6db4aca | 145 | t = 86400ULL * (d + (153 * m - 457) / 5 + 365 * y + y / 4 - y / 100 + |
3c6b2088 FB |
146 | y / 400 - 719469); |
147 | t += 3600 * tm->tm_hour + 60 * tm->tm_min + tm->tm_sec; | |
148 | return t; | |
149 | } | |
b39ade83 | 150 | |
6f1953c4 CH |
151 | /* |
152 | * Make sure data goes on disk, but if possible do not bother to | |
153 | * write out the inode just for timestamp updates. | |
154 | * | |
155 | * Unfortunately even in 2009 many operating systems do not support | |
156 | * fdatasync and have to fall back to fsync. | |
157 | */ | |
158 | int qemu_fdatasync(int fd) | |
159 | { | |
5f6b9e8f | 160 | #ifdef CONFIG_FDATASYNC |
6f1953c4 CH |
161 | return fdatasync(fd); |
162 | #else | |
163 | return fsync(fd); | |
164 | #endif | |
165 | } | |
166 | ||
db1a4972 PB |
167 | #ifndef _WIN32 |
168 | /* Sets a specific flag */ | |
169 | int fcntl_setfl(int fd, int flag) | |
170 | { | |
171 | int flags; | |
172 | ||
173 | flags = fcntl(fd, F_GETFL); | |
174 | if (flags == -1) | |
175 | return -errno; | |
176 | ||
177 | if (fcntl(fd, F_SETFL, flags | flag) == -1) | |
178 | return -errno; | |
179 | ||
180 | return 0; | |
181 | } | |
182 | #endif | |
183 | ||
eba90e4e MA |
184 | static int64_t suffix_mul(char suffix, int64_t unit) |
185 | { | |
186 | switch (qemu_toupper(suffix)) { | |
17f94256 | 187 | case 'B': |
eba90e4e | 188 | return 1; |
17f94256 | 189 | case 'K': |
eba90e4e | 190 | return unit; |
17f94256 | 191 | case 'M': |
eba90e4e | 192 | return unit * unit; |
17f94256 | 193 | case 'G': |
eba90e4e | 194 | return unit * unit * unit; |
17f94256 | 195 | case 'T': |
eba90e4e | 196 | return unit * unit * unit * unit; |
17f94256 | 197 | case 'P': |
5e00984a | 198 | return unit * unit * unit * unit * unit; |
17f94256 | 199 | case 'E': |
5e00984a | 200 | return unit * unit * unit * unit * unit * unit; |
eba90e4e MA |
201 | } |
202 | return -1; | |
203 | } | |
204 | ||
9f9b17a4 JS |
205 | /* |
206 | * Convert string to bytes, allowing either B/b for bytes, K/k for KB, | |
8dddfb55 | 207 | * M/m for MB, G/g for GB or T/t for TB. End pointer will be returned |
af02f4c5 | 208 | * in *end, if not NULL. Return -ERANGE on overflow, and -EINVAL on |
37edbf7e | 209 | * other error. |
9f9b17a4 | 210 | */ |
af02f4c5 | 211 | static int do_strtosz(const char *nptr, const char **end, |
f17fd4fd | 212 | const char default_suffix, int64_t unit, |
f46bfdbf | 213 | uint64_t *result) |
9f9b17a4 | 214 | { |
f17fd4fd | 215 | int retval; |
af02f4c5 | 216 | const char *endptr; |
eba90e4e | 217 | unsigned char c; |
9f9b17a4 JS |
218 | int mul_required = 0; |
219 | double val, mul, integral, fraction; | |
220 | ||
af02f4c5 DH |
221 | retval = qemu_strtod_finite(nptr, &endptr, &val); |
222 | if (retval) { | |
4fcdf65a | 223 | goto out; |
9f9b17a4 | 224 | } |
7eb05349 JS |
225 | fraction = modf(val, &integral); |
226 | if (fraction != 0) { | |
9f9b17a4 JS |
227 | mul_required = 1; |
228 | } | |
9f9b17a4 | 229 | c = *endptr; |
eba90e4e MA |
230 | mul = suffix_mul(c, unit); |
231 | if (mul >= 0) { | |
232 | endptr++; | |
233 | } else { | |
234 | mul = suffix_mul(default_suffix, unit); | |
235 | assert(mul >= 0); | |
9f9b17a4 | 236 | } |
eba90e4e | 237 | if (mul == 1 && mul_required) { |
4fcdf65a MA |
238 | retval = -EINVAL; |
239 | goto out; | |
9f9b17a4 | 240 | } |
f46bfdbf MA |
241 | /* |
242 | * Values >= 0xfffffffffffffc00 overflow uint64_t after their trip | |
243 | * through double (53 bits of precision). | |
244 | */ | |
245 | if ((val * mul >= 0xfffffffffffffc00) || val < 0) { | |
37edbf7e | 246 | retval = -ERANGE; |
4fcdf65a | 247 | goto out; |
9f9b17a4 | 248 | } |
f17fd4fd MA |
249 | *result = val * mul; |
250 | retval = 0; | |
9f9b17a4 | 251 | |
4fcdf65a | 252 | out: |
9f9b17a4 JS |
253 | if (end) { |
254 | *end = endptr; | |
4fcdf65a MA |
255 | } else if (*endptr) { |
256 | retval = -EINVAL; | |
9f9b17a4 JS |
257 | } |
258 | ||
259 | return retval; | |
260 | } | |
d8427002 | 261 | |
af02f4c5 | 262 | int qemu_strtosz(const char *nptr, const char **end, uint64_t *result) |
a732e1ba | 263 | { |
f17fd4fd | 264 | return do_strtosz(nptr, end, 'B', 1024, result); |
a732e1ba JR |
265 | } |
266 | ||
af02f4c5 | 267 | int qemu_strtosz_MiB(const char *nptr, const char **end, uint64_t *result) |
d8427002 | 268 | { |
f17fd4fd | 269 | return do_strtosz(nptr, end, 'M', 1024, result); |
d8427002 | 270 | } |
443916d1 | 271 | |
af02f4c5 | 272 | int qemu_strtosz_metric(const char *nptr, const char **end, uint64_t *result) |
d2734d26 | 273 | { |
f17fd4fd | 274 | return do_strtosz(nptr, end, 'B', 1000, result); |
d2734d26 MA |
275 | } |
276 | ||
764e0fa4 | 277 | /** |
717adf96 | 278 | * Helper function for error checking after strtol() and the like |
764e0fa4 | 279 | */ |
717adf96 MA |
280 | static int check_strtox_error(const char *nptr, char *ep, |
281 | const char **endptr, int libc_errno) | |
764e0fa4 | 282 | { |
53a90b97 | 283 | assert(ep >= nptr); |
4baef267 MA |
284 | if (endptr) { |
285 | *endptr = ep; | |
286 | } | |
287 | ||
288 | /* Turn "no conversion" into an error */ | |
717adf96 | 289 | if (libc_errno == 0 && ep == nptr) { |
4baef267 | 290 | return -EINVAL; |
47d4be12 | 291 | } |
4baef267 MA |
292 | |
293 | /* Fail when we're expected to consume the string, but didn't */ | |
717adf96 | 294 | if (!endptr && *ep) { |
764e0fa4 CT |
295 | return -EINVAL; |
296 | } | |
4baef267 | 297 | |
717adf96 | 298 | return -libc_errno; |
764e0fa4 CT |
299 | } |
300 | ||
473a2a33 DB |
301 | /** |
302 | * Convert string @nptr to an integer, and store it in @result. | |
303 | * | |
304 | * This is a wrapper around strtol() that is harder to misuse. | |
305 | * Semantics of @nptr, @endptr, @base match strtol() with differences | |
306 | * noted below. | |
307 | * | |
308 | * @nptr may be null, and no conversion is performed then. | |
309 | * | |
310 | * If no conversion is performed, store @nptr in *@endptr and return | |
311 | * -EINVAL. | |
312 | * | |
313 | * If @endptr is null, and the string isn't fully converted, return | |
314 | * -EINVAL. This is the case when the pointer that would be stored in | |
315 | * a non-null @endptr points to a character other than '\0'. | |
316 | * | |
317 | * If the conversion overflows @result, store INT_MAX in @result, | |
318 | * and return -ERANGE. | |
319 | * | |
320 | * If the conversion underflows @result, store INT_MIN in @result, | |
321 | * and return -ERANGE. | |
322 | * | |
323 | * Else store the converted value in @result, and return zero. | |
324 | */ | |
325 | int qemu_strtoi(const char *nptr, const char **endptr, int base, | |
326 | int *result) | |
327 | { | |
328 | char *ep; | |
329 | long long lresult; | |
330 | ||
53a90b97 | 331 | assert((unsigned) base <= 36 && base != 1); |
473a2a33 DB |
332 | if (!nptr) { |
333 | if (endptr) { | |
334 | *endptr = nptr; | |
335 | } | |
336 | return -EINVAL; | |
337 | } | |
338 | ||
339 | errno = 0; | |
340 | lresult = strtoll(nptr, &ep, base); | |
341 | if (lresult < INT_MIN) { | |
342 | *result = INT_MIN; | |
343 | errno = ERANGE; | |
344 | } else if (lresult > INT_MAX) { | |
345 | *result = INT_MAX; | |
346 | errno = ERANGE; | |
347 | } else { | |
348 | *result = lresult; | |
349 | } | |
350 | return check_strtox_error(nptr, ep, endptr, errno); | |
351 | } | |
352 | ||
353 | /** | |
354 | * Convert string @nptr to an unsigned integer, and store it in @result. | |
355 | * | |
356 | * This is a wrapper around strtoul() that is harder to misuse. | |
357 | * Semantics of @nptr, @endptr, @base match strtoul() with differences | |
358 | * noted below. | |
359 | * | |
360 | * @nptr may be null, and no conversion is performed then. | |
361 | * | |
362 | * If no conversion is performed, store @nptr in *@endptr and return | |
363 | * -EINVAL. | |
364 | * | |
365 | * If @endptr is null, and the string isn't fully converted, return | |
366 | * -EINVAL. This is the case when the pointer that would be stored in | |
367 | * a non-null @endptr points to a character other than '\0'. | |
368 | * | |
369 | * If the conversion overflows @result, store UINT_MAX in @result, | |
370 | * and return -ERANGE. | |
371 | * | |
372 | * Else store the converted value in @result, and return zero. | |
373 | * | |
374 | * Note that a number with a leading minus sign gets converted without | |
375 | * the minus sign, checked for overflow (see above), then negated (in | |
376 | * @result's type). This is exactly how strtoul() works. | |
377 | */ | |
378 | int qemu_strtoui(const char *nptr, const char **endptr, int base, | |
379 | unsigned int *result) | |
380 | { | |
381 | char *ep; | |
382 | long long lresult; | |
383 | ||
53a90b97 | 384 | assert((unsigned) base <= 36 && base != 1); |
473a2a33 DB |
385 | if (!nptr) { |
386 | if (endptr) { | |
387 | *endptr = nptr; | |
388 | } | |
389 | return -EINVAL; | |
390 | } | |
391 | ||
392 | errno = 0; | |
393 | lresult = strtoull(nptr, &ep, base); | |
394 | ||
395 | /* Windows returns 1 for negative out-of-range values. */ | |
396 | if (errno == ERANGE) { | |
397 | *result = -1; | |
398 | } else { | |
399 | if (lresult > UINT_MAX) { | |
400 | *result = UINT_MAX; | |
401 | errno = ERANGE; | |
402 | } else if (lresult < INT_MIN) { | |
403 | *result = UINT_MAX; | |
404 | errno = ERANGE; | |
405 | } else { | |
406 | *result = lresult; | |
407 | } | |
408 | } | |
409 | return check_strtox_error(nptr, ep, endptr, errno); | |
410 | } | |
411 | ||
764e0fa4 | 412 | /** |
4295f879 | 413 | * Convert string @nptr to a long integer, and store it in @result. |
764e0fa4 | 414 | * |
4295f879 MA |
415 | * This is a wrapper around strtol() that is harder to misuse. |
416 | * Semantics of @nptr, @endptr, @base match strtol() with differences | |
417 | * noted below. | |
764e0fa4 | 418 | * |
4295f879 | 419 | * @nptr may be null, and no conversion is performed then. |
764e0fa4 | 420 | * |
4295f879 MA |
421 | * If no conversion is performed, store @nptr in *@endptr and return |
422 | * -EINVAL. | |
764e0fa4 | 423 | * |
4295f879 MA |
424 | * If @endptr is null, and the string isn't fully converted, return |
425 | * -EINVAL. This is the case when the pointer that would be stored in | |
426 | * a non-null @endptr points to a character other than '\0'. | |
427 | * | |
428 | * If the conversion overflows @result, store LONG_MAX in @result, | |
429 | * and return -ERANGE. | |
430 | * | |
431 | * If the conversion underflows @result, store LONG_MIN in @result, | |
432 | * and return -ERANGE. | |
433 | * | |
434 | * Else store the converted value in @result, and return zero. | |
764e0fa4 CT |
435 | */ |
436 | int qemu_strtol(const char *nptr, const char **endptr, int base, | |
437 | long *result) | |
438 | { | |
717adf96 | 439 | char *ep; |
4baef267 | 440 | |
53a90b97 | 441 | assert((unsigned) base <= 36 && base != 1); |
764e0fa4 CT |
442 | if (!nptr) { |
443 | if (endptr) { | |
444 | *endptr = nptr; | |
445 | } | |
4baef267 | 446 | return -EINVAL; |
764e0fa4 | 447 | } |
4baef267 MA |
448 | |
449 | errno = 0; | |
450 | *result = strtol(nptr, &ep, base); | |
451 | return check_strtox_error(nptr, ep, endptr, errno); | |
764e0fa4 | 452 | } |
c817c015 CT |
453 | |
454 | /** | |
4295f879 MA |
455 | * Convert string @nptr to an unsigned long, and store it in @result. |
456 | * | |
457 | * This is a wrapper around strtoul() that is harder to misuse. | |
458 | * Semantics of @nptr, @endptr, @base match strtoul() with differences | |
459 | * noted below. | |
460 | * | |
461 | * @nptr may be null, and no conversion is performed then. | |
462 | * | |
463 | * If no conversion is performed, store @nptr in *@endptr and return | |
464 | * -EINVAL. | |
465 | * | |
466 | * If @endptr is null, and the string isn't fully converted, return | |
467 | * -EINVAL. This is the case when the pointer that would be stored in | |
468 | * a non-null @endptr points to a character other than '\0'. | |
c817c015 | 469 | * |
4295f879 MA |
470 | * If the conversion overflows @result, store ULONG_MAX in @result, |
471 | * and return -ERANGE. | |
c817c015 | 472 | * |
4295f879 | 473 | * Else store the converted value in @result, and return zero. |
c817c015 | 474 | * |
4295f879 MA |
475 | * Note that a number with a leading minus sign gets converted without |
476 | * the minus sign, checked for overflow (see above), then negated (in | |
477 | * @result's type). This is exactly how strtoul() works. | |
c817c015 CT |
478 | */ |
479 | int qemu_strtoul(const char *nptr, const char **endptr, int base, | |
480 | unsigned long *result) | |
481 | { | |
717adf96 | 482 | char *ep; |
4baef267 | 483 | |
53a90b97 | 484 | assert((unsigned) base <= 36 && base != 1); |
c817c015 CT |
485 | if (!nptr) { |
486 | if (endptr) { | |
487 | *endptr = nptr; | |
488 | } | |
4baef267 MA |
489 | return -EINVAL; |
490 | } | |
491 | ||
492 | errno = 0; | |
493 | *result = strtoul(nptr, &ep, base); | |
494 | /* Windows returns 1 for negative out-of-range values. */ | |
495 | if (errno == ERANGE) { | |
496 | *result = -1; | |
c817c015 | 497 | } |
4baef267 | 498 | return check_strtox_error(nptr, ep, endptr, errno); |
c817c015 CT |
499 | } |
500 | ||
8ac4df40 | 501 | /** |
4295f879 | 502 | * Convert string @nptr to an int64_t. |
8ac4df40 | 503 | * |
4295f879 MA |
504 | * Works like qemu_strtol(), except it stores INT64_MAX on overflow, |
505 | * and INT_MIN on underflow. | |
8ac4df40 | 506 | */ |
b30d1886 | 507 | int qemu_strtoi64(const char *nptr, const char **endptr, int base, |
8ac4df40 CT |
508 | int64_t *result) |
509 | { | |
717adf96 | 510 | char *ep; |
4baef267 | 511 | |
53a90b97 | 512 | assert((unsigned) base <= 36 && base != 1); |
8ac4df40 CT |
513 | if (!nptr) { |
514 | if (endptr) { | |
515 | *endptr = nptr; | |
516 | } | |
4baef267 | 517 | return -EINVAL; |
8ac4df40 | 518 | } |
4baef267 MA |
519 | |
520 | errno = 0; | |
521 | /* FIXME This assumes int64_t is long long */ | |
522 | *result = strtoll(nptr, &ep, base); | |
523 | return check_strtox_error(nptr, ep, endptr, errno); | |
8ac4df40 CT |
524 | } |
525 | ||
3904e6bf | 526 | /** |
4295f879 | 527 | * Convert string @nptr to an uint64_t. |
3904e6bf | 528 | * |
4295f879 | 529 | * Works like qemu_strtoul(), except it stores UINT64_MAX on overflow. |
3904e6bf | 530 | */ |
b30d1886 | 531 | int qemu_strtou64(const char *nptr, const char **endptr, int base, |
3904e6bf CT |
532 | uint64_t *result) |
533 | { | |
717adf96 | 534 | char *ep; |
4baef267 | 535 | |
53a90b97 | 536 | assert((unsigned) base <= 36 && base != 1); |
3904e6bf CT |
537 | if (!nptr) { |
538 | if (endptr) { | |
539 | *endptr = nptr; | |
540 | } | |
4baef267 MA |
541 | return -EINVAL; |
542 | } | |
543 | ||
544 | errno = 0; | |
545 | /* FIXME This assumes uint64_t is unsigned long long */ | |
546 | *result = strtoull(nptr, &ep, base); | |
547 | /* Windows returns 1 for negative out-of-range values. */ | |
548 | if (errno == ERANGE) { | |
549 | *result = -1; | |
3904e6bf | 550 | } |
4baef267 | 551 | return check_strtox_error(nptr, ep, endptr, errno); |
3904e6bf CT |
552 | } |
553 | ||
ca28f548 DH |
554 | /** |
555 | * Convert string @nptr to a double. | |
556 | * | |
557 | * This is a wrapper around strtod() that is harder to misuse. | |
558 | * Semantics of @nptr and @endptr match strtod() with differences | |
559 | * noted below. | |
560 | * | |
561 | * @nptr may be null, and no conversion is performed then. | |
562 | * | |
563 | * If no conversion is performed, store @nptr in *@endptr and return | |
564 | * -EINVAL. | |
565 | * | |
566 | * If @endptr is null, and the string isn't fully converted, return | |
567 | * -EINVAL. This is the case when the pointer that would be stored in | |
568 | * a non-null @endptr points to a character other than '\0'. | |
569 | * | |
570 | * If the conversion overflows, store +/-HUGE_VAL in @result, depending | |
571 | * on the sign, and return -ERANGE. | |
572 | * | |
573 | * If the conversion underflows, store +/-0.0 in @result, depending on the | |
574 | * sign, and return -ERANGE. | |
575 | * | |
576 | * Else store the converted value in @result, and return zero. | |
577 | */ | |
578 | int qemu_strtod(const char *nptr, const char **endptr, double *result) | |
579 | { | |
580 | char *ep; | |
581 | ||
582 | if (!nptr) { | |
583 | if (endptr) { | |
584 | *endptr = nptr; | |
585 | } | |
586 | return -EINVAL; | |
587 | } | |
588 | ||
589 | errno = 0; | |
590 | *result = strtod(nptr, &ep); | |
591 | return check_strtox_error(nptr, ep, endptr, errno); | |
592 | } | |
593 | ||
594 | /** | |
595 | * Convert string @nptr to a finite double. | |
596 | * | |
597 | * Works like qemu_strtod(), except that "NaN" and "inf" are rejected | |
598 | * with -EINVAL and no conversion is performed. | |
599 | */ | |
600 | int qemu_strtod_finite(const char *nptr, const char **endptr, double *result) | |
601 | { | |
602 | double tmp; | |
603 | int ret; | |
604 | ||
605 | ret = qemu_strtod(nptr, endptr, &tmp); | |
606 | if (!ret && !isfinite(tmp)) { | |
607 | if (endptr) { | |
608 | *endptr = nptr; | |
609 | } | |
610 | ret = -EINVAL; | |
611 | } | |
612 | ||
613 | if (ret != -EINVAL) { | |
614 | *result = tmp; | |
615 | } | |
616 | return ret; | |
617 | } | |
618 | ||
5c99fa37 KF |
619 | /** |
620 | * Searches for the first occurrence of 'c' in 's', and returns a pointer | |
621 | * to the trailing null byte if none was found. | |
622 | */ | |
623 | #ifndef HAVE_STRCHRNUL | |
624 | const char *qemu_strchrnul(const char *s, int c) | |
625 | { | |
626 | const char *e = strchr(s, c); | |
627 | if (!e) { | |
628 | e = s + strlen(s); | |
629 | } | |
630 | return e; | |
631 | } | |
632 | #endif | |
633 | ||
e3f9fe2d EH |
634 | /** |
635 | * parse_uint: | |
636 | * | |
637 | * @s: String to parse | |
638 | * @value: Destination for parsed integer value | |
639 | * @endptr: Destination for pointer to first character not consumed | |
640 | * @base: integer base, between 2 and 36 inclusive, or 0 | |
641 | * | |
642 | * Parse unsigned integer | |
643 | * | |
644 | * Parsed syntax is like strtoull()'s: arbitrary whitespace, a single optional | |
645 | * '+' or '-', an optional "0x" if @base is 0 or 16, one or more digits. | |
646 | * | |
647 | * If @s is null, or @base is invalid, or @s doesn't start with an | |
648 | * integer in the syntax above, set *@value to 0, *@endptr to @s, and | |
649 | * return -EINVAL. | |
650 | * | |
651 | * Set *@endptr to point right beyond the parsed integer (even if the integer | |
652 | * overflows or is negative, all digits will be parsed and *@endptr will | |
653 | * point right beyond them). | |
654 | * | |
655 | * If the integer is negative, set *@value to 0, and return -ERANGE. | |
656 | * | |
657 | * If the integer overflows unsigned long long, set *@value to | |
658 | * ULLONG_MAX, and return -ERANGE. | |
659 | * | |
660 | * Else, set *@value to the parsed integer, and return 0. | |
661 | */ | |
662 | int parse_uint(const char *s, unsigned long long *value, char **endptr, | |
663 | int base) | |
664 | { | |
665 | int r = 0; | |
666 | char *endp = (char *)s; | |
667 | unsigned long long val = 0; | |
668 | ||
53a90b97 | 669 | assert((unsigned) base <= 36 && base != 1); |
e3f9fe2d EH |
670 | if (!s) { |
671 | r = -EINVAL; | |
672 | goto out; | |
673 | } | |
674 | ||
675 | errno = 0; | |
676 | val = strtoull(s, &endp, base); | |
677 | if (errno) { | |
678 | r = -errno; | |
679 | goto out; | |
680 | } | |
681 | ||
682 | if (endp == s) { | |
683 | r = -EINVAL; | |
684 | goto out; | |
685 | } | |
686 | ||
687 | /* make sure we reject negative numbers: */ | |
db3d11ee | 688 | while (qemu_isspace(*s)) { |
e3f9fe2d EH |
689 | s++; |
690 | } | |
691 | if (*s == '-') { | |
692 | val = 0; | |
693 | r = -ERANGE; | |
694 | goto out; | |
695 | } | |
696 | ||
697 | out: | |
698 | *value = val; | |
699 | *endptr = endp; | |
700 | return r; | |
701 | } | |
702 | ||
703 | /** | |
704 | * parse_uint_full: | |
705 | * | |
706 | * @s: String to parse | |
707 | * @value: Destination for parsed integer value | |
708 | * @base: integer base, between 2 and 36 inclusive, or 0 | |
709 | * | |
710 | * Parse unsigned integer from entire string | |
711 | * | |
712 | * Have the same behavior of parse_uint(), but with an additional check | |
713 | * for additional data after the parsed number. If extra characters are present | |
714 | * after the parsed number, the function will return -EINVAL, and *@v will | |
715 | * be set to 0. | |
716 | */ | |
717 | int parse_uint_full(const char *s, unsigned long long *value, int base) | |
718 | { | |
719 | char *endp; | |
720 | int r; | |
721 | ||
722 | r = parse_uint(s, value, &endp, base); | |
723 | if (r < 0) { | |
724 | return r; | |
725 | } | |
726 | if (*endp) { | |
727 | *value = 0; | |
728 | return -EINVAL; | |
729 | } | |
730 | ||
731 | return 0; | |
732 | } | |
733 | ||
443916d1 SB |
734 | int qemu_parse_fd(const char *param) |
735 | { | |
e9c5c1f4 LE |
736 | long fd; |
737 | char *endptr; | |
443916d1 | 738 | |
e9c5c1f4 | 739 | errno = 0; |
443916d1 | 740 | fd = strtol(param, &endptr, 10); |
e9c5c1f4 LE |
741 | if (param == endptr /* no conversion performed */ || |
742 | errno != 0 /* not representable as long; possibly others */ || | |
743 | *endptr != '\0' /* final string not empty */ || | |
744 | fd < 0 /* invalid as file descriptor */ || | |
745 | fd > INT_MAX /* not representable as int */) { | |
443916d1 SB |
746 | return -1; |
747 | } | |
748 | return fd; | |
749 | } | |
9fb26641 | 750 | |
e6546bb9 OW |
751 | /* |
752 | * Implementation of ULEB128 (http://en.wikipedia.org/wiki/LEB128) | |
753 | * Input is limited to 14-bit numbers | |
754 | */ | |
755 | int uleb128_encode_small(uint8_t *out, uint32_t n) | |
756 | { | |
757 | g_assert(n <= 0x3fff); | |
758 | if (n < 0x80) { | |
7c960d61 | 759 | *out = n; |
e6546bb9 OW |
760 | return 1; |
761 | } else { | |
762 | *out++ = (n & 0x7f) | 0x80; | |
7c960d61 | 763 | *out = n >> 7; |
e6546bb9 OW |
764 | return 2; |
765 | } | |
766 | } | |
767 | ||
768 | int uleb128_decode_small(const uint8_t *in, uint32_t *n) | |
769 | { | |
770 | if (!(*in & 0x80)) { | |
7c960d61 | 771 | *n = *in; |
e6546bb9 OW |
772 | return 1; |
773 | } else { | |
774 | *n = *in++ & 0x7f; | |
775 | /* we exceed 14 bit number */ | |
776 | if (*in & 0x80) { | |
777 | return -1; | |
778 | } | |
7c960d61 | 779 | *n |= *in << 7; |
e6546bb9 OW |
780 | return 2; |
781 | } | |
782 | } | |
b16352ac AL |
783 | |
784 | /* | |
785 | * helper to parse debug environment variables | |
786 | */ | |
787 | int parse_debug_env(const char *name, int max, int initial) | |
788 | { | |
789 | char *debug_env = getenv(name); | |
790 | char *inv = NULL; | |
cc5d0e04 | 791 | long debug; |
b16352ac AL |
792 | |
793 | if (!debug_env) { | |
794 | return initial; | |
795 | } | |
cc5d0e04 | 796 | errno = 0; |
b16352ac AL |
797 | debug = strtol(debug_env, &inv, 10); |
798 | if (inv == debug_env) { | |
799 | return initial; | |
800 | } | |
cc5d0e04 | 801 | if (debug < 0 || debug > max || errno != 0) { |
05cb8ed5 | 802 | warn_report("%s not in [0, %d]", name, max); |
b16352ac AL |
803 | return initial; |
804 | } | |
805 | return debug; | |
806 | } | |
4297c8ee AK |
807 | |
808 | /* | |
809 | * Helper to print ethernet mac address | |
810 | */ | |
811 | const char *qemu_ether_ntoa(const MACAddr *mac) | |
812 | { | |
813 | static char ret[18]; | |
814 | ||
815 | snprintf(ret, sizeof(ret), "%02x:%02x:%02x:%02x:%02x:%02x", | |
816 | mac->a[0], mac->a[1], mac->a[2], mac->a[3], mac->a[4], mac->a[5]); | |
817 | ||
818 | return ret; | |
819 | } | |
22951aaa PX |
820 | |
821 | /* | |
822 | * Return human readable string for size @val. | |
823 | * @val can be anything that uint64_t allows (no more than "16 EiB"). | |
824 | * Use IEC binary units like KiB, MiB, and so forth. | |
825 | * Caller is responsible for passing it to g_free(). | |
826 | */ | |
827 | char *size_to_str(uint64_t val) | |
828 | { | |
829 | static const char *suffixes[] = { "", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei" }; | |
754da867 | 830 | uint64_t div; |
22951aaa PX |
831 | int i; |
832 | ||
833 | /* | |
834 | * The exponent (returned in i) minus one gives us | |
835 | * floor(log2(val * 1024 / 1000). The correction makes us | |
836 | * switch to the higher power when the integer part is >= 1000. | |
837 | * (see e41b509d68afb1f for more info) | |
838 | */ | |
839 | frexp(val / (1000.0 / 1024.0), &i); | |
840 | i = (i - 1) / 10; | |
841 | div = 1ULL << (i * 10); | |
842 | ||
843 | return g_strdup_printf("%0.3g %sB", (double)val / div, suffixes[i]); | |
844 | } | |
85e33a28 MAL |
845 | |
846 | int qemu_pstrcmp0(const char **str1, const char **str2) | |
847 | { | |
848 | return g_strcmp0(*str1, *str2); | |
849 | } |