src/touch.c

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