logo

utils-std

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

datetime_parse.c (9953B)

    

  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
  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] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
  22. static const char *short_month_name[12] = {
  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. #ifndef TZNAME_MAX
  31. #define TZNAME_MAX _POSIX_TZNAME_MAX
  32. #endif
  33. #if TZNAME_MAX < 5
  34. #error TZNAME_MAX is too small
  35. #endif
  36. 	static char offname[TZNAME_MAX + 1] = "";
  38. 	int neg;
  39. 	if(s[0] == '+')
  40. 		neg = 0;
  41. 	else if(s[0] == '-')
  42. 		neg = 1;
  43. 	else
  44. 	{
  45. 		*errstr = "Invalid timezone offset, must start with + or -";
  46. 		return NULL;
  47. 	}
  49. 	size_t offname_i = 0;
  50. 	offname[offname_i++] = *s++;
  52. 	if(isdigit(s[0]) && isdigit(s[1]))
  53. 	{
  54. 		time->tm_gmtoff = (s[0] - '0') * 36000 + (s[1] - '0') * 3600;
  55. 		offname[offname_i++] = *s++;
  56. 		offname[offname_i++] = *s++;
  57. 	}
  58. 	else
  59. 	{
  60. 		*errstr = "Invalid timezone offset, no digits after <+|->";
  61. 		return NULL;
  62. 	}
  64. 	if(s[0] == ':') s++;
  66. 	if(isdigit(s[0]) && isdigit(s[1]))
  67. 	{
  68. 		time->tm_gmtoff += (s[0] - '0') * 600 + (s[1] - '0') * 60;
  69. 		offname[offname_i++] = *s++;
  70. 		offname[offname_i++] = *s++;
  71. 	}
  72. 	else
  73. 	{
  74. 		*errstr = "Invalid timezone offset, no digits after <+|->HH[:]";
  75. 		return NULL;
  76. 	}
  78. 	if(neg) time->tm_gmtoff = -time->tm_gmtoff;
  80. 	offname[offname_i++] = '\0';
  82. 	time->tm_isdst = 0;
  83. 	time->tm_zone = offname;
  85. 	return s;
  86. }
  88. // Sets *errstr to NULL when it isn't an email date-time
  89. //
  90. // Check if it could be Email / Internet Message Format datetime
  91. // - Ignores RFC822 (ARPA era, folding space, 2-digit year)
  92. // - Uses RFC5322 / RFC2822 with ignoring RFC822 obsolete formats (aka obs)
  93. //
  94. // RFC5322 and RFC2822 (no obs): "([ ]*Day,)[ ]*DD[ ]+Mon[ ]+YYYY[ ]+HH:MM(:SS)?[ ]+[+/-]hhmm"
  95. static char *
  96. email_datetime_parse(char *arg, struct tm *time, const char **errstr)
  97. {
  98. 	// Kept free of strptime() due to update/overriding being undefined and
  99. 	// requiring custom parsing, notably locale-free, which strptime() can't handle
  101. 	for(; isspace(arg[0]); arg++)
  102. 		;
  104. 	// Change `time` only right before returning in case datetime is invalid
  105. 	struct tm tmp_time = *time;
  106. 	tmp_time.tm_isdst = -1;
  107. 	tmp_time.tm_wday = -1;
  109. 	if(arg[3] == ',')
  110. 	{
  111. 		// Because %a/%A is locale-dependent, Sunday is tm_wday=0
  112. 		for(size_t i = 0; i < 7; i++)
  113. 		{
  114. 			if(memcmp(arg, short_weekday_name[i], 3) == 0)
  115. 			{
  116. 				tmp_time.tm_wday = i;
  117. 				break;
  118. 			}
  119. 		}
  121. 		if(tmp_time.tm_wday == -1)
  122. 		{
  123. 			*errstr = "Failed parsing short weekday name";
  124. 			errno = 0;
  125. 			return NULL;
  126. 		}
  128. 		arg += 4;
  130. 		for(; isspace(arg[0]); arg++)
  131. 			;
  132. 	}
  134. 	errno = 0;
  135. 	int parsed = 0;
  136. 	char month_name[4] = "";
  137. 	if(sscanf(arg,
  138. 	          "%2d %3s %d %2d:%2d%n",
  139. 	          &tmp_time.tm_mday,
  140. 	          month_name,
  141. 	          &tmp_time.tm_year,
  142. 	          &tmp_time.tm_hour,
  143. 	          &tmp_time.tm_min,
  144. 	          &parsed) < 5)
  145. 	{
  146. 		if(errno == 0 || errno == EINVAL)
  147. 		{
  148. 			if(tmp_time.tm_wday == -1)
  149. 			{
  150. 				*errstr = NULL;
  151. 			}
  152. 			else
  153. 			{
  154. 				*errstr = "Failed parsing Email-datetime";
  155. 			}
  156. 		}
  157. 		else
  158. 		{
  159. 			*errstr = strerror(errno);
  160. 			errno = 0;
  161. 		}
  162. 		return NULL;
  163. 	}
  165. 	if(tmp_time.tm_year < 49)
  166. 	{
  167. 		tmp_time.tm_year += 100; // 2000-2049
  168. 	}
  169. 	else if(tmp_time.tm_year > 99)
  170. 	{
  171. 		tmp_time.tm_year -= 1900;
  172. 	}
  174. 	arg += parsed;
  176. 	if(arg[0] == ':' && isdigit(arg[1]))
  177. 	{
  178. 		if(isdigit(arg[2]))
  179. 		{
  180. 			tmp_time.tm_sec = (arg[1] - '0') * 10 + (arg[2] - '0');
  181. 			arg += 3;
  182. 		}
  183. 		else
  184. 		{
  185. 			tmp_time.tm_sec = arg[1] - '0';
  186. 			arg += 2;
  187. 		}
  188. 	}
  190. 	for(; isspace(arg[0]); arg++)
  191. 		;
  193. 	// Consider that nobody is going to transmit a timezone name which isn't GMT
  194. 	if(arg[0] == 'G' && arg[1] == 'M' && arg[2] == 'T' && (arg[3] == '\0' || isspace(arg[3])))
  195. 	{
  196. 		tmp_time.tm_isdst = 0;
  197. 		tmp_time.tm_gmtoff = 0;
  198. 		tmp_time.tm_zone = "UTC";
  199. 	}
  200. 	else
  201. 	{
  202. 		arg = tzoffset_parse(arg, &tmp_time, errstr);
  203. 		if(arg == NULL) return NULL;
  204. 	}
  206. 	// Done extracting directly from arg
  208. 	tmp_time.tm_mon = -1;
  209. 	// Because %b/%B is locale-dependent
  210. 	for(size_t i = 0; i < 12; i++)
  211. 	{
  212. 		if(memcmp(month_name, short_month_name[i], 3) == 0)
  213. 		{
  214. 			tmp_time.tm_mon = i;
  215. 			break;
  216. 		}
  217. 	}
  218. 	if(tmp_time.tm_mon < 0)
  219. 	{
  220. 		*errstr = "Failed parsing short month name";
  221. 		errno = 0;
  222. 		return NULL;
  223. 	}
  225. 	memcpy(time, &tmp_time, sizeof(tmp_time));
  226. 	return arg;
  227. }
  229. // Sets *errstr to NULL when it isn't an email date-time
  230. //
  231. // Check if it could be asctime() format: Thu Nov 24 18:22:48 1986
  232. static char *
  233. asctime_datetime_parse(char *arg, struct tm *time, const char **errstr)
  234. {
  235. 	// Kept free of strptime() due to update/overriding being undefined and
  236. 	// requiring custom parsing, notably locale-free, which strptime() can't handle
  238. 	// Change `time` only right before returning in case datetime is invalid
  239. 	struct tm tmp_time = *time;
  240. 	tmp_time.tm_isdst = -1;
  241. 	tmp_time.tm_wday = -1;
  243. 	// asctime() doesn't gives any timezone information, assume UTC
  244. 	tmp_time.tm_isdst = 0;
  245. 	tmp_time.tm_gmtoff = 0;
  246. 	tmp_time.tm_zone = "UTC";
  248. 	errno = 0;
  249. 	int parsed = 0;
  250. 	char month_name[4] = "";
  251. 	char weekday_name[4] = "";
  252. 	if(sscanf(arg,
  253. 	          "%3s %3s %d %2d:%2d:%2d %d%n",
  254. 	          weekday_name,
  255. 	          month_name,
  256. 	          &tmp_time.tm_mday,
  257. 	          &tmp_time.tm_hour,
  258. 	          &tmp_time.tm_min,
  259. 	          &tmp_time.tm_sec,
  260. 	          &tmp_time.tm_year,
  261. 	          &parsed) < 7)
  262. 	{
  263. 		if(errno == 0 || errno == EINVAL)
  264. 		{
  265. 			*errstr = NULL;
  266. 		}
  267. 		else
  268. 		{
  269. 			*errstr = strerror(errno);
  270. 			errno = 0;
  271. 		}
  272. 		return NULL;
  273. 	}
  275. 	arg += parsed;
  277. 	tmp_time.tm_year -= 1900;
  279. 	tmp_time.tm_wday = -1;
  280. 	// Because %a/%A is locale-dependent
  281. 	for(size_t i = 0; i < 7; i++)
  282. 	{
  283. 		if(memcmp(weekday_name, short_weekday_name[i], 3) == 0)
  284. 		{
  285. 			tmp_time.tm_wday = i;
  286. 			break;
  287. 		}
  288. 	}
  289. 	if(tmp_time.tm_wday < 0)
  290. 	{
  291. 		*errstr = "Failed parsing short weekday name";
  292. 		errno = 0;
  293. 		return NULL;
  294. 	}
  296. 	tmp_time.tm_mon = -1;
  297. 	// Because %b/%B is locale-dependent
  298. 	for(size_t i = 0; i < 12; i++)
  299. 	{
  300. 		if(memcmp(month_name, short_month_name[i], 3) == 0)
  301. 		{
  302. 			tmp_time.tm_mon = i;
  303. 			break;
  304. 		}
  305. 	}
  306. 	if(tmp_time.tm_mon < 0)
  307. 	{
  308. 		*errstr = "Failed parsing short month name";
  309. 		errno = 0;
  310. 		return NULL;
  311. 	}
  313. 	for(; isspace(arg[0]); arg++)
  314. 		;
  316. 	memcpy(time, &tmp_time, sizeof(tmp_time));
  317. 	return arg;
  318. }
  320. // Sets errstr on failure
  321. // YYYY-MM-DD[T ]hh:mm:SS([,\.]frac)?(Z|[+\-]hh:?mm)?
  322. static char *
  323. iso_datetime_parse(char *arg, struct tm *time, long *nsec, const char **errstr)
  324. {
  325. 	// Try parsing as RFC3339 subset of ISO 8601:1988
  327. 	// FIXME?: Calling strptime() multiple times is explicitly unspecified in POSIX.1-2024
  328. 	// instead a single strptime() call should be done
  330. 	// No %F in POSIX prior to POSIX.1-2024 (<https://www.austingroupbugs.net/view.php?id=920>)
  331. 	char *s = strptime(arg, "%Y-%m-%d", time);
  333. 	if(s == NULL)
  334. 	{
  335. 		*errstr = "strptime(…, \"%Y-%m-%d\", …) returned NULL";
  336. 		errno = 0;
  337. 		return NULL;
  338. 	}
  339. 	if(s[0] != 'T' && s[0] != ' ')
  340. 	{
  341. 		*errstr = "Couldn't find time-separator (T or space) after date (Y-m-d)";
  342. 		errno = 0;
  343. 		return NULL;
  344. 	}
  345. 	s++;
  347. 	for(; isspace(s[0]); s++)
  348. 		;
  350. 	s = strptime(s, "%H:%M:%S", time);
  351. 	if(s == NULL)
  352. 	{
  353. 		*errstr = "strptime(…, \"%H:%M:%S\", …) returned NULL";
  354. 		errno = 0;
  355. 		return NULL;
  356. 	}
  358. 	if(s[0] == ',' || s[0] == '.')
  359. 	{
  360. 		double fraction = 0.0;
  361. 		int parsed = 0;
  363. 		if(s[0] == ',') s[0] = '.';
  365. 		if(sscanf(s, "%10lf%n", &fraction, &parsed) < 1)
  366. 		{
  367. 			if(errno == 0)
  368. 			{
  369. 				*errstr = "Failed to parse fractional seconds";
  370. 			}
  371. 			else
  372. 			{
  373. 				*errstr = strerror(errno);
  374. 				errno = 0;
  375. 			}
  376. 			return NULL;
  377. 		}
  379. 		*nsec = (long)(fraction * 1000000000);
  380. 		s += parsed;
  382. 		// too many digits
  383. 		if(isdigit(s[0]))
  384. 		{
  385. 			*errstr = "Too many digits (> 10) for fractional seconds";
  386. 			return NULL;
  387. 		}
  388. 	}
  390. 	for(; isspace(s[0]); s++)
  391. 		;
  393. 	if(s != NULL && s[0] != '\0')
  394. 	{
  395. 		if(s[0] == 'Z' && s[1] == '\0')
  396. 		{
  397. 			time->tm_isdst = 0;
  398. 			time->tm_gmtoff = 0;
  399. 			time->tm_zone = "UTC";
  400. 		}
  401. 		else
  402. 		{
  403. 			s = tzoffset_parse(s, time, errstr);
  404. 			if(s == NULL) return NULL;
  405. 		}
  406. 	}
  408. 	return s;
  409. }
  411. // Sets errstr on failure
  412. char *
  413. datetime_parse(char *arg, struct tm *time, long *nsec, const char **errstr)
  414. {
  415. 	*nsec = 0;
  417. 	// For Alpine's abuild compatibility
  418. 	if(arg[0] == '@')
  419. 	{
  420. 		arg++;
  422. 		char *endptr = NULL;
  423. 		time_t now = strtol(arg, &endptr, 10);
  424. 		if(errno != 0)
  425. 		{
  426. 			*errstr = strerror(errno);
  427. 			errno = 0;
  428. 			return NULL;
  429. 		}
  431. 		gmtime_r(&now, time);
  433. 		return endptr;
  434. 	}
  436. 	char *ret = NULL;
  438. 	ret = email_datetime_parse(arg, time, errstr);
  439. 	if(ret != NULL || *errstr != NULL)
  440. 	{
  441. 		return ret;
  442. 	}
  444. 	ret = asctime_datetime_parse(arg, time, errstr);
  445. 	if(ret != NULL || *errstr != NULL)
  446. 	{
  447. 		return ret;
  448. 	}
  450. 	return iso_datetime_parse(arg, time, nsec, errstr);
  451. }
  453. // Because mktime() messes with tm_gmtoff yet doesn't applies it, even in POSIX.1-2024
  454. // Returns (time_t)-1 on failure
  455. // Maybe should be replaced by mktime_z once <https://www.austingroupbugs.net/view.php?id=1794> gets accepted and implemented
  456. time_t
  457. mktime_tz(struct tm *tm)
  458. {
  459. 	long gmtoff = tm->tm_gmtoff;
  460. 	const char *zone = tm->tm_zone;
  462. 	time_t res = mktime(tm);
  463. 	tm->tm_gmtoff = gmtoff;
  464. 	tm->tm_zone = zone;
  466. 	if(res == (time_t)-1) return res;
  468. 	// 12:00+02:00 corresponds to 10:00Z so needs to be reversed
  469. 	res += -gmtoff;
  471. 	return res;
  472. }