nbd: Don't use *_to_cpup() functions
[qemu.git] / util / cutils.c
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 #include "qemu/osdep.h"
25 #include "qemu-common.h"
26 #include "qemu/host-utils.h"
27 #include <math.h>
28
29 #include "qemu/sockets.h"
30 #include "qemu/iov.h"
31 #include "net/net.h"
32 #include "qemu/cutils.h"
33
34 void strpadcpy(char *buf, int buf_size, const char *str, char pad)
35 {
36 int len = qemu_strnlen(str, buf_size);
37 memcpy(buf, str, len);
38 memset(buf + len, pad, buf_size - len);
39 }
40
41 void pstrcpy(char *buf, int buf_size, const char *str)
42 {
43 int c;
44 char *q = buf;
45
46 if (buf_size <= 0)
47 return;
48
49 for(;;) {
50 c = *str++;
51 if (c == 0 || q >= buf + buf_size - 1)
52 break;
53 *q++ = c;
54 }
55 *q = '\0';
56 }
57
58 /* strcat and truncate. */
59 char *pstrcat(char *buf, int buf_size, const char *s)
60 {
61 int len;
62 len = strlen(buf);
63 if (len < buf_size)
64 pstrcpy(buf + len, buf_size - len, s);
65 return buf;
66 }
67
68 int strstart(const char *str, const char *val, const char **ptr)
69 {
70 const char *p, *q;
71 p = str;
72 q = val;
73 while (*q != '\0') {
74 if (*p != *q)
75 return 0;
76 p++;
77 q++;
78 }
79 if (ptr)
80 *ptr = p;
81 return 1;
82 }
83
84 int stristart(const char *str, const char *val, const char **ptr)
85 {
86 const char *p, *q;
87 p = str;
88 q = val;
89 while (*q != '\0') {
90 if (qemu_toupper(*p) != qemu_toupper(*q))
91 return 0;
92 p++;
93 q++;
94 }
95 if (ptr)
96 *ptr = p;
97 return 1;
98 }
99
100 /* XXX: use host strnlen if available ? */
101 int qemu_strnlen(const char *s, int max_len)
102 {
103 int i;
104
105 for(i = 0; i < max_len; i++) {
106 if (s[i] == '\0') {
107 break;
108 }
109 }
110 return i;
111 }
112
113 char *qemu_strsep(char **input, const char *delim)
114 {
115 char *result = *input;
116 if (result != NULL) {
117 char *p;
118
119 for (p = result; *p != '\0'; p++) {
120 if (strchr(delim, *p)) {
121 break;
122 }
123 }
124 if (*p == '\0') {
125 *input = NULL;
126 } else {
127 *p = '\0';
128 *input = p + 1;
129 }
130 }
131 return result;
132 }
133
134 time_t mktimegm(struct tm *tm)
135 {
136 time_t t;
137 int y = tm->tm_year + 1900, m = tm->tm_mon + 1, d = tm->tm_mday;
138 if (m < 3) {
139 m += 12;
140 y--;
141 }
142 t = 86400ULL * (d + (153 * m - 457) / 5 + 365 * y + y / 4 - y / 100 +
143 y / 400 - 719469);
144 t += 3600 * tm->tm_hour + 60 * tm->tm_min + tm->tm_sec;
145 return t;
146 }
147
148 /*
149 * Make sure data goes on disk, but if possible do not bother to
150 * write out the inode just for timestamp updates.
151 *
152 * Unfortunately even in 2009 many operating systems do not support
153 * fdatasync and have to fall back to fsync.
154 */
155 int qemu_fdatasync(int fd)
156 {
157 #ifdef CONFIG_FDATASYNC
158 return fdatasync(fd);
159 #else
160 return fsync(fd);
161 #endif
162 }
163
164 /* vector definitions */
165 #ifdef __ALTIVEC__
166 #include <altivec.h>
167 /* The altivec.h header says we're allowed to undef these for
168 * C++ compatibility. Here we don't care about C++, but we
169 * undef them anyway to avoid namespace pollution.
170 */
171 #undef vector
172 #undef pixel
173 #undef bool
174 #define VECTYPE __vector unsigned char
175 #define SPLAT(p) vec_splat(vec_ld(0, p), 0)
176 #define ALL_EQ(v1, v2) vec_all_eq(v1, v2)
177 #define VEC_OR(v1, v2) ((v1) | (v2))
178 /* altivec.h may redefine the bool macro as vector type.
179 * Reset it to POSIX semantics. */
180 #define bool _Bool
181 #elif defined __SSE2__
182 #include <emmintrin.h>
183 #define VECTYPE __m128i
184 #define SPLAT(p) _mm_set1_epi8(*(p))
185 #define ALL_EQ(v1, v2) (_mm_movemask_epi8(_mm_cmpeq_epi8(v1, v2)) == 0xFFFF)
186 #define VEC_OR(v1, v2) (_mm_or_si128(v1, v2))
187 #else
188 #define VECTYPE unsigned long
189 #define SPLAT(p) (*(p) * (~0UL / 255))
190 #define ALL_EQ(v1, v2) ((v1) == (v2))
191 #define VEC_OR(v1, v2) ((v1) | (v2))
192 #endif
193
194 #define BUFFER_FIND_NONZERO_OFFSET_UNROLL_FACTOR 8
195
196 static bool
197 can_use_buffer_find_nonzero_offset_inner(const void *buf, size_t len)
198 {
199 return (len % (BUFFER_FIND_NONZERO_OFFSET_UNROLL_FACTOR
200 * sizeof(VECTYPE)) == 0
201 && ((uintptr_t) buf) % sizeof(VECTYPE) == 0);
202 }
203
204 /*
205 * Searches for an area with non-zero content in a buffer
206 *
207 * Attention! The len must be a multiple of
208 * BUFFER_FIND_NONZERO_OFFSET_UNROLL_FACTOR * sizeof(VECTYPE)
209 * and addr must be a multiple of sizeof(VECTYPE) due to
210 * restriction of optimizations in this function.
211 *
212 * can_use_buffer_find_nonzero_offset_inner() can be used to
213 * check these requirements.
214 *
215 * The return value is the offset of the non-zero area rounded
216 * down to a multiple of sizeof(VECTYPE) for the first
217 * BUFFER_FIND_NONZERO_OFFSET_UNROLL_FACTOR chunks and down to
218 * BUFFER_FIND_NONZERO_OFFSET_UNROLL_FACTOR * sizeof(VECTYPE)
219 * afterwards.
220 *
221 * If the buffer is all zero the return value is equal to len.
222 */
223
224 static size_t buffer_find_nonzero_offset_inner(const void *buf, size_t len)
225 {
226 const VECTYPE *p = buf;
227 const VECTYPE zero = (VECTYPE){0};
228 size_t i;
229
230 assert(can_use_buffer_find_nonzero_offset_inner(buf, len));
231
232 if (!len) {
233 return 0;
234 }
235
236 for (i = 0; i < BUFFER_FIND_NONZERO_OFFSET_UNROLL_FACTOR; i++) {
237 if (!ALL_EQ(p[i], zero)) {
238 return i * sizeof(VECTYPE);
239 }
240 }
241
242 for (i = BUFFER_FIND_NONZERO_OFFSET_UNROLL_FACTOR;
243 i < len / sizeof(VECTYPE);
244 i += BUFFER_FIND_NONZERO_OFFSET_UNROLL_FACTOR) {
245 VECTYPE tmp0 = VEC_OR(p[i + 0], p[i + 1]);
246 VECTYPE tmp1 = VEC_OR(p[i + 2], p[i + 3]);
247 VECTYPE tmp2 = VEC_OR(p[i + 4], p[i + 5]);
248 VECTYPE tmp3 = VEC_OR(p[i + 6], p[i + 7]);
249 VECTYPE tmp01 = VEC_OR(tmp0, tmp1);
250 VECTYPE tmp23 = VEC_OR(tmp2, tmp3);
251 if (!ALL_EQ(VEC_OR(tmp01, tmp23), zero)) {
252 break;
253 }
254 }
255
256 return i * sizeof(VECTYPE);
257 }
258
259 #if defined CONFIG_AVX2_OPT
260 #pragma GCC push_options
261 #pragma GCC target("avx2")
262 #include <cpuid.h>
263 #include <immintrin.h>
264
265 #define AVX2_VECTYPE __m256i
266 #define AVX2_SPLAT(p) _mm256_set1_epi8(*(p))
267 #define AVX2_ALL_EQ(v1, v2) \
268 (_mm256_movemask_epi8(_mm256_cmpeq_epi8(v1, v2)) == 0xFFFFFFFF)
269 #define AVX2_VEC_OR(v1, v2) (_mm256_or_si256(v1, v2))
270
271 static bool
272 can_use_buffer_find_nonzero_offset_avx2(const void *buf, size_t len)
273 {
274 return (len % (BUFFER_FIND_NONZERO_OFFSET_UNROLL_FACTOR
275 * sizeof(AVX2_VECTYPE)) == 0
276 && ((uintptr_t) buf) % sizeof(AVX2_VECTYPE) == 0);
277 }
278
279 static size_t buffer_find_nonzero_offset_avx2(const void *buf, size_t len)
280 {
281 const AVX2_VECTYPE *p = buf;
282 const AVX2_VECTYPE zero = (AVX2_VECTYPE){0};
283 size_t i;
284
285 assert(can_use_buffer_find_nonzero_offset_avx2(buf, len));
286
287 if (!len) {
288 return 0;
289 }
290
291 for (i = 0; i < BUFFER_FIND_NONZERO_OFFSET_UNROLL_FACTOR; i++) {
292 if (!AVX2_ALL_EQ(p[i], zero)) {
293 return i * sizeof(AVX2_VECTYPE);
294 }
295 }
296
297 for (i = BUFFER_FIND_NONZERO_OFFSET_UNROLL_FACTOR;
298 i < len / sizeof(AVX2_VECTYPE);
299 i += BUFFER_FIND_NONZERO_OFFSET_UNROLL_FACTOR) {
300 AVX2_VECTYPE tmp0 = AVX2_VEC_OR(p[i + 0], p[i + 1]);
301 AVX2_VECTYPE tmp1 = AVX2_VEC_OR(p[i + 2], p[i + 3]);
302 AVX2_VECTYPE tmp2 = AVX2_VEC_OR(p[i + 4], p[i + 5]);
303 AVX2_VECTYPE tmp3 = AVX2_VEC_OR(p[i + 6], p[i + 7]);
304 AVX2_VECTYPE tmp01 = AVX2_VEC_OR(tmp0, tmp1);
305 AVX2_VECTYPE tmp23 = AVX2_VEC_OR(tmp2, tmp3);
306 if (!AVX2_ALL_EQ(AVX2_VEC_OR(tmp01, tmp23), zero)) {
307 break;
308 }
309 }
310
311 return i * sizeof(AVX2_VECTYPE);
312 }
313
314 static bool avx2_support(void)
315 {
316 int a, b, c, d;
317
318 if (__get_cpuid_max(0, NULL) < 7) {
319 return false;
320 }
321
322 __cpuid_count(7, 0, a, b, c, d);
323
324 return b & bit_AVX2;
325 }
326
327 bool can_use_buffer_find_nonzero_offset(const void *buf, size_t len) \
328 __attribute__ ((ifunc("can_use_buffer_find_nonzero_offset_ifunc")));
329 size_t buffer_find_nonzero_offset(const void *buf, size_t len) \
330 __attribute__ ((ifunc("buffer_find_nonzero_offset_ifunc")));
331
332 static void *buffer_find_nonzero_offset_ifunc(void)
333 {
334 typeof(buffer_find_nonzero_offset) *func = (avx2_support()) ?
335 buffer_find_nonzero_offset_avx2 : buffer_find_nonzero_offset_inner;
336
337 return func;
338 }
339
340 static void *can_use_buffer_find_nonzero_offset_ifunc(void)
341 {
342 typeof(can_use_buffer_find_nonzero_offset) *func = (avx2_support()) ?
343 can_use_buffer_find_nonzero_offset_avx2 :
344 can_use_buffer_find_nonzero_offset_inner;
345
346 return func;
347 }
348 #pragma GCC pop_options
349 #else
350 bool can_use_buffer_find_nonzero_offset(const void *buf, size_t len)
351 {
352 return can_use_buffer_find_nonzero_offset_inner(buf, len);
353 }
354
355 size_t buffer_find_nonzero_offset(const void *buf, size_t len)
356 {
357 return buffer_find_nonzero_offset_inner(buf, len);
358 }
359 #endif
360
361 /*
362 * Checks if a buffer is all zeroes
363 *
364 * Attention! The len must be a multiple of 4 * sizeof(long) due to
365 * restriction of optimizations in this function.
366 */
367 bool buffer_is_zero(const void *buf, size_t len)
368 {
369 /*
370 * Use long as the biggest available internal data type that fits into the
371 * CPU register and unroll the loop to smooth out the effect of memory
372 * latency.
373 */
374
375 size_t i;
376 long d0, d1, d2, d3;
377 const long * const data = buf;
378
379 /* use vector optimized zero check if possible */
380 if (can_use_buffer_find_nonzero_offset(buf, len)) {
381 return buffer_find_nonzero_offset(buf, len) == len;
382 }
383
384 assert(len % (4 * sizeof(long)) == 0);
385 len /= sizeof(long);
386
387 for (i = 0; i < len; i += 4) {
388 d0 = data[i + 0];
389 d1 = data[i + 1];
390 d2 = data[i + 2];
391 d3 = data[i + 3];
392
393 if (d0 || d1 || d2 || d3) {
394 return false;
395 }
396 }
397
398 return true;
399 }
400
401 #ifndef _WIN32
402 /* Sets a specific flag */
403 int fcntl_setfl(int fd, int flag)
404 {
405 int flags;
406
407 flags = fcntl(fd, F_GETFL);
408 if (flags == -1)
409 return -errno;
410
411 if (fcntl(fd, F_SETFL, flags | flag) == -1)
412 return -errno;
413
414 return 0;
415 }
416 #endif
417
418 static int64_t suffix_mul(char suffix, int64_t unit)
419 {
420 switch (qemu_toupper(suffix)) {
421 case QEMU_STRTOSZ_DEFSUFFIX_B:
422 return 1;
423 case QEMU_STRTOSZ_DEFSUFFIX_KB:
424 return unit;
425 case QEMU_STRTOSZ_DEFSUFFIX_MB:
426 return unit * unit;
427 case QEMU_STRTOSZ_DEFSUFFIX_GB:
428 return unit * unit * unit;
429 case QEMU_STRTOSZ_DEFSUFFIX_TB:
430 return unit * unit * unit * unit;
431 case QEMU_STRTOSZ_DEFSUFFIX_PB:
432 return unit * unit * unit * unit * unit;
433 case QEMU_STRTOSZ_DEFSUFFIX_EB:
434 return unit * unit * unit * unit * unit * unit;
435 }
436 return -1;
437 }
438
439 /*
440 * Convert string to bytes, allowing either B/b for bytes, K/k for KB,
441 * M/m for MB, G/g for GB or T/t for TB. End pointer will be returned
442 * in *end, if not NULL. Return -ERANGE on overflow, Return -EINVAL on
443 * other error.
444 */
445 int64_t qemu_strtosz_suffix_unit(const char *nptr, char **end,
446 const char default_suffix, int64_t unit)
447 {
448 int64_t retval = -EINVAL;
449 char *endptr;
450 unsigned char c;
451 int mul_required = 0;
452 double val, mul, integral, fraction;
453
454 errno = 0;
455 val = strtod(nptr, &endptr);
456 if (isnan(val) || endptr == nptr || errno != 0) {
457 goto fail;
458 }
459 fraction = modf(val, &integral);
460 if (fraction != 0) {
461 mul_required = 1;
462 }
463 c = *endptr;
464 mul = suffix_mul(c, unit);
465 if (mul >= 0) {
466 endptr++;
467 } else {
468 mul = suffix_mul(default_suffix, unit);
469 assert(mul >= 0);
470 }
471 if (mul == 1 && mul_required) {
472 goto fail;
473 }
474 if ((val * mul >= INT64_MAX) || val < 0) {
475 retval = -ERANGE;
476 goto fail;
477 }
478 retval = val * mul;
479
480 fail:
481 if (end) {
482 *end = endptr;
483 }
484
485 return retval;
486 }
487
488 int64_t qemu_strtosz_suffix(const char *nptr, char **end,
489 const char default_suffix)
490 {
491 return qemu_strtosz_suffix_unit(nptr, end, default_suffix, 1024);
492 }
493
494 int64_t qemu_strtosz(const char *nptr, char **end)
495 {
496 return qemu_strtosz_suffix(nptr, end, QEMU_STRTOSZ_DEFSUFFIX_MB);
497 }
498
499 /**
500 * Helper function for qemu_strto*l() functions.
501 */
502 static int check_strtox_error(const char *p, char *endptr, const char **next,
503 int err)
504 {
505 /* If no conversion was performed, prefer BSD behavior over glibc
506 * behavior.
507 */
508 if (err == 0 && endptr == p) {
509 err = EINVAL;
510 }
511 if (!next && *endptr) {
512 return -EINVAL;
513 }
514 if (next) {
515 *next = endptr;
516 }
517 return -err;
518 }
519
520 /**
521 * QEMU wrappers for strtol(), strtoll(), strtoul(), strotull() C functions.
522 *
523 * Convert ASCII string @nptr to a long integer value
524 * from the given @base. Parameters @nptr, @endptr, @base
525 * follows same semantics as strtol() C function.
526 *
527 * Unlike from strtol() function, if @endptr is not NULL, this
528 * function will return -EINVAL whenever it cannot fully convert
529 * the string in @nptr with given @base to a long. This function returns
530 * the result of the conversion only through the @result parameter.
531 *
532 * If NULL is passed in @endptr, then the whole string in @ntpr
533 * is a number otherwise it returns -EINVAL.
534 *
535 * RETURN VALUE
536 * Unlike from strtol() function, this wrapper returns either
537 * -EINVAL or the errno set by strtol() function (e.g -ERANGE).
538 * If the conversion overflows, -ERANGE is returned, and @result
539 * is set to the max value of the desired type
540 * (e.g. LONG_MAX, LLONG_MAX, ULONG_MAX, ULLONG_MAX). If the case
541 * of underflow, -ERANGE is returned, and @result is set to the min
542 * value of the desired type. For strtol(), strtoll(), @result is set to
543 * LONG_MIN, LLONG_MIN, respectively, and for strtoul(), strtoull() it
544 * is set to 0.
545 */
546 int qemu_strtol(const char *nptr, const char **endptr, int base,
547 long *result)
548 {
549 char *p;
550 int err = 0;
551 if (!nptr) {
552 if (endptr) {
553 *endptr = nptr;
554 }
555 err = -EINVAL;
556 } else {
557 errno = 0;
558 *result = strtol(nptr, &p, base);
559 err = check_strtox_error(nptr, p, endptr, errno);
560 }
561 return err;
562 }
563
564 /**
565 * Converts ASCII string to an unsigned long integer.
566 *
567 * If string contains a negative number, value will be converted to
568 * the unsigned representation of the signed value, unless the original
569 * (nonnegated) value would overflow, in this case, it will set @result
570 * to ULONG_MAX, and return ERANGE.
571 *
572 * The same behavior holds, for qemu_strtoull() but sets @result to
573 * ULLONG_MAX instead of ULONG_MAX.
574 *
575 * See qemu_strtol() documentation for more info.
576 */
577 int qemu_strtoul(const char *nptr, const char **endptr, int base,
578 unsigned long *result)
579 {
580 char *p;
581 int err = 0;
582 if (!nptr) {
583 if (endptr) {
584 *endptr = nptr;
585 }
586 err = -EINVAL;
587 } else {
588 errno = 0;
589 *result = strtoul(nptr, &p, base);
590 /* Windows returns 1 for negative out-of-range values. */
591 if (errno == ERANGE) {
592 *result = -1;
593 }
594 err = check_strtox_error(nptr, p, endptr, errno);
595 }
596 return err;
597 }
598
599 /**
600 * Converts ASCII string to a long long integer.
601 *
602 * See qemu_strtol() documentation for more info.
603 */
604 int qemu_strtoll(const char *nptr, const char **endptr, int base,
605 int64_t *result)
606 {
607 char *p;
608 int err = 0;
609 if (!nptr) {
610 if (endptr) {
611 *endptr = nptr;
612 }
613 err = -EINVAL;
614 } else {
615 errno = 0;
616 *result = strtoll(nptr, &p, base);
617 err = check_strtox_error(nptr, p, endptr, errno);
618 }
619 return err;
620 }
621
622 /**
623 * Converts ASCII string to an unsigned long long integer.
624 *
625 * See qemu_strtol() documentation for more info.
626 */
627 int qemu_strtoull(const char *nptr, const char **endptr, int base,
628 uint64_t *result)
629 {
630 char *p;
631 int err = 0;
632 if (!nptr) {
633 if (endptr) {
634 *endptr = nptr;
635 }
636 err = -EINVAL;
637 } else {
638 errno = 0;
639 *result = strtoull(nptr, &p, base);
640 /* Windows returns 1 for negative out-of-range values. */
641 if (errno == ERANGE) {
642 *result = -1;
643 }
644 err = check_strtox_error(nptr, p, endptr, errno);
645 }
646 return err;
647 }
648
649 /**
650 * parse_uint:
651 *
652 * @s: String to parse
653 * @value: Destination for parsed integer value
654 * @endptr: Destination for pointer to first character not consumed
655 * @base: integer base, between 2 and 36 inclusive, or 0
656 *
657 * Parse unsigned integer
658 *
659 * Parsed syntax is like strtoull()'s: arbitrary whitespace, a single optional
660 * '+' or '-', an optional "0x" if @base is 0 or 16, one or more digits.
661 *
662 * If @s is null, or @base is invalid, or @s doesn't start with an
663 * integer in the syntax above, set *@value to 0, *@endptr to @s, and
664 * return -EINVAL.
665 *
666 * Set *@endptr to point right beyond the parsed integer (even if the integer
667 * overflows or is negative, all digits will be parsed and *@endptr will
668 * point right beyond them).
669 *
670 * If the integer is negative, set *@value to 0, and return -ERANGE.
671 *
672 * If the integer overflows unsigned long long, set *@value to
673 * ULLONG_MAX, and return -ERANGE.
674 *
675 * Else, set *@value to the parsed integer, and return 0.
676 */
677 int parse_uint(const char *s, unsigned long long *value, char **endptr,
678 int base)
679 {
680 int r = 0;
681 char *endp = (char *)s;
682 unsigned long long val = 0;
683
684 if (!s) {
685 r = -EINVAL;
686 goto out;
687 }
688
689 errno = 0;
690 val = strtoull(s, &endp, base);
691 if (errno) {
692 r = -errno;
693 goto out;
694 }
695
696 if (endp == s) {
697 r = -EINVAL;
698 goto out;
699 }
700
701 /* make sure we reject negative numbers: */
702 while (isspace((unsigned char)*s)) {
703 s++;
704 }
705 if (*s == '-') {
706 val = 0;
707 r = -ERANGE;
708 goto out;
709 }
710
711 out:
712 *value = val;
713 *endptr = endp;
714 return r;
715 }
716
717 /**
718 * parse_uint_full:
719 *
720 * @s: String to parse
721 * @value: Destination for parsed integer value
722 * @base: integer base, between 2 and 36 inclusive, or 0
723 *
724 * Parse unsigned integer from entire string
725 *
726 * Have the same behavior of parse_uint(), but with an additional check
727 * for additional data after the parsed number. If extra characters are present
728 * after the parsed number, the function will return -EINVAL, and *@v will
729 * be set to 0.
730 */
731 int parse_uint_full(const char *s, unsigned long long *value, int base)
732 {
733 char *endp;
734 int r;
735
736 r = parse_uint(s, value, &endp, base);
737 if (r < 0) {
738 return r;
739 }
740 if (*endp) {
741 *value = 0;
742 return -EINVAL;
743 }
744
745 return 0;
746 }
747
748 int qemu_parse_fd(const char *param)
749 {
750 long fd;
751 char *endptr;
752
753 errno = 0;
754 fd = strtol(param, &endptr, 10);
755 if (param == endptr /* no conversion performed */ ||
756 errno != 0 /* not representable as long; possibly others */ ||
757 *endptr != '\0' /* final string not empty */ ||
758 fd < 0 /* invalid as file descriptor */ ||
759 fd > INT_MAX /* not representable as int */) {
760 return -1;
761 }
762 return fd;
763 }
764
765 /*
766 * Implementation of ULEB128 (http://en.wikipedia.org/wiki/LEB128)
767 * Input is limited to 14-bit numbers
768 */
769 int uleb128_encode_small(uint8_t *out, uint32_t n)
770 {
771 g_assert(n <= 0x3fff);
772 if (n < 0x80) {
773 *out++ = n;
774 return 1;
775 } else {
776 *out++ = (n & 0x7f) | 0x80;
777 *out++ = n >> 7;
778 return 2;
779 }
780 }
781
782 int uleb128_decode_small(const uint8_t *in, uint32_t *n)
783 {
784 if (!(*in & 0x80)) {
785 *n = *in++;
786 return 1;
787 } else {
788 *n = *in++ & 0x7f;
789 /* we exceed 14 bit number */
790 if (*in & 0x80) {
791 return -1;
792 }
793 *n |= *in++ << 7;
794 return 2;
795 }
796 }
797
798 /*
799 * helper to parse debug environment variables
800 */
801 int parse_debug_env(const char *name, int max, int initial)
802 {
803 char *debug_env = getenv(name);
804 char *inv = NULL;
805 long debug;
806
807 if (!debug_env) {
808 return initial;
809 }
810 errno = 0;
811 debug = strtol(debug_env, &inv, 10);
812 if (inv == debug_env) {
813 return initial;
814 }
815 if (debug < 0 || debug > max || errno != 0) {
816 fprintf(stderr, "warning: %s not in [0, %d]", name, max);
817 return initial;
818 }
819 return debug;
820 }
821
822 /*
823 * Helper to print ethernet mac address
824 */
825 const char *qemu_ether_ntoa(const MACAddr *mac)
826 {
827 static char ret[18];
828
829 snprintf(ret, sizeof(ret), "%02x:%02x:%02x:%02x:%02x:%02x",
830 mac->a[0], mac->a[1], mac->a[2], mac->a[3], mac->a[4], mac->a[5]);
831
832 return ret;
833 }