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