logo

utils-std

Collection of commonly available Unix tools git clone https://anongit.hacktivis.me/git/utils-std.git/

date.c (10169B)

    

  1. // utils-std: Collection of commonly available Unix tools
  2. // SPDX-FileCopyrightText: 2017 Haelwenn (lanodan) Monnier <contact+utils@hacktivis.me>
  3. // SPDX-License-Identifier: MPL-2.0
  5. #define _DEFAULT_SOURCE // tm_gmtoff/tm_zone (POSIX.1-2024)
  6. #define _POSIX_C_SOURCE 200809L
  7. #define _XOPEN_SOURCE 700 // strptime is in XSI
  9. #include "../config.h"
  10. #include "../lib/absu.h"
  11. #include "../libutils/datetime_parse.h" /* datetime_parse */
  12. #include "../libutils/getopt_nolong.h"
  14. #include <assert.h>
  15. #include <errno.h>
  16. #include <inttypes.h> /* PRId64 */
  17. #include <locale.h>   /* setlocale() */
  18. #include <stdbool.h>
  19. #include <stdio.h>  /* BUFSIZ, fprintf(), puts() */
  20. #include <stdlib.h> /* strtol() */
  21. #include <string.h> /* strerror */
  22. #include <time.h>   /* time, localtime, tm, strftime, strptime, clock_settime */
  23. #include <unistd.h> /* getopt(), opt… */
  24. #ifdef HAS_GETOPT_LONG
  25. #include <getopt.h>
  26. #endif
  28. const char *argv0 = "date";
  30. static size_t
  31. date_strftime(char *restrict buf,
  32.               size_t buflen,
  33.               const char *restrict fmt,
  34.               const struct tm *restrict tm,
  35.               long nsec)
  36. {
  37. 	size_t fmtlen = strlen(fmt);
  38. 	size_t printed = 0;
  40. 	if(fmtlen == 0)
  41. 	{
  42. 		buf[0] = '\0';
  43. 		return 0;
  44. 	}
  46. 	for(size_t i = 0; i < fmtlen;)
  47. 	{
  48. 		// size taken from musl strftime
  49. 		static char fmt_buf[100] = "";
  50. 		size_t fmt_bufi = 0;
  52. 		if(fmt[i] == '%')
  53. 		{
  54. 			fmt_buf[fmt_bufi++] = fmt[i++];
  56. 			if(fmt[i] == '%') // handle '%%'
  57. 			{
  58. 				*buf = '%';
  59. 				buf++;
  60. 				buflen--;
  61. 				printed++;
  62. 				i++;
  63. 				continue;
  64. 			}
  65. 		}
  67. 		for(; fmt[i] != '%' && i < fmtlen;)
  68. 		{
  69. 			fmt_buf[fmt_bufi++] = fmt[i++];
  70. 			assert(fmt_bufi < 100);
  71. 		}
  73. 		fmt_buf[fmt_bufi] = '\0';
  75. 		size_t fmt_bufused = 0;
  76. 		if(fmt_buf[0] == '%' && fmt_buf[1] == ':' && fmt_buf[2] == 'z')
  77. 		{
  78. 			size_t got = snprintf(
  79. 			    buf, buflen, "%+.2ld:%.2u", tm->tm_gmtoff / 3600, absu(tm->tm_gmtoff % 3600 / 60));
  80. 			if(got == 0) return got;
  82. 			buf += got;
  83. 			buflen -= got;
  84. 			printed += got;
  85. 			fmt_bufused += 3;
  86. 		}
  87. 		else if(fmt_buf[0] == '%' && fmt_buf[1] == ':' && fmt_buf[2] == ':' && fmt_buf[3] == 'z')
  88. 		{
  89. 			unsigned tzhr = absu(tm->tm_gmtoff % 3600 / 60);
  90. 			unsigned tzsec = absu(tm->tm_gmtoff % 3600 % 60);
  92. 			size_t got = snprintf(buf, buflen, "%+.2ld:%.2u:%.2u", tm->tm_gmtoff / 3600, tzhr, tzsec);
  93. 			if(got == 0) return got;
  95. 			buf += got;
  96. 			buflen -= got;
  97. 			printed += got;
  98. 			fmt_bufused += 4;
  99. 		}
  100. 		else if(fmt_buf[0] == '%' && fmt_buf[1] == 'N')
  101. 		{
  102. 			size_t got = snprintf(buf, buflen, "%09ld", nsec);
  103. 			if(got == 0) return got;
  105. 			buf += got;
  106. 			buflen -= got;
  107. 			printed += got;
  108. 			fmt_bufused += 2;
  109. 		}
  111. 		if(fmt_bufi > fmt_bufused)
  112. 		{
  113. 			size_t got = strftime(buf, buflen, fmt_buf + fmt_bufused, tm);
  114. 			if(got == 0) return got;
  116. 			buf += got;
  117. 			buflen -= got;
  118. 			printed += got;
  119. 		}
  120. 	}
  122. 	return printed;
  123. }
  125. static void
  126. usage(void)
  127. {
  128. 	fprintf(stderr, "\
  129. Usage:\n\
  130. 	date [-jRu] [-I iso_fmt] [-d datetime | -r epoch] [+format]\n\
  131. 	date [-jRu] [-I iso_fmt] mmddHHMM[[CC]yy] [+format]\n\
  132. 	date [-jRu] [-I iso_fmt] -f now_format now [+format]\n\
  133. ");
  134. }
  136. int
  137. main(int argc, char *argv[])
  138. {
  139. 	char outstr[BUFSIZ] = "";
  140. 	struct timespec tp = {
  141. 	    .tv_sec = 0,
  142. 	    .tv_nsec = 0,
  143. 	};
  144. 	const char *format = "%c";
  145. 	const char *input_format = NULL;
  146. 	int uflag = 0;
  147. 	int dflag = 0, rflag = 0;
  148. 	bool jflag = false;
  149. 	bool settime = false;
  151. 	char *lc_all = setlocale(LC_ALL, "");
  152. 	if(lc_all == NULL)
  153. 	{
  154. 		fprintf(stderr,
  155. 		        "%s: warning: Failed loading locales. setlocale(LC_ALL, \"\"): %s\n",
  156. 		        argv0,
  157. 		        strerror(errno));
  158. 	}
  159. 	errno = 0;
  161. 	if(clock_gettime(CLOCK_REALTIME, &tp) != 0)
  162. 	{
  163. 		fprintf(stderr, "%s: error: Failed getting current time: %s\n", argv0, strerror(errno));
  164. 		return 1;
  165. 	}
  167. #ifdef HAS_GETOPT_LONG
  168. 	// Strictly for GNUisms compatibility so no long-only options
  169. 	// clang-format off
  170. 	static struct option opts[] = {
  171. 		{"date", required_argument, NULL, 'd'},
  172. 		{"iso-8601", optional_argument, NULL, 'I'},
  173. 		{"rfc-email", no_argument, NULL, 'R'},
  174. 		{"universal", no_argument, NULL, 'u'},
  175. 		{"utc", no_argument, NULL, 'u'},
  176. 		{0, 0, 0, 0},
  177. 	};
  178. 	// clang-format on
  180. 	// Need + as first character to get POSIX-style option parsing
  181. 	// Assume all getopt_long implementations support :: for optional args
  182. 	for(int c = -1; (c = getopt_long(argc, argv, "+:d:f:I::jr:Ru", opts, NULL)) != -1;)
  183. #else
  184. 	for(int c = -1; (c = getopt_nolong(argc, argv, ":d:f:I:jr:Ru")) != -1;)
  185. #endif
  186. 	{
  187. 		const char *errstr = NULL;
  188. 		switch(c)
  189. 		{
  190. 		case 'd': /* Custom datetime */
  191. 			if(input_format != NULL)
  192. 			{
  193. 				fprintf(stderr, "%s: error: Cannot both use '-d' and '-f'\n", argv0);
  194. 				return 1;
  195. 			}
  196. 			if(rflag == 1)
  197. 			{
  198. 				fprintf(stderr, "%s: error: Cannot both use '-d' and '-r'\n", argv0);
  199. 				return 1;
  200. 			}
  202. 			datetime_parse(optarg, &tp.tv_sec, &tp.tv_nsec, &errstr);
  203. 			dflag = 1;
  204. 			if(errstr != NULL)
  205. 			{
  206. 				fprintf(stderr, "%s: error: datetime_parse(\"%s\", …): %s\n", argv0, optarg, errstr);
  207. 				return 1;
  208. 			}
  209. 			break;
  210. 		case 'f': /* input datetime format */
  211. 			if(dflag == 1)
  212. 			{
  213. 				fprintf(stderr, "%s: error: Cannot both use '-d' and '-f'\n", argv0);
  214. 				return 1;
  215. 			}
  216. 			if(rflag == 1)
  217. 			{
  218. 				fprintf(stderr, "%s: error: Cannot both use '-f' and '-r'\n", argv0);
  219. 				return 1;
  220. 			}
  222. 			input_format = optarg;
  223. 			settime = true;
  224. 			break;
  225. 		case 'r': /* seconds relative to epoch */
  226. 		{
  227. 			if(input_format != NULL)
  228. 			{
  229. 				fprintf(stderr, "%s: error: Cannot both use '-f' and '-r'\n", argv0);
  230. 				return 1;
  231. 			}
  232. 			if(dflag == 1)
  233. 			{
  234. 				fprintf(stderr, "%s: error: Cannot both use '-d' and '-r'\n", argv0);
  235. 				return 1;
  236. 			}
  238. 			char *endptr = NULL;
  239. 			errno = 0;
  240. 			tp.tv_sec = strtol(optarg, &endptr, 10);
  241. 			if(errno != 0)
  242. 			{
  243. 				fprintf(stderr, "%s: error: Failed parsing '-r %s'\n", argv0, optarg);
  244. 				return 1;
  245. 			}
  246. 			if(!(endptr == NULL || *endptr == '\0'))
  247. 			{
  248. 				fprintf(stderr, "%s: error: Invalid characters in '-r %s': %s\n", argv0, optarg, endptr);
  249. 				return 1;
  250. 			}
  251. 			break;
  252. 		}
  253. 		case 'R': /* Email (RFC 5322) format */
  254. 			format = "%a, %d %b %Y %H:%M:%S %z";
  255. 			break;
  256. 		case 'u': /* UTC timezone */
  257. 			uflag++;
  258. 			setenv("TZ", "UTC", 1);
  259. 			tzset();
  260. 			break;
  261. 		case 'I': /* ISO 8601 */
  262. 			if(optarg)
  263. 			{
  264. 				/* note: %:z (±ZZ:ZZ) and %N (nanoseconds) are date(1) GNU-isms absent from C libraries including glibc */
  265. 				switch(optarg[0])
  266. 				{
  267. 				case 'h': // hours
  268. 					format = "%Y-%m-%dT%H%:z";
  269. 					break;
  270. 				case 'm': // minutes
  271. 					format = "%Y-%m-%dT%H:%M%:z";
  272. 					break;
  273. 				case 's': // seconds
  274. 					format = "%Y-%m-%dT%H:%M:%S%:z";
  275. 					break;
  276. 				case 'n': // ns, nanoseconds
  277. 					format = "%Y-%m-%dT%H:%M:%S,%N%:z";
  278. 					break;
  279. 				case 'd': // date
  280. 				default:
  281. 					format = "%Y-%m-%d";
  282. 					break;
  283. 				}
  284. 			}
  285. 			else
  286. 				format = "%Y-%m-%d";
  287. 			break;
  288. 		case 'j':
  289. 			jflag = true;
  290. 			break;
  291. 		case ':':
  292. 			fprintf(stderr, "%s: error: Missing operand for option: '-%c'\n", argv0, optopt);
  293. 			usage();
  294. 			return 1;
  295. 		case '?':
  296. 			GETOPT_UNKNOWN_OPT
  297. 			usage();
  298. 			return 1;
  299. 		}
  300. 	}
  302. 	argc -= optind;
  303. 	argv += optind;
  305. 	if(argc > 0 && input_format != NULL)
  306. 	{
  307. 		struct tm input_tm;
  309. 		time_t timez = 0;
  310. 		gmtime_r(&timez, &input_tm); // init
  312. 		char *res = strptime(argv[0], input_format, &input_tm);
  314. 		if(res == NULL)
  315. 		{
  316. 			fprintf(stderr,
  317. 			        "%s: error: strptime(\"%s\", \"%s\", …) as passed by '-f' option failed\n",
  318. 			        argv0,
  319. 			        argv[0],
  320. 			        input_format);
  321. 			return 1;
  322. 		}
  324. 		/* TODO: %N (nanoseconds) support */
  325. 		tp.tv_sec = utils_timegm(&input_tm);
  326. 		tp.tv_nsec = 0;
  327. 		if(tp.tv_sec == (time_t)-1)
  328. 		{
  329. 			fprintf(stderr, "%s: error: timegm: %s\n", argv0, strerror(errno));
  330. 			return 1;
  331. 		}
  332. 		errno = 0;
  334. 		argv++;
  335. 		argc--;
  336. 	}
  338. 	if(input_format == NULL && argc > 0 && *argv && **argv != '+')
  339. 	{
  340. 		struct tm arg_tm;
  341. 		const char *fmt = "%m%d%H%M";
  343. 		int year = 0;
  344. 		int eyear = 0;
  345. 		if(gmtime_r(&tp.tv_sec, &arg_tm) == NULL)
  346. 			eyear = errno;
  347. 		else
  348. 			year = arg_tm.tm_year;
  350. 		char *s = strptime(argv[0], fmt, &arg_tm);
  351. 		if(s == NULL)
  352. 		{
  353. 			fprintf(stderr, "%s: error: strptime(\"%s\", \"%s\", …) returned NULL\n", argv0, *argv, fmt);
  354. 			return 1;
  355. 		}
  357. 		size_t rem = strlen(s);
  358. 		if(rem > 0)
  359. 		{
  360. 			switch(rem)
  361. 			{
  362. 			case 2:
  363. 				fmt = "%y";
  364. 				break;
  365. 			case 4:
  366. 				fmt = "%Y";
  367. 				break;
  368. 			default:
  369. 				fprintf(stderr,
  370. 				        "%s: error: Got %zu trailing characters after \"%s\" for mmddHHMM\n",
  371. 				        argv0,
  372. 				        rem,
  373. 				        fmt);
  374. 				return 1;
  375. 			}
  377. 			s = strptime(s, fmt, &arg_tm);
  378. 			if(s == NULL)
  379. 			{
  380. 				fprintf(
  381. 				    stderr, "%s: error: strptime(\"%s\", \"%s\", …) returned NULL\n", argv0, *argv, fmt);
  382. 				return 1;
  383. 			}
  384. 		}
  385. 		else if(eyear != 0)
  386. 		{
  387. 			fprintf(stderr,
  388. 			        "%s: error: Year wasn't specified in '%s' and failed to get current time: %s\n",
  389. 			        argv0,
  390. 			        *argv,
  391. 			        strerror(eyear));
  392. 			return 1;
  393. 		}
  395. 		/* TODO: %N (nanoseconds) support */
  396. 		tp.tv_sec = utils_timegm(&arg_tm);
  397. 		tp.tv_nsec = 0;
  398. 		if(tp.tv_sec == (time_t)-1)
  399. 		{
  400. 			fprintf(stderr, "%s: error: timegm: %s\n", argv0, strerror(errno));
  401. 			return 1;
  402. 		}
  403. 		errno = 0;
  405. 		argv++;
  406. 		argc--;
  407. 		settime = true;
  408. 	}
  410. 	struct tm tm;
  411. 	if(uflag)
  412. 	{
  413. 		if(gmtime_r(&tp.tv_sec, &tm) == NULL)
  414. 		{
  415. 			fprintf(stderr, "%s: error: gmtime_r: %s\n", argv0, strerror(errno));
  416. 			return 1;
  417. 		}
  418. 	}
  419. 	else
  420. 	{
  421. 		if(localtime_r(&tp.tv_sec, &tm) == NULL)
  422. 		{
  423. 			fprintf(stderr, "%s: error: localtime_r: %s\n", argv0, strerror(errno));
  424. 			return 1;
  425. 		}
  426. 	}
  428. 	if(settime && !jflag)
  429. 	{
  430. 		if(clock_settime(CLOCK_REALTIME, &tp) != 0)
  431. 		{
  432. 			fprintf(stderr,
  433. 			        "%s: error: clock_settime(CLOCK_REALTIME, {%" PRId64 ", %" PRId64 "}): %s\n",
  434. 			        argv0,
  435. 			        (int64_t)tp.tv_sec,
  436. 			        (int64_t)tp.tv_nsec,
  437. 			        strerror(errno));
  438. 			return 1;
  439. 		}
  440. 	}
  442. 	if(argc > 0 && *argv && **argv == '+')
  443. 	{
  444. 		format = *argv + 1;
  446. 		argv++;
  447. 		argc--;
  448. 	}
  450. 	errno = 0;
  451. 	if(date_strftime(outstr, sizeof(outstr), format, &tm, tp.tv_nsec) == 0 && errno != 0)
  452. 	{
  453. 		fprintf(stderr, "%s: error: Failed formatting time: %s\n", argv0, strerror(errno));
  454. 		return 1;
  455. 	}
  457. 	if(puts(outstr) < 0)
  458. 	{
  459. 		fprintf(stderr, "%s: error: Failed writing time: %s\n", argv0, strerror(errno));
  460. 		return 1;
  461. 	}
  463. 	return 0;
  464. }