xref: /openbmc/qemu/util/cutils.c (revision 587adaca)
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 /**
168  * Sync changes made to the memory mapped file back to the backing
169  * storage. For POSIX compliant systems this will fallback
170  * to regular msync call. Otherwise it will trigger whole file sync
171  * (including the metadata case there is no support to skip that otherwise)
172  *
173  * @addr   - start of the memory area to be synced
174  * @length - length of the are to be synced
175  * @fd     - file descriptor for the file to be synced
176  *           (mandatory only for POSIX non-compliant systems)
177  */
178 int qemu_msync(void *addr, size_t length, int fd)
179 {
180 #ifdef CONFIG_POSIX
181     size_t align_mask = ~(qemu_real_host_page_size - 1);
182 
183     /**
184      * There are no strict reqs as per the length of mapping
185      * to be synced. Still the length needs to follow the address
186      * alignment changes. Additionally - round the size to the multiple
187      * of PAGE_SIZE
188      */
189     length += ((uintptr_t)addr & (qemu_real_host_page_size - 1));
190     length = (length + ~align_mask) & align_mask;
191 
192     addr = (void *)((uintptr_t)addr & align_mask);
193 
194     return msync(addr, length, MS_SYNC);
195 #else /* CONFIG_POSIX */
196     /**
197      * Perform the sync based on the file descriptor
198      * The sync range will most probably be wider than the one
199      * requested - but it will still get the job done
200      */
201     return qemu_fdatasync(fd);
202 #endif /* CONFIG_POSIX */
203 }
204 
205 #ifndef _WIN32
206 /* Sets a specific flag */
207 int fcntl_setfl(int fd, int flag)
208 {
209     int flags;
210 
211     flags = fcntl(fd, F_GETFL);
212     if (flags == -1)
213         return -errno;
214 
215     if (fcntl(fd, F_SETFL, flags | flag) == -1)
216         return -errno;
217 
218     return 0;
219 }
220 #endif
221 
222 static int64_t suffix_mul(char suffix, int64_t unit)
223 {
224     switch (qemu_toupper(suffix)) {
225     case 'B':
226         return 1;
227     case 'K':
228         return unit;
229     case 'M':
230         return unit * unit;
231     case 'G':
232         return unit * unit * unit;
233     case 'T':
234         return unit * unit * unit * unit;
235     case 'P':
236         return unit * unit * unit * unit * unit;
237     case 'E':
238         return unit * unit * unit * unit * unit * unit;
239     }
240     return -1;
241 }
242 
243 /*
244  * Convert size string to bytes.
245  *
246  * The size parsing supports the following syntaxes
247  * - 12345 - decimal, scale determined by @default_suffix and @unit
248  * - 12345{bBkKmMgGtTpPeE} - decimal, scale determined by suffix and @unit
249  * - 12345.678{kKmMgGtTpPeE} - decimal, scale determined by suffix, and
250  *   fractional portion is truncated to byte
251  * - 0x7fEE - hexadecimal, unit determined by @default_suffix
252  *
253  * The following cause a deprecation warning, and may be removed in the future
254  * - 0xabc{kKmMgGtTpP} - hex with scaling suffix
255  *
256  * The following are intentionally not supported
257  * - octal, such as 08
258  * - fractional hex, such as 0x1.8
259  * - floating point exponents, such as 1e3
260  *
261  * The end pointer will be returned in *end, if not NULL.  If there is
262  * no fraction, the input can be decimal or hexadecimal; if there is a
263  * fraction, then the input must be decimal and there must be a suffix
264  * (possibly by @default_suffix) larger than Byte, and the fractional
265  * portion may suffer from precision loss or rounding.  The input must
266  * be positive.
267  *
268  * Return -ERANGE on overflow (with *@end advanced), and -EINVAL on
269  * other error (with *@end left unchanged).
270  */
271 static int do_strtosz(const char *nptr, const char **end,
272                       const char default_suffix, int64_t unit,
273                       uint64_t *result)
274 {
275     int retval;
276     const char *endptr, *f;
277     unsigned char c;
278     bool hex = false;
279     uint64_t val, valf = 0;
280     int64_t mul;
281 
282     /* Parse integral portion as decimal. */
283     retval = qemu_strtou64(nptr, &endptr, 10, &val);
284     if (retval) {
285         goto out;
286     }
287     if (memchr(nptr, '-', endptr - nptr) != NULL) {
288         endptr = nptr;
289         retval = -EINVAL;
290         goto out;
291     }
292     if (val == 0 && (*endptr == 'x' || *endptr == 'X')) {
293         /* Input looks like hex, reparse, and insist on no fraction. */
294         retval = qemu_strtou64(nptr, &endptr, 16, &val);
295         if (retval) {
296             goto out;
297         }
298         if (*endptr == '.') {
299             endptr = nptr;
300             retval = -EINVAL;
301             goto out;
302         }
303         hex = true;
304     } else if (*endptr == '.') {
305         /*
306          * Input looks like a fraction.  Make sure even 1.k works
307          * without fractional digits.  If we see an exponent, treat
308          * the entire input as invalid instead.
309          */
310         double fraction;
311 
312         f = endptr;
313         retval = qemu_strtod_finite(f, &endptr, &fraction);
314         if (retval) {
315             endptr++;
316         } else if (memchr(f, 'e', endptr - f) || memchr(f, 'E', endptr - f)) {
317             endptr = nptr;
318             retval = -EINVAL;
319             goto out;
320         } else {
321             /* Extract into a 64-bit fixed-point fraction. */
322             valf = (uint64_t)(fraction * 0x1p64);
323         }
324     }
325     c = *endptr;
326     mul = suffix_mul(c, unit);
327     if (mul > 0) {
328         if (hex) {
329             warn_report("Using a multiplier suffix on hex numbers "
330                         "is deprecated: %s", nptr);
331         }
332         endptr++;
333     } else {
334         mul = suffix_mul(default_suffix, unit);
335         assert(mul > 0);
336     }
337     if (mul == 1) {
338         /* When a fraction is present, a scale is required. */
339         if (valf != 0) {
340             endptr = nptr;
341             retval = -EINVAL;
342             goto out;
343         }
344     } else {
345         uint64_t valh, tmp;
346 
347         /* Compute exact result: 64.64 x 64.0 -> 128.64 fixed point */
348         mulu64(&val, &valh, val, mul);
349         mulu64(&valf, &tmp, valf, mul);
350         val += tmp;
351         valh += val < tmp;
352 
353         /* Round 0.5 upward. */
354         tmp = valf >> 63;
355         val += tmp;
356         valh += val < tmp;
357 
358         /* Report overflow. */
359         if (valh != 0) {
360             retval = -ERANGE;
361             goto out;
362         }
363     }
364 
365     retval = 0;
366 
367 out:
368     if (end) {
369         *end = endptr;
370     } else if (*endptr) {
371         retval = -EINVAL;
372     }
373     if (retval == 0) {
374         *result = val;
375     }
376 
377     return retval;
378 }
379 
380 int qemu_strtosz(const char *nptr, const char **end, uint64_t *result)
381 {
382     return do_strtosz(nptr, end, 'B', 1024, result);
383 }
384 
385 int qemu_strtosz_MiB(const char *nptr, const char **end, uint64_t *result)
386 {
387     return do_strtosz(nptr, end, 'M', 1024, result);
388 }
389 
390 int qemu_strtosz_metric(const char *nptr, const char **end, uint64_t *result)
391 {
392     return do_strtosz(nptr, end, 'B', 1000, result);
393 }
394 
395 /**
396  * Helper function for error checking after strtol() and the like
397  */
398 static int check_strtox_error(const char *nptr, char *ep,
399                               const char **endptr, bool check_zero,
400                               int libc_errno)
401 {
402     assert(ep >= nptr);
403 
404     /* Windows has a bug in that it fails to parse 0 from "0x" in base 16 */
405     if (check_zero && ep == nptr && libc_errno == 0) {
406         char *tmp;
407 
408         errno = 0;
409         if (strtol(nptr, &tmp, 10) == 0 && errno == 0 &&
410             (*tmp == 'x' || *tmp == 'X')) {
411             ep = tmp;
412         }
413     }
414 
415     if (endptr) {
416         *endptr = ep;
417     }
418 
419     /* Turn "no conversion" into an error */
420     if (libc_errno == 0 && ep == nptr) {
421         return -EINVAL;
422     }
423 
424     /* Fail when we're expected to consume the string, but didn't */
425     if (!endptr && *ep) {
426         return -EINVAL;
427     }
428 
429     return -libc_errno;
430 }
431 
432 /**
433  * Convert string @nptr to an integer, and store it in @result.
434  *
435  * This is a wrapper around strtol() that is harder to misuse.
436  * Semantics of @nptr, @endptr, @base match strtol() with differences
437  * noted below.
438  *
439  * @nptr may be null, and no conversion is performed then.
440  *
441  * If no conversion is performed, store @nptr in *@endptr and return
442  * -EINVAL.
443  *
444  * If @endptr is null, and the string isn't fully converted, return
445  * -EINVAL.  This is the case when the pointer that would be stored in
446  * a non-null @endptr points to a character other than '\0'.
447  *
448  * If the conversion overflows @result, store INT_MAX in @result,
449  * and return -ERANGE.
450  *
451  * If the conversion underflows @result, store INT_MIN in @result,
452  * and return -ERANGE.
453  *
454  * Else store the converted value in @result, and return zero.
455  */
456 int qemu_strtoi(const char *nptr, const char **endptr, int base,
457                 int *result)
458 {
459     char *ep;
460     long long lresult;
461 
462     assert((unsigned) base <= 36 && base != 1);
463     if (!nptr) {
464         if (endptr) {
465             *endptr = nptr;
466         }
467         return -EINVAL;
468     }
469 
470     errno = 0;
471     lresult = strtoll(nptr, &ep, base);
472     if (lresult < INT_MIN) {
473         *result = INT_MIN;
474         errno = ERANGE;
475     } else if (lresult > INT_MAX) {
476         *result = INT_MAX;
477         errno = ERANGE;
478     } else {
479         *result = lresult;
480     }
481     return check_strtox_error(nptr, ep, endptr, lresult == 0, errno);
482 }
483 
484 /**
485  * Convert string @nptr to an unsigned integer, and store it in @result.
486  *
487  * This is a wrapper around strtoul() that is harder to misuse.
488  * Semantics of @nptr, @endptr, @base match strtoul() with differences
489  * noted below.
490  *
491  * @nptr may be null, and no conversion is performed then.
492  *
493  * If no conversion is performed, store @nptr in *@endptr and return
494  * -EINVAL.
495  *
496  * If @endptr is null, and the string isn't fully converted, return
497  * -EINVAL.  This is the case when the pointer that would be stored in
498  * a non-null @endptr points to a character other than '\0'.
499  *
500  * If the conversion overflows @result, store UINT_MAX in @result,
501  * and return -ERANGE.
502  *
503  * Else store the converted value in @result, and return zero.
504  *
505  * Note that a number with a leading minus sign gets converted without
506  * the minus sign, checked for overflow (see above), then negated (in
507  * @result's type).  This is exactly how strtoul() works.
508  */
509 int qemu_strtoui(const char *nptr, const char **endptr, int base,
510                  unsigned int *result)
511 {
512     char *ep;
513     long long lresult;
514 
515     assert((unsigned) base <= 36 && base != 1);
516     if (!nptr) {
517         if (endptr) {
518             *endptr = nptr;
519         }
520         return -EINVAL;
521     }
522 
523     errno = 0;
524     lresult = strtoull(nptr, &ep, base);
525 
526     /* Windows returns 1 for negative out-of-range values.  */
527     if (errno == ERANGE) {
528         *result = -1;
529     } else {
530         if (lresult > UINT_MAX) {
531             *result = UINT_MAX;
532             errno = ERANGE;
533         } else if (lresult < INT_MIN) {
534             *result = UINT_MAX;
535             errno = ERANGE;
536         } else {
537             *result = lresult;
538         }
539     }
540     return check_strtox_error(nptr, ep, endptr, lresult == 0, errno);
541 }
542 
543 /**
544  * Convert string @nptr to a long integer, and store it in @result.
545  *
546  * This is a wrapper around strtol() that is harder to misuse.
547  * Semantics of @nptr, @endptr, @base match strtol() with differences
548  * noted below.
549  *
550  * @nptr may be null, and no conversion is performed then.
551  *
552  * If no conversion is performed, store @nptr in *@endptr and return
553  * -EINVAL.
554  *
555  * If @endptr is null, and the string isn't fully converted, return
556  * -EINVAL.  This is the case when the pointer that would be stored in
557  * a non-null @endptr points to a character other than '\0'.
558  *
559  * If the conversion overflows @result, store LONG_MAX in @result,
560  * and return -ERANGE.
561  *
562  * If the conversion underflows @result, store LONG_MIN in @result,
563  * and return -ERANGE.
564  *
565  * Else store the converted value in @result, and return zero.
566  */
567 int qemu_strtol(const char *nptr, const char **endptr, int base,
568                 long *result)
569 {
570     char *ep;
571 
572     assert((unsigned) base <= 36 && base != 1);
573     if (!nptr) {
574         if (endptr) {
575             *endptr = nptr;
576         }
577         return -EINVAL;
578     }
579 
580     errno = 0;
581     *result = strtol(nptr, &ep, base);
582     return check_strtox_error(nptr, ep, endptr, *result == 0, errno);
583 }
584 
585 /**
586  * Convert string @nptr to an unsigned long, and store it in @result.
587  *
588  * This is a wrapper around strtoul() that is harder to misuse.
589  * Semantics of @nptr, @endptr, @base match strtoul() with differences
590  * noted below.
591  *
592  * @nptr may be null, and no conversion is performed then.
593  *
594  * If no conversion is performed, store @nptr in *@endptr and return
595  * -EINVAL.
596  *
597  * If @endptr is null, and the string isn't fully converted, return
598  * -EINVAL.  This is the case when the pointer that would be stored in
599  * a non-null @endptr points to a character other than '\0'.
600  *
601  * If the conversion overflows @result, store ULONG_MAX in @result,
602  * and return -ERANGE.
603  *
604  * Else store the converted value in @result, and return zero.
605  *
606  * Note that a number with a leading minus sign gets converted without
607  * the minus sign, checked for overflow (see above), then negated (in
608  * @result's type).  This is exactly how strtoul() works.
609  */
610 int qemu_strtoul(const char *nptr, const char **endptr, int base,
611                  unsigned long *result)
612 {
613     char *ep;
614 
615     assert((unsigned) base <= 36 && base != 1);
616     if (!nptr) {
617         if (endptr) {
618             *endptr = nptr;
619         }
620         return -EINVAL;
621     }
622 
623     errno = 0;
624     *result = strtoul(nptr, &ep, base);
625     /* Windows returns 1 for negative out-of-range values.  */
626     if (errno == ERANGE) {
627         *result = -1;
628     }
629     return check_strtox_error(nptr, ep, endptr, *result == 0, errno);
630 }
631 
632 /**
633  * Convert string @nptr to an int64_t.
634  *
635  * Works like qemu_strtol(), except it stores INT64_MAX on overflow,
636  * and INT64_MIN on underflow.
637  */
638 int qemu_strtoi64(const char *nptr, const char **endptr, int base,
639                  int64_t *result)
640 {
641     char *ep;
642 
643     assert((unsigned) base <= 36 && base != 1);
644     if (!nptr) {
645         if (endptr) {
646             *endptr = nptr;
647         }
648         return -EINVAL;
649     }
650 
651     /* This assumes int64_t is long long TODO relax */
652     QEMU_BUILD_BUG_ON(sizeof(int64_t) != sizeof(long long));
653     errno = 0;
654     *result = strtoll(nptr, &ep, base);
655     return check_strtox_error(nptr, ep, endptr, *result == 0, errno);
656 }
657 
658 /**
659  * Convert string @nptr to an uint64_t.
660  *
661  * Works like qemu_strtoul(), except it stores UINT64_MAX on overflow.
662  */
663 int qemu_strtou64(const char *nptr, const char **endptr, int base,
664                   uint64_t *result)
665 {
666     char *ep;
667 
668     assert((unsigned) base <= 36 && base != 1);
669     if (!nptr) {
670         if (endptr) {
671             *endptr = nptr;
672         }
673         return -EINVAL;
674     }
675 
676     /* This assumes uint64_t is unsigned long long TODO relax */
677     QEMU_BUILD_BUG_ON(sizeof(uint64_t) != sizeof(unsigned long long));
678     errno = 0;
679     *result = strtoull(nptr, &ep, base);
680     /* Windows returns 1 for negative out-of-range values.  */
681     if (errno == ERANGE) {
682         *result = -1;
683     }
684     return check_strtox_error(nptr, ep, endptr, *result == 0, errno);
685 }
686 
687 /**
688  * Convert string @nptr to a double.
689   *
690  * This is a wrapper around strtod() that is harder to misuse.
691  * Semantics of @nptr and @endptr match strtod() with differences
692  * noted below.
693  *
694  * @nptr may be null, and no conversion is performed then.
695  *
696  * If no conversion is performed, store @nptr in *@endptr and return
697  * -EINVAL.
698  *
699  * If @endptr is null, and the string isn't fully converted, return
700  * -EINVAL. This is the case when the pointer that would be stored in
701  * a non-null @endptr points to a character other than '\0'.
702  *
703  * If the conversion overflows, store +/-HUGE_VAL in @result, depending
704  * on the sign, and return -ERANGE.
705  *
706  * If the conversion underflows, store +/-0.0 in @result, depending on the
707  * sign, and return -ERANGE.
708  *
709  * Else store the converted value in @result, and return zero.
710  */
711 int qemu_strtod(const char *nptr, const char **endptr, double *result)
712 {
713     char *ep;
714 
715     if (!nptr) {
716         if (endptr) {
717             *endptr = nptr;
718         }
719         return -EINVAL;
720     }
721 
722     errno = 0;
723     *result = strtod(nptr, &ep);
724     return check_strtox_error(nptr, ep, endptr, false, errno);
725 }
726 
727 /**
728  * Convert string @nptr to a finite double.
729  *
730  * Works like qemu_strtod(), except that "NaN" and "inf" are rejected
731  * with -EINVAL and no conversion is performed.
732  */
733 int qemu_strtod_finite(const char *nptr, const char **endptr, double *result)
734 {
735     double tmp;
736     int ret;
737 
738     ret = qemu_strtod(nptr, endptr, &tmp);
739     if (!ret && !isfinite(tmp)) {
740         if (endptr) {
741             *endptr = nptr;
742         }
743         ret = -EINVAL;
744     }
745 
746     if (ret != -EINVAL) {
747         *result = tmp;
748     }
749     return ret;
750 }
751 
752 /**
753  * Searches for the first occurrence of 'c' in 's', and returns a pointer
754  * to the trailing null byte if none was found.
755  */
756 #ifndef HAVE_STRCHRNUL
757 const char *qemu_strchrnul(const char *s, int c)
758 {
759     const char *e = strchr(s, c);
760     if (!e) {
761         e = s + strlen(s);
762     }
763     return e;
764 }
765 #endif
766 
767 /**
768  * parse_uint:
769  *
770  * @s: String to parse
771  * @value: Destination for parsed integer value
772  * @endptr: Destination for pointer to first character not consumed
773  * @base: integer base, between 2 and 36 inclusive, or 0
774  *
775  * Parse unsigned integer
776  *
777  * Parsed syntax is like strtoull()'s: arbitrary whitespace, a single optional
778  * '+' or '-', an optional "0x" if @base is 0 or 16, one or more digits.
779  *
780  * If @s is null, or @base is invalid, or @s doesn't start with an
781  * integer in the syntax above, set *@value to 0, *@endptr to @s, and
782  * return -EINVAL.
783  *
784  * Set *@endptr to point right beyond the parsed integer (even if the integer
785  * overflows or is negative, all digits will be parsed and *@endptr will
786  * point right beyond them).
787  *
788  * If the integer is negative, set *@value to 0, and return -ERANGE.
789  *
790  * If the integer overflows unsigned long long, set *@value to
791  * ULLONG_MAX, and return -ERANGE.
792  *
793  * Else, set *@value to the parsed integer, and return 0.
794  */
795 int parse_uint(const char *s, unsigned long long *value, char **endptr,
796                int base)
797 {
798     int r = 0;
799     char *endp = (char *)s;
800     unsigned long long val = 0;
801 
802     assert((unsigned) base <= 36 && base != 1);
803     if (!s) {
804         r = -EINVAL;
805         goto out;
806     }
807 
808     errno = 0;
809     val = strtoull(s, &endp, base);
810     if (errno) {
811         r = -errno;
812         goto out;
813     }
814 
815     if (endp == s) {
816         r = -EINVAL;
817         goto out;
818     }
819 
820     /* make sure we reject negative numbers: */
821     while (qemu_isspace(*s)) {
822         s++;
823     }
824     if (*s == '-') {
825         val = 0;
826         r = -ERANGE;
827         goto out;
828     }
829 
830 out:
831     *value = val;
832     *endptr = endp;
833     return r;
834 }
835 
836 /**
837  * parse_uint_full:
838  *
839  * @s: String to parse
840  * @value: Destination for parsed integer value
841  * @base: integer base, between 2 and 36 inclusive, or 0
842  *
843  * Parse unsigned integer from entire string
844  *
845  * Have the same behavior of parse_uint(), but with an additional check
846  * for additional data after the parsed number. If extra characters are present
847  * after the parsed number, the function will return -EINVAL, and *@v will
848  * be set to 0.
849  */
850 int parse_uint_full(const char *s, unsigned long long *value, int base)
851 {
852     char *endp;
853     int r;
854 
855     r = parse_uint(s, value, &endp, base);
856     if (r < 0) {
857         return r;
858     }
859     if (*endp) {
860         *value = 0;
861         return -EINVAL;
862     }
863 
864     return 0;
865 }
866 
867 int qemu_parse_fd(const char *param)
868 {
869     long fd;
870     char *endptr;
871 
872     errno = 0;
873     fd = strtol(param, &endptr, 10);
874     if (param == endptr /* no conversion performed */                    ||
875         errno != 0      /* not representable as long; possibly others */ ||
876         *endptr != '\0' /* final string not empty */                     ||
877         fd < 0          /* invalid as file descriptor */                 ||
878         fd > INT_MAX    /* not representable as int */) {
879         return -1;
880     }
881     return fd;
882 }
883 
884 /*
885  * Implementation of  ULEB128 (http://en.wikipedia.org/wiki/LEB128)
886  * Input is limited to 14-bit numbers
887  */
888 int uleb128_encode_small(uint8_t *out, uint32_t n)
889 {
890     g_assert(n <= 0x3fff);
891     if (n < 0x80) {
892         *out = n;
893         return 1;
894     } else {
895         *out++ = (n & 0x7f) | 0x80;
896         *out = n >> 7;
897         return 2;
898     }
899 }
900 
901 int uleb128_decode_small(const uint8_t *in, uint32_t *n)
902 {
903     if (!(*in & 0x80)) {
904         *n = *in;
905         return 1;
906     } else {
907         *n = *in++ & 0x7f;
908         /* we exceed 14 bit number */
909         if (*in & 0x80) {
910             return -1;
911         }
912         *n |= *in << 7;
913         return 2;
914     }
915 }
916 
917 /*
918  * helper to parse debug environment variables
919  */
920 int parse_debug_env(const char *name, int max, int initial)
921 {
922     char *debug_env = getenv(name);
923     char *inv = NULL;
924     long debug;
925 
926     if (!debug_env) {
927         return initial;
928     }
929     errno = 0;
930     debug = strtol(debug_env, &inv, 10);
931     if (inv == debug_env) {
932         return initial;
933     }
934     if (debug < 0 || debug > max || errno != 0) {
935         warn_report("%s not in [0, %d]", name, max);
936         return initial;
937     }
938     return debug;
939 }
940 
941 /*
942  * Helper to print ethernet mac address
943  */
944 const char *qemu_ether_ntoa(const MACAddr *mac)
945 {
946     static char ret[18];
947 
948     snprintf(ret, sizeof(ret), "%02x:%02x:%02x:%02x:%02x:%02x",
949              mac->a[0], mac->a[1], mac->a[2], mac->a[3], mac->a[4], mac->a[5]);
950 
951     return ret;
952 }
953 
954 /*
955  * Return human readable string for size @val.
956  * @val can be anything that uint64_t allows (no more than "16 EiB").
957  * Use IEC binary units like KiB, MiB, and so forth.
958  * Caller is responsible for passing it to g_free().
959  */
960 char *size_to_str(uint64_t val)
961 {
962     static const char *suffixes[] = { "", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei" };
963     uint64_t div;
964     int i;
965 
966     /*
967      * The exponent (returned in i) minus one gives us
968      * floor(log2(val * 1024 / 1000).  The correction makes us
969      * switch to the higher power when the integer part is >= 1000.
970      * (see e41b509d68afb1f for more info)
971      */
972     frexp(val / (1000.0 / 1024.0), &i);
973     i = (i - 1) / 10;
974     div = 1ULL << (i * 10);
975 
976     return g_strdup_printf("%0.3g %sB", (double)val / div, suffixes[i]);
977 }
978 
979 char *freq_to_str(uint64_t freq_hz)
980 {
981     static const char *const suffixes[] = { "", "K", "M", "G", "T", "P", "E" };
982     double freq = freq_hz;
983     size_t idx = 0;
984 
985     while (freq >= 1000.0) {
986         freq /= 1000.0;
987         idx++;
988     }
989     assert(idx < ARRAY_SIZE(suffixes));
990 
991     return g_strdup_printf("%0.3g %sHz", freq, suffixes[idx]);
992 }
993 
994 int qemu_pstrcmp0(const char **str1, const char **str2)
995 {
996     return g_strcmp0(*str1, *str2);
997 }
998 
999 static inline bool starts_with_prefix(const char *dir)
1000 {
1001     size_t prefix_len = strlen(CONFIG_PREFIX);
1002     return !memcmp(dir, CONFIG_PREFIX, prefix_len) &&
1003         (!dir[prefix_len] || G_IS_DIR_SEPARATOR(dir[prefix_len]));
1004 }
1005 
1006 /* Return the next path component in dir, and store its length in *p_len.  */
1007 static inline const char *next_component(const char *dir, int *p_len)
1008 {
1009     int len;
1010     while ((*dir && G_IS_DIR_SEPARATOR(*dir)) ||
1011            (*dir == '.' && (G_IS_DIR_SEPARATOR(dir[1]) || dir[1] == '\0'))) {
1012         dir++;
1013     }
1014     len = 0;
1015     while (dir[len] && !G_IS_DIR_SEPARATOR(dir[len])) {
1016         len++;
1017     }
1018     *p_len = len;
1019     return dir;
1020 }
1021 
1022 char *get_relocated_path(const char *dir)
1023 {
1024     size_t prefix_len = strlen(CONFIG_PREFIX);
1025     const char *bindir = CONFIG_BINDIR;
1026     const char *exec_dir = qemu_get_exec_dir();
1027     GString *result;
1028     int len_dir, len_bindir;
1029 
1030     /* Fail if qemu_init_exec_dir was not called.  */
1031     assert(exec_dir[0]);
1032     if (!starts_with_prefix(dir) || !starts_with_prefix(bindir)) {
1033         return g_strdup(dir);
1034     }
1035 
1036     result = g_string_new(exec_dir);
1037 
1038     /* Advance over common components.  */
1039     len_dir = len_bindir = prefix_len;
1040     do {
1041         dir += len_dir;
1042         bindir += len_bindir;
1043         dir = next_component(dir, &len_dir);
1044         bindir = next_component(bindir, &len_bindir);
1045     } while (len_dir && len_dir == len_bindir && !memcmp(dir, bindir, len_dir));
1046 
1047     /* Ascend from bindir to the common prefix with dir.  */
1048     while (len_bindir) {
1049         bindir += len_bindir;
1050         g_string_append(result, "/..");
1051         bindir = next_component(bindir, &len_bindir);
1052     }
1053 
1054     if (*dir) {
1055         assert(G_IS_DIR_SEPARATOR(dir[-1]));
1056         g_string_append(result, dir - 1);
1057     }
1058     return g_string_free(result, false);
1059 }
1060