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