2 * Simple C functions to supplement the C library
4 * Copyright (c) 2006 Fabrice Bellard
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:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
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
25 #include "qemu/osdep.h"
26 #include "qemu/host-utils.h"
29 #include "qemu-common.h"
30 #include "qemu/sockets.h"
33 #include "qemu/ctype.h"
34 #include "qemu/cutils.h"
35 #include "qemu/error-report.h"
37 void strpadcpy(char *buf
, int buf_size
, const char *str
, char pad
)
39 int len
= qemu_strnlen(str
, buf_size
);
40 memcpy(buf
, str
, len
);
41 memset(buf
+ len
, pad
, buf_size
- len
);
44 void pstrcpy(char *buf
, int buf_size
, const char *str
)
54 if (c
== 0 || q
>= buf
+ buf_size
- 1)
61 /* strcat and truncate. */
62 char *pstrcat(char *buf
, int buf_size
, const char *s
)
67 pstrcpy(buf
+ len
, buf_size
- len
, s
);
71 int strstart(const char *str
, const char *val
, const char **ptr
)
87 int stristart(const char *str
, const char *val
, const char **ptr
)
93 if (qemu_toupper(*p
) != qemu_toupper(*q
))
103 /* XXX: use host strnlen if available ? */
104 int qemu_strnlen(const char *s
, int max_len
)
108 for(i
= 0; i
< max_len
; i
++) {
116 char *qemu_strsep(char **input
, const char *delim
)
118 char *result
= *input
;
119 if (result
!= NULL
) {
122 for (p
= result
; *p
!= '\0'; p
++) {
123 if (strchr(delim
, *p
)) {
137 time_t mktimegm(struct tm
*tm
)
140 int y
= tm
->tm_year
+ 1900, m
= tm
->tm_mon
+ 1, d
= tm
->tm_mday
;
145 t
= 86400ULL * (d
+ (153 * m
- 457) / 5 + 365 * y
+ y
/ 4 - y
/ 100 +
147 t
+= 3600 * tm
->tm_hour
+ 60 * tm
->tm_min
+ tm
->tm_sec
;
152 * Make sure data goes on disk, but if possible do not bother to
153 * write out the inode just for timestamp updates.
155 * Unfortunately even in 2009 many operating systems do not support
156 * fdatasync and have to fall back to fsync.
158 int qemu_fdatasync(int fd
)
160 #ifdef CONFIG_FDATASYNC
161 return fdatasync(fd
);
168 /* Sets a specific flag */
169 int fcntl_setfl(int fd
, int flag
)
173 flags
= fcntl(fd
, F_GETFL
);
177 if (fcntl(fd
, F_SETFL
, flags
| flag
) == -1)
184 static int64_t suffix_mul(char suffix
, int64_t unit
)
186 switch (qemu_toupper(suffix
)) {
194 return unit
* unit
* unit
;
196 return unit
* unit
* unit
* unit
;
198 return unit
* unit
* unit
* unit
* unit
;
200 return unit
* unit
* unit
* unit
* unit
* unit
;
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
211 static int do_strtosz(const char *nptr
, const char **end
,
212 const char default_suffix
, int64_t unit
,
218 int mul_required
= 0;
219 double val
, mul
, integral
, fraction
;
221 retval
= qemu_strtod_finite(nptr
, &endptr
, &val
);
225 fraction
= modf(val
, &integral
);
230 mul
= suffix_mul(c
, unit
);
234 mul
= suffix_mul(default_suffix
, unit
);
237 if (mul
== 1 && mul_required
) {
242 * Values near UINT64_MAX overflow to 2**64 when converting to double
243 * precision. Compare against the maximum representable double precision
244 * value below 2**64, computed as "the next value after 2**64 (0x1p64) in
245 * the direction of 0".
247 if ((val
* mul
> nextafter(0x1p
64, 0)) || val
< 0) {
257 } else if (*endptr
) {
264 int qemu_strtosz(const char *nptr
, const char **end
, uint64_t *result
)
266 return do_strtosz(nptr
, end
, 'B', 1024, result
);
269 int qemu_strtosz_MiB(const char *nptr
, const char **end
, uint64_t *result
)
271 return do_strtosz(nptr
, end
, 'M', 1024, result
);
274 int qemu_strtosz_metric(const char *nptr
, const char **end
, uint64_t *result
)
276 return do_strtosz(nptr
, end
, 'B', 1000, result
);
280 * Helper function for error checking after strtol() and the like
282 static int check_strtox_error(const char *nptr
, char *ep
,
283 const char **endptr
, int libc_errno
)
290 /* Turn "no conversion" into an error */
291 if (libc_errno
== 0 && ep
== nptr
) {
295 /* Fail when we're expected to consume the string, but didn't */
296 if (!endptr
&& *ep
) {
304 * Convert string @nptr to an integer, and store it in @result.
306 * This is a wrapper around strtol() that is harder to misuse.
307 * Semantics of @nptr, @endptr, @base match strtol() with differences
310 * @nptr may be null, and no conversion is performed then.
312 * If no conversion is performed, store @nptr in *@endptr and return
315 * If @endptr is null, and the string isn't fully converted, return
316 * -EINVAL. This is the case when the pointer that would be stored in
317 * a non-null @endptr points to a character other than '\0'.
319 * If the conversion overflows @result, store INT_MAX in @result,
320 * and return -ERANGE.
322 * If the conversion underflows @result, store INT_MIN in @result,
323 * and return -ERANGE.
325 * Else store the converted value in @result, and return zero.
327 int qemu_strtoi(const char *nptr
, const char **endptr
, int base
,
333 assert((unsigned) base
<= 36 && base
!= 1);
342 lresult
= strtoll(nptr
, &ep
, base
);
343 if (lresult
< INT_MIN
) {
346 } else if (lresult
> INT_MAX
) {
352 return check_strtox_error(nptr
, ep
, endptr
, errno
);
356 * Convert string @nptr to an unsigned integer, and store it in @result.
358 * This is a wrapper around strtoul() that is harder to misuse.
359 * Semantics of @nptr, @endptr, @base match strtoul() with differences
362 * @nptr may be null, and no conversion is performed then.
364 * If no conversion is performed, store @nptr in *@endptr and return
367 * If @endptr is null, and the string isn't fully converted, return
368 * -EINVAL. This is the case when the pointer that would be stored in
369 * a non-null @endptr points to a character other than '\0'.
371 * If the conversion overflows @result, store UINT_MAX in @result,
372 * and return -ERANGE.
374 * Else store the converted value in @result, and return zero.
376 * Note that a number with a leading minus sign gets converted without
377 * the minus sign, checked for overflow (see above), then negated (in
378 * @result's type). This is exactly how strtoul() works.
380 int qemu_strtoui(const char *nptr
, const char **endptr
, int base
,
381 unsigned int *result
)
386 assert((unsigned) base
<= 36 && base
!= 1);
395 lresult
= strtoull(nptr
, &ep
, base
);
397 /* Windows returns 1 for negative out-of-range values. */
398 if (errno
== ERANGE
) {
401 if (lresult
> UINT_MAX
) {
404 } else if (lresult
< INT_MIN
) {
411 return check_strtox_error(nptr
, ep
, endptr
, errno
);
415 * Convert string @nptr to a long integer, and store it in @result.
417 * This is a wrapper around strtol() that is harder to misuse.
418 * Semantics of @nptr, @endptr, @base match strtol() with differences
421 * @nptr may be null, and no conversion is performed then.
423 * If no conversion is performed, store @nptr in *@endptr and return
426 * If @endptr is null, and the string isn't fully converted, return
427 * -EINVAL. This is the case when the pointer that would be stored in
428 * a non-null @endptr points to a character other than '\0'.
430 * If the conversion overflows @result, store LONG_MAX in @result,
431 * and return -ERANGE.
433 * If the conversion underflows @result, store LONG_MIN in @result,
434 * and return -ERANGE.
436 * Else store the converted value in @result, and return zero.
438 int qemu_strtol(const char *nptr
, const char **endptr
, int base
,
443 assert((unsigned) base
<= 36 && base
!= 1);
452 *result
= strtol(nptr
, &ep
, base
);
453 return check_strtox_error(nptr
, ep
, endptr
, errno
);
457 * Convert string @nptr to an unsigned long, and store it in @result.
459 * This is a wrapper around strtoul() that is harder to misuse.
460 * Semantics of @nptr, @endptr, @base match strtoul() with differences
463 * @nptr may be null, and no conversion is performed then.
465 * If no conversion is performed, store @nptr in *@endptr and return
468 * If @endptr is null, and the string isn't fully converted, return
469 * -EINVAL. This is the case when the pointer that would be stored in
470 * a non-null @endptr points to a character other than '\0'.
472 * If the conversion overflows @result, store ULONG_MAX in @result,
473 * and return -ERANGE.
475 * Else store the converted value in @result, and return zero.
477 * Note that a number with a leading minus sign gets converted without
478 * the minus sign, checked for overflow (see above), then negated (in
479 * @result's type). This is exactly how strtoul() works.
481 int qemu_strtoul(const char *nptr
, const char **endptr
, int base
,
482 unsigned long *result
)
486 assert((unsigned) base
<= 36 && base
!= 1);
495 *result
= strtoul(nptr
, &ep
, base
);
496 /* Windows returns 1 for negative out-of-range values. */
497 if (errno
== ERANGE
) {
500 return check_strtox_error(nptr
, ep
, endptr
, errno
);
504 * Convert string @nptr to an int64_t.
506 * Works like qemu_strtol(), except it stores INT64_MAX on overflow,
507 * and INT_MIN on underflow.
509 int qemu_strtoi64(const char *nptr
, const char **endptr
, int base
,
514 assert((unsigned) base
<= 36 && base
!= 1);
523 /* FIXME This assumes int64_t is long long */
524 *result
= strtoll(nptr
, &ep
, base
);
525 return check_strtox_error(nptr
, ep
, endptr
, errno
);
529 * Convert string @nptr to an uint64_t.
531 * Works like qemu_strtoul(), except it stores UINT64_MAX on overflow.
533 int qemu_strtou64(const char *nptr
, const char **endptr
, int base
,
538 assert((unsigned) base
<= 36 && base
!= 1);
547 /* FIXME This assumes uint64_t is unsigned long long */
548 *result
= strtoull(nptr
, &ep
, base
);
549 /* Windows returns 1 for negative out-of-range values. */
550 if (errno
== ERANGE
) {
553 return check_strtox_error(nptr
, ep
, endptr
, errno
);
557 * Convert string @nptr to a double.
559 * This is a wrapper around strtod() that is harder to misuse.
560 * Semantics of @nptr and @endptr match strtod() with differences
563 * @nptr may be null, and no conversion is performed then.
565 * If no conversion is performed, store @nptr in *@endptr and return
568 * If @endptr is null, and the string isn't fully converted, return
569 * -EINVAL. This is the case when the pointer that would be stored in
570 * a non-null @endptr points to a character other than '\0'.
572 * If the conversion overflows, store +/-HUGE_VAL in @result, depending
573 * on the sign, and return -ERANGE.
575 * If the conversion underflows, store +/-0.0 in @result, depending on the
576 * sign, and return -ERANGE.
578 * Else store the converted value in @result, and return zero.
580 int qemu_strtod(const char *nptr
, const char **endptr
, double *result
)
592 *result
= strtod(nptr
, &ep
);
593 return check_strtox_error(nptr
, ep
, endptr
, errno
);
597 * Convert string @nptr to a finite double.
599 * Works like qemu_strtod(), except that "NaN" and "inf" are rejected
600 * with -EINVAL and no conversion is performed.
602 int qemu_strtod_finite(const char *nptr
, const char **endptr
, double *result
)
607 ret
= qemu_strtod(nptr
, endptr
, &tmp
);
608 if (!ret
&& !isfinite(tmp
)) {
615 if (ret
!= -EINVAL
) {
622 * Searches for the first occurrence of 'c' in 's', and returns a pointer
623 * to the trailing null byte if none was found.
625 #ifndef HAVE_STRCHRNUL
626 const char *qemu_strchrnul(const char *s
, int c
)
628 const char *e
= strchr(s
, c
);
639 * @s: String to parse
640 * @value: Destination for parsed integer value
641 * @endptr: Destination for pointer to first character not consumed
642 * @base: integer base, between 2 and 36 inclusive, or 0
644 * Parse unsigned integer
646 * Parsed syntax is like strtoull()'s: arbitrary whitespace, a single optional
647 * '+' or '-', an optional "0x" if @base is 0 or 16, one or more digits.
649 * If @s is null, or @base is invalid, or @s doesn't start with an
650 * integer in the syntax above, set *@value to 0, *@endptr to @s, and
653 * Set *@endptr to point right beyond the parsed integer (even if the integer
654 * overflows or is negative, all digits will be parsed and *@endptr will
655 * point right beyond them).
657 * If the integer is negative, set *@value to 0, and return -ERANGE.
659 * If the integer overflows unsigned long long, set *@value to
660 * ULLONG_MAX, and return -ERANGE.
662 * Else, set *@value to the parsed integer, and return 0.
664 int parse_uint(const char *s
, unsigned long long *value
, char **endptr
,
668 char *endp
= (char *)s
;
669 unsigned long long val
= 0;
671 assert((unsigned) base
<= 36 && base
!= 1);
678 val
= strtoull(s
, &endp
, base
);
689 /* make sure we reject negative numbers: */
690 while (qemu_isspace(*s
)) {
708 * @s: String to parse
709 * @value: Destination for parsed integer value
710 * @base: integer base, between 2 and 36 inclusive, or 0
712 * Parse unsigned integer from entire string
714 * Have the same behavior of parse_uint(), but with an additional check
715 * for additional data after the parsed number. If extra characters are present
716 * after the parsed number, the function will return -EINVAL, and *@v will
719 int parse_uint_full(const char *s
, unsigned long long *value
, int base
)
724 r
= parse_uint(s
, value
, &endp
, base
);
736 int qemu_parse_fd(const char *param
)
742 fd
= strtol(param
, &endptr
, 10);
743 if (param
== endptr
/* no conversion performed */ ||
744 errno
!= 0 /* not representable as long; possibly others */ ||
745 *endptr
!= '\0' /* final string not empty */ ||
746 fd
< 0 /* invalid as file descriptor */ ||
747 fd
> INT_MAX
/* not representable as int */) {
754 * Implementation of ULEB128 (http://en.wikipedia.org/wiki/LEB128)
755 * Input is limited to 14-bit numbers
757 int uleb128_encode_small(uint8_t *out
, uint32_t n
)
759 g_assert(n
<= 0x3fff);
764 *out
++ = (n
& 0x7f) | 0x80;
770 int uleb128_decode_small(const uint8_t *in
, uint32_t *n
)
777 /* we exceed 14 bit number */
787 * helper to parse debug environment variables
789 int parse_debug_env(const char *name
, int max
, int initial
)
791 char *debug_env
= getenv(name
);
799 debug
= strtol(debug_env
, &inv
, 10);
800 if (inv
== debug_env
) {
803 if (debug
< 0 || debug
> max
|| errno
!= 0) {
804 warn_report("%s not in [0, %d]", name
, max
);
811 * Helper to print ethernet mac address
813 const char *qemu_ether_ntoa(const MACAddr
*mac
)
817 snprintf(ret
, sizeof(ret
), "%02x:%02x:%02x:%02x:%02x:%02x",
818 mac
->a
[0], mac
->a
[1], mac
->a
[2], mac
->a
[3], mac
->a
[4], mac
->a
[5]);
824 * Return human readable string for size @val.
825 * @val can be anything that uint64_t allows (no more than "16 EiB").
826 * Use IEC binary units like KiB, MiB, and so forth.
827 * Caller is responsible for passing it to g_free().
829 char *size_to_str(uint64_t val
)
831 static const char *suffixes
[] = { "", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei" };
836 * The exponent (returned in i) minus one gives us
837 * floor(log2(val * 1024 / 1000). The correction makes us
838 * switch to the higher power when the integer part is >= 1000.
839 * (see e41b509d68afb1f for more info)
841 frexp(val
/ (1000.0 / 1024.0), &i
);
843 div
= 1ULL << (i
* 10);
845 return g_strdup_printf("%0.3g %sB", (double)val
/ div
, suffixes
[i
]);
848 int qemu_pstrcmp0(const char **str1
, const char **str2
)
850 return g_strcmp0(*str1
, *str2
);