src/touch.c

   1 /* touch -- change modification and access times of files
   2    Copyright (C) 1987-2024 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 [[CC]YY]MMDDhhmm[.ss]  use specified time instead of current time,\n\
 243                          with a date-time format that differs from -d's\n\
 244 "), stdout);
 245       fputs (_("\
 246       --time=WORD        specify which time to change:\n\
 247                            access time (-a): 'access', 'atime', 'use';\n\
 248                            modification time (-m): 'modify', 'mtime'\n\
 249 "), stdout);
 250       fputs (HELP_OPTION_DESCRIPTION, stdout);
 251       fputs (VERSION_OPTION_DESCRIPTION, stdout);
 252       emit_ancillary_info (PROGRAM_NAME);
 253     }
 254   exit (status);
 255 }
 256
 257 int
 258 main (int argc, char **argv)
 259 {
 260   int c;
 261   bool date_set = false;
 262   bool ok = true;
 263   char const *flex_date = nullptr;
 264
 265   initialize_main (&argc, &argv);
 266   set_program_name (argv[0]);
 267   setlocale (LC_ALL, "");
 268   bindtextdomain (PACKAGE, LOCALEDIR);
 269   textdomain (PACKAGE);
 270
 271   atexit (close_stdout);
 272
 273   change_times = 0;
 274   no_create = use_ref = false;
 275
 276   while ((c = getopt_long (argc, argv, "acd:fhmr:t:", longopts, nullptr)) != -1)
 277     {
 278       switch (c)
 279         {
 280         case 'a':
 281           change_times |= CH_ATIME;
 282           break;
 283
 284         case 'c':
 285           no_create = true;
 286           break;
 287
 288         case 'd':
 289           flex_date = optarg;
 290           break;
 291
 292         case 'f':
 293           break;
 294
 295         case 'h':
 296           no_dereference = true;
 297           break;
 298
 299         case 'm':
 300           change_times |= CH_MTIME;
 301           break;
 302
 303         case 'r':
 304           use_ref = true;
 305           ref_file = optarg;
 306           break;
 307
 308         case 't':
 309           if (! posixtime (&newtime[0].tv_sec, optarg,
 310                            PDS_LEADING_YEAR | PDS_CENTURY | PDS_SECONDS))
 311             error (EXIT_FAILURE, 0, _("invalid date format %s"),
 312                    quote (optarg));
 313           newtime[0].tv_nsec = 0;
 314           newtime[1] = newtime[0];
 315           date_set = true;
 316           break;
 317
 318         case TIME_OPTION:       /* --time */
 319           change_times |= XARGMATCH ("--time", optarg,
 320                                      time_args, time_masks);
 321           break;
 322
 323         case_GETOPT_HELP_CHAR;
 324
 325         case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
 326
 327         default:
 328           usage (EXIT_FAILURE);
 329         }
 330     }
 331
 332   if (change_times == 0)
 333     change_times = CH_ATIME | CH_MTIME;
 334
 335   if (date_set && (use_ref || flex_date))
 336     {
 337       error (0, 0, _("cannot specify times from more than one source"));
 338       usage (EXIT_FAILURE);
 339     }
 340
 341   if (use_ref)
 342     {
 343       struct stat ref_stats;
 344       /* Don't use (no_dereference?lstat:stat) (args), since stat
 345          might be an object-like macro.  */
 346       if (no_dereference ? lstat (ref_file, &ref_stats)
 347           : stat (ref_file, &ref_stats))
 348         error (EXIT_FAILURE, errno,
 349                _("failed to get attributes of %s"), quoteaf (ref_file));
 350       newtime[0] = get_stat_atime (&ref_stats);
 351       newtime[1] = get_stat_mtime (&ref_stats);
 352       date_set = true;
 353       if (flex_date)
 354         {
 355           if (change_times & CH_ATIME)
 356             newtime[0] = date_relative (flex_date, newtime[0]);
 357           if (change_times & CH_MTIME)
 358             newtime[1] = date_relative (flex_date, newtime[1]);
 359         }
 360     }
 361   else
 362     {
 363       if (flex_date)
 364         {
 365           struct timespec now = current_timespec ();
 366           newtime[1] = newtime[0] = date_relative (flex_date, now);
 367           date_set = true;
 368
 369           /* If neither -a nor -m is specified, treat "-d now" as if
 370              it were absent; this lets "touch" succeed more often in
 371              the presence of restrictive permissions.  */
 372           if (change_times == (CH_ATIME | CH_MTIME)
 373               && newtime[0].tv_sec == now.tv_sec
 374               && newtime[0].tv_nsec == now.tv_nsec)
 375             {
 376               /* Check that it really was "-d now", and not a timestamp
 377                  that just happens to be the current time.  */
 378               struct timespec notnow, notnow1;
 379               notnow.tv_sec = now.tv_sec ^ 1;
 380               notnow.tv_nsec = now.tv_nsec;
 381               notnow1 = date_relative (flex_date, notnow);
 382               if (notnow1.tv_sec == notnow.tv_sec
 383                   && notnow1.tv_nsec == notnow.tv_nsec)
 384                 date_set = false;
 385             }
 386         }
 387     }
 388
 389   /* The obsolete 'MMDDhhmm[YY]' form is valid IFF there are
 390      two or more non-option arguments.  */
 391   if (!date_set && 2 <= argc - optind && posix2_version () < 200112
 392       && posixtime (&newtime[0].tv_sec, argv[optind],
 393                     PDS_TRAILING_YEAR | PDS_PRE_2000))
 394     {
 395       newtime[0].tv_nsec = 0;
 396       newtime[1] = newtime[0];
 397       date_set = true;
 398
 399       if (! getenv ("POSIXLY_CORRECT"))
 400         {
 401           struct tm const *tm = localtime (&newtime[0].tv_sec);
 402
 403           /* Technically, it appears that even a deliberate attempt to cause
 404              the above localtime to return nullptr will always fail because our
 405              posixtime implementation rejects all dates for which localtime
 406              would fail.  However, skip the warning if it ever fails.  */
 407           if (tm)
 408             error (0, 0,
 409                    _("warning: 'touch %s' is obsolete; use "
 410                      "'touch -t %04ld%02d%02d%02d%02d.%02d'"),
 411                    argv[optind],
 412                    tm->tm_year + 1900L, tm->tm_mon + 1, tm->tm_mday,
 413                    tm->tm_hour, tm->tm_min, tm->tm_sec);
 414         }
 415
 416       optind++;
 417     }
 418
 419   if (!date_set)
 420     {
 421       if (change_times == (CH_ATIME | CH_MTIME))
 422         amtime_now = true;
 423       else
 424         newtime[1].tv_nsec = newtime[0].tv_nsec = UTIME_NOW;
 425     }
 426
 427   if (optind == argc)
 428     {
 429       error (0, 0, _("missing file operand"));
 430       usage (EXIT_FAILURE);
 431     }
 432
 433   for (; optind < argc; ++optind)
 434     ok &= touch (argv[optind]);
 435
 436   return ok ? EXIT_SUCCESS : EXIT_FAILURE;
 437 }