src/date.c

   1 /* date - print or set the system date and time
   2    Copyright (C) 1989-1999 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 2, or (at your option)
   7    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, write to the Free Software Foundation,
  16    Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  17
  18    David MacKenzie <djm@gnu.ai.mit.edu> */
  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 "closeout.h"
  27 #include "error.h"
  28 #include "getdate.h"
  29 #include "getline.h"
  30 #include "long-options.h"
  31 #include "posixtm.h"
  32
  33 #ifndef STDC_HEADERS
  34 size_t strftime ();
  35 time_t time ();
  36 #endif
  37
  38 int putenv ();
  39 int stime ();
  40
  41 char *xstrdup ();
  42
  43 static void show_date PARAMS ((const char *format, time_t when));
  44
  45 /* The name this program was run with, for error messages. */
  46 char *program_name;
  47
  48 /* If non-zero, display time in RFC-822 format for mail or news. */
  49 static int rfc_format = 0;
  50
  51 /* If nonzero, print or set Coordinated Universal Time.  */
  52 static int universal_time = 0;
  53
  54 static struct option const long_options[] =
  55 {
  56   {"date", required_argument, NULL, 'd'},
  57   {"file", required_argument, NULL, 'f'},
  58   {"reference", required_argument, NULL, 'r'},
  59   {"rfc-822", no_argument, NULL, 'R'},
  60   {"set", required_argument, NULL, 's'},
  61   {"uct", no_argument, NULL, 'u'},
  62   {"utc", no_argument, NULL, 'u'},
  63   {"universal", no_argument, NULL, 'u'},
  64   {NULL, 0, NULL, 0}
  65 };
  66
  67 #define TZ_UTC0 "TZ=UTC0"
  68
  69 #if LOCALTIME_CACHE
  70 # define TZSET tzset ()
  71 #else
  72 # define TZSET /* empty */
  73 #endif
  74
  75 #define MAYBE_SET_TZ_UTC0 \
  76   do { if (universal_time) set_tz (TZ_UTC0); } while (0)
  77
  78 void
  79 usage (int status)
  80 {
  81   if (status != 0)
  82     fprintf (stderr, _("Try `%s --help' for more information.\n"),
  83              program_name);
  84   else
  85     {
  86       printf (_("\
  87 Usage: %s [OPTION]... [+FORMAT]\n\
  88   or:  %s [OPTION] [MMDDhhmm[[CC]YY][.ss]]\n\
  89 "),
  90               program_name, program_name);
  91       printf (_("\
  92 Display the current time in the given FORMAT, or set the system date.\n\
  93 \n\
  94   -d, --date=STRING        display time described by STRING, not `now'\n\
  95   -f, --file=DATEFILE      like --date once for each line of DATEFILE\n\
  96   -r, --reference=FILE     display the last modification time of FILE\n\
  97   -R, --rfc-822            output RFC-822 compliant date string\n\
  98   -s, --set=STRING         set time described by STRING\n\
  99   -u, --utc, --universal   print or set Coordinated Universal Time\n\
 100       --help               display this help and exit\n\
 101       --version            output version information and exit\n\
 102 "));
 103       printf (_("\
 104 \n\
 105 FORMAT controls the output.  The only valid option for the second form\n\
 106 specifies Coordinated Universal Time.  Interpreted sequences are:\n\
 107 \n\
 108   %%%%   a literal %%\n\
 109   %%a   locale's abbreviated weekday name (Sun..Sat)\n\
 110   %%A   locale's full weekday name, variable length (Sunday..Saturday)\n\
 111   %%b   locale's abbreviated month name (Jan..Dec)\n\
 112   %%B   locale's full month name, variable length (January..December)\n\
 113   %%c   locale's date and time (Sat Nov 04 12:02:33 EST 1989)\n\
 114   %%d   day of month (01..31)\n\
 115   %%D   date (mm/dd/yy)\n\
 116   %%e   day of month, blank padded ( 1..31)\n\
 117   %%h   same as %%b\n\
 118   %%H   hour (00..23)\n\
 119   %%I   hour (01..12)\n\
 120   %%j   day of year (001..366)\n\
 121   %%k   hour ( 0..23)\n\
 122   %%l   hour ( 1..12)\n\
 123   %%m   month (01..12)\n\
 124   %%M   minute (00..59)\n\
 125   %%n   a newline\n\
 126   %%p   locale's AM or PM\n\
 127   %%r   time, 12-hour (hh:mm:ss [AP]M)\n\
 128   %%s   seconds since 00:00:00, Jan 1, 1970 (a GNU extension)\n\
 129   %%S   second (00..61)\n\
 130   %%t   a horizontal tab\n\
 131   %%T   time, 24-hour (hh:mm:ss)\n\
 132   %%U   week number of year with Sunday as first day of week (00..53)\n\
 133   %%V   week number of year with Monday as first day of week (01..52)\n\
 134   %%w   day of week (0..6);  0 represents Sunday\n\
 135   %%W   week number of year with Monday as first day of week (00..53)\n\
 136   %%x   locale's date representation (mm/dd/yy)\n\
 137   %%X   locale's time representation (%%H:%%M:%%S)\n\
 138   %%y   last two digits of year (00..99)\n\
 139   %%Y   year (1970...)\n\
 140   %%z   RFC-822 style numeric timezone (-0500) (a nonstandard extension)\n\
 141   %%Z   time zone (e.g., EDT), or nothing if no time zone is determinable\n\
 142 \n\
 143 By default, date pads numeric fields with zeroes.  GNU date recognizes\n\
 144 the following modifiers between `%%' and a numeric directive.\n\
 145 \n\
 146   `-' (hyphen) do not pad the field\n\
 147   `_' (underscore) pad the field with spaces\n\
 148 "));
 149       puts (_("\nReport bugs to <bug-sh-utils@gnu.org>."));
 150     }
 151   exit (status);
 152 }
 153
 154 /* Set the TZ environment variable.  */
 155
 156 static void
 157 set_tz (const char *tz_eq_zone)
 158 {
 159   if (putenv (tz_eq_zone) != 0)
 160     error (1, 0, "memory exhausted");
 161   TZSET;
 162 }
 163
 164 /* Parse each line in INPUT_FILENAME as with --date and display each
 165    resulting time and date.  If the file cannot be opened, tell why
 166    then exit.  Issue a diagnostic for any lines that cannot be parsed.
 167    If any line cannot be parsed, return nonzero;  otherwise return zero.  */
 168
 169 static int
 170 batch_convert (const char *input_filename, const char *format)
 171 {
 172   int status;
 173   FILE *in_stream;
 174   char *line;
 175   int line_length;
 176   size_t buflen;
 177   time_t when;
 178   char *initial_TZ;
 179
 180 #ifdef lint
 181   /* Suppress `may be used before initialized' warning.  */
 182   initial_TZ = NULL;
 183 #endif
 184
 185   if (strcmp (input_filename, "-") == 0)
 186     {
 187       input_filename = _("standard input");
 188       in_stream = stdin;
 189     }
 190   else
 191     {
 192       in_stream = fopen (input_filename, "r");
 193       if (in_stream == NULL)
 194         {
 195           error (1, errno, "`%s'", input_filename);
 196         }
 197     }
 198
 199   line = NULL;
 200   buflen = 0;
 201
 202   if (universal_time)
 203     {
 204       initial_TZ = getenv ("TZ");
 205       if (initial_TZ == NULL)
 206         {
 207           initial_TZ = xstrdup ("TZ=");
 208         }
 209       else
 210         {
 211           size_t tz_len = strlen (initial_TZ);
 212           char *buf = xmalloc (3 + tz_len + 1);
 213           memcpy (mempcpy (buf, "TZ=", 3), initial_TZ, tz_len + 1);
 214           initial_TZ = buf;
 215         }
 216     }
 217
 218   status = 0;
 219   while (1)
 220     {
 221       line_length = getline (&line, &buflen, in_stream);
 222       if (line_length < 0)
 223         {
 224           /* FIXME: detect/handle error here.  */
 225           break;
 226         }
 227
 228       if (universal_time)
 229         {
 230           /* When given a universal time option, restore the initial
 231              value of TZ before parsing each string.  */
 232           set_tz (initial_TZ);
 233         }
 234
 235       when = get_date (line, NULL);
 236
 237       if (when == -1)
 238         {
 239           if (line[line_length - 1] == '\n')
 240             line[line_length - 1] = '\0';
 241           error (0, 0, _("invalid date `%s'"), line);
 242           status = 1;
 243         }
 244       else
 245         {
 246           MAYBE_SET_TZ_UTC0;
 247           show_date (format, when);
 248         }
 249     }
 250
 251   free (initial_TZ);
 252
 253   if (fclose (in_stream) == EOF)
 254     error (2, errno, "`%s'", input_filename);
 255
 256   if (line != NULL)
 257     free (line);
 258
 259   return status;
 260 }
 261
 262 int
 263 main (int argc, char **argv)
 264 {
 265   int optc;
 266   const char *datestr = NULL;
 267   const char *set_datestr = NULL;
 268   time_t when;
 269   int set_date = 0;
 270   char *format;
 271   char *batch_file = NULL;
 272   char *reference = NULL;
 273   struct stat refstats;
 274   int n_args;
 275   int status;
 276   int option_specified_date;
 277
 278   program_name = argv[0];
 279   setlocale (LC_ALL, "");
 280   bindtextdomain (PACKAGE, LOCALEDIR);
 281   textdomain (PACKAGE);
 282
 283   parse_long_options (argc, argv, "date", GNU_PACKAGE, VERSION,
 284                       "David MacKenzie", usage);
 285
 286   while ((optc = getopt_long (argc, argv, "d:f:r:Rs:u", long_options, NULL))
 287          != -1)
 288     switch (optc)
 289       {
 290       case 0:
 291         break;
 292       case 'd':
 293         datestr = optarg;
 294         break;
 295       case 'f':
 296         batch_file = optarg;
 297         break;
 298       case 'r':
 299         reference = optarg;
 300         break;
 301       case 'R':
 302         rfc_format = 1;
 303         break;
 304       case 's':
 305         set_datestr = optarg;
 306         set_date = 1;
 307         break;
 308       case 'u':
 309         universal_time = 1;
 310         break;
 311       default:
 312         usage (1);
 313       }
 314
 315   n_args = argc - optind;
 316
 317   option_specified_date = ((datestr ? 1 : 0)
 318                            + (batch_file ? 1 : 0)
 319                            + (reference ? 1 : 0));
 320
 321   if (option_specified_date > 1)
 322     {
 323       error (0, 0,
 324         _("the options to specify dates for printing are mutually exclusive"));
 325       usage (1);
 326     }
 327
 328   if (set_date && option_specified_date)
 329     {
 330       error (0, 0,
 331           _("the options to print and set the time may not be used together"));
 332       usage (1);
 333     }
 334
 335   if (n_args > 1)
 336     {
 337       error (0, 0, _("too many non-option arguments"));
 338       usage (1);
 339     }
 340
 341   if ((set_date || option_specified_date)
 342       && n_args == 1 && argv[optind][0] != '+')
 343     {
 344       error (0, 0, _("\
 345 the argument `%s' lacks a leading `+';\n\
 346 When using an option to specify date(s), any non-option\n\
 347 argument must be a format string beginning with `+'."),
 348              argv[optind]);
 349       usage (1);
 350     }
 351
 352   if (set_date)
 353     datestr = set_datestr;
 354
 355   if (batch_file != NULL)
 356     {
 357       status = batch_convert (batch_file,
 358                               (n_args == 1 ? argv[optind] + 1 : NULL));
 359     }
 360   else
 361     {
 362       status = 0;
 363
 364       if (!option_specified_date && !set_date)
 365         {
 366           if (n_args == 1 && argv[optind][0] != '+')
 367             {
 368               /* Prepare to set system clock to the specified date/time
 369                  given in the POSIX-format.  */
 370               set_date = 1;
 371               datestr = argv[optind];
 372               when = posixtime (datestr,
 373                                 PDS_TRAILING_YEAR | PDS_CENTURY | PDS_SECONDS);
 374               format = NULL;
 375             }
 376           else
 377             {
 378               /* Prepare to print the current date/time.  */
 379               datestr = _("undefined");
 380               time (&when);
 381               format = (n_args == 1 ? argv[optind] + 1 : NULL);
 382             }
 383         }
 384       else
 385         {
 386           /* (option_specified_date || set_date) */
 387           if (reference != NULL)
 388             {
 389               if (stat (reference, &refstats))
 390                 error (1, errno, "%s", reference);
 391               when = refstats.st_mtime;
 392             }
 393           else
 394             {
 395               when = get_date (datestr, NULL);
 396             }
 397
 398           format = (n_args == 1 ? argv[optind] + 1 : NULL);
 399         }
 400
 401       if (when == -1)
 402         error (1, 0, _("invalid date `%s'"), datestr);
 403
 404       if (set_date)
 405         {
 406           /* Set the system clock to the specified date, then regardless of
 407              the success of that operation, format and print that date.  */
 408           if (stime (&when) == -1)
 409             {
 410               error (0, errno, _("cannot set date"));
 411               status = 1;
 412             }
 413         }
 414
 415       /* When given a universal time option, set TZ to UTC0 after
 416          parsing the specified date, but before printing it.  */
 417       MAYBE_SET_TZ_UTC0;
 418
 419       show_date (format, when);
 420     }
 421
 422   close_stdout_status (2);
 423
 424   exit (status);
 425 }
 426
 427 /* Display the date and/or time in WHEN according to the format specified
 428    in FORMAT, followed by a newline.  If FORMAT is NULL, use the
 429    standard output format (ctime style but with a timezone inserted). */
 430
 431 static void
 432 show_date (const char *format, time_t when)
 433 {
 434   struct tm *tm;
 435   char *out = NULL;
 436   size_t out_length = 0;
 437
 438   tm = localtime (&when);
 439
 440   if (format == NULL)
 441     {
 442       /* Print the date in the default format.  Vanilla ANSI C strftime
 443          doesn't support %e, but POSIX requires it.  If you don't use
 444          a GNU strftime, make sure yours supports %e.
 445          If you are not using GNU strftime, you want to change %z
 446          in the RFC format to %Z; this gives, however, an invalid
 447          RFC time format outside the continental United States and GMT. */
 448
 449       format = (rfc_format
 450                 ? (universal_time
 451                    ? "%a, %_d %b %Y %H:%M:%S GMT"
 452                    : "%a, %_d %b %Y %H:%M:%S %z")
 453                 : "%a %b %e %H:%M:%S %Z %Y");
 454     }
 455   else if (*format == '\0')
 456     {
 457       printf ("\n");
 458       return;
 459     }
 460
 461   do
 462     {
 463       out_length += 200;
 464       out = (char *) xrealloc (out, out_length);
 465
 466       /* Mark the first byte of the buffer so we can detect the case
 467          of strftime producing an empty string.  Otherwise, this loop
 468          would not terminate when date was invoked like this
 469          `LANG=de date +%p' on a system with good language support.  */
 470       out[0] = '\1';
 471     }
 472   while (strftime (out, out_length, format, tm) == 0 && out[0] != '\0');
 473
 474   printf ("%s\n", out);
 475   free (out);
 476 }