logo

utils-std

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

datetime_parse.c (9071B)

    

  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, timegm (POSIX.1-2024 mktime() future directions)
  6. #define _XOPEN_SOURCE 700 // strptime (NetBSD)
  7. #define _POSIX_C_SOURCE 200809L // st_atim/st_mtim
  9. #include "./datetime_parse.h"
  11. #include <assert.h>
  12. #include <ctype.h>    /* isdigit */
  13. #include <errno.h>    /* errno */
  14. #include <inttypes.h> /* PRId16 */
  15. #include <limits.h>   /* TZNAME_MAX */
  16. #include <stdio.h>    /* perror, sscanf */
  17. #include <stdlib.h>   /* strtol */
  18. #include <string.h>   /* memset */
  19. #include <time.h>     /* strptime, tm */
  21. static const char short_weekday_name[7][3] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
  22. static const char short_month_name[12][3] = {
  23.     "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
  25. // Parses [+|-]HH:?MM timezone offsets
  26. // Would need tzalloc from <https://www.austingroupbugs.net/view.php?id=1794> to parse timezone names
  27. static char *
  28. tzoffset_parse(char *s, struct tm *time, const char **errstr)
  29. {
  30. 	int neg;
  31. 	if(s[0] == '+')
  32. 		neg = 0;
  33. 	else if(s[0] == '-')
  34. 		neg = 1;
  35. 	else
  36. 	{
  37. 		*errstr = "Invalid timezone offset, must start with + or -";
  38. 		return NULL;
  39. 	}
  41. 	s++;
  43. 	if(isdigit(s[0]) && isdigit(s[1]))
  44. 	{
  45. 		time->tm_gmtoff = (s[0] - '0') * 36000 + (s[1] - '0') * 3600;
  46. 		s += 2;
  47. 	}
  48. 	else
  49. 	{
  50. 		*errstr = "Invalid timezone offset, no digits after <+|->";
  51. 		return NULL;
  52. 	}
  54. 	if(s[0] == ':') s++;
  56. 	if(isdigit(s[0]) && isdigit(s[1]))
  57. 	{
  58. 		time->tm_gmtoff += (s[0] - '0') * 600 + (s[1] - '0') * 60;
  59. 	}
  60. 	else
  61. 	{
  62. 		*errstr = "Invalid timezone offset, no digits after <+|->HH[:]";
  63. 		return NULL;
  64. 	}
  66. 	if(neg) time->tm_gmtoff = -time->tm_gmtoff;
  68. 	time->tm_isdst = 0;
  69. 	time->tm_zone = NULL;
  71. 	return s;
  72. }
  74. // Sets *errstr to NULL when it isn't an email date-time
  75. //
  76. // Check if it could be Email / Internet Message Format datetime
  77. // - Ignores RFC822 (ARPA era, folding space, 2-digit year)
  78. // - Uses RFC5322 / RFC2822 with ignoring RFC822 obsolete formats (aka obs)
  79. //
  80. // RFC5322 and RFC2822 (no obs): "([ ]*Day,)[ ]*DD[ ]+Mon[ ]+YYYY[ ]+HH:MM(:SS)?[ ]+[+/-]hhmm"
  81. static char *
  82. email_datetime_parse(char *arg, time_t *epoch, const char **errstr)
  83. {
  84. 	// Kept free of strptime() due to update/overriding being undefined and
  85. 	// requiring custom parsing, notably locale-free, which strptime() can't handle
  87. 	for(; isspace(arg[0]); arg++)
  88. 		;
  90. 	// Change `time` only right before returning in case datetime is invalid
  91. 	struct tm tmp_time = {
  92. 	    .tm_isdst = -1,
  93. 	    .tm_wday = -1,
  94. 	};
  96. 	if(arg[3] == ',')
  97. 	{
  98. 		// Because %a/%A is locale-dependent, Sunday is tm_wday=0
  99. 		for(size_t i = 0; i < 7; i++)
  100. 		{
  101. 			if(memcmp(arg, short_weekday_name[i], 3) == 0)
  102. 			{
  103. 				tmp_time.tm_wday = i;
  104. 				break;
  105. 			}
  106. 		}
  108. 		if(tmp_time.tm_wday == -1)
  109. 		{
  110. 			*errstr = "Failed parsing short weekday name";
  111. 			errno = 0;
  112. 			return NULL;
  113. 		}
  115. 		arg += 4;
  117. 		for(; isspace(arg[0]); arg++)
  118. 			;
  119. 	}
  121. 	errno = 0;
  122. 	int parsed = 0;
  123. 	char month_name[4] = "";
  124. 	if(sscanf(arg,
  125. 	          "%2d %3s %d %2d:%2d%n",
  126. 	          &tmp_time.tm_mday,
  127. 	          month_name,
  128. 	          &tmp_time.tm_year,
  129. 	          &tmp_time.tm_hour,
  130. 	          &tmp_time.tm_min,
  131. 	          &parsed) < 5)
  132. 	{
  133. 		if(errno == 0 || errno == EINVAL)
  134. 		{
  135. 			if(tmp_time.tm_wday == -1)
  136. 			{
  137. 				*errstr = NULL;
  138. 			}
  139. 			else
  140. 			{
  141. 				*errstr = "Failed parsing Email-datetime";
  142. 			}
  143. 		}
  144. 		else
  145. 		{
  146. 			*errstr = strerror(errno);
  147. 			errno = 0;
  148. 		}
  149. 		return NULL;
  150. 	}
  152. 	if(tmp_time.tm_year < 49)
  153. 	{
  154. 		tmp_time.tm_year += 100; // 2000-2049
  155. 	}
  156. 	else if(tmp_time.tm_year > 99)
  157. 	{
  158. 		tmp_time.tm_year -= 1900;
  159. 	}
  161. 	arg += parsed;
  163. 	if(arg[0] == ':' && isdigit(arg[1]))
  164. 	{
  165. 		if(isdigit(arg[2]))
  166. 		{
  167. 			tmp_time.tm_sec = (arg[1] - '0') * 10 + (arg[2] - '0');
  168. 			arg += 3;
  169. 		}
  170. 		else
  171. 		{
  172. 			tmp_time.tm_sec = arg[1] - '0';
  173. 			arg += 2;
  174. 		}
  175. 	}
  177. 	for(; isspace(arg[0]); arg++)
  178. 		;
  180. 	// Consider that nobody is going to transmit a timezone name which isn't GMT
  181. 	if(arg[0] == 'G' && arg[1] == 'M' && arg[2] == 'T' && (arg[3] == '\0' || isspace(arg[3])))
  182. 	{
  183. 		tmp_time.tm_isdst = 0;
  184. 		tmp_time.tm_gmtoff = 0;
  185. 		tmp_time.tm_zone = "UTC";
  186. 	}
  187. 	else
  188. 	{
  189. 		arg = tzoffset_parse(arg, &tmp_time, errstr);
  190. 		if(arg == NULL) return NULL;
  191. 	}
  193. 	// Done extracting directly from arg
  195. 	tmp_time.tm_mon = -1;
  196. 	// Because %b/%B is locale-dependent
  197. 	for(size_t i = 0; i < 12; i++)
  198. 	{
  199. 		if(memcmp(month_name, short_month_name[i], 3) == 0)
  200. 		{
  201. 			tmp_time.tm_mon = i;
  202. 			break;
  203. 		}
  204. 	}
  205. 	if(tmp_time.tm_mon < 0)
  206. 	{
  207. 		*errstr = "Failed parsing short month name";
  208. 		errno = 0;
  209. 		return NULL;
  210. 	}
  212. 	*epoch = utils_timegm(&tmp_time);
  213. 	return arg;
  214. }
  216. // Sets *errstr to NULL when it isn't an email date-time
  217. //
  218. // Check if it could be asctime() format: Thu Nov 24 18:22:48 1986
  219. static char *
  220. asctime_datetime_parse(char *arg, time_t *epoch, const char **errstr)
  221. {
  222. 	// Kept free of strptime() due to update/overriding being undefined and
  223. 	// requiring custom parsing, notably locale-free, which strptime() can't handle
  225. 	struct tm tmp_time = {
  226. 	    .tm_isdst = -1,
  227. 	    .tm_wday = -1,
  228. 	};
  230. 	// asctime() doesn't gives any timezone information, assume UTC
  231. 	tmp_time.tm_isdst = 0;
  232. 	tmp_time.tm_gmtoff = 0;
  233. 	tmp_time.tm_zone = "UTC";
  235. 	errno = 0;
  236. 	int parsed = 0;
  237. 	char month_name[4] = "";
  238. 	char weekday_name[4] = "";
  239. 	if(sscanf(arg,
  240. 	          "%3s %3s %d %2d:%2d:%2d %d%n",
  241. 	          weekday_name,
  242. 	          month_name,
  243. 	          &tmp_time.tm_mday,
  244. 	          &tmp_time.tm_hour,
  245. 	          &tmp_time.tm_min,
  246. 	          &tmp_time.tm_sec,
  247. 	          &tmp_time.tm_year,
  248. 	          &parsed) < 7)
  249. 	{
  250. 		if(errno == 0 || errno == EINVAL)
  251. 		{
  252. 			*errstr = NULL;
  253. 		}
  254. 		else
  255. 		{
  256. 			*errstr = strerror(errno);
  257. 			errno = 0;
  258. 		}
  259. 		return NULL;
  260. 	}
  262. 	arg += parsed;
  264. 	tmp_time.tm_year -= 1900;
  266. 	tmp_time.tm_wday = -1;
  267. 	// Because %a/%A is locale-dependent
  268. 	for(size_t i = 0; i < 7; i++)
  269. 	{
  270. 		if(memcmp(weekday_name, short_weekday_name[i], 3) == 0)
  271. 		{
  272. 			tmp_time.tm_wday = i;
  273. 			break;
  274. 		}
  275. 	}
  276. 	if(tmp_time.tm_wday < 0)
  277. 	{
  278. 		*errstr = "Failed parsing short weekday name";
  279. 		errno = 0;
  280. 		return NULL;
  281. 	}
  283. 	tmp_time.tm_mon = -1;
  284. 	// Because %b/%B is locale-dependent
  285. 	for(size_t i = 0; i < 12; i++)
  286. 	{
  287. 		if(memcmp(month_name, short_month_name[i], 3) == 0)
  288. 		{
  289. 			tmp_time.tm_mon = i;
  290. 			break;
  291. 		}
  292. 	}
  293. 	if(tmp_time.tm_mon < 0)
  294. 	{
  295. 		*errstr = "Failed parsing short month name";
  296. 		errno = 0;
  297. 		return NULL;
  298. 	}
  300. 	for(; isspace(arg[0]); arg++)
  301. 		;
  303. 	*epoch = utils_timegm(&tmp_time);
  304. 	return arg;
  305. }
  307. // Sets errstr on failure
  308. // YYYY-MM-DD[T ]hh:mm:SS([,\.]frac)?(Z|[+\-]hh:?mm)?
  309. static char *
  310. iso_datetime_parse(char *arg, time_t *epoch, long *nsec, const char **errstr)
  311. {
  312. 	// Try parsing as RFC3339 subset of ISO 8601:1988
  313. 	struct tm tmp_time = {
  314. 	    .tm_isdst = -1,
  315. 	    .tm_wday = -1,
  316. 	};
  318. 	// FIXME?: Calling strptime() multiple times is explicitly unspecified in POSIX.1-2024
  319. 	// instead a single strptime() call should be done
  321. 	// No %F in POSIX prior to POSIX.1-2024 (<https://www.austingroupbugs.net/view.php?id=920>)
  322. 	char *s = strptime(arg, "%Y-%m-%d", &tmp_time);
  324. 	if(s == NULL)
  325. 	{
  326. 		*errstr = "strptime(…, \"%Y-%m-%d\", …) returned NULL";
  327. 		errno = 0;
  328. 		return NULL;
  329. 	}
  330. 	if(s[0] != 'T' && s[0] != ' ')
  331. 	{
  332. 		*errstr = "Couldn't find time-separator (T or space) after date (Y-m-d)";
  333. 		errno = 0;
  334. 		return NULL;
  335. 	}
  336. 	s++;
  338. 	for(; isspace(s[0]); s++)
  339. 		;
  341. 	s = strptime(s, "%H:%M:%S", &tmp_time);
  342. 	if(s == NULL)
  343. 	{
  344. 		*errstr = "strptime(…, \"%H:%M:%S\", …) returned NULL";
  345. 		errno = 0;
  346. 		return NULL;
  347. 	}
  349. 	if(s[0] == ',' || s[0] == '.')
  350. 	{
  351. 		double fraction = 0.0;
  352. 		int parsed = 0;
  354. 		if(s[0] == ',') s[0] = '.';
  356. 		if(sscanf(s, "%10lf%n", &fraction, &parsed) < 1)
  357. 		{
  358. 			if(errno == 0)
  359. 			{
  360. 				*errstr = "Failed to parse fractional seconds";
  361. 			}
  362. 			else
  363. 			{
  364. 				*errstr = strerror(errno);
  365. 				errno = 0;
  366. 			}
  367. 			return NULL;
  368. 		}
  370. 		*nsec = (long)(fraction * 1000000000);
  371. 		s += parsed;
  373. 		// too many digits
  374. 		if(isdigit(s[0]))
  375. 		{
  376. 			*errstr = "Too many digits (> 10) for fractional seconds";
  377. 			return NULL;
  378. 		}
  379. 	}
  381. 	for(; isspace(s[0]); s++)
  382. 		;
  384. 	if(s != NULL && s[0] != '\0')
  385. 	{
  386. 		if(s[0] == 'Z' && s[1] == '\0')
  387. 		{
  388. 			tmp_time.tm_isdst = 0;
  389. 			tmp_time.tm_gmtoff = 0;
  390. 			tmp_time.tm_zone = "UTC";
  391. 		}
  392. 		else
  393. 		{
  394. 			s = tzoffset_parse(s, &tmp_time, errstr);
  395. 			if(s == NULL) return NULL;
  396. 		}
  397. 	}
  399. 	*epoch = utils_timegm(&tmp_time);
  400. 	return s;
  401. }
  403. // Sets errstr on failure
  404. char *
  405. datetime_parse(char *arg, time_t *epoch, long *nsec, const char **errstr)
  406. {
  407. 	*nsec = 0;
  409. 	// For Alpine's abuild compatibility
  410. 	if(arg[0] == '@')
  411. 	{
  412. 		arg++;
  414. 		char *endptr = NULL;
  415. 		*epoch = strtol(arg, &endptr, 10);
  416. 		if(errno != 0)
  417. 		{
  418. 			*errstr = strerror(errno);
  419. 			errno = 0;
  420. 			return NULL;
  421. 		}
  423. 		return endptr;
  424. 	}
  426. 	char *ret = NULL;
  428. 	ret = email_datetime_parse(arg, epoch, errstr);
  429. 	if(ret != NULL || *errstr != NULL)
  430. 	{
  431. 		return ret;
  432. 	}
  434. 	ret = asctime_datetime_parse(arg, epoch, errstr);
  435. 	if(ret != NULL || *errstr != NULL)
  436. 	{
  437. 		return ret;
  438. 	}
  440. 	return iso_datetime_parse(arg, epoch, nsec, errstr);
  441. }