1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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
37void 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
44void 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
62char *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
71int 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
87int 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
104int 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
116char *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
137time_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
153
154
155
156
157
158int qemu_fdatasync(int fd)
159{
160#ifdef CONFIG_FDATASYNC
161 return fdatasync(fd);
162#else
163 return fsync(fd);
164#endif
165}
166
167#ifndef _WIN32
168
169int fcntl_setfl(int fd, int flag)
170{
171 int flags;
172
173 flags = fcntl(fd, F_GETFL);
174 if (flags == -1)
175 return -errno;
176
177 if (fcntl(fd, F_SETFL, flags | flag) == -1)
178 return -errno;
179
180 return 0;
181}
182#endif
183
184static int64_t suffix_mul(char suffix, int64_t unit)
185{
186 switch (qemu_toupper(suffix)) {
187 case 'B':
188 return 1;
189 case 'K':
190 return unit;
191 case 'M':
192 return unit * unit;
193 case 'G':
194 return unit * unit * unit;
195 case 'T':
196 return unit * unit * unit * unit;
197 case 'P':
198 return unit * unit * unit * unit * unit;
199 case 'E':
200 return unit * unit * unit * unit * unit * unit;
201 }
202 return -1;
203}
204
205
206
207
208
209
210
211static int do_strtosz(const char *nptr, const char **end,
212 const char default_suffix, int64_t unit,
213 uint64_t *result)
214{
215 int retval;
216 const char *endptr;
217 unsigned char c;
218 int mul_required = 0;
219 double val, mul, integral, fraction;
220
221 retval = qemu_strtod_finite(nptr, &endptr, &val);
222 if (retval) {
223 goto out;
224 }
225 fraction = modf(val, &integral);
226 if (fraction != 0) {
227 mul_required = 1;
228 }
229 c = *endptr;
230 mul = suffix_mul(c, unit);
231 if (mul >= 0) {
232 endptr++;
233 } else {
234 mul = suffix_mul(default_suffix, unit);
235 assert(mul >= 0);
236 }
237 if (mul == 1 && mul_required) {
238 retval = -EINVAL;
239 goto out;
240 }
241
242
243
244
245
246
247 if ((val * mul > nextafter(0x1p64, 0)) || val < 0) {
248 retval = -ERANGE;
249 goto out;
250 }
251 *result = val * mul;
252 retval = 0;
253
254out:
255 if (end) {
256 *end = endptr;
257 } else if (*endptr) {
258 retval = -EINVAL;
259 }
260
261 return retval;
262}
263
264int qemu_strtosz(const char *nptr, const char **end, uint64_t *result)
265{
266 return do_strtosz(nptr, end, 'B', 1024, result);
267}
268
269int qemu_strtosz_MiB(const char *nptr, const char **end, uint64_t *result)
270{
271 return do_strtosz(nptr, end, 'M', 1024, result);
272}
273
274int qemu_strtosz_metric(const char *nptr, const char **end, uint64_t *result)
275{
276 return do_strtosz(nptr, end, 'B', 1000, result);
277}
278
279
280
281
282static int check_strtox_error(const char *nptr, char *ep,
283 const char **endptr, int libc_errno)
284{
285 assert(ep >= nptr);
286 if (endptr) {
287 *endptr = ep;
288 }
289
290
291 if (libc_errno == 0 && ep == nptr) {
292 return -EINVAL;
293 }
294
295
296 if (!endptr && *ep) {
297 return -EINVAL;
298 }
299
300 return -libc_errno;
301}
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327int qemu_strtoi(const char *nptr, const char **endptr, int base,
328 int *result)
329{
330 char *ep;
331 long long lresult;
332
333 assert((unsigned) base <= 36 && base != 1);
334 if (!nptr) {
335 if (endptr) {
336 *endptr = nptr;
337 }
338 return -EINVAL;
339 }
340
341 errno = 0;
342 lresult = strtoll(nptr, &ep, base);
343 if (lresult < INT_MIN) {
344 *result = INT_MIN;
345 errno = ERANGE;
346 } else if (lresult > INT_MAX) {
347 *result = INT_MAX;
348 errno = ERANGE;
349 } else {
350 *result = lresult;
351 }
352 return check_strtox_error(nptr, ep, endptr, errno);
353}
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380int qemu_strtoui(const char *nptr, const char **endptr, int base,
381 unsigned int *result)
382{
383 char *ep;
384 long long lresult;
385
386 assert((unsigned) base <= 36 && base != 1);
387 if (!nptr) {
388 if (endptr) {
389 *endptr = nptr;
390 }
391 return -EINVAL;
392 }
393
394 errno = 0;
395 lresult = strtoull(nptr, &ep, base);
396
397
398 if (errno == ERANGE) {
399 *result = -1;
400 } else {
401 if (lresult > UINT_MAX) {
402 *result = UINT_MAX;
403 errno = ERANGE;
404 } else if (lresult < INT_MIN) {
405 *result = UINT_MAX;
406 errno = ERANGE;
407 } else {
408 *result = lresult;
409 }
410 }
411 return check_strtox_error(nptr, ep, endptr, errno);
412}
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438int qemu_strtol(const char *nptr, const char **endptr, int base,
439 long *result)
440{
441 char *ep;
442
443 assert((unsigned) base <= 36 && base != 1);
444 if (!nptr) {
445 if (endptr) {
446 *endptr = nptr;
447 }
448 return -EINVAL;
449 }
450
451 errno = 0;
452 *result = strtol(nptr, &ep, base);
453 return check_strtox_error(nptr, ep, endptr, errno);
454}
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481int qemu_strtoul(const char *nptr, const char **endptr, int base,
482 unsigned long *result)
483{
484 char *ep;
485
486 assert((unsigned) base <= 36 && base != 1);
487 if (!nptr) {
488 if (endptr) {
489 *endptr = nptr;
490 }
491 return -EINVAL;
492 }
493
494 errno = 0;
495 *result = strtoul(nptr, &ep, base);
496
497 if (errno == ERANGE) {
498 *result = -1;
499 }
500 return check_strtox_error(nptr, ep, endptr, errno);
501}
502
503
504
505
506
507
508
509int qemu_strtoi64(const char *nptr, const char **endptr, int base,
510 int64_t *result)
511{
512 char *ep;
513
514 assert((unsigned) base <= 36 && base != 1);
515 if (!nptr) {
516 if (endptr) {
517 *endptr = nptr;
518 }
519 return -EINVAL;
520 }
521
522 errno = 0;
523
524 *result = strtoll(nptr, &ep, base);
525 return check_strtox_error(nptr, ep, endptr, errno);
526}
527
528
529
530
531
532
533int qemu_strtou64(const char *nptr, const char **endptr, int base,
534 uint64_t *result)
535{
536 char *ep;
537
538 assert((unsigned) base <= 36 && base != 1);
539 if (!nptr) {
540 if (endptr) {
541 *endptr = nptr;
542 }
543 return -EINVAL;
544 }
545
546 errno = 0;
547
548 *result = strtoull(nptr, &ep, base);
549
550 if (errno == ERANGE) {
551 *result = -1;
552 }
553 return check_strtox_error(nptr, ep, endptr, errno);
554}
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580int qemu_strtod(const char *nptr, const char **endptr, double *result)
581{
582 char *ep;
583
584 if (!nptr) {
585 if (endptr) {
586 *endptr = nptr;
587 }
588 return -EINVAL;
589 }
590
591 errno = 0;
592 *result = strtod(nptr, &ep);
593 return check_strtox_error(nptr, ep, endptr, errno);
594}
595
596
597
598
599
600
601
602int qemu_strtod_finite(const char *nptr, const char **endptr, double *result)
603{
604 double tmp;
605 int ret;
606
607 ret = qemu_strtod(nptr, endptr, &tmp);
608 if (!ret && !isfinite(tmp)) {
609 if (endptr) {
610 *endptr = nptr;
611 }
612 ret = -EINVAL;
613 }
614
615 if (ret != -EINVAL) {
616 *result = tmp;
617 }
618 return ret;
619}
620
621
622
623
624
625#ifndef HAVE_STRCHRNUL
626const char *qemu_strchrnul(const char *s, int c)
627{
628 const char *e = strchr(s, c);
629 if (!e) {
630 e = s + strlen(s);
631 }
632 return e;
633}
634#endif
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664int parse_uint(const char *s, unsigned long long *value, char **endptr,
665 int base)
666{
667 int r = 0;
668 char *endp = (char *)s;
669 unsigned long long val = 0;
670
671 assert((unsigned) base <= 36 && base != 1);
672 if (!s) {
673 r = -EINVAL;
674 goto out;
675 }
676
677 errno = 0;
678 val = strtoull(s, &endp, base);
679 if (errno) {
680 r = -errno;
681 goto out;
682 }
683
684 if (endp == s) {
685 r = -EINVAL;
686 goto out;
687 }
688
689
690 while (qemu_isspace(*s)) {
691 s++;
692 }
693 if (*s == '-') {
694 val = 0;
695 r = -ERANGE;
696 goto out;
697 }
698
699out:
700 *value = val;
701 *endptr = endp;
702 return r;
703}
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719int parse_uint_full(const char *s, unsigned long long *value, int base)
720{
721 char *endp;
722 int r;
723
724 r = parse_uint(s, value, &endp, base);
725 if (r < 0) {
726 return r;
727 }
728 if (*endp) {
729 *value = 0;
730 return -EINVAL;
731 }
732
733 return 0;
734}
735
736int qemu_parse_fd(const char *param)
737{
738 long fd;
739 char *endptr;
740
741 errno = 0;
742 fd = strtol(param, &endptr, 10);
743 if (param == endptr ||
744 errno != 0 ||
745 *endptr != '\0' ||
746 fd < 0 ||
747 fd > INT_MAX ) {
748 return -1;
749 }
750 return fd;
751}
752
753
754
755
756
757int uleb128_encode_small(uint8_t *out, uint32_t n)
758{
759 g_assert(n <= 0x3fff);
760 if (n < 0x80) {
761 *out = n;
762 return 1;
763 } else {
764 *out++ = (n & 0x7f) | 0x80;
765 *out = n >> 7;
766 return 2;
767 }
768}
769
770int uleb128_decode_small(const uint8_t *in, uint32_t *n)
771{
772 if (!(*in & 0x80)) {
773 *n = *in;
774 return 1;
775 } else {
776 *n = *in++ & 0x7f;
777
778 if (*in & 0x80) {
779 return -1;
780 }
781 *n |= *in << 7;
782 return 2;
783 }
784}
785
786
787
788
789int parse_debug_env(const char *name, int max, int initial)
790{
791 char *debug_env = getenv(name);
792 char *inv = NULL;
793 long debug;
794
795 if (!debug_env) {
796 return initial;
797 }
798 errno = 0;
799 debug = strtol(debug_env, &inv, 10);
800 if (inv == debug_env) {
801 return initial;
802 }
803 if (debug < 0 || debug > max || errno != 0) {
804 warn_report("%s not in [0, %d]", name, max);
805 return initial;
806 }
807 return debug;
808}
809
810
811
812
813const char *qemu_ether_ntoa(const MACAddr *mac)
814{
815 static char ret[18];
816
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]);
819
820 return ret;
821}
822
823
824
825
826
827
828
829char *size_to_str(uint64_t val)
830{
831 static const char *suffixes[] = { "", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei" };
832 uint64_t div;
833 int i;
834
835
836
837
838
839
840
841 frexp(val / (1000.0 / 1024.0), &i);
842 i = (i - 1) / 10;
843 div = 1ULL << (i * 10);
844
845 return g_strdup_printf("%0.3g %sB", (double)val / div, suffixes[i]);
846}
847
848int qemu_pstrcmp0(const char **str1, const char **str2)
849{
850 return g_strcmp0(*str1, *str2);
851}
852