lib/utimens.c

   1 /* Set file access and modification times.
   2
   3    Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free
   4    Software Foundation, Inc.
   5
   6    This program is free software: you can redistribute it and/or modify it
   7    under the terms of the GNU General Public License as published by the
   8    Free Software Foundation; either version 3 of the License, or any
   9    later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  18
  19 /* Written by Paul Eggert.  */
  20
  21 /* derived from a function in touch.c */
  22
  23 #include <config.h>
  24
  25 #include "utimens.h"
  26
  27 #include <errno.h>
  28 #include <fcntl.h>
  29 #include <sys/stat.h>
  30 #include <sys/time.h>
  31 #include <unistd.h>
  32
  33 #if HAVE_UTIME_H
  34 # include <utime.h>
  35 #endif
  36
  37 /* Some systems (even some that do have <utime.h>) don't declare this
  38    structure anywhere.  */
  39 #ifndef HAVE_STRUCT_UTIMBUF
  40 struct utimbuf
  41 {
  42   long actime;
  43   long modtime;
  44 };
  45 #endif
  46
  47 /* Set the access and modification time stamps of FD (a.k.a. FILE) to be
  48    TIMESPEC[0] and TIMESPEC[1], respectively.
  49    FD must be either negative -- in which case it is ignored --
  50    or a file descriptor that is open on FILE.
  51    If FD is nonnegative, then FILE can be NULL, which means
  52    use just futimes (or equivalent) instead of utimes (or equivalent),
  53    and fail if on an old system without futimes (or equivalent).
  54    If TIMESPEC is null, set the time stamps to the current time.
  55    Return 0 on success, -1 (setting errno) on failure.  */
  56
  57 int
  58 gl_futimens (int fd _UNUSED_PARAMETER_,
  59              char const *file, struct timespec const timespec[2])
  60 {
  61   /* Some Linux-based NFS clients are buggy, and mishandle time stamps
  62      of files in NFS file systems in some cases.  We have no
  63      configure-time test for this, but please see
  64      <http://bugs.gentoo.org/show_bug.cgi?id=132673> for references to
  65      some of the problems with Linux 2.6.16.  If this affects you,
  66      compile with -DHAVE_BUGGY_NFS_TIME_STAMPS; this is reported to
  67      help in some cases, albeit at a cost in performance.  But you
  68      really should upgrade your kernel to a fixed version, since the
  69      problem affects many applications.  */
  70
  71 #if HAVE_BUGGY_NFS_TIME_STAMPS
  72   if (fd < 0)
  73     sync ();
  74   else
  75     fsync (fd);
  76 #endif
  77
  78   /* POSIX 200x added two interfaces to set file timestamps with
  79      nanosecond resolution.  We provide a fallback for ENOSYS (for
  80      example, compiling against Linux 2.6.25 kernel headers and glibc
  81      2.7, but running on Linux 2.6.18 kernel).  */
  82 #if HAVE_UTIMENSAT
  83   if (fd < 0)
  84     {
  85       int result = utimensat (AT_FDCWD, file, timespec, 0);
  86 # ifdef __linux__
  87       /* Work around what might be a kernel bug:
  88          http://bugzilla.redhat.com/442352
  89          http://bugzilla.redhat.com/449910
  90          It appears that utimensat can mistakenly return 280 rather
  91          than -1 upon failure.
  92          FIXME: remove in 2010 or whenever the offending kernels
  93          are no longer in common use.  */
  94       if (0 < result)
  95         errno = ENOSYS;
  96 # endif
  97
  98       if (result == 0 || errno != ENOSYS)
  99         return result;
 100     }
 101 #endif
 102 #if HAVE_FUTIMENS
 103   {
 104     int result = futimens (fd, timespec);
 105 # ifdef __linux__
 106     /* Work around the same bug as above.  */
 107     if (0 < result)
 108       errno = ENOSYS;
 109 # endif
 110     if (result == 0 || errno != ENOSYS)
 111       return result;
 112   }
 113 #endif
 114
 115   /* The platform lacks an interface to set file timestamps with
 116      nanosecond resolution, so do the best we can, discarding any
 117      fractional part of the timestamp.  */
 118   {
 119 #if HAVE_FUTIMESAT || HAVE_WORKING_UTIMES
 120     struct timeval timeval[2];
 121     struct timeval const *t;
 122     if (timespec)
 123       {
 124         timeval[0].tv_sec = timespec[0].tv_sec;
 125         timeval[0].tv_usec = timespec[0].tv_nsec / 1000;
 126         timeval[1].tv_sec = timespec[1].tv_sec;
 127         timeval[1].tv_usec = timespec[1].tv_nsec / 1000;
 128         t = timeval;
 129       }
 130     else
 131       t = NULL;
 132
 133     if (fd < 0)
 134       {
 135 # if HAVE_FUTIMESAT
 136         return futimesat (AT_FDCWD, file, t);
 137 # endif
 138       }
 139     else
 140       {
 141         /* If futimesat or futimes fails here, don't try to speed things
 142            up by returning right away.  glibc can incorrectly fail with
 143            errno == ENOENT if /proc isn't mounted.  Also, Mandrake 10.0
 144            in high security mode doesn't allow ordinary users to read
 145            /proc/self, so glibc incorrectly fails with errno == EACCES.
 146            If errno == EIO, EPERM, or EROFS, it's probably safe to fail
 147            right away, but these cases are rare enough that they're not
 148            worth optimizing, and who knows what other messed-up systems
 149            are out there?  So play it safe and fall back on the code
 150            below.  */
 151 # if HAVE_FUTIMESAT
 152         if (futimesat (fd, NULL, t) == 0)
 153           return 0;
 154 # elif HAVE_FUTIMES
 155         if (futimes (fd, t) == 0)
 156           return 0;
 157 # endif
 158       }
 159 #endif /* HAVE_FUTIMESAT || HAVE_WORKING_UTIMES */
 160
 161     if (!file)
 162       {
 163 #if ! (HAVE_FUTIMESAT || (HAVE_WORKING_UTIMES && HAVE_FUTIMES))
 164         errno = ENOSYS;
 165 #endif
 166
 167         /* Prefer EBADF to ENOSYS if both error numbers apply.  */
 168         if (errno == ENOSYS)
 169           {
 170             int fd2 = dup (fd);
 171             int dup_errno = errno;
 172             if (0 <= fd2)
 173               close (fd2);
 174             errno = (fd2 < 0 && dup_errno == EBADF ? EBADF : ENOSYS);
 175           }
 176
 177         return -1;
 178       }
 179
 180 #if HAVE_WORKING_UTIMES
 181     return utimes (file, t);
 182 #else
 183     {
 184       struct utimbuf utimbuf;
 185       struct utimbuf const *ut;
 186       if (timespec)
 187         {
 188           utimbuf.actime = timespec[0].tv_sec;
 189           utimbuf.modtime = timespec[1].tv_sec;
 190           ut = &utimbuf;
 191         }
 192       else
 193         ut = NULL;
 194
 195       return utime (file, ut);
 196     }
 197 #endif /* !HAVE_WORKING_UTIMES */
 198   }
 199 }
 200
 201 /* Set the access and modification time stamps of FILE to be
 202    TIMESPEC[0] and TIMESPEC[1], respectively.  */
 203 int
 204 utimens (char const *file, struct timespec const timespec[2])
 205 {
 206   return gl_futimens (-1, file, timespec);
 207 }