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