tools/testing/selftests/exec/non-regular.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 #include <errno.h>
   3 #include <fcntl.h>
   4 #include <stdio.h>
   5 #include <string.h>
   6 #include <unistd.h>
   7 #include <sys/socket.h>
   8 #include <sys/stat.h>
   9 #include <sys/sysmacros.h>
  10 #include <sys/types.h>
  11
  12 #include "../kselftest_harness.h"
  13
  14 /* Remove a file, ignoring the result if it didn't exist. */
  15 void rm(struct __test_metadata *_metadata, const char *pathname,
  16         int is_dir)
  17 {
  18         int rc;
  19
  20         if (is_dir)
  21                 rc = rmdir(pathname);
  22         else
  23                 rc = unlink(pathname);
  24
  25         if (rc < 0) {
  26                 ASSERT_EQ(errno, ENOENT) {
  27                         TH_LOG("Not ENOENT: %s", pathname);
  28                 }
  29         } else {
  30                 ASSERT_EQ(rc, 0) {
  31                         TH_LOG("Failed to remove: %s", pathname);
  32                 }
  33         }
  34 }
  35
  36 FIXTURE(file) {
  37         char *pathname;
  38         int is_dir;
  39 };
  40
  41 FIXTURE_VARIANT(file)
  42 {
  43         const char *name;
  44         int expected;
  45         int is_dir;
  46         void (*setup)(struct __test_metadata *_metadata,
  47                       FIXTURE_DATA(file) *self,
  48                       const FIXTURE_VARIANT(file) *variant);
  49         int major, minor, mode; /* for mknod() */
  50 };
  51
  52 void setup_link(struct __test_metadata *_metadata,
  53                 FIXTURE_DATA(file) *self,
  54                 const FIXTURE_VARIANT(file) *variant)
  55 {
  56         const char * const paths[] = {
  57                 "/bin/true",
  58                 "/usr/bin/true",
  59         };
  60         int i;
  61
  62         for (i = 0; i < ARRAY_SIZE(paths); i++) {
  63                 if (access(paths[i], X_OK) == 0) {
  64                         ASSERT_EQ(symlink(paths[i], self->pathname), 0);
  65                         return;
  66                 }
  67         }
  68         ASSERT_EQ(1, 0) {
  69                 TH_LOG("Could not find viable 'true' binary");
  70         }
  71 }
  72
  73 FIXTURE_VARIANT_ADD(file, S_IFLNK)
  74 {
  75         .name = "S_IFLNK",
  76         .expected = ELOOP,
  77         .setup = setup_link,
  78 };
  79
  80 void setup_dir(struct __test_metadata *_metadata,
  81                FIXTURE_DATA(file) *self,
  82                const FIXTURE_VARIANT(file) *variant)
  83 {
  84         ASSERT_EQ(mkdir(self->pathname, 0755), 0);
  85 }
  86
  87 FIXTURE_VARIANT_ADD(file, S_IFDIR)
  88 {
  89         .name = "S_IFDIR",
  90         .is_dir = 1,
  91         .expected = EACCES,
  92         .setup = setup_dir,
  93 };
  94
  95 void setup_node(struct __test_metadata *_metadata,
  96                 FIXTURE_DATA(file) *self,
  97                 const FIXTURE_VARIANT(file) *variant)
  98 {
  99         dev_t dev;
 100         int rc;
 101
 102         dev = makedev(variant->major, variant->minor);
 103         rc = mknod(self->pathname, 0755 | variant->mode, dev);
 104         ASSERT_EQ(rc, 0) {
 105                 if (errno == EPERM)
 106                         SKIP(return, "Please run as root; cannot mknod(%s)",
 107                                 variant->name);
 108         }
 109 }
 110
 111 FIXTURE_VARIANT_ADD(file, S_IFBLK)
 112 {
 113         .name = "S_IFBLK",
 114         .expected = EACCES,
 115         .setup = setup_node,
 116         /* /dev/loop0 */
 117         .major = 7,
 118         .minor = 0,
 119         .mode = S_IFBLK,
 120 };
 121
 122 FIXTURE_VARIANT_ADD(file, S_IFCHR)
 123 {
 124         .name = "S_IFCHR",
 125         .expected = EACCES,
 126         .setup = setup_node,
 127         /* /dev/zero */
 128         .major = 1,
 129         .minor = 5,
 130         .mode = S_IFCHR,
 131 };
 132
 133 void setup_fifo(struct __test_metadata *_metadata,
 134                 FIXTURE_DATA(file) *self,
 135                 const FIXTURE_VARIANT(file) *variant)
 136 {
 137         ASSERT_EQ(mkfifo(self->pathname, 0755), 0);
 138 }
 139
 140 FIXTURE_VARIANT_ADD(file, S_IFIFO)
 141 {
 142         .name = "S_IFIFO",
 143         .expected = EACCES,
 144         .setup = setup_fifo,
 145 };
 146
 147 FIXTURE_SETUP(file)
 148 {
 149         ASSERT_GT(asprintf(&self->pathname, "%s.test", variant->name), 6);
 150         self->is_dir = variant->is_dir;
 151
 152         rm(_metadata, self->pathname, variant->is_dir);
 153         variant->setup(_metadata, self, variant);
 154 }
 155
 156 FIXTURE_TEARDOWN(file)
 157 {
 158         rm(_metadata, self->pathname, self->is_dir);
 159 }
 160
 161 TEST_F(file, exec_errno)
 162 {
 163         char * const argv[2] = { (char * const)self->pathname, NULL };
 164
 165         EXPECT_LT(execv(argv[0], argv), 0);
 166         EXPECT_EQ(errno, variant->expected);
 167 }
 168
 169 /* S_IFSOCK */
 170 FIXTURE(sock)
 171 {
 172         int fd;
 173 };
 174
 175 FIXTURE_SETUP(sock)
 176 {
 177         self->fd = socket(AF_INET, SOCK_STREAM, 0);
 178         ASSERT_GE(self->fd, 0);
 179 }
 180
 181 FIXTURE_TEARDOWN(sock)
 182 {
 183         if (self->fd >= 0)
 184                 ASSERT_EQ(close(self->fd), 0);
 185 }
 186
 187 TEST_F(sock, exec_errno)
 188 {
 189         char * const argv[2] = { " magic socket ", NULL };
 190         char * const envp[1] = { NULL };
 191
 192         EXPECT_LT(fexecve(self->fd, argv, envp), 0);
 193         EXPECT_EQ(errno, EACCES);
 194 }
 195
 196 TEST_HARNESS_MAIN