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=", f);
  75
  76         fflush(f);
  77         fclose(f);
  78
  79         r = load_env_file(NULL, t, NULL, &a);
  80         assert_se(r >= 0);
  81
  82         STRV_FOREACH(i, a)
  83                 log_info("Got: <%s>", *i);
  84
  85         assert_se(streq_ptr(a[0], "one=BAR"));
  86         assert_se(streq_ptr(a[1], "two=bar"));
  87         assert_se(streq_ptr(a[2], "three=333\nxxxx"));
  88         assert_se(streq_ptr(a[3], "four=44\"44"));
  89         assert_se(streq_ptr(a[4], "five=55\'55FIVEcinco"));
  90         assert_se(streq_ptr(a[5], "six=seis sechs sis"));
  91         assert_se(streq_ptr(a[6], "seven=sevenval#nocomment"));
  92         assert_se(streq_ptr(a[7], "eight=eightval #nocomment"));
  93         assert_se(streq_ptr(a[8], "export nine=nineval"));
  94         assert_se(streq_ptr(a[9], "ten="));
  95         assert_se(a[10] == NULL);
  96
  97         strv_env_clean(a);
  98
  99         k = 0;
 100         STRV_FOREACH(i, b) {
 101                 log_info("Got2: <%s>", *i);
 102                 assert_se(streq(*i, a[k++]));
 103         }
 104
 105         r = parse_env_file(
 106                         t, NULL,
 107                        "one", &one,
 108                        "two", &two,
 109                        "three", &three,
 110                        "four", &four,
 111                        "five", &five,
 112                        "six", &six,
 113                        "seven", &seven,
 114                        "eight", &eight,
 115                        "export nine", &nine,
 116                        "ten", &ten,
 117                        NULL);
 118
 119         assert_se(r >= 0);
 120
 121         log_info("one=[%s]", strna(one));
 122         log_info("two=[%s]", strna(two));
 123         log_info("three=[%s]", strna(three));
 124         log_info("four=[%s]", strna(four));
 125         log_info("five=[%s]", strna(five));
 126         log_info("six=[%s]", strna(six));
 127         log_info("seven=[%s]", strna(seven));
 128         log_info("eight=[%s]", strna(eight));
 129         log_info("export nine=[%s]", strna(nine));
 130         log_info("ten=[%s]", strna(nine));
 131
 132         assert_se(streq(one, "BAR"));
 133         assert_se(streq(two, "bar"));
 134         assert_se(streq(three, "333\nxxxx"));
 135         assert_se(streq(four, "44\"44"));
 136         assert_se(streq(five, "55\'55FIVEcinco"));
 137         assert_se(streq(six, "seis sechs sis"));
 138         assert_se(streq(seven, "sevenval#nocomment"));
 139         assert_se(streq(eight, "eightval #nocomment"));
 140         assert_se(streq(nine, "nineval"));
 141         assert_se(ten == NULL);
 142
 143         r = write_env_file(p, a);
 144         assert_se(r >= 0);
 145
 146         r = load_env_file(NULL, p, NULL, &b);
 147         assert_se(r >= 0);
 148
 149         unlink(t);
 150         unlink(p);
 151 }
 152
 153 static void test_parse_multiline_env_file(void) {
 154         char    t[] = "/tmp/test-fileio-in-XXXXXX",
 155                 p[] = "/tmp/test-fileio-out-XXXXXX";
 156         int fd, r;
 157         FILE *f;
 158         _cleanup_strv_free_ char **a = NULL, **b = NULL;
 159         char **i;
 160
 161         fd = mkostemp_safe(p);
 162         assert_se(fd >= 0);
 163         close(fd);
 164
 165         fd = mkostemp_safe(t);
 166         assert_se(fd >= 0);
 167
 168         f = fdopen(fd, "w");
 169         assert_se(f);
 170
 171         fputs("one=BAR\\\n"
 172               "    VAR\\\n"
 173               "\tGAR\n"
 174               "#comment\n"
 175               "two=\"bar\\\n"
 176               "    var\\\n"
 177               "\tgar\"\n"
 178               "#comment\n"
 179               "tri=\"bar \\\n"
 180               "    var \\\n"
 181               "\tgar \"\n", f);
 182
 183         fflush(f);
 184         fclose(f);
 185
 186         r = load_env_file(NULL, t, NULL, &a);
 187         assert_se(r >= 0);
 188
 189         STRV_FOREACH(i, a)
 190                 log_info("Got: <%s>", *i);
 191
 192         assert_se(streq_ptr(a[0], "one=BAR    VAR\tGAR"));
 193         assert_se(streq_ptr(a[1], "two=bar    var\tgar"));
 194         assert_se(streq_ptr(a[2], "tri=bar     var \tgar "));
 195         assert_se(a[3] == NULL);
 196
 197         r = write_env_file(p, a);
 198         assert_se(r >= 0);
 199
 200         r = load_env_file(NULL, p, NULL, &b);
 201         assert_se(r >= 0);
 202
 203         unlink(t);
 204         unlink(p);
 205 }
 206
 207
 208 static void test_executable_is_script(void) {
 209         char t[] = "/tmp/test-executable-XXXXXX";
 210         int fd, r;
 211         FILE *f;
 212         char *command;
 213
 214         fd = mkostemp_safe(t);
 215         assert_se(fd >= 0);
 216
 217         f = fdopen(fd, "w");
 218         assert_se(f);
 219
 220         fputs("#! /bin/script -a -b \ngoo goo", f);
 221         fflush(f);
 222
 223         r = executable_is_script(t, &command);
 224         assert_se(r > 0);
 225         assert_se(streq(command, "/bin/script"));
 226         free(command);
 227
 228         r = executable_is_script("/bin/sh", &command);
 229         assert_se(r == 0);
 230
 231         r = executable_is_script("/usr/bin/yum", &command);
 232         assert_se(r > 0 || r == -ENOENT);
 233         if (r > 0) {
 234                 assert_se(startswith(command, "/"));
 235                 free(command);
 236         }
 237
 238         fclose(f);
 239         unlink(t);
 240 }
 241
 242 static void test_status_field(void) {
 243         _cleanup_free_ char *t = NULL, *p = NULL, *s = NULL, *z = NULL;
 244         unsigned long long total = 0, buffers = 0;
 245         int r;
 246
 247         assert_se(get_proc_field("/proc/self/status", "Threads", WHITESPACE, &t) == 0);
 248         puts(t);
 249         assert_se(streq(t, "1"));
 250
 251         r = get_proc_field("/proc/meminfo", "MemTotal", WHITESPACE, &p);
 252         if (r != -ENOENT) {
 253                 assert_se(r == 0);
 254                 puts(p);
 255                 assert_se(safe_atollu(p, &total) == 0);
 256         }
 257
 258         r = get_proc_field("/proc/meminfo", "Buffers", WHITESPACE, &s);
 259         if (r != -ENOENT) {
 260                 assert_se(r == 0);
 261                 puts(s);
 262                 assert_se(safe_atollu(s, &buffers) == 0);
 263         }
 264
 265         if (p)
 266                 assert_se(buffers < total);
 267
 268         /* Seccomp should be a good test for field full of zeros. */
 269         r = get_proc_field("/proc/meminfo", "Seccomp", WHITESPACE, &z);
 270         if (r != -ENOENT) {
 271                 assert_se(r == 0);
 272                 puts(z);
 273                 assert_se(safe_atollu(z, &buffers) == 0);
 274         }
 275 }
 276
 277 static void test_capeff(void) {
 278         int pid, p;
 279
 280         for (pid = 0; pid < 2; pid++) {
 281                 _cleanup_free_ char *capeff = NULL;
 282                 int r;
 283
 284                 r = get_process_capeff(0, &capeff);
 285                 log_info("capeff: '%s' (r=%d)", capeff, r);
 286
 287                 if (r == -ENOENT || r == -EPERM)
 288                         return;
 289
 290                 assert_se(r == 0);
 291                 assert_se(*capeff);
 292                 p = capeff[strspn(capeff, HEXDIGITS)];
 293                 assert_se(!p || isspace(p));
 294         }
 295 }
 296
 297 static void test_write_string_stream(void) {
 298         char fn[] = "/tmp/test-write_string_stream-XXXXXX";
 299         _cleanup_fclose_ FILE *f = NULL;
 300         int fd;
 301         char buf[64];
 302
 303         fd = mkostemp_safe(fn);
 304         assert_se(fd >= 0);
 305
 306         f = fdopen(fd, "r");
 307         assert_se(f);
 308         assert_se(write_string_stream(f, "boohoo", true) < 0);
 309
 310         f = freopen(fn, "r+", f);
 311         assert_se(f);
 312
 313         assert_se(write_string_stream(f, "boohoo", true) == 0);
 314         rewind(f);
 315
 316         assert_se(fgets(buf, sizeof(buf), f));
 317         assert_se(streq(buf, "boohoo\n"));
 318
 319         f = freopen(fn, "w+", f);
 320         assert_se(f);
 321
 322         assert_se(write_string_stream(f, "boohoo", false) == 0);
 323         rewind(f);
 324
 325         assert_se(fgets(buf, sizeof(buf), f));
 326         printf(">%s<", buf);
 327         assert_se(streq(buf, "boohoo"));
 328
 329         unlink(fn);
 330 }
 331
 332 static void test_write_string_file(void) {
 333         char fn[] = "/tmp/test-write_string_file-XXXXXX";
 334         char buf[64] = {};
 335         _cleanup_close_ int fd;
 336
 337         fd = mkostemp_safe(fn);
 338         assert_se(fd >= 0);
 339
 340         assert_se(write_string_file(fn, "boohoo", WRITE_STRING_FILE_CREATE) == 0);
 341
 342         assert_se(read(fd, buf, sizeof(buf)) == 7);
 343         assert_se(streq(buf, "boohoo\n"));
 344
 345         unlink(fn);
 346 }
 347
 348 static void test_write_string_file_no_create(void) {
 349         char fn[] = "/tmp/test-write_string_file_no_create-XXXXXX";
 350         _cleanup_close_ int fd;
 351         char buf[64] = {0};
 352
 353         fd = mkostemp_safe(fn);
 354         assert_se(fd >= 0);
 355
 356         assert_se(write_string_file("/a/file/which/does/not/exists/i/guess", "boohoo", 0) < 0);
 357         assert_se(write_string_file(fn, "boohoo", 0) == 0);
 358
 359         assert_se(read(fd, buf, sizeof(buf)) == strlen("boohoo\n"));
 360         assert_se(streq(buf, "boohoo\n"));
 361
 362         unlink(fn);
 363 }
 364
 365 static void test_write_string_file_verify(void) {
 366         _cleanup_free_ char *buf = NULL, *buf2 = NULL;
 367         int r;
 368
 369         assert_se(read_one_line_file("/proc/cmdline", &buf) >= 0);
 370         assert_se((buf2 = strjoin(buf, "\n", NULL)));
 371
 372         r = write_string_file("/proc/cmdline", buf, 0);
 373         assert_se(r == -EACCES || r == -EIO);
 374         r = write_string_file("/proc/cmdline", buf2, 0);
 375         assert_se(r == -EACCES || r == -EIO);
 376
 377         assert_se(write_string_file("/proc/cmdline", buf, WRITE_STRING_FILE_VERIFY_ON_FAILURE) == 0);
 378         assert_se(write_string_file("/proc/cmdline", buf2, WRITE_STRING_FILE_VERIFY_ON_FAILURE) == 0);
 379
 380         r = write_string_file("/proc/cmdline", buf, WRITE_STRING_FILE_VERIFY_ON_FAILURE|WRITE_STRING_FILE_AVOID_NEWLINE);
 381         assert_se(r == -EACCES || r == -EIO);
 382         assert_se(write_string_file("/proc/cmdline", buf2, WRITE_STRING_FILE_VERIFY_ON_FAILURE|WRITE_STRING_FILE_AVOID_NEWLINE) == 0);
 383 }
 384
 385 static void test_load_env_file_pairs(void) {
 386         char fn[] = "/tmp/test-load_env_file_pairs-XXXXXX";
 387         int fd;
 388         int r;
 389         _cleanup_fclose_ FILE *f = NULL;
 390         _cleanup_strv_free_ char **l = NULL;
 391         char **k, **v;
 392
 393         fd = mkostemp_safe(fn);
 394         assert_se(fd >= 0);
 395
 396         r = write_string_file(fn,
 397                         "NAME=\"Arch Linux\"\n"
 398                         "ID=arch\n"
 399                         "PRETTY_NAME=\"Arch Linux\"\n"
 400                         "ANSI_COLOR=\"0;36\"\n"
 401                         "HOME_URL=\"https://www.archlinux.org/\"\n"
 402                         "SUPPORT_URL=\"https://bbs.archlinux.org/\"\n"
 403                         "BUG_REPORT_URL=\"https://bugs.archlinux.org/\"\n",
 404                         WRITE_STRING_FILE_CREATE);
 405         assert_se(r == 0);
 406
 407         f = fdopen(fd, "r");
 408         assert_se(f);
 409
 410         r = load_env_file_pairs(f, fn, NULL, &l);
 411         assert_se(r >= 0);
 412
 413         assert_se(strv_length(l) == 14);
 414         STRV_FOREACH_PAIR(k, v, l) {
 415                 assert_se(STR_IN_SET(*k, "NAME", "ID", "PRETTY_NAME", "ANSI_COLOR", "HOME_URL", "SUPPORT_URL", "BUG_REPORT_URL"));
 416                 printf("%s=%s\n", *k, *v);
 417                 if (streq(*k, "NAME")) assert_se(streq(*v, "Arch Linux"));
 418                 if (streq(*k, "ID")) assert_se(streq(*v, "arch"));
 419                 if (streq(*k, "PRETTY_NAME")) assert_se(streq(*v, "Arch Linux"));
 420                 if (streq(*k, "ANSI_COLOR")) assert_se(streq(*v, "0;36"));
 421                 if (streq(*k, "HOME_URL")) assert_se(streq(*v, "https://www.archlinux.org/"));
 422                 if (streq(*k, "SUPPORT_URL")) assert_se(streq(*v, "https://bbs.archlinux.org/"));
 423                 if (streq(*k, "BUG_REPORT_URL")) assert_se(streq(*v, "https://bugs.archlinux.org/"));
 424         }
 425
 426         unlink(fn);
 427 }
 428
 429 static void test_search_and_fopen(void) {
 430         const char *dirs[] = {"/tmp/foo/bar", "/tmp", NULL};
 431         char name[] = "/tmp/test-search_and_fopen.XXXXXX";
 432         int fd = -1;
 433         int r;
 434         FILE *f;
 435
 436         fd = mkostemp_safe(name);
 437         assert_se(fd >= 0);
 438         close(fd);
 439
 440         r = search_and_fopen(basename(name), "r", NULL, dirs, &f);
 441         assert_se(r >= 0);
 442         fclose(f);
 443
 444         r = search_and_fopen(name, "r", NULL, dirs, &f);
 445         assert_se(r >= 0);
 446         fclose(f);
 447
 448         r = search_and_fopen(basename(name), "r", "/", dirs, &f);
 449         assert_se(r >= 0);
 450         fclose(f);
 451
 452         r = search_and_fopen("/a/file/which/does/not/exist/i/guess", "r", NULL, dirs, &f);
 453         assert_se(r < 0);
 454         r = search_and_fopen("afilewhichdoesnotexistiguess", "r", NULL, dirs, &f);
 455         assert_se(r < 0);
 456
 457         r = unlink(name);
 458         assert_se(r == 0);
 459
 460         r = search_and_fopen(basename(name), "r", NULL, dirs, &f);
 461         assert_se(r < 0);
 462 }
 463
 464
 465 static void test_search_and_fopen_nulstr(void) {
 466         const char dirs[] = "/tmp/foo/bar\0/tmp\0";
 467         char name[] = "/tmp/test-search_and_fopen.XXXXXX";
 468         int fd = -1;
 469         int r;
 470         FILE *f;
 471
 472         fd = mkostemp_safe(name);
 473         assert_se(fd >= 0);
 474         close(fd);
 475
 476         r = search_and_fopen_nulstr(basename(name), "r", NULL, dirs, &f);
 477         assert_se(r >= 0);
 478         fclose(f);
 479
 480         r = search_and_fopen_nulstr(name, "r", NULL, dirs, &f);
 481         assert_se(r >= 0);
 482         fclose(f);
 483
 484         r = search_and_fopen_nulstr("/a/file/which/does/not/exist/i/guess", "r", NULL, dirs, &f);
 485         assert_se(r < 0);
 486         r = search_and_fopen_nulstr("afilewhichdoesnotexistiguess", "r", NULL, dirs, &f);
 487         assert_se(r < 0);
 488
 489         r = unlink(name);
 490         assert_se(r == 0);
 491
 492         r = search_and_fopen_nulstr(basename(name), "r", NULL, dirs, &f);
 493         assert_se(r < 0);
 494 }
 495
 496 static void test_writing_tmpfile(void) {
 497         char name[] = "/tmp/test-systemd_writing_tmpfile.XXXXXX";
 498         _cleanup_free_ char *contents = NULL;
 499         size_t size;
 500         int fd, r;
 501         struct iovec iov[3];
 502
 503         IOVEC_SET_STRING(iov[0], "abc\n");
 504         IOVEC_SET_STRING(iov[1], ALPHANUMERICAL "\n");
 505         IOVEC_SET_STRING(iov[2], "");
 506
 507         fd = mkostemp_safe(name);
 508         printf("tmpfile: %s", name);
 509
 510         r = writev(fd, iov, 3);
 511         assert_se(r >= 0);
 512
 513         r = read_full_file(name, &contents, &size);
 514         assert_se(r == 0);
 515         printf("contents: %s", contents);
 516         assert_se(streq(contents, "abc\n" ALPHANUMERICAL "\n"));
 517
 518         unlink(name);
 519 }
 520
 521 static void test_tempfn(void) {
 522         char *ret = NULL, *p;
 523
 524         assert_se(tempfn_xxxxxx("/foo/bar/waldo", NULL, &ret) >= 0);
 525         assert_se(streq_ptr(ret, "/foo/bar/.#waldoXXXXXX"));
 526         free(ret);
 527
 528         assert_se(tempfn_xxxxxx("/foo/bar/waldo", "[miau]", &ret) >= 0);
 529         assert_se(streq_ptr(ret, "/foo/bar/.#[miau]waldoXXXXXX"));
 530         free(ret);
 531
 532         assert_se(tempfn_random("/foo/bar/waldo", NULL, &ret) >= 0);
 533         assert_se(p = startswith(ret, "/foo/bar/.#waldo"));
 534         assert_se(strlen(p) == 16);
 535         assert_se(in_charset(p, "0123456789abcdef"));
 536         free(ret);
 537
 538         assert_se(tempfn_random("/foo/bar/waldo", "[wuff]", &ret) >= 0);
 539         assert_se(p = startswith(ret, "/foo/bar/.#[wuff]waldo"));
 540         assert_se(strlen(p) == 16);
 541         assert_se(in_charset(p, "0123456789abcdef"));
 542         free(ret);
 543
 544         assert_se(tempfn_random_child("/foo/bar/waldo", NULL, &ret) >= 0);
 545         assert_se(p = startswith(ret, "/foo/bar/waldo/.#"));
 546         assert_se(strlen(p) == 16);
 547         assert_se(in_charset(p, "0123456789abcdef"));
 548         free(ret);
 549
 550         assert_se(tempfn_random_child("/foo/bar/waldo", "[kikiriki]", &ret) >= 0);
 551         assert_se(p = startswith(ret, "/foo/bar/waldo/.#[kikiriki]"));
 552         assert_se(strlen(p) == 16);
 553         assert_se(in_charset(p, "0123456789abcdef"));
 554         free(ret);
 555 }
 556
 557 int main(int argc, char *argv[]) {
 558         log_parse_environment();
 559         log_open();
 560
 561         test_parse_env_file();
 562         test_parse_multiline_env_file();
 563         test_executable_is_script();
 564         test_status_field();
 565         test_capeff();
 566         test_write_string_stream();
 567         test_write_string_file();
 568         test_write_string_file_no_create();
 569         test_write_string_file_verify();
 570         test_load_env_file_pairs();
 571         test_search_and_fopen();
 572         test_search_and_fopen_nulstr();
 573         test_writing_tmpfile();
 574         test_tempfn();
 575
 576         return 0;
 577 }