google3/third_party/grte/v5_src/glibc-2.27/io/tst-open-tmpfile.c - GRTEv5 - Git at Google

 /* Test open and openat with O_TMPFILE.
    Copyright (C) 2016-2018 Free Software Foundation, Inc.
    This file is part of the GNU C Library.

    The GNU C Library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    The GNU C Library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */

 /* This test verifies that open and openat work as expected, i.e. they
    create a deleted file with the requested file mode.  */

 #include <errno.h>
 #include <fcntl.h>
 #include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
 #include <unistd.h>

 #include <support/support.h>

 #ifdef O_TMPFILE
 typedef int (*wrapper_func) (const char *, int, mode_t);

 /* Error-checking wrapper for the open function, compatible with the
    wrapper_func type.  */
 static int
 wrap_open (const char *path, int flags, mode_t mode)
 {
   int ret = open (path, flags, mode);
   if (ret < 0)
     {
       printf ("error: open (\"%s\", 0x%x, 0%03o): %m\n", path, flags, mode);
       exit (1);
     }
   return ret;
 }

 /* Error-checking wrapper for the openat function, compatible with the
    wrapper_func type.  */
 static int
 wrap_openat (const char *path, int flags, mode_t mode)
 {
   int ret = openat (AT_FDCWD, path, flags, mode);
   if (ret < 0)
     {
       printf ("error: openat (\"%s\", 0x%x, 0%03o): %m\n", path, flags, mode);
       exit (1);
     }
   return ret;
 }

 /* Error-checking wrapper for the open64 function, compatible with the
    wrapper_func type.  */
 static int
 wrap_open64 (const char *path, int flags, mode_t mode)
 {
   int ret = open64 (path, flags, mode);
   if (ret < 0)
     {
       printf ("error: open64 (\"%s\", 0x%x, 0%03o): %m\n", path, flags, mode);
       exit (1);
     }
   return ret;
 }

 /* Error-checking wrapper for the openat64 function, compatible with the
    wrapper_func type.  */
 static int
 wrap_openat64 (const char *path, int flags, mode_t mode)
 {
   int ret = openat64 (AT_FDCWD, path, flags, mode);
   if (ret < 0)
     {
       printf ("error: openat64 (\"%s\", 0x%x, 0%03o): %m\n", path, flags, mode);
       exit (1);
     }
   return ret;
 }

 /* Return true if FD is flagged as deleted in /proc/self/fd, false if
    not.  */
 static bool
 is_file_deteted (int fd)
 {
   char *proc_fd_path = xasprintf ("/proc/self/fd/%d", fd);
   char file_path[4096];
   ssize_t file_path_length
     = readlink (proc_fd_path, file_path, sizeof (file_path));
   if (file_path_length < 0)
     {
       printf ("error: readlink (\"%s\"): %m", proc_fd_path);
       free (proc_fd_path);
       exit (1);
     }
   free (proc_fd_path);
   if (file_path_length == sizeof (file_path))
     {
       printf ("error: path in /proc resolves to overlong file name: %.*s\n",
               (int) file_path_length, file_path);
       exit (1);
     }
   const char *deleted = " (deleted)";
   if (file_path_length < strlen (deleted))
     {
       printf ("error: path in /proc is too short: %.*s\n",
               (int) file_path_length, file_path);
       exit (1);
     }
   return memcmp (file_path + file_path_length - strlen (deleted),
               deleted, strlen (deleted)) == 0;
 }

 /* Obtain a file name which is difficult to guess.  */
 static char *
 get_random_name (void)
 {
   unsigned long long bytes[2];
   int random_device = open ("/dev/urandom", O_RDONLY);
   if (random_device < 0)
     {
       printf ("error: open (\"/dev/urandom\"): %m\n");
       exit (1);
     }
   ssize_t ret = read (random_device, bytes, sizeof (bytes));
   if (ret < 0)
     {
       printf ("error: read (\"/dev/urandom\"): %m\n");
       exit (1);
     }
   if (ret != sizeof (bytes))
     {
       printf ("error: short read from /dev/urandom: %zd\n", ret);
       exit (1);
     }
   close (random_device);
   return xasprintf ("tst-open-tmpfile-%08llx%08llx.tmp", bytes[0], bytes[1]);
 }

 /* Check open/openat (as specified by OP and WRAPPER) with a specific
    PATH/FLAGS/MODE combination.  */
 static void
 check_wrapper_flags_mode (const char *op, wrapper_func wrapper,
                           const char *path, int flags, mode_t mode)
 {
   int fd = wrapper (path, flags | O_TMPFILE, mode);
   struct stat64 st;
   if (fstat64 (fd, &st) != 0)
     {
       printf ("error: fstat64: %m\n");
       exit (1);
     }

   /* Verify that the mode was correctly processed.  */
   int actual_mode = st.st_mode & 0777;
   if (actual_mode != mode)
     {
       printf ("error: unexpected mode; expected 0%03o, actual 0%03o\n",
               mode, actual_mode);
       exit (1);
     }

   /* Check that the file is marked as deleted in /proc.  */
   if (!is_file_deteted (fd))
     {
       printf ("error: path in /proc is not marked as deleted\n");
       exit (1);
     }

   /* Check that the file can be turned into a regular file with
      linkat.  Open a file descriptor for the directory at PATH.  Use
      AT_FDCWD if PATH is ".", to exercise that functionality as
      well.  */
   int path_fd;
   if (strcmp (path, ".") == 0)
     path_fd = AT_FDCWD;
   else
     {
       path_fd = open (path, O_RDONLY | O_DIRECTORY);
       if (path_fd < 0)
         {
           printf ("error: open (\"%s\"): %m\n", path);
           exit (1);
         }
     }

   /* Use a hard-to-guess name for the new directory entry.  */
   char *new_name = get_random_name ();

   /* linkat does not require privileges if the path in /proc/self/fd
      is used.  */
   char *proc_fd_path = xasprintf ("/proc/self/fd/%d", fd);
   if (linkat (AT_FDCWD, proc_fd_path, path_fd, new_name,
               AT_SYMLINK_FOLLOW) == 0)
     {
       if (unlinkat (path_fd, new_name, 0) != 0 && errno != ENOENT)
         {
           printf ("error: unlinkat (\"%s/%s\"): %m\n", path, new_name);
           exit (1);
         }
     }
   else
     {
       /* linkat failed.  This is expected if O_EXCL was specified.  */
       if ((flags & O_EXCL) == 0)
         {
           printf ("error: linkat failed after %s (\"%s\", 0x%x, 0%03o): %m\n",
                   op, path, flags, mode);
           exit (1);
         }
     }

   free (proc_fd_path);
   free (new_name);
   if (path_fd != AT_FDCWD)
     close (path_fd);
   close (fd);
 }

 /* Check OP/WRAPPER with various flags at a specific PATH and
    MODE.  */
 static void
 check_wrapper_mode (const char *op, wrapper_func wrapper,
                     const char *path, mode_t mode)
 {
   check_wrapper_flags_mode (op, wrapper, path, O_WRONLY, mode);
   check_wrapper_flags_mode (op, wrapper, path, O_WRONLY | O_EXCL, mode);
   check_wrapper_flags_mode (op, wrapper, path, O_RDWR, mode);
   check_wrapper_flags_mode (op, wrapper, path, O_RDWR | O_EXCL, mode);
 }

 /* Check open/openat with varying permissions.  */
 static void
 check_wrapper (const char *op, wrapper_func wrapper,
                     const char *path)
 {
   printf ("info: testing %s at: %s\n", op, path);
   check_wrapper_mode (op, wrapper, path, 0);
   check_wrapper_mode (op, wrapper, path, 0640);
   check_wrapper_mode (op, wrapper, path, 0600);
   check_wrapper_mode (op, wrapper, path, 0755);
   check_wrapper_mode (op, wrapper, path, 0750);
 }

 /* Verify that the directory at PATH supports O_TMPFILE.  Exit with
    status 77 (unsupported) if the kernel does not support O_TMPFILE.
    Even with kernel support, not all file systems O_TMPFILE, so return
    true if the directory supports O_TMPFILE, false if not.  */
 static bool
 probe_path (const char *path)
 {
   int fd = openat (AT_FDCWD, path, O_TMPFILE | O_RDWR, 0);
   if (fd < 0)
     {
       if (errno == EISDIR)
         /* The system does not support O_TMPFILE.  */
         {
           printf ("info: kernel does not support O_TMPFILE\n");
           exit (77);
         }
       if (errno == EOPNOTSUPP)
         {
           printf ("info: path does not support O_TMPFILE: %s\n", path);
           return false;
         }
       printf ("error: openat (\"%s\", O_TMPFILE | O_RDWR): %m\n", path);
       exit (1);
     }
   close (fd);
   return true;
 }

 static int
 do_test (void)
 {
   umask (0);
   const char *paths[] = { ".", "/dev/shm", "/tmp",
                           getenv ("TEST_TMPFILE_PATH"),
                           NULL };
   bool supported = false;
   for (int i = 0; paths[i] != NULL; ++i)
     if (probe_path (paths[i]))
       {
         supported = true;
         check_wrapper ("open", wrap_open, paths[i]);
         check_wrapper ("openat", wrap_openat, paths[i]);
         check_wrapper ("open64", wrap_open64, paths[i]);
         check_wrapper ("openat64", wrap_openat64, paths[i]);
       }

   if (!supported)
     return 77;

   return 0;
 }

 #else  /* !O_TMPFILE */

 static int
 do_test (void)
 {
   return 77;
 }

 #endif  /* O_TMPFILE */

 #include <support/test-driver.c>
	/* Test open and openat with O_TMPFILE.
	Copyright (C) 2016-2018 Free Software Foundation, Inc.
	This file is part of the GNU C Library.

	The GNU C Library is free software; you can redistribute it and/or
	modify it under the terms of the GNU Lesser General Public
	License as published by the Free Software Foundation; either
	version 2.1 of the License, or (at your option) any later version.

	The GNU C Library is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	Lesser General Public License for more details.

	You should have received a copy of the GNU Lesser General Public
	License along with the GNU C Library; if not, see
	<http://www.gnu.org/licenses/>. */

	/* This test verifies that open and openat work as expected, i.e. they
	create a deleted file with the requested file mode. */

	#include <errno.h>
	#include <fcntl.h>
	#include <stdbool.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <sys/stat.h>
	#include <unistd.h>

	#include <support/support.h>

	#ifdef O_TMPFILE
	typedef int (wrapper_func) (const char , int, mode_t);

	/* Error-checking wrapper for the open function, compatible with the
	wrapper_func type. */
	static int
	wrap_open (const char *path, int flags, mode_t mode)
	{
	int ret = open (path, flags, mode);
	if (ret < 0)
	{
	printf ("error: open (\"%s\", 0x%x, 0%03o): %m\n", path, flags, mode);
	exit (1);
	}
	return ret;
	}

	/* Error-checking wrapper for the openat function, compatible with the
	wrapper_func type. */
	static int
	wrap_openat (const char *path, int flags, mode_t mode)
	{
	int ret = openat (AT_FDCWD, path, flags, mode);
	if (ret < 0)
	{
	printf ("error: openat (\"%s\", 0x%x, 0%03o): %m\n", path, flags, mode);
	exit (1);
	}
	return ret;
	}

	/* Error-checking wrapper for the open64 function, compatible with the
	wrapper_func type. */
	static int
	wrap_open64 (const char *path, int flags, mode_t mode)
	{
	int ret = open64 (path, flags, mode);
	if (ret < 0)
	{
	printf ("error: open64 (\"%s\", 0x%x, 0%03o): %m\n", path, flags, mode);
	exit (1);
	}
	return ret;
	}

	/* Error-checking wrapper for the openat64 function, compatible with the
	wrapper_func type. */
	static int
	wrap_openat64 (const char *path, int flags, mode_t mode)
	{
	int ret = openat64 (AT_FDCWD, path, flags, mode);
	if (ret < 0)
	{
	printf ("error: openat64 (\"%s\", 0x%x, 0%03o): %m\n", path, flags, mode);
	exit (1);
	}
	return ret;
	}

	/* Return true if FD is flagged as deleted in /proc/self/fd, false if
	not. */
	static bool
	is_file_deteted (int fd)
	{
	char *proc_fd_path = xasprintf ("/proc/self/fd/%d", fd);
	char file_path[4096];
	ssize_t file_path_length
	= readlink (proc_fd_path, file_path, sizeof (file_path));
	if (file_path_length < 0)
	{
	printf ("error: readlink (\"%s\"): %m", proc_fd_path);
	free (proc_fd_path);
	exit (1);
	}
	free (proc_fd_path);
	if (file_path_length == sizeof (file_path))
	{
	printf ("error: path in /proc resolves to overlong file name: %.*s\n",
	(int) file_path_length, file_path);
	exit (1);
	}
	const char *deleted = " (deleted)";
	if (file_path_length < strlen (deleted))
	{
	printf ("error: path in /proc is too short: %.*s\n",
	(int) file_path_length, file_path);
	exit (1);
	}
	return memcmp (file_path + file_path_length - strlen (deleted),
	deleted, strlen (deleted)) == 0;
	}

	/* Obtain a file name which is difficult to guess. */
	static char *
	get_random_name (void)
	{
	unsigned long long bytes[2];
	int random_device = open ("/dev/urandom", O_RDONLY);
	if (random_device < 0)
	{
	printf ("error: open (\"/dev/urandom\"): %m\n");
	exit (1);
	}
	ssize_t ret = read (random_device, bytes, sizeof (bytes));
	if (ret < 0)
	{
	printf ("error: read (\"/dev/urandom\"): %m\n");
	exit (1);
	}
	if (ret != sizeof (bytes))
	{
	printf ("error: short read from /dev/urandom: %zd\n", ret);
	exit (1);
	}
	close (random_device);
	return xasprintf ("tst-open-tmpfile-%08llx%08llx.tmp", bytes[0], bytes[1]);
	}

	/* Check open/openat (as specified by OP and WRAPPER) with a specific
	PATH/FLAGS/MODE combination. */
	static void
	check_wrapper_flags_mode (const char *op, wrapper_func wrapper,
	const char *path, int flags, mode_t mode)
	{
	int fd = wrapper (path, flags \| O_TMPFILE, mode);
	struct stat64 st;
	if (fstat64 (fd, &st) != 0)
	{
	printf ("error: fstat64: %m\n");
	exit (1);
	}

	/* Verify that the mode was correctly processed. */
	int actual_mode = st.st_mode & 0777;
	if (actual_mode != mode)
	{
	printf ("error: unexpected mode; expected 0%03o, actual 0%03o\n",
	mode, actual_mode);
	exit (1);
	}

	/* Check that the file is marked as deleted in /proc. */
	if (!is_file_deteted (fd))
	{
	printf ("error: path in /proc is not marked as deleted\n");
	exit (1);
	}

	/* Check that the file can be turned into a regular file with
	linkat. Open a file descriptor for the directory at PATH. Use
	AT_FDCWD if PATH is ".", to exercise that functionality as
	well. */
	int path_fd;
	if (strcmp (path, ".") == 0)
	path_fd = AT_FDCWD;
	else
	{
	path_fd = open (path, O_RDONLY \| O_DIRECTORY);
	if (path_fd < 0)
	{
	printf ("error: open (\"%s\"): %m\n", path);
	exit (1);
	}
	}

	/* Use a hard-to-guess name for the new directory entry. */
	char *new_name = get_random_name ();

	/* linkat does not require privileges if the path in /proc/self/fd
	is used. */
	char *proc_fd_path = xasprintf ("/proc/self/fd/%d", fd);
	if (linkat (AT_FDCWD, proc_fd_path, path_fd, new_name,
	AT_SYMLINK_FOLLOW) == 0)
	{
	if (unlinkat (path_fd, new_name, 0) != 0 && errno != ENOENT)
	{
	printf ("error: unlinkat (\"%s/%s\"): %m\n", path, new_name);
	exit (1);
	}
	}
	else
	{
	/* linkat failed. This is expected if O_EXCL was specified. */
	if ((flags & O_EXCL) == 0)
	{
	printf ("error: linkat failed after %s (\"%s\", 0x%x, 0%03o): %m\n",
	op, path, flags, mode);
	exit (1);
	}
	}

	free (proc_fd_path);
	free (new_name);
	if (path_fd != AT_FDCWD)
	close (path_fd);
	close (fd);
	}

	/* Check OP/WRAPPER with various flags at a specific PATH and
	MODE. */
	static void
	check_wrapper_mode (const char *op, wrapper_func wrapper,
	const char *path, mode_t mode)
	{
	check_wrapper_flags_mode (op, wrapper, path, O_WRONLY, mode);
	check_wrapper_flags_mode (op, wrapper, path, O_WRONLY \| O_EXCL, mode);
	check_wrapper_flags_mode (op, wrapper, path, O_RDWR, mode);
	check_wrapper_flags_mode (op, wrapper, path, O_RDWR \| O_EXCL, mode);
	}

	/* Check open/openat with varying permissions. */
	static void
	check_wrapper (const char *op, wrapper_func wrapper,
	const char *path)
	{
	printf ("info: testing %s at: %s\n", op, path);
	check_wrapper_mode (op, wrapper, path, 0);
	check_wrapper_mode (op, wrapper, path, 0640);
	check_wrapper_mode (op, wrapper, path, 0600);
	check_wrapper_mode (op, wrapper, path, 0755);
	check_wrapper_mode (op, wrapper, path, 0750);
	}

	/* Verify that the directory at PATH supports O_TMPFILE. Exit with
	status 77 (unsupported) if the kernel does not support O_TMPFILE.
	Even with kernel support, not all file systems O_TMPFILE, so return
	true if the directory supports O_TMPFILE, false if not. */
	static bool
	probe_path (const char *path)
	{
	int fd = openat (AT_FDCWD, path, O_TMPFILE \| O_RDWR, 0);
	if (fd < 0)
	{
	if (errno == EISDIR)
	/* The system does not support O_TMPFILE. */
	{
	printf ("info: kernel does not support O_TMPFILE\n");
	exit (77);
	}
	if (errno == EOPNOTSUPP)
	{
	printf ("info: path does not support O_TMPFILE: %s\n", path);
	return false;
	}
	printf ("error: openat (\"%s\", O_TMPFILE \| O_RDWR): %m\n", path);
	exit (1);
	}
	close (fd);
	return true;
	}

	static int
	do_test (void)
	{
	umask (0);
	const char *paths[] = { ".", "/dev/shm", "/tmp",
	getenv ("TEST_TMPFILE_PATH"),
	NULL };
	bool supported = false;
	for (int i = 0; paths[i] != NULL; ++i)
	if (probe_path (paths[i]))
	{
	supported = true;
	check_wrapper ("open", wrap_open, paths[i]);
	check_wrapper ("openat", wrap_openat, paths[i]);
	check_wrapper ("open64", wrap_open64, paths[i]);
	check_wrapper ("openat64", wrap_openat64, paths[i]);
	}

	if (!supported)
	return 77;

	return 0;
	}

	#else /* !O_TMPFILE */

	static int
	do_test (void)
	{
	return 77;
	}

	#endif /* O_TMPFILE */

	#include <support/test-driver.c>