290 lines
8.9 KiB
C
290 lines
8.9 KiB
C
|
/* Define 2-FD at-style functions like linkat or renameat.
|
||
|
|
Copyright (C) 2006, 2009-2020 Free Software Foundation, Inc.
|
||
|
|
|
||
|
|
This program is free software: you can redistribute it and/or modify
|
||
|
|
it under the terms of the GNU General Public License as published by
|
||
|
|
the Free Software Foundation; either version 3 of the License, or
|
||
|
|
(at your option) any later version.
|
||
|
|
|
||
|
|
This program 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 General Public License for more details.
|
||
|
|
|
||
|
|
You should have received a copy of the GNU General Public License
|
||
|
|
along with this program. If not, see <https://www.gnu.org/licenses/>. */
|
||
|
|
|
||
|
|
/* written by Jim Meyering and Eric Blake */
|
||
|
|
|
||
|
|
#include <config.h>
|
||
|
|
|
||
|
|
#include "openat-priv.h"
|
||
|
|
|
||
|
|
#include <errno.h>
|
||
|
|
#include <stdlib.h>
|
||
|
|
#include <string.h>
|
||
|
|
#include <unistd.h>
|
||
|
|
|
||
|
|
#include "dosname.h" /* solely for definition of IS_ABSOLUTE_FILE_NAME */
|
||
|
|
#include "filenamecat.h"
|
||
|
|
#include "openat.h"
|
||
|
|
#include "same-inode.h"
|
||
|
|
#include "save-cwd.h"
|
||
|
|
|
||
|
|
/* Call FUNC to operate on a pair of files, where FILE1 is relative to FD1,
|
||
|
|
and FILE2 is relative to FD2. If possible, do it without changing the
|
||
|
|
working directory. Otherwise, resort to using save_cwd/fchdir,
|
||
|
|
FUNC, restore_cwd (up to two times). If either the save_cwd or the
|
||
|
|
restore_cwd fails, then give a diagnostic and exit nonzero. */
|
||
|
|
int
|
||
|
|
at_func2 (int fd1, char const *file1,
|
||
|
|
int fd2, char const *file2,
|
||
|
|
int (*func) (char const *file1, char const *file2))
|
||
|
|
{
|
||
|
|
struct saved_cwd saved_cwd;
|
||
|
|
int saved_errno;
|
||
|
|
int err;
|
||
|
|
char *file1_alt;
|
||
|
|
char *file2_alt;
|
||
|
|
struct stat st1;
|
||
|
|
struct stat st2;
|
||
|
|
|
||
|
|
/* There are 16 possible scenarios, based on whether an fd is
|
||
|
|
AT_FDCWD or real, and whether a file is absolute or relative:
|
||
|
|
|
||
|
|
fd1 file1 fd2 file2 action
|
||
|
|
0 cwd abs cwd abs direct call
|
||
|
|
1 cwd abs cwd rel direct call
|
||
|
|
2 cwd abs fd abs direct call
|
||
|
|
3 cwd abs fd rel chdir to fd2
|
||
|
|
4 cwd rel cwd abs direct call
|
||
|
|
5 cwd rel cwd rel direct call
|
||
|
|
6 cwd rel fd abs direct call
|
||
|
|
7 cwd rel fd rel convert file1 to abs, then case 3
|
||
|
|
8 fd abs cwd abs direct call
|
||
|
|
9 fd abs cwd rel direct call
|
||
|
|
10 fd abs fd abs direct call
|
||
|
|
11 fd abs fd rel chdir to fd2
|
||
|
|
12 fd rel cwd abs chdir to fd1
|
||
|
|
13 fd rel cwd rel convert file2 to abs, then case 12
|
||
|
|
14 fd rel fd abs chdir to fd1
|
||
|
|
15a fd1 rel fd1 rel chdir to fd1
|
||
|
|
15b fd1 rel fd2 rel chdir to fd1, then case 7
|
||
|
|
|
||
|
|
Try some optimizations to reduce fd to AT_FDCWD, or to at least
|
||
|
|
avoid converting an absolute name or doing a double chdir. */
|
||
|
|
|
||
|
|
if ((fd1 == AT_FDCWD || IS_ABSOLUTE_FILE_NAME (file1))
|
||
|
|
&& (fd2 == AT_FDCWD || IS_ABSOLUTE_FILE_NAME (file2)))
|
||
|
|
return func (file1, file2); /* Case 0-2, 4-6, 8-10. */
|
||
|
|
|
||
|
|
/* If /proc/self/fd works, we don't need any stat or chdir. */
|
||
|
|
{
|
||
|
|
char proc_buf1[OPENAT_BUFFER_SIZE];
|
||
|
|
char *proc_file1 = ((fd1 == AT_FDCWD || IS_ABSOLUTE_FILE_NAME (file1))
|
||
|
|
? (char *) file1
|
||
|
|
: openat_proc_name (proc_buf1, fd1, file1));
|
||
|
|
if (proc_file1)
|
||
|
|
{
|
||
|
|
char proc_buf2[OPENAT_BUFFER_SIZE];
|
||
|
|
char *proc_file2 = ((fd2 == AT_FDCWD || IS_ABSOLUTE_FILE_NAME (file2))
|
||
|
|
? (char *) file2
|
||
|
|
: openat_proc_name (proc_buf2, fd2, file2));
|
||
|
|
if (proc_file2)
|
||
|
|
{
|
||
|
|
int proc_result = func (proc_file1, proc_file2);
|
||
|
|
int proc_errno = errno;
|
||
|
|
if (proc_file1 != proc_buf1 && proc_file1 != file1)
|
||
|
|
free (proc_file1);
|
||
|
|
if (proc_file2 != proc_buf2 && proc_file2 != file2)
|
||
|
|
free (proc_file2);
|
||
|
|
/* If the syscall succeeds, or if it fails with an unexpected
|
||
|
|
errno value, then return right away. Otherwise, fall through
|
||
|
|
and resort to using save_cwd/restore_cwd. */
|
||
|
|
if (0 <= proc_result)
|
||
|
|
return proc_result;
|
||
|
|
if (! EXPECTED_ERRNO (proc_errno))
|
||
|
|
{
|
||
|
|
errno = proc_errno;
|
||
|
|
return proc_result;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if (proc_file1 != proc_buf1 && proc_file1 != file1)
|
||
|
|
free (proc_file1);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Cases 3, 7, 11-15 remain. Time to normalize directory fds, if
|
||
|
|
possible. */
|
||
|
|
if (IS_ABSOLUTE_FILE_NAME (file1))
|
||
|
|
fd1 = AT_FDCWD; /* Case 11 reduced to 3. */
|
||
|
|
else if (IS_ABSOLUTE_FILE_NAME (file2))
|
||
|
|
fd2 = AT_FDCWD; /* Case 14 reduced to 12. */
|
||
|
|
|
||
|
|
/* Cases 3, 7, 12, 13, 15 remain. */
|
||
|
|
|
||
|
|
if (fd1 == AT_FDCWD) /* Cases 3, 7. */
|
||
|
|
{
|
||
|
|
if (stat (".", &st1) == -1 || fstat (fd2, &st2) == -1)
|
||
|
|
return -1;
|
||
|
|
if (!S_ISDIR (st2.st_mode))
|
||
|
|
{
|
||
|
|
errno = ENOTDIR;
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
if (SAME_INODE (st1, st2)) /* Reduced to cases 1, 5. */
|
||
|
|
return func (file1, file2);
|
||
|
|
}
|
||
|
|
else if (fd2 == AT_FDCWD) /* Cases 12, 13. */
|
||
|
|
{
|
||
|
|
if (stat (".", &st2) == -1 || fstat (fd1, &st1) == -1)
|
||
|
|
return -1;
|
||
|
|
if (!S_ISDIR (st1.st_mode))
|
||
|
|
{
|
||
|
|
errno = ENOTDIR;
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
if (SAME_INODE (st1, st2)) /* Reduced to cases 4, 5. */
|
||
|
|
return func (file1, file2);
|
||
|
|
}
|
||
|
|
else if (fd1 != fd2) /* Case 15b. */
|
||
|
|
{
|
||
|
|
if (fstat (fd1, &st1) == -1 || fstat (fd2, &st2) == -1)
|
||
|
|
return -1;
|
||
|
|
if (!S_ISDIR (st1.st_mode) || !S_ISDIR (st2.st_mode))
|
||
|
|
{
|
||
|
|
errno = ENOTDIR;
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
if (SAME_INODE (st1, st2)) /* Reduced to case 15a. */
|
||
|
|
{
|
||
|
|
fd2 = fd1;
|
||
|
|
if (stat (".", &st1) == 0 && SAME_INODE (st1, st2))
|
||
|
|
return func (file1, file2); /* Further reduced to case 5. */
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else /* Case 15a. */
|
||
|
|
{
|
||
|
|
if (fstat (fd1, &st1) == -1)
|
||
|
|
return -1;
|
||
|
|
if (!S_ISDIR (st1.st_mode))
|
||
|
|
{
|
||
|
|
errno = ENOTDIR;
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
if (stat (".", &st2) == 0 && SAME_INODE (st1, st2))
|
||
|
|
return func (file1, file2); /* Reduced to case 5. */
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Catch invalid arguments before changing directories. */
|
||
|
|
if (file1[0] == '\0' || file2[0] == '\0')
|
||
|
|
{
|
||
|
|
errno = ENOENT;
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Cases 3, 7, 12, 13, 15a, 15b remain. With all reductions in
|
||
|
|
place, it is time to start changing directories. */
|
||
|
|
|
||
|
|
if (save_cwd (&saved_cwd) != 0)
|
||
|
|
openat_save_fail (errno);
|
||
|
|
|
||
|
|
if (fd1 != AT_FDCWD && fd2 != AT_FDCWD && fd1 != fd2) /* Case 15b. */
|
||
|
|
{
|
||
|
|
if (fchdir (fd1) != 0)
|
||
|
|
{
|
||
|
|
saved_errno = errno;
|
||
|
|
free_cwd (&saved_cwd);
|
||
|
|
errno = saved_errno;
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
fd1 = AT_FDCWD; /* Reduced to case 7. */
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Cases 3, 7, 12, 13, 15a remain. Convert one relative name to
|
||
|
|
absolute, if necessary. */
|
||
|
|
|
||
|
|
file1_alt = (char *) file1;
|
||
|
|
file2_alt = (char *) file2;
|
||
|
|
|
||
|
|
if (fd1 == AT_FDCWD && !IS_ABSOLUTE_FILE_NAME (file1)) /* Case 7. */
|
||
|
|
{
|
||
|
|
/* It would be nicer to use:
|
||
|
|
file1_alt = file_name_concat (xgetcwd (), file1, NULL);
|
||
|
|
but libraries should not call xalloc_die. */
|
||
|
|
char *cwd = getcwd (NULL, 0);
|
||
|
|
if (!cwd)
|
||
|
|
{
|
||
|
|
saved_errno = errno;
|
||
|
|
free_cwd (&saved_cwd);
|
||
|
|
errno = saved_errno;
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
file1_alt = mfile_name_concat (cwd, file1, NULL);
|
||
|
|
if (!file1_alt)
|
||
|
|
{
|
||
|
|
saved_errno = errno;
|
||
|
|
free (cwd);
|
||
|
|
free_cwd (&saved_cwd);
|
||
|
|
errno = saved_errno;
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
free (cwd); /* Reduced to case 3. */
|
||
|
|
}
|
||
|
|
else if (fd2 == AT_FDCWD && !IS_ABSOLUTE_FILE_NAME (file2)) /* Case 13. */
|
||
|
|
{
|
||
|
|
char *cwd = getcwd (NULL, 0);
|
||
|
|
if (!cwd)
|
||
|
|
{
|
||
|
|
saved_errno = errno;
|
||
|
|
free_cwd (&saved_cwd);
|
||
|
|
errno = saved_errno;
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
file2_alt = mfile_name_concat (cwd, file2, NULL);
|
||
|
|
if (!file2_alt)
|
||
|
|
{
|
||
|
|
saved_errno = errno;
|
||
|
|
free (cwd);
|
||
|
|
free_cwd (&saved_cwd);
|
||
|
|
errno = saved_errno;
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
free (cwd); /* Reduced to case 12. */
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Cases 3, 12, 15a remain. Change to the correct directory. */
|
||
|
|
if (fchdir (fd1 == AT_FDCWD ? fd2 : fd1) != 0)
|
||
|
|
{
|
||
|
|
saved_errno = errno;
|
||
|
|
free_cwd (&saved_cwd);
|
||
|
|
if (file1 != file1_alt)
|
||
|
|
free (file1_alt);
|
||
|
|
else if (file2 != file2_alt)
|
||
|
|
free (file2_alt);
|
||
|
|
errno = saved_errno;
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Finally safe to perform the user's function, then clean up. */
|
||
|
|
|
||
|
|
err = func (file1_alt, file2_alt);
|
||
|
|
saved_errno = (err < 0 ? errno : 0);
|
||
|
|
|
||
|
|
if (file1 != file1_alt)
|
||
|
|
free (file1_alt);
|
||
|
|
else if (file2 != file2_alt)
|
||
|
|
free (file2_alt);
|
||
|
|
|
||
|
|
if (restore_cwd (&saved_cwd) != 0)
|
||
|
|
openat_restore_fail (errno);
|
||
|
|
|
||
|
|
free_cwd (&saved_cwd);
|
||
|
|
|
||
|
|
if (saved_errno)
|
||
|
|
errno = saved_errno;
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
#undef CALL_FUNC
|
||
|
|
#undef FUNC_RESULT
|