src/test/test-fileio.c

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