chiark / gitweb /
Prep v234: Apply missing upstream fixes in src/basic (1/6)
[elogind.git] / src / basic / parse-util.c
1 /***
2   This file is part of systemd.
3
4   Copyright 2010 Lennart Poettering
5
6   systemd is free software; you can redistribute it and/or modify it
7   under the terms of the GNU Lesser General Public License as published by
8   the Free Software Foundation; either version 2.1 of the License, or
9   (at your option) any later version.
10
11   systemd is distributed in the hope that it will be useful, but
12   WITHOUT ANY WARRANTY; without even the implied warranty of
13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14   Lesser General Public License for more details.
15
16   You should have received a copy of the GNU Lesser General Public License
17   along with systemd; If not, see <http://www.gnu.org/licenses/>.
18 ***/
19
20 #include <errno.h>
21 #include <inttypes.h>
22 #include <locale.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26
27 #include "alloc-util.h"
28 //#include "extract-word.h"
29 #include "macro.h"
30 #include "parse-util.h"
31 #include "string-util.h"
32
33 /// Additional includes needed by elogind
34 #include "musl_missing.h"
35
36 int parse_boolean(const char *v) {
37         assert(v);
38
39         if (streq(v, "1") || strcaseeq(v, "yes") || strcaseeq(v, "y") || strcaseeq(v, "true") || strcaseeq(v, "t") || strcaseeq(v, "on"))
40                 return 1;
41         else if (streq(v, "0") || strcaseeq(v, "no") || strcaseeq(v, "n") || strcaseeq(v, "false") || strcaseeq(v, "f") || strcaseeq(v, "off"))
42                 return 0;
43
44         return -EINVAL;
45 }
46
47 int parse_pid(const char *s, pid_t* ret_pid) {
48         unsigned long ul = 0;
49         pid_t pid;
50         int r;
51
52         assert(s);
53         assert(ret_pid);
54
55         r = safe_atolu(s, &ul);
56         if (r < 0)
57                 return r;
58
59         pid = (pid_t) ul;
60
61         if ((unsigned long) pid != ul)
62                 return -ERANGE;
63
64         if (pid <= 0)
65                 return -ERANGE;
66
67         *ret_pid = pid;
68         return 0;
69 }
70
71 int parse_mode(const char *s, mode_t *ret) {
72         char *x;
73         long l;
74
75         assert(s);
76         assert(ret);
77
78         s += strspn(s, WHITESPACE);
79         if (s[0] == '-')
80                 return -ERANGE;
81
82         errno = 0;
83         l = strtol(s, &x, 8);
84         if (errno > 0)
85                 return -errno;
86         if (!x || x == s || *x)
87                 return -EINVAL;
88         if (l < 0 || l  > 07777)
89                 return -ERANGE;
90
91         *ret = (mode_t) l;
92         return 0;
93 }
94
95 int parse_ifindex(const char *s, int *ret) {
96         int ifi, r;
97
98         r = safe_atoi(s, &ifi);
99         if (r < 0)
100                 return r;
101         if (ifi <= 0)
102                 return -EINVAL;
103
104         *ret = ifi;
105         return 0;
106 }
107
108 int parse_size(const char *t, uint64_t base, uint64_t *size) {
109
110         /* Soo, sometimes we want to parse IEC binary suffixes, and
111          * sometimes SI decimal suffixes. This function can parse
112          * both. Which one is the right way depends on the
113          * context. Wikipedia suggests that SI is customary for
114          * hardware metrics and network speeds, while IEC is
115          * customary for most data sizes used by software and volatile
116          * (RAM) memory. Hence be careful which one you pick!
117          *
118          * In either case we use just K, M, G as suffix, and not Ki,
119          * Mi, Gi or so (as IEC would suggest). That's because that's
120          * frickin' ugly. But this means you really need to make sure
121          * to document which base you are parsing when you use this
122          * call. */
123
124         struct table {
125                 const char *suffix;
126                 unsigned long long factor;
127         };
128
129         static const struct table iec[] = {
130                 { "E", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
131                 { "P", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
132                 { "T", 1024ULL*1024ULL*1024ULL*1024ULL },
133                 { "G", 1024ULL*1024ULL*1024ULL },
134                 { "M", 1024ULL*1024ULL },
135                 { "K", 1024ULL },
136                 { "B", 1ULL },
137                 { "",  1ULL },
138         };
139
140         static const struct table si[] = {
141                 { "E", 1000ULL*1000ULL*1000ULL*1000ULL*1000ULL*1000ULL },
142                 { "P", 1000ULL*1000ULL*1000ULL*1000ULL*1000ULL },
143                 { "T", 1000ULL*1000ULL*1000ULL*1000ULL },
144                 { "G", 1000ULL*1000ULL*1000ULL },
145                 { "M", 1000ULL*1000ULL },
146                 { "K", 1000ULL },
147                 { "B", 1ULL },
148                 { "",  1ULL },
149         };
150
151         const struct table *table;
152         const char *p;
153         unsigned long long r = 0;
154         unsigned n_entries, start_pos = 0;
155
156         assert(t);
157         assert(base == 1000 || base == 1024);
158         assert(size);
159
160         if (base == 1000) {
161                 table = si;
162                 n_entries = ELEMENTSOF(si);
163         } else {
164                 table = iec;
165                 n_entries = ELEMENTSOF(iec);
166         }
167
168         p = t;
169         do {
170                 unsigned long long l, tmp;
171                 double frac = 0;
172                 char *e;
173                 unsigned i;
174
175                 p += strspn(p, WHITESPACE);
176
177                 errno = 0;
178                 l = strtoull(p, &e, 10);
179                 if (errno > 0)
180                         return -errno;
181                 if (e == p)
182                         return -EINVAL;
183                 if (*p == '-')
184                         return -ERANGE;
185
186                 if (*e == '.') {
187                         e++;
188
189                         /* strtoull() itself would accept space/+/- */
190                         if (*e >= '0' && *e <= '9') {
191                                 unsigned long long l2;
192                                 char *e2;
193
194                                 l2 = strtoull(e, &e2, 10);
195                                 if (errno > 0)
196                                         return -errno;
197
198                                 /* Ignore failure. E.g. 10.M is valid */
199                                 frac = l2;
200                                 for (; e < e2; e++)
201                                         frac /= 10;
202                         }
203                 }
204
205                 e += strspn(e, WHITESPACE);
206
207                 for (i = start_pos; i < n_entries; i++)
208                         if (startswith(e, table[i].suffix))
209                                 break;
210
211                 if (i >= n_entries)
212                         return -EINVAL;
213
214                 if (l + (frac > 0) > ULLONG_MAX / table[i].factor)
215                         return -ERANGE;
216
217                 tmp = l * table[i].factor + (unsigned long long) (frac * table[i].factor);
218                 if (tmp > ULLONG_MAX - r)
219                         return -ERANGE;
220
221                 r += tmp;
222                 if ((unsigned long long) (uint64_t) r != r)
223                         return -ERANGE;
224
225                 p = e + strlen(table[i].suffix);
226
227                 start_pos = i + 1;
228
229         } while (*p);
230
231         *size = r;
232
233         return 0;
234 }
235
236 #if 0 /// UNNEEDED by elogind
237 int parse_range(const char *t, unsigned *lower, unsigned *upper) {
238         _cleanup_free_ char *word = NULL;
239         unsigned l, u;
240         int r;
241
242         assert(lower);
243         assert(upper);
244
245         /* Extract the lower bound. */
246         r = extract_first_word(&t, &word, "-", EXTRACT_DONT_COALESCE_SEPARATORS);
247         if (r < 0)
248                 return r;
249         if (r == 0)
250                 return -EINVAL;
251
252         r = safe_atou(word, &l);
253         if (r < 0)
254                 return r;
255
256         /* Check for the upper bound and extract it if needed */
257         if (!t)
258                 /* Single number with no dashes. */
259                 u = l;
260         else if (!*t)
261                 /* Trailing dash is an error. */
262                 return -EINVAL;
263         else {
264                 r = safe_atou(t, &u);
265                 if (r < 0)
266                         return r;
267         }
268
269         *lower = l;
270         *upper = u;
271         return 0;
272 }
273 #endif // 0
274
275 char *format_bytes(char *buf, size_t l, uint64_t t) {
276         unsigned i;
277
278         /* This only does IEC units so far */
279
280         static const struct {
281                 const char *suffix;
282                 uint64_t factor;
283         } table[] = {
284                 { "E", UINT64_C(1024)*UINT64_C(1024)*UINT64_C(1024)*UINT64_C(1024)*UINT64_C(1024)*UINT64_C(1024) },
285                 { "P", UINT64_C(1024)*UINT64_C(1024)*UINT64_C(1024)*UINT64_C(1024)*UINT64_C(1024) },
286                 { "T", UINT64_C(1024)*UINT64_C(1024)*UINT64_C(1024)*UINT64_C(1024) },
287                 { "G", UINT64_C(1024)*UINT64_C(1024)*UINT64_C(1024) },
288                 { "M", UINT64_C(1024)*UINT64_C(1024) },
289                 { "K", UINT64_C(1024) },
290         };
291
292         if (t == (uint64_t) -1)
293                 return NULL;
294
295         for (i = 0; i < ELEMENTSOF(table); i++) {
296
297                 if (t >= table[i].factor) {
298                         snprintf(buf, l,
299                                  "%" PRIu64 ".%" PRIu64 "%s",
300                                  t / table[i].factor,
301                                  ((t*UINT64_C(10)) / table[i].factor) % UINT64_C(10),
302                                  table[i].suffix);
303
304                         goto finish;
305                 }
306         }
307
308         snprintf(buf, l, "%" PRIu64 "B", t);
309
310 finish:
311         buf[l-1] = 0;
312         return buf;
313
314 }
315
316 int safe_atou(const char *s, unsigned *ret_u) {
317         char *x = NULL;
318         unsigned long l;
319
320         assert(s);
321         assert(ret_u);
322
323         /* strtoul() is happy to parse negative values, and silently
324          * converts them to unsigned values without generating an
325          * error. We want a clean error, hence let's look for the "-"
326          * prefix on our own, and generate an error. But let's do so
327          * only after strtoul() validated that the string is clean
328          * otherwise, so that we return EINVAL preferably over
329          * ERANGE. */
330
331         s += strspn(s, WHITESPACE);
332
333         errno = 0;
334         l = strtoul(s, &x, 0);
335         if (errno > 0)
336                 return -errno;
337         if (!x || x == s || *x)
338                 return -EINVAL;
339         if (s[0] == '-')
340                 return -ERANGE;
341         if ((unsigned long) (unsigned) l != l)
342                 return -ERANGE;
343
344         *ret_u = (unsigned) l;
345         return 0;
346 }
347
348 int safe_atoi(const char *s, int *ret_i) {
349         char *x = NULL;
350         long l;
351
352         assert(s);
353         assert(ret_i);
354
355         errno = 0;
356         l = strtol(s, &x, 0);
357         if (errno > 0)
358                 return -errno;
359         if (!x || x == s || *x)
360                 return -EINVAL;
361         if ((long) (int) l != l)
362                 return -ERANGE;
363
364         *ret_i = (int) l;
365         return 0;
366 }
367
368 int safe_atollu(const char *s, long long unsigned *ret_llu) {
369         char *x = NULL;
370         unsigned long long l;
371
372         assert(s);
373         assert(ret_llu);
374
375         s += strspn(s, WHITESPACE);
376
377         errno = 0;
378         l = strtoull(s, &x, 0);
379         if (errno > 0)
380                 return -errno;
381         if (!x || x == s || *x)
382                 return -EINVAL;
383         if (*s == '-')
384                 return -ERANGE;
385
386         *ret_llu = l;
387         return 0;
388 }
389
390 int safe_atolli(const char *s, long long int *ret_lli) {
391         char *x = NULL;
392         long long l;
393
394         assert(s);
395         assert(ret_lli);
396
397         errno = 0;
398         l = strtoll(s, &x, 0);
399         if (errno > 0)
400                 return -errno;
401         if (!x || x == s || *x)
402                 return -EINVAL;
403
404         *ret_lli = l;
405         return 0;
406 }
407
408 int safe_atou8(const char *s, uint8_t *ret) {
409         char *x = NULL;
410         unsigned long l;
411
412         assert(s);
413         assert(ret);
414
415         s += strspn(s, WHITESPACE);
416
417         errno = 0;
418         l = strtoul(s, &x, 0);
419         if (errno > 0)
420                 return -errno;
421         if (!x || x == s || *x)
422                 return -EINVAL;
423         if (s[0] == '-')
424                 return -ERANGE;
425         if ((unsigned long) (uint8_t) l != l)
426                 return -ERANGE;
427
428         *ret = (uint8_t) l;
429         return 0;
430 }
431
432 int safe_atou16(const char *s, uint16_t *ret) {
433         char *x = NULL;
434         unsigned long l;
435
436         assert(s);
437         assert(ret);
438
439         s += strspn(s, WHITESPACE);
440
441         errno = 0;
442         l = strtoul(s, &x, 0);
443         if (errno > 0)
444                 return -errno;
445         if (!x || x == s || *x)
446                 return -EINVAL;
447         if (s[0] == '-')
448                 return -ERANGE;
449         if ((unsigned long) (uint16_t) l != l)
450                 return -ERANGE;
451
452         *ret = (uint16_t) l;
453         return 0;
454 }
455
456 int safe_atoi16(const char *s, int16_t *ret) {
457         char *x = NULL;
458         long l;
459
460         assert(s);
461         assert(ret);
462
463         errno = 0;
464         l = strtol(s, &x, 0);
465         if (errno > 0)
466                 return -errno;
467         if (!x || x == s || *x)
468                 return -EINVAL;
469         if ((long) (int16_t) l != l)
470                 return -ERANGE;
471
472         *ret = (int16_t) l;
473         return 0;
474 }
475
476 int safe_atod(const char *s, double *ret_d) {
477         char *x = NULL;
478         double d = 0;
479         locale_t loc;
480
481         assert(s);
482         assert(ret_d);
483
484         loc = newlocale(LC_NUMERIC_MASK, "C", (locale_t) 0);
485         if (loc == (locale_t) 0)
486                 return -errno;
487
488         errno = 0;
489         d = strtod_l(s, &x, loc);
490         if (errno > 0) {
491                 freelocale(loc);
492                 return -errno;
493         }
494         if (!x || x == s || *x) {
495                 freelocale(loc);
496                 return -EINVAL;
497         }
498
499         freelocale(loc);
500         *ret_d = (double) d;
501         return 0;
502 }
503
504 int parse_fractional_part_u(const char **p, size_t digits, unsigned *res) {
505         size_t i;
506         unsigned val = 0;
507         const char *s;
508
509         s = *p;
510
511         /* accept any number of digits, strtoull is limted to 19 */
512         for (i=0; i < digits; i++,s++) {
513                 if (*s < '0' || *s > '9') {
514                         if (i == 0)
515                                 return -EINVAL;
516
517                         /* too few digits, pad with 0 */
518                         for (; i < digits; i++)
519                                 val *= 10;
520
521                         break;
522                 }
523
524                 val *= 10;
525                 val += *s - '0';
526         }
527
528         /* maybe round up */
529         if (*s >= '5' && *s <= '9')
530                 val++;
531
532         s += strspn(s, DIGITS);
533
534         *p = s;
535         *res = val;
536
537         return 0;
538 }
539
540 int parse_percent_unbounded(const char *p) {
541         const char *pc, *n;
542         unsigned v;
543         int r;
544
545         pc = endswith(p, "%");
546         if (!pc)
547                 return -EINVAL;
548
549         n = strndupa(p, pc - p);
550         r = safe_atou(n, &v);
551         if (r < 0)
552                 return r;
553
554         return (int) v;
555 }
556
557 int parse_percent(const char *p) {
558         int v;
559
560         v = parse_percent_unbounded(p);
561         if (v > 100)
562                 return -ERANGE;
563
564         return v;
565 }
566
567 #if 0 /// UNNEEDED by elogind
568 int parse_nice(const char *p, int *ret) {
569         int n, r;
570
571         r = safe_atoi(p, &n);
572         if (r < 0)
573                 return r;
574
575         if (!nice_is_valid(n))
576                 return -ERANGE;
577
578         *ret = n;
579         return 0;
580 }
581
582 int parse_ip_port(const char *s, uint16_t *ret) {
583         uint16_t l;
584         int r;
585
586         r = safe_atou16(s, &l);
587         if (r < 0)
588                 return r;
589
590         if (l == 0)
591                 return -EINVAL;
592
593         *ret = (uint16_t) l;
594
595         return 0;
596 }
597 #endif // 0
598
599 int parse_dev(const char *s, dev_t *ret) {
600         unsigned x, y;
601         dev_t d;
602
603         if (sscanf(s, "%u:%u", &x, &y) != 2)
604                 return -EINVAL;
605
606         d = makedev(x, y);
607         if ((unsigned) major(d) != x || (unsigned) minor(d) != y)
608                 return -EINVAL;
609
610         *ret = d;
611         return 0;
612 }