logo

utils-std

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

iso_parse.c (9541B)

    

  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 "./iso_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. static char *
  27. tzoffset_parse(char *s, struct tm *time, const char **errstr)
  28. {
  29. #ifndef TZNAME_MAX
  30. #define TZNAME_MAX _POSIX_TZNAME_MAX
  31. #endif
  32. #if TZNAME_MAX < 5
  33. #error TZNAME_MAX is too small
  34. #endif
  35. 	static char offname[TZNAME_MAX + 1] = "";
  37. 	int neg;
  38. 	if(s[0] == '+')
  39. 		neg = 0;
  40. 	else if(s[0] == '-')
  41. 		neg = 1;
  42. 	else
  43. 	{
  44. 		*errstr = "Invalid timezone offset, must start with + or -";
  45. 		return NULL;
  46. 	}
  48. 	size_t offname_i = 0;
  49. 	offname[offname_i++] = *s++;
  51. 	if(isdigit(s[0]) && isdigit(s[1]))
  52. 	{
  53. 		time->tm_gmtoff = (s[0] - '0') * 36000 + (s[1] - '0') * 3600;
  54. 		offname[offname_i++] = *s++;
  55. 		offname[offname_i++] = *s++;
  56. 	}
  57. 	else
  58. 	{
  59. 		*errstr = "Invalid timezone offset, no digits after <+|->";
  60. 		return NULL;
  61. 	}
  63. 	if(s[0] == ':') s++;
  65. 	if(isdigit(s[0]) && isdigit(s[1]))
  66. 	{
  67. 		time->tm_gmtoff += (s[0] - '0') * 600 + (s[1] - '0') * 60;
  68. 		offname[offname_i++] = *s++;
  69. 		offname[offname_i++] = *s++;
  70. 	}
  71. 	else
  72. 	{
  73. 		*errstr = "Invalid timezone offset, no digits after <+|->HH[:]";
  74. 		return NULL;
  75. 	}
  77. 	if(neg) time->tm_gmtoff = -time->tm_gmtoff;
  79. 	offname[offname_i++] = '\0';
  81. 	time->tm_isdst = 0;
  82. 	time->tm_zone = offname;
  84. 	return s;
  85. }
  87. // For iso_parse function
  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_date_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. // For iso_parse function
  230. // Sets *errstr to NULL when it isn't an email date-time
  231. //
  232. // Check if it could be asctime() format: Thu Nov 24 18:22:48 1986
  233. static char *
  234. asctime_date_parse(char *arg, struct tm *time, const char **errstr)
  235. {
  236. 	// Kept free of strptime() due to update/overriding being undefined and
  237. 	// requiring custom parsing, notably locale-free, which strptime() can't handle
  239. 	// Change `time` only right before returning in case datetime is invalid
  240. 	struct tm tmp_time = *time;
  241. 	tmp_time.tm_isdst = -1;
  242. 	tmp_time.tm_wday = -1;
  244. 	// asctime() doesn't gives any timezone information, assume UTC
  245. 	tmp_time.tm_isdst = 0;
  246. 	tmp_time.tm_gmtoff = 0;
  247. 	tmp_time.tm_zone = "UTC";
  249. 	errno = 0;
  250. 	int parsed = 0;
  251. 	char month_name[4] = "";
  252. 	char weekday_name[4] = "";
  253. 	if(sscanf(arg,
  254. 	          "%3s %3s %d %2d:%2d:%2d %d%n",
  255. 	          weekday_name,
  256. 	          month_name,
  257. 	          &tmp_time.tm_mday,
  258. 	          &tmp_time.tm_hour,
  259. 	          &tmp_time.tm_min,
  260. 	          &tmp_time.tm_sec,
  261. 	          &tmp_time.tm_year,
  262. 	          &parsed) < 7)
  263. 	{
  264. 		if(errno == 0 || errno == EINVAL)
  265. 		{
  266. 			*errstr = NULL;
  267. 		}
  268. 		else
  269. 		{
  270. 			*errstr = strerror(errno);
  271. 			errno = 0;
  272. 		}
  273. 		return NULL;
  274. 	}
  276. 	arg += parsed;
  278. 	tmp_time.tm_year -= 1900;
  280. 	tmp_time.tm_wday = -1;
  281. 	// Because %a/%A is locale-dependent
  282. 	for(size_t i = 0; i < 7; i++)
  283. 	{
  284. 		if(memcmp(weekday_name, short_weekday_name[i], 3) == 0)
  285. 		{
  286. 			tmp_time.tm_wday = i;
  287. 			break;
  288. 		}
  289. 	}
  290. 	if(tmp_time.tm_wday < 0)
  291. 	{
  292. 		*errstr = "Failed parsing short weekday name";
  293. 		errno = 0;
  294. 		return NULL;
  295. 	}
  297. 	tmp_time.tm_mon = -1;
  298. 	// Because %b/%B is locale-dependent
  299. 	for(size_t i = 0; i < 12; i++)
  300. 	{
  301. 		if(memcmp(month_name, short_month_name[i], 3) == 0)
  302. 		{
  303. 			tmp_time.tm_mon = i;
  304. 			break;
  305. 		}
  306. 	}
  307. 	if(tmp_time.tm_mon < 0)
  308. 	{
  309. 		*errstr = "Failed parsing short month name";
  310. 		errno = 0;
  311. 		return NULL;
  312. 	}
  314. 	for(; isspace(arg[0]); arg++)
  315. 		;
  317. 	memcpy(time, &tmp_time, sizeof(tmp_time));
  318. 	return arg;
  319. }
  321. // Sets errstr on failure
  322. // YYYY-MM-DD[T ]hh:mm:SS([,\.]frac)?(Z|[+\-]hh:?mm)?
  323. char *
  324. iso_parse(char *arg, struct tm *time, long *nsec, const char **errstr)
  325. {
  326. 	*nsec = 0;
  328. 	// For Alpine's abuild compatibility
  329. 	if(arg[0] == '@')
  330. 	{
  331. 		arg++;
  333. 		char *endptr = NULL;
  334. 		time_t now = strtol(arg, &endptr, 10);
  335. 		if(errno != 0)
  336. 		{
  337. 			*errstr = strerror(errno);
  338. 			errno = 0;
  339. 			return NULL;
  340. 		}
  342. 		gmtime_r(&now, time);
  344. 		return endptr;
  345. 	}
  347. 	char *ret = NULL;
  349. 	ret = email_date_parse(arg, time, errstr);
  350. 	if(ret != NULL || *errstr != NULL)
  351. 	{
  352. 		return ret;
  353. 	}
  355. 	ret = asctime_date_parse(arg, time, errstr);
  356. 	if(ret != NULL || *errstr != NULL)
  357. 	{
  358. 		return ret;
  359. 	}
  361. 	// Try parsing as RFC3339 subset of ISO 8601:1988
  363. 	// FIXME?: Calling strptime() multiple times is explicitly unspecified in POSIX.1-2024
  364. 	// instead a single strptime() call should be done
  366. 	// No %F in POSIX prior to POSIX.1-2024 (<https://www.austingroupbugs.net/view.php?id=920>)
  367. 	char *s = strptime(arg, "%Y-%m-%d", time);
  369. 	if(s == NULL)
  370. 	{
  371. 		*errstr = "strptime(…, \"%Y-%m-%d\", …) returned NULL";
  372. 		errno = 0;
  373. 		return NULL;
  374. 	}
  375. 	if(s[0] != 'T' && s[0] != ' ')
  376. 	{
  377. 		*errstr = "Couldn't find time-separator (T or space) after date (Y-m-d)";
  378. 		errno = 0;
  379. 		return NULL;
  380. 	}
  381. 	s++;
  383. 	s = strptime(s, "%H:%M:%S", time);
  384. 	if(s == NULL)
  385. 	{
  386. 		*errstr = "strptime(…, \"%H:%M:%S\", …) returned NULL";
  387. 		errno = 0;
  388. 		return NULL;
  389. 	}
  391. 	if(s[0] == ',' || s[0] == '.')
  392. 	{
  393. 		double fraction = 0.0;
  394. 		int parsed = 0;
  396. 		if(s[0] == ',') s[0] = '.';
  398. 		if(sscanf(s, "%10lf%n", &fraction, &parsed) < 1)
  399. 		{
  400. 			if(errno == 0)
  401. 			{
  402. 				*errstr = "Failed to parse fractional seconds";
  403. 			}
  404. 			else
  405. 			{
  406. 				*errstr = strerror(errno);
  407. 				errno = 0;
  408. 			}
  409. 			return NULL;
  410. 		}
  412. 		*nsec = (long)(fraction * 1000000000);
  413. 		s += parsed;
  415. 		// too many digits
  416. 		if(isdigit(s[0]))
  417. 		{
  418. 			*errstr = "Too many digits (> 10) for fractional seconds";
  419. 			return NULL;
  420. 		}
  421. 	}
  423. 	for(; isspace(s[0]); s++)
  424. 		;
  426. 	if(s != NULL && s[0] != '\0')
  427. 	{
  428. 		if(s[0] == 'Z' && s[1] == '\0')
  429. 		{
  430. 			time->tm_isdst = 0;
  431. 			time->tm_gmtoff = 0;
  432. 			time->tm_zone = "UTC";
  433. 		}
  434. 		else
  435. 		{
  436. 			s = tzoffset_parse(s, time, errstr);
  437. 			if(s == NULL) return NULL;
  438. 		}
  439. 	}
  441. 	return s;
  442. }
  444. // Because mktime() messes with tm_gmtoff yet doesn't applies it, even in POSIX.1-2024
  445. // Returns (time_t)-1 on failure
  446. time_t
  447. mktime_tz(struct tm *tm)
  448. {
  449. 	long gmtoff = tm->tm_gmtoff;
  450. 	const char *zone = tm->tm_zone;
  452. 	time_t res = mktime(tm);
  453. 	tm->tm_gmtoff = gmtoff;
  454. 	tm->tm_zone = zone;
  456. 	if(res == (time_t)-1) return res;
  458. 	// 12:00+02:00 corresponds to 10:00Z so needs to be reversed
  459. 	res += -gmtoff;
  461. 	return res;
  462. }