xref: /openbmc/qemu/util/cutils.c (revision ce437484)
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 string to bytes, allowing either B/b for bytes, K/k for KB,
245   * M/m for MB, G/g for GB or T/t for TB. End pointer will be returned
246   * in *end, if not NULL. Return -ERANGE on overflow, and -EINVAL on
247   * other error.
248   */
249  static int do_strtosz(const char *nptr, const char **end,
250                        const char default_suffix, int64_t unit,
251                        uint64_t *result)
252  {
253      int retval;
254      const char *endptr;
255      unsigned char c;
256      int mul_required = 0;
257      double val, mul, integral, fraction;
258  
259      retval = qemu_strtod_finite(nptr, &endptr, &val);
260      if (retval) {
261          goto out;
262      }
263      fraction = modf(val, &integral);
264      if (fraction != 0) {
265          mul_required = 1;
266      }
267      c = *endptr;
268      mul = suffix_mul(c, unit);
269      if (mul >= 0) {
270          endptr++;
271      } else {
272          mul = suffix_mul(default_suffix, unit);
273          assert(mul >= 0);
274      }
275      if (mul == 1 && mul_required) {
276          retval = -EINVAL;
277          goto out;
278      }
279      /*
280       * Values near UINT64_MAX overflow to 2**64 when converting to double
281       * precision.  Compare against the maximum representable double precision
282       * value below 2**64, computed as "the next value after 2**64 (0x1p64) in
283       * the direction of 0".
284       */
285      if ((val * mul > nextafter(0x1p64, 0)) || val < 0) {
286          retval = -ERANGE;
287          goto out;
288      }
289      *result = val * mul;
290      retval = 0;
291  
292  out:
293      if (end) {
294          *end = endptr;
295      } else if (*endptr) {
296          retval = -EINVAL;
297      }
298  
299      return retval;
300  }
301  
302  int qemu_strtosz(const char *nptr, const char **end, uint64_t *result)
303  {
304      return do_strtosz(nptr, end, 'B', 1024, result);
305  }
306  
307  int qemu_strtosz_MiB(const char *nptr, const char **end, uint64_t *result)
308  {
309      return do_strtosz(nptr, end, 'M', 1024, result);
310  }
311  
312  int qemu_strtosz_metric(const char *nptr, const char **end, uint64_t *result)
313  {
314      return do_strtosz(nptr, end, 'B', 1000, result);
315  }
316  
317  /**
318   * Helper function for error checking after strtol() and the like
319   */
320  static int check_strtox_error(const char *nptr, char *ep,
321                                const char **endptr, int libc_errno)
322  {
323      assert(ep >= nptr);
324      if (endptr) {
325          *endptr = ep;
326      }
327  
328      /* Turn "no conversion" into an error */
329      if (libc_errno == 0 && ep == nptr) {
330          return -EINVAL;
331      }
332  
333      /* Fail when we're expected to consume the string, but didn't */
334      if (!endptr && *ep) {
335          return -EINVAL;
336      }
337  
338      return -libc_errno;
339  }
340  
341  /**
342   * Convert string @nptr to an integer, and store it in @result.
343   *
344   * This is a wrapper around strtol() that is harder to misuse.
345   * Semantics of @nptr, @endptr, @base match strtol() with differences
346   * noted below.
347   *
348   * @nptr may be null, and no conversion is performed then.
349   *
350   * If no conversion is performed, store @nptr in *@endptr and return
351   * -EINVAL.
352   *
353   * If @endptr is null, and the string isn't fully converted, return
354   * -EINVAL.  This is the case when the pointer that would be stored in
355   * a non-null @endptr points to a character other than '\0'.
356   *
357   * If the conversion overflows @result, store INT_MAX in @result,
358   * and return -ERANGE.
359   *
360   * If the conversion underflows @result, store INT_MIN in @result,
361   * and return -ERANGE.
362   *
363   * Else store the converted value in @result, and return zero.
364   */
365  int qemu_strtoi(const char *nptr, const char **endptr, int base,
366                  int *result)
367  {
368      char *ep;
369      long long lresult;
370  
371      assert((unsigned) base <= 36 && base != 1);
372      if (!nptr) {
373          if (endptr) {
374              *endptr = nptr;
375          }
376          return -EINVAL;
377      }
378  
379      errno = 0;
380      lresult = strtoll(nptr, &ep, base);
381      if (lresult < INT_MIN) {
382          *result = INT_MIN;
383          errno = ERANGE;
384      } else if (lresult > INT_MAX) {
385          *result = INT_MAX;
386          errno = ERANGE;
387      } else {
388          *result = lresult;
389      }
390      return check_strtox_error(nptr, ep, endptr, errno);
391  }
392  
393  /**
394   * Convert string @nptr to an unsigned integer, and store it in @result.
395   *
396   * This is a wrapper around strtoul() that is harder to misuse.
397   * Semantics of @nptr, @endptr, @base match strtoul() with differences
398   * noted below.
399   *
400   * @nptr may be null, and no conversion is performed then.
401   *
402   * If no conversion is performed, store @nptr in *@endptr and return
403   * -EINVAL.
404   *
405   * If @endptr is null, and the string isn't fully converted, return
406   * -EINVAL.  This is the case when the pointer that would be stored in
407   * a non-null @endptr points to a character other than '\0'.
408   *
409   * If the conversion overflows @result, store UINT_MAX in @result,
410   * and return -ERANGE.
411   *
412   * Else store the converted value in @result, and return zero.
413   *
414   * Note that a number with a leading minus sign gets converted without
415   * the minus sign, checked for overflow (see above), then negated (in
416   * @result's type).  This is exactly how strtoul() works.
417   */
418  int qemu_strtoui(const char *nptr, const char **endptr, int base,
419                   unsigned int *result)
420  {
421      char *ep;
422      long long lresult;
423  
424      assert((unsigned) base <= 36 && base != 1);
425      if (!nptr) {
426          if (endptr) {
427              *endptr = nptr;
428          }
429          return -EINVAL;
430      }
431  
432      errno = 0;
433      lresult = strtoull(nptr, &ep, base);
434  
435      /* Windows returns 1 for negative out-of-range values.  */
436      if (errno == ERANGE) {
437          *result = -1;
438      } else {
439          if (lresult > UINT_MAX) {
440              *result = UINT_MAX;
441              errno = ERANGE;
442          } else if (lresult < INT_MIN) {
443              *result = UINT_MAX;
444              errno = ERANGE;
445          } else {
446              *result = lresult;
447          }
448      }
449      return check_strtox_error(nptr, ep, endptr, errno);
450  }
451  
452  /**
453   * Convert string @nptr to a long integer, and store it in @result.
454   *
455   * This is a wrapper around strtol() that is harder to misuse.
456   * Semantics of @nptr, @endptr, @base match strtol() with differences
457   * noted below.
458   *
459   * @nptr may be null, and no conversion is performed then.
460   *
461   * If no conversion is performed, store @nptr in *@endptr and return
462   * -EINVAL.
463   *
464   * If @endptr is null, and the string isn't fully converted, return
465   * -EINVAL.  This is the case when the pointer that would be stored in
466   * a non-null @endptr points to a character other than '\0'.
467   *
468   * If the conversion overflows @result, store LONG_MAX in @result,
469   * and return -ERANGE.
470   *
471   * If the conversion underflows @result, store LONG_MIN in @result,
472   * and return -ERANGE.
473   *
474   * Else store the converted value in @result, and return zero.
475   */
476  int qemu_strtol(const char *nptr, const char **endptr, int base,
477                  long *result)
478  {
479      char *ep;
480  
481      assert((unsigned) base <= 36 && base != 1);
482      if (!nptr) {
483          if (endptr) {
484              *endptr = nptr;
485          }
486          return -EINVAL;
487      }
488  
489      errno = 0;
490      *result = strtol(nptr, &ep, base);
491      return check_strtox_error(nptr, ep, endptr, errno);
492  }
493  
494  /**
495   * Convert string @nptr to an unsigned long, and store it in @result.
496   *
497   * This is a wrapper around strtoul() that is harder to misuse.
498   * Semantics of @nptr, @endptr, @base match strtoul() with differences
499   * noted below.
500   *
501   * @nptr may be null, and no conversion is performed then.
502   *
503   * If no conversion is performed, store @nptr in *@endptr and return
504   * -EINVAL.
505   *
506   * If @endptr is null, and the string isn't fully converted, return
507   * -EINVAL.  This is the case when the pointer that would be stored in
508   * a non-null @endptr points to a character other than '\0'.
509   *
510   * If the conversion overflows @result, store ULONG_MAX in @result,
511   * and return -ERANGE.
512   *
513   * Else store the converted value in @result, and return zero.
514   *
515   * Note that a number with a leading minus sign gets converted without
516   * the minus sign, checked for overflow (see above), then negated (in
517   * @result's type).  This is exactly how strtoul() works.
518   */
519  int qemu_strtoul(const char *nptr, const char **endptr, int base,
520                   unsigned long *result)
521  {
522      char *ep;
523  
524      assert((unsigned) base <= 36 && base != 1);
525      if (!nptr) {
526          if (endptr) {
527              *endptr = nptr;
528          }
529          return -EINVAL;
530      }
531  
532      errno = 0;
533      *result = strtoul(nptr, &ep, base);
534      /* Windows returns 1 for negative out-of-range values.  */
535      if (errno == ERANGE) {
536          *result = -1;
537      }
538      return check_strtox_error(nptr, ep, endptr, errno);
539  }
540  
541  /**
542   * Convert string @nptr to an int64_t.
543   *
544   * Works like qemu_strtol(), except it stores INT64_MAX on overflow,
545   * and INT64_MIN on underflow.
546   */
547  int qemu_strtoi64(const char *nptr, const char **endptr, int base,
548                   int64_t *result)
549  {
550      char *ep;
551  
552      assert((unsigned) base <= 36 && base != 1);
553      if (!nptr) {
554          if (endptr) {
555              *endptr = nptr;
556          }
557          return -EINVAL;
558      }
559  
560      /* This assumes int64_t is long long TODO relax */
561      QEMU_BUILD_BUG_ON(sizeof(int64_t) != sizeof(long long));
562      errno = 0;
563      *result = strtoll(nptr, &ep, base);
564      return check_strtox_error(nptr, ep, endptr, errno);
565  }
566  
567  /**
568   * Convert string @nptr to an uint64_t.
569   *
570   * Works like qemu_strtoul(), except it stores UINT64_MAX on overflow.
571   */
572  int qemu_strtou64(const char *nptr, const char **endptr, int base,
573                    uint64_t *result)
574  {
575      char *ep;
576  
577      assert((unsigned) base <= 36 && base != 1);
578      if (!nptr) {
579          if (endptr) {
580              *endptr = nptr;
581          }
582          return -EINVAL;
583      }
584  
585      /* This assumes uint64_t is unsigned long long TODO relax */
586      QEMU_BUILD_BUG_ON(sizeof(uint64_t) != sizeof(unsigned long long));
587      errno = 0;
588      *result = strtoull(nptr, &ep, base);
589      /* Windows returns 1 for negative out-of-range values.  */
590      if (errno == ERANGE) {
591          *result = -1;
592      }
593      return check_strtox_error(nptr, ep, endptr, errno);
594  }
595  
596  /**
597   * Convert string @nptr to a double.
598    *
599   * This is a wrapper around strtod() that is harder to misuse.
600   * Semantics of @nptr and @endptr match strtod() with differences
601   * noted below.
602   *
603   * @nptr may be null, and no conversion is performed then.
604   *
605   * If no conversion is performed, store @nptr in *@endptr and return
606   * -EINVAL.
607   *
608   * If @endptr is null, and the string isn't fully converted, return
609   * -EINVAL. This is the case when the pointer that would be stored in
610   * a non-null @endptr points to a character other than '\0'.
611   *
612   * If the conversion overflows, store +/-HUGE_VAL in @result, depending
613   * on the sign, and return -ERANGE.
614   *
615   * If the conversion underflows, store +/-0.0 in @result, depending on the
616   * sign, and return -ERANGE.
617   *
618   * Else store the converted value in @result, and return zero.
619   */
620  int qemu_strtod(const char *nptr, const char **endptr, double *result)
621  {
622      char *ep;
623  
624      if (!nptr) {
625          if (endptr) {
626              *endptr = nptr;
627          }
628          return -EINVAL;
629      }
630  
631      errno = 0;
632      *result = strtod(nptr, &ep);
633      return check_strtox_error(nptr, ep, endptr, errno);
634  }
635  
636  /**
637   * Convert string @nptr to a finite double.
638   *
639   * Works like qemu_strtod(), except that "NaN" and "inf" are rejected
640   * with -EINVAL and no conversion is performed.
641   */
642  int qemu_strtod_finite(const char *nptr, const char **endptr, double *result)
643  {
644      double tmp;
645      int ret;
646  
647      ret = qemu_strtod(nptr, endptr, &tmp);
648      if (!ret && !isfinite(tmp)) {
649          if (endptr) {
650              *endptr = nptr;
651          }
652          ret = -EINVAL;
653      }
654  
655      if (ret != -EINVAL) {
656          *result = tmp;
657      }
658      return ret;
659  }
660  
661  /**
662   * Searches for the first occurrence of 'c' in 's', and returns a pointer
663   * to the trailing null byte if none was found.
664   */
665  #ifndef HAVE_STRCHRNUL
666  const char *qemu_strchrnul(const char *s, int c)
667  {
668      const char *e = strchr(s, c);
669      if (!e) {
670          e = s + strlen(s);
671      }
672      return e;
673  }
674  #endif
675  
676  /**
677   * parse_uint:
678   *
679   * @s: String to parse
680   * @value: Destination for parsed integer value
681   * @endptr: Destination for pointer to first character not consumed
682   * @base: integer base, between 2 and 36 inclusive, or 0
683   *
684   * Parse unsigned integer
685   *
686   * Parsed syntax is like strtoull()'s: arbitrary whitespace, a single optional
687   * '+' or '-', an optional "0x" if @base is 0 or 16, one or more digits.
688   *
689   * If @s is null, or @base is invalid, or @s doesn't start with an
690   * integer in the syntax above, set *@value to 0, *@endptr to @s, and
691   * return -EINVAL.
692   *
693   * Set *@endptr to point right beyond the parsed integer (even if the integer
694   * overflows or is negative, all digits will be parsed and *@endptr will
695   * point right beyond them).
696   *
697   * If the integer is negative, set *@value to 0, and return -ERANGE.
698   *
699   * If the integer overflows unsigned long long, set *@value to
700   * ULLONG_MAX, and return -ERANGE.
701   *
702   * Else, set *@value to the parsed integer, and return 0.
703   */
704  int parse_uint(const char *s, unsigned long long *value, char **endptr,
705                 int base)
706  {
707      int r = 0;
708      char *endp = (char *)s;
709      unsigned long long val = 0;
710  
711      assert((unsigned) base <= 36 && base != 1);
712      if (!s) {
713          r = -EINVAL;
714          goto out;
715      }
716  
717      errno = 0;
718      val = strtoull(s, &endp, base);
719      if (errno) {
720          r = -errno;
721          goto out;
722      }
723  
724      if (endp == s) {
725          r = -EINVAL;
726          goto out;
727      }
728  
729      /* make sure we reject negative numbers: */
730      while (qemu_isspace(*s)) {
731          s++;
732      }
733      if (*s == '-') {
734          val = 0;
735          r = -ERANGE;
736          goto out;
737      }
738  
739  out:
740      *value = val;
741      *endptr = endp;
742      return r;
743  }
744  
745  /**
746   * parse_uint_full:
747   *
748   * @s: String to parse
749   * @value: Destination for parsed integer value
750   * @base: integer base, between 2 and 36 inclusive, or 0
751   *
752   * Parse unsigned integer from entire string
753   *
754   * Have the same behavior of parse_uint(), but with an additional check
755   * for additional data after the parsed number. If extra characters are present
756   * after the parsed number, the function will return -EINVAL, and *@v will
757   * be set to 0.
758   */
759  int parse_uint_full(const char *s, unsigned long long *value, int base)
760  {
761      char *endp;
762      int r;
763  
764      r = parse_uint(s, value, &endp, base);
765      if (r < 0) {
766          return r;
767      }
768      if (*endp) {
769          *value = 0;
770          return -EINVAL;
771      }
772  
773      return 0;
774  }
775  
776  int qemu_parse_fd(const char *param)
777  {
778      long fd;
779      char *endptr;
780  
781      errno = 0;
782      fd = strtol(param, &endptr, 10);
783      if (param == endptr /* no conversion performed */                    ||
784          errno != 0      /* not representable as long; possibly others */ ||
785          *endptr != '\0' /* final string not empty */                     ||
786          fd < 0          /* invalid as file descriptor */                 ||
787          fd > INT_MAX    /* not representable as int */) {
788          return -1;
789      }
790      return fd;
791  }
792  
793  /*
794   * Implementation of  ULEB128 (http://en.wikipedia.org/wiki/LEB128)
795   * Input is limited to 14-bit numbers
796   */
797  int uleb128_encode_small(uint8_t *out, uint32_t n)
798  {
799      g_assert(n <= 0x3fff);
800      if (n < 0x80) {
801          *out = n;
802          return 1;
803      } else {
804          *out++ = (n & 0x7f) | 0x80;
805          *out = n >> 7;
806          return 2;
807      }
808  }
809  
810  int uleb128_decode_small(const uint8_t *in, uint32_t *n)
811  {
812      if (!(*in & 0x80)) {
813          *n = *in;
814          return 1;
815      } else {
816          *n = *in++ & 0x7f;
817          /* we exceed 14 bit number */
818          if (*in & 0x80) {
819              return -1;
820          }
821          *n |= *in << 7;
822          return 2;
823      }
824  }
825  
826  /*
827   * helper to parse debug environment variables
828   */
829  int parse_debug_env(const char *name, int max, int initial)
830  {
831      char *debug_env = getenv(name);
832      char *inv = NULL;
833      long debug;
834  
835      if (!debug_env) {
836          return initial;
837      }
838      errno = 0;
839      debug = strtol(debug_env, &inv, 10);
840      if (inv == debug_env) {
841          return initial;
842      }
843      if (debug < 0 || debug > max || errno != 0) {
844          warn_report("%s not in [0, %d]", name, max);
845          return initial;
846      }
847      return debug;
848  }
849  
850  /*
851   * Helper to print ethernet mac address
852   */
853  const char *qemu_ether_ntoa(const MACAddr *mac)
854  {
855      static char ret[18];
856  
857      snprintf(ret, sizeof(ret), "%02x:%02x:%02x:%02x:%02x:%02x",
858               mac->a[0], mac->a[1], mac->a[2], mac->a[3], mac->a[4], mac->a[5]);
859  
860      return ret;
861  }
862  
863  /*
864   * Return human readable string for size @val.
865   * @val can be anything that uint64_t allows (no more than "16 EiB").
866   * Use IEC binary units like KiB, MiB, and so forth.
867   * Caller is responsible for passing it to g_free().
868   */
869  char *size_to_str(uint64_t val)
870  {
871      static const char *suffixes[] = { "", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei" };
872      uint64_t div;
873      int i;
874  
875      /*
876       * The exponent (returned in i) minus one gives us
877       * floor(log2(val * 1024 / 1000).  The correction makes us
878       * switch to the higher power when the integer part is >= 1000.
879       * (see e41b509d68afb1f for more info)
880       */
881      frexp(val / (1000.0 / 1024.0), &i);
882      i = (i - 1) / 10;
883      div = 1ULL << (i * 10);
884  
885      return g_strdup_printf("%0.3g %sB", (double)val / div, suffixes[i]);
886  }
887  
888  char *freq_to_str(uint64_t freq_hz)
889  {
890      static const char *const suffixes[] = { "", "K", "M", "G", "T", "P", "E" };
891      double freq = freq_hz;
892      size_t idx = 0;
893  
894      while (freq >= 1000.0 && idx < ARRAY_SIZE(suffixes)) {
895          freq /= 1000.0;
896          idx++;
897      }
898  
899      return g_strdup_printf("%0.3g %sHz", freq, suffixes[idx]);
900  }
901  
902  int qemu_pstrcmp0(const char **str1, const char **str2)
903  {
904      return g_strcmp0(*str1, *str2);
905  }
906  
907  static inline bool starts_with_prefix(const char *dir)
908  {
909      size_t prefix_len = strlen(CONFIG_PREFIX);
910      return !memcmp(dir, CONFIG_PREFIX, prefix_len) &&
911          (!dir[prefix_len] || G_IS_DIR_SEPARATOR(dir[prefix_len]));
912  }
913  
914  /* Return the next path component in dir, and store its length in *p_len.  */
915  static inline const char *next_component(const char *dir, int *p_len)
916  {
917      int len;
918      while (*dir && G_IS_DIR_SEPARATOR(*dir)) {
919          dir++;
920      }
921      len = 0;
922      while (dir[len] && !G_IS_DIR_SEPARATOR(dir[len])) {
923          len++;
924      }
925      *p_len = len;
926      return dir;
927  }
928  
929  char *get_relocated_path(const char *dir)
930  {
931      size_t prefix_len = strlen(CONFIG_PREFIX);
932      const char *bindir = CONFIG_BINDIR;
933      const char *exec_dir = qemu_get_exec_dir();
934      GString *result;
935      int len_dir, len_bindir;
936  
937      /* Fail if qemu_init_exec_dir was not called.  */
938      assert(exec_dir[0]);
939      if (!starts_with_prefix(dir) || !starts_with_prefix(bindir)) {
940          return g_strdup(dir);
941      }
942  
943      result = g_string_new(exec_dir);
944  
945      /* Advance over common components.  */
946      len_dir = len_bindir = prefix_len;
947      do {
948          dir += len_dir;
949          bindir += len_bindir;
950          dir = next_component(dir, &len_dir);
951          bindir = next_component(bindir, &len_bindir);
952      } while (len_dir && len_dir == len_bindir && !memcmp(dir, bindir, len_dir));
953  
954      /* Ascend from bindir to the common prefix with dir.  */
955      while (len_bindir) {
956          bindir += len_bindir;
957          g_string_append(result, "/..");
958          bindir = next_component(bindir, &len_bindir);
959      }
960  
961      if (*dir) {
962          assert(G_IS_DIR_SEPARATOR(dir[-1]));
963          g_string_append(result, dir - 1);
964      }
965      return result->str;
966  }
967