io/tst-open-tmpfile.c

   1 /* Test open and openat with O_TMPFILE.
   2    Copyright (C) 2016-2023 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, see
  17    <https://www.gnu.org/licenses/>.  */
  18
  19 /* This test verifies that open and openat work as expected, i.e. they
  20    create a deleted file with the requested file mode.  */
  21
  22 #include <errno.h>
  23 #include <fcntl.h>
  24 #include <stdbool.h>
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <sys/stat.h>
  29 #include <unistd.h>
  30
  31 #include <support/support.h>
  32
  33 #ifdef O_TMPFILE
  34 typedef int (*wrapper_func) (const char *, int, mode_t);
  35
  36 /* Error-checking wrapper for the open function, compatible with the
  37    wrapper_func type.  */
  38 static int
  39 wrap_open (const char *path, int flags, mode_t mode)
  40 {
  41   int ret = open (path, flags, mode);
  42   if (ret < 0)
  43     {
  44       printf ("error: open (\"%s\", 0x%x, 0%03o): %m\n", path, flags, mode);
  45       exit (1);
  46     }
  47   return ret;
  48 }
  49
  50 /* Error-checking wrapper for the openat function, compatible with the
  51    wrapper_func type.  */
  52 static int
  53 wrap_openat (const char *path, int flags, mode_t mode)
  54 {
  55   int ret = openat (AT_FDCWD, path, flags, mode);
  56   if (ret < 0)
  57     {
  58       printf ("error: openat (\"%s\", 0x%x, 0%03o): %m\n", path, flags, mode);
  59       exit (1);
  60     }
  61   return ret;
  62 }
  63
  64 /* Error-checking wrapper for the open64 function, compatible with the
  65    wrapper_func type.  */
  66 static int
  67 wrap_open64 (const char *path, int flags, mode_t mode)
  68 {
  69   int ret = open64 (path, flags, mode);
  70   if (ret < 0)
  71     {
  72       printf ("error: open64 (\"%s\", 0x%x, 0%03o): %m\n", path, flags, mode);
  73       exit (1);
  74     }
  75   return ret;
  76 }
  77
  78 /* Error-checking wrapper for the openat64 function, compatible with the
  79    wrapper_func type.  */
  80 static int
  81 wrap_openat64 (const char *path, int flags, mode_t mode)
  82 {
  83   int ret = openat64 (AT_FDCWD, path, flags, mode);
  84   if (ret < 0)
  85     {
  86       printf ("error: openat64 (\"%s\", 0x%x, 0%03o): %m\n", path, flags, mode);
  87       exit (1);
  88     }
  89   return ret;
  90 }
  91
  92 /* Return true if FD is flagged as deleted in /proc/self/fd, false if
  93    not.  */
  94 static bool
  95 is_file_deleted (int fd)
  96 {
  97   char *proc_fd_path = xasprintf ("/proc/self/fd/%d", fd);
  98   char file_path[4096];
  99   ssize_t file_path_length
 100     = readlink (proc_fd_path, file_path, sizeof (file_path));
 101   if (file_path_length < 0)
 102     {
 103       printf ("error: readlink (\"%s\"): %m", proc_fd_path);
 104       free (proc_fd_path);
 105       exit (1);
 106     }
 107   free (proc_fd_path);
 108   if (file_path_length == sizeof (file_path))
 109     {
 110       printf ("error: path in /proc resolves to overlong file name: %.*s\n",
 111               (int) file_path_length, file_path);
 112       exit (1);
 113     }
 114   const char *deleted = " (deleted)";
 115   if (file_path_length < strlen (deleted))
 116     {
 117       printf ("error: path in /proc is too short: %.*s\n",
 118               (int) file_path_length, file_path);
 119       exit (1);
 120     }
 121   return memcmp (file_path + file_path_length - strlen (deleted),
 122               deleted, strlen (deleted)) == 0;
 123 }
 124
 125 /* Obtain a file name which is difficult to guess.  */
 126 static char *
 127 get_random_name (void)
 128 {
 129   unsigned long long bytes[2];
 130   int random_device = open ("/dev/urandom", O_RDONLY);
 131   if (random_device < 0)
 132     {
 133       printf ("error: open (\"/dev/urandom\"): %m\n");
 134       exit (1);
 135     }
 136   ssize_t ret = read (random_device, bytes, sizeof (bytes));
 137   if (ret < 0)
 138     {
 139       printf ("error: read (\"/dev/urandom\"): %m\n");
 140       exit (1);
 141     }
 142   if (ret != sizeof (bytes))
 143     {
 144       printf ("error: short read from /dev/urandom: %zd\n", ret);
 145       exit (1);
 146     }
 147   close (random_device);
 148   return xasprintf ("tst-open-tmpfile-%08llx%08llx.tmp", bytes[0], bytes[1]);
 149 }
 150
 151 /* Check open/openat (as specified by OP and WRAPPER) with a specific
 152    PATH/FLAGS/MODE combination.  */
 153 static void
 154 check_wrapper_flags_mode (const char *op, wrapper_func wrapper,
 155                           const char *path, int flags, mode_t mode)
 156 {
 157   int fd = wrapper (path, flags | O_TMPFILE, mode);
 158   struct stat64 st;
 159   if (fstat64 (fd, &st) != 0)
 160     {
 161       printf ("error: fstat64: %m\n");
 162       exit (1);
 163     }
 164
 165   /* Verify that the mode was correctly processed.  */
 166   int actual_mode = st.st_mode & 0777;
 167   if (actual_mode != mode)
 168     {
 169       printf ("error: unexpected mode; expected 0%03o, actual 0%03o\n",
 170               mode, actual_mode);
 171       exit (1);
 172     }
 173
 174   /* Check that the file is marked as deleted in /proc.  */
 175   if (!is_file_deleted (fd))
 176     {
 177       printf ("error: path in /proc is not marked as deleted\n");
 178       exit (1);
 179     }
 180
 181   /* Check that the file can be turned into a regular file with
 182      linkat.  Open a file descriptor for the directory at PATH.  Use
 183      AT_FDCWD if PATH is ".", to exercise that functionality as
 184      well.  */
 185   int path_fd;
 186   if (strcmp (path, ".") == 0)
 187     path_fd = AT_FDCWD;
 188   else
 189     {
 190       path_fd = open (path, O_RDONLY | O_DIRECTORY);
 191       if (path_fd < 0)
 192         {
 193           printf ("error: open (\"%s\"): %m\n", path);
 194           exit (1);
 195         }
 196     }
 197
 198   /* Use a hard-to-guess name for the new directory entry.  */
 199   char *new_name = get_random_name ();
 200
 201   /* linkat does not require privileges if the path in /proc/self/fd
 202      is used.  */
 203   char *proc_fd_path = xasprintf ("/proc/self/fd/%d", fd);
 204   if (linkat (AT_FDCWD, proc_fd_path, path_fd, new_name,
 205               AT_SYMLINK_FOLLOW) == 0)
 206     {
 207       if (unlinkat (path_fd, new_name, 0) != 0 && errno != ENOENT)
 208         {
 209           printf ("error: unlinkat (\"%s/%s\"): %m\n", path, new_name);
 210           exit (1);
 211         }
 212     }
 213   else
 214     {
 215       /* linkat failed.  This is expected if O_EXCL was specified.  */
 216       if ((flags & O_EXCL) == 0)
 217         {
 218           printf ("error: linkat failed after %s (\"%s\", 0x%x, 0%03o): %m\n",
 219                   op, path, flags, mode);
 220           exit (1);
 221         }
 222     }
 223
 224   free (proc_fd_path);
 225   free (new_name);
 226   if (path_fd != AT_FDCWD)
 227     close (path_fd);
 228   close (fd);
 229 }
 230
 231 /* Check OP/WRAPPER with various flags at a specific PATH and
 232    MODE.  */
 233 static void
 234 check_wrapper_mode (const char *op, wrapper_func wrapper,
 235                     const char *path, mode_t mode)
 236 {
 237   check_wrapper_flags_mode (op, wrapper, path, O_WRONLY, mode);
 238   check_wrapper_flags_mode (op, wrapper, path, O_WRONLY | O_EXCL, mode);
 239   check_wrapper_flags_mode (op, wrapper, path, O_RDWR, mode);
 240   check_wrapper_flags_mode (op, wrapper, path, O_RDWR | O_EXCL, mode);
 241 }
 242
 243 /* Check open/openat with varying permissions.  */
 244 static void
 245 check_wrapper (const char *op, wrapper_func wrapper,
 246                     const char *path)
 247 {
 248   printf ("info: testing %s at: %s\n", op, path);
 249   check_wrapper_mode (op, wrapper, path, 0);
 250   check_wrapper_mode (op, wrapper, path, 0640);
 251   check_wrapper_mode (op, wrapper, path, 0600);
 252   check_wrapper_mode (op, wrapper, path, 0755);
 253   check_wrapper_mode (op, wrapper, path, 0750);
 254 }
 255
 256 /* Verify that the directory at PATH supports O_TMPFILE.  Exit with
 257    status 77 (unsupported) if the kernel does not support O_TMPFILE.
 258    Even with kernel support, not all file systems O_TMPFILE, so return
 259    true if the directory supports O_TMPFILE, false if not.  */
 260 static bool
 261 probe_path (const char *path)
 262 {
 263   int fd = openat (AT_FDCWD, path, O_TMPFILE | O_RDWR, 0);
 264   if (fd < 0)
 265     {
 266       if (errno == EISDIR)
 267         /* The system does not support O_TMPFILE.  */
 268         {
 269           printf ("info: kernel does not support O_TMPFILE\n");
 270           exit (77);
 271         }
 272       if (errno == EOPNOTSUPP)
 273         {
 274           printf ("info: path does not support O_TMPFILE: %s\n", path);
 275           return false;
 276         }
 277       printf ("error: openat (\"%s\", O_TMPFILE | O_RDWR): %m\n", path);
 278       exit (1);
 279     }
 280   close (fd);
 281   return true;
 282 }
 283
 284 static int
 285 do_test (void)
 286 {
 287   umask (0);
 288   const char *paths[] = { ".", "/dev/shm", "/tmp",
 289                           getenv ("TEST_TMPFILE_PATH"),
 290                           NULL };
 291   bool supported = false;
 292   for (int i = 0; paths[i] != NULL; ++i)
 293     if (probe_path (paths[i]))
 294       {
 295         supported = true;
 296         check_wrapper ("open", wrap_open, paths[i]);
 297         check_wrapper ("openat", wrap_openat, paths[i]);
 298         check_wrapper ("open64", wrap_open64, paths[i]);
 299         check_wrapper ("openat64", wrap_openat64, paths[i]);
 300       }
 301
 302   if (!supported)
 303     return 77;
 304
 305   return 0;
 306 }
 307
 308 #else  /* !O_TMPFILE */
 309
 310 static int
 311 do_test (void)
 312 {
 313   return 77;
 314 }
 315
 316 #endif  /* O_TMPFILE */
 317
 318 #include <support/test-driver.c>