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