Line data Source code
1 : /* SPDX-License-Identifier: LGPL-2.1+ */
2 :
3 : #include <errno.h>
4 : #include <locale.h>
5 : #include <math.h>
6 : #include <sys/socket.h>
7 :
8 : #include "alloc-util.h"
9 : #include "errno-list.h"
10 : #include "log.h"
11 : #include "parse-util.h"
12 : #include "string-util.h"
13 :
14 1 : static void test_parse_boolean(void) {
15 1 : assert_se(parse_boolean("1") == 1);
16 1 : assert_se(parse_boolean("y") == 1);
17 1 : assert_se(parse_boolean("Y") == 1);
18 1 : assert_se(parse_boolean("yes") == 1);
19 1 : assert_se(parse_boolean("YES") == 1);
20 1 : assert_se(parse_boolean("true") == 1);
21 1 : assert_se(parse_boolean("TRUE") == 1);
22 1 : assert_se(parse_boolean("on") == 1);
23 1 : assert_se(parse_boolean("ON") == 1);
24 :
25 1 : assert_se(parse_boolean("0") == 0);
26 1 : assert_se(parse_boolean("n") == 0);
27 1 : assert_se(parse_boolean("N") == 0);
28 1 : assert_se(parse_boolean("no") == 0);
29 1 : assert_se(parse_boolean("NO") == 0);
30 1 : assert_se(parse_boolean("false") == 0);
31 1 : assert_se(parse_boolean("FALSE") == 0);
32 1 : assert_se(parse_boolean("off") == 0);
33 1 : assert_se(parse_boolean("OFF") == 0);
34 :
35 1 : assert_se(parse_boolean("garbage") < 0);
36 1 : assert_se(parse_boolean("") < 0);
37 1 : assert_se(parse_boolean("full") < 0);
38 1 : }
39 :
40 1 : static void test_parse_pid(void) {
41 : int r;
42 : pid_t pid;
43 :
44 1 : r = parse_pid("100", &pid);
45 1 : assert_se(r == 0);
46 1 : assert_se(pid == 100);
47 :
48 1 : r = parse_pid("0x7FFFFFFF", &pid);
49 1 : assert_se(r == 0);
50 1 : assert_se(pid == 2147483647);
51 :
52 1 : pid = 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
53 1 : r = parse_pid("0", &pid);
54 1 : assert_se(r == -ERANGE);
55 1 : assert_se(pid == 65);
56 :
57 1 : pid = 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
58 1 : r = parse_pid("-100", &pid);
59 1 : assert_se(r == -ERANGE);
60 1 : assert_se(pid == 65);
61 :
62 1 : pid = 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
63 1 : r = parse_pid("0xFFFFFFFFFFFFFFFFF", &pid);
64 1 : assert_se(r == -ERANGE);
65 1 : assert_se(pid == 65);
66 :
67 1 : r = parse_pid("junk", &pid);
68 1 : assert_se(r == -EINVAL);
69 :
70 1 : r = parse_pid("", &pid);
71 1 : assert_se(r == -EINVAL);
72 1 : }
73 :
74 1 : static void test_parse_mode(void) {
75 : mode_t m;
76 :
77 1 : assert_se(parse_mode("-1", &m) < 0);
78 1 : assert_se(parse_mode("", &m) < 0);
79 1 : assert_se(parse_mode("888", &m) < 0);
80 1 : assert_se(parse_mode("77777", &m) < 0);
81 :
82 1 : assert_se(parse_mode("544", &m) >= 0 && m == 0544);
83 1 : assert_se(parse_mode("777", &m) >= 0 && m == 0777);
84 1 : assert_se(parse_mode("7777", &m) >= 0 && m == 07777);
85 1 : assert_se(parse_mode("0", &m) >= 0 && m == 0);
86 1 : }
87 :
88 1 : static void test_parse_size(void) {
89 : uint64_t bytes;
90 :
91 1 : assert_se(parse_size("", 1024, &bytes) == -EINVAL);
92 :
93 1 : assert_se(parse_size("111", 1024, &bytes) == 0);
94 1 : assert_se(bytes == 111);
95 :
96 1 : assert_se(parse_size("111.4", 1024, &bytes) == 0);
97 1 : assert_se(bytes == 111);
98 :
99 1 : assert_se(parse_size(" 112 B", 1024, &bytes) == 0);
100 1 : assert_se(bytes == 112);
101 :
102 1 : assert_se(parse_size(" 112.6 B", 1024, &bytes) == 0);
103 1 : assert_se(bytes == 112);
104 :
105 1 : assert_se(parse_size("3.5 K", 1024, &bytes) == 0);
106 1 : assert_se(bytes == 3*1024 + 512);
107 :
108 1 : assert_se(parse_size("3. K", 1024, &bytes) == 0);
109 1 : assert_se(bytes == 3*1024);
110 :
111 1 : assert_se(parse_size("3.0 K", 1024, &bytes) == 0);
112 1 : assert_se(bytes == 3*1024);
113 :
114 1 : assert_se(parse_size("3. 0 K", 1024, &bytes) == -EINVAL);
115 :
116 1 : assert_se(parse_size(" 4 M 11.5K", 1024, &bytes) == 0);
117 1 : assert_se(bytes == 4*1024*1024 + 11 * 1024 + 512);
118 :
119 1 : assert_se(parse_size("3B3.5G", 1024, &bytes) == -EINVAL);
120 :
121 1 : assert_se(parse_size("3.5G3B", 1024, &bytes) == 0);
122 1 : assert_se(bytes == 3ULL*1024*1024*1024 + 512*1024*1024 + 3);
123 :
124 1 : assert_se(parse_size("3.5G 4B", 1024, &bytes) == 0);
125 1 : assert_se(bytes == 3ULL*1024*1024*1024 + 512*1024*1024 + 4);
126 :
127 1 : assert_se(parse_size("3B3G4T", 1024, &bytes) == -EINVAL);
128 :
129 1 : assert_se(parse_size("4T3G3B", 1024, &bytes) == 0);
130 1 : assert_se(bytes == (4ULL*1024 + 3)*1024*1024*1024 + 3);
131 :
132 1 : assert_se(parse_size(" 4 T 3 G 3 B", 1024, &bytes) == 0);
133 1 : assert_se(bytes == (4ULL*1024 + 3)*1024*1024*1024 + 3);
134 :
135 1 : assert_se(parse_size("12P", 1024, &bytes) == 0);
136 1 : assert_se(bytes == 12ULL * 1024*1024*1024*1024*1024);
137 :
138 1 : assert_se(parse_size("12P12P", 1024, &bytes) == -EINVAL);
139 :
140 1 : assert_se(parse_size("3E 2P", 1024, &bytes) == 0);
141 1 : assert_se(bytes == (3 * 1024 + 2ULL) * 1024*1024*1024*1024*1024);
142 :
143 1 : assert_se(parse_size("12X", 1024, &bytes) == -EINVAL);
144 :
145 1 : assert_se(parse_size("12.5X", 1024, &bytes) == -EINVAL);
146 :
147 1 : assert_se(parse_size("12.5e3", 1024, &bytes) == -EINVAL);
148 :
149 1 : assert_se(parse_size("1024E", 1024, &bytes) == -ERANGE);
150 1 : assert_se(parse_size("-1", 1024, &bytes) == -ERANGE);
151 1 : assert_se(parse_size("-1024E", 1024, &bytes) == -ERANGE);
152 :
153 1 : assert_se(parse_size("-1024P", 1024, &bytes) == -ERANGE);
154 :
155 1 : assert_se(parse_size("-10B 20K", 1024, &bytes) == -ERANGE);
156 1 : }
157 :
158 1 : static void test_parse_range(void) {
159 : unsigned lower, upper;
160 :
161 : /* Successful cases */
162 1 : assert_se(parse_range("111", &lower, &upper) == 0);
163 1 : assert_se(lower == 111);
164 1 : assert_se(upper == 111);
165 :
166 1 : assert_se(parse_range("111-123", &lower, &upper) == 0);
167 1 : assert_se(lower == 111);
168 1 : assert_se(upper == 123);
169 :
170 1 : assert_se(parse_range("123-111", &lower, &upper) == 0);
171 1 : assert_se(lower == 123);
172 1 : assert_se(upper == 111);
173 :
174 1 : assert_se(parse_range("123-123", &lower, &upper) == 0);
175 1 : assert_se(lower == 123);
176 1 : assert_se(upper == 123);
177 :
178 1 : assert_se(parse_range("0", &lower, &upper) == 0);
179 1 : assert_se(lower == 0);
180 1 : assert_se(upper == 0);
181 :
182 1 : assert_se(parse_range("0-15", &lower, &upper) == 0);
183 1 : assert_se(lower == 0);
184 1 : assert_se(upper == 15);
185 :
186 1 : assert_se(parse_range("15-0", &lower, &upper) == 0);
187 1 : assert_se(lower == 15);
188 1 : assert_se(upper == 0);
189 :
190 1 : assert_se(parse_range("128-65535", &lower, &upper) == 0);
191 1 : assert_se(lower == 128);
192 1 : assert_se(upper == 65535);
193 :
194 1 : assert_se(parse_range("1024-4294967295", &lower, &upper) == 0);
195 1 : assert_se(lower == 1024);
196 1 : assert_se(upper == 4294967295);
197 :
198 : /* Leading whitespace is acceptable */
199 1 : assert_se(parse_range(" 111", &lower, &upper) == 0);
200 1 : assert_se(lower == 111);
201 1 : assert_se(upper == 111);
202 :
203 1 : assert_se(parse_range(" 111-123", &lower, &upper) == 0);
204 1 : assert_se(lower == 111);
205 1 : assert_se(upper == 123);
206 :
207 1 : assert_se(parse_range("111- 123", &lower, &upper) == 0);
208 1 : assert_se(lower == 111);
209 1 : assert_se(upper == 123);
210 :
211 1 : assert_se(parse_range("\t111-\t123", &lower, &upper) == 0);
212 1 : assert_se(lower == 111);
213 1 : assert_se(upper == 123);
214 :
215 1 : assert_se(parse_range(" \t 111- \t 123", &lower, &upper) == 0);
216 1 : assert_se(lower == 111);
217 1 : assert_se(upper == 123);
218 :
219 : /* Error cases, make sure they fail as expected */
220 1 : lower = upper = 9999;
221 1 : assert_se(parse_range("111garbage", &lower, &upper) == -EINVAL);
222 1 : assert_se(lower == 9999);
223 1 : assert_se(upper == 9999);
224 :
225 1 : assert_se(parse_range("garbage111", &lower, &upper) == -EINVAL);
226 1 : assert_se(lower == 9999);
227 1 : assert_se(upper == 9999);
228 :
229 1 : assert_se(parse_range("garbage", &lower, &upper) == -EINVAL);
230 1 : assert_se(lower == 9999);
231 1 : assert_se(upper == 9999);
232 :
233 1 : assert_se(parse_range("111-123garbage", &lower, &upper) == -EINVAL);
234 1 : assert_se(lower == 9999);
235 1 : assert_se(upper == 9999);
236 :
237 1 : assert_se(parse_range("111garbage-123", &lower, &upper) == -EINVAL);
238 1 : assert_se(lower == 9999);
239 1 : assert_se(upper == 9999);
240 :
241 : /* Empty string */
242 1 : lower = upper = 9999;
243 1 : assert_se(parse_range("", &lower, &upper) == -EINVAL);
244 1 : assert_se(lower == 9999);
245 1 : assert_se(upper == 9999);
246 :
247 : /* 111--123 will pass -123 to safe_atou which returns -ERANGE for negative */
248 1 : assert_se(parse_range("111--123", &lower, &upper) == -ERANGE);
249 1 : assert_se(lower == 9999);
250 1 : assert_se(upper == 9999);
251 :
252 1 : assert_se(parse_range("-123", &lower, &upper) == -EINVAL);
253 1 : assert_se(lower == 9999);
254 1 : assert_se(upper == 9999);
255 :
256 1 : assert_se(parse_range("-111-123", &lower, &upper) == -EINVAL);
257 1 : assert_se(lower == 9999);
258 1 : assert_se(upper == 9999);
259 :
260 1 : assert_se(parse_range("111-123-", &lower, &upper) == -EINVAL);
261 1 : assert_se(lower == 9999);
262 1 : assert_se(upper == 9999);
263 :
264 1 : assert_se(parse_range("111.4-123", &lower, &upper) == -EINVAL);
265 1 : assert_se(lower == 9999);
266 1 : assert_se(upper == 9999);
267 :
268 1 : assert_se(parse_range("111-123.4", &lower, &upper) == -EINVAL);
269 1 : assert_se(lower == 9999);
270 1 : assert_se(upper == 9999);
271 :
272 1 : assert_se(parse_range("111,4-123", &lower, &upper) == -EINVAL);
273 1 : assert_se(lower == 9999);
274 1 : assert_se(upper == 9999);
275 :
276 1 : assert_se(parse_range("111-123,4", &lower, &upper) == -EINVAL);
277 1 : assert_se(lower == 9999);
278 1 : assert_se(upper == 9999);
279 :
280 : /* Error on trailing dash */
281 1 : assert_se(parse_range("111-", &lower, &upper) == -EINVAL);
282 1 : assert_se(lower == 9999);
283 1 : assert_se(upper == 9999);
284 :
285 1 : assert_se(parse_range("111-123-", &lower, &upper) == -EINVAL);
286 1 : assert_se(lower == 9999);
287 1 : assert_se(upper == 9999);
288 :
289 1 : assert_se(parse_range("111--", &lower, &upper) == -EINVAL);
290 1 : assert_se(lower == 9999);
291 1 : assert_se(upper == 9999);
292 :
293 1 : assert_se(parse_range("111- ", &lower, &upper) == -EINVAL);
294 1 : assert_se(lower == 9999);
295 1 : assert_se(upper == 9999);
296 :
297 : /* Whitespace is not a separator */
298 1 : assert_se(parse_range("111 123", &lower, &upper) == -EINVAL);
299 1 : assert_se(lower == 9999);
300 1 : assert_se(upper == 9999);
301 :
302 1 : assert_se(parse_range("111\t123", &lower, &upper) == -EINVAL);
303 1 : assert_se(lower == 9999);
304 1 : assert_se(upper == 9999);
305 :
306 1 : assert_se(parse_range("111 \t 123", &lower, &upper) == -EINVAL);
307 1 : assert_se(lower == 9999);
308 1 : assert_se(upper == 9999);
309 :
310 : /* Trailing whitespace is invalid (from safe_atou) */
311 1 : assert_se(parse_range("111 ", &lower, &upper) == -EINVAL);
312 1 : assert_se(lower == 9999);
313 1 : assert_se(upper == 9999);
314 :
315 1 : assert_se(parse_range("111-123 ", &lower, &upper) == -EINVAL);
316 1 : assert_se(lower == 9999);
317 1 : assert_se(upper == 9999);
318 :
319 1 : assert_se(parse_range("111 -123", &lower, &upper) == -EINVAL);
320 1 : assert_se(lower == 9999);
321 1 : assert_se(upper == 9999);
322 :
323 1 : assert_se(parse_range("111 -123 ", &lower, &upper) == -EINVAL);
324 1 : assert_se(lower == 9999);
325 1 : assert_se(upper == 9999);
326 :
327 1 : assert_se(parse_range("111\t-123\t", &lower, &upper) == -EINVAL);
328 1 : assert_se(lower == 9999);
329 1 : assert_se(upper == 9999);
330 :
331 1 : assert_se(parse_range("111 \t -123 \t ", &lower, &upper) == -EINVAL);
332 1 : assert_se(lower == 9999);
333 1 : assert_se(upper == 9999);
334 :
335 : /* Out of the "unsigned" range, this is 1<<64 */
336 1 : assert_se(parse_range("0-18446744073709551616", &lower, &upper) == -ERANGE);
337 1 : assert_se(lower == 9999);
338 1 : assert_se(upper == 9999);
339 1 : }
340 :
341 1 : static void test_safe_atolli(void) {
342 : int r;
343 : long long l;
344 :
345 1 : r = safe_atolli("12345", &l);
346 1 : assert_se(r == 0);
347 1 : assert_se(l == 12345);
348 :
349 1 : r = safe_atolli(" 12345", &l);
350 1 : assert_se(r == 0);
351 1 : assert_se(l == 12345);
352 :
353 1 : r = safe_atolli("-12345", &l);
354 1 : assert_se(r == 0);
355 1 : assert_se(l == -12345);
356 :
357 1 : r = safe_atolli(" -12345", &l);
358 1 : assert_se(r == 0);
359 1 : assert_se(l == -12345);
360 :
361 1 : r = safe_atolli("12345678901234567890", &l);
362 1 : assert_se(r == -ERANGE);
363 :
364 1 : r = safe_atolli("-12345678901234567890", &l);
365 1 : assert_se(r == -ERANGE);
366 :
367 1 : r = safe_atolli("junk", &l);
368 1 : assert_se(r == -EINVAL);
369 :
370 1 : r = safe_atolli("123x", &l);
371 1 : assert_se(r == -EINVAL);
372 :
373 1 : r = safe_atolli("12.3", &l);
374 1 : assert_se(r == -EINVAL);
375 :
376 1 : r = safe_atolli("", &l);
377 1 : assert_se(r == -EINVAL);
378 1 : }
379 :
380 1 : static void test_safe_atou16(void) {
381 : int r;
382 : uint16_t l;
383 :
384 1 : r = safe_atou16("12345", &l);
385 1 : assert_se(r == 0);
386 1 : assert_se(l == 12345);
387 :
388 1 : r = safe_atou16(" 12345", &l);
389 1 : assert_se(r == 0);
390 1 : assert_se(l == 12345);
391 :
392 1 : r = safe_atou16("123456", &l);
393 1 : assert_se(r == -ERANGE);
394 :
395 1 : r = safe_atou16("-1", &l);
396 1 : assert_se(r == -ERANGE);
397 :
398 1 : r = safe_atou16(" -1", &l);
399 1 : assert_se(r == -ERANGE);
400 :
401 1 : r = safe_atou16("junk", &l);
402 1 : assert_se(r == -EINVAL);
403 :
404 1 : r = safe_atou16("123x", &l);
405 1 : assert_se(r == -EINVAL);
406 :
407 1 : r = safe_atou16("12.3", &l);
408 1 : assert_se(r == -EINVAL);
409 :
410 1 : r = safe_atou16("", &l);
411 1 : assert_se(r == -EINVAL);
412 1 : }
413 :
414 1 : static void test_safe_atoi16(void) {
415 : int r;
416 : int16_t l;
417 :
418 1 : r = safe_atoi16("-12345", &l);
419 1 : assert_se(r == 0);
420 1 : assert_se(l == -12345);
421 :
422 1 : r = safe_atoi16(" -12345", &l);
423 1 : assert_se(r == 0);
424 1 : assert_se(l == -12345);
425 :
426 1 : r = safe_atoi16("32767", &l);
427 1 : assert_se(r == 0);
428 1 : assert_se(l == 32767);
429 :
430 1 : r = safe_atoi16(" 32767", &l);
431 1 : assert_se(r == 0);
432 1 : assert_se(l == 32767);
433 :
434 1 : r = safe_atoi16("36536", &l);
435 1 : assert_se(r == -ERANGE);
436 :
437 1 : r = safe_atoi16("-32769", &l);
438 1 : assert_se(r == -ERANGE);
439 :
440 1 : r = safe_atoi16("junk", &l);
441 1 : assert_se(r == -EINVAL);
442 :
443 1 : r = safe_atoi16("123x", &l);
444 1 : assert_se(r == -EINVAL);
445 :
446 1 : r = safe_atoi16("12.3", &l);
447 1 : assert_se(r == -EINVAL);
448 :
449 1 : r = safe_atoi16("", &l);
450 1 : assert_se(r == -EINVAL);
451 1 : }
452 :
453 1 : static void test_safe_atoux16(void) {
454 : int r;
455 : uint16_t l;
456 :
457 1 : r = safe_atoux16("1234", &l);
458 1 : assert_se(r == 0);
459 1 : assert_se(l == 0x1234);
460 :
461 1 : r = safe_atoux16("abcd", &l);
462 1 : assert_se(r == 0);
463 1 : assert_se(l == 0xabcd);
464 :
465 1 : r = safe_atoux16(" 1234", &l);
466 1 : assert_se(r == 0);
467 1 : assert_se(l == 0x1234);
468 :
469 1 : r = safe_atoux16("12345", &l);
470 1 : assert_se(r == -ERANGE);
471 :
472 1 : r = safe_atoux16("-1", &l);
473 1 : assert_se(r == -ERANGE);
474 :
475 1 : r = safe_atoux16(" -1", &l);
476 1 : assert_se(r == -ERANGE);
477 :
478 1 : r = safe_atoux16("junk", &l);
479 1 : assert_se(r == -EINVAL);
480 :
481 1 : r = safe_atoux16("123x", &l);
482 1 : assert_se(r == -EINVAL);
483 :
484 1 : r = safe_atoux16("12.3", &l);
485 1 : assert_se(r == -EINVAL);
486 :
487 1 : r = safe_atoux16("", &l);
488 1 : assert_se(r == -EINVAL);
489 1 : }
490 :
491 1 : static void test_safe_atou64(void) {
492 : int r;
493 : uint64_t l;
494 :
495 1 : r = safe_atou64("12345", &l);
496 1 : assert_se(r == 0);
497 1 : assert_se(l == 12345);
498 :
499 1 : r = safe_atou64(" 12345", &l);
500 1 : assert_se(r == 0);
501 1 : assert_se(l == 12345);
502 :
503 1 : r = safe_atou64("18446744073709551617", &l);
504 1 : assert_se(r == -ERANGE);
505 :
506 1 : r = safe_atou64("-1", &l);
507 1 : assert_se(r == -ERANGE);
508 :
509 1 : r = safe_atou64(" -1", &l);
510 1 : assert_se(r == -ERANGE);
511 :
512 1 : r = safe_atou64("junk", &l);
513 1 : assert_se(r == -EINVAL);
514 :
515 1 : r = safe_atou64("123x", &l);
516 1 : assert_se(r == -EINVAL);
517 :
518 1 : r = safe_atou64("12.3", &l);
519 1 : assert_se(r == -EINVAL);
520 :
521 1 : r = safe_atou64("", &l);
522 1 : assert_se(r == -EINVAL);
523 1 : }
524 :
525 1 : static void test_safe_atoi64(void) {
526 : int r;
527 : int64_t l;
528 :
529 1 : r = safe_atoi64("-12345", &l);
530 1 : assert_se(r == 0);
531 1 : assert_se(l == -12345);
532 :
533 1 : r = safe_atoi64(" -12345", &l);
534 1 : assert_se(r == 0);
535 1 : assert_se(l == -12345);
536 :
537 1 : r = safe_atoi64("32767", &l);
538 1 : assert_se(r == 0);
539 1 : assert_se(l == 32767);
540 :
541 1 : r = safe_atoi64(" 32767", &l);
542 1 : assert_se(r == 0);
543 1 : assert_se(l == 32767);
544 :
545 1 : r = safe_atoi64("9223372036854775813", &l);
546 1 : assert_se(r == -ERANGE);
547 :
548 1 : r = safe_atoi64("-9223372036854775813", &l);
549 1 : assert_se(r == -ERANGE);
550 :
551 1 : r = safe_atoi64("junk", &l);
552 1 : assert_se(r == -EINVAL);
553 :
554 1 : r = safe_atoi64("123x", &l);
555 1 : assert_se(r == -EINVAL);
556 :
557 1 : r = safe_atoi64("12.3", &l);
558 1 : assert_se(r == -EINVAL);
559 :
560 1 : r = safe_atoi64("", &l);
561 1 : assert_se(r == -EINVAL);
562 1 : }
563 :
564 1 : static void test_safe_atod(void) {
565 : int r;
566 : double d;
567 : char *e;
568 :
569 1 : r = safe_atod("junk", &d);
570 1 : assert_se(r == -EINVAL);
571 :
572 1 : r = safe_atod("0.2244", &d);
573 1 : assert_se(r == 0);
574 1 : assert_se(fabs(d - 0.2244) < 0.000001);
575 :
576 1 : r = safe_atod("0,5", &d);
577 1 : assert_se(r == -EINVAL);
578 :
579 1 : errno = 0;
580 1 : strtod("0,5", &e);
581 1 : assert_se(*e == ',');
582 :
583 1 : r = safe_atod("", &d);
584 1 : assert_se(r == -EINVAL);
585 :
586 : /* Check if this really is locale independent */
587 1 : if (setlocale(LC_NUMERIC, "de_DE.utf8")) {
588 :
589 1 : r = safe_atod("0.2244", &d);
590 1 : assert_se(r == 0);
591 1 : assert_se(fabs(d - 0.2244) < 0.000001);
592 :
593 1 : r = safe_atod("0,5", &d);
594 1 : assert_se(r == -EINVAL);
595 :
596 1 : errno = 0;
597 1 : assert_se(fabs(strtod("0,5", &e) - 0.5) < 0.00001);
598 :
599 1 : r = safe_atod("", &d);
600 1 : assert_se(r == -EINVAL);
601 : }
602 :
603 : /* And check again, reset */
604 1 : assert_se(setlocale(LC_NUMERIC, "C"));
605 :
606 1 : r = safe_atod("0.2244", &d);
607 1 : assert_se(r == 0);
608 1 : assert_se(fabs(d - 0.2244) < 0.000001);
609 :
610 1 : r = safe_atod("0,5", &d);
611 1 : assert_se(r == -EINVAL);
612 :
613 1 : errno = 0;
614 1 : strtod("0,5", &e);
615 1 : assert_se(*e == ',');
616 :
617 1 : r = safe_atod("", &d);
618 1 : assert_se(r == -EINVAL);
619 1 : }
620 :
621 1 : static void test_parse_percent(void) {
622 1 : assert_se(parse_percent("") == -EINVAL);
623 1 : assert_se(parse_percent("foo") == -EINVAL);
624 1 : assert_se(parse_percent("0") == -EINVAL);
625 1 : assert_se(parse_percent("50") == -EINVAL);
626 1 : assert_se(parse_percent("100") == -EINVAL);
627 1 : assert_se(parse_percent("-1") == -EINVAL);
628 1 : assert_se(parse_percent("0%") == 0);
629 1 : assert_se(parse_percent("55%") == 55);
630 1 : assert_se(parse_percent("100%") == 100);
631 1 : assert_se(parse_percent("-7%") == -ERANGE);
632 1 : assert_se(parse_percent("107%") == -ERANGE);
633 1 : assert_se(parse_percent("%") == -EINVAL);
634 1 : assert_se(parse_percent("%%") == -EINVAL);
635 1 : assert_se(parse_percent("%1") == -EINVAL);
636 1 : assert_se(parse_percent("1%%") == -EINVAL);
637 1 : assert_se(parse_percent("3.2%") == -EINVAL);
638 1 : }
639 :
640 1 : static void test_parse_percent_unbounded(void) {
641 1 : assert_se(parse_percent_unbounded("101%") == 101);
642 1 : assert_se(parse_percent_unbounded("400%") == 400);
643 1 : }
644 :
645 1 : static void test_parse_permille(void) {
646 1 : assert_se(parse_permille("") == -EINVAL);
647 1 : assert_se(parse_permille("foo") == -EINVAL);
648 1 : assert_se(parse_permille("0") == -EINVAL);
649 1 : assert_se(parse_permille("50") == -EINVAL);
650 1 : assert_se(parse_permille("100") == -EINVAL);
651 1 : assert_se(parse_permille("-1") == -EINVAL);
652 :
653 1 : assert_se(parse_permille("0‰") == 0);
654 1 : assert_se(parse_permille("555‰") == 555);
655 1 : assert_se(parse_permille("1000‰") == 1000);
656 1 : assert_se(parse_permille("-7‰") == -ERANGE);
657 1 : assert_se(parse_permille("1007‰") == -ERANGE);
658 1 : assert_se(parse_permille("‰") == -EINVAL);
659 1 : assert_se(parse_permille("‰‰") == -EINVAL);
660 1 : assert_se(parse_permille("‰1") == -EINVAL);
661 1 : assert_se(parse_permille("1‰‰") == -EINVAL);
662 1 : assert_se(parse_permille("3.2‰") == -EINVAL);
663 :
664 1 : assert_se(parse_permille("0%") == 0);
665 1 : assert_se(parse_permille("55%") == 550);
666 1 : assert_se(parse_permille("55.5%") == 555);
667 1 : assert_se(parse_permille("100%") == 1000);
668 1 : assert_se(parse_permille("-7%") == -ERANGE);
669 1 : assert_se(parse_permille("107%") == -ERANGE);
670 1 : assert_se(parse_permille("%") == -EINVAL);
671 1 : assert_se(parse_permille("%%") == -EINVAL);
672 1 : assert_se(parse_permille("%1") == -EINVAL);
673 1 : assert_se(parse_permille("1%%") == -EINVAL);
674 1 : assert_se(parse_permille("3.21%") == -EINVAL);
675 1 : }
676 :
677 1 : static void test_parse_permille_unbounded(void) {
678 1 : assert_se(parse_permille_unbounded("1001‰") == 1001);
679 1 : assert_se(parse_permille_unbounded("4000‰") == 4000);
680 1 : assert_se(parse_permille_unbounded("2147483647‰") == 2147483647);
681 1 : assert_se(parse_permille_unbounded("2147483648‰") == -ERANGE);
682 1 : assert_se(parse_permille_unbounded("4294967295‰") == -ERANGE);
683 1 : assert_se(parse_permille_unbounded("4294967296‰") == -ERANGE);
684 :
685 1 : assert_se(parse_permille_unbounded("101%") == 1010);
686 1 : assert_se(parse_permille_unbounded("400%") == 4000);
687 1 : assert_se(parse_permille_unbounded("214748364.7%") == 2147483647);
688 1 : assert_se(parse_permille_unbounded("214748364.8%") == -ERANGE);
689 1 : assert_se(parse_permille_unbounded("429496729.5%") == -ERANGE);
690 1 : assert_se(parse_permille_unbounded("429496729.6%") == -ERANGE);
691 1 : }
692 :
693 1 : static void test_parse_nice(void) {
694 : int n;
695 :
696 1 : assert_se(parse_nice("0", &n) >= 0 && n == 0);
697 1 : assert_se(parse_nice("+0", &n) >= 0 && n == 0);
698 1 : assert_se(parse_nice("-1", &n) >= 0 && n == -1);
699 1 : assert_se(parse_nice("-2", &n) >= 0 && n == -2);
700 1 : assert_se(parse_nice("1", &n) >= 0 && n == 1);
701 1 : assert_se(parse_nice("2", &n) >= 0 && n == 2);
702 1 : assert_se(parse_nice("+1", &n) >= 0 && n == 1);
703 1 : assert_se(parse_nice("+2", &n) >= 0 && n == 2);
704 1 : assert_se(parse_nice("-20", &n) >= 0 && n == -20);
705 1 : assert_se(parse_nice("19", &n) >= 0 && n == 19);
706 1 : assert_se(parse_nice("+19", &n) >= 0 && n == 19);
707 :
708 1 : assert_se(parse_nice("", &n) == -EINVAL);
709 1 : assert_se(parse_nice("-", &n) == -EINVAL);
710 1 : assert_se(parse_nice("+", &n) == -EINVAL);
711 1 : assert_se(parse_nice("xx", &n) == -EINVAL);
712 1 : assert_se(parse_nice("-50", &n) == -ERANGE);
713 1 : assert_se(parse_nice("50", &n) == -ERANGE);
714 1 : assert_se(parse_nice("+50", &n) == -ERANGE);
715 1 : assert_se(parse_nice("-21", &n) == -ERANGE);
716 1 : assert_se(parse_nice("20", &n) == -ERANGE);
717 1 : assert_se(parse_nice("+20", &n) == -ERANGE);
718 1 : }
719 :
720 1 : static void test_parse_dev(void) {
721 : dev_t dev;
722 :
723 1 : assert_se(parse_dev("", &dev) == -EINVAL);
724 1 : assert_se(parse_dev("junk", &dev) == -EINVAL);
725 1 : assert_se(parse_dev("0", &dev) == -EINVAL);
726 1 : assert_se(parse_dev("5", &dev) == -EINVAL);
727 1 : assert_se(parse_dev("5:", &dev) == -EINVAL);
728 1 : assert_se(parse_dev(":5", &dev) == -EINVAL);
729 1 : assert_se(parse_dev("-1:-1", &dev) == -EINVAL);
730 : #if SIZEOF_DEV_T < 8
731 : assert_se(parse_dev("4294967295:4294967295", &dev) == -EINVAL);
732 : #endif
733 1 : assert_se(parse_dev("8:11", &dev) >= 0 && major(dev) == 8 && minor(dev) == 11);
734 1 : assert_se(parse_dev("0:0", &dev) >= 0 && major(dev) == 0 && minor(dev) == 0);
735 1 : }
736 :
737 1 : static void test_parse_errno(void) {
738 1 : assert_se(parse_errno("EILSEQ") == EILSEQ);
739 1 : assert_se(parse_errno("EINVAL") == EINVAL);
740 1 : assert_se(parse_errno("0") == 0);
741 1 : assert_se(parse_errno("1") == 1);
742 1 : assert_se(parse_errno("4095") == 4095);
743 :
744 1 : assert_se(parse_errno("-1") == -ERANGE);
745 1 : assert_se(parse_errno("-3") == -ERANGE);
746 1 : assert_se(parse_errno("4096") == -ERANGE);
747 :
748 1 : assert_se(parse_errno("") == -EINVAL);
749 1 : assert_se(parse_errno("12.3") == -EINVAL);
750 1 : assert_se(parse_errno("123junk") == -EINVAL);
751 1 : assert_se(parse_errno("junk123") == -EINVAL);
752 1 : assert_se(parse_errno("255EILSEQ") == -EINVAL);
753 1 : assert_se(parse_errno("EINVAL12") == -EINVAL);
754 1 : assert_se(parse_errno("-EINVAL") == -EINVAL);
755 1 : assert_se(parse_errno("EINVALaaa") == -EINVAL);
756 1 : }
757 :
758 1 : static void test_parse_syscall_and_errno(void) {
759 1 : _cleanup_free_ char *n = NULL;
760 : int e;
761 :
762 1 : assert_se(parse_syscall_and_errno("uname:EILSEQ", &n, &e) >= 0);
763 1 : assert_se(streq(n, "uname"));
764 1 : assert_se(e == errno_from_name("EILSEQ") && e >= 0);
765 1 : n = mfree(n);
766 :
767 1 : assert_se(parse_syscall_and_errno("uname:EINVAL", &n, &e) >= 0);
768 1 : assert_se(streq(n, "uname"));
769 1 : assert_se(e == errno_from_name("EINVAL") && e >= 0);
770 1 : n = mfree(n);
771 :
772 1 : assert_se(parse_syscall_and_errno("@sync:4095", &n, &e) >= 0);
773 1 : assert_se(streq(n, "@sync"));
774 1 : assert_se(e == 4095);
775 1 : n = mfree(n);
776 :
777 : /* If errno is omitted, then e is set to -1 */
778 1 : assert_se(parse_syscall_and_errno("mount", &n, &e) >= 0);
779 1 : assert_se(streq(n, "mount"));
780 1 : assert_se(e == -1);
781 1 : n = mfree(n);
782 :
783 : /* parse_syscall_and_errno() does not check the syscall name is valid or not. */
784 1 : assert_se(parse_syscall_and_errno("hoge:255", &n, &e) >= 0);
785 1 : assert_se(streq(n, "hoge"));
786 1 : assert_se(e == 255);
787 1 : n = mfree(n);
788 :
789 : /* The function checks the syscall name is empty or not. */
790 1 : assert_se(parse_syscall_and_errno("", &n, &e) == -EINVAL);
791 1 : assert_se(parse_syscall_and_errno(":255", &n, &e) == -EINVAL);
792 :
793 : /* errno must be a valid errno name or number between 0 and ERRNO_MAX == 4095 */
794 1 : assert_se(parse_syscall_and_errno("hoge:4096", &n, &e) == -ERANGE);
795 1 : assert_se(parse_syscall_and_errno("hoge:-3", &n, &e) == -ERANGE);
796 1 : assert_se(parse_syscall_and_errno("hoge:12.3", &n, &e) == -EINVAL);
797 1 : assert_se(parse_syscall_and_errno("hoge:123junk", &n, &e) == -EINVAL);
798 1 : assert_se(parse_syscall_and_errno("hoge:junk123", &n, &e) == -EINVAL);
799 1 : assert_se(parse_syscall_and_errno("hoge:255:EILSEQ", &n, &e) == -EINVAL);
800 1 : assert_se(parse_syscall_and_errno("hoge:-EINVAL", &n, &e) == -EINVAL);
801 1 : assert_se(parse_syscall_and_errno("hoge:EINVALaaa", &n, &e) == -EINVAL);
802 1 : assert_se(parse_syscall_and_errno("hoge:", &n, &e) == -EINVAL);
803 1 : }
804 :
805 1 : static void test_parse_mtu(void) {
806 1 : uint32_t mtu = 0;
807 :
808 1 : assert_se(parse_mtu(AF_UNSPEC, "1500", &mtu) >= 0 && mtu == 1500);
809 1 : assert_se(parse_mtu(AF_UNSPEC, "1400", &mtu) >= 0 && mtu == 1400);
810 1 : assert_se(parse_mtu(AF_UNSPEC, "65535", &mtu) >= 0 && mtu == 65535);
811 1 : assert_se(parse_mtu(AF_UNSPEC, "65536", &mtu) >= 0 && mtu == 65536);
812 1 : assert_se(parse_mtu(AF_UNSPEC, "4294967295", &mtu) >= 0 && mtu == 4294967295);
813 1 : assert_se(parse_mtu(AF_UNSPEC, "500", &mtu) >= 0 && mtu == 500);
814 1 : assert_se(parse_mtu(AF_UNSPEC, "1280", &mtu) >= 0 && mtu == 1280);
815 1 : assert_se(parse_mtu(AF_INET6, "1280", &mtu) >= 0 && mtu == 1280);
816 1 : assert_se(parse_mtu(AF_INET6, "1279", &mtu) == -ERANGE);
817 1 : assert_se(parse_mtu(AF_UNSPEC, "4294967296", &mtu) == -ERANGE);
818 1 : assert_se(parse_mtu(AF_INET6, "4294967296", &mtu) == -ERANGE);
819 1 : assert_se(parse_mtu(AF_INET6, "68", &mtu) == -ERANGE);
820 1 : assert_se(parse_mtu(AF_UNSPEC, "68", &mtu) >= 0 && mtu == 68);
821 1 : assert_se(parse_mtu(AF_UNSPEC, "67", &mtu) == -ERANGE);
822 1 : assert_se(parse_mtu(AF_UNSPEC, "0", &mtu) == -ERANGE);
823 1 : assert_se(parse_mtu(AF_UNSPEC, "", &mtu) == -EINVAL);
824 1 : }
825 :
826 1 : int main(int argc, char *argv[]) {
827 1 : log_parse_environment();
828 1 : log_open();
829 :
830 1 : test_parse_boolean();
831 1 : test_parse_pid();
832 1 : test_parse_mode();
833 1 : test_parse_size();
834 1 : test_parse_range();
835 1 : test_safe_atolli();
836 1 : test_safe_atou16();
837 1 : test_safe_atoi16();
838 1 : test_safe_atoux16();
839 1 : test_safe_atou64();
840 1 : test_safe_atoi64();
841 1 : test_safe_atod();
842 1 : test_parse_percent();
843 1 : test_parse_percent_unbounded();
844 1 : test_parse_permille();
845 1 : test_parse_permille_unbounded();
846 1 : test_parse_nice();
847 1 : test_parse_dev();
848 1 : test_parse_errno();
849 1 : test_parse_syscall_and_errno();
850 1 : test_parse_mtu();
851 :
852 1 : return 0;
853 : }
|
