logo

utils-std

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

iso_parse.c (9769B)

    

  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. // 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. // For iso_parse function
  89. // Sets *errstr to NULL when it isn't an email date-time
  90. //
  91. // Check if it could be Email / Internet Message Format datetime
  92. // - Ignores RFC822 (ARPA era, folding space, 2-digit year)
  93. // - Uses RFC5322 / RFC2822 with ignoring RFC822 obsolete formats (aka obs)
  94. //
  95. // RFC5322 and RFC2822 (no obs): "([ ]*Day,)[ ]*DD[ ]+Mon[ ]+YYYY[ ]+HH:MM(:SS)?[ ]+[+/-]hhmm"
  96. static char *
  97. email_date_parse(char *arg, struct tm *time, const char **errstr)
  98. {
  99. 	// Kept free of strptime() due to update/overriding being undefined and
  100. 	// requiring custom parsing, notably locale-free, which strptime() can't handle
  102. 	for(; isspace(arg[0]); arg++)
  103. 		;
  105. 	// Change `time` only right before returning in case datetime is invalid
  106. 	struct tm tmp_time = *time;
  107. 	tmp_time.tm_isdst = -1;
  108. 	tmp_time.tm_wday = -1;
  110. 	if(arg[3] == ',')
  111. 	{
  112. 		// Because %a/%A is locale-dependent, Sunday is tm_wday=0
  113. 		for(size_t i = 0; i < 7; i++)
  114. 		{
  115. 			if(memcmp(arg, short_weekday_name[i], 3) == 0)
  116. 			{
  117. 				tmp_time.tm_wday = i;
  118. 				break;
  119. 			}
  120. 		}
  122. 		if(tmp_time.tm_wday == -1)
  123. 		{
  124. 			*errstr = "Failed parsing short weekday name";
  125. 			errno = 0;
  126. 			return NULL;
  127. 		}
  129. 		arg += 4;
  131. 		for(; isspace(arg[0]); arg++)
  132. 			;
  133. 	}
  135. 	errno = 0;
  136. 	int parsed = 0;
  137. 	char month_name[4] = "";
  138. 	if(sscanf(arg,
  139. 	          "%2d %3s %d %2d:%2d%n",
  140. 	          &tmp_time.tm_mday,
  141. 	          month_name,
  142. 	          &tmp_time.tm_year,
  143. 	          &tmp_time.tm_hour,
  144. 	          &tmp_time.tm_min,
  145. 	          &parsed) < 5)
  146. 	{
  147. 		if(errno == 0 || errno == EINVAL)
  148. 		{
  149. 			if(tmp_time.tm_wday == -1)
  150. 			{
  151. 				*errstr = NULL;
  152. 			}
  153. 			else
  154. 			{
  155. 				*errstr = "Failed parsing Email-datetime";
  156. 			}
  157. 		}
  158. 		else
  159. 		{
  160. 			*errstr = strerror(errno);
  161. 			errno = 0;
  162. 		}
  163. 		return NULL;
  164. 	}
  166. 	if(tmp_time.tm_year < 49)
  167. 	{
  168. 		tmp_time.tm_year += 100; // 2000-2049
  169. 	}
  170. 	else if(tmp_time.tm_year > 99)
  171. 	{
  172. 		tmp_time.tm_year -= 1900;
  173. 	}
  175. 	arg += parsed;
  177. 	if(arg[0] == ':' && isdigit(arg[1]))
  178. 	{
  179. 		if(isdigit(arg[2]))
  180. 		{
  181. 			tmp_time.tm_sec = (arg[1] - '0') * 10 + (arg[2] - '0');
  182. 			arg += 3;
  183. 		}
  184. 		else
  185. 		{
  186. 			tmp_time.tm_sec = arg[1] - '0';
  187. 			arg += 2;
  188. 		}
  189. 	}
  191. 	for(; isspace(arg[0]); arg++)
  192. 		;
  194. 	// Consider that nobody is going to transmit a timezone name which isn't GMT
  195. 	if(arg[0] == 'G' && arg[1] == 'M' && arg[2] == 'T' && (arg[3] == '\0' || isspace(arg[3])))
  196. 	{
  197. 		tmp_time.tm_isdst = 0;
  198. 		tmp_time.tm_gmtoff = 0;
  199. 		tmp_time.tm_zone = "UTC";
  200. 	}
  201. 	else
  202. 	{
  203. 		arg = tzoffset_parse(arg, &tmp_time, errstr);
  204. 		if(arg == NULL) return NULL;
  205. 	}
  207. 	// Done extracting directly from arg
  209. 	tmp_time.tm_mon = -1;
  210. 	// Because %b/%B is locale-dependent
  211. 	for(size_t i = 0; i < 12; i++)
  212. 	{
  213. 		if(memcmp(month_name, short_month_name[i], 3) == 0)
  214. 		{
  215. 			tmp_time.tm_mon = i;
  216. 			break;
  217. 		}
  218. 	}
  219. 	if(tmp_time.tm_mon < 0)
  220. 	{
  221. 		*errstr = "Failed parsing short month name";
  222. 		errno = 0;
  223. 		return NULL;
  224. 	}
  226. 	memcpy(time, &tmp_time, sizeof(tmp_time));
  227. 	return arg;
  228. }
  230. // For iso_parse function
  231. // Sets *errstr to NULL when it isn't an email date-time
  232. //
  233. // Check if it could be asctime() format: Thu Nov 24 18:22:48 1986
  234. static char *
  235. asctime_date_parse(char *arg, struct tm *time, const char **errstr)
  236. {
  237. 	// Kept free of strptime() due to update/overriding being undefined and
  238. 	// requiring custom parsing, notably locale-free, which strptime() can't handle
  240. 	// Change `time` only right before returning in case datetime is invalid
  241. 	struct tm tmp_time = *time;
  242. 	tmp_time.tm_isdst = -1;
  243. 	tmp_time.tm_wday = -1;
  245. 	// asctime() doesn't gives any timezone information, assume UTC
  246. 	tmp_time.tm_isdst = 0;
  247. 	tmp_time.tm_gmtoff = 0;
  248. 	tmp_time.tm_zone = "UTC";
  250. 	errno = 0;
  251. 	int parsed = 0;
  252. 	char month_name[4] = "";
  253. 	char weekday_name[4] = "";
  254. 	if(sscanf(arg,
  255. 	          "%3s %3s %d %2d:%2d:%2d %d%n",
  256. 	          weekday_name,
  257. 	          month_name,
  258. 	          &tmp_time.tm_mday,
  259. 	          &tmp_time.tm_hour,
  260. 	          &tmp_time.tm_min,
  261. 	          &tmp_time.tm_sec,
  262. 	          &tmp_time.tm_year,
  263. 	          &parsed) < 7)
  264. 	{
  265. 		if(errno == 0 || errno == EINVAL)
  266. 		{
  267. 			*errstr = NULL;
  268. 		}
  269. 		else
  270. 		{
  271. 			*errstr = strerror(errno);
  272. 			errno = 0;
  273. 		}
  274. 		return NULL;
  275. 	}
  277. 	arg += parsed;
  279. 	tmp_time.tm_year -= 1900;
  281. 	tmp_time.tm_wday = -1;
  282. 	// Because %a/%A is locale-dependent
  283. 	for(size_t i = 0; i < 7; i++)
  284. 	{
  285. 		if(memcmp(weekday_name, short_weekday_name[i], 3) == 0)
  286. 		{
  287. 			tmp_time.tm_wday = i;
  288. 			break;
  289. 		}
  290. 	}
  291. 	if(tmp_time.tm_wday < 0)
  292. 	{
  293. 		*errstr = "Failed parsing short weekday name";
  294. 		errno = 0;
  295. 		return NULL;
  296. 	}
  298. 	tmp_time.tm_mon = -1;
  299. 	// Because %b/%B is locale-dependent
  300. 	for(size_t i = 0; i < 12; i++)
  301. 	{
  302. 		if(memcmp(month_name, short_month_name[i], 3) == 0)
  303. 		{
  304. 			tmp_time.tm_mon = i;
  305. 			break;
  306. 		}
  307. 	}
  308. 	if(tmp_time.tm_mon < 0)
  309. 	{
  310. 		*errstr = "Failed parsing short month name";
  311. 		errno = 0;
  312. 		return NULL;
  313. 	}
  315. 	for(; isspace(arg[0]); arg++)
  316. 		;
  318. 	memcpy(time, &tmp_time, sizeof(tmp_time));
  319. 	return arg;
  320. }
  322. // Sets errstr on failure
  323. // YYYY-MM-DD[T ]hh:mm:SS([,\.]frac)?(Z|[+\-]hh:?mm)?
  324. char *
  325. iso_parse(char *arg, struct tm *time, long *nsec, const char **errstr)
  326. {
  327. 	*nsec = 0;
  329. 	// For Alpine's abuild compatibility
  330. 	if(arg[0] == '@')
  331. 	{
  332. 		arg++;
  334. 		char *endptr = NULL;
  335. 		time_t now = strtol(arg, &endptr, 10);
  336. 		if(errno != 0)
  337. 		{
  338. 			*errstr = strerror(errno);
  339. 			errno = 0;
  340. 			return NULL;
  341. 		}
  343. 		gmtime_r(&now, time);
  345. 		return endptr;
  346. 	}
  348. 	char *ret = NULL;
  350. 	ret = email_date_parse(arg, time, errstr);
  351. 	if(ret != NULL || *errstr != NULL)
  352. 	{
  353. 		return ret;
  354. 	}
  356. 	ret = asctime_date_parse(arg, time, errstr);
  357. 	if(ret != NULL || *errstr != NULL)
  358. 	{
  359. 		return ret;
  360. 	}
  362. 	// Try parsing as RFC3339 subset of ISO 8601:1988
  364. 	// FIXME?: Calling strptime() multiple times is explicitly unspecified in POSIX.1-2024
  365. 	// instead a single strptime() call should be done
  367. 	// No %F in POSIX prior to POSIX.1-2024 (<https://www.austingroupbugs.net/view.php?id=920>)
  368. 	char *s = strptime(arg, "%Y-%m-%d", time);
  370. 	if(s == NULL)
  371. 	{
  372. 		*errstr = "strptime(…, \"%Y-%m-%d\", …) returned NULL";
  373. 		errno = 0;
  374. 		return NULL;
  375. 	}
  376. 	if(s[0] != 'T' && s[0] != ' ')
  377. 	{
  378. 		*errstr = "Couldn't find time-separator (T or space) after date (Y-m-d)";
  379. 		errno = 0;
  380. 		return NULL;
  381. 	}
  382. 	s++;
  384. 	s = strptime(s, "%H:%M:%S", time);
  385. 	if(s == NULL)
  386. 	{
  387. 		*errstr = "strptime(…, \"%H:%M:%S\", …) returned NULL";
  388. 		errno = 0;
  389. 		return NULL;
  390. 	}
  392. 	if(s[0] == ',' || s[0] == '.')
  393. 	{
  394. 		double fraction = 0.0;
  395. 		int parsed = 0;
  397. 		if(s[0] == ',') s[0] = '.';
  399. 		if(sscanf(s, "%10lf%n", &fraction, &parsed) < 1)
  400. 		{
  401. 			if(errno == 0)
  402. 			{
  403. 				*errstr = "Failed to parse fractional seconds";
  404. 			}
  405. 			else
  406. 			{
  407. 				*errstr = strerror(errno);
  408. 				errno = 0;
  409. 			}
  410. 			return NULL;
  411. 		}
  413. 		*nsec = (long)(fraction * 1000000000);
  414. 		s += parsed;
  416. 		// too many digits
  417. 		if(isdigit(s[0]))
  418. 		{
  419. 			*errstr = "Too many digits (> 10) for fractional seconds";
  420. 			return NULL;
  421. 		}
  422. 	}
  424. 	for(; isspace(s[0]); s++)
  425. 		;
  427. 	if(s != NULL && s[0] != '\0')
  428. 	{
  429. 		if(s[0] == 'Z' && s[1] == '\0')
  430. 		{
  431. 			time->tm_isdst = 0;
  432. 			time->tm_gmtoff = 0;
  433. 			time->tm_zone = "UTC";
  434. 		}
  435. 		else
  436. 		{
  437. 			s = tzoffset_parse(s, time, errstr);
  438. 			if(s == NULL) return NULL;
  439. 		}
  440. 	}
  442. 	return s;
  443. }
  445. // Because mktime() messes with tm_gmtoff yet doesn't applies it, even in POSIX.1-2024
  446. // Returns (time_t)-1 on failure
  447. // Maybe should be replaced by mktime_z once <https://www.austingroupbugs.net/view.php?id=1794> gets accepted and implemented
  448. time_t
  449. mktime_tz(struct tm *tm)
  450. {
  451. 	long gmtoff = tm->tm_gmtoff;
  452. 	const char *zone = tm->tm_zone;
  454. 	time_t res = mktime(tm);
  455. 	tm->tm_gmtoff = gmtoff;
  456. 	tm->tm_zone = zone;
  458. 	if(res == (time_t)-1) return res;
  460. 	// 12:00+02:00 corresponds to 10:00Z so needs to be reversed
  461. 	res += -gmtoff;
  463. 	return res;
  464. }