1 /*- 2 * SPDX-License-Identifier: BSD-3-Clause 3 * 4 * Copyright (c) 1985, 1987, 1988, 1993 5 * The Regents of the University of California. All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. Neither the name of the University nor the names of its contributors 16 * may be used to endorse or promote products derived from this software 17 * without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 */ 31 32 #include <sys/param.h> 33 #include <sys/time.h> 34 #include <sys/stat.h> 35 36 #include <ctype.h> 37 #include <err.h> 38 #include <errno.h> 39 #include <locale.h> 40 #include <stdbool.h> 41 #include <stdio.h> 42 #include <stdlib.h> 43 #include <string.h> 44 #include <syslog.h> 45 #include <unistd.h> 46 #include <utmpx.h> 47 48 #include "vary.h" 49 50 #ifndef TM_YEAR_BASE 51 #define TM_YEAR_BASE 1900 52 #endif 53 54 static void badformat(void); 55 static void iso8601_usage(const char *) __dead2; 56 static void multipleformats(void); 57 static void printdate(const char *); 58 static void printisodate(struct tm *, long); 59 static void setthetime(const char *, const char *, int, struct timespec *); 60 static size_t strftime_ns(char * __restrict, size_t, const char * __restrict, 61 const struct tm * __restrict, long); 62 static void usage(void) __dead2; 63 64 static const struct iso8601_fmt { 65 const char *refname; 66 const char *format_string; 67 } iso8601_fmts[] = { 68 { "date", "%Y-%m-%d" }, 69 { "hours", "T%H" }, 70 { "minutes", ":%M" }, 71 { "seconds", ":%S" }, 72 { "ns", ",%N" }, 73 }; 74 static const struct iso8601_fmt *iso8601_selected; 75 76 static const char *rfc2822_format = "%a, %d %b %Y %T %z"; 77 78 int 79 main(int argc, char *argv[]) 80 { 81 struct timespec ts; 82 int ch, rflag; 83 bool Iflag, jflag, Rflag; 84 const char *format; 85 char buf[1024]; 86 char *fmt, *outzone = NULL; 87 char *tmp; 88 struct vary *v; 89 const struct vary *badv; 90 struct tm *lt; 91 struct stat sb; 92 size_t i; 93 94 v = NULL; 95 fmt = NULL; 96 (void) setlocale(LC_TIME, ""); 97 rflag = 0; 98 Iflag = jflag = Rflag = 0; 99 ts.tv_sec = 0; 100 ts.tv_nsec = 0; 101 while ((ch = getopt(argc, argv, "f:I::jnRr:uv:z:")) != -1) 102 switch((char)ch) { 103 case 'f': 104 fmt = optarg; 105 break; 106 case 'I': 107 if (Rflag) 108 multipleformats(); 109 Iflag = 1; 110 if (optarg == NULL) { 111 iso8601_selected = iso8601_fmts; 112 break; 113 } 114 for (i = 0; i < nitems(iso8601_fmts); i++) 115 if (strcmp(optarg, iso8601_fmts[i].refname) == 0) 116 break; 117 if (i == nitems(iso8601_fmts)) 118 iso8601_usage(optarg); 119 120 iso8601_selected = &iso8601_fmts[i]; 121 break; 122 case 'j': 123 jflag = 1; /* don't set time */ 124 break; 125 case 'n': 126 break; 127 case 'R': /* RFC 2822 datetime format */ 128 if (Iflag) 129 multipleformats(); 130 Rflag = 1; 131 break; 132 case 'r': /* user specified seconds */ 133 rflag = 1; 134 ts.tv_sec = strtoq(optarg, &tmp, 0); 135 if (*tmp != 0) { 136 if (stat(optarg, &sb) == 0) { 137 ts.tv_sec = sb.st_mtim.tv_sec; 138 ts.tv_nsec = sb.st_mtim.tv_nsec; 139 } else 140 usage(); 141 } 142 break; 143 case 'u': /* do everything in UTC */ 144 (void)setenv("TZ", "UTC0", 1); 145 break; 146 case 'z': 147 outzone = optarg; 148 break; 149 case 'v': 150 v = vary_append(v, optarg); 151 break; 152 default: 153 usage(); 154 } 155 argc -= optind; 156 argv += optind; 157 158 if (!rflag && clock_gettime(CLOCK_REALTIME, &ts) == -1) 159 err(1, "clock_gettime"); 160 161 format = "%+"; 162 163 if (Rflag) 164 format = rfc2822_format; 165 166 /* allow the operands in any order */ 167 if (*argv && **argv == '+') { 168 if (Iflag) 169 multipleformats(); 170 format = *argv + 1; 171 ++argv; 172 } 173 174 if (*argv) { 175 setthetime(fmt, *argv, jflag, &ts); 176 ++argv; 177 } else if (fmt != NULL) 178 usage(); 179 180 if (*argv && **argv == '+') { 181 if (Iflag) 182 multipleformats(); 183 format = *argv + 1; 184 } 185 186 if (outzone != NULL && setenv("TZ", outzone, 1) != 0) 187 err(1, "setenv(TZ)"); 188 lt = localtime(&ts.tv_sec); 189 if (lt == NULL) 190 errx(1, "invalid time"); 191 badv = vary_apply(v, lt); 192 if (badv) { 193 fprintf(stderr, "%s: Cannot apply date adjustment\n", 194 badv->arg); 195 vary_destroy(v); 196 usage(); 197 } 198 vary_destroy(v); 199 200 if (Iflag) 201 printisodate(lt, ts.tv_nsec); 202 203 if (format == rfc2822_format) 204 /* 205 * When using RFC 2822 datetime format, don't honor the 206 * locale. 207 */ 208 setlocale(LC_TIME, "C"); 209 210 211 (void)strftime_ns(buf, sizeof(buf), format, lt, ts.tv_nsec); 212 printdate(buf); 213 } 214 215 static void 216 printdate(const char *buf) 217 { 218 (void)printf("%s\n", buf); 219 if (fflush(stdout)) 220 err(1, "stdout"); 221 exit(EXIT_SUCCESS); 222 } 223 224 static void 225 printisodate(struct tm *lt, long nsec) 226 { 227 const struct iso8601_fmt *it; 228 char fmtbuf[64], buf[64], tzbuf[8]; 229 230 fmtbuf[0] = 0; 231 for (it = iso8601_fmts; it <= iso8601_selected; it++) 232 strlcat(fmtbuf, it->format_string, sizeof(fmtbuf)); 233 234 (void)strftime_ns(buf, sizeof(buf), fmtbuf, lt, nsec); 235 236 if (iso8601_selected > iso8601_fmts) { 237 (void)strftime_ns(tzbuf, sizeof(tzbuf), "%z", lt, nsec); 238 memmove(&tzbuf[4], &tzbuf[3], 3); 239 tzbuf[3] = ':'; 240 strlcat(buf, tzbuf, sizeof(buf)); 241 } 242 243 printdate(buf); 244 } 245 246 #define ATOI2(s) ((s) += 2, ((s)[-2] - '0') * 10 + ((s)[-1] - '0')) 247 248 static void 249 setthetime(const char *fmt, const char *p, int jflag, struct timespec *ts) 250 { 251 struct utmpx utx; 252 struct tm *lt; 253 const char *dot, *t; 254 int century; 255 256 lt = localtime(&ts->tv_sec); 257 if (lt == NULL) 258 errx(1, "invalid time"); 259 lt->tm_isdst = -1; /* divine correct DST */ 260 261 if (fmt != NULL) { 262 t = strptime(p, fmt, lt); 263 if (t == NULL) { 264 fprintf(stderr, "Failed conversion of ``%s''" 265 " using format ``%s''\n", p, fmt); 266 badformat(); 267 } else if (*t != '\0') 268 fprintf(stderr, "Warning: Ignoring %ld extraneous" 269 " characters in date string (%s)\n", 270 (long) strlen(t), t); 271 } else { 272 for (t = p, dot = NULL; *t; ++t) { 273 if (isdigit(*t)) 274 continue; 275 if (*t == '.' && dot == NULL) { 276 dot = t; 277 continue; 278 } 279 badformat(); 280 } 281 282 if (dot != NULL) { /* .ss */ 283 dot++; /* *dot++ = '\0'; */ 284 if (strlen(dot) != 2) 285 badformat(); 286 lt->tm_sec = ATOI2(dot); 287 if (lt->tm_sec > 61) 288 badformat(); 289 } else 290 lt->tm_sec = 0; 291 292 century = 0; 293 /* if p has a ".ss" field then let's pretend it's not there */ 294 switch (strlen(p) - ((dot != NULL) ? 3 : 0)) { 295 case 12: /* cc */ 296 lt->tm_year = ATOI2(p) * 100 - TM_YEAR_BASE; 297 century = 1; 298 /* FALLTHROUGH */ 299 case 10: /* yy */ 300 if (century) 301 lt->tm_year += ATOI2(p); 302 else { 303 lt->tm_year = ATOI2(p); 304 if (lt->tm_year < 69) /* hack for 2000 ;-} */ 305 lt->tm_year += 2000 - TM_YEAR_BASE; 306 else 307 lt->tm_year += 1900 - TM_YEAR_BASE; 308 } 309 /* FALLTHROUGH */ 310 case 8: /* mm */ 311 lt->tm_mon = ATOI2(p); 312 if (lt->tm_mon > 12) 313 badformat(); 314 --lt->tm_mon; /* time struct is 0 - 11 */ 315 /* FALLTHROUGH */ 316 case 6: /* dd */ 317 lt->tm_mday = ATOI2(p); 318 if (lt->tm_mday > 31) 319 badformat(); 320 /* FALLTHROUGH */ 321 case 4: /* HH */ 322 lt->tm_hour = ATOI2(p); 323 if (lt->tm_hour > 23) 324 badformat(); 325 /* FALLTHROUGH */ 326 case 2: /* MM */ 327 lt->tm_min = ATOI2(p); 328 if (lt->tm_min > 59) 329 badformat(); 330 break; 331 default: 332 badformat(); 333 } 334 } 335 336 /* convert broken-down time to GMT clock time */ 337 lt->tm_yday = -1; 338 ts->tv_sec = mktime(lt); 339 if (lt->tm_yday == -1) 340 errx(1, "nonexistent time"); 341 ts->tv_nsec = 0; 342 343 if (!jflag) { 344 utx.ut_type = OLD_TIME; 345 memset(utx.ut_id, 0, sizeof(utx.ut_id)); 346 (void)gettimeofday(&utx.ut_tv, NULL); 347 pututxline(&utx); 348 if (clock_settime(CLOCK_REALTIME, ts) != 0) 349 err(1, "clock_settime"); 350 utx.ut_type = NEW_TIME; 351 (void)gettimeofday(&utx.ut_tv, NULL); 352 pututxline(&utx); 353 354 if ((p = getlogin()) == NULL) 355 p = "???"; 356 syslog(LOG_AUTH | LOG_NOTICE, "date set by %s", p); 357 } 358 } 359 360 /* 361 * The strftime_ns function is a wrapper around strftime(3), which adds support 362 * for features absent from strftime(3). Currently, the only extra feature is 363 * support for %N, the nanosecond conversion specification. 364 * 365 * The functions scans the format string for the non-standard conversion 366 * specifications and replaces them with the date and time values before 367 * passing the format string to strftime(3). The handling of the non-standard 368 * conversion specifications happens before the call to strftime(3) to handle 369 * cases like "%%N" correctly ("%%N" should yield "%N" instead of nanoseconds). 370 */ 371 static size_t 372 strftime_ns(char * __restrict s, size_t maxsize, const char * __restrict format, 373 const struct tm * __restrict t, long nsec) 374 { 375 size_t prefixlen; 376 size_t ret; 377 char *newformat; 378 char *oldformat; 379 const char *prefix; 380 const char *suffix; 381 const char *tok; 382 bool seen_percent; 383 384 seen_percent = false; 385 if (asprintf(&newformat, "%s", format) < 0) 386 err(1, "asprintf"); 387 tok = newformat; 388 for (tok = newformat; *tok != '\0'; tok++) { 389 switch (*tok) { 390 case '%': 391 /* 392 * If the previous token was a percent sign, 393 * then there are two percent tokens in a row. 394 */ 395 if (seen_percent) 396 seen_percent = false; 397 else 398 seen_percent = true; 399 break; 400 case 'N': 401 if (seen_percent) { 402 oldformat = newformat; 403 prefix = oldformat; 404 prefixlen = tok - oldformat - 1; 405 suffix = tok + 1; 406 /* 407 * Construct a new format string from the 408 * prefix (i.e., the part of the old fromat 409 * from its beginning to the currently handled 410 * "%N" conversion specification, the 411 * nanoseconds, and the suffix (i.e., the part 412 * of the old format from the next token to the 413 * end). 414 */ 415 if (asprintf(&newformat, "%.*s%.9ld%s", 416 (int)prefixlen, prefix, nsec, 417 suffix) < 0) { 418 err(1, "asprintf"); 419 } 420 free(oldformat); 421 tok = newformat + prefixlen + 9; 422 } 423 seen_percent = false; 424 break; 425 default: 426 seen_percent = false; 427 break; 428 } 429 } 430 431 ret = strftime(s, maxsize, newformat, t); 432 free(newformat); 433 return (ret); 434 } 435 436 static void 437 badformat(void) 438 { 439 warnx("illegal time format"); 440 usage(); 441 } 442 443 static void 444 iso8601_usage(const char *badarg) 445 { 446 errx(1, "invalid argument '%s' for -I", badarg); 447 } 448 449 static void 450 multipleformats(void) 451 { 452 errx(1, "multiple output formats specified"); 453 } 454 455 static void 456 usage(void) 457 { 458 (void)fprintf(stderr, "%s\n%s\n%s\n", 459 "usage: date [-jnRu] [-I[date|hours|minutes|seconds|ns]] [-f input_fmt]", 460 " " 461 "[ -z output_zone ] [-r filename|seconds] [-v[+|-]val[y|m|w|d|H|M|S]]", 462 " " 463 "[[[[[[cc]yy]mm]dd]HH]MM[.SS] | new_date] [+output_fmt]" 464 ); 465 exit(1); 466 } 467