xref: /illumos-gate/usr/src/cmd/zic/zic.c (revision 9cdf9e12f0c6a1d10a3583d36c9a167cf71f48f4)
1 /*
2  * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
3  * Use is subject to license terms.
4  */
5 
6 static char    elsieid[] = "@(#)zic.c  7.128.1";
7 
8 /*
9  * #define	LEAPSECOND_SUPPORT
10  */
11 
12 /*
13  * Regardless of the type of time_t, we do our work using this type.
14  */
15 
16 typedef int	zic_t;
17 
18 #include "private.h"
19 #include <tzfile.h>			/* this is in system headers at Sun */
20 
21 #include <sys/stat.h>			/* for umask manifest constants */
22 #include <ctype.h>
23 #include <locale.h>
24 #include <stdlib.h>			/* for getopt */
25 
26 #ifndef ZIC_MAX_ABBR_LEN_WO_WARN
27 #define	ZIC_MAX_ABBR_LEN_WO_WARN	6
28 #endif /* !defined ZIC_MAX_ABBR_LEN_WO_WARN */
29 
30 #ifdef S_IRUSR
31 #define	MKDIR_UMASK (S_IRUSR|S_IWUSR|S_IXUSR|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH)
32 #else
33 #define	MKDIR_UMASK 0755
34 #endif
35 
36 struct rule {
37 	const char	*r_filename;
38 	int		r_linenum;
39 	const char	*r_name;
40 
41 	int		r_loyear;	/* for example, 1986 */
42 	int		r_hiyear;	/* for example, 1986 */
43 	const char	*r_yrtype;
44 
45 	int		r_month;	/* 0..11 */
46 
47 	int		r_dycode;	/* see below */
48 	int		r_dayofmonth;
49 	int		r_wday;
50 
51 	long		r_tod;		/* time from midnight */
52 	int		r_todisstd;	/* above is standard time if TRUE */
53 					/* or wall clock time if FALSE */
54 	int		r_todisgmt;	/* above is GMT if TRUE */
55 					/* or local time if FALSE */
56 	long		r_stdoff;	/* offset from standard time */
57 	const char	*r_abbrvar;	/* variable part of abbreviation */
58 
59 	int		r_todo;		/* a rule to do (used in outzone) */
60 	zic_t		r_temp;		/* used in outzone */
61 };
62 
63 /*
64  *	r_dycode		r_dayofmonth	r_wday
65  */
66 
67 #define	DC_DOM		0	/* 1..31 */	/* unused */
68 #define	DC_DOWGEQ	1	/* 1..31 */	/* 0..6 (Sun..Sat) */
69 #define	DC_DOWLEQ	2	/* 1..31 */	/* 0..6 (Sun..Sat) */
70 
71 struct zone {
72 	const char	*z_filename;
73 	int		z_linenum;
74 
75 	const char	*z_name;
76 	long		z_gmtoff;
77 	const char	*z_rule;
78 	const char	*z_format;
79 
80 	long		z_stdoff;
81 
82 	struct rule	*z_rules;
83 	int		z_nrules;
84 
85 	struct rule	z_untilrule;
86 	zic_t		z_untiltime;
87 };
88 
89 static void	addtt(zic_t starttime, int type);
90 static int	addtype(long gmtoff, const char *abbr, int isdst,
91 				int ttisstd, int ttisgmt);
92 #ifdef LEAPSECOND_SUPPORT
93 static void	leapadd(zic_t t, int positive, int rolling, int count);
94 static void	adjleap(void);
95 #endif
96 static void	associate(void);
97 static int	ciequal(const char *ap, const char *bp);
98 static void	convert(long val, char *buf);
99 static void	dolink(const char *fromfield, const char *tofield);
100 static void	doabbr(char *abbr, const char *format,
101 			const char *letters, int isdst);
102 static void	eat(const char *name, int num);
103 static void	eats(const char *name, int num,
104 			const char *rname, int rnum);
105 static long	eitol(int i);
106 static void	error(const char *message);
107 static char	**getfields(char *buf);
108 static long	gethms(const char *string, const char *errstrng, int signable);
109 static void	infile(const char *filename);
110 #ifdef LEAPSECOND_SUPPORT
111 static void	inleap(char **fields, int nfields);
112 #endif
113 static void	inlink(char **fields, int nfields);
114 static void	inrule(char **fields, int nfields);
115 static int	inzcont(char **fields, int nfields);
116 static int	inzone(char **fields, int nfields);
117 static int	inzsub(char **fields, int nfields, int iscont);
118 static int	itsabbr(const char *abbr, const char *word);
119 static int	itsdir(const char *name);
120 static int	lowerit(int c);
121 static char	*memcheck(char *tocheck);
122 static int	mkdirs(char *filename);
123 static void	newabbr(const char *abbr);
124 static long	oadd(long t1, long t2);
125 static void	outzone(const struct zone *zp, int ntzones);
126 static void	puttzcode(long code, FILE *fp);
127 static int	rcomp(const void *leftp, const void *rightp);
128 static zic_t	rpytime(const struct rule *rp, int wantedy);
129 static void	rulesub(struct rule *rp,
130 			const char *loyearp, const char *hiyearp,
131 			const char *typep, const char *monthp,
132 			const char *dayp, const char *timep);
133 static void	setboundaries(void);
134 static zic_t	tadd(zic_t t1, long t2);
135 static void	usage(void);
136 static void	writezone(const char *name);
137 static int	yearistype(int year, const char *type);
138 
139 static int		charcnt;
140 static int		errors;
141 static const char	*filename;
142 static int		leapcnt;
143 static int		linenum;
144 static zic_t		max_time;
145 static int		max_year;
146 static int		max_year_representable;
147 static zic_t		min_time;
148 static int		min_year;
149 static int		min_year_representable;
150 static int		noise;
151 static const char	*rfilename;
152 static int		rlinenum;
153 static const char	*progname;
154 static int		timecnt;
155 static int		typecnt;
156 
157 /*
158  * Line codes.
159  */
160 
161 #define	LC_RULE		0
162 #define	LC_ZONE		1
163 #define	LC_LINK		2
164 #define	LC_LEAP		3
165 
166 /*
167  * Which fields are which on a Zone line.
168  */
169 
170 #define	ZF_NAME		1
171 #define	ZF_GMTOFF	2
172 #define	ZF_RULE		3
173 #define	ZF_FORMAT	4
174 #define	ZF_TILYEAR	5
175 #define	ZF_TILMONTH	6
176 #define	ZF_TILDAY	7
177 #define	ZF_TILTIME	8
178 #define	ZONE_MINFIELDS	5
179 #define	ZONE_MAXFIELDS	9
180 
181 /*
182  * Which fields are which on a Zone continuation line.
183  */
184 
185 #define	ZFC_GMTOFF	0
186 #define	ZFC_RULE	1
187 #define	ZFC_FORMAT	2
188 #define	ZFC_TILYEAR	3
189 #define	ZFC_TILMONTH	4
190 #define	ZFC_TILDAY	5
191 #define	ZFC_TILTIME	6
192 #define	ZONEC_MINFIELDS	3
193 #define	ZONEC_MAXFIELDS	7
194 
195 /*
196  * Which files are which on a Rule line.
197  */
198 
199 #define	RF_NAME		1
200 #define	RF_LOYEAR	2
201 #define	RF_HIYEAR	3
202 #define	RF_COMMAND	4
203 #define	RF_MONTH	5
204 #define	RF_DAY		6
205 #define	RF_TOD		7
206 #define	RF_STDOFF	8
207 #define	RF_ABBRVAR	9
208 #define	RULE_FIELDS	10
209 
210 /*
211  * Which fields are which on a Link line.
212  */
213 
214 #define	LF_FROM		1
215 #define	LF_TO		2
216 #define	LINK_FIELDS	3
217 
218 /*
219  * Which fields are which on a Leap line.
220  */
221 
222 #define	LP_YEAR		1
223 #define	LP_MONTH	2
224 #define	LP_DAY		3
225 #define	LP_TIME		4
226 #define	LP_CORR		5
227 #define	LP_ROLL		6
228 #define	LEAP_FIELDS	7
229 
230 /*
231  * Year synonyms.
232  */
233 
234 #define	YR_MINIMUM	0
235 #define	YR_MAXIMUM	1
236 #define	YR_ONLY		2
237 
238 static struct rule	*rules;
239 static int		nrules;	/* number of rules */
240 
241 static struct zone	*zones;
242 static int		nzones;	/* number of zones */
243 
244 struct link {
245 	const char	*l_filename;
246 	int		l_linenum;
247 	const char	*l_from;
248 	const char	*l_to;
249 };
250 
251 static struct link	*links;
252 static int		nlinks;
253 
254 struct lookup {
255 	const char	*l_word;
256 	const int	l_value;
257 };
258 
259 static struct lookup const *byword(const char *string,
260     const struct lookup *lp);
261 
262 static struct lookup const	line_codes[] = {
263 	{ "Rule",	LC_RULE },
264 	{ "Zone",	LC_ZONE },
265 	{ "Link",	LC_LINK },
266 	{ "Leap",	LC_LEAP },
267 	{ NULL,		0}
268 };
269 
270 static struct lookup const	mon_names[] = {
271 	{ "January",	TM_JANUARY },
272 	{ "February",	TM_FEBRUARY },
273 	{ "March",	TM_MARCH },
274 	{ "April",	TM_APRIL },
275 	{ "May",	TM_MAY },
276 	{ "June",	TM_JUNE },
277 	{ "July",	TM_JULY },
278 	{ "August",	TM_AUGUST },
279 	{ "September",	TM_SEPTEMBER },
280 	{ "October",	TM_OCTOBER },
281 	{ "November",	TM_NOVEMBER },
282 	{ "December",	TM_DECEMBER },
283 	{ NULL,		0 }
284 };
285 
286 static struct lookup const	wday_names[] = {
287 	{ "Sunday",	TM_SUNDAY },
288 	{ "Monday",	TM_MONDAY },
289 	{ "Tuesday",	TM_TUESDAY },
290 	{ "Wednesday",	TM_WEDNESDAY },
291 	{ "Thursday",	TM_THURSDAY },
292 	{ "Friday",	TM_FRIDAY },
293 	{ "Saturday",	TM_SATURDAY },
294 	{ NULL,		0 }
295 };
296 
297 static struct lookup const	lasts[] = {
298 	{ "last-Sunday",	TM_SUNDAY },
299 	{ "last-Monday",	TM_MONDAY },
300 	{ "last-Tuesday",	TM_TUESDAY },
301 	{ "last-Wednesday",	TM_WEDNESDAY },
302 	{ "last-Thursday",	TM_THURSDAY },
303 	{ "last-Friday",	TM_FRIDAY },
304 	{ "last-Saturday",	TM_SATURDAY },
305 	{ NULL,			0 }
306 };
307 
308 static struct lookup const	begin_years[] = {
309 	{ "minimum",	YR_MINIMUM },
310 	{ "maximum",	YR_MAXIMUM },
311 	{ NULL,		0 }
312 };
313 
314 static struct lookup const	end_years[] = {
315 	{ "minimum",	YR_MINIMUM },
316 	{ "maximum",	YR_MAXIMUM },
317 	{ "only",	YR_ONLY },
318 	{ NULL,		0 }
319 };
320 
321 static struct lookup const	leap_types[] = {
322 	{ "Rolling",	TRUE },
323 	{ "Stationary",	FALSE },
324 	{ NULL,		0 }
325 };
326 
327 static const int	len_months[2][MONSPERYEAR] = {
328 	{ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
329 	{ 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
330 };
331 
332 static const int	len_years[2] = {
333 	DAYSPERNYEAR, DAYSPERLYEAR
334 };
335 
336 static struct attype {
337 	zic_t		at;
338 	unsigned char	type;
339 }			attypes[TZ_MAX_TIMES];
340 static long		gmtoffs[TZ_MAX_TYPES];
341 static char		isdsts[TZ_MAX_TYPES];
342 static unsigned char	abbrinds[TZ_MAX_TYPES];
343 static char		ttisstds[TZ_MAX_TYPES];
344 static char		ttisgmts[TZ_MAX_TYPES];
345 static char		chars[TZ_MAX_CHARS];
346 static zic_t		trans[TZ_MAX_LEAPS];
347 static long		corr[TZ_MAX_LEAPS];
348 static char		roll[TZ_MAX_LEAPS];
349 
350 /*
351  * Memory allocation.
352  */
353 
354 static char *
memcheck(ptr)355 memcheck(ptr)
356 char * const	ptr;
357 {
358 	if (ptr == NULL) {
359 		const char *e = strerror(errno);
360 		(void) fprintf(stderr, gettext("%s: Memory exhausted: %s\n"),
361 			progname, e);
362 		exit(EXIT_FAILURE);
363 	}
364 	return (ptr);
365 }
366 
367 #define	emalloc(size)		memcheck(imalloc(size))
368 #define	erealloc(ptr, size)	memcheck(irealloc((ptr), (size)))
369 #define	ecpyalloc(ptr)		memcheck(icpyalloc(ptr))
370 #define	ecatalloc(oldp, newp)	memcheck(icatalloc((oldp), (newp)))
371 
372 /*
373  * Error handling.
374  */
375 
376 static void
eats(name,num,rname,rnum)377 eats(name, num, rname, rnum)
378 const char * const	name;
379 const int		num;
380 const char * const	rname;
381 const int		rnum;
382 {
383 	filename = name;
384 	linenum = num;
385 	rfilename = rname;
386 	rlinenum = rnum;
387 }
388 
389 static void
eat(name,num)390 eat(name, num)
391 const char * const	name;
392 const int		num;
393 {
394 	eats(name, num, (char *)NULL, -1);
395 }
396 
397 static void
error(string)398 error(string)
399 const char * const	string;
400 {
401 	/*
402 	 * Match the format of "cc" to allow sh users to
403 	 *	zic ... 2>&1 | error -t "*" -v
404 	 * on BSD systems.
405 	 */
406 	(void) fprintf(stderr, gettext("\"%s\", line %d: %s"),
407 		filename, linenum, string);
408 	if (rfilename != NULL)
409 		(void) fprintf(stderr, gettext(" (rule from \"%s\", line %d)"),
410 			rfilename, rlinenum);
411 	(void) fprintf(stderr, "\n");
412 	++errors;
413 }
414 
415 static void
warning(string)416 warning(string)
417 const char * const	string;
418 {
419 	char *cp;
420 
421 	cp = ecpyalloc(gettext("warning: "));
422 	cp = ecatalloc(cp, string);
423 	error(cp);
424 	ifree(cp);
425 	--errors;
426 }
427 
428 static void
usage(void)429 usage(void)
430 {
431 #ifdef LEAPSECOND_SUPPORT
432 	(void) fprintf(stderr, gettext("%s: usage is %s "
433 	    "[ --version ] [ -s ] [ -v ] [ -l localtime ] "
434 	    "\n\t[ -p posixrules ] [ -d directory ] [ -L leapseconds ] "
435 	    "[ -y yearistype ] [ filename ... ]\n"), progname, progname);
436 #else /* ! LEAPSECOND_SUPPORT */
437 	(void) fprintf(stderr, gettext("%s: usage is %s "
438 	    "[ --version ] [ -s ] [ -v ] [ -l localtime ]"
439 	    "\n\t[ -p posixrules ] [ -d directory ] [ -y yearistype ] "
440 	    "[ filename ... ]\n"), progname, progname);
441 #endif /* LEAPSECOND_SUPPORT */
442 	exit(EXIT_FAILURE);
443 }
444 
445 static const char	*psxrules;
446 static const char	*lcltime;
447 static const char	*directory;
448 static const char	*leapsec;
449 static const char	*yitcommand;
450 static int		sflag = FALSE;
451 
452 int
main(argc,argv)453 main(argc, argv)
454 int	argc;
455 char	*argv[];
456 {
457 	register int	i;
458 	register int	j;
459 	register int	c;
460 
461 	(void) umask(umask(S_IWGRP | S_IWOTH) | (S_IWGRP | S_IWOTH));
462 
463 	(void) setlocale(LC_ALL, "");
464 #if !defined(TEXT_DOMAIN)
465 #define	TEXT_DOMAIN	"SYS_TEST"
466 #endif
467 	(void) textdomain(TEXT_DOMAIN);
468 
469 	progname = argv[0];
470 	for (i = 1; i < argc; ++i)
471 		if (strcmp(argv[i], "--version") == 0) {
472 			(void) printf("%s\n", elsieid);
473 			exit(EXIT_SUCCESS);
474 		}
475 
476 #ifdef LEAPSECOND_SUPPORT
477 	while ((c = getopt(argc, argv, "d:l:p:L:vsy:")) != EOF)
478 #else
479 	while ((c = getopt(argc, argv, "d:l:p:vsy:")) != EOF)
480 #endif
481 		switch (c) {
482 			default:
483 				usage();
484 				break;
485 			case 'd':
486 				if (directory == NULL)
487 					directory = optarg;
488 				else {
489 					(void) fprintf(stderr, gettext(
490 "%s: More than one -d option specified\n"),
491 						progname);
492 					exit(EXIT_FAILURE);
493 				}
494 				break;
495 			case 'l':
496 				if (lcltime == NULL)
497 					lcltime = optarg;
498 				else {
499 					(void) fprintf(stderr, gettext(
500 "%s: More than one -l option specified\n"),
501 						progname);
502 					exit(EXIT_FAILURE);
503 				}
504 				break;
505 			case 'p':
506 				if (psxrules == NULL)
507 					psxrules = optarg;
508 				else {
509 					(void) fprintf(stderr, gettext(
510 "%s: More than one -p option specified\n"),
511 						progname);
512 					exit(EXIT_FAILURE);
513 				}
514 				break;
515 			case 'y':
516 				if (yitcommand == NULL)
517 					yitcommand = optarg;
518 				else {
519 					(void) fprintf(stderr, gettext(
520 "%s: More than one -y option specified\n"),
521 						progname);
522 					exit(EXIT_FAILURE);
523 				}
524 				break;
525 #ifdef LEAPSECOND_SUPPORT
526 			case 'L':
527 				if (leapsec == NULL)
528 					leapsec = optarg;
529 				else {
530 					(void) fprintf(stderr, gettext(
531 "%s: More than one -L option specified\n"),
532 						progname);
533 					exit(EXIT_FAILURE);
534 				}
535 				break;
536 #endif /* LEAPSECOND_SUPPORT */
537 			case 'v':
538 				noise = TRUE;
539 				break;
540 			case 's':
541 				sflag = TRUE;
542 				break;
543 		}
544 	if (optind == argc - 1 && strcmp(argv[optind], "=") == 0)
545 		usage();	/* usage message by request */
546 	if (directory == NULL)
547 		directory = TZDIR;
548 	if (yitcommand == NULL)
549 		yitcommand = "yearistype";
550 
551 	setboundaries();
552 
553 #ifdef LEAPSECOND_SUPPORT
554 	if (optind < argc && leapsec != NULL) {
555 		infile(leapsec);
556 		adjleap();
557 	}
558 #endif /* LEAPSECOND_SUPPORT */
559 
560 	for (i = optind; i < argc; ++i)
561 		infile(argv[i]);
562 	if (errors)
563 		exit(EXIT_FAILURE);
564 	associate();
565 	for (i = 0; i < nzones; i = j) {
566 		/*
567 		 * Find the next non-continuation zone entry.
568 		 */
569 		for (j = i + 1; j < nzones && zones[j].z_name == NULL; ++j)
570 			continue;
571 		outzone(&zones[i], j - i);
572 	}
573 	/*
574 	 * Make links.
575 	 */
576 	for (i = 0; i < nlinks; ++i) {
577 		eat(links[i].l_filename, links[i].l_linenum);
578 		dolink(links[i].l_from, links[i].l_to);
579 		if (noise)
580 			for (j = 0; j < nlinks; ++j)
581 				if (strcmp(links[i].l_to, links[j].l_from) == 0)
582 					warning(gettext("link to link"));
583 	}
584 	if (lcltime != NULL) {
585 		eat("command line", 1);
586 		dolink(lcltime, TZDEFAULT);
587 	}
588 	if (psxrules != NULL) {
589 		eat("command line", 1);
590 		dolink(psxrules, TZDEFRULES);
591 	}
592 	return ((errors == 0) ? EXIT_SUCCESS : EXIT_FAILURE);
593 }
594 
595 static void
dolink(fromfield,tofield)596 dolink(fromfield, tofield)
597 const char * const	fromfield;
598 const char * const	tofield;
599 {
600 	register char *fromname;
601 	register char *toname;
602 
603 	if (fromfield[0] == '/')
604 		fromname = ecpyalloc(fromfield);
605 	else {
606 		fromname = ecpyalloc(directory);
607 		fromname = ecatalloc(fromname, "/");
608 		fromname = ecatalloc(fromname, fromfield);
609 	}
610 	if (tofield[0] == '/')
611 		toname = ecpyalloc(tofield);
612 	else {
613 		toname = ecpyalloc(directory);
614 		toname = ecatalloc(toname, "/");
615 		toname = ecatalloc(toname, tofield);
616 	}
617 	/*
618 	 * We get to be careful here since
619 	 * there's a fair chance of root running us.
620 	 */
621 	if (!itsdir(toname))
622 		(void) remove(toname);
623 	if (link(fromname, toname) != 0) {
624 		int	result;
625 
626 		if (mkdirs(toname) != 0)
627 			exit(EXIT_FAILURE);
628 
629 		result = link(fromname, toname);
630 
631 		if (result != 0 && access(fromname, F_OK) == 0 &&
632 		    !itsdir(fromname)) {
633 			const char *s = tofield;
634 			register char *symlinkcontents = NULL;
635 
636 			while ((s = strchr(s+1, '/')) != NULL)
637 				symlinkcontents = ecatalloc(symlinkcontents,
638 					"../");
639 			symlinkcontents = ecatalloc(symlinkcontents, fromname);
640 			result = symlink(symlinkcontents, toname);
641 			if (result == 0)
642 				warning(gettext(
643 				    "hard link failed, symbolic link used"));
644 			ifree(symlinkcontents);
645 		}
646 
647 		if (result != 0) {
648 			const char *e = strerror(errno);
649 
650 			(void) fprintf(stderr, gettext(
651 				"%s: Can't link from %s to %s: %s\n"),
652 				progname, fromname, toname, e);
653 			exit(EXIT_FAILURE);
654 		}
655 	}
656 	ifree(fromname);
657 	ifree(toname);
658 }
659 
660 #ifndef INT_MAX
661 #define	INT_MAX		((int)(((unsigned)~0)>>1))
662 #endif /* !defined INT_MAX */
663 
664 #ifndef INT_MIN
665 #define	INT_MIN		((int)~(((unsigned)~0)>>1))
666 #endif /* !defined INT_MIN */
667 
668 /*
669  * The tz file format currently allows at most 32-bit quantities.
670  * This restriction should be removed before signed 32-bit values
671  * wrap around in 2038, but unfortunately this will require a
672  * change to the tz file format.
673  */
674 
675 #define	MAX_BITS_IN_FILE	32
676 /* CSTYLED */
677 #define	TIME_T_BITS_IN_FILE	((TYPE_BIT(zic_t) < MAX_BITS_IN_FILE) ? \
678 				    TYPE_BIT(zic_t): MAX_BITS_IN_FILE)
679 
680 static void
setboundaries(void)681 setboundaries(void)
682 {
683 	register int	i;
684 
685 	if (TYPE_SIGNED(zic_t)) {
686 		min_time = -1;
687 		for (i = 0; i < TIME_T_BITS_IN_FILE - 1; ++i)
688 			min_time *= 2;
689 		max_time = -(min_time + 1);
690 		if (sflag)
691 			min_time = 0;
692 	} else {
693 		min_time = 0;
694 		max_time = 2 - sflag;
695 		for (i = 0; i < TIME_T_BITS_IN_FILE - 1; ++i)
696 			max_time *= 2;
697 		--max_time;
698 	}
699 	{
700 		time_t	t;
701 
702 		t = (time_t)min_time;
703 		min_year = TM_YEAR_BASE + gmtime(&t)->tm_year;
704 		t = (time_t)max_time;
705 		max_year = TM_YEAR_BASE + gmtime(&t)->tm_year;
706 	}
707 	min_year_representable = min_year;
708 	max_year_representable = max_year;
709 }
710 
711 static int
itsdir(name)712 itsdir(name)
713 const char * const	name;
714 {
715 	register char	*myname;
716 	register int	accres;
717 
718 	myname = ecpyalloc(name);
719 	myname = ecatalloc(myname, "/.");
720 	accres = access(myname, F_OK);
721 	ifree(myname);
722 	return (accres == 0);
723 }
724 
725 /*
726  * Associate sets of rules with zones.
727  */
728 
729 /*
730  * Sort by rule name.
731  */
732 
733 static int
rcomp(cp1,cp2)734 rcomp(cp1, cp2)
735 const void *	cp1;
736 const void *	cp2;
737 {
738 	return (strcmp(((const struct rule *) cp1)->r_name,
739 		((const struct rule *) cp2)->r_name));
740 }
741 
742 static void
associate(void)743 associate(void)
744 {
745 	register struct zone	*zp;
746 	register struct rule	*rp;
747 	register int		base, out;
748 	register int		i, j;
749 
750 	if (nrules != 0) {
751 		(void) qsort((void *)rules, (size_t)nrules,
752 			(size_t)sizeof (*rules), rcomp);
753 		for (i = 0; i < nrules - 1; ++i) {
754 			if (strcmp(rules[i].r_name,
755 				rules[i + 1].r_name) != 0)
756 					continue;
757 			if (strcmp(rules[i].r_filename,
758 				rules[i + 1].r_filename) == 0)
759 					continue;
760 			eat(rules[i].r_filename, rules[i].r_linenum);
761 			warning(gettext("same rule name in multiple files"));
762 			eat(rules[i + 1].r_filename, rules[i + 1].r_linenum);
763 			warning(gettext("same rule name in multiple files"));
764 			for (j = i + 2; j < nrules; ++j) {
765 				if (strcmp(rules[i].r_name,
766 					rules[j].r_name) != 0)
767 						break;
768 				if (strcmp(rules[i].r_filename,
769 					rules[j].r_filename) == 0)
770 						continue;
771 				if (strcmp(rules[i + 1].r_filename,
772 					rules[j].r_filename) == 0)
773 						continue;
774 				break;
775 			}
776 			i = j - 1;
777 		}
778 	}
779 	for (i = 0; i < nzones; ++i) {
780 		zp = &zones[i];
781 		zp->z_rules = NULL;
782 		zp->z_nrules = 0;
783 	}
784 	for (base = 0; base < nrules; base = out) {
785 		rp = &rules[base];
786 		for (out = base + 1; out < nrules; ++out)
787 			if (strcmp(rp->r_name, rules[out].r_name) != 0)
788 				break;
789 		for (i = 0; i < nzones; ++i) {
790 			zp = &zones[i];
791 			if (strcmp(zp->z_rule, rp->r_name) != 0)
792 				continue;
793 			zp->z_rules = rp;
794 			zp->z_nrules = out - base;
795 		}
796 	}
797 	for (i = 0; i < nzones; ++i) {
798 		zp = &zones[i];
799 		if (zp->z_nrules == 0) {
800 			/*
801 			 * Maybe we have a local standard time offset.
802 			 */
803 			eat(zp->z_filename, zp->z_linenum);
804 			zp->z_stdoff = gethms(zp->z_rule,
805 				gettext("unruly zone"), TRUE);
806 			/*
807 			 * Note, though, that if there's no rule,
808 			 * a '%s' in the format is a bad thing.
809 			 */
810 			if (strchr(zp->z_format, '%') != 0)
811 				error(gettext("%s in ruleless zone"));
812 		}
813 	}
814 	if (errors)
815 		exit(EXIT_FAILURE);
816 }
817 
818 static void
infile(name)819 infile(name)
820 const char *name;
821 {
822 	register FILE			*fp;
823 	register char			**fields;
824 	register char			*cp;
825 	register const struct lookup	*lp;
826 	register int			nfields;
827 	register int			wantcont;
828 	register int			num;
829 	char				buf[BUFSIZ];
830 
831 	if (strcmp(name, "-") == 0) {
832 		name = gettext("standard input");
833 		fp = stdin;
834 	} else if ((fp = fopen(name, "r")) == NULL) {
835 		const char *e = strerror(errno);
836 
837 		(void) fprintf(stderr, gettext("%s: Can't open %s: %s\n"),
838 			progname, name, e);
839 		exit(EXIT_FAILURE);
840 	}
841 	wantcont = FALSE;
842 	for (num = 1; ; ++num) {
843 		eat(name, num);
844 		if (fgets(buf, (int)sizeof (buf), fp) != buf)
845 			break;
846 		cp = strchr(buf, '\n');
847 		if (cp == NULL) {
848 			error(gettext("line too long"));
849 			exit(EXIT_FAILURE);
850 		}
851 		*cp = '\0';
852 		fields = getfields(buf);
853 		nfields = 0;
854 		while (fields[nfields] != NULL) {
855 			static char	nada;
856 
857 			if (strcmp(fields[nfields], "-") == 0)
858 				fields[nfields] = &nada;
859 			++nfields;
860 		}
861 		if (nfields == 0) {
862 			/* nothing to do */
863 		} else if (wantcont) {
864 			wantcont = inzcont(fields, nfields);
865 		} else {
866 			lp = byword(fields[0], line_codes);
867 			if (lp == NULL)
868 				error(gettext("input line of unknown type"));
869 			else switch ((int)(lp->l_value)) {
870 				case LC_RULE:
871 					inrule(fields, nfields);
872 					wantcont = FALSE;
873 					break;
874 				case LC_ZONE:
875 					wantcont = inzone(fields, nfields);
876 					break;
877 				case LC_LINK:
878 					inlink(fields, nfields);
879 					wantcont = FALSE;
880 					break;
881 #ifdef LEAPSECOND_SUPPORT
882 				case LC_LEAP:
883 					if (name != leapsec)
884 						(void) fprintf(stderr, gettext(
885 "%s: Leap line in non leap seconds file %s\n"),
886 							progname, name);
887 					else	inleap(fields, nfields);
888 					wantcont = FALSE;
889 					break;
890 #endif /* LEAPSECOND_SUPPORT */
891 				default:	/* "cannot happen" */
892 					(void) fprintf(stderr, gettext(
893 "%s: panic: Invalid l_value %d\n"),
894 						progname, lp->l_value);
895 					exit(EXIT_FAILURE);
896 			}
897 		}
898 		ifree((char *)fields);
899 	}
900 	if (ferror(fp)) {
901 		(void) fprintf(stderr, gettext("%s: Error reading %s\n"),
902 			progname, filename);
903 		exit(EXIT_FAILURE);
904 	}
905 	if (fp != stdin && fclose(fp)) {
906 		const char *e = strerror(errno);
907 		(void) fprintf(stderr, gettext("%s: Error closing %s: %s\n"),
908 			progname, filename, e);
909 		exit(EXIT_FAILURE);
910 	}
911 	if (wantcont)
912 		error(gettext("expected continuation line not found"));
913 }
914 
915 /*
916  * Convert a string of one of the forms
917  *	h	-h	hh:mm	-hh:mm	hh:mm:ss	-hh:mm:ss
918  * into a number of seconds.
919  * A null string maps to zero.
920  * Call error with errstring and return zero on errors.
921  */
922 
923 static long
gethms(string,errstring,signable)924 gethms(string, errstring, signable)
925 const char		*string;
926 const char * const	errstring;
927 const int		signable;
928 {
929 	long	hh;
930 	int	mm, ss, sign;
931 
932 	if (string == NULL || *string == '\0')
933 		return (0);
934 	if (!signable)
935 		sign = 1;
936 	else if (*string == '-') {
937 		sign = -1;
938 		++string;
939 	} else	sign = 1;
940 	if (sscanf(string, scheck(string, "%ld"), &hh) == 1)
941 		mm = ss = 0;
942 	else if (sscanf(string, scheck(string, "%ld:%d"), &hh, &mm) == 2)
943 		ss = 0;
944 	else if (sscanf(string, scheck(string, "%ld:%d:%d"),
945 		&hh, &mm, &ss) != 3) {
946 			error(errstring);
947 			return (0);
948 	}
949 	if (hh < 0 ||
950 		mm < 0 || mm >= MINSPERHOUR ||
951 		ss < 0 || ss > SECSPERMIN) {
952 			error(errstring);
953 			return (0);
954 	}
955 	if (LONG_MAX / SECSPERHOUR < hh) {
956 		error(gettext("time overflow"));
957 		return (0);
958 	}
959 	if (noise && hh == HOURSPERDAY && mm == 0 && ss == 0)
960 		warning(
961 		    gettext("24:00 not handled by pre-1998 versions of zic"));
962 	if (noise && (hh > HOURSPERDAY ||
963 		(hh == HOURSPERDAY && (mm != 0 || ss != 0))))
964 		warning(gettext("values over 24 hours not handled by "
965 			    "pre-2007 versions of zic"));
966 
967 	return (oadd(eitol(sign) * hh * eitol(SECSPERHOUR),
968 		eitol(sign) * (eitol(mm) * eitol(SECSPERMIN) + eitol(ss))));
969 }
970 
971 static void
inrule(fields,nfields)972 inrule(fields, nfields)
973 register char ** const	fields;
974 const int		nfields;
975 {
976 	static struct rule	r;
977 
978 	if (nfields != RULE_FIELDS) {
979 		error(gettext("wrong number of fields on Rule line"));
980 		return;
981 	}
982 	if (*fields[RF_NAME] == '\0') {
983 		error(gettext("nameless rule"));
984 		return;
985 	}
986 	r.r_filename = filename;
987 	r.r_linenum = linenum;
988 	r.r_stdoff = gethms(fields[RF_STDOFF], gettext("invalid saved time"),
989 		TRUE);
990 	rulesub(&r, fields[RF_LOYEAR], fields[RF_HIYEAR], fields[RF_COMMAND],
991 		fields[RF_MONTH], fields[RF_DAY], fields[RF_TOD]);
992 	r.r_name = ecpyalloc(fields[RF_NAME]);
993 	r.r_abbrvar = ecpyalloc(fields[RF_ABBRVAR]);
994 	rules = (struct rule *)(void *)erealloc((char *)rules,
995 		(int)((nrules + 1) * sizeof (*rules)));
996 	rules[nrules++] = r;
997 }
998 
999 static int
inzone(fields,nfields)1000 inzone(fields, nfields)
1001 register char ** const	fields;
1002 const int		nfields;
1003 {
1004 	register int	i;
1005 	static char	*buf;
1006 
1007 	if (nfields < ZONE_MINFIELDS || nfields > ZONE_MAXFIELDS) {
1008 		error(gettext("wrong number of fields on Zone line"));
1009 		return (FALSE);
1010 	}
1011 	if (strcmp(fields[ZF_NAME], TZDEFAULT) == 0 && lcltime != NULL) {
1012 		buf = erealloc(buf, (int)(132 + strlen(TZDEFAULT)));
1013 		(void) sprintf(buf,
1014 gettext("\"Zone %s\" line and -l option are mutually exclusive"),
1015 			TZDEFAULT);
1016 		error(buf);
1017 		return (FALSE);
1018 	}
1019 	if (strcmp(fields[ZF_NAME], TZDEFRULES) == 0 && psxrules != NULL) {
1020 		buf = erealloc(buf, (int)(132 + strlen(TZDEFRULES)));
1021 		(void) sprintf(buf,
1022 gettext("\"Zone %s\" line and -p option are mutually exclusive"),
1023 			TZDEFRULES);
1024 		error(buf);
1025 		return (FALSE);
1026 	}
1027 	for (i = 0; i < nzones; ++i)
1028 		if (zones[i].z_name != NULL &&
1029 			strcmp(zones[i].z_name, fields[ZF_NAME]) == 0) {
1030 				buf = erealloc(buf, (int)(132 +
1031 					strlen(fields[ZF_NAME]) +
1032 					strlen(zones[i].z_filename)));
1033 				(void) sprintf(buf,
1034 gettext("duplicate zone name %s (file \"%s\", line %d)"),
1035 					fields[ZF_NAME],
1036 					zones[i].z_filename,
1037 					zones[i].z_linenum);
1038 				error(buf);
1039 				return (FALSE);
1040 		}
1041 	return (inzsub(fields, nfields, FALSE));
1042 }
1043 
1044 static int
inzcont(fields,nfields)1045 inzcont(fields, nfields)
1046 register char ** const	fields;
1047 const int		nfields;
1048 {
1049 	if (nfields < ZONEC_MINFIELDS || nfields > ZONEC_MAXFIELDS) {
1050 		error(gettext(
1051 		    "wrong number of fields on Zone continuation line"));
1052 		return (FALSE);
1053 	}
1054 	return (inzsub(fields, nfields, TRUE));
1055 }
1056 
1057 static int
inzsub(fields,nfields,iscont)1058 inzsub(fields, nfields, iscont)
1059 register char ** const	fields;
1060 const int		nfields;
1061 const int		iscont;
1062 {
1063 	register char		*cp;
1064 	static struct zone	z;
1065 	register int		i_gmtoff, i_rule, i_format;
1066 	register int		i_untilyear, i_untilmonth;
1067 	register int		i_untilday, i_untiltime;
1068 	register int		hasuntil;
1069 
1070 	if (iscont) {
1071 		i_gmtoff = ZFC_GMTOFF;
1072 		i_rule = ZFC_RULE;
1073 		i_format = ZFC_FORMAT;
1074 		i_untilyear = ZFC_TILYEAR;
1075 		i_untilmonth = ZFC_TILMONTH;
1076 		i_untilday = ZFC_TILDAY;
1077 		i_untiltime = ZFC_TILTIME;
1078 		z.z_name = NULL;
1079 	} else {
1080 		i_gmtoff = ZF_GMTOFF;
1081 		i_rule = ZF_RULE;
1082 		i_format = ZF_FORMAT;
1083 		i_untilyear = ZF_TILYEAR;
1084 		i_untilmonth = ZF_TILMONTH;
1085 		i_untilday = ZF_TILDAY;
1086 		i_untiltime = ZF_TILTIME;
1087 		z.z_name = ecpyalloc(fields[ZF_NAME]);
1088 	}
1089 	z.z_filename = filename;
1090 	z.z_linenum = linenum;
1091 	z.z_gmtoff = gethms(fields[i_gmtoff], gettext("invalid UTC offset"),
1092 		TRUE);
1093 	if ((cp = strchr(fields[i_format], '%')) != 0) {
1094 		if (*++cp != 's' || strchr(cp, '%') != 0) {
1095 			error(gettext("invalid abbreviation format"));
1096 			return (FALSE);
1097 		}
1098 	}
1099 	z.z_rule = ecpyalloc(fields[i_rule]);
1100 	z.z_format = ecpyalloc(fields[i_format]);
1101 	hasuntil = nfields > i_untilyear;
1102 	if (hasuntil) {
1103 		z.z_untilrule.r_filename = filename;
1104 		z.z_untilrule.r_linenum = linenum;
1105 		rulesub(&z.z_untilrule,
1106 			fields[i_untilyear],
1107 			"only",
1108 			"",
1109 			(nfields > i_untilmonth) ?
1110 			fields[i_untilmonth] : "Jan",
1111 			(nfields > i_untilday) ? fields[i_untilday] : "1",
1112 			(nfields > i_untiltime) ? fields[i_untiltime] : "0");
1113 		z.z_untiltime = rpytime(&z.z_untilrule,
1114 			z.z_untilrule.r_loyear);
1115 		if (iscont && nzones > 0 &&
1116 			z.z_untiltime > min_time &&
1117 			z.z_untiltime < max_time &&
1118 			zones[nzones - 1].z_untiltime > min_time &&
1119 			zones[nzones - 1].z_untiltime < max_time &&
1120 			zones[nzones - 1].z_untiltime >= z.z_untiltime) {
1121 				error(gettext(
1122 "Zone continuation line end time is not after end time of previous line"));
1123 				return (FALSE);
1124 		}
1125 	}
1126 	zones = (struct zone *)(void *)erealloc((char *)zones,
1127 		(int)((nzones + 1) * sizeof (*zones)));
1128 	zones[nzones++] = z;
1129 	/*
1130 	 * If there was an UNTIL field on this line,
1131 	 * there's more information about the zone on the next line.
1132 	 */
1133 	return (hasuntil);
1134 }
1135 
1136 #ifdef LEAPSECOND_SUPPORT
1137 static void
inleap(fields,nfields)1138 inleap(fields, nfields)
1139 register char ** const	fields;
1140 const int		nfields;
1141 {
1142 	register const char 		*cp;
1143 	register const struct lookup 	*lp;
1144 	register int			i, j;
1145 	int				year, month, day;
1146 	long				dayoff, tod;
1147 	zic_t				t;
1148 
1149 	if (nfields != LEAP_FIELDS) {
1150 		error(gettext("wrong number of fields on Leap line"));
1151 		return;
1152 	}
1153 	dayoff = 0;
1154 	cp = fields[LP_YEAR];
1155 	if (sscanf(cp, scheck(cp, "%d"), &year) != 1) {
1156 		/*
1157 		 * Leapin' Lizards!
1158 		 */
1159 		error(gettext("invalid leaping year"));
1160 		return;
1161 	}
1162 	j = EPOCH_YEAR;
1163 	while (j != year) {
1164 		if (year > j) {
1165 			i = len_years[isleap(j)];
1166 			++j;
1167 		} else {
1168 			--j;
1169 			i = -len_years[isleap(j)];
1170 		}
1171 		dayoff = oadd(dayoff, eitol(i));
1172 	}
1173 	if ((lp = byword(fields[LP_MONTH], mon_names)) == NULL) {
1174 		error(gettext("invalid month name"));
1175 		return;
1176 	}
1177 	month = lp->l_value;
1178 	j = TM_JANUARY;
1179 	while (j != month) {
1180 		i = len_months[isleap(year)][j];
1181 		dayoff = oadd(dayoff, eitol(i));
1182 		++j;
1183 	}
1184 	cp = fields[LP_DAY];
1185 	if (sscanf(cp, scheck(cp, "%d"), &day) != 1 ||
1186 		day <= 0 || day > len_months[isleap(year)][month]) {
1187 			error(gettext("invalid day of month"));
1188 			return;
1189 	}
1190 	dayoff = oadd(dayoff, eitol(day - 1));
1191 	if (dayoff < 0 && !TYPE_SIGNED(zic_t)) {
1192 		error(gettext("time before zero"));
1193 		return;
1194 	}
1195 	if (dayoff < min_time / SECSPERDAY) {
1196 		error(gettext("time too small"));
1197 		return;
1198 	}
1199 	if (dayoff > max_time / SECSPERDAY) {
1200 		error(gettext("time too large"));
1201 		return;
1202 	}
1203 	t = (zic_t)dayoff * SECSPERDAY;
1204 	tod = gethms(fields[LP_TIME], gettext("invalid time of day"), FALSE);
1205 	cp = fields[LP_CORR];
1206 	{
1207 		register int	positive;
1208 		int		count;
1209 
1210 		if (strcmp(cp, "") == 0) { /* infile() turns "-" into "" */
1211 			positive = FALSE;
1212 			count = 1;
1213 		} else if (strcmp(cp, "--") == 0) {
1214 			positive = FALSE;
1215 			count = 2;
1216 		} else if (strcmp(cp, "+") == 0) {
1217 			positive = TRUE;
1218 			count = 1;
1219 		} else if (strcmp(cp, "++") == 0) {
1220 			positive = TRUE;
1221 			count = 2;
1222 		} else {
1223 			error(gettext("illegal CORRECTION field on Leap line"));
1224 			return;
1225 		}
1226 		if ((lp = byword(fields[LP_ROLL], leap_types)) == NULL) {
1227 			error(gettext(
1228 			    "illegal Rolling/Stationary field on Leap line"));
1229 			return;
1230 		}
1231 		leapadd(tadd(t, tod), positive, lp->l_value, count);
1232 	}
1233 }
1234 #endif /* LEAPSECOND_SUPPORT */
1235 
1236 static void
inlink(fields,nfields)1237 inlink(fields, nfields)
1238 register char ** const	fields;
1239 const int		nfields;
1240 {
1241 	struct link	l;
1242 
1243 	if (nfields != LINK_FIELDS) {
1244 		error(gettext("wrong number of fields on Link line"));
1245 		return;
1246 	}
1247 	if (*fields[LF_FROM] == '\0') {
1248 		error(gettext("blank FROM field on Link line"));
1249 		return;
1250 	}
1251 	if (*fields[LF_TO] == '\0') {
1252 		error(gettext("blank TO field on Link line"));
1253 		return;
1254 	}
1255 	l.l_filename = filename;
1256 	l.l_linenum = linenum;
1257 	l.l_from = ecpyalloc(fields[LF_FROM]);
1258 	l.l_to = ecpyalloc(fields[LF_TO]);
1259 	links = (struct link *)(void *)erealloc((char *)links,
1260 		(int)((nlinks + 1) * sizeof (*links)));
1261 	links[nlinks++] = l;
1262 }
1263 
1264 static void
rulesub(rp,loyearp,hiyearp,typep,monthp,dayp,timep)1265 rulesub(rp, loyearp, hiyearp, typep, monthp, dayp, timep)
1266 register struct rule * const	rp;
1267 const char * const		loyearp;
1268 const char * const		hiyearp;
1269 const char * const		typep;
1270 const char * const		monthp;
1271 const char * const		dayp;
1272 const char * const		timep;
1273 {
1274 	register const struct lookup	*lp;
1275 	register const char		*cp;
1276 	register char			*dp;
1277 	register char			*ep;
1278 
1279 	if ((lp = byword(monthp, mon_names)) == NULL) {
1280 		error(gettext("invalid month name"));
1281 		return;
1282 	}
1283 	rp->r_month = lp->l_value;
1284 	rp->r_todisstd = FALSE;
1285 	rp->r_todisgmt = FALSE;
1286 	dp = ecpyalloc(timep);
1287 	if (*dp != '\0') {
1288 		ep = dp + strlen(dp) - 1;
1289 		switch (lowerit(*ep)) {
1290 			case 's':	/* Standard */
1291 				rp->r_todisstd = TRUE;
1292 				rp->r_todisgmt = FALSE;
1293 				*ep = '\0';
1294 				break;
1295 			case 'w':	/* Wall */
1296 				rp->r_todisstd = FALSE;
1297 				rp->r_todisgmt = FALSE;
1298 				*ep = '\0';
1299 				break;
1300 			case 'g':	/* Greenwich */
1301 			case 'u':	/* Universal */
1302 			case 'z':	/* Zulu */
1303 				rp->r_todisstd = TRUE;
1304 				rp->r_todisgmt = TRUE;
1305 				*ep = '\0';
1306 				break;
1307 		}
1308 	}
1309 	rp->r_tod = gethms(dp, gettext("invalid time of day"), FALSE);
1310 	ifree(dp);
1311 	/*
1312 	 * Year work.
1313 	 */
1314 	cp = loyearp;
1315 	lp = byword(cp, begin_years);
1316 	if (lp != NULL) {
1317 	    switch ((int)lp->l_value) {
1318 		case YR_MINIMUM:
1319 			rp->r_loyear = INT_MIN;
1320 			break;
1321 		case YR_MAXIMUM:
1322 			rp->r_loyear = INT_MAX;
1323 			break;
1324 		default:	/* "cannot happen" */
1325 			(void) fprintf(stderr,
1326 				gettext("%s: panic: Invalid l_value %d\n"),
1327 				progname, lp->l_value);
1328 			exit(EXIT_FAILURE);
1329 	    }
1330 	} else if (sscanf(cp, scheck(cp, "%d"), &rp->r_loyear) != 1) {
1331 		error(gettext("invalid starting year"));
1332 		return;
1333 	} else if (noise) {
1334 		if (rp->r_loyear < min_year_representable)
1335 			warning(gettext(
1336 			    "starting year too low to be represented"));
1337 		else if (rp->r_loyear > max_year_representable)
1338 			warning(gettext(
1339 			    "starting year too high to be represented"));
1340 	}
1341 	cp = hiyearp;
1342 	if ((lp = byword(cp, end_years)) != NULL) {
1343 	    switch ((int)lp->l_value) {
1344 		case YR_MINIMUM:
1345 			rp->r_hiyear = INT_MIN;
1346 			break;
1347 		case YR_MAXIMUM:
1348 			rp->r_hiyear = INT_MAX;
1349 			break;
1350 		case YR_ONLY:
1351 			rp->r_hiyear = rp->r_loyear;
1352 			break;
1353 		default:	/* "cannot happen" */
1354 			(void) fprintf(stderr,
1355 				gettext("%s: panic: Invalid l_value %d\n"),
1356 				progname, lp->l_value);
1357 			exit(EXIT_FAILURE);
1358 	    }
1359 	} else if (sscanf(cp, scheck(cp, "%d"), &rp->r_hiyear) != 1) {
1360 		error(gettext("invalid ending year"));
1361 		return;
1362 	} else if (noise) {
1363 		if (rp->r_loyear < min_year_representable)
1364 			warning(gettext(
1365 			    "ending year too low to be represented"));
1366 		else if (rp->r_loyear > max_year_representable)
1367 			warning(gettext(
1368 			    "ending year too high to be represented"));
1369 	}
1370 	if (rp->r_loyear > rp->r_hiyear) {
1371 		error(gettext("starting year greater than ending year"));
1372 		return;
1373 	}
1374 	if (*typep == '\0')
1375 		rp->r_yrtype = NULL;
1376 	else {
1377 		if (rp->r_loyear == rp->r_hiyear) {
1378 			error(gettext("typed single year"));
1379 			return;
1380 		}
1381 		rp->r_yrtype = ecpyalloc(typep);
1382 	}
1383 	if (rp->r_loyear < min_year && rp->r_loyear > 0)
1384 		min_year = rp->r_loyear;
1385 	/*
1386 	 * Day work.
1387 	 * Accept things such as:
1388 	 *	1
1389 	 *	last-Sunday
1390 	 *	Sun<=20
1391 	 *	Sun>=7
1392 	 */
1393 	dp = ecpyalloc(dayp);
1394 	if ((lp = byword(dp, lasts)) != NULL) {
1395 		rp->r_dycode = DC_DOWLEQ;
1396 		rp->r_wday = lp->l_value;
1397 		rp->r_dayofmonth = len_months[1][rp->r_month];
1398 	} else {
1399 		if ((ep = strchr(dp, '<')) != 0)
1400 			rp->r_dycode = DC_DOWLEQ;
1401 		else if ((ep = strchr(dp, '>')) != 0)
1402 			rp->r_dycode = DC_DOWGEQ;
1403 		else {
1404 			ep = dp;
1405 			rp->r_dycode = DC_DOM;
1406 		}
1407 		if (rp->r_dycode != DC_DOM) {
1408 			*ep++ = 0;
1409 			if (*ep++ != '=') {
1410 				error(gettext("invalid day of month"));
1411 				ifree(dp);
1412 				return;
1413 			}
1414 			if ((lp = byword(dp, wday_names)) == NULL) {
1415 				error(gettext("invalid weekday name"));
1416 				ifree(dp);
1417 				return;
1418 			}
1419 			rp->r_wday = lp->l_value;
1420 		}
1421 		if (sscanf(ep, scheck(ep, "%d"), &rp->r_dayofmonth) != 1 ||
1422 			rp->r_dayofmonth <= 0 ||
1423 			(rp->r_dayofmonth > len_months[1][rp->r_month])) {
1424 				error(gettext("invalid day of month"));
1425 				ifree(dp);
1426 				return;
1427 		}
1428 	}
1429 	ifree(dp);
1430 }
1431 
1432 static void
convert(val,buf)1433 convert(val, buf)
1434 const long	val;
1435 char * const	buf;
1436 {
1437 	register int	i;
1438 	register long	shift;
1439 
1440 	for (i = 0, shift = 24; i < 4; ++i, shift -= 8)
1441 		buf[i] = val >> shift;
1442 }
1443 
1444 static void
puttzcode(val,fp)1445 puttzcode(val, fp)
1446 const long	val;
1447 FILE * const	fp;
1448 {
1449 	char	buf[4];
1450 
1451 	convert(val, buf);
1452 	(void) fwrite((void *)buf, (size_t)sizeof (buf), (size_t)1, fp);
1453 }
1454 
1455 static int
atcomp(avp,bvp)1456 atcomp(avp, bvp)
1457 const void *avp;
1458 const void *bvp;
1459 {
1460 	if (((struct attype *)avp)->at < ((struct attype *)bvp)->at)
1461 		return (-1);
1462 	else if (((struct attype *)avp)->at > ((struct attype *)bvp)->at)
1463 		return (1);
1464 	else	return (0);
1465 }
1466 
1467 static void
writezone(name)1468 writezone(name)
1469 const char * const	name;
1470 {
1471 	register FILE		*fp;
1472 	register int		i, j;
1473 	static char		*fullname;
1474 	static struct tzhead	tzh;
1475 	zic_t			ats[TZ_MAX_TIMES];
1476 	unsigned char		types[TZ_MAX_TIMES];
1477 
1478 	/*
1479 	 * Sort.
1480 	 */
1481 	if (timecnt > 1)
1482 		(void) qsort((void *)attypes, (size_t)timecnt,
1483 			(size_t)sizeof (*attypes), atcomp);
1484 	/*
1485 	 * Optimize.
1486 	 */
1487 	{
1488 		int	fromi;
1489 		int	toi;
1490 
1491 		toi = 0;
1492 		fromi = 0;
1493 		while (fromi < timecnt && attypes[fromi].at < min_time)
1494 			++fromi;
1495 		if (isdsts[0] == 0)
1496 			while (fromi < timecnt && attypes[fromi].type == 0)
1497 				++fromi;	/* handled by default rule */
1498 		for (; fromi < timecnt; ++fromi) {
1499 			if (toi != 0 && ((attypes[fromi].at +
1500 				gmtoffs[attypes[toi - 1].type]) <=
1501 				(attypes[toi - 1].at + gmtoffs[toi == 1 ? 0
1502 				: attypes[toi - 2].type]))) {
1503 					attypes[toi - 1].type =
1504 						attypes[fromi].type;
1505 					continue;
1506 			}
1507 			if (toi == 0 ||
1508 				attypes[toi - 1].type != attypes[fromi].type)
1509 					attypes[toi++] = attypes[fromi];
1510 		}
1511 		timecnt = toi;
1512 	}
1513 	/*
1514 	 * Transfer.
1515 	 */
1516 	for (i = 0; i < timecnt; ++i) {
1517 		ats[i] = attypes[i].at;
1518 		types[i] = attypes[i].type;
1519 	}
1520 	fullname = erealloc(fullname,
1521 		(int)(strlen(directory) + 1 + strlen(name) + 1));
1522 	(void) sprintf(fullname, "%s/%s", directory, name);
1523 	/*
1524 	 * Remove old file, if any, to snap links.
1525 	 */
1526 	if (!itsdir(fullname) && remove(fullname) != 0 && errno != ENOENT) {
1527 		const char *e = strerror(errno);
1528 
1529 		(void) fprintf(stderr, gettext("%s: Can't remove %s: %s\n"),
1530 			progname, fullname, e);
1531 		exit(EXIT_FAILURE);
1532 	}
1533 	if ((fp = fopen(fullname, "wb")) == NULL) {
1534 		if (mkdirs(fullname) != 0)
1535 			exit(EXIT_FAILURE);
1536 		if ((fp = fopen(fullname, "wb")) == NULL) {
1537 			const char *e = strerror(errno);
1538 			(void) fprintf(stderr, gettext(
1539 				"%s: Can't create %s: %s\n"),
1540 				progname, fullname, e);
1541 			exit(EXIT_FAILURE);
1542 		}
1543 	}
1544 	convert(eitol(typecnt), tzh.tzh_ttisgmtcnt);
1545 	convert(eitol(typecnt), tzh.tzh_ttisstdcnt);
1546 	convert(eitol(leapcnt), tzh.tzh_leapcnt);
1547 	convert(eitol(timecnt), tzh.tzh_timecnt);
1548 	convert(eitol(typecnt), tzh.tzh_typecnt);
1549 	convert(eitol(charcnt), tzh.tzh_charcnt);
1550 	(void) strncpy(tzh.tzh_magic, TZ_MAGIC, sizeof (tzh.tzh_magic));
1551 #define	DO(field)	(void) fwrite((void *) tzh.field, \
1552 			(size_t)sizeof (tzh.field), (size_t)1, fp)
1553 	DO(tzh_magic);
1554 	DO(tzh_reserved);
1555 	DO(tzh_ttisgmtcnt);
1556 	DO(tzh_ttisstdcnt);
1557 	DO(tzh_leapcnt);
1558 	DO(tzh_timecnt);
1559 	DO(tzh_typecnt);
1560 	DO(tzh_charcnt);
1561 #undef DO
1562 	for (i = 0; i < timecnt; ++i) {
1563 		j = leapcnt;
1564 		while (--j >= 0)
1565 			if (ats[i] >= trans[j]) {
1566 				ats[i] = tadd(ats[i], corr[j]);
1567 				break;
1568 			}
1569 		puttzcode((long)ats[i], fp);
1570 	}
1571 	if (timecnt > 0)
1572 		(void) fwrite((void *)types, (size_t)sizeof (types[0]),
1573 			(size_t)timecnt, fp);
1574 	for (i = 0; i < typecnt; ++i) {
1575 		puttzcode((long)gmtoffs[i], fp);
1576 		(void) putc(isdsts[i], fp);
1577 		(void) putc(abbrinds[i], fp);
1578 	}
1579 	if (charcnt != 0)
1580 		(void) fwrite((void *)chars, (size_t)sizeof (chars[0]),
1581 			(size_t)charcnt, fp);
1582 	for (i = 0; i < leapcnt; ++i) {
1583 		if (roll[i]) {
1584 			if (timecnt == 0 || trans[i] < ats[0]) {
1585 				j = 0;
1586 				while (isdsts[j])
1587 					if (++j >= typecnt) {
1588 						j = 0;
1589 						break;
1590 					}
1591 			} else {
1592 				j = 1;
1593 				while (j < timecnt && trans[i] >= ats[j])
1594 					++j;
1595 				j = types[j - 1];
1596 			}
1597 			puttzcode((long)tadd(trans[i], -gmtoffs[j]), fp);
1598 		} else	puttzcode((long)trans[i], fp);
1599 		puttzcode((long)corr[i], fp);
1600 	}
1601 	for (i = 0; i < typecnt; ++i)
1602 		(void) putc(ttisstds[i], fp);
1603 	for (i = 0; i < typecnt; ++i)
1604 		(void) putc(ttisgmts[i], fp);
1605 	if (ferror(fp) || fclose(fp)) {
1606 		(void) fprintf(stderr, gettext("%s: Error writing %s\n"),
1607 			progname, fullname);
1608 		exit(EXIT_FAILURE);
1609 	}
1610 }
1611 
1612 static void
doabbr(abbr,format,letters,isdst)1613 doabbr(abbr, format, letters, isdst)
1614 char * const		abbr;
1615 const char * const	format;
1616 const char * const	letters;
1617 const int		isdst;
1618 {
1619 	if (strchr(format, '/') == NULL) {
1620 		if (letters == NULL)
1621 			(void) strcpy(abbr, format);
1622 		else
1623 			(void) sprintf(abbr, format, letters);
1624 	} else if (isdst)
1625 		(void) strcpy(abbr, strchr(format, '/') + 1);
1626 	else {
1627 		(void) strcpy(abbr, format);
1628 		*strchr(abbr, '/') = '\0';
1629 	}
1630 }
1631 
1632 static void
outzone(zpfirst,zonecount)1633 outzone(zpfirst, zonecount)
1634 const struct zone * const	zpfirst;
1635 const int			zonecount;
1636 {
1637 	register const struct zone	*zp;
1638 	register struct rule		*rp;
1639 	register int			i, j;
1640 	register int			usestart, useuntil;
1641 	register zic_t			starttime, untiltime;
1642 	register long			gmtoff;
1643 	register long			stdoff;
1644 	register int			year;
1645 	register long			startoff;
1646 	register int			startttisstd;
1647 	register int			startttisgmt;
1648 	register int			type;
1649 	char				startbuf[BUFSIZ];
1650 
1651 	INITIALIZE(untiltime);
1652 	INITIALIZE(starttime);
1653 	/*
1654 	 * Now. . .finally. . .generate some useful data!
1655 	 */
1656 	timecnt = 0;
1657 	typecnt = 0;
1658 	charcnt = 0;
1659 	/*
1660 	 * Thanks to Earl Chew
1661 	 * for noting the need to unconditionally initialize startttisstd.
1662 	 */
1663 	startttisstd = FALSE;
1664 	startttisgmt = FALSE;
1665 	for (i = 0; i < zonecount; ++i) {
1666 		/*
1667 		 * A guess that may well be corrected later.
1668 		 */
1669 		stdoff = 0;
1670 		zp = &zpfirst[i];
1671 		usestart = i > 0 && (zp - 1)->z_untiltime > min_time;
1672 		useuntil = i < (zonecount - 1);
1673 		if (useuntil && zp->z_untiltime <= min_time)
1674 			continue;
1675 		gmtoff = zp->z_gmtoff;
1676 		eat(zp->z_filename, zp->z_linenum);
1677 		*startbuf = '\0';
1678 		startoff = zp->z_gmtoff;
1679 		if (zp->z_nrules == 0) {
1680 			stdoff = zp->z_stdoff;
1681 			doabbr(startbuf, zp->z_format,
1682 				(char *)NULL, stdoff != 0);
1683 			type = addtype(oadd(zp->z_gmtoff, stdoff),
1684 				startbuf, stdoff != 0, startttisstd,
1685 				startttisgmt);
1686 			if (usestart) {
1687 				addtt(starttime, type);
1688 				usestart = FALSE;
1689 			} else if (stdoff != 0)
1690 				addtt(min_time, type);
1691 		} else
1692 		    for (year = min_year; year <= max_year; ++year) {
1693 			if (useuntil && year > zp->z_untilrule.r_hiyear)
1694 				break;
1695 			/*
1696 			 * Mark which rules to do in the current year.
1697 			 * For those to do, calculate rpytime(rp, year);
1698 			 */
1699 			for (j = 0; j < zp->z_nrules; ++j) {
1700 				rp = &zp->z_rules[j];
1701 				eats(zp->z_filename, zp->z_linenum,
1702 					rp->r_filename, rp->r_linenum);
1703 				rp->r_todo = year >= rp->r_loyear &&
1704 						year <= rp->r_hiyear &&
1705 						yearistype(year, rp->r_yrtype);
1706 				if (rp->r_todo)
1707 					rp->r_temp = rpytime(rp, year);
1708 			}
1709 			for (;;) {
1710 				register int	k;
1711 				register zic_t	jtime, ktime;
1712 				register long	offset;
1713 				char		buf[BUFSIZ];
1714 
1715 				INITIALIZE(ktime);
1716 				if (useuntil) {
1717 					/*
1718 					 * Turn untiltime into UTC * assuming
1719 					 * the current gmtoff and stdoff values.
1720 					 */
1721 					untiltime = zp->z_untiltime;
1722 					if (!zp->z_untilrule.r_todisgmt)
1723 						untiltime = tadd(untiltime,
1724 							-gmtoff);
1725 					if (!zp->z_untilrule.r_todisstd)
1726 						untiltime = tadd(untiltime,
1727 							-stdoff);
1728 				}
1729 				/*
1730 				 * Find the rule (of those to do, if any)
1731 				 * that takes effect earliest in the year.
1732 				 */
1733 				k = -1;
1734 				for (j = 0; j < zp->z_nrules; ++j) {
1735 					rp = &zp->z_rules[j];
1736 					if (!rp->r_todo)
1737 						continue;
1738 					eats(zp->z_filename, zp->z_linenum,
1739 						rp->r_filename, rp->r_linenum);
1740 					offset = rp->r_todisgmt ? 0 : gmtoff;
1741 					if (!rp->r_todisstd)
1742 						offset = oadd(offset, stdoff);
1743 					jtime = rp->r_temp;
1744 					if (jtime == min_time ||
1745 						jtime == max_time)
1746 							continue;
1747 					jtime = tadd(jtime, -offset);
1748 					if (k < 0 || jtime < ktime) {
1749 						k = j;
1750 						ktime = jtime;
1751 					}
1752 				}
1753 				if (k < 0)
1754 					break;	/* go on to next year */
1755 				rp = &zp->z_rules[k];
1756 				rp->r_todo = FALSE;
1757 				if (useuntil && ktime >= untiltime)
1758 					break;
1759 				stdoff = rp->r_stdoff;
1760 				if (usestart && ktime == starttime)
1761 					usestart = FALSE;
1762 				if (usestart) {
1763 					if (ktime < starttime) {
1764 						startoff = oadd(zp->z_gmtoff,
1765 							stdoff);
1766 						doabbr(startbuf, zp->z_format,
1767 							rp->r_abbrvar,
1768 							rp->r_stdoff != 0);
1769 						continue;
1770 					}
1771 					if (*startbuf == '\0' &&
1772 					    startoff == oadd(zp->z_gmtoff,
1773 					    stdoff)) {
1774 						doabbr(startbuf, zp->z_format,
1775 							rp->r_abbrvar,
1776 							rp->r_stdoff != 0);
1777 					}
1778 				}
1779 				eats(zp->z_filename, zp->z_linenum,
1780 					rp->r_filename, rp->r_linenum);
1781 				doabbr(buf, zp->z_format, rp->r_abbrvar,
1782 					rp->r_stdoff != 0);
1783 				offset = oadd(zp->z_gmtoff, rp->r_stdoff);
1784 				type = addtype(offset, buf, rp->r_stdoff != 0,
1785 					rp->r_todisstd, rp->r_todisgmt);
1786 				addtt(ktime, type);
1787 			}
1788 		    }
1789 		if (usestart) {
1790 			if (*startbuf == '\0' &&
1791 				zp->z_format != NULL &&
1792 				strchr(zp->z_format, '%') == NULL &&
1793 				strchr(zp->z_format, '/') == NULL)
1794 					(void) strcpy(startbuf, zp->z_format);
1795 			eat(zp->z_filename, zp->z_linenum);
1796 			if (*startbuf == '\0')
1797 				error(gettext(
1798 "can't determine time zone abbrevation to use just after until time"));
1799 			else	addtt(starttime,
1800 					addtype(startoff, startbuf,
1801 						startoff != zp->z_gmtoff,
1802 						startttisstd,
1803 						startttisgmt));
1804 		}
1805 		/*
1806 		 * Now we may get to set starttime for the next zone line.
1807 		 */
1808 		if (useuntil) {
1809 			startttisstd = zp->z_untilrule.r_todisstd;
1810 			startttisgmt = zp->z_untilrule.r_todisgmt;
1811 			starttime = zp->z_untiltime;
1812 			if (!startttisstd)
1813 				starttime = tadd(starttime, -stdoff);
1814 			if (!startttisgmt)
1815 				starttime = tadd(starttime, -gmtoff);
1816 		}
1817 	}
1818 	writezone(zpfirst->z_name);
1819 }
1820 
1821 static void
addtt(starttime,type)1822 addtt(starttime, type)
1823 const zic_t	starttime;
1824 int		type;
1825 {
1826 	if (starttime <= min_time ||
1827 		(timecnt == 1 && attypes[0].at < min_time)) {
1828 		gmtoffs[0] = gmtoffs[type];
1829 		isdsts[0] = isdsts[type];
1830 		ttisstds[0] = ttisstds[type];
1831 		ttisgmts[0] = ttisgmts[type];
1832 		if (abbrinds[type] != 0)
1833 			(void) strcpy(chars, &chars[abbrinds[type]]);
1834 		abbrinds[0] = 0;
1835 		charcnt = strlen(chars) + 1;
1836 		typecnt = 1;
1837 		timecnt = 0;
1838 		type = 0;
1839 	}
1840 	if (timecnt >= TZ_MAX_TIMES) {
1841 		error(gettext("too many transitions?!"));
1842 		exit(EXIT_FAILURE);
1843 	}
1844 	attypes[timecnt].at = starttime;
1845 	attypes[timecnt].type = type;
1846 	++timecnt;
1847 }
1848 
1849 static int
addtype(gmtoff,abbr,isdst,ttisstd,ttisgmt)1850 addtype(gmtoff, abbr, isdst, ttisstd, ttisgmt)
1851 const long		gmtoff;
1852 const char * const	abbr;
1853 const int		isdst;
1854 const int		ttisstd;
1855 const int		ttisgmt;
1856 {
1857 	register int	i, j;
1858 
1859 	if (isdst != TRUE && isdst != FALSE) {
1860 		error(gettext(
1861 		    "internal error - addtype called with bad isdst"));
1862 		exit(EXIT_FAILURE);
1863 	}
1864 	if (ttisstd != TRUE && ttisstd != FALSE) {
1865 		error(gettext(
1866 		    "internal error - addtype called with bad ttisstd"));
1867 		exit(EXIT_FAILURE);
1868 	}
1869 	if (ttisgmt != TRUE && ttisgmt != FALSE) {
1870 		error(gettext(
1871 		    "internal error - addtype called with bad ttisgmt"));
1872 		exit(EXIT_FAILURE);
1873 	}
1874 	/*
1875 	 * See if there's already an entry for this zone type.
1876 	 * If so, just return its index.
1877 	 */
1878 	for (i = 0; i < typecnt; ++i) {
1879 		if (gmtoff == gmtoffs[i] && isdst == isdsts[i] &&
1880 			strcmp(abbr, &chars[abbrinds[i]]) == 0 &&
1881 			ttisstd == ttisstds[i] &&
1882 			ttisgmt == ttisgmts[i])
1883 				return (i);
1884 	}
1885 	/*
1886 	 * There isn't one; add a new one, unless there are already too
1887 	 * many.
1888 	 */
1889 	if (typecnt >= TZ_MAX_TYPES) {
1890 		error(gettext("too many local time types"));
1891 		exit(EXIT_FAILURE);
1892 	}
1893 	if (!(-1L - 2147483647L <= gmtoff && gmtoff <= 2147483647L)) {
1894 		error(gettext("UTC offset out of range"));
1895 		exit(EXIT_FAILURE);
1896 	}
1897 	gmtoffs[i] = gmtoff;
1898 	isdsts[i] = isdst;
1899 	ttisstds[i] = ttisstd;
1900 	ttisgmts[i] = ttisgmt;
1901 
1902 	for (j = 0; j < charcnt; ++j)
1903 		if (strcmp(&chars[j], abbr) == 0)
1904 			break;
1905 	if (j == charcnt)
1906 		newabbr(abbr);
1907 	abbrinds[i] = j;
1908 	++typecnt;
1909 	return (i);
1910 }
1911 
1912 #ifdef LEAPSECOND_SUPPORT
1913 static void
leapadd(t,positive,rolling,count)1914 leapadd(t, positive, rolling, count)
1915 const zic_t	t;
1916 const int	positive;
1917 const int	rolling;
1918 int		count;
1919 {
1920 	register int	i, j;
1921 
1922 	if (leapcnt + (positive ? count : 1) > TZ_MAX_LEAPS) {
1923 		error(gettext("too many leap seconds"));
1924 		exit(EXIT_FAILURE);
1925 	}
1926 	for (i = 0; i < leapcnt; ++i)
1927 		if (t <= trans[i]) {
1928 			if (t == trans[i]) {
1929 				error(gettext("repeated leap second moment"));
1930 				exit(EXIT_FAILURE);
1931 			}
1932 			break;
1933 		}
1934 	do {
1935 		for (j = leapcnt; j > i; --j) {
1936 			trans[j] = trans[j - 1];
1937 			corr[j] = corr[j - 1];
1938 			roll[j] = roll[j - 1];
1939 		}
1940 		trans[i] = t;
1941 		corr[i] = positive ? 1L : eitol(-count);
1942 		roll[i] = rolling;
1943 		++leapcnt;
1944 	} while (positive && --count != 0);
1945 }
1946 #endif /* LEAPSECOND_SUPPORT */
1947 
1948 #ifdef LEAPSECOND_SUPPORT
1949 static void
adjleap(void)1950 adjleap(void)
1951 {
1952 	register int	i;
1953 	register long	last = 0;
1954 
1955 	/*
1956 	 * propagate leap seconds forward
1957 	 */
1958 	for (i = 0; i < leapcnt; ++i) {
1959 		trans[i] = tadd(trans[i], last);
1960 		last = corr[i] += last;
1961 	}
1962 }
1963 #endif /* LEAPSECOND_SUPPORT */
1964 
1965 static int
yearistype(year,type)1966 yearistype(year, type)
1967 const int		year;
1968 const char * const	type;
1969 {
1970 	static char	*buf;
1971 	int		result;
1972 
1973 	if (type == NULL || *type == '\0')
1974 		return (TRUE);
1975 #if defined(sun)
1976 	if (strcmp(type, "uspres") == 0)
1977 		return ((year % 4) == 0);
1978 	if (strcmp(type, "nonpres") == 0)
1979 		return ((year % 4) != 0);
1980 	if (strcmp(type, "even") == 0)
1981 		return ((year % 2) == 0);
1982 	if (strcmp(type, "odd") == 0)
1983 		return ((year % 2) != 0);
1984 #endif /* defined(sun) */
1985 
1986 	buf = erealloc(buf, (int)(132 + strlen(yitcommand) + strlen(type)));
1987 	(void) sprintf(buf, "%s %d %s", yitcommand, year, type);
1988 	result = system(buf);
1989 	if (WIFEXITED(result)) {
1990 		switch (WEXITSTATUS(result)) {
1991 		case 0:
1992 			return (TRUE);
1993 		case 1:
1994 			return (FALSE);
1995 		}
1996 	}
1997 	error(gettext("Wild result from command execution"));
1998 	(void) fprintf(stderr, gettext("%s: command was '%s', result was %d\n"),
1999 		progname, buf, result);
2000 	for (;;)
2001 		exit(EXIT_FAILURE);
2002 }
2003 
2004 static int
lowerit(a)2005 lowerit(a)
2006 int	a;
2007 {
2008 	a = (unsigned char) a;
2009 	return ((isascii(a) && isupper(a)) ? tolower(a) : a);
2010 }
2011 
2012 static int
ciequal(ap,bp)2013 ciequal(ap, bp)		/* case-insensitive equality */
2014 register const char *ap;
2015 register const char *bp;
2016 {
2017 	while (lowerit(*ap) == lowerit(*bp++))
2018 		if (*ap++ == '\0')
2019 			return (TRUE);
2020 	return (FALSE);
2021 }
2022 
2023 static int
itsabbr(abbr,word)2024 itsabbr(abbr, word)
2025 register const char *abbr;
2026 register const char *word;
2027 {
2028 	if (lowerit(*abbr) != lowerit(*word))
2029 		return (FALSE);
2030 	++word;
2031 	while (*++abbr != '\0')
2032 		do {
2033 			if (*word == '\0')
2034 				return (FALSE);
2035 		} while (lowerit(*word++) != lowerit(*abbr));
2036 	return (TRUE);
2037 }
2038 
2039 static const struct lookup *
byword(word,table)2040 byword(word, table)
2041 register const char * const		word;
2042 register const struct lookup * const	table;
2043 {
2044 	register const struct lookup *foundlp;
2045 	register const struct lookup *lp;
2046 
2047 	if (word == NULL || table == NULL)
2048 		return (NULL);
2049 	/*
2050 	 * Look for exact match.
2051 	 */
2052 	for (lp = table; lp->l_word != NULL; ++lp)
2053 		if (ciequal(word, lp->l_word))
2054 			return (lp);
2055 	/*
2056 	 * Look for inexact match.
2057 	 */
2058 	foundlp = NULL;
2059 	for (lp = table; lp->l_word != NULL; ++lp)
2060 		if (itsabbr(word, lp->l_word)) {
2061 			if (foundlp == NULL)
2062 				foundlp = lp;
2063 			else	return (NULL);	/* multiple inexact matches */
2064 		}
2065 	return (foundlp);
2066 }
2067 
2068 static char **
getfields(cp)2069 getfields(cp)
2070 register char *cp;
2071 {
2072 	register char 	*dp;
2073 	register char	**array;
2074 	register int	nsubs;
2075 
2076 	if (cp == NULL)
2077 		return (NULL);
2078 	array = (char **)(void *)
2079 		emalloc((int)((strlen(cp) + 1) * sizeof (*array)));
2080 	nsubs = 0;
2081 	for (;;) {
2082 		while (isascii(*cp) && isspace((unsigned char) *cp))
2083 			++cp;
2084 		if (*cp == '\0' || *cp == '#')
2085 			break;
2086 		array[nsubs++] = dp = cp;
2087 		do {
2088 			if ((*dp = *cp++) != '"')
2089 				++dp;
2090 			else while ((*dp = *cp++) != '"')
2091 				if (*dp != '\0')
2092 					++dp;
2093 				else {
2094 					error(gettext(
2095 					    "Odd number of quotation marks"));
2096 					exit(1);
2097 				}
2098 		} while (*cp != '\0' && *cp != '#' &&
2099 			(!isascii(*cp) || !isspace((unsigned char) *cp)));
2100 		if (isascii(*cp) && isspace((unsigned char) *cp))
2101 			++cp;
2102 		*dp = '\0';
2103 	}
2104 	array[nsubs] = NULL;
2105 	return (array);
2106 }
2107 
2108 static long
oadd(t1,t2)2109 oadd(t1, t2)
2110 const long	t1;
2111 const long	t2;
2112 {
2113 	register long	t;
2114 
2115 	t = t1 + t2;
2116 	if ((t2 > 0 && t <= t1) || (t2 < 0 && t >= t1)) {
2117 		error(gettext("time overflow"));
2118 		exit(EXIT_FAILURE);
2119 	}
2120 	return (t);
2121 }
2122 
2123 static zic_t
tadd(t1,t2)2124 tadd(t1, t2)
2125 const zic_t	t1;
2126 const long	t2;
2127 {
2128 	register zic_t	t;
2129 
2130 	if (t1 == max_time && t2 > 0)
2131 		return (max_time);
2132 	if (t1 == min_time && t2 < 0)
2133 		return (min_time);
2134 	t = t1 + t2;
2135 	if ((t2 > 0 && t <= t1) || (t2 < 0 && t >= t1)) {
2136 		error(gettext("time overflow"));
2137 		exit(EXIT_FAILURE);
2138 	}
2139 	return (t);
2140 }
2141 
2142 /*
2143  * Given a rule, and a year, compute the date - in seconds since January 1,
2144  * 1970, 00:00 LOCAL time - in that year that the rule refers to.
2145  */
2146 
2147 static zic_t
rpytime(rp,wantedy)2148 rpytime(rp, wantedy)
2149 register const struct rule * const	rp;
2150 register const int			wantedy;
2151 {
2152 	register int	y, m, i;
2153 	register long	dayoff;			/* with a nod to Margaret O. */
2154 	register zic_t	t;
2155 
2156 	if (wantedy == INT_MIN)
2157 		return (min_time);
2158 	if (wantedy == INT_MAX)
2159 		return (max_time);
2160 	dayoff = 0;
2161 	m = TM_JANUARY;
2162 	y = EPOCH_YEAR;
2163 	while (wantedy != y) {
2164 		if (wantedy > y) {
2165 			i = len_years[isleap(y)];
2166 			++y;
2167 		} else {
2168 			--y;
2169 			i = -len_years[isleap(y)];
2170 		}
2171 		dayoff = oadd(dayoff, eitol(i));
2172 	}
2173 	while (m != rp->r_month) {
2174 		i = len_months[isleap(y)][m];
2175 		dayoff = oadd(dayoff, eitol(i));
2176 		++m;
2177 	}
2178 	i = rp->r_dayofmonth;
2179 	if (m == TM_FEBRUARY && i == 29 && !isleap(y)) {
2180 		if (rp->r_dycode == DC_DOWLEQ)
2181 			--i;
2182 		else {
2183 			error(gettext("use of 2/29 in non leap-year"));
2184 			exit(EXIT_FAILURE);
2185 		}
2186 	}
2187 	--i;
2188 	dayoff = oadd(dayoff, eitol(i));
2189 	if (rp->r_dycode == DC_DOWGEQ || rp->r_dycode == DC_DOWLEQ) {
2190 		register long	wday;
2191 
2192 #define	LDAYSPERWEEK	((long)DAYSPERWEEK)
2193 		wday = eitol(EPOCH_WDAY);
2194 		/*
2195 		 * Don't trust mod of negative numbers.
2196 		 */
2197 		if (dayoff >= 0)
2198 			wday = (wday + dayoff) % LDAYSPERWEEK;
2199 		else {
2200 			wday -= ((-dayoff) % LDAYSPERWEEK);
2201 			if (wday < 0)
2202 				wday += LDAYSPERWEEK;
2203 		}
2204 		while (wday != eitol(rp->r_wday))
2205 			if (rp->r_dycode == DC_DOWGEQ) {
2206 				dayoff = oadd(dayoff, (long)1);
2207 				if (++wday >= LDAYSPERWEEK)
2208 					wday = 0;
2209 				++i;
2210 			} else {
2211 				dayoff = oadd(dayoff, (long)-1);
2212 				if (--wday < 0)
2213 					wday = LDAYSPERWEEK - 1;
2214 				--i;
2215 			}
2216 		if (i < 0 || i >= len_months[isleap(y)][m]) {
2217 			if (noise)
2218 				warning(gettext("rule goes past start/end of "
2219 				    "month--will not work with pre-2004 "
2220 				    "versions of zic"));
2221 		}
2222 	}
2223 	if (dayoff < 0 && !TYPE_SIGNED(zic_t))
2224 		return (min_time);
2225 	if (dayoff < min_time / SECSPERDAY)
2226 		return (min_time);
2227 	if (dayoff > max_time / SECSPERDAY)
2228 		return (max_time);
2229 	t = (zic_t)dayoff * SECSPERDAY;
2230 	return (tadd(t, rp->r_tod));
2231 }
2232 
2233 static void
newabbr(const char * const string)2234 newabbr(const char * const string)
2235 {
2236 	register int	i;
2237 
2238 	if (strcmp(string, GRANDPARENTED) != 0) {
2239 		register const char *cp;
2240 		register char *wp;
2241 
2242 		cp = string;
2243 		wp = NULL;
2244 		while (isalpha(*cp) || ('0' <= *cp && *cp <= '9') ||
2245 		    *cp == '-' || *cp == '+') {
2246 			++cp;
2247 		}
2248 		if (noise && cp - string < 3)
2249 			wp = gettext(("time zone abbreviation has less than 3 "
2250 			    "alphabetics"));
2251 		if (wp == NULL && cp - string > ZIC_MAX_ABBR_LEN_WO_WARN)
2252 			wp = gettext(("time zone abbreviation has too many "
2253 			    "characters"));
2254 		if (wp == NULL && (*cp == '+' || *cp == '-')) {
2255 			++cp;
2256 			if (isascii(*cp) && isdigit(*cp))
2257 				if (*cp++ == '1' && *cp >= '0' && *cp <= '4')
2258 					++cp;
2259 		}
2260 		if (wp == NULL && *cp != '\0')
2261 			wp = gettext("time zone abbreviation differs from "
2262 			    "POSIX standard");
2263 		if (wp != NULL) {
2264 			wp = ecpyalloc(wp);
2265 			wp = ecatalloc(wp, " (");
2266 			wp = ecatalloc(wp, string);
2267 			wp = ecatalloc(wp, ")");
2268 			warning(wp);
2269 			ifree(wp);
2270 		}
2271 	}
2272 	i = strlen(string) + 1;
2273 	if (charcnt + i > TZ_MAX_CHARS) {
2274 		error(gettext("too many, or too long, time zone "
2275 		    "abbreviations"));
2276 		exit(EXIT_FAILURE);
2277 	}
2278 	(void) strcpy(&chars[charcnt], string);
2279 	charcnt += eitol(i);
2280 }
2281 
2282 static int
mkdirs(argname)2283 mkdirs(argname)
2284 char *argname;
2285 {
2286 	register char *name;
2287 	register char *cp;
2288 
2289 	if (argname == NULL || *argname == '\0')
2290 		return (0);
2291 	cp = name = ecpyalloc(argname);
2292 	while ((cp = strchr(cp + 1, '/')) != 0) {
2293 		*cp = '\0';
2294 		if (!itsdir(name)) {
2295 			/*
2296 			 * It doesn't seem to exist, so we try to create it.
2297 			 * Creation may fail because of the directory being
2298 			 * created by some other multiprocessor, so we get
2299 			 * to do extra checking.
2300 			 */
2301 			if (mkdir(name, MKDIR_UMASK) != 0) {
2302 				const char *e = strerror(errno);
2303 
2304 				if (errno != EEXIST || !itsdir(name)) {
2305 					(void) fprintf(stderr, gettext(
2306 				    "%s: Can't create directory %s: %s\n"),
2307 						progname, name, e);
2308 					ifree(name);
2309 					return (-1);
2310 				}
2311 			}
2312 		}
2313 		*cp = '/';
2314 	}
2315 	ifree(name);
2316 	return (0);
2317 }
2318 
2319 static long
eitol(i)2320 eitol(i)
2321 const int	i;
2322 {
2323 	long	l;
2324 
2325 	l = i;
2326 	if ((i < 0 && l >= 0) || (i == 0 && l != 0) || (i > 0 && l <= 0)) {
2327 		(void) fprintf(stderr,
2328 			gettext("%s: %d did not sign extend correctly\n"),
2329 			progname, i);
2330 		exit(EXIT_FAILURE);
2331 	}
2332 	return (l);
2333 }
2334 
2335 /*
2336  * UNIX was a registered trademark of The Open Group in 2003.
2337  */
2338