]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/test/test-util.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
parse-util: Introduce new parse_range function
[thirdparty/systemd.git] / src / test / test-util.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4 This file is part of systemd.
5
6 Copyright 2010 Lennart Poettering
7 Copyright 2013 Thomas H.P. Andersen
8
9 systemd is free software; you can redistribute it and/or modify it
10 under the terms of the GNU Lesser General Public License as published by
11 the Free Software Foundation; either version 2.1 of the License, or
12 (at your option) any later version.
13
14 systemd is distributed in the hope that it will be useful, but
15 WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 Lesser General Public License for more details.
18
19 You should have received a copy of the GNU Lesser General Public License
20 along with systemd; If not, see <http://www.gnu.org/licenses/>.
21 ***/
22
23 #include <errno.h>
24 #include <fcntl.h>
25 #include <locale.h>
26 #include <math.h>
27 #include <signal.h>
28 #include <string.h>
29 #include <sys/types.h>
30 #include <sys/wait.h>
31 #include <sys/xattr.h>
32 #include <unistd.h>
33
34 #include "alloc-util.h"
35 #include "conf-parser.h"
36 #include "cpu-set-util.h"
37 #include "def.h"
38 #include "escape.h"
39 #include "fd-util.h"
40 #include "fileio.h"
41 #include "fs-util.h"
42 #include "fstab-util.h"
43 #include "glob-util.h"
44 #include "hexdecoct.h"
45 #include "io-util.h"
46 #include "mkdir.h"
47 #include "parse-util.h"
48 #include "path-util.h"
49 #include "proc-cmdline.h"
50 #include "process-util.h"
51 #include "rm-rf.h"
52 #include "signal-util.h"
53 #include "stat-util.h"
54 #include "string-util.h"
55 #include "strv.h"
56 #include "user-util.h"
57 #include "util.h"
58 #include "virt.h"
59 #include "web-util.h"
60 #include "xattr-util.h"
61
62 static void test_streq_ptr(void) {
63 assert_se(streq_ptr(NULL, NULL));
64 assert_se(!streq_ptr("abc", "cdef"));
65 }
66
67 static void test_align_power2(void) {
68 unsigned long i, p2;
69
70 assert_se(ALIGN_POWER2(0) == 0);
71 assert_se(ALIGN_POWER2(1) == 1);
72 assert_se(ALIGN_POWER2(2) == 2);
73 assert_se(ALIGN_POWER2(3) == 4);
74 assert_se(ALIGN_POWER2(12) == 16);
75
76 assert_se(ALIGN_POWER2(ULONG_MAX) == 0);
77 assert_se(ALIGN_POWER2(ULONG_MAX - 1) == 0);
78 assert_se(ALIGN_POWER2(ULONG_MAX - 1024) == 0);
79 assert_se(ALIGN_POWER2(ULONG_MAX / 2) == ULONG_MAX / 2 + 1);
80 assert_se(ALIGN_POWER2(ULONG_MAX + 1) == 0);
81
82 for (i = 1; i < 131071; ++i) {
83 for (p2 = 1; p2 < i; p2 <<= 1)
84 /* empty */ ;
85
86 assert_se(ALIGN_POWER2(i) == p2);
87 }
88
89 for (i = ULONG_MAX - 1024; i < ULONG_MAX; ++i) {
90 for (p2 = 1; p2 && p2 < i; p2 <<= 1)
91 /* empty */ ;
92
93 assert_se(ALIGN_POWER2(i) == p2);
94 }
95 }
96
97 static void test_max(void) {
98 static const struct {
99 int a;
100 int b[CONST_MAX(10, 100)];
101 } val1 = {
102 .a = CONST_MAX(10, 100),
103 };
104 int d = 0;
105
106 assert_cc(sizeof(val1.b) == sizeof(int) * 100);
107
108 /* CONST_MAX returns (void) instead of a value if the passed arguments
109 * are not of the same type or not constant expressions. */
110 assert_cc(__builtin_types_compatible_p(typeof(CONST_MAX(1, 10)), int));
111 assert_cc(__builtin_types_compatible_p(typeof(CONST_MAX(1, 1U)), void));
112
113 assert_se(val1.a == 100);
114 assert_se(MAX(++d, 0) == 1);
115 assert_se(d == 1);
116
117 assert_cc(MAXSIZE(char[3], uint16_t) == 3);
118 assert_cc(MAXSIZE(char[3], uint32_t) == 4);
119 assert_cc(MAXSIZE(char, long) == sizeof(long));
120
121 assert_se(MAX(-5, 5) == 5);
122 assert_se(MAX(5, 5) == 5);
123 assert_se(MAX(MAX(1, MAX(2, MAX(3, 4))), 5) == 5);
124 assert_se(MAX(MAX(1, MAX(2, MAX(3, 2))), 1) == 3);
125 assert_se(MAX(MIN(1, MIN(2, MIN(3, 4))), 5) == 5);
126 assert_se(MAX(MAX(1, MIN(2, MIN(3, 2))), 1) == 2);
127 assert_se(LESS_BY(8, 4) == 4);
128 assert_se(LESS_BY(8, 8) == 0);
129 assert_se(LESS_BY(4, 8) == 0);
130 assert_se(LESS_BY(16, LESS_BY(8, 4)) == 12);
131 assert_se(LESS_BY(4, LESS_BY(8, 4)) == 0);
132 assert_se(CLAMP(-5, 0, 1) == 0);
133 assert_se(CLAMP(5, 0, 1) == 1);
134 assert_se(CLAMP(5, -10, 1) == 1);
135 assert_se(CLAMP(5, -10, 10) == 5);
136 assert_se(CLAMP(CLAMP(0, -10, 10), CLAMP(-5, 10, 20), CLAMP(100, -5, 20)) == 10);
137 }
138
139 static void test_container_of(void) {
140 struct mytype {
141 uint8_t pad1[3];
142 uint64_t v1;
143 uint8_t pad2[2];
144 uint32_t v2;
145 } _packed_ myval = { };
146
147 assert_cc(sizeof(myval) == 17);
148 assert_se(container_of(&myval.v1, struct mytype, v1) == &myval);
149 assert_se(container_of(&myval.v2, struct mytype, v2) == &myval);
150 assert_se(container_of(&container_of(&myval.v2,
151 struct mytype,
152 v2)->v1,
153 struct mytype,
154 v1) == &myval);
155 }
156
157 static void test_alloca(void) {
158 static const uint8_t zero[997] = { };
159 char *t;
160
161 t = alloca_align(17, 512);
162 assert_se(!((uintptr_t)t & 0xff));
163 memzero(t, 17);
164
165 t = alloca0_align(997, 1024);
166 assert_se(!((uintptr_t)t & 0x1ff));
167 assert_se(!memcmp(t, zero, 997));
168 }
169
170 static void test_div_round_up(void) {
171 int div;
172
173 /* basic tests */
174 assert_se(DIV_ROUND_UP(0, 8) == 0);
175 assert_se(DIV_ROUND_UP(1, 8) == 1);
176 assert_se(DIV_ROUND_UP(8, 8) == 1);
177 assert_se(DIV_ROUND_UP(12, 8) == 2);
178 assert_se(DIV_ROUND_UP(16, 8) == 2);
179
180 /* test multiple evaluation */
181 div = 0;
182 assert_se(DIV_ROUND_UP(div++, 8) == 0 && div == 1);
183 assert_se(DIV_ROUND_UP(++div, 8) == 1 && div == 2);
184 assert_se(DIV_ROUND_UP(8, div++) == 4 && div == 3);
185 assert_se(DIV_ROUND_UP(8, ++div) == 2 && div == 4);
186
187 /* overflow test with exact division */
188 assert_se(sizeof(0U) == 4);
189 assert_se(0xfffffffaU % 10U == 0U);
190 assert_se(0xfffffffaU / 10U == 429496729U);
191 assert_se(DIV_ROUND_UP(0xfffffffaU, 10U) == 429496729U);
192 assert_se((0xfffffffaU + 10U - 1U) / 10U == 0U);
193 assert_se(0xfffffffaU / 10U + !!(0xfffffffaU % 10U) == 429496729U);
194
195 /* overflow test with rounded division */
196 assert_se(0xfffffffdU % 10U == 3U);
197 assert_se(0xfffffffdU / 10U == 429496729U);
198 assert_se(DIV_ROUND_UP(0xfffffffdU, 10U) == 429496730U);
199 assert_se((0xfffffffdU + 10U - 1U) / 10U == 0U);
200 assert_se(0xfffffffdU / 10U + !!(0xfffffffdU % 10U) == 429496730U);
201 }
202
203 static void test_first_word(void) {
204 assert_se(first_word("Hello", ""));
205 assert_se(first_word("Hello", "Hello"));
206 assert_se(first_word("Hello world", "Hello"));
207 assert_se(first_word("Hello\tworld", "Hello"));
208 assert_se(first_word("Hello\nworld", "Hello"));
209 assert_se(first_word("Hello\rworld", "Hello"));
210 assert_se(first_word("Hello ", "Hello"));
211
212 assert_se(!first_word("Hello", "Hellooo"));
213 assert_se(!first_word("Hello", "xxxxx"));
214 assert_se(!first_word("Hellooo", "Hello"));
215 }
216
217 static void test_close_many(void) {
218 int fds[3];
219 char name0[] = "/tmp/test-close-many.XXXXXX";
220 char name1[] = "/tmp/test-close-many.XXXXXX";
221 char name2[] = "/tmp/test-close-many.XXXXXX";
222
223 fds[0] = mkostemp_safe(name0, O_RDWR|O_CLOEXEC);
224 fds[1] = mkostemp_safe(name1, O_RDWR|O_CLOEXEC);
225 fds[2] = mkostemp_safe(name2, O_RDWR|O_CLOEXEC);
226
227 close_many(fds, 2);
228
229 assert_se(fcntl(fds[0], F_GETFD) == -1);
230 assert_se(fcntl(fds[1], F_GETFD) == -1);
231 assert_se(fcntl(fds[2], F_GETFD) >= 0);
232
233 safe_close(fds[2]);
234
235 unlink(name0);
236 unlink(name1);
237 unlink(name2);
238 }
239
240 static void test_parse_boolean(void) {
241 assert_se(parse_boolean("1") == 1);
242 assert_se(parse_boolean("y") == 1);
243 assert_se(parse_boolean("Y") == 1);
244 assert_se(parse_boolean("yes") == 1);
245 assert_se(parse_boolean("YES") == 1);
246 assert_se(parse_boolean("true") == 1);
247 assert_se(parse_boolean("TRUE") == 1);
248 assert_se(parse_boolean("on") == 1);
249 assert_se(parse_boolean("ON") == 1);
250
251 assert_se(parse_boolean("0") == 0);
252 assert_se(parse_boolean("n") == 0);
253 assert_se(parse_boolean("N") == 0);
254 assert_se(parse_boolean("no") == 0);
255 assert_se(parse_boolean("NO") == 0);
256 assert_se(parse_boolean("false") == 0);
257 assert_se(parse_boolean("FALSE") == 0);
258 assert_se(parse_boolean("off") == 0);
259 assert_se(parse_boolean("OFF") == 0);
260
261 assert_se(parse_boolean("garbage") < 0);
262 assert_se(parse_boolean("") < 0);
263 assert_se(parse_boolean("full") < 0);
264 }
265
266 static void test_parse_pid(void) {
267 int r;
268 pid_t pid;
269
270 r = parse_pid("100", &pid);
271 assert_se(r == 0);
272 assert_se(pid == 100);
273
274 r = parse_pid("0x7FFFFFFF", &pid);
275 assert_se(r == 0);
276 assert_se(pid == 2147483647);
277
278 pid = 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
279 r = parse_pid("0", &pid);
280 assert_se(r == -ERANGE);
281 assert_se(pid == 65);
282
283 pid = 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
284 r = parse_pid("-100", &pid);
285 assert_se(r == -ERANGE);
286 assert_se(pid == 65);
287
288 pid = 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
289 r = parse_pid("0xFFFFFFFFFFFFFFFFF", &pid);
290 assert_se(r == -ERANGE);
291 assert_se(pid == 65);
292
293 r = parse_pid("junk", &pid);
294 assert_se(r == -EINVAL);
295 }
296
297 static void test_parse_uid(void) {
298 int r;
299 uid_t uid;
300
301 r = parse_uid("100", &uid);
302 assert_se(r == 0);
303 assert_se(uid == 100);
304
305 r = parse_uid("65535", &uid);
306 assert_se(r == -ENXIO);
307
308 r = parse_uid("asdsdas", &uid);
309 assert_se(r == -EINVAL);
310 }
311
312 static void test_safe_atou16(void) {
313 int r;
314 uint16_t l;
315
316 r = safe_atou16("12345", &l);
317 assert_se(r == 0);
318 assert_se(l == 12345);
319
320 r = safe_atou16("123456", &l);
321 assert_se(r == -ERANGE);
322
323 r = safe_atou16("junk", &l);
324 assert_se(r == -EINVAL);
325 }
326
327 static void test_safe_atoi16(void) {
328 int r;
329 int16_t l;
330
331 r = safe_atoi16("-12345", &l);
332 assert_se(r == 0);
333 assert_se(l == -12345);
334
335 r = safe_atoi16("36536", &l);
336 assert_se(r == -ERANGE);
337
338 r = safe_atoi16("junk", &l);
339 assert_se(r == -EINVAL);
340 }
341
342 static void test_safe_atolli(void) {
343 int r;
344 long long l;
345
346 r = safe_atolli("12345", &l);
347 assert_se(r == 0);
348 assert_se(l == 12345);
349
350 r = safe_atolli("junk", &l);
351 assert_se(r == -EINVAL);
352 }
353
354 static void test_safe_atod(void) {
355 int r;
356 double d;
357 char *e;
358
359 r = safe_atod("junk", &d);
360 assert_se(r == -EINVAL);
361
362 r = safe_atod("0.2244", &d);
363 assert_se(r == 0);
364 assert_se(fabs(d - 0.2244) < 0.000001);
365
366 r = safe_atod("0,5", &d);
367 assert_se(r == -EINVAL);
368
369 errno = 0;
370 strtod("0,5", &e);
371 assert_se(*e == ',');
372
373 /* Check if this really is locale independent */
374 if (setlocale(LC_NUMERIC, "de_DE.utf8")) {
375
376 r = safe_atod("0.2244", &d);
377 assert_se(r == 0);
378 assert_se(fabs(d - 0.2244) < 0.000001);
379
380 r = safe_atod("0,5", &d);
381 assert_se(r == -EINVAL);
382
383 errno = 0;
384 assert_se(fabs(strtod("0,5", &e) - 0.5) < 0.00001);
385 }
386
387 /* And check again, reset */
388 assert_se(setlocale(LC_NUMERIC, "C"));
389
390 r = safe_atod("0.2244", &d);
391 assert_se(r == 0);
392 assert_se(fabs(d - 0.2244) < 0.000001);
393
394 r = safe_atod("0,5", &d);
395 assert_se(r == -EINVAL);
396
397 errno = 0;
398 strtod("0,5", &e);
399 assert_se(*e == ',');
400 }
401
402 static void test_strappend(void) {
403 _cleanup_free_ char *t1, *t2, *t3, *t4;
404
405 t1 = strappend(NULL, NULL);
406 assert_se(streq(t1, ""));
407
408 t2 = strappend(NULL, "suf");
409 assert_se(streq(t2, "suf"));
410
411 t3 = strappend("pre", NULL);
412 assert_se(streq(t3, "pre"));
413
414 t4 = strappend("pre", "suf");
415 assert_se(streq(t4, "presuf"));
416 }
417
418 static void test_strstrip(void) {
419 char *r;
420 char input[] = " hello, waldo. ";
421
422 r = strstrip(input);
423 assert_se(streq(r, "hello, waldo."));
424 }
425
426 static void test_delete_chars(void) {
427 char *r;
428 char input[] = " hello, waldo. abc";
429
430 r = delete_chars(input, WHITESPACE);
431 assert_se(streq(r, "hello,waldo.abc"));
432 }
433
434 static void test_in_charset(void) {
435 assert_se(in_charset("dddaaabbbcccc", "abcd"));
436 assert_se(!in_charset("dddaaabbbcccc", "abc f"));
437 }
438
439 static void test_hexchar(void) {
440 assert_se(hexchar(0xa) == 'a');
441 assert_se(hexchar(0x0) == '0');
442 }
443
444 static void test_unhexchar(void) {
445 assert_se(unhexchar('a') == 0xA);
446 assert_se(unhexchar('A') == 0xA);
447 assert_se(unhexchar('0') == 0x0);
448 }
449
450 static void test_base32hexchar(void) {
451 assert_se(base32hexchar(0) == '0');
452 assert_se(base32hexchar(9) == '9');
453 assert_se(base32hexchar(10) == 'A');
454 assert_se(base32hexchar(31) == 'V');
455 }
456
457 static void test_unbase32hexchar(void) {
458 assert_se(unbase32hexchar('0') == 0);
459 assert_se(unbase32hexchar('9') == 9);
460 assert_se(unbase32hexchar('A') == 10);
461 assert_se(unbase32hexchar('V') == 31);
462 assert_se(unbase32hexchar('=') == -EINVAL);
463 }
464
465 static void test_base64char(void) {
466 assert_se(base64char(0) == 'A');
467 assert_se(base64char(26) == 'a');
468 assert_se(base64char(63) == '/');
469 }
470
471 static void test_unbase64char(void) {
472 assert_se(unbase64char('A') == 0);
473 assert_se(unbase64char('Z') == 25);
474 assert_se(unbase64char('a') == 26);
475 assert_se(unbase64char('z') == 51);
476 assert_se(unbase64char('0') == 52);
477 assert_se(unbase64char('9') == 61);
478 assert_se(unbase64char('+') == 62);
479 assert_se(unbase64char('/') == 63);
480 assert_se(unbase64char('=') == -EINVAL);
481 }
482
483 static void test_octchar(void) {
484 assert_se(octchar(00) == '0');
485 assert_se(octchar(07) == '7');
486 }
487
488 static void test_unoctchar(void) {
489 assert_se(unoctchar('0') == 00);
490 assert_se(unoctchar('7') == 07);
491 }
492
493 static void test_decchar(void) {
494 assert_se(decchar(0) == '0');
495 assert_se(decchar(9) == '9');
496 }
497
498 static void test_undecchar(void) {
499 assert_se(undecchar('0') == 0);
500 assert_se(undecchar('9') == 9);
501 }
502
503 static void test_unhexmem(void) {
504 const char *hex = "efa214921";
505 const char *hex_invalid = "efa214921o";
506 _cleanup_free_ char *hex2 = NULL;
507 _cleanup_free_ void *mem = NULL;
508 size_t len;
509
510 assert_se(unhexmem(hex, strlen(hex), &mem, &len) == 0);
511 assert_se(unhexmem(hex, strlen(hex) + 1, &mem, &len) == -EINVAL);
512 assert_se(unhexmem(hex_invalid, strlen(hex_invalid), &mem, &len) == -EINVAL);
513
514 assert_se((hex2 = hexmem(mem, len)));
515
516 free(mem);
517
518 assert_se(memcmp(hex, hex2, strlen(hex)) == 0);
519
520 free(hex2);
521
522 assert_se(unhexmem(hex, strlen(hex) - 1, &mem, &len) == 0);
523 assert_se((hex2 = hexmem(mem, len)));
524 assert_se(memcmp(hex, hex2, strlen(hex) - 1) == 0);
525 }
526
527 /* https://tools.ietf.org/html/rfc4648#section-10 */
528 static void test_base32hexmem(void) {
529 char *b32;
530
531 b32 = base32hexmem("", strlen(""), true);
532 assert_se(b32);
533 assert_se(streq(b32, ""));
534 free(b32);
535
536 b32 = base32hexmem("f", strlen("f"), true);
537 assert_se(b32);
538 assert_se(streq(b32, "CO======"));
539 free(b32);
540
541 b32 = base32hexmem("fo", strlen("fo"), true);
542 assert_se(b32);
543 assert_se(streq(b32, "CPNG===="));
544 free(b32);
545
546 b32 = base32hexmem("foo", strlen("foo"), true);
547 assert_se(b32);
548 assert_se(streq(b32, "CPNMU==="));
549 free(b32);
550
551 b32 = base32hexmem("foob", strlen("foob"), true);
552 assert_se(b32);
553 assert_se(streq(b32, "CPNMUOG="));
554 free(b32);
555
556 b32 = base32hexmem("fooba", strlen("fooba"), true);
557 assert_se(b32);
558 assert_se(streq(b32, "CPNMUOJ1"));
559 free(b32);
560
561 b32 = base32hexmem("foobar", strlen("foobar"), true);
562 assert_se(b32);
563 assert_se(streq(b32, "CPNMUOJ1E8======"));
564 free(b32);
565
566 b32 = base32hexmem("", strlen(""), false);
567 assert_se(b32);
568 assert_se(streq(b32, ""));
569 free(b32);
570
571 b32 = base32hexmem("f", strlen("f"), false);
572 assert_se(b32);
573 assert_se(streq(b32, "CO"));
574 free(b32);
575
576 b32 = base32hexmem("fo", strlen("fo"), false);
577 assert_se(b32);
578 assert_se(streq(b32, "CPNG"));
579 free(b32);
580
581 b32 = base32hexmem("foo", strlen("foo"), false);
582 assert_se(b32);
583 assert_se(streq(b32, "CPNMU"));
584 free(b32);
585
586 b32 = base32hexmem("foob", strlen("foob"), false);
587 assert_se(b32);
588 assert_se(streq(b32, "CPNMUOG"));
589 free(b32);
590
591 b32 = base32hexmem("fooba", strlen("fooba"), false);
592 assert_se(b32);
593 assert_se(streq(b32, "CPNMUOJ1"));
594 free(b32);
595
596 b32 = base32hexmem("foobar", strlen("foobar"), false);
597 assert_se(b32);
598 assert_se(streq(b32, "CPNMUOJ1E8"));
599 free(b32);
600 }
601
602 static void test_unbase32hexmem(void) {
603 void *mem;
604 size_t len;
605
606 assert_se(unbase32hexmem("", strlen(""), true, &mem, &len) == 0);
607 assert_se(streq(strndupa(mem, len), ""));
608 free(mem);
609
610 assert_se(unbase32hexmem("CO======", strlen("CO======"), true, &mem, &len) == 0);
611 assert_se(streq(strndupa(mem, len), "f"));
612 free(mem);
613
614 assert_se(unbase32hexmem("CPNG====", strlen("CPNG===="), true, &mem, &len) == 0);
615 assert_se(streq(strndupa(mem, len), "fo"));
616 free(mem);
617
618 assert_se(unbase32hexmem("CPNMU===", strlen("CPNMU==="), true, &mem, &len) == 0);
619 assert_se(streq(strndupa(mem, len), "foo"));
620 free(mem);
621
622 assert_se(unbase32hexmem("CPNMUOG=", strlen("CPNMUOG="), true, &mem, &len) == 0);
623 assert_se(streq(strndupa(mem, len), "foob"));
624 free(mem);
625
626 assert_se(unbase32hexmem("CPNMUOJ1", strlen("CPNMUOJ1"), true, &mem, &len) == 0);
627 assert_se(streq(strndupa(mem, len), "fooba"));
628 free(mem);
629
630 assert_se(unbase32hexmem("CPNMUOJ1E8======", strlen("CPNMUOJ1E8======"), true, &mem, &len) == 0);
631 assert_se(streq(strndupa(mem, len), "foobar"));
632 free(mem);
633
634 assert_se(unbase32hexmem("A", strlen("A"), true, &mem, &len) == -EINVAL);
635 assert_se(unbase32hexmem("A=======", strlen("A======="), true, &mem, &len) == -EINVAL);
636 assert_se(unbase32hexmem("AAA=====", strlen("AAA====="), true, &mem, &len) == -EINVAL);
637 assert_se(unbase32hexmem("AAAAAA==", strlen("AAAAAA=="), true, &mem, &len) == -EINVAL);
638 assert_se(unbase32hexmem("AB======", strlen("AB======"), true, &mem, &len) == -EINVAL);
639 assert_se(unbase32hexmem("AAAB====", strlen("AAAB===="), true, &mem, &len) == -EINVAL);
640 assert_se(unbase32hexmem("AAAAB===", strlen("AAAAB==="), true, &mem, &len) == -EINVAL);
641 assert_se(unbase32hexmem("AAAAAAB=", strlen("AAAAAAB="), true, &mem, &len) == -EINVAL);
642
643 assert_se(unbase32hexmem("XPNMUOJ1", strlen("CPNMUOJ1"), true, &mem, &len) == -EINVAL);
644 assert_se(unbase32hexmem("CXNMUOJ1", strlen("CPNMUOJ1"), true, &mem, &len) == -EINVAL);
645 assert_se(unbase32hexmem("CPXMUOJ1", strlen("CPNMUOJ1"), true, &mem, &len) == -EINVAL);
646 assert_se(unbase32hexmem("CPNXUOJ1", strlen("CPNMUOJ1"), true, &mem, &len) == -EINVAL);
647 assert_se(unbase32hexmem("CPNMXOJ1", strlen("CPNMUOJ1"), true, &mem, &len) == -EINVAL);
648 assert_se(unbase32hexmem("CPNMUXJ1", strlen("CPNMUOJ1"), true, &mem, &len) == -EINVAL);
649 assert_se(unbase32hexmem("CPNMUOX1", strlen("CPNMUOJ1"), true, &mem, &len) == -EINVAL);
650 assert_se(unbase32hexmem("CPNMUOJX", strlen("CPNMUOJ1"), true, &mem, &len) == -EINVAL);
651
652 assert_se(unbase32hexmem("", strlen(""), false, &mem, &len) == 0);
653 assert_se(streq(strndupa(mem, len), ""));
654 free(mem);
655
656 assert_se(unbase32hexmem("CO", strlen("CO"), false, &mem, &len) == 0);
657 assert_se(streq(strndupa(mem, len), "f"));
658 free(mem);
659
660 assert_se(unbase32hexmem("CPNG", strlen("CPNG"), false, &mem, &len) == 0);
661 assert_se(streq(strndupa(mem, len), "fo"));
662 free(mem);
663
664 assert_se(unbase32hexmem("CPNMU", strlen("CPNMU"), false, &mem, &len) == 0);
665 assert_se(streq(strndupa(mem, len), "foo"));
666 free(mem);
667
668 assert_se(unbase32hexmem("CPNMUOG", strlen("CPNMUOG"), false, &mem, &len) == 0);
669 assert_se(streq(strndupa(mem, len), "foob"));
670 free(mem);
671
672 assert_se(unbase32hexmem("CPNMUOJ1", strlen("CPNMUOJ1"), false, &mem, &len) == 0);
673 assert_se(streq(strndupa(mem, len), "fooba"));
674 free(mem);
675
676 assert_se(unbase32hexmem("CPNMUOJ1E8", strlen("CPNMUOJ1E8"), false, &mem, &len) == 0);
677 assert_se(streq(strndupa(mem, len), "foobar"));
678 free(mem);
679
680 assert_se(unbase32hexmem("CPNMUOG=", strlen("CPNMUOG="), false, &mem, &len) == -EINVAL);
681 assert_se(unbase32hexmem("CPNMUOJ1E8======", strlen("CPNMUOJ1E8======"), false, &mem, &len) == -EINVAL);
682 assert_se(unbase32hexmem("A", strlen("A"), false, &mem, &len) == -EINVAL);
683 assert_se(unbase32hexmem("A", strlen("A"), false, &mem, &len) == -EINVAL);
684 assert_se(unbase32hexmem("AAA", strlen("AAA"), false, &mem, &len) == -EINVAL);
685 assert_se(unbase32hexmem("AAAAAA", strlen("AAAAAA"), false, &mem, &len) == -EINVAL);
686 assert_se(unbase32hexmem("AB", strlen("AB"), false, &mem, &len) == -EINVAL);
687 assert_se(unbase32hexmem("AAAB", strlen("AAAB"), false, &mem, &len) == -EINVAL);
688 assert_se(unbase32hexmem("AAAAB", strlen("AAAAB"), false, &mem, &len) == -EINVAL);
689 assert_se(unbase32hexmem("AAAAAAB", strlen("AAAAAAB"), false, &mem, &len) == -EINVAL);
690 }
691
692 /* https://tools.ietf.org/html/rfc4648#section-10 */
693 static void test_base64mem(void) {
694 char *b64;
695
696 b64 = base64mem("", strlen(""));
697 assert_se(b64);
698 assert_se(streq(b64, ""));
699 free(b64);
700
701 b64 = base64mem("f", strlen("f"));
702 assert_se(b64);
703 assert_se(streq(b64, "Zg=="));
704 free(b64);
705
706 b64 = base64mem("fo", strlen("fo"));
707 assert_se(b64);
708 assert_se(streq(b64, "Zm8="));
709 free(b64);
710
711 b64 = base64mem("foo", strlen("foo"));
712 assert_se(b64);
713 assert_se(streq(b64, "Zm9v"));
714 free(b64);
715
716 b64 = base64mem("foob", strlen("foob"));
717 assert_se(b64);
718 assert_se(streq(b64, "Zm9vYg=="));
719 free(b64);
720
721 b64 = base64mem("fooba", strlen("fooba"));
722 assert_se(b64);
723 assert_se(streq(b64, "Zm9vYmE="));
724 free(b64);
725
726 b64 = base64mem("foobar", strlen("foobar"));
727 assert_se(b64);
728 assert_se(streq(b64, "Zm9vYmFy"));
729 free(b64);
730 }
731
732 static void test_unbase64mem(void) {
733 void *mem;
734 size_t len;
735
736 assert_se(unbase64mem("", strlen(""), &mem, &len) == 0);
737 assert_se(streq(strndupa(mem, len), ""));
738 free(mem);
739
740 assert_se(unbase64mem("Zg==", strlen("Zg=="), &mem, &len) == 0);
741 assert_se(streq(strndupa(mem, len), "f"));
742 free(mem);
743
744 assert_se(unbase64mem("Zm8=", strlen("Zm8="), &mem, &len) == 0);
745 assert_se(streq(strndupa(mem, len), "fo"));
746 free(mem);
747
748 assert_se(unbase64mem("Zm9v", strlen("Zm9v"), &mem, &len) == 0);
749 assert_se(streq(strndupa(mem, len), "foo"));
750 free(mem);
751
752 assert_se(unbase64mem("Zm9vYg==", strlen("Zm9vYg=="), &mem, &len) == 0);
753 assert_se(streq(strndupa(mem, len), "foob"));
754 free(mem);
755
756 assert_se(unbase64mem("Zm9vYmE=", strlen("Zm9vYmE="), &mem, &len) == 0);
757 assert_se(streq(strndupa(mem, len), "fooba"));
758 free(mem);
759
760 assert_se(unbase64mem("Zm9vYmFy", strlen("Zm9vYmFy"), &mem, &len) == 0);
761 assert_se(streq(strndupa(mem, len), "foobar"));
762 free(mem);
763
764 assert_se(unbase64mem("A", strlen("A"), &mem, &len) == -EINVAL);
765 assert_se(unbase64mem("A====", strlen("A===="), &mem, &len) == -EINVAL);
766 assert_se(unbase64mem("AAB==", strlen("AAB=="), &mem, &len) == -EINVAL);
767 assert_se(unbase64mem("AAAB=", strlen("AAAB="), &mem, &len) == -EINVAL);
768 }
769
770 static void test_cescape(void) {
771 _cleanup_free_ char *escaped;
772
773 assert_se(escaped = cescape("abc\\\"\b\f\n\r\t\v\a\003\177\234\313"));
774 assert_se(streq(escaped, "abc\\\\\\\"\\b\\f\\n\\r\\t\\v\\a\\003\\177\\234\\313"));
775 }
776
777 static void test_cunescape(void) {
778 _cleanup_free_ char *unescaped;
779
780 assert_se(cunescape("abc\\\\\\\"\\b\\f\\a\\n\\r\\t\\v\\003\\177\\234\\313\\000\\x00", 0, &unescaped) < 0);
781 assert_se(cunescape("abc\\\\\\\"\\b\\f\\a\\n\\r\\t\\v\\003\\177\\234\\313\\000\\x00", UNESCAPE_RELAX, &unescaped) >= 0);
782 assert_se(streq_ptr(unescaped, "abc\\\"\b\f\a\n\r\t\v\003\177\234\313\\000\\x00"));
783 unescaped = mfree(unescaped);
784
785 /* incomplete sequences */
786 assert_se(cunescape("\\x0", 0, &unescaped) < 0);
787 assert_se(cunescape("\\x0", UNESCAPE_RELAX, &unescaped) >= 0);
788 assert_se(streq_ptr(unescaped, "\\x0"));
789 unescaped = mfree(unescaped);
790
791 assert_se(cunescape("\\x", 0, &unescaped) < 0);
792 assert_se(cunescape("\\x", UNESCAPE_RELAX, &unescaped) >= 0);
793 assert_se(streq_ptr(unescaped, "\\x"));
794 unescaped = mfree(unescaped);
795
796 assert_se(cunescape("\\", 0, &unescaped) < 0);
797 assert_se(cunescape("\\", UNESCAPE_RELAX, &unescaped) >= 0);
798 assert_se(streq_ptr(unescaped, "\\"));
799 unescaped = mfree(unescaped);
800
801 assert_se(cunescape("\\11", 0, &unescaped) < 0);
802 assert_se(cunescape("\\11", UNESCAPE_RELAX, &unescaped) >= 0);
803 assert_se(streq_ptr(unescaped, "\\11"));
804 unescaped = mfree(unescaped);
805
806 assert_se(cunescape("\\1", 0, &unescaped) < 0);
807 assert_se(cunescape("\\1", UNESCAPE_RELAX, &unescaped) >= 0);
808 assert_se(streq_ptr(unescaped, "\\1"));
809 unescaped = mfree(unescaped);
810
811 assert_se(cunescape("\\u0000", 0, &unescaped) < 0);
812 assert_se(cunescape("\\u00DF\\U000000df\\u03a0\\U00000041", UNESCAPE_RELAX, &unescaped) >= 0);
813 assert_se(streq_ptr(unescaped, "ßßΠA"));
814 unescaped = mfree(unescaped);
815
816 assert_se(cunescape("\\073", 0, &unescaped) >= 0);
817 assert_se(streq_ptr(unescaped, ";"));
818 }
819
820 static void test_foreach_word(void) {
821 const char *word, *state;
822 size_t l;
823 int i = 0;
824 const char test[] = "test abc d\te f ";
825 const char * const expected[] = {
826 "test",
827 "abc",
828 "d",
829 "e",
830 "f",
831 "",
832 NULL
833 };
834
835 FOREACH_WORD(word, l, test, state)
836 assert_se(strneq(expected[i++], word, l));
837 }
838
839 static void check(const char *test, char** expected, bool trailing) {
840 const char *word, *state;
841 size_t l;
842 int i = 0;
843
844 printf("<<<%s>>>\n", test);
845 FOREACH_WORD_QUOTED(word, l, test, state) {
846 _cleanup_free_ char *t = NULL;
847
848 assert_se(t = strndup(word, l));
849 assert_se(strneq(expected[i++], word, l));
850 printf("<%s>\n", t);
851 }
852 printf("<<<%s>>>\n", state);
853 assert_se(expected[i] == NULL);
854 assert_se(isempty(state) == !trailing);
855 }
856
857 static void test_foreach_word_quoted(void) {
858 check("test a b c 'd' e '' '' hhh '' '' \"a b c\"",
859 STRV_MAKE("test",
860 "a",
861 "b",
862 "c",
863 "d",
864 "e",
865 "",
866 "",
867 "hhh",
868 "",
869 "",
870 "a b c"),
871 false);
872
873 check("test \"xxx",
874 STRV_MAKE("test"),
875 true);
876
877 check("test\\",
878 STRV_MAKE_EMPTY,
879 true);
880 }
881
882 static void test_memdup_multiply(void) {
883 int org[] = {1, 2, 3};
884 int *dup;
885
886 dup = (int*)memdup_multiply(org, sizeof(int), 3);
887
888 assert_se(dup);
889 assert_se(dup[0] == 1);
890 assert_se(dup[1] == 2);
891 assert_se(dup[2] == 3);
892 free(dup);
893 }
894
895 static void test_u64log2(void) {
896 assert_se(u64log2(0) == 0);
897 assert_se(u64log2(8) == 3);
898 assert_se(u64log2(9) == 3);
899 assert_se(u64log2(15) == 3);
900 assert_se(u64log2(16) == 4);
901 assert_se(u64log2(1024*1024) == 20);
902 assert_se(u64log2(1024*1024+5) == 20);
903 }
904
905 static void test_protect_errno(void) {
906 errno = 12;
907 {
908 PROTECT_ERRNO;
909 errno = 11;
910 }
911 assert_se(errno == 12);
912 }
913
914 static void test_parse_size(void) {
915 uint64_t bytes;
916
917 assert_se(parse_size("111", 1024, &bytes) == 0);
918 assert_se(bytes == 111);
919
920 assert_se(parse_size("111.4", 1024, &bytes) == 0);
921 assert_se(bytes == 111);
922
923 assert_se(parse_size(" 112 B", 1024, &bytes) == 0);
924 assert_se(bytes == 112);
925
926 assert_se(parse_size(" 112.6 B", 1024, &bytes) == 0);
927 assert_se(bytes == 112);
928
929 assert_se(parse_size("3.5 K", 1024, &bytes) == 0);
930 assert_se(bytes == 3*1024 + 512);
931
932 assert_se(parse_size("3. K", 1024, &bytes) == 0);
933 assert_se(bytes == 3*1024);
934
935 assert_se(parse_size("3.0 K", 1024, &bytes) == 0);
936 assert_se(bytes == 3*1024);
937
938 assert_se(parse_size("3. 0 K", 1024, &bytes) == -EINVAL);
939
940 assert_se(parse_size(" 4 M 11.5K", 1024, &bytes) == 0);
941 assert_se(bytes == 4*1024*1024 + 11 * 1024 + 512);
942
943 assert_se(parse_size("3B3.5G", 1024, &bytes) == -EINVAL);
944
945 assert_se(parse_size("3.5G3B", 1024, &bytes) == 0);
946 assert_se(bytes == 3ULL*1024*1024*1024 + 512*1024*1024 + 3);
947
948 assert_se(parse_size("3.5G 4B", 1024, &bytes) == 0);
949 assert_se(bytes == 3ULL*1024*1024*1024 + 512*1024*1024 + 4);
950
951 assert_se(parse_size("3B3G4T", 1024, &bytes) == -EINVAL);
952
953 assert_se(parse_size("4T3G3B", 1024, &bytes) == 0);
954 assert_se(bytes == (4ULL*1024 + 3)*1024*1024*1024 + 3);
955
956 assert_se(parse_size(" 4 T 3 G 3 B", 1024, &bytes) == 0);
957 assert_se(bytes == (4ULL*1024 + 3)*1024*1024*1024 + 3);
958
959 assert_se(parse_size("12P", 1024, &bytes) == 0);
960 assert_se(bytes == 12ULL * 1024*1024*1024*1024*1024);
961
962 assert_se(parse_size("12P12P", 1024, &bytes) == -EINVAL);
963
964 assert_se(parse_size("3E 2P", 1024, &bytes) == 0);
965 assert_se(bytes == (3 * 1024 + 2ULL) * 1024*1024*1024*1024*1024);
966
967 assert_se(parse_size("12X", 1024, &bytes) == -EINVAL);
968
969 assert_se(parse_size("12.5X", 1024, &bytes) == -EINVAL);
970
971 assert_se(parse_size("12.5e3", 1024, &bytes) == -EINVAL);
972
973 assert_se(parse_size("1024E", 1024, &bytes) == -ERANGE);
974 assert_se(parse_size("-1", 1024, &bytes) == -ERANGE);
975 assert_se(parse_size("-1024E", 1024, &bytes) == -ERANGE);
976
977 assert_se(parse_size("-1024P", 1024, &bytes) == -ERANGE);
978
979 assert_se(parse_size("-10B 20K", 1024, &bytes) == -ERANGE);
980 }
981
982 static void test_parse_range(void) {
983 unsigned lower, upper;
984
985 /* Successful cases */
986 assert_se(parse_range("111", &lower, &upper) == 0);
987 assert_se(lower == 111);
988 assert_se(upper == 111);
989
990 assert_se(parse_range("111-123", &lower, &upper) == 0);
991 assert_se(lower == 111);
992 assert_se(upper == 123);
993
994 assert_se(parse_range("123-111", &lower, &upper) == 0);
995 assert_se(lower == 123);
996 assert_se(upper == 111);
997
998 assert_se(parse_range("123-123", &lower, &upper) == 0);
999 assert_se(lower == 123);
1000 assert_se(upper == 123);
1001
1002 assert_se(parse_range("0", &lower, &upper) == 0);
1003 assert_se(lower == 0);
1004 assert_se(upper == 0);
1005
1006 assert_se(parse_range("0-15", &lower, &upper) == 0);
1007 assert_se(lower == 0);
1008 assert_se(upper == 15);
1009
1010 assert_se(parse_range("15-0", &lower, &upper) == 0);
1011 assert_se(lower == 15);
1012 assert_se(upper == 0);
1013
1014 assert_se(parse_range("128-65535", &lower, &upper) == 0);
1015 assert_se(lower == 128);
1016 assert_se(upper == 65535);
1017
1018 assert_se(parse_range("1024-4294967295", &lower, &upper) == 0);
1019 assert_se(lower == 1024);
1020 assert_se(upper == 4294967295);
1021
1022 /* Leading whitespace is acceptable */
1023 assert_se(parse_range(" 111", &lower, &upper) == 0);
1024 assert_se(lower == 111);
1025 assert_se(upper == 111);
1026
1027 assert_se(parse_range(" 111-123", &lower, &upper) == 0);
1028 assert_se(lower == 111);
1029 assert_se(upper == 123);
1030
1031 assert_se(parse_range("111- 123", &lower, &upper) == 0);
1032 assert_se(lower == 111);
1033 assert_se(upper == 123);
1034
1035 assert_se(parse_range("\t111-\t123", &lower, &upper) == 0);
1036 assert_se(lower == 111);
1037 assert_se(upper == 123);
1038
1039 assert_se(parse_range(" \t 111- \t 123", &lower, &upper) == 0);
1040 assert_se(lower == 111);
1041 assert_se(upper == 123);
1042
1043 /* Error cases, make sure they fail as expected */
1044 lower = upper = 9999;
1045 assert_se(parse_range("111garbage", &lower, &upper) == -EINVAL);
1046 assert_se(lower == 9999);
1047 assert_se(upper == 9999);
1048
1049 assert_se(parse_range("garbage111", &lower, &upper) == -EINVAL);
1050 assert_se(lower == 9999);
1051 assert_se(upper == 9999);
1052
1053 assert_se(parse_range("garbage", &lower, &upper) == -EINVAL);
1054 assert_se(lower == 9999);
1055 assert_se(upper == 9999);
1056
1057 assert_se(parse_range("111-123garbage", &lower, &upper) == -EINVAL);
1058 assert_se(lower == 9999);
1059 assert_se(upper == 9999);
1060
1061 assert_se(parse_range("111garbage-123", &lower, &upper) == -EINVAL);
1062 assert_se(lower == 9999);
1063 assert_se(upper == 9999);
1064
1065 /* Empty string */
1066 lower = upper = 9999;
1067 assert_se(parse_range("", &lower, &upper) == -EINVAL);
1068 assert_se(lower == 9999);
1069 assert_se(upper == 9999);
1070
1071 /* 111--123 will pass -123 to safe_atou which returns -ERANGE for negative */
1072 assert_se(parse_range("111--123", &lower, &upper) == -ERANGE);
1073 assert_se(lower == 9999);
1074 assert_se(upper == 9999);
1075
1076 assert_se(parse_range("-111-123", &lower, &upper) == -EINVAL);
1077 assert_se(lower == 9999);
1078 assert_se(upper == 9999);
1079
1080 assert_se(parse_range("111-123-", &lower, &upper) == -EINVAL);
1081 assert_se(lower == 9999);
1082 assert_se(upper == 9999);
1083
1084 assert_se(parse_range("111.4-123", &lower, &upper) == -EINVAL);
1085 assert_se(lower == 9999);
1086 assert_se(upper == 9999);
1087
1088 assert_se(parse_range("111-123.4", &lower, &upper) == -EINVAL);
1089 assert_se(lower == 9999);
1090 assert_se(upper == 9999);
1091
1092 assert_se(parse_range("111,4-123", &lower, &upper) == -EINVAL);
1093 assert_se(lower == 9999);
1094 assert_se(upper == 9999);
1095
1096 assert_se(parse_range("111-123,4", &lower, &upper) == -EINVAL);
1097 assert_se(lower == 9999);
1098 assert_se(upper == 9999);
1099
1100 /* Error on trailing dash */
1101 assert_se(parse_range("111-", &lower, &upper) == -EINVAL);
1102 assert_se(lower == 9999);
1103 assert_se(upper == 9999);
1104
1105 assert_se(parse_range("111-123-", &lower, &upper) == -EINVAL);
1106 assert_se(lower == 9999);
1107 assert_se(upper == 9999);
1108
1109 assert_se(parse_range("111--", &lower, &upper) == -EINVAL);
1110 assert_se(lower == 9999);
1111 assert_se(upper == 9999);
1112
1113 assert_se(parse_range("111- ", &lower, &upper) == -EINVAL);
1114 assert_se(lower == 9999);
1115 assert_se(upper == 9999);
1116
1117 /* Whitespace is not a separator */
1118 assert_se(parse_range("111 123", &lower, &upper) == -EINVAL);
1119 assert_se(lower == 9999);
1120 assert_se(upper == 9999);
1121
1122 assert_se(parse_range("111\t123", &lower, &upper) == -EINVAL);
1123 assert_se(lower == 9999);
1124 assert_se(upper == 9999);
1125
1126 assert_se(parse_range("111 \t 123", &lower, &upper) == -EINVAL);
1127 assert_se(lower == 9999);
1128 assert_se(upper == 9999);
1129
1130 /* Trailing whitespace is invalid (from safe_atou) */
1131 assert_se(parse_range("111 ", &lower, &upper) == -EINVAL);
1132 assert_se(lower == 9999);
1133 assert_se(upper == 9999);
1134
1135 assert_se(parse_range("111-123 ", &lower, &upper) == -EINVAL);
1136 assert_se(lower == 9999);
1137 assert_se(upper == 9999);
1138
1139 assert_se(parse_range("111 -123", &lower, &upper) == -EINVAL);
1140 assert_se(lower == 9999);
1141 assert_se(upper == 9999);
1142
1143 assert_se(parse_range("111 -123 ", &lower, &upper) == -EINVAL);
1144 assert_se(lower == 9999);
1145 assert_se(upper == 9999);
1146
1147 assert_se(parse_range("111\t-123\t", &lower, &upper) == -EINVAL);
1148 assert_se(lower == 9999);
1149 assert_se(upper == 9999);
1150
1151 assert_se(parse_range("111 \t -123 \t ", &lower, &upper) == -EINVAL);
1152 assert_se(lower == 9999);
1153 assert_se(upper == 9999);
1154
1155 /* Out of the "unsigned" range, this is 1<<64 */
1156 assert_se(parse_range("0-18446744073709551616", &lower, &upper) == -ERANGE);
1157 assert_se(lower == 9999);
1158 assert_se(upper == 9999);
1159 }
1160
1161 static void test_parse_cpu_set(void) {
1162 cpu_set_t *c = NULL;
1163 int ncpus;
1164 int cpu;
1165
1166 /* Simple range (from CPUAffinity example) */
1167 ncpus = parse_cpu_set_and_warn("1 2", &c, NULL, "fake", 1, "CPUAffinity");
1168 assert_se(ncpus >= 1024);
1169 assert_se(CPU_ISSET_S(1, CPU_ALLOC_SIZE(ncpus), c));
1170 assert_se(CPU_ISSET_S(2, CPU_ALLOC_SIZE(ncpus), c));
1171 assert_se(CPU_COUNT_S(CPU_ALLOC_SIZE(ncpus), c) == 2);
1172 c = mfree(c);
1173
1174 /* A more interesting range */
1175 ncpus = parse_cpu_set_and_warn("0 1 2 3 8 9 10 11", &c, NULL, "fake", 1, "CPUAffinity");
1176 assert_se(ncpus >= 1024);
1177 assert_se(CPU_COUNT_S(CPU_ALLOC_SIZE(ncpus), c) == 8);
1178 for (cpu = 0; cpu < 4; cpu++)
1179 assert_se(CPU_ISSET_S(cpu, CPU_ALLOC_SIZE(ncpus), c));
1180 for (cpu = 8; cpu < 12; cpu++)
1181 assert_se(CPU_ISSET_S(cpu, CPU_ALLOC_SIZE(ncpus), c));
1182 c = mfree(c);
1183
1184 /* Quoted strings */
1185 ncpus = parse_cpu_set_and_warn("8 '9' 10 \"11\"", &c, NULL, "fake", 1, "CPUAffinity");
1186 assert_se(ncpus >= 1024);
1187 assert_se(CPU_COUNT_S(CPU_ALLOC_SIZE(ncpus), c) == 4);
1188 for (cpu = 8; cpu < 12; cpu++)
1189 assert_se(CPU_ISSET_S(cpu, CPU_ALLOC_SIZE(ncpus), c));
1190 c = mfree(c);
1191
1192 /* Use commas as separators */
1193 ncpus = parse_cpu_set_and_warn("0,1,2,3 8,9,10,11", &c, NULL, "fake", 1, "CPUAffinity");
1194 assert_se(ncpus >= 1024);
1195 assert_se(CPU_COUNT_S(CPU_ALLOC_SIZE(ncpus), c) == 8);
1196 for (cpu = 0; cpu < 4; cpu++)
1197 assert_se(CPU_ISSET_S(cpu, CPU_ALLOC_SIZE(ncpus), c));
1198 for (cpu = 8; cpu < 12; cpu++)
1199 assert_se(CPU_ISSET_S(cpu, CPU_ALLOC_SIZE(ncpus), c));
1200 c = mfree(c);
1201
1202 /* Commas with spaces (and trailing comma, space) */
1203 ncpus = parse_cpu_set_and_warn("0, 1, 2, 3, 4, 5, 6, 7, ", &c, NULL, "fake", 1, "CPUAffinity");
1204 assert_se(ncpus >= 1024);
1205 assert_se(CPU_COUNT_S(CPU_ALLOC_SIZE(ncpus), c) == 8);
1206 for (cpu = 0; cpu < 8; cpu++)
1207 assert_se(CPU_ISSET_S(cpu, CPU_ALLOC_SIZE(ncpus), c));
1208 c = mfree(c);
1209
1210 /* Ranges */
1211 ncpus = parse_cpu_set_and_warn("0-3,8-11", &c, NULL, "fake", 1, "CPUAffinity");
1212 assert_se(ncpus < 0);
1213 assert_se(!c);
1214
1215 /* Garbage */
1216 ncpus = parse_cpu_set_and_warn("0 1 2 3 garbage", &c, NULL, "fake", 1, "CPUAffinity");
1217 assert_se(ncpus < 0);
1218 assert_se(!c);
1219
1220 /* Empty string */
1221 c = NULL;
1222 ncpus = parse_cpu_set_and_warn("", &c, NULL, "fake", 1, "CPUAffinity");
1223 assert_se(ncpus == 0); /* empty string returns 0 */
1224 assert_se(!c);
1225
1226 /* Runnaway quoted string */
1227 ncpus = parse_cpu_set_and_warn("0 1 2 3 \"4 5 6 7 ", &c, NULL, "fake", 1, "CPUAffinity");
1228 assert_se(ncpus < 0);
1229 assert_se(!c);
1230 }
1231
1232 static void test_config_parse_iec_uint64(void) {
1233 uint64_t offset = 0;
1234 assert_se(config_parse_iec_uint64(NULL, "/this/file", 11, "Section", 22, "Size", 0, "4M", &offset, NULL) == 0);
1235 assert_se(offset == 4 * 1024 * 1024);
1236
1237 assert_se(config_parse_iec_uint64(NULL, "/this/file", 11, "Section", 22, "Size", 0, "4.5M", &offset, NULL) == 0);
1238 }
1239
1240 static void test_strextend(void) {
1241 _cleanup_free_ char *str = strdup("0123");
1242 strextend(&str, "456", "78", "9", NULL);
1243 assert_se(streq(str, "0123456789"));
1244 }
1245
1246 static void test_strrep(void) {
1247 _cleanup_free_ char *one, *three, *zero;
1248 one = strrep("waldo", 1);
1249 three = strrep("waldo", 3);
1250 zero = strrep("waldo", 0);
1251
1252 assert_se(streq(one, "waldo"));
1253 assert_se(streq(three, "waldowaldowaldo"));
1254 assert_se(streq(zero, ""));
1255 }
1256
1257 static void test_split_pair(void) {
1258 _cleanup_free_ char *a = NULL, *b = NULL;
1259
1260 assert_se(split_pair("", "", &a, &b) == -EINVAL);
1261 assert_se(split_pair("foo=bar", "", &a, &b) == -EINVAL);
1262 assert_se(split_pair("", "=", &a, &b) == -EINVAL);
1263 assert_se(split_pair("foo=bar", "=", &a, &b) >= 0);
1264 assert_se(streq(a, "foo"));
1265 assert_se(streq(b, "bar"));
1266 free(a);
1267 free(b);
1268 assert_se(split_pair("==", "==", &a, &b) >= 0);
1269 assert_se(streq(a, ""));
1270 assert_se(streq(b, ""));
1271 free(a);
1272 free(b);
1273
1274 assert_se(split_pair("===", "==", &a, &b) >= 0);
1275 assert_se(streq(a, ""));
1276 assert_se(streq(b, "="));
1277 }
1278
1279 static void test_fstab_node_to_udev_node(void) {
1280 char *n;
1281
1282 n = fstab_node_to_udev_node("LABEL=applé/jack");
1283 puts(n);
1284 assert_se(streq(n, "/dev/disk/by-label/applé\\x2fjack"));
1285 free(n);
1286
1287 n = fstab_node_to_udev_node("PARTLABEL=pinkié pie");
1288 puts(n);
1289 assert_se(streq(n, "/dev/disk/by-partlabel/pinkié\\x20pie"));
1290 free(n);
1291
1292 n = fstab_node_to_udev_node("UUID=037b9d94-148e-4ee4-8d38-67bfe15bb535");
1293 puts(n);
1294 assert_se(streq(n, "/dev/disk/by-uuid/037b9d94-148e-4ee4-8d38-67bfe15bb535"));
1295 free(n);
1296
1297 n = fstab_node_to_udev_node("PARTUUID=037b9d94-148e-4ee4-8d38-67bfe15bb535");
1298 puts(n);
1299 assert_se(streq(n, "/dev/disk/by-partuuid/037b9d94-148e-4ee4-8d38-67bfe15bb535"));
1300 free(n);
1301
1302 n = fstab_node_to_udev_node("PONIES=awesome");
1303 puts(n);
1304 assert_se(streq(n, "PONIES=awesome"));
1305 free(n);
1306
1307 n = fstab_node_to_udev_node("/dev/xda1");
1308 puts(n);
1309 assert_se(streq(n, "/dev/xda1"));
1310 free(n);
1311 }
1312
1313 static void test_get_files_in_directory(void) {
1314 _cleanup_strv_free_ char **l = NULL, **t = NULL;
1315
1316 assert_se(get_files_in_directory("/tmp", &l) >= 0);
1317 assert_se(get_files_in_directory(".", &t) >= 0);
1318 assert_se(get_files_in_directory(".", NULL) >= 0);
1319 }
1320
1321 static void test_in_set(void) {
1322 assert_se(IN_SET(1, 1));
1323 assert_se(IN_SET(1, 1, 2, 3, 4));
1324 assert_se(IN_SET(2, 1, 2, 3, 4));
1325 assert_se(IN_SET(3, 1, 2, 3, 4));
1326 assert_se(IN_SET(4, 1, 2, 3, 4));
1327 assert_se(!IN_SET(0, 1));
1328 assert_se(!IN_SET(0, 1, 2, 3, 4));
1329 }
1330
1331 static void test_writing_tmpfile(void) {
1332 char name[] = "/tmp/test-systemd_writing_tmpfile.XXXXXX";
1333 _cleanup_free_ char *contents = NULL;
1334 size_t size;
1335 int fd, r;
1336 struct iovec iov[3];
1337
1338 IOVEC_SET_STRING(iov[0], "abc\n");
1339 IOVEC_SET_STRING(iov[1], ALPHANUMERICAL "\n");
1340 IOVEC_SET_STRING(iov[2], "");
1341
1342 fd = mkostemp_safe(name, O_RDWR|O_CLOEXEC);
1343 printf("tmpfile: %s", name);
1344
1345 r = writev(fd, iov, 3);
1346 assert_se(r >= 0);
1347
1348 r = read_full_file(name, &contents, &size);
1349 assert_se(r == 0);
1350 printf("contents: %s", contents);
1351 assert_se(streq(contents, "abc\n" ALPHANUMERICAL "\n"));
1352
1353 unlink(name);
1354 }
1355
1356 static void test_hexdump(void) {
1357 uint8_t data[146];
1358 unsigned i;
1359
1360 hexdump(stdout, NULL, 0);
1361 hexdump(stdout, "", 0);
1362 hexdump(stdout, "", 1);
1363 hexdump(stdout, "x", 1);
1364 hexdump(stdout, "x", 2);
1365 hexdump(stdout, "foobar", 7);
1366 hexdump(stdout, "f\nobar", 7);
1367 hexdump(stdout, "xxxxxxxxxxxxxxxxxxxxyz", 23);
1368
1369 for (i = 0; i < ELEMENTSOF(data); i++)
1370 data[i] = i*2;
1371
1372 hexdump(stdout, data, sizeof(data));
1373 }
1374
1375 static void test_log2i(void) {
1376 assert_se(log2i(1) == 0);
1377 assert_se(log2i(2) == 1);
1378 assert_se(log2i(3) == 1);
1379 assert_se(log2i(4) == 2);
1380 assert_se(log2i(32) == 5);
1381 assert_se(log2i(33) == 5);
1382 assert_se(log2i(63) == 5);
1383 assert_se(log2i(INT_MAX) == sizeof(int)*8-2);
1384 }
1385
1386 static void test_foreach_string(void) {
1387 const char * const t[] = {
1388 "foo",
1389 "bar",
1390 "waldo",
1391 NULL
1392 };
1393 const char *x;
1394 unsigned i = 0;
1395
1396 FOREACH_STRING(x, "foo", "bar", "waldo")
1397 assert_se(streq_ptr(t[i++], x));
1398
1399 assert_se(i == 3);
1400
1401 FOREACH_STRING(x, "zzz")
1402 assert_se(streq(x, "zzz"));
1403 }
1404
1405 static void test_filename_is_valid(void) {
1406 char foo[FILENAME_MAX+2];
1407 int i;
1408
1409 assert_se(!filename_is_valid(""));
1410 assert_se(!filename_is_valid("/bar/foo"));
1411 assert_se(!filename_is_valid("/"));
1412 assert_se(!filename_is_valid("."));
1413 assert_se(!filename_is_valid(".."));
1414
1415 for (i=0; i<FILENAME_MAX+1; i++)
1416 foo[i] = 'a';
1417 foo[FILENAME_MAX+1] = '\0';
1418
1419 assert_se(!filename_is_valid(foo));
1420
1421 assert_se(filename_is_valid("foo_bar-333"));
1422 assert_se(filename_is_valid("o.o"));
1423 }
1424
1425 static void test_string_has_cc(void) {
1426 assert_se(string_has_cc("abc\1", NULL));
1427 assert_se(string_has_cc("abc\x7f", NULL));
1428 assert_se(string_has_cc("abc\x7f", NULL));
1429 assert_se(string_has_cc("abc\t\x7f", "\t"));
1430 assert_se(string_has_cc("abc\t\x7f", "\t"));
1431 assert_se(string_has_cc("\x7f", "\t"));
1432 assert_se(string_has_cc("\x7f", "\t\a"));
1433
1434 assert_se(!string_has_cc("abc\t\t", "\t"));
1435 assert_se(!string_has_cc("abc\t\t\a", "\t\a"));
1436 assert_se(!string_has_cc("a\ab\tc", "\t\a"));
1437 }
1438
1439 static void test_ascii_strlower(void) {
1440 char a[] = "AabBcC Jk Ii Od LKJJJ kkd LK";
1441 assert_se(streq(ascii_strlower(a), "aabbcc jk ii od lkjjj kkd lk"));
1442 }
1443
1444 static void test_files_same(void) {
1445 _cleanup_close_ int fd = -1;
1446 char name[] = "/tmp/test-files_same.XXXXXX";
1447 char name_alias[] = "/tmp/test-files_same.alias";
1448
1449 fd = mkostemp_safe(name, O_RDWR|O_CLOEXEC);
1450 assert_se(fd >= 0);
1451 assert_se(symlink(name, name_alias) >= 0);
1452
1453 assert_se(files_same(name, name));
1454 assert_se(files_same(name, name_alias));
1455
1456 unlink(name);
1457 unlink(name_alias);
1458 }
1459
1460 static void test_is_valid_documentation_url(void) {
1461 assert_se(documentation_url_is_valid("http://www.freedesktop.org/wiki/Software/systemd"));
1462 assert_se(documentation_url_is_valid("https://www.kernel.org/doc/Documentation/binfmt_misc.txt"));
1463 assert_se(documentation_url_is_valid("file:/foo/foo"));
1464 assert_se(documentation_url_is_valid("man:systemd.special(7)"));
1465 assert_se(documentation_url_is_valid("info:bar"));
1466
1467 assert_se(!documentation_url_is_valid("foo:"));
1468 assert_se(!documentation_url_is_valid("info:"));
1469 assert_se(!documentation_url_is_valid(""));
1470 }
1471
1472 static void test_file_in_same_dir(void) {
1473 char *t;
1474
1475 t = file_in_same_dir("/", "a");
1476 assert_se(streq(t, "/a"));
1477 free(t);
1478
1479 t = file_in_same_dir("/", "/a");
1480 assert_se(streq(t, "/a"));
1481 free(t);
1482
1483 t = file_in_same_dir("", "a");
1484 assert_se(streq(t, "a"));
1485 free(t);
1486
1487 t = file_in_same_dir("a/", "a");
1488 assert_se(streq(t, "a/a"));
1489 free(t);
1490
1491 t = file_in_same_dir("bar/foo", "bar");
1492 assert_se(streq(t, "bar/bar"));
1493 free(t);
1494 }
1495
1496 static void test_endswith(void) {
1497 assert_se(endswith("foobar", "bar"));
1498 assert_se(endswith("foobar", ""));
1499 assert_se(endswith("foobar", "foobar"));
1500 assert_se(endswith("", ""));
1501
1502 assert_se(!endswith("foobar", "foo"));
1503 assert_se(!endswith("foobar", "foobarfoofoo"));
1504 }
1505
1506 static void test_endswith_no_case(void) {
1507 assert_se(endswith_no_case("fooBAR", "bar"));
1508 assert_se(endswith_no_case("foobar", ""));
1509 assert_se(endswith_no_case("foobar", "FOOBAR"));
1510 assert_se(endswith_no_case("", ""));
1511
1512 assert_se(!endswith_no_case("foobar", "FOO"));
1513 assert_se(!endswith_no_case("foobar", "FOOBARFOOFOO"));
1514 }
1515
1516 static void test_close_nointr(void) {
1517 char name[] = "/tmp/test-test-close_nointr.XXXXXX";
1518 int fd;
1519
1520 fd = mkostemp_safe(name, O_RDWR|O_CLOEXEC);
1521 assert_se(fd >= 0);
1522 assert_se(close_nointr(fd) >= 0);
1523 assert_se(close_nointr(fd) < 0);
1524
1525 unlink(name);
1526 }
1527
1528
1529 static void test_unlink_noerrno(void) {
1530 char name[] = "/tmp/test-close_nointr.XXXXXX";
1531 int fd;
1532
1533 fd = mkostemp_safe(name, O_RDWR|O_CLOEXEC);
1534 assert_se(fd >= 0);
1535 assert_se(close_nointr(fd) >= 0);
1536
1537 {
1538 PROTECT_ERRNO;
1539 errno = -42;
1540 assert_se(unlink_noerrno(name) >= 0);
1541 assert_se(errno == -42);
1542 assert_se(unlink_noerrno(name) < 0);
1543 assert_se(errno == -42);
1544 }
1545 }
1546
1547 static void test_readlink_and_make_absolute(void) {
1548 char tempdir[] = "/tmp/test-readlink_and_make_absolute";
1549 char name[] = "/tmp/test-readlink_and_make_absolute/original";
1550 char name2[] = "test-readlink_and_make_absolute/original";
1551 char name_alias[] = "/tmp/test-readlink_and_make_absolute-alias";
1552 char *r = NULL;
1553
1554 assert_se(mkdir_safe(tempdir, 0755, getuid(), getgid()) >= 0);
1555 assert_se(touch(name) >= 0);
1556
1557 assert_se(symlink(name, name_alias) >= 0);
1558 assert_se(readlink_and_make_absolute(name_alias, &r) >= 0);
1559 assert_se(streq(r, name));
1560 free(r);
1561 assert_se(unlink(name_alias) >= 0);
1562
1563 assert_se(chdir(tempdir) >= 0);
1564 assert_se(symlink(name2, name_alias) >= 0);
1565 assert_se(readlink_and_make_absolute(name_alias, &r) >= 0);
1566 assert_se(streq(r, name));
1567 free(r);
1568 assert_se(unlink(name_alias) >= 0);
1569
1570 assert_se(rm_rf(tempdir, REMOVE_ROOT|REMOVE_PHYSICAL) >= 0);
1571 }
1572
1573 static void test_ignore_signals(void) {
1574 assert_se(ignore_signals(SIGINT, -1) >= 0);
1575 assert_se(kill(getpid(), SIGINT) >= 0);
1576 assert_se(ignore_signals(SIGUSR1, SIGUSR2, SIGTERM, SIGPIPE, -1) >= 0);
1577 assert_se(kill(getpid(), SIGUSR1) >= 0);
1578 assert_se(kill(getpid(), SIGUSR2) >= 0);
1579 assert_se(kill(getpid(), SIGTERM) >= 0);
1580 assert_se(kill(getpid(), SIGPIPE) >= 0);
1581 assert_se(default_signals(SIGINT, SIGUSR1, SIGUSR2, SIGTERM, SIGPIPE, -1) >= 0);
1582 }
1583
1584 static void test_strshorten(void) {
1585 char s[] = "foobar";
1586
1587 assert_se(strlen(strshorten(s, 6)) == 6);
1588 assert_se(strlen(strshorten(s, 12)) == 6);
1589 assert_se(strlen(strshorten(s, 2)) == 2);
1590 assert_se(strlen(strshorten(s, 0)) == 0);
1591 }
1592
1593 static void test_strjoina(void) {
1594 char *actual;
1595
1596 actual = strjoina("", "foo", "bar");
1597 assert_se(streq(actual, "foobar"));
1598
1599 actual = strjoina("foo", "bar", "baz");
1600 assert_se(streq(actual, "foobarbaz"));
1601
1602 actual = strjoina("foo", "", "bar", "baz");
1603 assert_se(streq(actual, "foobarbaz"));
1604
1605 actual = strjoina("foo");
1606 assert_se(streq(actual, "foo"));
1607
1608 actual = strjoina(NULL);
1609 assert_se(streq(actual, ""));
1610
1611 actual = strjoina(NULL, "foo");
1612 assert_se(streq(actual, ""));
1613
1614 actual = strjoina("foo", NULL, "bar");
1615 assert_se(streq(actual, "foo"));
1616 }
1617
1618 static void test_is_symlink(void) {
1619 char name[] = "/tmp/test-is_symlink.XXXXXX";
1620 char name_link[] = "/tmp/test-is_symlink.link";
1621 _cleanup_close_ int fd = -1;
1622
1623 fd = mkostemp_safe(name, O_RDWR|O_CLOEXEC);
1624 assert_se(fd >= 0);
1625 assert_se(symlink(name, name_link) >= 0);
1626
1627 assert_se(is_symlink(name) == 0);
1628 assert_se(is_symlink(name_link) == 1);
1629 assert_se(is_symlink("/a/file/which/does/not/exist/i/guess") < 0);
1630
1631
1632 unlink(name);
1633 unlink(name_link);
1634 }
1635
1636 static void test_search_and_fopen(void) {
1637 const char *dirs[] = {"/tmp/foo/bar", "/tmp", NULL};
1638 char name[] = "/tmp/test-search_and_fopen.XXXXXX";
1639 int fd = -1;
1640 int r;
1641 FILE *f;
1642
1643 fd = mkostemp_safe(name, O_RDWR|O_CLOEXEC);
1644 assert_se(fd >= 0);
1645 close(fd);
1646
1647 r = search_and_fopen(basename(name), "r", NULL, dirs, &f);
1648 assert_se(r >= 0);
1649 fclose(f);
1650
1651 r = search_and_fopen(name, "r", NULL, dirs, &f);
1652 assert_se(r >= 0);
1653 fclose(f);
1654
1655 r = search_and_fopen(basename(name), "r", "/", dirs, &f);
1656 assert_se(r >= 0);
1657 fclose(f);
1658
1659 r = search_and_fopen("/a/file/which/does/not/exist/i/guess", "r", NULL, dirs, &f);
1660 assert_se(r < 0);
1661 r = search_and_fopen("afilewhichdoesnotexistiguess", "r", NULL, dirs, &f);
1662 assert_se(r < 0);
1663
1664 r = unlink(name);
1665 assert_se(r == 0);
1666
1667 r = search_and_fopen(basename(name), "r", NULL, dirs, &f);
1668 assert_se(r < 0);
1669 }
1670
1671
1672 static void test_search_and_fopen_nulstr(void) {
1673 const char dirs[] = "/tmp/foo/bar\0/tmp\0";
1674 char name[] = "/tmp/test-search_and_fopen.XXXXXX";
1675 int fd = -1;
1676 int r;
1677 FILE *f;
1678
1679 fd = mkostemp_safe(name, O_RDWR|O_CLOEXEC);
1680 assert_se(fd >= 0);
1681 close(fd);
1682
1683 r = search_and_fopen_nulstr(basename(name), "r", NULL, dirs, &f);
1684 assert_se(r >= 0);
1685 fclose(f);
1686
1687 r = search_and_fopen_nulstr(name, "r", NULL, dirs, &f);
1688 assert_se(r >= 0);
1689 fclose(f);
1690
1691 r = search_and_fopen_nulstr("/a/file/which/does/not/exist/i/guess", "r", NULL, dirs, &f);
1692 assert_se(r < 0);
1693 r = search_and_fopen_nulstr("afilewhichdoesnotexistiguess", "r", NULL, dirs, &f);
1694 assert_se(r < 0);
1695
1696 r = unlink(name);
1697 assert_se(r == 0);
1698
1699 r = search_and_fopen_nulstr(basename(name), "r", NULL, dirs, &f);
1700 assert_se(r < 0);
1701 }
1702
1703 static void test_glob_exists(void) {
1704 char name[] = "/tmp/test-glob_exists.XXXXXX";
1705 int fd = -1;
1706 int r;
1707
1708 fd = mkostemp_safe(name, O_RDWR|O_CLOEXEC);
1709 assert_se(fd >= 0);
1710 close(fd);
1711
1712 r = glob_exists("/tmp/test-glob_exists*");
1713 assert_se(r == 1);
1714
1715 r = unlink(name);
1716 assert_se(r == 0);
1717 r = glob_exists("/tmp/test-glob_exists*");
1718 assert_se(r == 0);
1719 }
1720
1721 static void test_execute_directory(void) {
1722 char template_lo[] = "/tmp/test-readlink_and_make_absolute-lo.XXXXXXX";
1723 char template_hi[] = "/tmp/test-readlink_and_make_absolute-hi.XXXXXXX";
1724 const char * dirs[] = {template_hi, template_lo, NULL};
1725 const char *name, *name2, *name3, *overridden, *override, *masked, *mask;
1726
1727 assert_se(mkdtemp(template_lo));
1728 assert_se(mkdtemp(template_hi));
1729
1730 name = strjoina(template_lo, "/script");
1731 name2 = strjoina(template_hi, "/script2");
1732 name3 = strjoina(template_lo, "/useless");
1733 overridden = strjoina(template_lo, "/overridden");
1734 override = strjoina(template_hi, "/overridden");
1735 masked = strjoina(template_lo, "/masked");
1736 mask = strjoina(template_hi, "/masked");
1737
1738 assert_se(write_string_file(name, "#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/it_works", WRITE_STRING_FILE_CREATE) == 0);
1739 assert_se(write_string_file(name2, "#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/it_works2", WRITE_STRING_FILE_CREATE) == 0);
1740 assert_se(write_string_file(overridden, "#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/failed", WRITE_STRING_FILE_CREATE) == 0);
1741 assert_se(write_string_file(override, "#!/bin/sh\necho 'Executing '$0", WRITE_STRING_FILE_CREATE) == 0);
1742 assert_se(write_string_file(masked, "#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/failed", WRITE_STRING_FILE_CREATE) == 0);
1743 assert_se(symlink("/dev/null", mask) == 0);
1744 assert_se(chmod(name, 0755) == 0);
1745 assert_se(chmod(name2, 0755) == 0);
1746 assert_se(chmod(overridden, 0755) == 0);
1747 assert_se(chmod(override, 0755) == 0);
1748 assert_se(chmod(masked, 0755) == 0);
1749 assert_se(touch(name3) >= 0);
1750
1751 execute_directories(dirs, DEFAULT_TIMEOUT_USEC, NULL);
1752
1753 assert_se(chdir(template_lo) == 0);
1754 assert_se(access("it_works", F_OK) >= 0);
1755 assert_se(access("failed", F_OK) < 0);
1756
1757 assert_se(chdir(template_hi) == 0);
1758 assert_se(access("it_works2", F_OK) >= 0);
1759 assert_se(access("failed", F_OK) < 0);
1760
1761 (void) rm_rf(template_lo, REMOVE_ROOT|REMOVE_PHYSICAL);
1762 (void) rm_rf(template_hi, REMOVE_ROOT|REMOVE_PHYSICAL);
1763 }
1764
1765 static void test_extract_first_word(void) {
1766 const char *p, *original;
1767 char *t;
1768
1769 p = original = "foobar waldo";
1770 assert_se(extract_first_word(&p, &t, NULL, 0) > 0);
1771 assert_se(streq(t, "foobar"));
1772 free(t);
1773 assert_se(p == original + 7);
1774
1775 assert_se(extract_first_word(&p, &t, NULL, 0) > 0);
1776 assert_se(streq(t, "waldo"));
1777 free(t);
1778 assert_se(isempty(p));
1779
1780 assert_se(extract_first_word(&p, &t, NULL, 0) == 0);
1781 assert_se(!t);
1782 assert_se(isempty(p));
1783
1784 p = original = "\"foobar\" \'waldo\'";
1785 assert_se(extract_first_word(&p, &t, NULL, 0) > 0);
1786 assert_se(streq(t, "\"foobar\""));
1787 free(t);
1788 assert_se(p == original + 9);
1789
1790 assert_se(extract_first_word(&p, &t, NULL, 0) > 0);
1791 assert_se(streq(t, "\'waldo\'"));
1792 free(t);
1793 assert_se(isempty(p));
1794
1795 assert_se(extract_first_word(&p, &t, NULL, 0) == 0);
1796 assert_se(!t);
1797 assert_se(isempty(p));
1798
1799 p = original = "\"foobar\" \'waldo\'";
1800 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_QUOTES) > 0);
1801 assert_se(streq(t, "foobar"));
1802 free(t);
1803 assert_se(p == original + 9);
1804
1805 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_QUOTES) > 0);
1806 assert_se(streq(t, "waldo"));
1807 free(t);
1808 assert_se(isempty(p));
1809
1810 assert_se(extract_first_word(&p, &t, NULL, 0) == 0);
1811 assert_se(!t);
1812 assert_se(isempty(p));
1813
1814 p = original = "\"";
1815 assert_se(extract_first_word(&p, &t, NULL, 0) == 1);
1816 assert_se(streq(t, "\""));
1817 free(t);
1818 assert_se(isempty(p));
1819
1820 p = original = "\"";
1821 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_QUOTES) == -EINVAL);
1822 assert_se(p == original + 1);
1823
1824 p = original = "\'";
1825 assert_se(extract_first_word(&p, &t, NULL, 0) == 1);
1826 assert_se(streq(t, "\'"));
1827 free(t);
1828 assert_se(isempty(p));
1829
1830 p = original = "\'";
1831 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_QUOTES) == -EINVAL);
1832 assert_se(p == original + 1);
1833
1834 p = original = "\'fooo";
1835 assert_se(extract_first_word(&p, &t, NULL, 0) == 1);
1836 assert_se(streq(t, "\'fooo"));
1837 free(t);
1838 assert_se(isempty(p));
1839
1840 p = original = "\'fooo";
1841 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_QUOTES) == -EINVAL);
1842 assert_se(p == original + 5);
1843
1844 p = original = "\'fooo";
1845 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_QUOTES|EXTRACT_RELAX) > 0);
1846 assert_se(streq(t, "fooo"));
1847 free(t);
1848 assert_se(isempty(p));
1849
1850 p = original = "\"fooo";
1851 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_QUOTES|EXTRACT_RELAX) > 0);
1852 assert_se(streq(t, "fooo"));
1853 free(t);
1854 assert_se(isempty(p));
1855
1856 p = original = "yay\'foo\'bar";
1857 assert_se(extract_first_word(&p, &t, NULL, 0) > 0);
1858 assert_se(streq(t, "yay\'foo\'bar"));
1859 free(t);
1860 assert_se(isempty(p));
1861
1862 p = original = "yay\'foo\'bar";
1863 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_QUOTES) > 0);
1864 assert_se(streq(t, "yayfoobar"));
1865 free(t);
1866 assert_se(isempty(p));
1867
1868 p = original = " foobar ";
1869 assert_se(extract_first_word(&p, &t, NULL, 0) > 0);
1870 assert_se(streq(t, "foobar"));
1871 free(t);
1872 assert_se(isempty(p));
1873
1874 p = original = " foo\\ba\\x6ar ";
1875 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_CUNESCAPE) > 0);
1876 assert_se(streq(t, "foo\ba\x6ar"));
1877 free(t);
1878 assert_se(isempty(p));
1879
1880 p = original = " foo\\ba\\x6ar ";
1881 assert_se(extract_first_word(&p, &t, NULL, 0) > 0);
1882 assert_se(streq(t, "foobax6ar"));
1883 free(t);
1884 assert_se(isempty(p));
1885
1886 p = original = " f\\u00f6o \"pi\\U0001F4A9le\" ";
1887 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_CUNESCAPE) > 0);
1888 assert_se(streq(t, "föo"));
1889 free(t);
1890 assert_se(p == original + 13);
1891
1892 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_QUOTES|EXTRACT_CUNESCAPE) > 0);
1893 assert_se(streq(t, "pi\360\237\222\251le"));
1894 free(t);
1895 assert_se(isempty(p));
1896
1897 p = original = "fooo\\";
1898 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_RELAX) > 0);
1899 assert_se(streq(t, "fooo"));
1900 free(t);
1901 assert_se(isempty(p));
1902
1903 p = original = "fooo\\";
1904 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_CUNESCAPE_RELAX) > 0);
1905 assert_se(streq(t, "fooo\\"));
1906 free(t);
1907 assert_se(isempty(p));
1908
1909 p = original = "fooo\\";
1910 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_CUNESCAPE_RELAX|EXTRACT_RELAX) > 0);
1911 assert_se(streq(t, "fooo\\"));
1912 free(t);
1913 assert_se(isempty(p));
1914
1915 p = original = "fooo\\";
1916 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_CUNESCAPE|EXTRACT_CUNESCAPE_RELAX) > 0);
1917 assert_se(streq(t, "fooo\\"));
1918 free(t);
1919 assert_se(isempty(p));
1920
1921 p = original = "\"foo\\";
1922 assert_se(extract_first_word(&p, &t, NULL, 0) == -EINVAL);
1923 assert_se(p == original + 5);
1924
1925 p = original = "\"foo\\";
1926 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_QUOTES|EXTRACT_RELAX) > 0);
1927 assert_se(streq(t, "foo"));
1928 free(t);
1929 assert_se(isempty(p));
1930
1931 p = original = "foo::bar";
1932 assert_se(extract_first_word(&p, &t, ":", 0) == 1);
1933 assert_se(streq(t, "foo"));
1934 free(t);
1935 assert_se(p == original + 5);
1936
1937 assert_se(extract_first_word(&p, &t, ":", 0) == 1);
1938 assert_se(streq(t, "bar"));
1939 free(t);
1940 assert_se(isempty(p));
1941
1942 assert_se(extract_first_word(&p, &t, ":", 0) == 0);
1943 assert_se(!t);
1944 assert_se(isempty(p));
1945
1946 p = original = "foo\\:bar::waldo";
1947 assert_se(extract_first_word(&p, &t, ":", 0) == 1);
1948 assert_se(streq(t, "foo:bar"));
1949 free(t);
1950 assert_se(p == original + 10);
1951
1952 assert_se(extract_first_word(&p, &t, ":", 0) == 1);
1953 assert_se(streq(t, "waldo"));
1954 free(t);
1955 assert_se(isempty(p));
1956
1957 assert_se(extract_first_word(&p, &t, ":", 0) == 0);
1958 assert_se(!t);
1959 assert_se(isempty(p));
1960
1961 p = original = "\"foo\\";
1962 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_QUOTES|EXTRACT_CUNESCAPE_RELAX) == -EINVAL);
1963 assert_se(p == original + 5);
1964
1965 p = original = "\"foo\\";
1966 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_QUOTES|EXTRACT_CUNESCAPE_RELAX|EXTRACT_RELAX) > 0);
1967 assert_se(streq(t, "foo\\"));
1968 free(t);
1969 assert_se(isempty(p));
1970
1971 p = original = "\"foo\\";
1972 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_QUOTES|EXTRACT_CUNESCAPE|EXTRACT_CUNESCAPE_RELAX|EXTRACT_RELAX) > 0);
1973 assert_se(streq(t, "foo\\"));
1974 free(t);
1975 assert_se(isempty(p));
1976
1977 p = original = "fooo\\ bar quux";
1978 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_RELAX) > 0);
1979 assert_se(streq(t, "fooo bar"));
1980 free(t);
1981 assert_se(p == original + 10);
1982
1983 p = original = "fooo\\ bar quux";
1984 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_CUNESCAPE_RELAX) > 0);
1985 assert_se(streq(t, "fooo bar"));
1986 free(t);
1987 assert_se(p == original + 10);
1988
1989 p = original = "fooo\\ bar quux";
1990 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_CUNESCAPE_RELAX|EXTRACT_RELAX) > 0);
1991 assert_se(streq(t, "fooo bar"));
1992 free(t);
1993 assert_se(p == original + 10);
1994
1995 p = original = "fooo\\ bar quux";
1996 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_CUNESCAPE) == -EINVAL);
1997 assert_se(p == original + 5);
1998
1999 p = original = "fooo\\ bar quux";
2000 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_CUNESCAPE|EXTRACT_CUNESCAPE_RELAX) > 0);
2001 assert_se(streq(t, "fooo\\ bar"));
2002 free(t);
2003 assert_se(p == original + 10);
2004
2005 p = original = "\\w+@\\K[\\d.]+";
2006 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_CUNESCAPE) == -EINVAL);
2007 assert_se(p == original + 1);
2008
2009 p = original = "\\w+@\\K[\\d.]+";
2010 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_CUNESCAPE|EXTRACT_CUNESCAPE_RELAX) > 0);
2011 assert_se(streq(t, "\\w+@\\K[\\d.]+"));
2012 free(t);
2013 assert_se(isempty(p));
2014
2015 p = original = "\\w+\\b";
2016 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_CUNESCAPE|EXTRACT_CUNESCAPE_RELAX) > 0);
2017 assert_se(streq(t, "\\w+\b"));
2018 free(t);
2019 assert_se(isempty(p));
2020
2021 p = original = "-N ''";
2022 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_QUOTES) > 0);
2023 assert_se(streq(t, "-N"));
2024 free(t);
2025 assert_se(p == original + 3);
2026
2027 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_QUOTES) > 0);
2028 assert_se(streq(t, ""));
2029 free(t);
2030 assert_se(isempty(p));
2031
2032 p = original = ":foo\\:bar::waldo:";
2033 assert_se(extract_first_word(&p, &t, ":", EXTRACT_DONT_COALESCE_SEPARATORS) == 1);
2034 assert_se(t);
2035 assert_se(streq(t, ""));
2036 free(t);
2037 assert_se(p == original + 1);
2038
2039 assert_se(extract_first_word(&p, &t, ":", EXTRACT_DONT_COALESCE_SEPARATORS) == 1);
2040 assert_se(streq(t, "foo:bar"));
2041 free(t);
2042 assert_se(p == original + 10);
2043
2044 assert_se(extract_first_word(&p, &t, ":", EXTRACT_DONT_COALESCE_SEPARATORS) == 1);
2045 assert_se(t);
2046 assert_se(streq(t, ""));
2047 free(t);
2048 assert_se(p == original + 11);
2049
2050 assert_se(extract_first_word(&p, &t, ":", EXTRACT_DONT_COALESCE_SEPARATORS) == 1);
2051 assert_se(streq(t, "waldo"));
2052 free(t);
2053 assert_se(p == original + 17);
2054
2055 assert_se(extract_first_word(&p, &t, ":", EXTRACT_DONT_COALESCE_SEPARATORS) == 1);
2056 assert_se(streq(t, ""));
2057 free(t);
2058 assert_se(p == NULL);
2059
2060 assert_se(extract_first_word(&p, &t, ":", EXTRACT_DONT_COALESCE_SEPARATORS) == 0);
2061 assert_se(!t);
2062 assert_se(!p);
2063 }
2064
2065 static void test_extract_first_word_and_warn(void) {
2066 const char *p, *original;
2067 char *t;
2068
2069 p = original = "foobar waldo";
2070 assert_se(extract_first_word_and_warn(&p, &t, NULL, 0, NULL, "fake", 1, original) > 0);
2071 assert_se(streq(t, "foobar"));
2072 free(t);
2073 assert_se(p == original + 7);
2074
2075 assert_se(extract_first_word_and_warn(&p, &t, NULL, 0, NULL, "fake", 1, original) > 0);
2076 assert_se(streq(t, "waldo"));
2077 free(t);
2078 assert_se(isempty(p));
2079
2080 assert_se(extract_first_word_and_warn(&p, &t, NULL, 0, NULL, "fake", 1, original) == 0);
2081 assert_se(!t);
2082 assert_se(isempty(p));
2083
2084 p = original = "\"foobar\" \'waldo\'";
2085 assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_QUOTES, NULL, "fake", 1, original) > 0);
2086 assert_se(streq(t, "foobar"));
2087 free(t);
2088 assert_se(p == original + 9);
2089
2090 assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_QUOTES, NULL, "fake", 1, original) > 0);
2091 assert_se(streq(t, "waldo"));
2092 free(t);
2093 assert_se(isempty(p));
2094
2095 assert_se(extract_first_word_and_warn(&p, &t, NULL, 0, NULL, "fake", 1, original) == 0);
2096 assert_se(!t);
2097 assert_se(isempty(p));
2098
2099 p = original = "\"";
2100 assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_QUOTES, NULL, "fake", 1, original) == -EINVAL);
2101 assert_se(p == original + 1);
2102
2103 p = original = "\'";
2104 assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_QUOTES, NULL, "fake", 1, original) == -EINVAL);
2105 assert_se(p == original + 1);
2106
2107 p = original = "\'fooo";
2108 assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_QUOTES, NULL, "fake", 1, original) == -EINVAL);
2109 assert_se(p == original + 5);
2110
2111 p = original = "\'fooo";
2112 assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_QUOTES|EXTRACT_RELAX, NULL, "fake", 1, original) > 0);
2113 assert_se(streq(t, "fooo"));
2114 free(t);
2115 assert_se(isempty(p));
2116
2117 p = original = " foo\\ba\\x6ar ";
2118 assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_CUNESCAPE, NULL, "fake", 1, original) > 0);
2119 assert_se(streq(t, "foo\ba\x6ar"));
2120 free(t);
2121 assert_se(isempty(p));
2122
2123 p = original = " foo\\ba\\x6ar ";
2124 assert_se(extract_first_word_and_warn(&p, &t, NULL, 0, NULL, "fake", 1, original) > 0);
2125 assert_se(streq(t, "foobax6ar"));
2126 free(t);
2127 assert_se(isempty(p));
2128
2129 p = original = " f\\u00f6o \"pi\\U0001F4A9le\" ";
2130 assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_CUNESCAPE, NULL, "fake", 1, original) > 0);
2131 assert_se(streq(t, "föo"));
2132 free(t);
2133 assert_se(p == original + 13);
2134
2135 assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_QUOTES|EXTRACT_CUNESCAPE, NULL, "fake", 1, original) > 0);
2136 assert_se(streq(t, "pi\360\237\222\251le"));
2137 free(t);
2138 assert_se(isempty(p));
2139
2140 p = original = "fooo\\";
2141 assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_RELAX, NULL, "fake", 1, original) > 0);
2142 assert_se(streq(t, "fooo"));
2143 free(t);
2144 assert_se(isempty(p));
2145
2146 p = original = "fooo\\";
2147 assert_se(extract_first_word_and_warn(&p, &t, NULL, 0, NULL, "fake", 1, original) > 0);
2148 assert_se(streq(t, "fooo\\"));
2149 free(t);
2150 assert_se(isempty(p));
2151
2152 p = original = "fooo\\";
2153 assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_CUNESCAPE, NULL, "fake", 1, original) > 0);
2154 assert_se(streq(t, "fooo\\"));
2155 free(t);
2156 assert_se(isempty(p));
2157
2158 p = original = "\"foo\\";
2159 assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_QUOTES, NULL, "fake", 1, original) == -EINVAL);
2160 assert_se(p == original + 5);
2161
2162 p = original = "\"foo\\";
2163 assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_QUOTES|EXTRACT_RELAX, NULL, "fake", 1, original) > 0);
2164 assert_se(streq(t, "foo"));
2165 free(t);
2166 assert_se(isempty(p));
2167
2168 p = original = "\"foo\\";
2169 assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_QUOTES|EXTRACT_CUNESCAPE, NULL, "fake", 1, original) == -EINVAL);
2170 assert_se(p == original + 5);
2171
2172 p = original = "\"foo\\";
2173 assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_QUOTES|EXTRACT_CUNESCAPE|EXTRACT_RELAX, NULL, "fake", 1, original) > 0);
2174 assert_se(streq(t, "foo"));
2175 free(t);
2176 assert_se(isempty(p));
2177
2178 p = original = "fooo\\ bar quux";
2179 assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_RELAX, NULL, "fake", 1, original) > 0);
2180 assert_se(streq(t, "fooo bar"));
2181 free(t);
2182 assert_se(p == original + 10);
2183
2184 p = original = "fooo\\ bar quux";
2185 assert_se(extract_first_word_and_warn(&p, &t, NULL, 0, NULL, "fake", 1, original) > 0);
2186 assert_se(streq(t, "fooo bar"));
2187 free(t);
2188 assert_se(p == original + 10);
2189
2190 p = original = "fooo\\ bar quux";
2191 assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_CUNESCAPE, NULL, "fake", 1, original) > 0);
2192 assert_se(streq(t, "fooo\\ bar"));
2193 free(t);
2194 assert_se(p == original + 10);
2195
2196 p = original = "\\w+@\\K[\\d.]+";
2197 assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_CUNESCAPE, NULL, "fake", 1, original) > 0);
2198 assert_se(streq(t, "\\w+@\\K[\\d.]+"));
2199 free(t);
2200 assert_se(isempty(p));
2201
2202 p = original = "\\w+\\b";
2203 assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_CUNESCAPE, NULL, "fake", 1, original) > 0);
2204 assert_se(streq(t, "\\w+\b"));
2205 free(t);
2206 assert_se(isempty(p));
2207 }
2208
2209 static void test_extract_many_words(void) {
2210 const char *p, *original;
2211 char *a, *b, *c;
2212
2213 p = original = "foobar waldi piep";
2214 assert_se(extract_many_words(&p, NULL, 0, &a, &b, &c, NULL) == 3);
2215 assert_se(isempty(p));
2216 assert_se(streq_ptr(a, "foobar"));
2217 assert_se(streq_ptr(b, "waldi"));
2218 assert_se(streq_ptr(c, "piep"));
2219 free(a);
2220 free(b);
2221 free(c);
2222
2223 p = original = "'foobar' wa\"ld\"i ";
2224 assert_se(extract_many_words(&p, NULL, 0, &a, &b, &c, NULL) == 2);
2225 assert_se(isempty(p));
2226 assert_se(streq_ptr(a, "'foobar'"));
2227 assert_se(streq_ptr(b, "wa\"ld\"i"));
2228 assert_se(streq_ptr(c, NULL));
2229 free(a);
2230 free(b);
2231
2232 p = original = "'foobar' wa\"ld\"i ";
2233 assert_se(extract_many_words(&p, NULL, EXTRACT_QUOTES, &a, &b, &c, NULL) == 2);
2234 assert_se(isempty(p));
2235 assert_se(streq_ptr(a, "foobar"));
2236 assert_se(streq_ptr(b, "waldi"));
2237 assert_se(streq_ptr(c, NULL));
2238 free(a);
2239 free(b);
2240
2241 p = original = "";
2242 assert_se(extract_many_words(&p, NULL, 0, &a, &b, &c, NULL) == 0);
2243 assert_se(isempty(p));
2244 assert_se(streq_ptr(a, NULL));
2245 assert_se(streq_ptr(b, NULL));
2246 assert_se(streq_ptr(c, NULL));
2247
2248 p = original = " ";
2249 assert_se(extract_many_words(&p, NULL, 0, &a, &b, &c, NULL) == 0);
2250 assert_se(isempty(p));
2251 assert_se(streq_ptr(a, NULL));
2252 assert_se(streq_ptr(b, NULL));
2253 assert_se(streq_ptr(c, NULL));
2254
2255 p = original = "foobar";
2256 assert_se(extract_many_words(&p, NULL, 0, NULL) == 0);
2257 assert_se(p == original);
2258
2259 p = original = "foobar waldi";
2260 assert_se(extract_many_words(&p, NULL, 0, &a, NULL) == 1);
2261 assert_se(p == original+7);
2262 assert_se(streq_ptr(a, "foobar"));
2263 free(a);
2264
2265 p = original = " foobar ";
2266 assert_se(extract_many_words(&p, NULL, 0, &a, NULL) == 1);
2267 assert_se(isempty(p));
2268 assert_se(streq_ptr(a, "foobar"));
2269 free(a);
2270 }
2271
2272 static int parse_item(const char *key, const char *value) {
2273 assert_se(key);
2274
2275 log_info("kernel cmdline option <%s> = <%s>", key, strna(value));
2276 return 0;
2277 }
2278
2279 static void test_parse_proc_cmdline(void) {
2280 assert_se(parse_proc_cmdline(parse_item) >= 0);
2281 }
2282
2283 static void test_raw_clone(void) {
2284 pid_t parent, pid, pid2;
2285
2286 parent = getpid();
2287 log_info("before clone: getpid()→"PID_FMT, parent);
2288 assert_se(raw_getpid() == parent);
2289
2290 pid = raw_clone(0, NULL);
2291 assert_se(pid >= 0);
2292
2293 pid2 = raw_getpid();
2294 log_info("raw_clone: "PID_FMT" getpid()→"PID_FMT" raw_getpid()→"PID_FMT,
2295 pid, getpid(), pid2);
2296 if (pid == 0) {
2297 assert_se(pid2 != parent);
2298 _exit(EXIT_SUCCESS);
2299 } else {
2300 int status;
2301
2302 assert_se(pid2 == parent);
2303 waitpid(pid, &status, __WCLONE);
2304 assert_se(WIFEXITED(status) && WEXITSTATUS(status) == EXIT_SUCCESS);
2305 }
2306 }
2307
2308 static void test_same_fd(void) {
2309 _cleanup_close_pair_ int p[2] = { -1, -1 };
2310 _cleanup_close_ int a = -1, b = -1, c = -1;
2311
2312 assert_se(pipe2(p, O_CLOEXEC) >= 0);
2313 assert_se((a = dup(p[0])) >= 0);
2314 assert_se((b = open("/dev/null", O_RDONLY|O_CLOEXEC)) >= 0);
2315 assert_se((c = dup(a)) >= 0);
2316
2317 assert_se(same_fd(p[0], p[0]) > 0);
2318 assert_se(same_fd(p[1], p[1]) > 0);
2319 assert_se(same_fd(a, a) > 0);
2320 assert_se(same_fd(b, b) > 0);
2321
2322 assert_se(same_fd(a, p[0]) > 0);
2323 assert_se(same_fd(p[0], a) > 0);
2324 assert_se(same_fd(c, p[0]) > 0);
2325 assert_se(same_fd(p[0], c) > 0);
2326 assert_se(same_fd(a, c) > 0);
2327 assert_se(same_fd(c, a) > 0);
2328
2329 assert_se(same_fd(p[0], p[1]) == 0);
2330 assert_se(same_fd(p[1], p[0]) == 0);
2331 assert_se(same_fd(p[0], b) == 0);
2332 assert_se(same_fd(b, p[0]) == 0);
2333 assert_se(same_fd(p[1], a) == 0);
2334 assert_se(same_fd(a, p[1]) == 0);
2335 assert_se(same_fd(p[1], b) == 0);
2336 assert_se(same_fd(b, p[1]) == 0);
2337
2338 assert_se(same_fd(a, b) == 0);
2339 assert_se(same_fd(b, a) == 0);
2340 }
2341
2342 static void test_uid_ptr(void) {
2343
2344 assert_se(UID_TO_PTR(0) != NULL);
2345 assert_se(UID_TO_PTR(1000) != NULL);
2346
2347 assert_se(PTR_TO_UID(UID_TO_PTR(0)) == 0);
2348 assert_se(PTR_TO_UID(UID_TO_PTR(1000)) == 1000);
2349 }
2350
2351 static void test_sparse_write_one(int fd, const char *buffer, size_t n) {
2352 char check[n];
2353
2354 assert_se(lseek(fd, 0, SEEK_SET) == 0);
2355 assert_se(ftruncate(fd, 0) >= 0);
2356 assert_se(sparse_write(fd, buffer, n, 4) == (ssize_t) n);
2357
2358 assert_se(lseek(fd, 0, SEEK_CUR) == (off_t) n);
2359 assert_se(ftruncate(fd, n) >= 0);
2360
2361 assert_se(lseek(fd, 0, SEEK_SET) == 0);
2362 assert_se(read(fd, check, n) == (ssize_t) n);
2363
2364 assert_se(memcmp(buffer, check, n) == 0);
2365 }
2366
2367 static void test_sparse_write(void) {
2368 const char test_a[] = "test";
2369 const char test_b[] = "\0\0\0\0test\0\0\0\0";
2370 const char test_c[] = "\0\0test\0\0\0\0";
2371 const char test_d[] = "\0\0test\0\0\0test\0\0\0\0test\0\0\0\0\0test\0\0\0test\0\0\0\0test\0\0\0\0\0\0\0\0";
2372 const char test_e[] = "test\0\0\0\0test";
2373 _cleanup_close_ int fd = -1;
2374 char fn[] = "/tmp/sparseXXXXXX";
2375
2376 fd = mkostemp(fn, O_CLOEXEC);
2377 assert_se(fd >= 0);
2378 unlink(fn);
2379
2380 test_sparse_write_one(fd, test_a, sizeof(test_a));
2381 test_sparse_write_one(fd, test_b, sizeof(test_b));
2382 test_sparse_write_one(fd, test_c, sizeof(test_c));
2383 test_sparse_write_one(fd, test_d, sizeof(test_d));
2384 test_sparse_write_one(fd, test_e, sizeof(test_e));
2385 }
2386
2387 static void test_shell_escape_one(const char *s, const char *bad, const char *expected) {
2388 _cleanup_free_ char *r;
2389
2390 assert_se(r = shell_escape(s, bad));
2391 assert_se(streq_ptr(r, expected));
2392 }
2393
2394 static void test_shell_escape(void) {
2395 test_shell_escape_one("", "", "");
2396 test_shell_escape_one("\\", "", "\\\\");
2397 test_shell_escape_one("foobar", "", "foobar");
2398 test_shell_escape_one("foobar", "o", "f\\o\\obar");
2399 test_shell_escape_one("foo:bar,baz", ",:", "foo\\:bar\\,baz");
2400 }
2401
2402 static void test_shell_maybe_quote_one(const char *s, const char *expected) {
2403 _cleanup_free_ char *r;
2404
2405 assert_se(r = shell_maybe_quote(s));
2406 assert_se(streq(r, expected));
2407 }
2408
2409 static void test_shell_maybe_quote(void) {
2410
2411 test_shell_maybe_quote_one("", "");
2412 test_shell_maybe_quote_one("\\", "\"\\\\\"");
2413 test_shell_maybe_quote_one("\"", "\"\\\"\"");
2414 test_shell_maybe_quote_one("foobar", "foobar");
2415 test_shell_maybe_quote_one("foo bar", "\"foo bar\"");
2416 test_shell_maybe_quote_one("foo \"bar\" waldo", "\"foo \\\"bar\\\" waldo\"");
2417 test_shell_maybe_quote_one("foo$bar", "\"foo\\$bar\"");
2418 }
2419
2420 static void test_parse_mode(void) {
2421 mode_t m;
2422
2423 assert_se(parse_mode("-1", &m) < 0);
2424 assert_se(parse_mode("", &m) < 0);
2425 assert_se(parse_mode("888", &m) < 0);
2426 assert_se(parse_mode("77777", &m) < 0);
2427
2428 assert_se(parse_mode("544", &m) >= 0 && m == 0544);
2429 assert_se(parse_mode("777", &m) >= 0 && m == 0777);
2430 assert_se(parse_mode("7777", &m) >= 0 && m == 07777);
2431 assert_se(parse_mode("0", &m) >= 0 && m == 0);
2432 }
2433
2434 static void test_tempfn(void) {
2435 char *ret = NULL, *p;
2436
2437 assert_se(tempfn_xxxxxx("/foo/bar/waldo", NULL, &ret) >= 0);
2438 assert_se(streq_ptr(ret, "/foo/bar/.#waldoXXXXXX"));
2439 free(ret);
2440
2441 assert_se(tempfn_xxxxxx("/foo/bar/waldo", "[miau]", &ret) >= 0);
2442 assert_se(streq_ptr(ret, "/foo/bar/.#[miau]waldoXXXXXX"));
2443 free(ret);
2444
2445 assert_se(tempfn_random("/foo/bar/waldo", NULL, &ret) >= 0);
2446 assert_se(p = startswith(ret, "/foo/bar/.#waldo"));
2447 assert_se(strlen(p) == 16);
2448 assert_se(in_charset(p, "0123456789abcdef"));
2449 free(ret);
2450
2451 assert_se(tempfn_random("/foo/bar/waldo", "[wuff]", &ret) >= 0);
2452 assert_se(p = startswith(ret, "/foo/bar/.#[wuff]waldo"));
2453 assert_se(strlen(p) == 16);
2454 assert_se(in_charset(p, "0123456789abcdef"));
2455 free(ret);
2456
2457 assert_se(tempfn_random_child("/foo/bar/waldo", NULL, &ret) >= 0);
2458 assert_se(p = startswith(ret, "/foo/bar/waldo/.#"));
2459 assert_se(strlen(p) == 16);
2460 assert_se(in_charset(p, "0123456789abcdef"));
2461 free(ret);
2462
2463 assert_se(tempfn_random_child("/foo/bar/waldo", "[kikiriki]", &ret) >= 0);
2464 assert_se(p = startswith(ret, "/foo/bar/waldo/.#[kikiriki]"));
2465 assert_se(strlen(p) == 16);
2466 assert_se(in_charset(p, "0123456789abcdef"));
2467 free(ret);
2468 }
2469
2470 static void test_strcmp_ptr(void) {
2471 assert_se(strcmp_ptr(NULL, NULL) == 0);
2472 assert_se(strcmp_ptr("", NULL) > 0);
2473 assert_se(strcmp_ptr("foo", NULL) > 0);
2474 assert_se(strcmp_ptr(NULL, "") < 0);
2475 assert_se(strcmp_ptr(NULL, "bar") < 0);
2476 assert_se(strcmp_ptr("foo", "bar") > 0);
2477 assert_se(strcmp_ptr("bar", "baz") < 0);
2478 assert_se(strcmp_ptr("foo", "foo") == 0);
2479 assert_se(strcmp_ptr("", "") == 0);
2480 }
2481
2482 static void test_fgetxattrat_fake(void) {
2483 char t[] = "/var/tmp/xattrtestXXXXXX";
2484 _cleanup_close_ int fd = -1;
2485 const char *x;
2486 char v[3] = {};
2487 int r;
2488
2489 assert_se(mkdtemp(t));
2490 x = strjoina(t, "/test");
2491 assert_se(touch(x) >= 0);
2492
2493 r = setxattr(x, "user.foo", "bar", 3, 0);
2494 if (r < 0 && errno == EOPNOTSUPP) /* no xattrs supported on /var/tmp... */
2495 goto cleanup;
2496 assert_se(r >= 0);
2497
2498 fd = open(t, O_RDONLY|O_DIRECTORY|O_CLOEXEC|O_NOCTTY);
2499 assert_se(fd >= 0);
2500
2501 assert_se(fgetxattrat_fake(fd, "test", "user.foo", v, 3, 0) >= 0);
2502 assert_se(memcmp(v, "bar", 3) == 0);
2503
2504 safe_close(fd);
2505 fd = open("/", O_RDONLY|O_DIRECTORY|O_CLOEXEC|O_NOCTTY);
2506 assert_se(fd >= 0);
2507 assert_se(fgetxattrat_fake(fd, "usr", "user.idontexist", v, 3, 0) == -ENODATA);
2508
2509 cleanup:
2510 assert_se(unlink(x) >= 0);
2511 assert_se(rmdir(t) >= 0);
2512 }
2513
2514 int main(int argc, char *argv[]) {
2515 log_parse_environment();
2516 log_open();
2517
2518 test_streq_ptr();
2519 test_align_power2();
2520 test_max();
2521 test_container_of();
2522 test_alloca();
2523 test_div_round_up();
2524 test_first_word();
2525 test_close_many();
2526 test_parse_boolean();
2527 test_parse_pid();
2528 test_parse_uid();
2529 test_safe_atou16();
2530 test_safe_atoi16();
2531 test_safe_atolli();
2532 test_safe_atod();
2533 test_strappend();
2534 test_strstrip();
2535 test_delete_chars();
2536 test_in_charset();
2537 test_hexchar();
2538 test_unhexchar();
2539 test_base32hexchar();
2540 test_unbase32hexchar();
2541 test_base64char();
2542 test_unbase64char();
2543 test_octchar();
2544 test_unoctchar();
2545 test_decchar();
2546 test_undecchar();
2547 test_unhexmem();
2548 test_base32hexmem();
2549 test_unbase32hexmem();
2550 test_base64mem();
2551 test_unbase64mem();
2552 test_cescape();
2553 test_cunescape();
2554 test_foreach_word();
2555 test_foreach_word_quoted();
2556 test_memdup_multiply();
2557 test_u64log2();
2558 test_protect_errno();
2559 test_parse_size();
2560 test_parse_range();
2561 test_parse_cpu_set();
2562 test_config_parse_iec_uint64();
2563 test_strextend();
2564 test_strrep();
2565 test_split_pair();
2566 test_fstab_node_to_udev_node();
2567 test_get_files_in_directory();
2568 test_in_set();
2569 test_writing_tmpfile();
2570 test_hexdump();
2571 test_log2i();
2572 test_foreach_string();
2573 test_filename_is_valid();
2574 test_string_has_cc();
2575 test_ascii_strlower();
2576 test_files_same();
2577 test_is_valid_documentation_url();
2578 test_file_in_same_dir();
2579 test_endswith();
2580 test_endswith_no_case();
2581 test_close_nointr();
2582 test_unlink_noerrno();
2583 test_readlink_and_make_absolute();
2584 test_ignore_signals();
2585 test_strshorten();
2586 test_strjoina();
2587 test_is_symlink();
2588 test_search_and_fopen();
2589 test_search_and_fopen_nulstr();
2590 test_glob_exists();
2591 test_execute_directory();
2592 test_extract_first_word();
2593 test_extract_first_word_and_warn();
2594 test_extract_many_words();
2595 test_parse_proc_cmdline();
2596 test_raw_clone();
2597 test_same_fd();
2598 test_uid_ptr();
2599 test_sparse_write();
2600 test_shell_escape();
2601 test_shell_maybe_quote();
2602 test_parse_mode();
2603 test_tempfn();
2604 test_strcmp_ptr();
2605 test_fgetxattrat_fake();
2606
2607 return 0;
2608 }
Unnamed repository; edit this file 'description' to name the repository.