src/test/test-fileio.c

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