src/touch.c

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