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