1 | /* |
2 | * Simple C functions to supplement the C library |
3 | * |
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 | */ |
24 | |
25 | #include "qemu/osdep.h" |
26 | #include "qemu/host-utils.h" |
27 | #include <math.h> |
28 | |
29 | #include "qemu-common.h" |
30 | #include "qemu/sockets.h" |
31 | #include "qemu/iov.h" |
32 | #include "net/net.h" |
33 | #include "qemu/ctype.h" |
34 | #include "qemu/cutils.h" |
35 | #include "qemu/error-report.h" |
36 | |
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 | |
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); |
66 | if (len < buf_size) |
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') { |
93 | if (qemu_toupper(*p) != qemu_toupper(*q)) |
94 | return 0; |
95 | p++; |
96 | q++; |
97 | } |
98 | if (ptr) |
99 | *ptr = p; |
100 | return 1; |
101 | } |
102 | |
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 | |
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 | |
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 | } |
145 | t = 86400ULL * (d + (153 * m - 457) / 5 + 365 * y + y / 4 - y / 100 + |
146 | y / 400 - 719469); |
147 | t += 3600 * tm->tm_hour + 60 * tm->tm_min + tm->tm_sec; |
148 | return t; |
149 | } |
150 | |
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 | { |
160 | #ifdef CONFIG_FDATASYNC |
161 | return fdatasync(fd); |
162 | #else |
163 | return fsync(fd); |
164 | #endif |
165 | } |
166 | |
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 | |
184 | static int64_t suffix_mul(char suffix, int64_t unit) |
185 | { |
186 | switch (qemu_toupper(suffix)) { |
187 | case 'B': |
188 | return 1; |
189 | case 'K': |
190 | return unit; |
191 | case 'M': |
192 | return unit * unit; |
193 | case 'G': |
194 | return unit * unit * unit; |
195 | case 'T': |
196 | return unit * unit * unit * unit; |
197 | case 'P': |
198 | return unit * unit * unit * unit * unit; |
199 | case 'E': |
200 | return unit * unit * unit * unit * unit * unit; |
201 | } |
202 | return -1; |
203 | } |
204 | |
205 | /* |
206 | * Convert string to bytes, allowing either B/b for bytes, K/k for KB, |
207 | * M/m for MB, G/g for GB or T/t for TB. End pointer will be returned |
208 | * in *end, if not NULL. Return -ERANGE on overflow, and -EINVAL on |
209 | * other error. |
210 | */ |
211 | static int do_strtosz(const char *nptr, const char **end, |
212 | const char default_suffix, int64_t unit, |
213 | uint64_t *result) |
214 | { |
215 | int retval; |
216 | const char *endptr; |
217 | unsigned char c; |
218 | int mul_required = 0; |
219 | double val, mul, integral, fraction; |
220 | |
221 | retval = qemu_strtod_finite(nptr, &endptr, &val); |
222 | if (retval) { |
223 | goto out; |
224 | } |
225 | fraction = modf(val, &integral); |
226 | if (fraction != 0) { |
227 | mul_required = 1; |
228 | } |
229 | c = *endptr; |
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); |
236 | } |
237 | if (mul == 1 && mul_required) { |
238 | retval = -EINVAL; |
239 | goto out; |
240 | } |
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) { |
246 | retval = -ERANGE; |
247 | goto out; |
248 | } |
249 | *result = val * mul; |
250 | retval = 0; |
251 | |
252 | out: |
253 | if (end) { |
254 | *end = endptr; |
255 | } else if (*endptr) { |
256 | retval = -EINVAL; |
257 | } |
258 | |
259 | return retval; |
260 | } |
261 | |
262 | int qemu_strtosz(const char *nptr, const char **end, uint64_t *result) |
263 | { |
264 | return do_strtosz(nptr, end, 'B', 1024, result); |
265 | } |
266 | |
267 | int qemu_strtosz_MiB(const char *nptr, const char **end, uint64_t *result) |
268 | { |
269 | return do_strtosz(nptr, end, 'M', 1024, result); |
270 | } |
271 | |
272 | int qemu_strtosz_metric(const char *nptr, const char **end, uint64_t *result) |
273 | { |
274 | return do_strtosz(nptr, end, 'B', 1000, result); |
275 | } |
276 | |
277 | /** |
278 | * Helper function for error checking after strtol() and the like |
279 | */ |
280 | static int check_strtox_error(const char *nptr, char *ep, |
281 | const char **endptr, int libc_errno) |
282 | { |
283 | assert(ep >= nptr); |
284 | if (endptr) { |
285 | *endptr = ep; |
286 | } |
287 | |
288 | /* Turn "no conversion" into an error */ |
289 | if (libc_errno == 0 && ep == nptr) { |
290 | return -EINVAL; |
291 | } |
292 | |
293 | /* Fail when we're expected to consume the string, but didn't */ |
294 | if (!endptr && *ep) { |
295 | return -EINVAL; |
296 | } |
297 | |
298 | return -libc_errno; |
299 | } |
300 | |
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 | |
331 | assert((unsigned) base <= 36 && base != 1); |
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 | |
384 | assert((unsigned) base <= 36 && base != 1); |
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 | |
412 | /** |
413 | * Convert string @nptr to a long integer, and store it in @result. |
414 | * |
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. |
418 | * |
419 | * @nptr may be null, and no conversion is performed then. |
420 | * |
421 | * If no conversion is performed, store @nptr in *@endptr and return |
422 | * -EINVAL. |
423 | * |
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. |
435 | */ |
436 | int qemu_strtol(const char *nptr, const char **endptr, int base, |
437 | long *result) |
438 | { |
439 | char *ep; |
440 | |
441 | assert((unsigned) base <= 36 && base != 1); |
442 | if (!nptr) { |
443 | if (endptr) { |
444 | *endptr = nptr; |
445 | } |
446 | return -EINVAL; |
447 | } |
448 | |
449 | errno = 0; |
450 | *result = strtol(nptr, &ep, base); |
451 | return check_strtox_error(nptr, ep, endptr, errno); |
452 | } |
453 | |
454 | /** |
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'. |
469 | * |
470 | * If the conversion overflows @result, store ULONG_MAX in @result, |
471 | * and return -ERANGE. |
472 | * |
473 | * Else store the converted value in @result, and return zero. |
474 | * |
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. |
478 | */ |
479 | int qemu_strtoul(const char *nptr, const char **endptr, int base, |
480 | unsigned long *result) |
481 | { |
482 | char *ep; |
483 | |
484 | assert((unsigned) base <= 36 && base != 1); |
485 | if (!nptr) { |
486 | if (endptr) { |
487 | *endptr = nptr; |
488 | } |
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; |
497 | } |
498 | return check_strtox_error(nptr, ep, endptr, errno); |
499 | } |
500 | |
501 | /** |
502 | * Convert string @nptr to an int64_t. |
503 | * |
504 | * Works like qemu_strtol(), except it stores INT64_MAX on overflow, |
505 | * and INT_MIN on underflow. |
506 | */ |
507 | int qemu_strtoi64(const char *nptr, const char **endptr, int base, |
508 | int64_t *result) |
509 | { |
510 | char *ep; |
511 | |
512 | assert((unsigned) base <= 36 && base != 1); |
513 | if (!nptr) { |
514 | if (endptr) { |
515 | *endptr = nptr; |
516 | } |
517 | return -EINVAL; |
518 | } |
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); |
524 | } |
525 | |
526 | /** |
527 | * Convert string @nptr to an uint64_t. |
528 | * |
529 | * Works like qemu_strtoul(), except it stores UINT64_MAX on overflow. |
530 | */ |
531 | int qemu_strtou64(const char *nptr, const char **endptr, int base, |
532 | uint64_t *result) |
533 | { |
534 | char *ep; |
535 | |
536 | assert((unsigned) base <= 36 && base != 1); |
537 | if (!nptr) { |
538 | if (endptr) { |
539 | *endptr = nptr; |
540 | } |
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; |
550 | } |
551 | return check_strtox_error(nptr, ep, endptr, errno); |
552 | } |
553 | |
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 | |
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 | |
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 | |
669 | assert((unsigned) base <= 36 && base != 1); |
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: */ |
688 | while (qemu_isspace(*s)) { |
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 | |
734 | int qemu_parse_fd(const char *param) |
735 | { |
736 | long fd; |
737 | char *endptr; |
738 | |
739 | errno = 0; |
740 | fd = strtol(param, &endptr, 10); |
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 */) { |
746 | return -1; |
747 | } |
748 | return fd; |
749 | } |
750 | |
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) { |
759 | *out = n; |
760 | return 1; |
761 | } else { |
762 | *out++ = (n & 0x7f) | 0x80; |
763 | *out = n >> 7; |
764 | return 2; |
765 | } |
766 | } |
767 | |
768 | int uleb128_decode_small(const uint8_t *in, uint32_t *n) |
769 | { |
770 | if (!(*in & 0x80)) { |
771 | *n = *in; |
772 | return 1; |
773 | } else { |
774 | *n = *in++ & 0x7f; |
775 | /* we exceed 14 bit number */ |
776 | if (*in & 0x80) { |
777 | return -1; |
778 | } |
779 | *n |= *in << 7; |
780 | return 2; |
781 | } |
782 | } |
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; |
791 | long debug; |
792 | |
793 | if (!debug_env) { |
794 | return initial; |
795 | } |
796 | errno = 0; |
797 | debug = strtol(debug_env, &inv, 10); |
798 | if (inv == debug_env) { |
799 | return initial; |
800 | } |
801 | if (debug < 0 || debug > max || errno != 0) { |
802 | warn_report("%s not in [0, %d]" , name, max); |
803 | return initial; |
804 | } |
805 | return debug; |
806 | } |
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 | } |
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" }; |
830 | uint64_t div; |
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 | } |
845 | |
846 | int qemu_pstrcmp0(const char **str1, const char **str2) |
847 | { |
848 | return g_strcmp0(*str1, *str2); |
849 | } |
850 | |