]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/test/test-fileio.c
projects / thirdparty / systemd.git / blob
? search:


e0ae30bbb918815e1181a54961fcc46a5a850da9
[thirdparty/systemd.git] / src / test / test-fileio.c
1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3 #include <fcntl.h>
4 #include <stdio.h>
5 #include <unistd.h>
6
7 #include "alloc-util.h"
8 #include "env-file.h"
9 #include "env-util.h"
10 #include "errno-util.h"
11 #include "fd-util.h"
12 #include "fileio.h"
13 #include "fs-util.h"
14 #include "iovec-util.h"
15 #include "memfd-util.h"
16 #include "parse-util.h"
17 #include "path-util.h"
18 #include "process-util.h"
19 #include "random-util.h"
20 #include "rm-rf.h"
21 #include "socket-util.h"
22 #include "string-util.h"
23 #include "strv.h"
24 #include "tests.h"
25 #include "tmpfile-util.h"
26
27 TEST(parse_env_file) {
28 _cleanup_(unlink_tempfilep) char
29 t[] = "/tmp/test-fileio-in-XXXXXX",
30 p[] = "/tmp/test-fileio-out-XXXXXX";
31 FILE *f;
32 _cleanup_free_ char *one = NULL, *two = NULL, *three = NULL, *four = NULL, *five = NULL,
33 *six = NULL, *seven = NULL, *eight = NULL, *nine = NULL, *ten = NULL,
34 *eleven = NULL, *twelve = NULL, *thirteen = NULL;
35 _cleanup_strv_free_ char **a = NULL, **b = NULL;
36 unsigned k;
37 int r;
38
39 assert_se(fmkostemp_safe(t, "w", &f) == 0);
40 fputs("one=BAR \n"
41 "# comment\n"
42 " # comment \n"
43 " ; comment \n"
44 " two = bar \n"
45 "invalid line\n"
46 "invalid line #comment\n"
47 "three = \"333\n"
48 "xxxx\"\n"
49 "four = \'44\\\"44\'\n"
50 "five = \"55\\\"55\" \"FIVE\" cinco \n"
51 "six = seis sechs\\\n"
52 " sis\n"
53 "seven=\"sevenval\" #nocomment\n"
54 "eight=eightval #nocomment\n"
55 "export nine=nineval\n"
56 "ten=ignored\n"
57 "ten=ignored\n"
58 "ten=\n"
59 "eleven=\\value\n"
60 "twelve=\"\\value\"\n"
61 "thirteen='\\value'", f);
62
63 fflush(f);
64 fclose(f);
65
66 r = load_env_file(NULL, t, &a);
67 assert_se(r >= 0);
68
69 STRV_FOREACH(i, a)
70 log_info("Got: <%s>", *i);
71
72 ASSERT_STREQ(a[0], "one=BAR");
73 ASSERT_STREQ(a[1], "two=bar");
74 ASSERT_STREQ(a[2], "three=333\nxxxx");
75 ASSERT_STREQ(a[3], "four=44\\\"44");
76 ASSERT_STREQ(a[4], "five=55\"55FIVEcinco");
77 ASSERT_STREQ(a[5], "six=seis sechs sis");
78 ASSERT_STREQ(a[6], "seven=sevenval#nocomment");
79 ASSERT_STREQ(a[7], "eight=eightval #nocomment");
80 ASSERT_STREQ(a[8], "export nine=nineval");
81 ASSERT_STREQ(a[9], "ten=");
82 ASSERT_STREQ(a[10], "eleven=value");
83 ASSERT_STREQ(a[11], "twelve=\\value");
84 ASSERT_STREQ(a[12], "thirteen=\\value");
85 ASSERT_NULL(a[13]);
86
87 strv_env_clean(a);
88
89 k = 0;
90 STRV_FOREACH(i, b) {
91 log_info("Got2: <%s>", *i);
92 ASSERT_STREQ(*i, a[k++]);
93 }
94
95 r = parse_env_file(
96 NULL, t,
97 "one", &one,
98 "two", &two,
99 "three", &three,
100 "four", &four,
101 "five", &five,
102 "six", &six,
103 "seven", &seven,
104 "eight", &eight,
105 "export nine", &nine,
106 "ten", &ten,
107 "eleven", &eleven,
108 "twelve", &twelve,
109 "thirteen", &thirteen);
110 assert_se(r == 0);
111
112 log_info("one=[%s]", strna(one));
113 log_info("two=[%s]", strna(two));
114 log_info("three=[%s]", strna(three));
115 log_info("four=[%s]", strna(four));
116 log_info("five=[%s]", strna(five));
117 log_info("six=[%s]", strna(six));
118 log_info("seven=[%s]", strna(seven));
119 log_info("eight=[%s]", strna(eight));
120 log_info("export nine=[%s]", strna(nine));
121 log_info("ten=[%s]", strna(nine));
122 log_info("eleven=[%s]", strna(eleven));
123 log_info("twelve=[%s]", strna(twelve));
124 log_info("thirteen=[%s]", strna(thirteen));
125
126 ASSERT_STREQ(one, "BAR");
127 ASSERT_STREQ(two, "bar");
128 ASSERT_STREQ(three, "333\nxxxx");
129 ASSERT_STREQ(four, "44\\\"44");
130 ASSERT_STREQ(five, "55\"55FIVEcinco");
131 ASSERT_STREQ(six, "seis sechs sis");
132 ASSERT_STREQ(seven, "sevenval#nocomment");
133 ASSERT_STREQ(eight, "eightval #nocomment");
134 ASSERT_STREQ(nine, "nineval");
135 ASSERT_NULL(ten);
136 ASSERT_STREQ(eleven, "value");
137 ASSERT_STREQ(twelve, "\\value");
138 ASSERT_STREQ(thirteen, "\\value");
139
140 {
141 /* prepare a temporary file to write the environment to */
142 _cleanup_close_ int fd = mkostemp_safe(p);
143 assert_se(fd >= 0);
144 }
145
146 r = write_env_file(AT_FDCWD, p, /* headers= */ NULL, a, /* flags= */ 0);
147 assert_se(r >= 0);
148
149 r = load_env_file(NULL, p, &b);
150 assert_se(r >= 0);
151 }
152
153 static void test_one_shell_var(const char *file, const char *variable, const char *value) {
154 _cleanup_free_ char *cmd = NULL, *from_shell = NULL;
155 _cleanup_pclose_ FILE *f = NULL;
156 size_t sz;
157
158 assert_se(cmd = strjoin(". ", file, " && /bin/echo -n \"$", variable, "\""));
159 assert_se(f = popen(cmd, "re"));
160 assert_se(read_full_stream(f, &from_shell, &sz) >= 0);
161 assert_se(sz == strlen(value));
162 ASSERT_STREQ(from_shell, value);
163 }
164
165 TEST(parse_multiline_env_file) {
166 _cleanup_(unlink_tempfilep) char
167 t[] = "/tmp/test-fileio-in-XXXXXX",
168 p[] = "/tmp/test-fileio-out-XXXXXX";
169 FILE *f;
170 _cleanup_strv_free_ char **a = NULL, **b = NULL;
171 int r;
172
173 assert_se(fmkostemp_safe(t, "w", &f) == 0);
174 fputs("one=BAR\\\n"
175 "\\ \\ \\ \\ VAR\\\n"
176 "\\\tGAR\n"
177 "#comment\n"
178 "two=\"bar\\\n"
179 " var\\\n"
180 "\tgar\"\n"
181 "#comment\n"
182 "tri=\"bar \\\n"
183 " var \\\n"
184 "\tgar \"\n", f);
185
186 assert_se(fflush_and_check(f) >= 0);
187 fclose(f);
188
189 test_one_shell_var(t, "one", "BAR VAR\tGAR");
190 test_one_shell_var(t, "two", "bar var\tgar");
191 test_one_shell_var(t, "tri", "bar var \tgar ");
192
193 r = load_env_file(NULL, t, &a);
194 assert_se(r >= 0);
195
196 STRV_FOREACH(i, a)
197 log_info("Got: <%s>", *i);
198
199 ASSERT_STREQ(a[0], "one=BAR VAR\tGAR");
200 ASSERT_STREQ(a[1], "two=bar var\tgar");
201 ASSERT_STREQ(a[2], "tri=bar var \tgar ");
202 ASSERT_NULL(a[3]);
203
204 {
205 _cleanup_close_ int fd = mkostemp_safe(p);
206 assert_se(fd >= 0);
207 }
208
209 r = write_env_file(AT_FDCWD, p, /* headers= */ NULL, a, /* flags= */ 0);
210 assert_se(r >= 0);
211
212 r = load_env_file(NULL, p, &b);
213 assert_se(r >= 0);
214 }
215
216 TEST(merge_env_file) {
217 _cleanup_(unlink_tempfilep) char t[] = "/tmp/test-fileio-XXXXXX";
218 _cleanup_fclose_ FILE *f = NULL;
219 _cleanup_strv_free_ char **a = NULL;
220 int r;
221
222 assert_se(fmkostemp_safe(t, "w", &f) == 0);
223 log_info("/* %s (%s) */", __func__, t);
224
225 r = write_string_stream(f,
226 "one=1 \n"
227 "twelve=${one}2\n"
228 "twentyone=2${one}\n"
229 "one=2\n"
230 "twentytwo=2${one}\n"
231 "xxx_minus_three=$xxx - 3\n"
232 "xxx=0x$one$one$one\n"
233 "yyy=${one:-fallback}\n"
234 "zzz=${one:+replacement}\n"
235 "zzzz=${foobar:-${nothing}}\n"
236 "zzzzz=${nothing:+${nothing}}\n"
237 , WRITE_STRING_FILE_AVOID_NEWLINE);
238 assert_se(r >= 0);
239
240 r = merge_env_file(&a, NULL, t);
241 assert_se(r >= 0);
242 strv_sort(a);
243
244 STRV_FOREACH(i, a)
245 log_info("Got: <%s>", *i);
246
247 ASSERT_STREQ(a[0], "one=2");
248 ASSERT_STREQ(a[1], "twelve=12");
249 ASSERT_STREQ(a[2], "twentyone=21");
250 ASSERT_STREQ(a[3], "twentytwo=22");
251 ASSERT_STREQ(a[4], "xxx=0x222");
252 ASSERT_STREQ(a[5], "xxx_minus_three= - 3");
253 ASSERT_STREQ(a[6], "yyy=2");
254 ASSERT_STREQ(a[7], "zzz=replacement");
255 ASSERT_STREQ(a[8], "zzzz=");
256 ASSERT_STREQ(a[9], "zzzzz=");
257 ASSERT_NULL(a[10]);
258
259 r = merge_env_file(&a, NULL, t);
260 assert_se(r >= 0);
261 strv_sort(a);
262
263 STRV_FOREACH(i, a)
264 log_info("Got2: <%s>", *i);
265
266 ASSERT_STREQ(a[0], "one=2");
267 ASSERT_STREQ(a[1], "twelve=12");
268 ASSERT_STREQ(a[2], "twentyone=21");
269 ASSERT_STREQ(a[3], "twentytwo=22");
270 ASSERT_STREQ(a[4], "xxx=0x222");
271 ASSERT_STREQ(a[5], "xxx_minus_three=0x222 - 3");
272 ASSERT_STREQ(a[6], "yyy=2");
273 ASSERT_STREQ(a[7], "zzz=replacement");
274 ASSERT_STREQ(a[8], "zzzz=");
275 ASSERT_STREQ(a[9], "zzzzz=");
276 ASSERT_NULL(a[10]);
277 }
278
279 TEST(merge_env_file_invalid) {
280 _cleanup_(unlink_tempfilep) char t[] = "/tmp/test-fileio-XXXXXX";
281 _cleanup_fclose_ FILE *f = NULL;
282 _cleanup_strv_free_ char **a = NULL;
283 int r;
284
285 assert_se(fmkostemp_safe(t, "w", &f) == 0);
286 log_info("/* %s (%s) */", __func__, t);
287
288 r = write_string_stream(f,
289 "unset one \n"
290 "unset one= \n"
291 "unset one=1 \n"
292 "one \n"
293 "one = \n"
294 "one two =\n"
295 "\x20two=\n"
296 "#comment=comment\n"
297 ";comment2=comment2\n"
298 "#\n"
299 "\n\n" /* empty line */
300 , WRITE_STRING_FILE_AVOID_NEWLINE);
301 assert_se(r >= 0);
302
303 r = merge_env_file(&a, NULL, t);
304 assert_se(r >= 0);
305
306 STRV_FOREACH(i, a)
307 log_info("Got: <%s>", *i);
308
309 assert_se(strv_isempty(a));
310 }
311
312 TEST(script_get_shebang_interpreter) {
313 _cleanup_(unlink_tempfilep) char t[] = "/tmp/test-fileio-XXXXXX";
314 _cleanup_fclose_ FILE *f = NULL;
315 char *command;
316
317 assert_se(fmkostemp_safe(t, "w", &f) == 0);
318 fputs("#! /bin/script -a -b \ngoo goo", f);
319 fflush(f);
320
321 ASSERT_OK(script_get_shebang_interpreter(t, &command));
322 ASSERT_STREQ(command, "/bin/script");
323 free(command);
324
325 ASSERT_ERROR(script_get_shebang_interpreter("/bin/sh", NULL), EMEDIUMTYPE);
326
327 if (script_get_shebang_interpreter("/usr/bin/yum", &command) >= 0) {
328 assert_se(startswith(command, "/"));
329 free(command);
330 }
331 }
332
333 TEST(status_field) {
334 _cleanup_free_ char *p = NULL, *s = NULL;
335 unsigned long long total = 0, buffers = 0;
336 int r;
337
338 r = get_proc_field("/proc/meminfo", "MemTotal", &p);
339 if (!IN_SET(r, -ENOENT, -ENOSYS)) {
340 assert_se(r == 0);
341 puts(p);
342 assert_se(safe_atollu(p, &total) == 0);
343 }
344
345 r = get_proc_field("/proc/meminfo", "Buffers", &s);
346 if (!IN_SET(r, -ENOENT, -ENOSYS)) {
347 assert_se(r == 0);
348 puts(s);
349 assert_se(safe_atollu(s, &buffers) == 0);
350 }
351
352 if (p)
353 assert_se(buffers < total);
354 }
355
356 TEST(read_one_line_file) {
357 _cleanup_(unlink_tempfilep) char fn[] = "/tmp/test-fileio-1lf-XXXXXX";
358 int fd;
359 _cleanup_fclose_ FILE *f = NULL;
360 _cleanup_free_ char *buf, *buf2, *buf3, *buf4, *buf5;
361
362 fd = mkostemp_safe(fn);
363 assert_se(fd >= 0);
364
365 f = fdopen(fd, "we");
366 assert_se(f);
367
368 assert_se(read_one_line_file(fn, &buf) == 0);
369 ASSERT_STREQ(buf, "");
370 assert_se(read_one_line_file(fn, &buf2) == 0);
371 ASSERT_STREQ(buf2, "");
372
373 assert_se(write_string_stream(f, "x", WRITE_STRING_FILE_AVOID_NEWLINE) >= 0);
374 fflush(f);
375
376 assert_se(read_one_line_file(fn, &buf3) == 1);
377 ASSERT_STREQ(buf3, "x");
378
379 assert_se(write_string_stream(f, "\n", WRITE_STRING_FILE_AVOID_NEWLINE) >= 0);
380 fflush(f);
381
382 assert_se(read_one_line_file(fn, &buf4) == 2);
383 ASSERT_STREQ(buf4, "x");
384
385 assert_se(write_string_stream(f, "\n", WRITE_STRING_FILE_AVOID_NEWLINE) >= 0);
386 fflush(f);
387
388 assert_se(read_one_line_file(fn, &buf5) == 2);
389 ASSERT_STREQ(buf5, "x");
390 }
391
392 TEST(write_string_stream) {
393 _cleanup_(unlink_tempfilep) char fn[] = "/tmp/test-write_string_stream-XXXXXX";
394 _cleanup_fclose_ FILE *f = NULL;
395 int fd;
396 char buf[64];
397
398 fd = mkostemp_safe(fn);
399 assert_se(fd >= 0);
400
401 f = fdopen(fd, "r");
402 assert_se(f);
403 assert_se(write_string_stream(f, "boohoo", 0) < 0);
404 f = safe_fclose(f);
405
406 f = fopen(fn, "r+");
407 assert_se(f);
408
409 assert_se(write_string_stream(f, "boohoo", 0) == 0);
410 rewind(f);
411
412 assert_se(fgets(buf, sizeof(buf), f));
413 ASSERT_STREQ(buf, "boohoo\n");
414 f = safe_fclose(f);
415
416 f = fopen(fn, "w+");
417 assert_se(f);
418
419 assert_se(write_string_stream(f, "boohoo", WRITE_STRING_FILE_AVOID_NEWLINE) == 0);
420 rewind(f);
421
422 assert_se(fgets(buf, sizeof(buf), f));
423 printf(">%s<", buf);
424 ASSERT_STREQ(buf, "boohoo");
425 }
426
427 TEST(write_string_file) {
428 _cleanup_(unlink_tempfilep) char fn[] = "/tmp/test-write_string_file-XXXXXX";
429 char buf[64] = {};
430 _cleanup_close_ int fd = -EBADF;
431
432 fd = mkostemp_safe(fn);
433 assert_se(fd >= 0);
434
435 assert_se(write_string_file(fn, "boohoo", WRITE_STRING_FILE_CREATE) == 0);
436
437 assert_se(read(fd, buf, sizeof(buf)) == 7);
438 ASSERT_STREQ(buf, "boohoo\n");
439 }
440
441 TEST(write_string_file_no_create) {
442 _cleanup_(unlink_tempfilep) char fn[] = "/tmp/test-write_string_file_no_create-XXXXXX";
443 _cleanup_close_ int fd = -EBADF;
444 char buf[64] = {};
445
446 fd = mkostemp_safe(fn);
447 assert_se(fd >= 0);
448
449 assert_se(write_string_file("/a/file/which/does/not/exists/i/guess", "boohoo", 0) < 0);
450 assert_se(write_string_file(fn, "boohoo", 0) == 0);
451
452 assert_se(read(fd, buf, sizeof buf) == (ssize_t) strlen("boohoo\n"));
453 ASSERT_STREQ(buf, "boohoo\n");
454 }
455
456 TEST(write_string_file_verify) {
457 _cleanup_free_ char *buf = NULL, *buf2 = NULL;
458 int r;
459
460 r = read_one_line_file("/proc/version", &buf);
461 if (ERRNO_IS_NEG_PRIVILEGE(r))
462 return;
463 assert_se(r >= 0);
464 assert_se(buf2 = strjoin(buf, "\n"));
465
466 r = write_string_file("/proc/version", buf, 0);
467 assert_se(IN_SET(r, -EACCES, -EIO));
468 r = write_string_file("/proc/version", buf2, 0);
469 assert_se(IN_SET(r, -EACCES, -EIO));
470
471 assert_se(write_string_file("/proc/version", buf, WRITE_STRING_FILE_VERIFY_ON_FAILURE) == 0);
472 assert_se(write_string_file("/proc/version", buf2, WRITE_STRING_FILE_VERIFY_ON_FAILURE) == 0);
473
474 r = write_string_file("/proc/version", buf, WRITE_STRING_FILE_VERIFY_ON_FAILURE|WRITE_STRING_FILE_AVOID_NEWLINE);
475 assert_se(IN_SET(r, -EACCES, -EIO));
476 assert_se(write_string_file("/proc/version", buf2, WRITE_STRING_FILE_VERIFY_ON_FAILURE|WRITE_STRING_FILE_AVOID_NEWLINE) == 0);
477 }
478
479 static void check_file_pairs_one(char **l) {
480 assert_se(l);
481 assert_se(strv_length(l) == 14);
482
483 STRV_FOREACH_PAIR(k, v, l) {
484 assert_se(STR_IN_SET(*k, "NAME", "ID", "PRETTY_NAME", "ANSI_COLOR", "HOME_URL", "SUPPORT_URL", "BUG_REPORT_URL"));
485 printf("%s=%s\n", *k, *v);
486 assert_se(!streq(*k, "NAME") || streq(*v, "Arch Linux"));
487 assert_se(!streq(*k, "ID") || streq(*v, "arch"));
488 assert_se(!streq(*k, "PRETTY_NAME") || streq(*v, "Arch Linux"));
489 assert_se(!streq(*k, "ANSI_COLOR") || streq(*v, "0;36"));
490 assert_se(!streq(*k, "HOME_URL") || streq(*v, "https://www.archlinux.org/"));
491 assert_se(!streq(*k, "SUPPORT_URL") || streq(*v, "https://bbs.archlinux.org/"));
492 assert_se(!streq(*k, "BUG_REPORT_URL") || streq(*v, "https://bugs.archlinux.org/"));
493 }
494 }
495
496 TEST(load_env_file_pairs) {
497 _cleanup_(unlink_tempfilep) char fn[] = "/tmp/test-load_env_file_pairs-XXXXXX";
498 int fd, r;
499 _cleanup_fclose_ FILE *f = NULL;
500 _cleanup_strv_free_ char **l = NULL;
501
502 fd = mkostemp_safe(fn);
503 assert_se(fd >= 0);
504
505 r = write_string_file(fn,
506 "NAME=\"Arch Linux\"\n"
507 "ID=arch\n"
508 "PRETTY_NAME=\"Arch Linux\"\n"
509 "ANSI_COLOR=\"0;36\"\n"
510 "HOME_URL=\"https://www.archlinux.org/\"\n"
511 "SUPPORT_URL=\"https://bbs.archlinux.org/\"\n"
512 "BUG_REPORT_URL=\"https://bugs.archlinux.org/\"\n",
513 WRITE_STRING_FILE_CREATE);
514 assert_se(r == 0);
515
516 r = load_env_file_pairs_fd(fd, fn, &l);
517 assert_se(r >= 0);
518 check_file_pairs_one(l);
519 l = strv_free(l);
520
521 f = fdopen(fd, "r");
522 assert_se(f);
523
524 r = load_env_file_pairs(f, fn, &l);
525 assert_se(r >= 0);
526 check_file_pairs_one(l);
527 }
528
529 TEST(search_and_fopen) {
530 static const char* const dirs[] = {
531 "/tmp/foo/bar",
532 "/tmp",
533 NULL
534 };
535 char name[] = "/tmp/test-search_and_fopen.XXXXXX";
536 _cleanup_fclose_ FILE *f = NULL;
537 _cleanup_free_ char *p = NULL, *bn = NULL;
538 _cleanup_close_ int fd = -EBADF;
539 const char *e;
540 int r;
541
542 fd = mkostemp_safe(name);
543 assert_se(fd >= 0);
544 fd = safe_close(fd);
545
546 ASSERT_OK(path_extract_filename(name, &bn));
547 ASSERT_OK(search_and_fopen(bn, "re", NULL, (const char**) dirs, &f, &p));
548 assert_se(e = path_startswith(p, "/tmp/"));
549 ASSERT_STREQ(bn, e);
550 f = safe_fclose(f);
551 p = mfree(p);
552
553 ASSERT_OK(search_and_fopen(bn, NULL, NULL, (const char**) dirs, NULL, &p));
554 assert_se(e = path_startswith(p, "/tmp/"));
555 ASSERT_STREQ(bn, e);
556 p = mfree(p);
557
558 ASSERT_OK(search_and_fopen(name, "re", NULL, (const char**) dirs, &f, &p));
559 assert_se(path_equal(name, p));
560 f = safe_fclose(f);
561 p = mfree(p);
562
563 ASSERT_OK(search_and_fopen(name, NULL, NULL, (const char**) dirs, NULL, &p));
564 assert_se(path_equal(name, p));
565 p = mfree(p);
566
567 ASSERT_OK(search_and_fopen(bn, "re", "/", (const char**) dirs, &f, &p));
568 assert_se(e = path_startswith(p, "/tmp/"));
569 ASSERT_STREQ(bn, e);
570 f = safe_fclose(f);
571 p = mfree(p);
572
573 ASSERT_OK(search_and_fopen(bn, NULL, "/", (const char**) dirs, NULL, &p));
574 assert_se(e = path_startswith(p, "/tmp/"));
575 ASSERT_STREQ(bn, e);
576 p = mfree(p);
577
578 ASSERT_ERROR(search_and_fopen("/a/file/which/does/not/exist/i/guess", "re", NULL, (const char**) dirs, &f, &p), ENOENT);
579 ASSERT_ERROR(search_and_fopen("/a/file/which/does/not/exist/i/guess", NULL, NULL, (const char**) dirs, NULL, &p), ENOENT);
580 ASSERT_ERROR(search_and_fopen("afilewhichdoesnotexistiguess", "re", NULL, (const char**) dirs, &f, &p), ENOENT);
581 ASSERT_ERROR(search_and_fopen("afilewhichdoesnotexistiguess", NULL, NULL, (const char**) dirs, NULL, &p), ENOENT);
582
583 r = unlink(name);
584 assert_se(r == 0);
585
586 ASSERT_ERROR(search_and_fopen(bn, "re", NULL, (const char**) dirs, &f, &p), ENOENT);
587 ASSERT_ERROR(search_and_fopen(bn, NULL, NULL, (const char**) dirs, NULL, &p), ENOENT);
588 }
589
590 TEST(search_and_fopen_nulstr) {
591 static const char dirs[] =
592 "/tmp/foo/bar\0"
593 "/tmp\0";
594
595 _cleanup_(unlink_tempfilep) char name[] = "/tmp/test-search_and_fopen.XXXXXX";
596 _cleanup_fclose_ FILE *f = NULL;
597 _cleanup_free_ char *p = NULL, *bn = NULL;
598 _cleanup_close_ int fd = -EBADF;
599 const char *e;
600 int r;
601
602 fd = mkostemp_safe(name);
603 assert_se(fd >= 0);
604 fd = safe_close(fd);
605
606 ASSERT_OK(path_extract_filename(name, &bn));
607 ASSERT_OK(search_and_fopen_nulstr(bn, "re", NULL, dirs, &f, &p));
608 assert_se(e = path_startswith(p, "/tmp/"));
609 ASSERT_STREQ(bn, e);
610 f = safe_fclose(f);
611 p = mfree(p);
612
613 ASSERT_OK(search_and_fopen_nulstr(name, "re", NULL, dirs, &f, &p));
614 assert_se(path_equal(name, p));
615 f = safe_fclose(f);
616 p = mfree(p);
617
618 ASSERT_ERROR(search_and_fopen_nulstr("/a/file/which/does/not/exist/i/guess", "re", NULL, dirs, &f, &p), ENOENT);
619 ASSERT_ERROR(search_and_fopen_nulstr("afilewhichdoesnotexistiguess", "re", NULL, dirs, &f, &p), ENOENT);
620
621 r = unlink(name);
622 assert_se(r == 0);
623
624 ASSERT_ERROR(search_and_fopen_nulstr(bn, "re", NULL, dirs, &f, &p), ENOENT);
625 }
626
627 TEST(writing_tmpfile) {
628 _cleanup_(unlink_tempfilep) char name[] = "/tmp/test-systemd_writing_tmpfile.XXXXXX";
629 _cleanup_free_ char *contents = NULL;
630 size_t size;
631 _cleanup_close_ int fd = -EBADF;
632 int r;
633
634 struct iovec iov[] = {
635 IOVEC_MAKE_STRING("abc\n"),
636 IOVEC_MAKE_STRING(ALPHANUMERICAL "\n"),
637 IOVEC_MAKE_STRING(""),
638 };
639
640 fd = mkostemp_safe(name);
641 printf("tmpfile: %s", name);
642
643 r = writev(fd, iov, 3);
644 assert_se(r >= 0);
645
646 r = read_full_file(name, &contents, &size);
647 assert_se(r == 0);
648 printf("contents: %s", contents);
649 ASSERT_STREQ(contents, "abc\n" ALPHANUMERICAL "\n");
650 }
651
652 TEST(tempfn) {
653 char *ret = NULL, *p;
654
655 assert_se(tempfn_xxxxxx("/foo/bar/waldo", NULL, &ret) >= 0);
656 ASSERT_STREQ(ret, "/foo/bar/.#waldoXXXXXX");
657 free(ret);
658
659 assert_se(tempfn_xxxxxx("/foo/bar/waldo", "[miau]", &ret) >= 0);
660 ASSERT_STREQ(ret, "/foo/bar/.#[miau]waldoXXXXXX");
661 free(ret);
662
663 assert_se(tempfn_random("/foo/bar/waldo", NULL, &ret) >= 0);
664 assert_se(p = startswith(ret, "/foo/bar/.#waldo"));
665 assert_se(strlen(p) == 16);
666 assert_se(in_charset(p, "0123456789abcdef"));
667 free(ret);
668
669 assert_se(tempfn_random("/foo/bar/waldo", "[wuff]", &ret) >= 0);
670 assert_se(p = startswith(ret, "/foo/bar/.#[wuff]waldo"));
671 assert_se(strlen(p) == 16);
672 assert_se(in_charset(p, "0123456789abcdef"));
673 free(ret);
674
675 assert_se(tempfn_random_child("/foo/bar/waldo", NULL, &ret) >= 0);
676 assert_se(p = startswith(ret, "/foo/bar/waldo/.#"));
677 assert_se(strlen(p) == 16);
678 assert_se(in_charset(p, "0123456789abcdef"));
679 free(ret);
680
681 assert_se(tempfn_random_child("/foo/bar/waldo", "[kikiriki]", &ret) >= 0);
682 assert_se(p = startswith(ret, "/foo/bar/waldo/.#[kikiriki]"));
683 assert_se(strlen(p) == 16);
684 assert_se(in_charset(p, "0123456789abcdef"));
685 free(ret);
686 }
687
688 static const char chars[] =
689 "Aąę„”\n루\377";
690
691 DISABLE_WARNING_TYPE_LIMITS;
692
693 TEST(fgetc) {
694 _cleanup_fclose_ FILE *f = NULL;
695 char c;
696
697 assert_se(f = fmemopen_unlocked((void*) chars, sizeof(chars), "r"));
698
699 for (size_t i = 0; i < sizeof(chars); i++) {
700 assert_se(safe_fgetc(f, &c) == 1);
701 assert_se(c == chars[i]);
702
703 if (ungetc(c, f) == EOF) {
704 /* EOF is -1, and hence we can't push value 255 in this way – if char is signed */
705 assert_se(c == (char) EOF);
706 assert_se(CHAR_MIN == -128); /* verify that char is signed on this platform */
707 } else {
708 assert_se(safe_fgetc(f, &c) == 1);
709 assert_se(c == chars[i]);
710 }
711
712 /* But it works when we push it properly cast */
713 assert_se(ungetc((unsigned char) c, f) != EOF);
714 assert_se(safe_fgetc(f, &c) == 1);
715 assert_se(c == chars[i]);
716 }
717
718 assert_se(safe_fgetc(f, &c) == 0);
719 }
720
721 REENABLE_WARNING;
722
723 static const char buffer[] =
724 "Some test data\n"
725 "루Non-ascii chars: ąę„”\n"
726 "terminators\r\n"
727 "and even more\n\r"
728 "now the same with a NUL\n\0"
729 "and more\r\0"
730 "and even more\r\n\0"
731 "and yet even more\n\r\0"
732 "With newlines, and a NUL byte\0"
733 "\n"
734 "an empty line\n"
735 "an ignored line\n"
736 "and a very long line that is supposed to be truncated, because it is so long\n";
737
738 static void test_read_line_one_file(FILE *f) {
739 _cleanup_free_ char *line = NULL;
740
741 assert_se(read_line(f, SIZE_MAX, &line) == 15 && streq(line, "Some test data"));
742 line = mfree(line);
743
744 assert_se(read_line(f, SIZE_MAX, &line) > 0 && streq(line, "루Non-ascii chars: ąę„”"));
745 line = mfree(line);
746
747 assert_se(read_line(f, SIZE_MAX, &line) == 13 && streq(line, "terminators"));
748 line = mfree(line);
749
750 assert_se(read_line(f, SIZE_MAX, &line) == 15 && streq(line, "and even more"));
751 line = mfree(line);
752
753 assert_se(read_line(f, SIZE_MAX, &line) == 25 && streq(line, "now the same with a NUL"));
754 line = mfree(line);
755
756 assert_se(read_line(f, SIZE_MAX, &line) == 10 && streq(line, "and more"));
757 line = mfree(line);
758
759 assert_se(read_line(f, SIZE_MAX, &line) == 16 && streq(line, "and even more"));
760 line = mfree(line);
761
762 assert_se(read_line(f, SIZE_MAX, &line) == 20 && streq(line, "and yet even more"));
763 line = mfree(line);
764
765 assert_se(read_line(f, 1024, &line) == 30 && streq(line, "With newlines, and a NUL byte"));
766 line = mfree(line);
767
768 assert_se(read_line(f, 1024, &line) == 1 && streq(line, ""));
769 line = mfree(line);
770
771 assert_se(read_line(f, 1024, &line) == 14 && streq(line, "an empty line"));
772 line = mfree(line);
773
774 assert_se(read_line(f, SIZE_MAX, NULL) == 16);
775
776 assert_se(read_line(f, 16, &line) == -ENOBUFS);
777 line = mfree(line);
778
779 /* read_line() stopped when it hit the limit, that means when we continue reading we'll read at the first
780 * character after the previous limit. Let's make use of that to continue our test. */
781 assert_se(read_line(f, 1024, &line) == 62 && streq(line, "line that is supposed to be truncated, because it is so long"));
782 line = mfree(line);
783
784 assert_se(read_line(f, 1024, &line) == 0 && streq(line, ""));
785 }
786
787 TEST(read_line1) {
788 _cleanup_fclose_ FILE *f = NULL;
789
790 assert_se(f = fmemopen_unlocked((void*) buffer, sizeof(buffer), "r"));
791 test_read_line_one_file(f);
792 }
793
794 TEST(read_line2) {
795 _cleanup_(unlink_tempfilep) char name[] = "/tmp/test-fileio.XXXXXX";
796 int fd;
797 _cleanup_fclose_ FILE *f = NULL;
798
799 fd = mkostemp_safe(name);
800 assert_se(fd >= 0);
801 assert_se((size_t) write(fd, buffer, sizeof(buffer)) == sizeof(buffer));
802
803 assert_se(lseek(fd, 0, SEEK_SET) == 0);
804 assert_se(f = fdopen(fd, "r"));
805
806 test_read_line_one_file(f);
807 }
808
809 TEST(read_line3) {
810 _cleanup_fclose_ FILE *f = NULL;
811 _cleanup_free_ char *line = NULL;
812 int r;
813
814 f = fopen("/proc/uptime", "re");
815 if (!f && IN_SET(errno, ENOENT, EPERM))
816 return;
817 assert_se(f);
818
819 r = read_line(f, LINE_MAX, &line);
820 assert_se(r >= 0);
821 if (r == 0)
822 assert_se(line && isempty(line));
823 else
824 assert_se((size_t) r == strlen(line) + 1);
825 assert_se(read_line(f, LINE_MAX, NULL) == 0);
826 }
827
828 TEST(read_line4) {
829 static const struct {
830 size_t length;
831 const char *string;
832 } eof_endings[] = {
833 /* Each of these will be followed by EOF and should generate the one same single string */
834 { 3, "foo" },
835 { 4, "foo\n" },
836 { 4, "foo\r" },
837 { 4, "foo\0" },
838 { 5, "foo\n\0" },
839 { 5, "foo\r\0" },
840 { 5, "foo\r\n" },
841 { 5, "foo\n\r" },
842 { 6, "foo\r\n\0" },
843 { 6, "foo\n\r\0" },
844 };
845
846 int r;
847
848 FOREACH_ELEMENT(ending, eof_endings) {
849 _cleanup_fclose_ FILE *f = NULL;
850 _cleanup_free_ char *s = NULL;
851
852 assert_se(f = fmemopen_unlocked((void*) ending->string, ending->length, "r"));
853
854 r = read_line(f, SIZE_MAX, &s);
855 assert_se((size_t) r == ending->length);
856 ASSERT_STREQ(s, "foo");
857
858 assert_se(read_line(f, SIZE_MAX, NULL) == 0); /* Ensure we hit EOF */
859 }
860 }
861
862 TEST(read_nul_string) {
863 static const char test[] = "string nr. 1\0"
864 "string nr. 2\n\0"
865 "\377empty string follows\0"
866 "\0"
867 "final string\n is empty\0"
868 "\0";
869
870 _cleanup_fclose_ FILE *f = NULL;
871 _cleanup_free_ char *s = NULL;
872
873 assert_se(f = fmemopen_unlocked((void*) test, sizeof(test)-1, "r"));
874
875 assert_se(read_nul_string(f, LONG_LINE_MAX, &s) == 13 && streq_ptr(s, "string nr. 1"));
876 s = mfree(s);
877
878 assert_se(read_nul_string(f, LONG_LINE_MAX, &s) == 14 && streq_ptr(s, "string nr. 2\n"));
879 s = mfree(s);
880
881 assert_se(read_nul_string(f, LONG_LINE_MAX, &s) == 22 && streq_ptr(s, "\377empty string follows"));
882 s = mfree(s);
883
884 assert_se(read_nul_string(f, LONG_LINE_MAX, &s) == 1 && streq_ptr(s, ""));
885 s = mfree(s);
886
887 assert_se(read_nul_string(f, LONG_LINE_MAX, &s) == 23 && streq_ptr(s, "final string\n is empty"));
888 s = mfree(s);
889
890 assert_se(read_nul_string(f, LONG_LINE_MAX, &s) == 1 && streq_ptr(s, ""));
891 s = mfree(s);
892
893 assert_se(read_nul_string(f, LONG_LINE_MAX, &s) == 0 && streq_ptr(s, ""));
894 }
895
896 TEST(read_full_file_socket) {
897 _cleanup_(rm_rf_physical_and_freep) char *z = NULL;
898 _cleanup_close_ int listener = -EBADF;
899 _cleanup_free_ char *data = NULL, *clientname = NULL;
900 union sockaddr_union sa;
901 const char *j, *jj;
902 size_t size;
903 pid_t pid;
904 int r;
905
906 listener = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC, 0);
907 assert_se(listener >= 0);
908
909 assert_se(mkdtemp_malloc(NULL, &z) >= 0);
910 j = strjoina(z, "/socket");
911
912 assert_se(sockaddr_un_set_path(&sa.un, j) >= 0);
913
914 assert_se(bind(listener, &sa.sa, sockaddr_un_len(&sa.un)) >= 0);
915 assert_se(listen(listener, 1) >= 0);
916
917 /* Make sure the socket doesn't fit into a struct sockaddr_un, but we can still access it */
918 jj = strjoina(z, "/a_very_long_patha_very_long_patha_very_long_patha_very_long_patha_very_long_patha_very_long_patha_very_long_patha_very_long_path");
919 assert_se(strlen(jj) > sizeof_field(struct sockaddr_un, sun_path));
920 assert_se(rename(j, jj) >= 0);
921
922 /* Bind the *client* socket to some randomized name, to verify that this works correctly. */
923 assert_se(asprintf(&clientname, "@%" PRIx64 "/test-bindname", random_u64()) >= 0);
924
925 r = safe_fork("(server)", FORK_DEATHSIG_SIGTERM|FORK_LOG, &pid);
926 assert_se(r >= 0);
927 if (r == 0) {
928 union sockaddr_union peer = {};
929 socklen_t peerlen = sizeof(peer);
930 _cleanup_close_ int rfd = -EBADF;
931 /* child */
932
933 rfd = accept4(listener, NULL, NULL, SOCK_CLOEXEC);
934 assert_se(rfd >= 0);
935
936 assert_se(getpeername(rfd, &peer.sa, &peerlen) >= 0);
937
938 assert_se(peer.un.sun_family == AF_UNIX);
939 assert_se(peerlen > offsetof(struct sockaddr_un, sun_path));
940 assert_se(peer.un.sun_path[0] == 0);
941 ASSERT_STREQ(peer.un.sun_path + 1, clientname + 1);
942
943 #define TEST_STR "This is a test\nreally."
944
945 assert_se(write(rfd, TEST_STR, strlen(TEST_STR)) == strlen(TEST_STR));
946 _exit(EXIT_SUCCESS);
947 }
948
949 assert_se(read_full_file_full(AT_FDCWD, jj, UINT64_MAX, SIZE_MAX, 0, NULL, &data, &size) == -ENXIO);
950 assert_se(read_full_file_full(AT_FDCWD, jj, UINT64_MAX, SIZE_MAX, READ_FULL_FILE_CONNECT_SOCKET, clientname, &data, &size) >= 0);
951 assert_se(size == strlen(TEST_STR));
952 ASSERT_STREQ(data, TEST_STR);
953
954 assert_se(wait_for_terminate_and_check("(server)", pid, WAIT_LOG) >= 0);
955 #undef TEST_STR
956 }
957
958 TEST(read_full_file_offset_size) {
959 _cleanup_fclose_ FILE *f = NULL;
960 _cleanup_(unlink_and_freep) char *fn = NULL;
961 _cleanup_free_ char *rbuf = NULL;
962 size_t rbuf_size;
963 uint8_t buf[4711];
964
965 random_bytes(buf, sizeof(buf));
966
967 assert_se(tempfn_random_child(NULL, NULL, &fn) >= 0);
968 assert_se(f = fopen(fn, "we"));
969 assert_se(fwrite(buf, 1, sizeof(buf), f) == sizeof(buf));
970 assert_se(fflush_and_check(f) >= 0);
971
972 assert_se(read_full_file_full(AT_FDCWD, fn, UINT64_MAX, SIZE_MAX, 0, NULL, &rbuf, &rbuf_size) >= 0);
973 assert_se(rbuf_size == sizeof(buf));
974 assert_se(memcmp(buf, rbuf, rbuf_size) == 0);
975 rbuf = mfree(rbuf);
976
977 assert_se(read_full_file_full(AT_FDCWD, fn, UINT64_MAX, 128, 0, NULL, &rbuf, &rbuf_size) >= 0);
978 assert_se(rbuf_size == 128);
979 assert_se(memcmp(buf, rbuf, rbuf_size) == 0);
980 rbuf = mfree(rbuf);
981
982 assert_se(read_full_file_full(AT_FDCWD, fn, UINT64_MAX, 128, READ_FULL_FILE_FAIL_WHEN_LARGER, NULL, &rbuf, &rbuf_size) == -E2BIG);
983 assert_se(read_full_file_full(AT_FDCWD, fn, UINT64_MAX, sizeof(buf)-1, READ_FULL_FILE_FAIL_WHEN_LARGER, NULL, &rbuf, &rbuf_size) == -E2BIG);
984 assert_se(read_full_file_full(AT_FDCWD, fn, UINT64_MAX, sizeof(buf), READ_FULL_FILE_FAIL_WHEN_LARGER, NULL, &rbuf, &rbuf_size) >= 0);
985 assert_se(rbuf_size == sizeof(buf));
986 assert_se(memcmp(buf, rbuf, rbuf_size) == 0);
987 rbuf = mfree(rbuf);
988
989 assert_se(read_full_file_full(AT_FDCWD, fn, 47, 128, READ_FULL_FILE_FAIL_WHEN_LARGER, NULL, &rbuf, &rbuf_size) == -E2BIG);
990 assert_se(read_full_file_full(AT_FDCWD, fn, 47, sizeof(buf)-47-1, READ_FULL_FILE_FAIL_WHEN_LARGER, NULL, &rbuf, &rbuf_size) == -E2BIG);
991 assert_se(read_full_file_full(AT_FDCWD, fn, 47, sizeof(buf)-47, READ_FULL_FILE_FAIL_WHEN_LARGER, NULL, &rbuf, &rbuf_size) >= 0);
992 assert_se(rbuf_size == sizeof(buf)-47);
993 assert_se(memcmp(buf+47, rbuf, rbuf_size) == 0);
994 rbuf = mfree(rbuf);
995
996 assert_se(read_full_file_full(AT_FDCWD, fn, UINT64_MAX, sizeof(buf)+1, READ_FULL_FILE_FAIL_WHEN_LARGER, NULL, &rbuf, &rbuf_size) >= 0);
997 assert_se(rbuf_size == sizeof(buf));
998 assert_se(memcmp(buf, rbuf, rbuf_size) == 0);
999 rbuf = mfree(rbuf);
1000
1001 assert_se(read_full_file_full(AT_FDCWD, fn, 1234, SIZE_MAX, 0, NULL, &rbuf, &rbuf_size) >= 0);
1002 assert_se(rbuf_size == sizeof(buf) - 1234);
1003 assert_se(memcmp(buf + 1234, rbuf, rbuf_size) == 0);
1004 rbuf = mfree(rbuf);
1005
1006 assert_se(read_full_file_full(AT_FDCWD, fn, 2345, 777, 0, NULL, &rbuf, &rbuf_size) >= 0);
1007 assert_se(rbuf_size == 777);
1008 assert_se(memcmp(buf + 2345, rbuf, rbuf_size) == 0);
1009 rbuf = mfree(rbuf);
1010
1011 assert_se(read_full_file_full(AT_FDCWD, fn, 4700, 20, 0, NULL, &rbuf, &rbuf_size) >= 0);
1012 assert_se(rbuf_size == 11);
1013 assert_se(memcmp(buf + 4700, rbuf, rbuf_size) == 0);
1014 rbuf = mfree(rbuf);
1015
1016 assert_se(read_full_file_full(AT_FDCWD, fn, 10000, 99, 0, NULL, &rbuf, &rbuf_size) >= 0);
1017 assert_se(rbuf_size == 0);
1018 rbuf = mfree(rbuf);
1019 }
1020
1021 static void test_read_virtual_file_one(size_t max_size) {
1022 int r;
1023
1024 log_info("/* %s (max_size=%zu) */", __func__, max_size);
1025
1026 FOREACH_STRING(filename,
1027 "/proc/1/cmdline",
1028 "/etc/nsswitch.conf",
1029 "/sys/kernel/uevent_seqnum",
1030 "/proc/kcore",
1031 "/proc/kallsyms",
1032 "/proc/self/exe",
1033 "/proc/self/pagemap") {
1034
1035 _cleanup_free_ char *buf = NULL;
1036 size_t size = 0;
1037
1038 r = read_virtual_file(filename, max_size, &buf, &size);
1039 if (r < 0) {
1040 log_info_errno(r, "read_virtual_file(\"%s\", %zu): %m", filename, max_size);
1041 assert_se(ERRNO_IS_PRIVILEGE(r) || /* /proc/kcore is not accessible to unpriv */
1042 IN_SET(r,
1043 -ENOENT, /* Some of the files might be absent */
1044 -EINVAL, /* too small reads from /proc/self/pagemap trigger EINVAL */
1045 -EFBIG, /* /proc/kcore and /proc/self/pagemap should be too large */
1046 -EBADF)); /* /proc/kcore is masked when we are running in docker. */
1047 } else
1048 log_info("read_virtual_file(\"%s\", %zu): %s (%zu bytes)", filename, max_size, r ? "non-truncated" : "truncated", size);
1049 }
1050 }
1051
1052 TEST(read_virtual_file) {
1053 test_read_virtual_file_one(0);
1054 test_read_virtual_file_one(1);
1055 test_read_virtual_file_one(2);
1056 test_read_virtual_file_one(20);
1057 test_read_virtual_file_one(4096);
1058 test_read_virtual_file_one(4097);
1059 test_read_virtual_file_one(SIZE_MAX);
1060 }
1061
1062 TEST(fdopen_independent) {
1063 #define TEST_TEXT "this is some random test text we are going to write to a memfd"
1064 _cleanup_close_ int fd = -EBADF;
1065 _cleanup_fclose_ FILE *f = NULL;
1066 char buf[STRLEN(TEST_TEXT) + 1];
1067
1068 fd = memfd_new("fdopen_independent");
1069 if (fd < 0) {
1070 assert_se(ERRNO_IS_NOT_SUPPORTED(fd));
1071 return;
1072 }
1073
1074 assert_se(write(fd, TEST_TEXT, strlen(TEST_TEXT)) == strlen(TEST_TEXT));
1075 /* we'll leave the read offset at the end of the memfd, the fdopen_independent() descriptors should
1076 * start at the beginning anyway */
1077
1078 assert_se(fdopen_independent(fd, "re", &f) >= 0);
1079 zero(buf);
1080 assert_se(fread(buf, 1, sizeof(buf), f) == strlen(TEST_TEXT));
1081 ASSERT_STREQ(buf, TEST_TEXT);
1082 assert_se((fcntl(fileno(f), F_GETFL) & O_ACCMODE_STRICT) == O_RDONLY);
1083 assert_se(FLAGS_SET(fcntl(fileno(f), F_GETFD), FD_CLOEXEC));
1084 f = safe_fclose(f);
1085
1086 assert_se(fdopen_independent(fd, "r", &f) >= 0);
1087 zero(buf);
1088 assert_se(fread(buf, 1, sizeof(buf), f) == strlen(TEST_TEXT));
1089 ASSERT_STREQ(buf, TEST_TEXT);
1090 assert_se((fcntl(fileno(f), F_GETFL) & O_ACCMODE_STRICT) == O_RDONLY);
1091 assert_se(!FLAGS_SET(fcntl(fileno(f), F_GETFD), FD_CLOEXEC));
1092 f = safe_fclose(f);
1093
1094 assert_se(fdopen_independent(fd, "r+e", &f) >= 0);
1095 zero(buf);
1096 assert_se(fread(buf, 1, sizeof(buf), f) == strlen(TEST_TEXT));
1097 ASSERT_STREQ(buf, TEST_TEXT);
1098 assert_se((fcntl(fileno(f), F_GETFL) & O_ACCMODE_STRICT) == O_RDWR);
1099 assert_se(FLAGS_SET(fcntl(fileno(f), F_GETFD), FD_CLOEXEC));
1100 f = safe_fclose(f);
1101 }
1102
1103 DEFINE_TEST_MAIN(LOG_DEBUG);
Unnamed repository; edit this file 'description' to name the repository.