src/test/test-fileio.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include <fcntl.h>
   4 #include <stdio.h>
   5 #include <unistd.h>
   6
   7 #include "alloc-util.h"
   8 #include "ctype.h"
   9 #include "def.h"
  10 #include "env-util.h"
  11 #include "fd-util.h"
  12 #include "fileio.h"
  13 #include "fs-util.h"
  14 #include "io-util.h"
  15 #include "parse-util.h"
  16 #include "process-util.h"
  17 #include "string-util.h"
  18 #include "strv.h"
  19 #include "util.h"
  20
  21 static void test_parse_env_file(void) {
  22         _cleanup_(unlink_tempfilep) char
  23                 t[] = "/tmp/test-fileio-in-XXXXXX",
  24                 p[] = "/tmp/test-fileio-out-XXXXXX";
  25         int fd, r;
  26         FILE *f;
  27         _cleanup_free_ char *one = NULL, *two = NULL, *three = NULL, *four = NULL, *five = NULL,
  28                         *six = NULL, *seven = NULL, *eight = NULL, *nine = NULL, *ten = NULL;
  29         _cleanup_strv_free_ char **a = NULL, **b = NULL;
  30         char **i;
  31         unsigned k;
  32
  33         fd = mkostemp_safe(p);
  34         assert_se(fd >= 0);
  35         close(fd);
  36
  37         fd = mkostemp_safe(t);
  38         assert_se(fd >= 0);
  39
  40         f = fdopen(fd, "w");
  41         assert_se(f);
  42
  43         fputs("one=BAR   \n"
  44               "# comment\n"
  45               " # comment \n"
  46               " ; comment \n"
  47               "  two   =   bar    \n"
  48               "invalid line\n"
  49               "invalid line #comment\n"
  50               "three = \"333\n"
  51               "xxxx\"\n"
  52               "four = \'44\\\"44\'\n"
  53               "five = \'55\\\'55\' \"FIVE\" cinco   \n"
  54               "six = seis sechs\\\n"
  55               " sis\n"
  56               "seven=\"sevenval\" #nocomment\n"
  57               "eight=eightval #nocomment\n"
  58               "export nine=nineval\n"
  59               "ten=ignored\n"
  60               "ten=ignored\n"
  61               "ten=", f);
  62
  63         fflush(f);
  64         fclose(f);
  65
  66         r = load_env_file(NULL, t, NULL, &a);
  67         assert_se(r >= 0);
  68
  69         STRV_FOREACH(i, a)
  70                 log_info("Got: <%s>", *i);
  71
  72         assert_se(streq_ptr(a[0], "one=BAR"));
  73         assert_se(streq_ptr(a[1], "two=bar"));
  74         assert_se(streq_ptr(a[2], "three=333\nxxxx"));
  75         assert_se(streq_ptr(a[3], "four=44\"44"));
  76         assert_se(streq_ptr(a[4], "five=55\'55FIVEcinco"));
  77         assert_se(streq_ptr(a[5], "six=seis sechs sis"));
  78         assert_se(streq_ptr(a[6], "seven=sevenval#nocomment"));
  79         assert_se(streq_ptr(a[7], "eight=eightval #nocomment"));
  80         assert_se(streq_ptr(a[8], "export nine=nineval"));
  81         assert_se(streq_ptr(a[9], "ten="));
  82         assert_se(a[10] == NULL);
  83
  84         strv_env_clean(a);
  85
  86         k = 0;
  87         STRV_FOREACH(i, b) {
  88                 log_info("Got2: <%s>", *i);
  89                 assert_se(streq(*i, a[k++]));
  90         }
  91
  92         r = parse_env_file(
  93                         NULL, t, NULL,
  94                        "one", &one,
  95                        "two", &two,
  96                        "three", &three,
  97                        "four", &four,
  98                        "five", &five,
  99                        "six", &six,
 100                        "seven", &seven,
 101                        "eight", &eight,
 102                        "export nine", &nine,
 103                        "ten", &ten,
 104                        NULL);
 105
 106         assert_se(r >= 0);
 107
 108         log_info("one=[%s]", strna(one));
 109         log_info("two=[%s]", strna(two));
 110         log_info("three=[%s]", strna(three));
 111         log_info("four=[%s]", strna(four));
 112         log_info("five=[%s]", strna(five));
 113         log_info("six=[%s]", strna(six));
 114         log_info("seven=[%s]", strna(seven));
 115         log_info("eight=[%s]", strna(eight));
 116         log_info("export nine=[%s]", strna(nine));
 117         log_info("ten=[%s]", strna(nine));
 118
 119         assert_se(streq(one, "BAR"));
 120         assert_se(streq(two, "bar"));
 121         assert_se(streq(three, "333\nxxxx"));
 122         assert_se(streq(four, "44\"44"));
 123         assert_se(streq(five, "55\'55FIVEcinco"));
 124         assert_se(streq(six, "seis sechs sis"));
 125         assert_se(streq(seven, "sevenval#nocomment"));
 126         assert_se(streq(eight, "eightval #nocomment"));
 127         assert_se(streq(nine, "nineval"));
 128         assert_se(ten == NULL);
 129
 130         r = write_env_file(p, a);
 131         assert_se(r >= 0);
 132
 133         r = load_env_file(NULL, p, NULL, &b);
 134         assert_se(r >= 0);
 135 }
 136
 137 static void test_parse_multiline_env_file(void) {
 138         _cleanup_(unlink_tempfilep) char
 139                 t[] = "/tmp/test-fileio-in-XXXXXX",
 140                 p[] = "/tmp/test-fileio-out-XXXXXX";
 141         int fd, r;
 142         FILE *f;
 143         _cleanup_strv_free_ char **a = NULL, **b = NULL;
 144         char **i;
 145
 146         fd = mkostemp_safe(p);
 147         assert_se(fd >= 0);
 148         close(fd);
 149
 150         fd = mkostemp_safe(t);
 151         assert_se(fd >= 0);
 152
 153         f = fdopen(fd, "w");
 154         assert_se(f);
 155
 156         fputs("one=BAR\\\n"
 157               "    VAR\\\n"
 158               "\tGAR\n"
 159               "#comment\n"
 160               "two=\"bar\\\n"
 161               "    var\\\n"
 162               "\tgar\"\n"
 163               "#comment\n"
 164               "tri=\"bar \\\n"
 165               "    var \\\n"
 166               "\tgar \"\n", f);
 167
 168         fflush(f);
 169         fclose(f);
 170
 171         r = load_env_file(NULL, t, NULL, &a);
 172         assert_se(r >= 0);
 173
 174         STRV_FOREACH(i, a)
 175                 log_info("Got: <%s>", *i);
 176
 177         assert_se(streq_ptr(a[0], "one=BAR    VAR\tGAR"));
 178         assert_se(streq_ptr(a[1], "two=bar    var\tgar"));
 179         assert_se(streq_ptr(a[2], "tri=bar     var \tgar "));
 180         assert_se(a[3] == NULL);
 181
 182         r = write_env_file(p, a);
 183         assert_se(r >= 0);
 184
 185         r = load_env_file(NULL, p, NULL, &b);
 186         assert_se(r >= 0);
 187 }
 188
 189 static void test_merge_env_file(void) {
 190         _cleanup_(unlink_tempfilep) char t[] = "/tmp/test-fileio-XXXXXX";
 191         int fd, r;
 192         _cleanup_fclose_ FILE *f = NULL;
 193         _cleanup_strv_free_ char **a = NULL;
 194         char **i;
 195
 196         fd = mkostemp_safe(t);
 197         assert_se(fd >= 0);
 198
 199         log_info("/* %s (%s) */", __func__, t);
 200
 201         f = fdopen(fd, "w");
 202         assert_se(f);
 203
 204         r = write_string_stream(f,
 205                                 "one=1   \n"
 206                                 "twelve=${one}2\n"
 207                                 "twentyone=2${one}\n"
 208                                 "one=2\n"
 209                                 "twentytwo=2${one}\n"
 210                                 "xxx_minus_three=$xxx - 3\n"
 211                                 "xxx=0x$one$one$one\n"
 212                                 "yyy=${one:-fallback}\n"
 213                                 "zzz=${one:+replacement}\n"
 214                                 "zzzz=${foobar:-${nothing}}\n"
 215                                 "zzzzz=${nothing:+${nothing}}\n"
 216                                 , WRITE_STRING_FILE_AVOID_NEWLINE);
 217         assert(r >= 0);
 218
 219         r = merge_env_file(&a, NULL, t);
 220         assert_se(r >= 0);
 221         strv_sort(a);
 222
 223         STRV_FOREACH(i, a)
 224                 log_info("Got: <%s>", *i);
 225
 226         assert_se(streq(a[0], "one=2"));
 227         assert_se(streq(a[1], "twelve=12"));
 228         assert_se(streq(a[2], "twentyone=21"));
 229         assert_se(streq(a[3], "twentytwo=22"));
 230         assert_se(streq(a[4], "xxx=0x222"));
 231         assert_se(streq(a[5], "xxx_minus_three= - 3"));
 232         assert_se(streq(a[6], "yyy=2"));
 233         assert_se(streq(a[7], "zzz=replacement"));
 234         assert_se(streq(a[8], "zzzz="));
 235         assert_se(streq(a[9], "zzzzz="));
 236         assert_se(a[10] == NULL);
 237
 238         r = merge_env_file(&a, NULL, t);
 239         assert_se(r >= 0);
 240         strv_sort(a);
 241
 242         STRV_FOREACH(i, a)
 243                 log_info("Got2: <%s>", *i);
 244
 245         assert_se(streq(a[0], "one=2"));
 246         assert_se(streq(a[1], "twelve=12"));
 247         assert_se(streq(a[2], "twentyone=21"));
 248         assert_se(streq(a[3], "twentytwo=22"));
 249         assert_se(streq(a[4], "xxx=0x222"));
 250         assert_se(streq(a[5], "xxx_minus_three=0x222 - 3"));
 251         assert_se(streq(a[6], "yyy=2"));
 252         assert_se(streq(a[7], "zzz=replacement"));
 253         assert_se(streq(a[8], "zzzz="));
 254         assert_se(streq(a[9], "zzzzz="));
 255         assert_se(a[10] == NULL);
 256 }
 257
 258 static void test_merge_env_file_invalid(void) {
 259         _cleanup_(unlink_tempfilep) char t[] = "/tmp/test-fileio-XXXXXX";
 260         int fd, r;
 261         _cleanup_fclose_ FILE *f = NULL;
 262         _cleanup_strv_free_ char **a = NULL;
 263         char **i;
 264
 265         fd = mkostemp_safe(t);
 266         assert_se(fd >= 0);
 267
 268         log_info("/* %s (%s) */", __func__, t);
 269
 270         f = fdopen(fd, "w");
 271         assert_se(f);
 272
 273         r = write_string_stream(f,
 274                                 "unset one   \n"
 275                                 "unset one=   \n"
 276                                 "unset one=1   \n"
 277                                 "one   \n"
 278                                 "one =  \n"
 279                                 "one two =\n"
 280                                 "\x20two=\n"
 281                                 "#comment=comment\n"
 282                                 ";comment2=comment2\n"
 283                                 "#\n"
 284                                 "\n\n"                  /* empty line */
 285                                 , WRITE_STRING_FILE_AVOID_NEWLINE);
 286         assert(r >= 0);
 287
 288         r = merge_env_file(&a, NULL, t);
 289         assert_se(r >= 0);
 290
 291         STRV_FOREACH(i, a)
 292                 log_info("Got: <%s>", *i);
 293
 294         assert_se(strv_isempty(a));
 295 }
 296
 297 static void test_executable_is_script(void) {
 298         _cleanup_(unlink_tempfilep) char t[] = "/tmp/test-fileio-XXXXXX";
 299         int fd, r;
 300         _cleanup_fclose_ FILE *f = NULL;
 301         char *command;
 302
 303         fd = mkostemp_safe(t);
 304         assert_se(fd >= 0);
 305
 306         f = fdopen(fd, "w");
 307         assert_se(f);
 308
 309         fputs("#! /bin/script -a -b \ngoo goo", f);
 310         fflush(f);
 311
 312         r = executable_is_script(t, &command);
 313         assert_se(r > 0);
 314         assert_se(streq(command, "/bin/script"));
 315         free(command);
 316
 317         r = executable_is_script("/bin/sh", &command);
 318         assert_se(r == 0);
 319
 320         r = executable_is_script("/usr/bin/yum", &command);
 321         assert_se(r > 0 || r == -ENOENT);
 322         if (r > 0) {
 323                 assert_se(startswith(command, "/"));
 324                 free(command);
 325         }
 326 }
 327
 328 static void test_status_field(void) {
 329         _cleanup_free_ char *t = NULL, *p = NULL, *s = NULL, *z = NULL;
 330         unsigned long long total = 0, buffers = 0;
 331         int r;
 332
 333         assert_se(get_proc_field("/proc/self/status", "Threads", WHITESPACE, &t) == 0);
 334         puts(t);
 335         assert_se(streq(t, "1"));
 336
 337         r = get_proc_field("/proc/meminfo", "MemTotal", WHITESPACE, &p);
 338         if (r != -ENOENT) {
 339                 assert_se(r == 0);
 340                 puts(p);
 341                 assert_se(safe_atollu(p, &total) == 0);
 342         }
 343
 344         r = get_proc_field("/proc/meminfo", "Buffers", WHITESPACE, &s);
 345         if (r != -ENOENT) {
 346                 assert_se(r == 0);
 347                 puts(s);
 348                 assert_se(safe_atollu(s, &buffers) == 0);
 349         }
 350
 351         if (p)
 352                 assert_se(buffers < total);
 353
 354         /* Seccomp should be a good test for field full of zeros. */
 355         r = get_proc_field("/proc/meminfo", "Seccomp", WHITESPACE, &z);
 356         if (r != -ENOENT) {
 357                 assert_se(r == 0);
 358                 puts(z);
 359                 assert_se(safe_atollu(z, &buffers) == 0);
 360         }
 361 }
 362
 363 static void test_capeff(void) {
 364         int pid, p;
 365
 366         for (pid = 0; pid < 2; pid++) {
 367                 _cleanup_free_ char *capeff = NULL;
 368                 int r;
 369
 370                 r = get_process_capeff(0, &capeff);
 371                 log_info("capeff: '%s' (r=%d)", capeff, r);
 372
 373                 if (IN_SET(r, -ENOENT, -EPERM))
 374                         return;
 375
 376                 assert_se(r == 0);
 377                 assert_se(*capeff);
 378                 p = capeff[strspn(capeff, HEXDIGITS)];
 379                 assert_se(!p || isspace(p));
 380         }
 381 }
 382
 383 static void test_write_string_stream(void) {
 384         _cleanup_(unlink_tempfilep) char fn[] = "/tmp/test-write_string_stream-XXXXXX";
 385         _cleanup_fclose_ FILE *f = NULL;
 386         int fd;
 387         char buf[64];
 388
 389         fd = mkostemp_safe(fn);
 390         assert_se(fd >= 0);
 391
 392         f = fdopen(fd, "r");
 393         assert_se(f);
 394         assert_se(write_string_stream(f, "boohoo", 0) < 0);
 395         f = safe_fclose(f);
 396
 397         f = fopen(fn, "r+");
 398         assert_se(f);
 399
 400         assert_se(write_string_stream(f, "boohoo", 0) == 0);
 401         rewind(f);
 402
 403         assert_se(fgets(buf, sizeof(buf), f));
 404         assert_se(streq(buf, "boohoo\n"));
 405         f = safe_fclose(f);
 406
 407         f = fopen(fn, "w+");
 408         assert_se(f);
 409
 410         assert_se(write_string_stream(f, "boohoo", WRITE_STRING_FILE_AVOID_NEWLINE) == 0);
 411         rewind(f);
 412
 413         assert_se(fgets(buf, sizeof(buf), f));
 414         printf(">%s<", buf);
 415         assert_se(streq(buf, "boohoo"));
 416 }
 417
 418 static void test_write_string_file(void) {
 419         _cleanup_(unlink_tempfilep) char fn[] = "/tmp/test-write_string_file-XXXXXX";
 420         char buf[64] = {};
 421         _cleanup_close_ int fd;
 422
 423         fd = mkostemp_safe(fn);
 424         assert_se(fd >= 0);
 425
 426         assert_se(write_string_file(fn, "boohoo", WRITE_STRING_FILE_CREATE) == 0);
 427
 428         assert_se(read(fd, buf, sizeof(buf)) == 7);
 429         assert_se(streq(buf, "boohoo\n"));
 430 }
 431
 432 static void test_write_string_file_no_create(void) {
 433         _cleanup_(unlink_tempfilep) char fn[] = "/tmp/test-write_string_file_no_create-XXXXXX";
 434         _cleanup_close_ int fd;
 435         char buf[64] = {0};
 436
 437         fd = mkostemp_safe(fn);
 438         assert_se(fd >= 0);
 439
 440         assert_se(write_string_file("/a/file/which/does/not/exists/i/guess", "boohoo", 0) < 0);
 441         assert_se(write_string_file(fn, "boohoo", 0) == 0);
 442
 443         assert_se(read(fd, buf, sizeof(buf)) == STRLEN("boohoo\n"));
 444         assert_se(streq(buf, "boohoo\n"));
 445 }
 446
 447 static void test_write_string_file_verify(void) {
 448         _cleanup_free_ char *buf = NULL, *buf2 = NULL;
 449         int r;
 450
 451         assert_se(read_one_line_file("/proc/cmdline", &buf) >= 0);
 452         assert_se(buf2 = strjoin(buf, "\n"));
 453
 454         r = write_string_file("/proc/cmdline", buf, 0);
 455         assert_se(IN_SET(r, -EACCES, -EIO));
 456         r = write_string_file("/proc/cmdline", buf2, 0);
 457         assert_se(IN_SET(r, -EACCES, -EIO));
 458
 459         assert_se(write_string_file("/proc/cmdline", buf, WRITE_STRING_FILE_VERIFY_ON_FAILURE) == 0);
 460         assert_se(write_string_file("/proc/cmdline", buf2, WRITE_STRING_FILE_VERIFY_ON_FAILURE) == 0);
 461
 462         r = write_string_file("/proc/cmdline", buf, WRITE_STRING_FILE_VERIFY_ON_FAILURE|WRITE_STRING_FILE_AVOID_NEWLINE);
 463         assert_se(IN_SET(r, -EACCES, -EIO));
 464         assert_se(write_string_file("/proc/cmdline", buf2, WRITE_STRING_FILE_VERIFY_ON_FAILURE|WRITE_STRING_FILE_AVOID_NEWLINE) == 0);
 465 }
 466
 467 static void test_load_env_file_pairs(void) {
 468         _cleanup_(unlink_tempfilep) char fn[] = "/tmp/test-load_env_file_pairs-XXXXXX";
 469         int fd, r;
 470         _cleanup_fclose_ FILE *f = NULL;
 471         _cleanup_strv_free_ char **l = NULL;
 472         char **k, **v;
 473
 474         fd = mkostemp_safe(fn);
 475         assert_se(fd >= 0);
 476
 477         r = write_string_file(fn,
 478                         "NAME=\"Arch Linux\"\n"
 479                         "ID=arch\n"
 480                         "PRETTY_NAME=\"Arch Linux\"\n"
 481                         "ANSI_COLOR=\"0;36\"\n"
 482                         "HOME_URL=\"https://www.archlinux.org/\"\n"
 483                         "SUPPORT_URL=\"https://bbs.archlinux.org/\"\n"
 484                         "BUG_REPORT_URL=\"https://bugs.archlinux.org/\"\n",
 485                         WRITE_STRING_FILE_CREATE);
 486         assert_se(r == 0);
 487
 488         f = fdopen(fd, "r");
 489         assert_se(f);
 490
 491         r = load_env_file_pairs(f, fn, NULL, &l);
 492         assert_se(r >= 0);
 493
 494         assert_se(strv_length(l) == 14);
 495         STRV_FOREACH_PAIR(k, v, l) {
 496                 assert_se(STR_IN_SET(*k, "NAME", "ID", "PRETTY_NAME", "ANSI_COLOR", "HOME_URL", "SUPPORT_URL", "BUG_REPORT_URL"));
 497                 printf("%s=%s\n", *k, *v);
 498                 if (streq(*k, "NAME")) assert_se(streq(*v, "Arch Linux"));
 499                 if (streq(*k, "ID")) assert_se(streq(*v, "arch"));
 500                 if (streq(*k, "PRETTY_NAME")) assert_se(streq(*v, "Arch Linux"));
 501                 if (streq(*k, "ANSI_COLOR")) assert_se(streq(*v, "0;36"));
 502                 if (streq(*k, "HOME_URL")) assert_se(streq(*v, "https://www.archlinux.org/"));
 503                 if (streq(*k, "SUPPORT_URL")) assert_se(streq(*v, "https://bbs.archlinux.org/"));
 504                 if (streq(*k, "BUG_REPORT_URL")) assert_se(streq(*v, "https://bugs.archlinux.org/"));
 505         }
 506 }
 507
 508 static void test_search_and_fopen(void) {
 509         const char *dirs[] = {"/tmp/foo/bar", "/tmp", NULL};
 510
 511         char name[] = "/tmp/test-search_and_fopen.XXXXXX";
 512         int fd, r;
 513         FILE *f;
 514
 515         fd = mkostemp_safe(name);
 516         assert_se(fd >= 0);
 517         close(fd);
 518
 519         r = search_and_fopen(basename(name), "r", NULL, dirs, &f);
 520         assert_se(r >= 0);
 521         fclose(f);
 522
 523         r = search_and_fopen(name, "r", NULL, dirs, &f);
 524         assert_se(r >= 0);
 525         fclose(f);
 526
 527         r = search_and_fopen(basename(name), "r", "/", dirs, &f);
 528         assert_se(r >= 0);
 529         fclose(f);
 530
 531         r = search_and_fopen("/a/file/which/does/not/exist/i/guess", "r", NULL, dirs, &f);
 532         assert_se(r < 0);
 533         r = search_and_fopen("afilewhichdoesnotexistiguess", "r", NULL, dirs, &f);
 534         assert_se(r < 0);
 535
 536         r = unlink(name);
 537         assert_se(r == 0);
 538
 539         r = search_and_fopen(basename(name), "r", NULL, dirs, &f);
 540         assert_se(r < 0);
 541 }
 542
 543 static void test_search_and_fopen_nulstr(void) {
 544         const char dirs[] = "/tmp/foo/bar\0/tmp\0";
 545
 546         _cleanup_(unlink_tempfilep) char name[] = "/tmp/test-search_and_fopen.XXXXXX";
 547         int fd, r;
 548         FILE *f;
 549
 550         fd = mkostemp_safe(name);
 551         assert_se(fd >= 0);
 552         close(fd);
 553
 554         r = search_and_fopen_nulstr(basename(name), "r", NULL, dirs, &f);
 555         assert_se(r >= 0);
 556         fclose(f);
 557
 558         r = search_and_fopen_nulstr(name, "r", NULL, dirs, &f);
 559         assert_se(r >= 0);
 560         fclose(f);
 561
 562         r = search_and_fopen_nulstr("/a/file/which/does/not/exist/i/guess", "r", NULL, dirs, &f);
 563         assert_se(r < 0);
 564         r = search_and_fopen_nulstr("afilewhichdoesnotexistiguess", "r", NULL, dirs, &f);
 565         assert_se(r < 0);
 566
 567         r = unlink(name);
 568         assert_se(r == 0);
 569
 570         r = search_and_fopen_nulstr(basename(name), "r", NULL, dirs, &f);
 571         assert_se(r < 0);
 572 }
 573
 574 static void test_writing_tmpfile(void) {
 575         _cleanup_(unlink_tempfilep) char name[] = "/tmp/test-systemd_writing_tmpfile.XXXXXX";
 576         _cleanup_free_ char *contents = NULL;
 577         size_t size;
 578         _cleanup_close_ int fd = -1;
 579         struct iovec iov[3];
 580         int r;
 581
 582         iov[0] = IOVEC_MAKE_STRING("abc\n");
 583         iov[1] = IOVEC_MAKE_STRING(ALPHANUMERICAL "\n");
 584         iov[2] = IOVEC_MAKE_STRING("");
 585
 586         fd = mkostemp_safe(name);
 587         printf("tmpfile: %s", name);
 588
 589         r = writev(fd, iov, 3);
 590         assert_se(r >= 0);
 591
 592         r = read_full_file(name, &contents, &size);
 593         assert_se(r == 0);
 594         printf("contents: %s", contents);
 595         assert_se(streq(contents, "abc\n" ALPHANUMERICAL "\n"));
 596 }
 597
 598 static void test_tempfn(void) {
 599         char *ret = NULL, *p;
 600
 601         assert_se(tempfn_xxxxxx("/foo/bar/waldo", NULL, &ret) >= 0);
 602         assert_se(streq_ptr(ret, "/foo/bar/.#waldoXXXXXX"));
 603         free(ret);
 604
 605         assert_se(tempfn_xxxxxx("/foo/bar/waldo", "[miau]", &ret) >= 0);
 606         assert_se(streq_ptr(ret, "/foo/bar/.#[miau]waldoXXXXXX"));
 607         free(ret);
 608
 609         assert_se(tempfn_random("/foo/bar/waldo", NULL, &ret) >= 0);
 610         assert_se(p = startswith(ret, "/foo/bar/.#waldo"));
 611         assert_se(strlen(p) == 16);
 612         assert_se(in_charset(p, "0123456789abcdef"));
 613         free(ret);
 614
 615         assert_se(tempfn_random("/foo/bar/waldo", "[wuff]", &ret) >= 0);
 616         assert_se(p = startswith(ret, "/foo/bar/.#[wuff]waldo"));
 617         assert_se(strlen(p) == 16);
 618         assert_se(in_charset(p, "0123456789abcdef"));
 619         free(ret);
 620
 621         assert_se(tempfn_random_child("/foo/bar/waldo", NULL, &ret) >= 0);
 622         assert_se(p = startswith(ret, "/foo/bar/waldo/.#"));
 623         assert_se(strlen(p) == 16);
 624         assert_se(in_charset(p, "0123456789abcdef"));
 625         free(ret);
 626
 627         assert_se(tempfn_random_child("/foo/bar/waldo", "[kikiriki]", &ret) >= 0);
 628         assert_se(p = startswith(ret, "/foo/bar/waldo/.#[kikiriki]"));
 629         assert_se(strlen(p) == 16);
 630         assert_se(in_charset(p, "0123456789abcdef"));
 631         free(ret);
 632 }
 633
 634 static const char buffer[] =
 635         "Some test data\n"
 636         "With newlines, and a NUL byte\0"
 637         "\n"
 638         "an empty line\n"
 639         "an ignored line\n"
 640         "and a very long line that is supposed to be truncated, because it is so long\n";
 641
 642 static void test_read_line_one_file(FILE *f) {
 643         _cleanup_free_ char *line = NULL;
 644
 645         assert_se(read_line(f, (size_t) -1, &line) == 15 && streq(line, "Some test data"));
 646         line = mfree(line);
 647
 648         assert_se(read_line(f, 1024, &line) == 30 && streq(line, "With newlines, and a NUL byte"));
 649         line = mfree(line);
 650
 651         assert_se(read_line(f, 1024, &line) == 1 && streq(line, ""));
 652         line = mfree(line);
 653
 654         assert_se(read_line(f, 1024, &line) == 14 && streq(line, "an empty line"));
 655         line = mfree(line);
 656
 657         assert_se(read_line(f, (size_t) -1, NULL) == 16);
 658
 659         assert_se(read_line(f, 16, &line) == -ENOBUFS);
 660         line = mfree(line);
 661
 662         /* read_line() stopped when it hit the limit, that means when we continue reading we'll read at the first
 663          * character after the previous limit. Let's make use of tha to continue our test. */
 664         assert_se(read_line(f, 1024, &line) == 61 && streq(line, "line that is supposed to be truncated, because it is so long"));
 665         line = mfree(line);
 666
 667         assert_se(read_line(f, 1024, &line) == 1 && streq(line, ""));
 668         line = mfree(line);
 669
 670         assert_se(read_line(f, 1024, &line) == 0 && streq(line, ""));
 671 }
 672
 673 static void test_read_line(void) {
 674         _cleanup_fclose_ FILE *f = NULL;
 675
 676         f = fmemopen((void*) buffer, sizeof(buffer), "re");
 677         assert_se(f);
 678
 679         test_read_line_one_file(f);
 680 }
 681
 682 static void test_read_line2(void) {
 683         _cleanup_(unlink_tempfilep) char name[] = "/tmp/test-fileio.XXXXXX";
 684         int fd;
 685         _cleanup_fclose_ FILE *f = NULL;
 686
 687         fd = mkostemp_safe(name);
 688         assert_se(fd >= 0);
 689         assert_se((size_t) write(fd, buffer, sizeof(buffer)) == sizeof(buffer));
 690
 691         assert_se(lseek(fd, 0, SEEK_SET) == 0);
 692         assert_se(f = fdopen(fd, "r"));
 693
 694         test_read_line_one_file(f);
 695 }
 696
 697 static void test_read_line3(void) {
 698         _cleanup_fclose_ FILE *f = NULL;
 699         _cleanup_free_ char *line = NULL;
 700         int r;
 701
 702         f = fopen("/proc/cmdline", "re");
 703         if (!f && IN_SET(errno, ENOENT, EPERM))
 704                 return;
 705         assert_se(f);
 706
 707         r = read_line(f, LINE_MAX, &line);
 708         assert_se((size_t) r == strlen(line) + 1);
 709         assert_se(read_line(f, LINE_MAX, NULL) == 0);
 710 }
 711
 712 int main(int argc, char *argv[]) {
 713         log_set_max_level(LOG_DEBUG);
 714         log_parse_environment();
 715         log_open();
 716
 717         test_parse_env_file();
 718         test_parse_multiline_env_file();
 719         test_merge_env_file();
 720         test_merge_env_file_invalid();
 721         test_executable_is_script();
 722         test_status_field();
 723         test_capeff();
 724         test_write_string_stream();
 725         test_write_string_file();
 726         test_write_string_file_no_create();
 727         test_write_string_file_verify();
 728         test_load_env_file_pairs();
 729         test_search_and_fopen();
 730         test_search_and_fopen_nulstr();
 731         test_writing_tmpfile();
 732         test_tempfn();
 733         test_read_line();
 734         test_read_line2();
 735         test_read_line3();
 736
 737         return 0;
 738 }