src/test/test-fd-util.c

   1 /***
   2   This file is part of systemd.
   3
   4   Copyright 2010 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 <unistd.h>
  22
  23 #include "alloc-util.h"
  24 #include "fd-util.h"
  25 #include "fileio.h"
  26 #include "macro.h"
  27 #include "random-util.h"
  28 #include "string-util.h"
  29 #include "util.h"
  30
  31 static void test_close_many(void) {
  32         int fds[3];
  33         char name0[] = "/tmp/test-close-many.XXXXXX";
  34         char name1[] = "/tmp/test-close-many.XXXXXX";
  35         char name2[] = "/tmp/test-close-many.XXXXXX";
  36
  37         fds[0] = mkostemp_safe(name0);
  38         fds[1] = mkostemp_safe(name1);
  39         fds[2] = mkostemp_safe(name2);
  40
  41         close_many(fds, 2);
  42
  43         assert_se(fcntl(fds[0], F_GETFD) == -1);
  44         assert_se(fcntl(fds[1], F_GETFD) == -1);
  45         assert_se(fcntl(fds[2], F_GETFD) >= 0);
  46
  47         safe_close(fds[2]);
  48
  49         unlink(name0);
  50         unlink(name1);
  51         unlink(name2);
  52 }
  53
  54 static void test_close_nointr(void) {
  55         char name[] = "/tmp/test-test-close_nointr.XXXXXX";
  56         int fd;
  57
  58         fd = mkostemp_safe(name);
  59         assert_se(fd >= 0);
  60         assert_se(close_nointr(fd) >= 0);
  61         assert_se(close_nointr(fd) < 0);
  62
  63         unlink(name);
  64 }
  65
  66 static void test_same_fd(void) {
  67         _cleanup_close_pair_ int p[2] = { -1, -1 };
  68         _cleanup_close_ int a = -1, b = -1, c = -1;
  69
  70         assert_se(pipe2(p, O_CLOEXEC) >= 0);
  71         assert_se((a = dup(p[0])) >= 0);
  72         assert_se((b = open("/dev/null", O_RDONLY|O_CLOEXEC)) >= 0);
  73         assert_se((c = dup(a)) >= 0);
  74
  75         assert_se(same_fd(p[0], p[0]) > 0);
  76         assert_se(same_fd(p[1], p[1]) > 0);
  77         assert_se(same_fd(a, a) > 0);
  78         assert_se(same_fd(b, b) > 0);
  79
  80         assert_se(same_fd(a, p[0]) > 0);
  81         assert_se(same_fd(p[0], a) > 0);
  82         assert_se(same_fd(c, p[0]) > 0);
  83         assert_se(same_fd(p[0], c) > 0);
  84         assert_se(same_fd(a, c) > 0);
  85         assert_se(same_fd(c, a) > 0);
  86
  87         assert_se(same_fd(p[0], p[1]) == 0);
  88         assert_se(same_fd(p[1], p[0]) == 0);
  89         assert_se(same_fd(p[0], b) == 0);
  90         assert_se(same_fd(b, p[0]) == 0);
  91         assert_se(same_fd(p[1], a) == 0);
  92         assert_se(same_fd(a, p[1]) == 0);
  93         assert_se(same_fd(p[1], b) == 0);
  94         assert_se(same_fd(b, p[1]) == 0);
  95
  96         assert_se(same_fd(a, b) == 0);
  97         assert_se(same_fd(b, a) == 0);
  98 }
  99
 100 static void test_open_serialization_fd(void) {
 101         _cleanup_close_ int fd = -1;
 102
 103         fd = open_serialization_fd("test");
 104         assert_se(fd >= 0);
 105
 106         write(fd, "test\n", 5);
 107 }
 108
 109 static void test_acquire_data_fd_one(unsigned flags) {
 110         char wbuffer[196*1024 - 7];
 111         char rbuffer[sizeof(wbuffer)];
 112         int fd;
 113
 114         fd = acquire_data_fd("foo", 3, flags);
 115         assert_se(fd >= 0);
 116
 117         zero(rbuffer);
 118         assert_se(read(fd, rbuffer, sizeof(rbuffer)) == 3);
 119         assert_se(streq(rbuffer, "foo"));
 120
 121         fd = safe_close(fd);
 122
 123         fd = acquire_data_fd("", 0, flags);
 124         assert_se(fd >= 0);
 125
 126         zero(rbuffer);
 127         assert_se(read(fd, rbuffer, sizeof(rbuffer)) == 0);
 128         assert_se(streq(rbuffer, ""));
 129
 130         fd = safe_close(fd);
 131
 132         random_bytes(wbuffer, sizeof(wbuffer));
 133
 134         fd = acquire_data_fd(wbuffer, sizeof(wbuffer), flags);
 135         assert_se(fd >= 0);
 136
 137         zero(rbuffer);
 138         assert_se(read(fd, rbuffer, sizeof(rbuffer)) == sizeof(rbuffer));
 139         assert_se(memcmp(rbuffer, wbuffer, sizeof(rbuffer)) == 0);
 140
 141         fd = safe_close(fd);
 142 }
 143
 144 static void test_acquire_data_fd(void) {
 145
 146         test_acquire_data_fd_one(0);
 147         test_acquire_data_fd_one(ACQUIRE_NO_DEV_NULL);
 148         test_acquire_data_fd_one(ACQUIRE_NO_MEMFD);
 149         test_acquire_data_fd_one(ACQUIRE_NO_DEV_NULL|ACQUIRE_NO_MEMFD);
 150         test_acquire_data_fd_one(ACQUIRE_NO_PIPE);
 151         test_acquire_data_fd_one(ACQUIRE_NO_DEV_NULL|ACQUIRE_NO_PIPE);
 152         test_acquire_data_fd_one(ACQUIRE_NO_MEMFD|ACQUIRE_NO_PIPE);
 153         test_acquire_data_fd_one(ACQUIRE_NO_DEV_NULL|ACQUIRE_NO_MEMFD|ACQUIRE_NO_PIPE);
 154         test_acquire_data_fd_one(ACQUIRE_NO_DEV_NULL|ACQUIRE_NO_MEMFD|ACQUIRE_NO_PIPE|ACQUIRE_NO_TMPFILE);
 155 }
 156
 157 int main(int argc, char *argv[]) {
 158         test_close_many();
 159         test_close_nointr();
 160         test_same_fd();
 161         test_open_serialization_fd();
 162         test_acquire_data_fd();
 163
 164         return 0;
 165 }