2009-10-07 Eric Blake <ebb9@byu.net>
+ openat, utimens: whitespace cleanup
+ * lib/openat.c: Prefer space throughout, rather than mix of 8
+ spaces vs. tabs.
+ * lib/at-func.c: Likewise.
+ * lib/utimens.c: Likewise.
+
openat: avoid using wrong fd
* lib/openat.c (openat_permissive): Reject user's fd if saving the
working directory chooses same fd.
char *proc_file = openat_proc_name (proc_buf, fd, file);
if (proc_file)
{
- FUNC_RESULT proc_result = CALL_FUNC (proc_file);
- int proc_errno = errno;
- if (proc_file != proc_buf)
- free (proc_file);
- /* 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;
- }
+ FUNC_RESULT proc_result = CALL_FUNC (proc_file);
+ int proc_errno = errno;
+ if (proc_file != proc_buf)
+ free (proc_file);
+ /* 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;
+ }
}
}
va_start (arg, flags);
/* We have to use PROMOTED_MODE_T instead of mode_t, otherwise GCC 4
- creates crashing code when 'mode_t' is smaller than 'int'. */
+ creates crashing code when 'mode_t' is smaller than 'int'. */
mode = va_arg (arg, PROMOTED_MODE_T);
va_end (arg);
{
size_t len = strlen (filename);
if (len > 0 && filename[len - 1] == '/')
- {
- errno = EISDIR;
- return -1;
- }
+ {
+ errno = EISDIR;
+ return -1;
+ }
}
#endif
/* We know len is positive, since open did not fail with ENOENT. */
size_t len = strlen (filename);
if (filename[len - 1] == '/')
- {
- struct stat statbuf;
-
- if (fstat (fd, &statbuf) >= 0 && !S_ISDIR (statbuf.st_mode))
- {
- close (fd);
- errno = ENOTDIR;
- return -1;
- }
- }
+ {
+ struct stat statbuf;
+
+ if (fstat (fd, &statbuf) >= 0 && !S_ISDIR (statbuf.st_mode))
+ {
+ close (fd);
+ errno = ENOTDIR;
+ return -1;
+ }
+ }
}
#endif
va_start (arg, flags);
/* We have to use PROMOTED_MODE_T instead of mode_t, otherwise GCC 4
- creates crashing code when 'mode_t' is smaller than 'int'. */
+ creates crashing code when 'mode_t' is smaller than 'int'. */
mode = va_arg (arg, PROMOTED_MODE_T);
va_end (arg);
int
openat_permissive (int fd, char const *file, int flags, mode_t mode,
- int *cwd_errno)
+ int *cwd_errno)
{
struct saved_cwd saved_cwd;
int saved_errno;
char *proc_file = openat_proc_name (buf, fd, file);
if (proc_file)
{
- int open_result = open (proc_file, flags, mode);
- int open_errno = errno;
- if (proc_file != buf)
- free (proc_file);
- /* 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 <= open_result || ! EXPECTED_ERRNO (open_errno))
- {
- errno = open_errno;
- return open_result;
- }
+ int open_result = open (proc_file, flags, mode);
+ int open_errno = errno;
+ if (proc_file != buf)
+ free (proc_file);
+ /* 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 <= open_result || ! EXPECTED_ERRNO (open_errno))
+ {
+ errno = open_errno;
+ return open_result;
+ }
}
}
if (! save_ok)
{
if (! cwd_errno)
- openat_save_fail (errno);
+ openat_save_fail (errno);
*cwd_errno = errno;
}
if (0 <= fd && fd == saved_cwd.desc)
err = open (file, flags, mode);
saved_errno = errno;
if (save_ok && restore_cwd (&saved_cwd) != 0)
- {
- if (! cwd_errno)
- {
- /* Don't write a message to just-created fd 2. */
- saved_errno = errno;
- if (err == STDERR_FILENO)
- close (err);
- openat_restore_fail (saved_errno);
- }
- *cwd_errno = errno;
- }
+ {
+ if (! cwd_errno)
+ {
+ /* Don't write a message to just-created fd 2. */
+ saved_errno = errno;
+ if (err == STDERR_FILENO)
+ close (err);
+ openat_restore_fail (saved_errno);
+ }
+ *cwd_errno = errno;
+ }
}
free_cwd (&saved_cwd);
char buf[OPENAT_BUFFER_SIZE];
char *proc_file = openat_proc_name (buf, fd, ".");
if (proc_file)
- {
- needs_fchdir = false;
- if (proc_file != buf)
- free (proc_file);
- }
+ {
+ needs_fchdir = false;
+ if (proc_file != buf)
+ free (proc_file);
+ }
close (fd);
}
int
gl_futimens (int fd ATTRIBUTE_UNUSED,
- char const *file, struct timespec const timespec[2])
+ char const *file, struct timespec const timespec[2])
{
/* Some Linux-based NFS clients are buggy, and mishandle time stamps
of files in NFS file systems in some cases. We have no
struct timeval const *t;
if (timespec)
{
- timeval[0].tv_sec = timespec[0].tv_sec;
- timeval[0].tv_usec = timespec[0].tv_nsec / 1000;
- timeval[1].tv_sec = timespec[1].tv_sec;
- timeval[1].tv_usec = timespec[1].tv_nsec / 1000;
- t = timeval;
+ timeval[0].tv_sec = timespec[0].tv_sec;
+ timeval[0].tv_usec = timespec[0].tv_nsec / 1000;
+ timeval[1].tv_sec = timespec[1].tv_sec;
+ timeval[1].tv_usec = timespec[1].tv_nsec / 1000;
+ t = timeval;
}
else
t = NULL;
if (fd < 0)
{
# if HAVE_FUTIMESAT
- return futimesat (AT_FDCWD, file, t);
+ return futimesat (AT_FDCWD, file, t);
# endif
}
else
{
- /* If futimesat or futimes fails here, don't try to speed things
- up by returning right away. glibc can incorrectly fail with
- errno == ENOENT if /proc isn't mounted. Also, Mandrake 10.0
- in high security mode doesn't allow ordinary users to read
- /proc/self, so glibc incorrectly fails with errno == EACCES.
- If errno == EIO, EPERM, or EROFS, it's probably safe to fail
- right away, but these cases are rare enough that they're not
- worth optimizing, and who knows what other messed-up systems
- are out there? So play it safe and fall back on the code
- below. */
+ /* If futimesat or futimes fails here, don't try to speed things
+ up by returning right away. glibc can incorrectly fail with
+ errno == ENOENT if /proc isn't mounted. Also, Mandrake 10.0
+ in high security mode doesn't allow ordinary users to read
+ /proc/self, so glibc incorrectly fails with errno == EACCES.
+ If errno == EIO, EPERM, or EROFS, it's probably safe to fail
+ right away, but these cases are rare enough that they're not
+ worth optimizing, and who knows what other messed-up systems
+ are out there? So play it safe and fall back on the code
+ below. */
# if HAVE_FUTIMESAT
- if (futimesat (fd, NULL, t) == 0)
- return 0;
+ if (futimesat (fd, NULL, t) == 0)
+ return 0;
# elif HAVE_FUTIMES
- if (futimes (fd, t) == 0)
- return 0;
+ if (futimes (fd, t) == 0)
+ return 0;
# endif
}
#endif /* HAVE_FUTIMESAT || HAVE_WORKING_UTIMES */
if (!file)
{
#if ! (HAVE_FUTIMESAT || (HAVE_WORKING_UTIMES && HAVE_FUTIMES))
- errno = ENOSYS;
+ errno = ENOSYS;
#endif
- /* Prefer EBADF to ENOSYS if both error numbers apply. */
- if (errno == ENOSYS)
- {
- int fd2 = dup (fd);
- int dup_errno = errno;
- if (0 <= fd2)
- close (fd2);
- errno = (fd2 < 0 && dup_errno == EBADF ? EBADF : ENOSYS);
- }
-
- return -1;
+ /* Prefer EBADF to ENOSYS if both error numbers apply. */
+ if (errno == ENOSYS)
+ {
+ int fd2 = dup (fd);
+ int dup_errno = errno;
+ if (0 <= fd2)
+ close (fd2);
+ errno = (fd2 < 0 && dup_errno == EBADF ? EBADF : ENOSYS);
+ }
+
+ return -1;
}
#if HAVE_WORKING_UTIMES
struct utimbuf utimbuf;
struct utimbuf const *ut;
if (timespec)
- {
- utimbuf.actime = timespec[0].tv_sec;
- utimbuf.modtime = timespec[1].tv_sec;
- ut = &utimbuf;
- }
+ {
+ utimbuf.actime = timespec[0].tv_sec;
+ utimbuf.modtime = timespec[1].tv_sec;
+ ut = &utimbuf;
+ }
else
- ut = NULL;
+ ut = NULL;
return utime (file, ut);
}
projects / pspp / commitdiff