src/touch.c

   1 /* touch -- change modification and access times of files
   2    Copyright (C) 1987, 1989-1991, 1995-2005, 2007-2012 Free Software
   3    Foundation, Inc.
   4
   5    This program is free software: you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation, either version 3 of the License, or
   8    (at your option) any later version.
   9
  10    This program 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
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  17
  18 /* Written by Paul Rubin, Arnold Robbins, Jim Kingdon, David MacKenzie,
  19    and Randy Smith. */
  20
  21 #include <config.h>
  22 #include <stdio.h>
  23 #include <getopt.h>
  24 #include <sys/types.h>
  25 #include <assert.h>
  26
  27 #include "system.h"
  28 #include "argmatch.h"
  29 #include "error.h"
  30 #include "fd-reopen.h"
  31 #include "parse-datetime.h"
  32 #include "posixtm.h"
  33 #include "posixver.h"
  34 #include "quote.h"
  35 #include "stat-time.h"
  36 #include "utimens.h"
  37
  38 /* The official name of this program (e.g., no `g' prefix).  */
  39 #define PROGRAM_NAME "touch"
  40
  41 #define AUTHORS \
  42   proper_name ("Paul Rubin"), \
  43   proper_name ("Arnold Robbins"), \
  44   proper_name ("Jim Kingdon"), \
  45   proper_name ("David MacKenzie"), \
  46   proper_name ("Randy Smith")
  47
  48 /* Bitmasks for `change_times'. */
  49 #define CH_ATIME 1
  50 #define CH_MTIME 2
  51
  52 /* Which timestamps to change. */
  53 static int change_times;
  54
  55 /* (-c) If true, don't create if not already there.  */
  56 static bool no_create;
  57
  58 /* (-r) If true, use times from a reference file.  */
  59 static bool use_ref;
  60
  61 /* (-h) If true, change the times of an existing symlink, if possible.  */
  62 static bool no_dereference;
  63
  64 /* If true, the only thing we have to do is change both the
  65    modification and access time to the current time, so we don't
  66    have to own the file, just be able to read and write it.
  67    On some systems, we can do this if we own the file, even though
  68    we have neither read nor write access to it.  */
  69 static bool amtime_now;
  70
  71 /* New access and modification times to use when setting time.  */
  72 static struct timespec newtime[2];
  73
  74 /* File to use for -r. */
  75 static char *ref_file;
  76
  77 /* For long options that have no equivalent short option, use a
  78    non-character as a pseudo short option, starting with CHAR_MAX + 1.  */
  79 enum
  80 {
  81   TIME_OPTION = CHAR_MAX + 1
  82 };
  83
  84 static struct option const longopts[] =
  85 {
  86   {"time", required_argument, NULL, TIME_OPTION},
  87   {"no-create", no_argument, NULL, 'c'},
  88   {"date", required_argument, NULL, 'd'},
  89   {"reference", required_argument, NULL, 'r'},
  90   {"no-dereference", no_argument, NULL, 'h'},
  91   {GETOPT_HELP_OPTION_DECL},
  92   {GETOPT_VERSION_OPTION_DECL},
  93   {NULL, 0, NULL, 0}
  94 };
  95
  96 /* Valid arguments to the `--time' option. */
  97 static char const* const time_args[] =
  98 {
  99   "atime", "access", "use", "mtime", "modify", NULL
 100 };
 101
 102 /* The bits in `change_times' that those arguments set. */
 103 static int const time_masks[] =
 104 {
 105   CH_ATIME, CH_ATIME, CH_ATIME, CH_MTIME, CH_MTIME
 106 };
 107
 108 /* Store into *RESULT the result of interpreting FLEX_DATE as a date,
 109    relative to NOW.  If NOW is null, use the current time.  */
 110
 111 static void
 112 get_reldate (struct timespec *result,
 113              char const *flex_date, struct timespec const *now)
 114 {
 115   if (! parse_datetime (result, flex_date, now))
 116     error (EXIT_FAILURE, 0, _("invalid date format %s"), quote (flex_date));
 117 }
 118
 119 /* Update the time of file FILE according to the options given.
 120    Return true if successful.  */
 121
 122 static bool
 123 touch (const char *file)
 124 {
 125   bool ok;
 126   int fd = -1;
 127   int open_errno = 0;
 128   struct timespec const *t = newtime;
 129
 130   if (STREQ (file, "-"))
 131     fd = STDOUT_FILENO;
 132   else if (! (no_create || no_dereference))
 133     {
 134       /* Try to open FILE, creating it if necessary.  */
 135       int default_permissions =
 136         S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
 137       fd = fd_reopen (STDIN_FILENO, file,
 138                       O_WRONLY | O_CREAT | O_NONBLOCK | O_NOCTTY,
 139                       default_permissions);
 140
 141       /* Don't save a copy of errno if it's EISDIR, since that would lead
 142          touch to give a bogus diagnostic for e.g., `touch /' (assuming
 143          we don't own / or have write access to it).  On Solaris 5.6,
 144          and probably other systems, it is EINVAL.  On SunOS4, it's EPERM.  */
 145       if (fd == -1 && errno != EISDIR && errno != EINVAL && errno != EPERM)
 146         open_errno = errno;
 147     }
 148
 149   if (change_times != (CH_ATIME | CH_MTIME))
 150     {
 151       /* We're setting only one of the time values.  */
 152       if (change_times == CH_MTIME)
 153         newtime[0].tv_nsec = UTIME_OMIT;
 154       else
 155         {
 156           assert (change_times == CH_ATIME);
 157           newtime[1].tv_nsec = UTIME_OMIT;
 158         }
 159     }
 160
 161   if (amtime_now)
 162     {
 163       /* Pass NULL to futimens so it will not fail if we have
 164          write access to the file, but don't own it.  */
 165       t = NULL;
 166     }
 167
 168   ok = (fdutimensat (fd, AT_FDCWD, (fd == STDOUT_FILENO ? NULL : file), t,
 169                      (no_dereference && fd == -1) ? AT_SYMLINK_NOFOLLOW : 0)
 170         == 0);
 171
 172   if (fd == STDIN_FILENO)
 173     {
 174       if (close (STDIN_FILENO) != 0)
 175         {
 176           error (0, errno, _("closing %s"), quote (file));
 177           return false;
 178         }
 179     }
 180   else if (fd == STDOUT_FILENO)
 181     {
 182       /* Do not diagnose "touch -c - >&-".  */
 183       if (!ok && errno == EBADF && no_create)
 184         return true;
 185     }
 186
 187   if (!ok)
 188     {
 189       if (open_errno)
 190         {
 191           /* The wording of this diagnostic should cover at least two cases:
 192              - the file does not exist, but the parent directory is unwritable
 193              - the file exists, but it isn't writable
 194              I think it's not worth trying to distinguish them.  */
 195           error (0, open_errno, _("cannot touch %s"), quote (file));
 196         }
 197       else
 198         {
 199           if (no_create && errno == ENOENT)
 200             return true;
 201           error (0, errno, _("setting times of %s"), quote (file));
 202         }
 203       return false;
 204     }
 205
 206   return true;
 207 }
 208
 209 void
 210 usage (int status)
 211 {
 212   if (status != EXIT_SUCCESS)
 213     emit_try_help ();
 214   else
 215     {
 216       printf (_("Usage: %s [OPTION]... FILE...\n"), program_name);
 217       fputs (_("\
 218 Update the access and modification times of each FILE to the current time.\n\
 219 \n\
 220 A FILE argument that does not exist is created empty, unless -c or -h\n\
 221 is supplied.\n\
 222 \n\
 223 A FILE argument string of - is handled specially and causes touch to\n\
 224 change the times of the file associated with standard output.\n\
 225 \n\
 226 "), stdout);
 227       fputs (_("\
 228 Mandatory arguments to long options are mandatory for short options too.\n\
 229 "), stdout);
 230       fputs (_("\
 231   -a                     change only the access time\n\
 232   -c, --no-create        do not create any files\n\
 233   -d, --date=STRING      parse STRING and use it instead of current time\n\
 234   -f                     (ignored)\n\
 235 "), stdout);
 236       fputs (_("\
 237   -h, --no-dereference   affect each symbolic link instead of any referenced\n\
 238                          file (useful only on systems that can change the\n\
 239                          timestamps of a symlink)\n\
 240   -m                     change only the modification time\n\
 241 "), stdout);
 242       fputs (_("\
 243   -r, --reference=FILE   use this file's times instead of current time\n\
 244   -t STAMP               use [[CC]YY]MMDDhhmm[.ss] instead of current time\n\
 245   --time=WORD            change the specified time:\n\
 246                            WORD is access, atime, or use: equivalent to -a\n\
 247                            WORD is modify or mtime: equivalent to -m\n\
 248 "), stdout);
 249       fputs (HELP_OPTION_DESCRIPTION, stdout);
 250       fputs (VERSION_OPTION_DESCRIPTION, stdout);
 251       fputs (_("\
 252 \n\
 253 Note that the -d and -t options accept different time-date formats.\n\
 254 "), stdout);
 255       emit_ancillary_info ();
 256     }
 257   exit (status);
 258 }
 259
 260 int
 261 main (int argc, char **argv)
 262 {
 263   int c;
 264   bool date_set = false;
 265   bool ok = true;
 266   char const *flex_date = NULL;
 267
 268   initialize_main (&argc, &argv);
 269   set_program_name (argv[0]);
 270   setlocale (LC_ALL, "");
 271   bindtextdomain (PACKAGE, LOCALEDIR);
 272   textdomain (PACKAGE);
 273
 274   atexit (close_stdout);
 275
 276   change_times = 0;
 277   no_create = use_ref = false;
 278
 279   while ((c = getopt_long (argc, argv, "acd:fhmr:t:", longopts, NULL)) != -1)
 280     {
 281       switch (c)
 282         {
 283         case 'a':
 284           change_times |= CH_ATIME;
 285           break;
 286
 287         case 'c':
 288           no_create = true;
 289           break;
 290
 291         case 'd':
 292           flex_date = optarg;
 293           break;
 294
 295         case 'f':
 296           break;
 297
 298         case 'h':
 299           no_dereference = true;
 300           break;
 301
 302         case 'm':
 303           change_times |= CH_MTIME;
 304           break;
 305
 306         case 'r':
 307           use_ref = true;
 308           ref_file = optarg;
 309           break;
 310
 311         case 't':
 312           if (! posixtime (&newtime[0].tv_sec, optarg,
 313                            PDS_LEADING_YEAR | PDS_CENTURY | PDS_SECONDS))
 314             error (EXIT_FAILURE, 0, _("invalid date format %s"),
 315                    quote (optarg));
 316           newtime[0].tv_nsec = 0;
 317           newtime[1] = newtime[0];
 318           date_set = true;
 319           break;
 320
 321         case TIME_OPTION:       /* --time */
 322           change_times |= XARGMATCH ("--time", optarg,
 323                                      time_args, time_masks);
 324           break;
 325
 326         case_GETOPT_HELP_CHAR;
 327
 328         case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
 329
 330         default:
 331           usage (EXIT_FAILURE);
 332         }
 333     }
 334
 335   if (change_times == 0)
 336     change_times = CH_ATIME | CH_MTIME;
 337
 338   if (date_set && (use_ref || flex_date))
 339     {
 340       error (0, 0, _("cannot specify times from more than one source"));
 341       usage (EXIT_FAILURE);
 342     }
 343
 344   if (use_ref)
 345     {
 346       struct stat ref_stats;
 347       /* Don't use (no_dereference?lstat:stat) (args), since stat
 348          might be an object-like macro.  */
 349       if (no_dereference ? lstat (ref_file, &ref_stats)
 350           : stat (ref_file, &ref_stats))
 351         error (EXIT_FAILURE, errno,
 352                _("failed to get attributes of %s"), quote (ref_file));
 353       newtime[0] = get_stat_atime (&ref_stats);
 354       newtime[1] = get_stat_mtime (&ref_stats);
 355       date_set = true;
 356       if (flex_date)
 357         {
 358           if (change_times & CH_ATIME)
 359             get_reldate (&newtime[0], flex_date, &newtime[0]);
 360           if (change_times & CH_MTIME)
 361             get_reldate (&newtime[1], flex_date, &newtime[1]);
 362         }
 363     }
 364   else
 365     {
 366       if (flex_date)
 367         {
 368           struct timespec now;
 369           gettime (&now);
 370           get_reldate (&newtime[0], flex_date, &now);
 371           newtime[1] = newtime[0];
 372           date_set = true;
 373
 374           /* If neither -a nor -m is specified, treat "-d now" as if
 375              it were absent; this lets "touch" succeed more often in
 376              the presence of restrictive permissions.  */
 377           if (change_times == (CH_ATIME | CH_MTIME)
 378               && newtime[0].tv_sec == now.tv_sec
 379               && newtime[0].tv_nsec == now.tv_nsec)
 380             {
 381               /* Check that it really was "-d now", and not a time
 382                  stamp that just happens to be the current time.  */
 383               struct timespec notnow, notnow1;
 384               notnow.tv_sec = now.tv_sec ^ 1;
 385               notnow.tv_nsec = now.tv_nsec;
 386               get_reldate (&notnow1, flex_date, &notnow);
 387               if (notnow1.tv_sec == notnow.tv_sec
 388                   && notnow1.tv_nsec == notnow.tv_nsec)
 389                 date_set = false;
 390             }
 391         }
 392     }
 393
 394   /* The obsolete `MMDDhhmm[YY]' form is valid IFF there are
 395      two or more non-option arguments.  */
 396   if (!date_set && 2 <= argc - optind && posix2_version () < 200112
 397       && posixtime (&newtime[0].tv_sec, argv[optind],
 398                     PDS_TRAILING_YEAR | PDS_PRE_2000))
 399     {
 400       newtime[0].tv_nsec = 0;
 401       newtime[1] = newtime[0];
 402       date_set = true;
 403
 404       if (! getenv ("POSIXLY_CORRECT"))
 405         {
 406           struct tm const *tm = localtime (&newtime[0].tv_sec);
 407
 408           /* Technically, it appears that even a deliberate attempt to cause
 409              the above localtime to return NULL will always fail because our
 410              posixtime implementation rejects all dates for which localtime
 411              would fail.  However, skip the warning if it ever fails.  */
 412           if (tm)
 413             error (0, 0,
 414                    _("warning: 'touch %s' is obsolete; use "
 415                      "'touch -t %04ld%02d%02d%02d%02d.%02d'"),
 416                    argv[optind],
 417                    tm->tm_year + 1900L, tm->tm_mon + 1, tm->tm_mday,
 418                    tm->tm_hour, tm->tm_min, tm->tm_sec);
 419         }
 420
 421       optind++;
 422     }
 423
 424   if (!date_set)
 425     {
 426       if (change_times == (CH_ATIME | CH_MTIME))
 427         amtime_now = true;
 428       else
 429         newtime[1].tv_nsec = newtime[0].tv_nsec = UTIME_NOW;
 430     }
 431
 432   if (optind == argc)
 433     {
 434       error (0, 0, _("missing file operand"));
 435       usage (EXIT_FAILURE);
 436     }
 437
 438   for (; optind < argc; ++optind)
 439     ok &= touch (argv[optind]);
 440
 441   exit (ok ? EXIT_SUCCESS : EXIT_FAILURE);
 442 }