PostgreSQL Source Code  git master
zic.c
Go to the documentation of this file.
1 /* Compile .zi time zone data into TZif binary files. */
2 
3 /*
4  * This file is in the public domain, so clarified as of
5  * 2006-07-17 by Arthur David Olson.
6  *
7  * IDENTIFICATION
8  * src/timezone/zic.c
9  */
10 
11 #include "postgres_fe.h"
12 
13 #include <fcntl.h>
14 #include <sys/stat.h>
15 #include <time.h>
16 
17 #include "pg_getopt.h"
18 
19 #include "private.h"
20 #include "tzfile.h"
21 
22 #define ZIC_VERSION_PRE_2013 '2'
23 #define ZIC_VERSION '3'
24 
25 typedef int64 zic_t;
26 #define ZIC_MIN PG_INT64_MIN
27 #define ZIC_MAX PG_INT64_MAX
28 
29 #ifndef ZIC_MAX_ABBR_LEN_WO_WARN
30 #define ZIC_MAX_ABBR_LEN_WO_WARN 6
31 #endif /* !defined ZIC_MAX_ABBR_LEN_WO_WARN */
32 
33 #ifndef WIN32
34 #ifdef S_IRUSR
35 #define MKDIR_UMASK (S_IRUSR|S_IWUSR|S_IXUSR|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH)
36 #else
37 #define MKDIR_UMASK 0755
38 #endif
39 #endif
40 /* Port to native MS-Windows and to ancient UNIX. */
41 #if !defined S_ISDIR && defined S_IFDIR && defined S_IFMT
42 #define S_ISDIR(mode) (((mode) & S_IFMT) == S_IFDIR)
43 #endif
44 
45 /* The maximum ptrdiff_t value, for pre-C99 platforms. */
46 #ifndef PTRDIFF_MAX
47 static ptrdiff_t const PTRDIFF_MAX = MAXVAL(ptrdiff_t, TYPE_BIT(ptrdiff_t));
48 #endif
49 
50 /*
51  * The type for line numbers. In Postgres, use %d to format them; upstream
52  * uses PRIdMAX but we prefer not to rely on that, not least because it
53  * results in platform-dependent strings to be translated.
54  */
55 typedef int lineno_t;
56 
57 struct rule
58 {
59  const char *r_filename;
61  const char *r_name;
62 
63  zic_t r_loyear; /* for example, 1986 */
64  zic_t r_hiyear; /* for example, 1986 */
65  bool r_lowasnum;
66  bool r_hiwasnum;
67 
68  int r_month; /* 0..11 */
69 
70  int r_dycode; /* see below */
72  int r_wday;
73 
74  zic_t r_tod; /* time from midnight */
75  bool r_todisstd; /* is r_tod standard time? */
76  bool r_todisut; /* is r_tod UT? */
77  bool r_isdst; /* is this daylight saving time? */
78  zic_t r_save; /* offset from standard time */
79  const char *r_abbrvar; /* variable part of abbreviation */
80 
81  bool r_todo; /* a rule to do (used in outzone) */
82  zic_t r_temp; /* used in outzone */
83 };
84 
85 /*
86  * r_dycode r_dayofmonth r_wday
87  */
88 
89 #define DC_DOM 0 /* 1..31 */ /* unused */
90 #define DC_DOWGEQ 1 /* 1..31 */ /* 0..6 (Sun..Sat) */
91 #define DC_DOWLEQ 2 /* 1..31 */ /* 0..6 (Sun..Sat) */
92 
93 struct zone
94 {
95  const char *z_filename;
97 
98  const char *z_name;
100  char *z_rule;
101  const char *z_format;
103 
104  bool z_isdst;
106 
107  struct rule *z_rules;
108  ptrdiff_t z_nrules;
109 
110  struct rule z_untilrule;
112 };
113 
114 extern int link(const char *target, const char *linkname);
115 #ifndef AT_SYMLINK_FOLLOW
116 #define linkat(targetdir, target, linknamedir, linkname, flag) \
117  (itssymlink(target) ? (errno = ENOTSUP, -1) : link(target, linkname))
118 #endif
119 
120 static void memory_exhausted(const char *msg) pg_attribute_noreturn();
121 static void verror(const char *string, va_list args) pg_attribute_printf(1, 0);
122 static void error(const char *string,...) pg_attribute_printf(1, 2);
123 static void warning(const char *string,...) pg_attribute_printf(1, 2);
124 static void usage(FILE *stream, int status) pg_attribute_noreturn();
125 static void addtt(zic_t starttime, int type);
126 static int addtype(zic_t utoff, char const *abbr,
127  bool isdst, bool ttisstd, bool ttisut);
128 static void leapadd(zic_t t, int correction, int rolling);
129 static void adjleap(void);
130 static void associate(void);
131 static void dolink(char const *target, char const *linkname,
132  bool staysymlink);
133 static char **getfields(char *cp);
134 static zic_t gethms(const char *string, const char *errstring);
135 static zic_t getsave(char *field, bool *isdst);
136 static void inexpires(char **fields, int nfields);
137 static void infile(const char *name);
138 static void inleap(char **fields, int nfields);
139 static void inlink(char **fields, int nfields);
140 static void inrule(char **fields, int nfields);
141 static bool inzcont(char **fields, int nfields);
142 static bool inzone(char **fields, int nfields);
143 static bool inzsub(char **fields, int nfields, bool iscont);
144 static bool itsdir(char const *name);
145 static bool itssymlink(char const *name);
146 static bool is_alpha(char a);
147 static char lowerit(char a);
148 static void mkdirs(char const *argname, bool ancestors);
149 static void newabbr(const char *string);
150 static zic_t oadd(zic_t t1, zic_t t2);
151 static void outzone(const struct zone *zpfirst, ptrdiff_t zonecount);
152 static zic_t rpytime(const struct rule *rp, zic_t wantedy);
153 static void rulesub(struct rule *rp,
154  const char *loyearp, const char *hiyearp,
155  const char *typep, const char *monthp,
156  const char *dayp, const char *timep);
157 static zic_t tadd(zic_t t1, zic_t t2);
158 
159 /* Bound on length of what %z can expand to. */
160 enum
161 {
162 PERCENT_Z_LEN_BOUND = sizeof "+995959" - 1};
163 
164 /* If true, work around a bug in Qt 5.6.1 and earlier, which mishandles
165  TZif files whose POSIX-TZ-style strings contain '<'; see
166  QTBUG-53071 <https://bugreports.qt.io/browse/QTBUG-53071>. This
167  workaround will no longer be needed when Qt 5.6.1 and earlier are
168  obsolete, say in the year 2021. */
169 #ifndef WORK_AROUND_QTBUG_53071
170 enum
171 {
173 #endif
174 
175 static int charcnt;
176 static bool errors;
177 static bool warnings;
178 static const char *filename;
179 static int leapcnt;
180 static bool leapseen;
185 static int max_format_len;
188 static bool noise;
189 static bool print_abbrevs;
191 static const char *rfilename;
193 static const char *progname;
194 static ptrdiff_t timecnt;
195 static ptrdiff_t timecnt_alloc;
196 static int typecnt;
197 
198 /*
199  * Line codes.
200  */
201 
202 #define LC_RULE 0
203 #define LC_ZONE 1
204 #define LC_LINK 2
205 #define LC_LEAP 3
206 #define LC_EXPIRES 4
207 
208 /*
209  * Which fields are which on a Zone line.
210  */
211 
212 #define ZF_NAME 1
213 #define ZF_STDOFF 2
214 #define ZF_RULE 3
215 #define ZF_FORMAT 4
216 #define ZF_TILYEAR 5
217 #define ZF_TILMONTH 6
218 #define ZF_TILDAY 7
219 #define ZF_TILTIME 8
220 #define ZONE_MINFIELDS 5
221 #define ZONE_MAXFIELDS 9
222 
223 /*
224  * Which fields are which on a Zone continuation line.
225  */
226 
227 #define ZFC_STDOFF 0
228 #define ZFC_RULE 1
229 #define ZFC_FORMAT 2
230 #define ZFC_TILYEAR 3
231 #define ZFC_TILMONTH 4
232 #define ZFC_TILDAY 5
233 #define ZFC_TILTIME 6
234 #define ZONEC_MINFIELDS 3
235 #define ZONEC_MAXFIELDS 7
236 
237 /*
238  * Which files are which on a Rule line.
239  */
240 
241 #define RF_NAME 1
242 #define RF_LOYEAR 2
243 #define RF_HIYEAR 3
244 #define RF_COMMAND 4
245 #define RF_MONTH 5
246 #define RF_DAY 6
247 #define RF_TOD 7
248 #define RF_SAVE 8
249 #define RF_ABBRVAR 9
250 #define RULE_FIELDS 10
251 
252 /*
253  * Which fields are which on a Link line.
254  */
255 
256 #define LF_TARGET 1
257 #define LF_LINKNAME 2
258 #define LINK_FIELDS 3
259 
260 /*
261  * Which fields are which on a Leap line.
262  */
263 
264 #define LP_YEAR 1
265 #define LP_MONTH 2
266 #define LP_DAY 3
267 #define LP_TIME 4
268 #define LP_CORR 5
269 #define LP_ROLL 6
270 #define LEAP_FIELDS 7
271 
272 /* Expires lines are like Leap lines, except without CORR and ROLL fields. */
273 #define EXPIRES_FIELDS 5
274 
275 /*
276  * Year synonyms.
277  */
278 
279 #define YR_MINIMUM 0
280 #define YR_MAXIMUM 1
281 #define YR_ONLY 2
282 
283 static struct rule *rules;
284 static ptrdiff_t nrules; /* number of rules */
285 static ptrdiff_t nrules_alloc;
286 
287 static struct zone *zones;
288 static ptrdiff_t nzones; /* number of zones */
289 static ptrdiff_t nzones_alloc;
290 
291 struct link
292 {
293  const char *l_filename;
295  const char *l_target;
296  const char *l_linkname;
297 };
298 
299 static struct link *links;
300 static ptrdiff_t nlinks;
301 static ptrdiff_t nlinks_alloc;
302 
303 struct lookup
304 {
305  const char *l_word;
306  const int l_value;
307 };
308 
309 static struct lookup const *byword(const char *word,
310  const struct lookup *table);
311 
312 static struct lookup const zi_line_codes[] = {
313  {"Rule", LC_RULE},
314  {"Zone", LC_ZONE},
315  {"Link", LC_LINK},
316  {NULL, 0}
317 };
318 static struct lookup const leap_line_codes[] = {
319  {"Leap", LC_LEAP},
320  {"Expires", LC_EXPIRES},
321  {NULL, 0}
322 };
323 
324 static struct lookup const mon_names[] = {
325  {"January", TM_JANUARY},
326  {"February", TM_FEBRUARY},
327  {"March", TM_MARCH},
328  {"April", TM_APRIL},
329  {"May", TM_MAY},
330  {"June", TM_JUNE},
331  {"July", TM_JULY},
332  {"August", TM_AUGUST},
333  {"September", TM_SEPTEMBER},
334  {"October", TM_OCTOBER},
335  {"November", TM_NOVEMBER},
336  {"December", TM_DECEMBER},
337  {NULL, 0}
338 };
339 
340 static struct lookup const wday_names[] = {
341  {"Sunday", TM_SUNDAY},
342  {"Monday", TM_MONDAY},
343  {"Tuesday", TM_TUESDAY},
344  {"Wednesday", TM_WEDNESDAY},
345  {"Thursday", TM_THURSDAY},
346  {"Friday", TM_FRIDAY},
347  {"Saturday", TM_SATURDAY},
348  {NULL, 0}
349 };
350 
351 static struct lookup const lasts[] = {
352  {"last-Sunday", TM_SUNDAY},
353  {"last-Monday", TM_MONDAY},
354  {"last-Tuesday", TM_TUESDAY},
355  {"last-Wednesday", TM_WEDNESDAY},
356  {"last-Thursday", TM_THURSDAY},
357  {"last-Friday", TM_FRIDAY},
358  {"last-Saturday", TM_SATURDAY},
359  {NULL, 0}
360 };
361 
362 static struct lookup const begin_years[] = {
363  {"minimum", YR_MINIMUM},
364  {"maximum", YR_MAXIMUM},
365  {NULL, 0}
366 };
367 
368 static struct lookup const end_years[] = {
369  {"minimum", YR_MINIMUM},
370  {"maximum", YR_MAXIMUM},
371  {"only", YR_ONLY},
372  {NULL, 0}
373 };
374 
375 static struct lookup const leap_types[] = {
376  {"Rolling", true},
377  {"Stationary", false},
378  {NULL, 0}
379 };
380 
381 static const int len_months[2][MONSPERYEAR] = {
382  {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
383  {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}
384 };
385 
386 static const int len_years[2] = {
388 };
389 
390 static struct attype
391 {
393  bool dontmerge;
394  unsigned char type;
397 static char isdsts[TZ_MAX_TYPES];
398 static unsigned char desigidx[TZ_MAX_TYPES];
399 static bool ttisstds[TZ_MAX_TYPES];
400 static bool ttisuts[TZ_MAX_TYPES];
401 static char chars[TZ_MAX_CHARS];
404 static char roll[TZ_MAX_LEAPS];
405 
406 /*
407  * Memory allocation.
408  */
409 
410 static void
411 memory_exhausted(const char *msg)
412 {
413  fprintf(stderr, _("%s: Memory exhausted: %s\n"), progname, msg);
415 }
416 
417 static size_t
418 size_product(size_t nitems, size_t itemsize)
419 {
420  if (SIZE_MAX / itemsize < nitems)
421  memory_exhausted(_("size overflow"));
422  return nitems * itemsize;
423 }
424 
425 static void *
426 memcheck(void *ptr)
427 {
428  if (ptr == NULL)
429  memory_exhausted(strerror(errno));
430  return ptr;
431 }
432 
433 static void *
434 emalloc(size_t size)
435 {
436  return memcheck(malloc(size));
437 }
438 
439 static void *
440 erealloc(void *ptr, size_t size)
441 {
442  return memcheck(realloc(ptr, size));
443 }
444 
445 static char *
446 ecpyalloc(char const *str)
447 {
448  return memcheck(strdup(str));
449 }
450 
451 static void *
452 growalloc(void *ptr, size_t itemsize, ptrdiff_t nitems, ptrdiff_t *nitems_alloc)
453 {
454  if (nitems < *nitems_alloc)
455  return ptr;
456  else
457  {
458  ptrdiff_t nitems_max = PTRDIFF_MAX - WORK_AROUND_QTBUG_53071;
459  ptrdiff_t amax = nitems_max < SIZE_MAX ? nitems_max : SIZE_MAX;
460 
461  if ((amax - 1) / 3 * 2 < *nitems_alloc)
462  memory_exhausted(_("integer overflow"));
463  *nitems_alloc += (*nitems_alloc >> 1) + 1;
464  return erealloc(ptr, size_product(*nitems_alloc, itemsize));
465  }
466 }
467 
468 /*
469  * Error handling.
470  */
471 
472 static void
473 eats(char const *name, lineno_t num, char const *rname, lineno_t rnum)
474 {
475  filename = name;
476  linenum = num;
477  rfilename = rname;
478  rlinenum = rnum;
479 }
480 
481 static void
482 eat(char const *name, lineno_t num)
483 {
484  eats(name, num, NULL, -1);
485 }
486 
487 static void
488 verror(const char *string, va_list args)
489 {
490  /*
491  * Match the format of "cc" to allow sh users to zic ... 2>&1 | error -t
492  * "*" -v on BSD systems.
493  */
494  if (filename)
495  fprintf(stderr, _("\"%s\", line %d: "), filename, linenum);
496  vfprintf(stderr, string, args);
497  if (rfilename != NULL)
498  fprintf(stderr, _(" (rule from \"%s\", line %d)"),
500  fprintf(stderr, "\n");
501 }
502 
503 static void
504 error(const char *string,...)
505 {
506  va_list args;
507 
508  va_start(args, string);
509  verror(string, args);
510  va_end(args);
511  errors = true;
512 }
513 
514 static void
515 warning(const char *string,...)
516 {
517  va_list args;
518 
519  fprintf(stderr, _("warning: "));
520  va_start(args, string);
521  verror(string, args);
522  va_end(args);
523  warnings = true;
524 }
525 
526 static void
527 close_file(FILE *stream, char const *dir, char const *name)
528 {
529  char const *e = (ferror(stream) ? _("I/O error")
530  : fclose(stream) != 0 ? strerror(errno) : NULL);
531 
532  if (e)
533  {
534  fprintf(stderr, "%s: %s%s%s%s%s\n", progname,
535  dir ? dir : "", dir ? "/" : "",
536  name ? name : "", name ? ": " : "",
537  e);
539  }
540 }
541 
542 static void
543 usage(FILE *stream, int status)
544 {
545  fprintf(stream,
546  _("%s: usage is %s [ --version ] [ --help ] [ -v ] [ -P ] \\\n"
547  "\t[ -b {slim|fat} ] [ -d directory ] [ -l localtime ]"
548  " [ -L leapseconds ] \\\n"
549  "\t[ -p posixrules ] [ -r '[@lo][/@hi]' ] [ -t localtime-link ] \\\n"
550  "\t[ filename ... ]\n\n"
551  "Report bugs to %s.\n"),
552  progname, progname, PACKAGE_BUGREPORT);
553  if (status == EXIT_SUCCESS)
554  close_file(stream, NULL, NULL);
555  exit(status);
556 }
557 
558 /* Change the working directory to DIR, possibly creating DIR and its
559  ancestors. After this is done, all files are accessed with names
560  relative to DIR. */
561 static void
562 change_directory(char const *dir)
563 {
564  if (chdir(dir) != 0)
565  {
566  int chdir_errno = errno;
567 
568  if (chdir_errno == ENOENT)
569  {
570  mkdirs(dir, false);
571  chdir_errno = chdir(dir) == 0 ? 0 : errno;
572  }
573  if (chdir_errno != 0)
574  {
575  fprintf(stderr, _("%s: Can't chdir to %s: %s\n"),
576  progname, dir, strerror(chdir_errno));
578  }
579  }
580 }
581 
582 #define TIME_T_BITS_IN_FILE 64
583 
584 /* The minimum and maximum values representable in a TZif file. */
587 
588 /* The minimum, and one less than the maximum, values specified by
589  the -r option. These default to MIN_TIME and MAX_TIME. */
592 
593 /* The time specified by an Expires line, or negative if no such line. */
594 static zic_t leapexpires = -1;
595 
596 /* The time specified by an #expires comment, or negative if no such line. */
598 
599 /* Set the time range of the output to TIMERANGE.
600  Return true if successful. */
601 static bool
603 {
604  int64 lo = min_time,
605  hi = max_time;
606  char *lo_end = timerange,
607  *hi_end;
608 
609  if (*timerange == '@')
610  {
611  errno = 0;
612  lo = strtoimax(timerange + 1, &lo_end, 10);
613  if (lo_end == timerange + 1 || (lo == PG_INT64_MAX && errno == ERANGE))
614  return false;
615  }
616  hi_end = lo_end;
617  if (lo_end[0] == '/' && lo_end[1] == '@')
618  {
619  errno = 0;
620  hi = strtoimax(lo_end + 2, &hi_end, 10);
621  if (hi_end == lo_end + 2 || hi == PG_INT64_MIN)
622  return false;
623  hi -= !(hi == PG_INT64_MAX && errno == ERANGE);
624  }
625  if (*hi_end || hi < lo || max_time < lo || hi < min_time)
626  return false;
627  lo_time = lo < min_time ? min_time : lo;
628  hi_time = max_time < hi ? max_time : hi;
629  return true;
630 }
631 
632 static const char *psxrules;
633 static const char *lcltime;
634 static const char *directory;
635 static const char *leapsec;
636 static const char *tzdefault;
637 
638 /* -1 if the TZif output file should be slim, 0 if default, 1 if the
639  output should be fat for backward compatibility. ZIC_BLOAT_DEFAULT
640  determines the default. */
641 static int bloat;
642 
643 static bool
645 {
646  return 0 <= bloat;
647 }
648 
649 #ifndef ZIC_BLOAT_DEFAULT
650 #define ZIC_BLOAT_DEFAULT "slim"
651 #endif
652 
653 int
654 main(int argc, char **argv)
655 {
656  int c,
657  k;
658  ptrdiff_t i,
659  j;
660  bool timerange_given = false;
661 
662 #ifndef WIN32
663  umask(umask(S_IWGRP | S_IWOTH) | (S_IWGRP | S_IWOTH));
664 #endif
665  progname = argv[0];
666  if (TYPE_BIT(zic_t) < 64)
667  {
668  fprintf(stderr, "%s: %s\n", progname,
669  _("wild compilation-time specification of zic_t"));
670  return EXIT_FAILURE;
671  }
672  for (k = 1; k < argc; k++)
673  if (strcmp(argv[k], "--version") == 0)
674  {
675  printf("zic %s\n", PG_VERSION);
676  close_file(stdout, NULL, NULL);
677  return EXIT_SUCCESS;
678  }
679  else if (strcmp(argv[k], "--help") == 0)
680  {
682  }
683  while ((c = getopt(argc, argv, "b:d:l:L:p:Pr:st:vy:")) != EOF && c != -1)
684  switch (c)
685  {
686  default:
687  usage(stderr, EXIT_FAILURE);
688  case 'b':
689  if (strcmp(optarg, "slim") == 0)
690  {
691  if (0 < bloat)
692  error(_("incompatible -b options"));
693  bloat = -1;
694  }
695  else if (strcmp(optarg, "fat") == 0)
696  {
697  if (bloat < 0)
698  error(_("incompatible -b options"));
699  bloat = 1;
700  }
701  else
702  error(_("invalid option: -b '%s'"), optarg);
703  break;
704  case 'd':
705  if (directory == NULL)
706  directory = strdup(optarg);
707  else
708  {
709  fprintf(stderr,
710  _("%s: More than one -d option specified\n"),
711  progname);
712  return EXIT_FAILURE;
713  }
714  break;
715  case 'l':
716  if (lcltime == NULL)
717  lcltime = strdup(optarg);
718  else
719  {
720  fprintf(stderr,
721  _("%s: More than one -l option specified\n"),
722  progname);
723  return EXIT_FAILURE;
724  }
725  break;
726  case 'p':
727  if (psxrules == NULL)
728  psxrules = strdup(optarg);
729  else
730  {
731  fprintf(stderr,
732  _("%s: More than one -p option specified\n"),
733  progname);
734  return EXIT_FAILURE;
735  }
736  break;
737  case 't':
738  if (tzdefault != NULL)
739  {
740  fprintf(stderr,
741  _("%s: More than one -t option"
742  " specified\n"),
743  progname);
744  return EXIT_FAILURE;
745  }
746  tzdefault = optarg;
747  break;
748  case 'y':
749  warning(_("-y ignored"));
750  break;
751  case 'L':
752  if (leapsec == NULL)
753  leapsec = strdup(optarg);
754  else
755  {
756  fprintf(stderr,
757  _("%s: More than one -L option specified\n"),
758  progname);
759  return EXIT_FAILURE;
760  }
761  break;
762  case 'v':
763  noise = true;
764  break;
765  case 'P':
766  print_abbrevs = true;
767  print_cutoff = time(NULL);
768  break;
769  case 'r':
770  if (timerange_given)
771  {
772  fprintf(stderr,
773  _("%s: More than one -r option specified\n"),
774  progname);
775  return EXIT_FAILURE;
776  }
777  if (!timerange_option(optarg))
778  {
779  fprintf(stderr,
780  _("%s: invalid time range: %s\n"),
781  progname, optarg);
782  return EXIT_FAILURE;
783  }
784  timerange_given = true;
785  break;
786  case 's':
787  warning(_("-s ignored"));
788  break;
789  }
790  if (optind == argc - 1 && strcmp(argv[optind], "=") == 0)
791  usage(stderr, EXIT_FAILURE); /* usage message by request */
792  if (bloat == 0)
793  {
794  static char const bloat_default[] = ZIC_BLOAT_DEFAULT;
795 
796  if (strcmp(bloat_default, "slim") == 0)
797  bloat = -1;
798  else if (strcmp(bloat_default, "fat") == 0)
799  bloat = 1;
800  else
801  abort(); /* Configuration error. */
802  }
803  if (directory == NULL)
804  directory = "data";
805  if (tzdefault == NULL)
807 
808  if (optind < argc && leapsec != NULL)
809  {
810  infile(leapsec);
811  adjleap();
812  }
813 
814  for (k = optind; k < argc; k++)
815  infile(argv[k]);
816  if (errors)
817  return EXIT_FAILURE;
818  associate();
820  for (i = 0; i < nzones; i = j)
821  {
822  /*
823  * Find the next non-continuation zone entry.
824  */
825  for (j = i + 1; j < nzones && zones[j].z_name == NULL; ++j)
826  continue;
827  outzone(&zones[i], j - i);
828  }
829 
830  /*
831  * Make links.
832  */
833  for (i = 0; i < nlinks; ++i)
834  {
835  eat(links[i].l_filename, links[i].l_linenum);
836  dolink(links[i].l_target, links[i].l_linkname, false);
837  if (noise)
838  for (j = 0; j < nlinks; ++j)
839  if (strcmp(links[i].l_linkname,
840  links[j].l_target) == 0)
841  warning(_("link to link"));
842  }
843  if (lcltime != NULL)
844  {
845  eat(_("command line"), 1);
846  dolink(lcltime, tzdefault, true);
847  }
848  if (psxrules != NULL)
849  {
850  eat(_("command line"), 1);
851  dolink(psxrules, TZDEFRULES, true);
852  }
853  if (warnings && (ferror(stderr) || fclose(stderr) != 0))
854  return EXIT_FAILURE;
855  return errors ? EXIT_FAILURE : EXIT_SUCCESS;
856 }
857 
858 static bool
859 componentcheck(char const *name, char const *component,
860  char const *component_end)
861 {
862  enum
863  {
864  component_len_max = 14};
865  ptrdiff_t component_len = component_end - component;
866 
867  if (component_len == 0)
868  {
869  if (!*name)
870  error(_("empty file name"));
871  else
872  error(_(component == name
873  ? "file name '%s' begins with '/'"
874  : *component_end
875  ? "file name '%s' contains '//'"
876  : "file name '%s' ends with '/'"),
877  name);
878  return false;
879  }
880  if (0 < component_len && component_len <= 2
881  && component[0] == '.' && component_end[-1] == '.')
882  {
883  int len = component_len;
884 
885  error(_("file name '%s' contains '%.*s' component"),
886  name, len, component);
887  return false;
888  }
889  if (noise)
890  {
891  if (0 < component_len && component[0] == '-')
892  warning(_("file name '%s' component contains leading '-'"),
893  name);
894  if (component_len_max < component_len)
895  warning(_("file name '%s' contains overlength component"
896  " '%.*s...'"),
897  name, component_len_max, component);
898  }
899  return true;
900 }
901 
902 static bool
903 namecheck(const char *name)
904 {
905  char const *cp;
906 
907  /* Benign characters in a portable file name. */
908  static char const benign[] =
909  "-/_"
910  "abcdefghijklmnopqrstuvwxyz"
911  "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
912 
913  /*
914  * Non-control chars in the POSIX portable character set, excluding the
915  * benign characters.
916  */
917  static char const printable_and_not_benign[] =
918  " !\"#$%&'()*+,.0123456789:;<=>?@[\\]^`{|}~";
919 
920  char const *component = name;
921 
922  for (cp = name; *cp; cp++)
923  {
924  unsigned char c = *cp;
925 
926  if (noise && !strchr(benign, c))
927  {
928  warning((strchr(printable_and_not_benign, c)
929  ? _("file name '%s' contains byte '%c'")
930  : _("file name '%s' contains byte '\\%o'")),
931  name, c);
932  }
933  if (c == '/')
934  {
935  if (!componentcheck(name, component, cp))
936  return false;
937  component = cp + 1;
938  }
939  }
940  return componentcheck(name, component, cp);
941 }
942 
943 /*
944  * Create symlink contents suitable for symlinking FROM to TO, as a
945  * freshly allocated string. FROM should be a relative file name, and
946  * is relative to the global variable DIRECTORY. TO can be either
947  * relative or absolute.
948  */
949 #ifdef HAVE_SYMLINK
950 static char *
951 relname(char const *target, char const *linkname)
952 {
953  size_t i,
954  taillen,
955  dotdotetcsize;
956  size_t dir_len = 0,
957  dotdots = 0,
958  linksize = SIZE_MAX;
959  char const *f = target;
960  char *result = NULL;
961 
962  if (*linkname == '/')
963  {
964  /* Make F absolute too. */
965  size_t len = strlen(directory);
966  bool needslash = len && directory[len - 1] != '/';
967 
968  linksize = len + needslash + strlen(target) + 1;
969  f = result = emalloc(linksize);
970  strcpy(result, directory);
971  result[len] = '/';
972  strcpy(result + len + needslash, target);
973  }
974  for (i = 0; f[i] && f[i] == linkname[i]; i++)
975  if (f[i] == '/')
976  dir_len = i + 1;
977  for (; linkname[i]; i++)
978  dotdots += linkname[i] == '/' && linkname[i - 1] != '/';
979  taillen = strlen(f + dir_len);
980  dotdotetcsize = 3 * dotdots + taillen + 1;
981  if (dotdotetcsize <= linksize)
982  {
983  if (!result)
984  result = emalloc(dotdotetcsize);
985  for (i = 0; i < dotdots; i++)
986  memcpy(result + 3 * i, "../", 3);
987  memmove(result + 3 * dotdots, f + dir_len, taillen + 1);
988  }
989  return result;
990 }
991 #endif /* HAVE_SYMLINK */
992 
993 /* Hard link FROM to TO, following any symbolic links.
994  Return 0 if successful, an error number otherwise. */
995 static int
996 hardlinkerr(char const *target, char const *linkname)
997 {
998  int r = linkat(AT_FDCWD, target, AT_FDCWD, linkname, AT_SYMLINK_FOLLOW);
999 
1000  return r == 0 ? 0 : errno;
1001 }
1002 
1003 static void
1004 dolink(char const *target, char const *linkname, bool staysymlink)
1005 {
1006  bool remove_only = strcmp(target, "-") == 0;
1007  bool linkdirs_made = false;
1008  int link_errno;
1009 
1010  /*
1011  * We get to be careful here since there's a fair chance of root running
1012  * us.
1013  */
1014  if (!remove_only && itsdir(target))
1015  {
1016  fprintf(stderr, _("%s: linking target %s/%s failed: %s\n"),
1017  progname, directory, target, strerror(EPERM));
1018  exit(EXIT_FAILURE);
1019  }
1020  if (staysymlink)
1021  staysymlink = itssymlink(linkname);
1022  if (remove(linkname) == 0)
1023  linkdirs_made = true;
1024  else if (errno != ENOENT)
1025  {
1026  char const *e = strerror(errno);
1027 
1028  fprintf(stderr, _("%s: Can't remove %s/%s: %s\n"),
1029  progname, directory, linkname, e);
1030  exit(EXIT_FAILURE);
1031  }
1032  if (remove_only)
1033  return;
1034  link_errno = staysymlink ? ENOTSUP : hardlinkerr(target, linkname);
1035  if (link_errno == ENOENT && !linkdirs_made)
1036  {
1037  mkdirs(linkname, true);
1038  linkdirs_made = true;
1039  link_errno = hardlinkerr(target, linkname);
1040  }
1041  if (link_errno != 0)
1042  {
1043 #ifdef HAVE_SYMLINK
1044  bool absolute = *target == '/';
1045  char *linkalloc = absolute ? NULL : relname(target, linkname);
1046  char const *contents = absolute ? target : linkalloc;
1047  int symlink_errno = symlink(contents, linkname) == 0 ? 0 : errno;
1048 
1049  if (!linkdirs_made
1050  && (symlink_errno == ENOENT || symlink_errno == ENOTSUP))
1051  {
1052  mkdirs(linkname, true);
1053  if (symlink_errno == ENOENT)
1054  symlink_errno = symlink(contents, linkname) == 0 ? 0 : errno;
1055  }
1056  free(linkalloc);
1057  if (symlink_errno == 0)
1058  {
1059  if (link_errno != ENOTSUP)
1060  warning(_("symbolic link used because hard link failed: %s"),
1061  strerror(link_errno));
1062  }
1063  else
1064 #endif /* HAVE_SYMLINK */
1065  {
1066  FILE *fp,
1067  *tp;
1068  int c;
1069 
1070  fp = fopen(target, "rb");
1071  if (!fp)
1072  {
1073  char const *e = strerror(errno);
1074 
1075  fprintf(stderr, _("%s: Can't read %s/%s: %s\n"),
1076  progname, directory, target, e);
1077  exit(EXIT_FAILURE);
1078  }
1079  tp = fopen(linkname, "wb");
1080  if (!tp)
1081  {
1082  char const *e = strerror(errno);
1083 
1084  fprintf(stderr, _("%s: Can't create %s/%s: %s\n"),
1085  progname, directory, linkname, e);
1086  exit(EXIT_FAILURE);
1087  }
1088  while ((c = getc(fp)) != EOF)
1089  putc(c, tp);
1090  close_file(fp, directory, target);
1091  close_file(tp, directory, linkname);
1092  if (link_errno != ENOTSUP)
1093  warning(_("copy used because hard link failed: %s"),
1094  strerror(link_errno));
1095 #ifdef HAVE_SYMLINK
1096  else if (symlink_errno != ENOTSUP)
1097  warning(_("copy used because symbolic link failed: %s"),
1098  strerror(symlink_errno));
1099 #endif
1100  }
1101  }
1102 }
1103 
1104 /* Return true if NAME is a directory. */
1105 static bool
1106 itsdir(char const *name)
1107 {
1108  struct stat st;
1109  int res = stat(name, &st);
1110 #ifdef S_ISDIR
1111  if (res == 0)
1112  return S_ISDIR(st.st_mode) != 0;
1113 #endif
1114  if (res == 0 || errno == EOVERFLOW)
1115  {
1116  size_t n = strlen(name);
1117  char *nameslashdot = emalloc(n + 3);
1118  bool dir;
1119 
1120  memcpy(nameslashdot, name, n);
1121  strcpy(&nameslashdot[n], &"/."[!(n && name[n - 1] != '/')]);
1122  dir = stat(nameslashdot, &st) == 0 || errno == EOVERFLOW;
1123  free(nameslashdot);
1124  return dir;
1125  }
1126  return false;
1127 }
1128 
1129 /* Return true if NAME is a symbolic link. */
1130 static bool
1131 itssymlink(char const *name)
1132 {
1133 #ifdef HAVE_SYMLINK
1134  char c;
1135 
1136  return 0 <= readlink(name, &c, 1);
1137 #else
1138  return false;
1139 #endif
1140 }
1141 
1142 /*
1143  * Associate sets of rules with zones.
1144  */
1145 
1146 /*
1147  * Sort by rule name.
1148  */
1149 
1150 static int
1151 rcomp(const void *cp1, const void *cp2)
1152 {
1153  return strcmp(((const struct rule *) cp1)->r_name,
1154  ((const struct rule *) cp2)->r_name);
1155 }
1156 
1157 static void
1159 {
1160  struct zone *zp;
1161  struct rule *rp;
1162  ptrdiff_t i,
1163  j,
1164  base,
1165  out;
1166 
1167  if (nrules != 0)
1168  {
1169  qsort(rules, nrules, sizeof *rules, rcomp);
1170  for (i = 0; i < nrules - 1; ++i)
1171  {
1172  if (strcmp(rules[i].r_name,
1173  rules[i + 1].r_name) != 0)
1174  continue;
1175  if (strcmp(rules[i].r_filename,
1176  rules[i + 1].r_filename) == 0)
1177  continue;
1179  warning(_("same rule name in multiple files"));
1180  eat(rules[i + 1].r_filename, rules[i + 1].r_linenum);
1181  warning(_("same rule name in multiple files"));
1182  for (j = i + 2; j < nrules; ++j)
1183  {
1184  if (strcmp(rules[i].r_name,
1185  rules[j].r_name) != 0)
1186  break;
1187  if (strcmp(rules[i].r_filename,
1188  rules[j].r_filename) == 0)
1189  continue;
1190  if (strcmp(rules[i + 1].r_filename,
1191  rules[j].r_filename) == 0)
1192  continue;
1193  break;
1194  }
1195  i = j - 1;
1196  }
1197  }
1198  for (i = 0; i < nzones; ++i)
1199  {
1200  zp = &zones[i];
1201  zp->z_rules = NULL;
1202  zp->z_nrules = 0;
1203  }
1204  for (base = 0; base < nrules; base = out)
1205  {
1206  rp = &rules[base];
1207  for (out = base + 1; out < nrules; ++out)
1208  if (strcmp(rp->r_name, rules[out].r_name) != 0)
1209  break;
1210  for (i = 0; i < nzones; ++i)
1211  {
1212  zp = &zones[i];
1213  if (strcmp(zp->z_rule, rp->r_name) != 0)
1214  continue;
1215  zp->z_rules = rp;
1216  zp->z_nrules = out - base;
1217  }
1218  }
1219  for (i = 0; i < nzones; ++i)
1220  {
1221  zp = &zones[i];
1222  if (zp->z_nrules == 0)
1223  {
1224  /*
1225  * Maybe we have a local standard time offset.
1226  */
1227  eat(zp->z_filename, zp->z_linenum);
1228  zp->z_save = getsave(zp->z_rule, &zp->z_isdst);
1229 
1230  /*
1231  * Note, though, that if there's no rule, a '%s' in the format is
1232  * a bad thing.
1233  */
1234  if (zp->z_format_specifier == 's')
1235  error("%s", _("%s in ruleless zone"));
1236  }
1237  }
1238  if (errors)
1239  exit(EXIT_FAILURE);
1240 }
1241 
1242 static void
1243 infile(const char *name)
1244 {
1245  FILE *fp;
1246  char **fields;
1247  char *cp;
1248  const struct lookup *lp;
1249  int nfields;
1250  bool wantcont;
1251  lineno_t num;
1252  char buf[BUFSIZ];
1253 
1254  if (strcmp(name, "-") == 0)
1255  {
1256  name = _("standard input");
1257  fp = stdin;
1258  }
1259  else if ((fp = fopen(name, "r")) == NULL)
1260  {
1261  const char *e = strerror(errno);
1262 
1263  fprintf(stderr, _("%s: Cannot open %s: %s\n"),
1264  progname, name, e);
1265  exit(EXIT_FAILURE);
1266  }
1267  wantcont = false;
1268  for (num = 1;; ++num)
1269  {
1270  eat(name, num);
1271  if (fgets(buf, sizeof buf, fp) != buf)
1272  break;
1273  cp = strchr(buf, '\n');
1274  if (cp == NULL)
1275  {
1276  error(_("line too long"));
1277  exit(EXIT_FAILURE);
1278  }
1279  *cp = '\0';
1280  fields = getfields(buf);
1281  nfields = 0;
1282  while (fields[nfields] != NULL)
1283  {
1284  static char nada;
1285 
1286  if (strcmp(fields[nfields], "-") == 0)
1287  fields[nfields] = &nada;
1288  ++nfields;
1289  }
1290  if (nfields == 0)
1291  {
1292  if (name == leapsec && *buf == '#')
1293  {
1294  /*
1295  * PG: INT64_FORMAT isn't portable for sscanf, so be content
1296  * with scanning a "long". Once we are requiring C99 in all
1297  * live branches, it'd be sensible to adopt upstream's
1298  * practice of using the <inttypes.h> macros. But for now, we
1299  * don't actually use this code, and it won't overflow before
1300  * 2038 anyway.
1301  */
1302  long cl_tmp;
1303 
1304  sscanf(buf, "#expires %ld", &cl_tmp);
1305  comment_leapexpires = cl_tmp;
1306  }
1307  }
1308  else if (wantcont)
1309  {
1310  wantcont = inzcont(fields, nfields);
1311  }
1312  else
1313  {
1314  struct lookup const *line_codes
1316 
1317  lp = byword(fields[0], line_codes);
1318  if (lp == NULL)
1319  error(_("input line of unknown type"));
1320  else
1321  switch (lp->l_value)
1322  {
1323  case LC_RULE:
1324  inrule(fields, nfields);
1325  wantcont = false;
1326  break;
1327  case LC_ZONE:
1328  wantcont = inzone(fields, nfields);
1329  break;
1330  case LC_LINK:
1331  inlink(fields, nfields);
1332  wantcont = false;
1333  break;
1334  case LC_LEAP:
1335  inleap(fields, nfields);
1336  wantcont = false;
1337  break;
1338  case LC_EXPIRES:
1339  inexpires(fields, nfields);
1340  wantcont = false;
1341  break;
1342  default: /* "cannot happen" */
1343  fprintf(stderr,
1344  _("%s: panic: Invalid l_value %d\n"),
1345  progname, lp->l_value);
1346  exit(EXIT_FAILURE);
1347  }
1348  }
1349  free(fields);
1350  }
1351  close_file(fp, NULL, filename);
1352  if (wantcont)
1353  error(_("expected continuation line not found"));
1354 }
1355 
1356 /*
1357  * Convert a string of one of the forms
1358  * h -h hh:mm -hh:mm hh:mm:ss -hh:mm:ss
1359  * into a number of seconds.
1360  * A null string maps to zero.
1361  * Call error with errstring and return zero on errors.
1362  */
1363 
1364 static zic_t
1365 gethms(char const *string, char const *errstring)
1366 {
1367  /* PG: make hh be int not zic_t to avoid sscanf portability issues */
1368  int hh;
1369  int sign,
1370  mm = 0,
1371  ss = 0;
1372  char hhx,
1373  mmx,
1374  ssx,
1375  xr = '0',
1376  xs;
1377  int tenths = 0;
1378  bool ok = true;
1379 
1380  if (string == NULL || *string == '\0')
1381  return 0;
1382  if (*string == '-')
1383  {
1384  sign = -1;
1385  ++string;
1386  }
1387  else
1388  sign = 1;
1389  switch (sscanf(string,
1390  "%d%c%d%c%d%c%1d%*[0]%c%*[0123456789]%c",
1391  &hh, &hhx, &mm, &mmx, &ss, &ssx, &tenths, &xr, &xs))
1392  {
1393  default:
1394  ok = false;
1395  break;
1396  case 8:
1397  ok = '0' <= xr && xr <= '9';
1398  /* fallthrough */
1399  case 7:
1400  ok &= ssx == '.';
1401  if (ok && noise)
1402  warning(_("fractional seconds rejected by"
1403  " pre-2018 versions of zic"));
1404  /* fallthrough */
1405  case 5:
1406  ok &= mmx == ':';
1407  /* fallthrough */
1408  case 3:
1409  ok &= hhx == ':';
1410  /* fallthrough */
1411  case 1:
1412  break;
1413  }
1414  if (!ok)
1415  {
1416  error("%s", errstring);
1417  return 0;
1418  }
1419  if (hh < 0 ||
1420  mm < 0 || mm >= MINSPERHOUR ||
1421  ss < 0 || ss > SECSPERMIN)
1422  {
1423  error("%s", errstring);
1424  return 0;
1425  }
1426  /* Some compilers warn that this test is unsatisfiable for 32-bit ints */
1427 #if INT_MAX > PG_INT32_MAX
1428  if (ZIC_MAX / SECSPERHOUR < hh)
1429  {
1430  error(_("time overflow"));
1431  return 0;
1432  }
1433 #endif
1434  ss += 5 + ((ss ^ 1) & (xr == '0')) <= tenths; /* Round to even. */
1435  if (noise && (hh > HOURSPERDAY ||
1436  (hh == HOURSPERDAY && (mm != 0 || ss != 0))))
1437  warning(_("values over 24 hours not handled by pre-2007 versions of zic"));
1438  return oadd(sign * (zic_t) hh * SECSPERHOUR,
1439  sign * (mm * SECSPERMIN + ss));
1440 }
1441 
1442 static zic_t
1443 getsave(char *field, bool *isdst)
1444 {
1445  int dst = -1;
1446  zic_t save;
1447  size_t fieldlen = strlen(field);
1448 
1449  if (fieldlen != 0)
1450  {
1451  char *ep = field + fieldlen - 1;
1452 
1453  switch (*ep)
1454  {
1455  case 'd':
1456  dst = 1;
1457  *ep = '\0';
1458  break;
1459  case 's':
1460  dst = 0;
1461  *ep = '\0';
1462  break;
1463  }
1464  }
1465  save = gethms(field, _("invalid saved time"));
1466  *isdst = dst < 0 ? save != 0 : dst;
1467  return save;
1468 }
1469 
1470 static void
1471 inrule(char **fields, int nfields)
1472 {
1473  static struct rule r;
1474 
1475  if (nfields != RULE_FIELDS)
1476  {
1477  error(_("wrong number of fields on Rule line"));
1478  return;
1479  }
1480  switch (*fields[RF_NAME])
1481  {
1482  case '\0':
1483  case ' ':
1484  case '\f':
1485  case '\n':
1486  case '\r':
1487  case '\t':
1488  case '\v':
1489  case '+':
1490  case '-':
1491  case '0':
1492  case '1':
1493  case '2':
1494  case '3':
1495  case '4':
1496  case '5':
1497  case '6':
1498  case '7':
1499  case '8':
1500  case '9':
1501  error(_("Invalid rule name \"%s\""), fields[RF_NAME]);
1502  return;
1503  }
1504  r.r_filename = filename;
1505  r.r_linenum = linenum;
1506  r.r_save = getsave(fields[RF_SAVE], &r.r_isdst);
1507  rulesub(&r, fields[RF_LOYEAR], fields[RF_HIYEAR], fields[RF_COMMAND],
1508  fields[RF_MONTH], fields[RF_DAY], fields[RF_TOD]);
1509  r.r_name = ecpyalloc(fields[RF_NAME]);
1510  r.r_abbrvar = ecpyalloc(fields[RF_ABBRVAR]);
1511  if (max_abbrvar_len < strlen(r.r_abbrvar))
1512  max_abbrvar_len = strlen(r.r_abbrvar);
1513  rules = growalloc(rules, sizeof *rules, nrules, &nrules_alloc);
1514  rules[nrules++] = r;
1515 }
1516 
1517 static bool
1518 inzone(char **fields, int nfields)
1519 {
1520  ptrdiff_t i;
1521 
1522  if (nfields < ZONE_MINFIELDS || nfields > ZONE_MAXFIELDS)
1523  {
1524  error(_("wrong number of fields on Zone line"));
1525  return false;
1526  }
1527  if (lcltime != NULL && strcmp(fields[ZF_NAME], tzdefault) == 0)
1528  {
1529  error(
1530  _("\"Zone %s\" line and -l option are mutually exclusive"),
1531  tzdefault);
1532  return false;
1533  }
1534  if (strcmp(fields[ZF_NAME], TZDEFRULES) == 0 && psxrules != NULL)
1535  {
1536  error(
1537  _("\"Zone %s\" line and -p option are mutually exclusive"),
1538  TZDEFRULES);
1539  return false;
1540  }
1541  for (i = 0; i < nzones; ++i)
1542  if (zones[i].z_name != NULL &&
1543  strcmp(zones[i].z_name, fields[ZF_NAME]) == 0)
1544  {
1545  error(_("duplicate zone name %s"
1546  " (file \"%s\", line %d)"),
1547  fields[ZF_NAME],
1548  zones[i].z_filename,
1549  zones[i].z_linenum);
1550  return false;
1551  }
1552  return inzsub(fields, nfields, false);
1553 }
1554 
1555 static bool
1556 inzcont(char **fields, int nfields)
1557 {
1558  if (nfields < ZONEC_MINFIELDS || nfields > ZONEC_MAXFIELDS)
1559  {
1560  error(_("wrong number of fields on Zone continuation line"));
1561  return false;
1562  }
1563  return inzsub(fields, nfields, true);
1564 }
1565 
1566 static bool
1567 inzsub(char **fields, int nfields, bool iscont)
1568 {
1569  char *cp;
1570  char *cp1;
1571  static struct zone z;
1572  int i_stdoff,
1573  i_rule,
1574  i_format;
1575  int i_untilyear,
1576  i_untilmonth;
1577  int i_untilday,
1578  i_untiltime;
1579  bool hasuntil;
1580 
1581  if (iscont)
1582  {
1583  i_stdoff = ZFC_STDOFF;
1584  i_rule = ZFC_RULE;
1585  i_format = ZFC_FORMAT;
1586  i_untilyear = ZFC_TILYEAR;
1587  i_untilmonth = ZFC_TILMONTH;
1588  i_untilday = ZFC_TILDAY;
1589  i_untiltime = ZFC_TILTIME;
1590  z.z_name = NULL;
1591  }
1592  else if (!namecheck(fields[ZF_NAME]))
1593  return false;
1594  else
1595  {
1596  i_stdoff = ZF_STDOFF;
1597  i_rule = ZF_RULE;
1598  i_format = ZF_FORMAT;
1599  i_untilyear = ZF_TILYEAR;
1600  i_untilmonth = ZF_TILMONTH;
1601  i_untilday = ZF_TILDAY;
1602  i_untiltime = ZF_TILTIME;
1603  z.z_name = ecpyalloc(fields[ZF_NAME]);
1604  }
1605  z.z_filename = filename;
1606  z.z_linenum = linenum;
1607  z.z_stdoff = gethms(fields[i_stdoff], _("invalid UT offset"));
1608  if ((cp = strchr(fields[i_format], '%')) != NULL)
1609  {
1610  if ((*++cp != 's' && *cp != 'z') || strchr(cp, '%')
1611  || strchr(fields[i_format], '/'))
1612  {
1613  error(_("invalid abbreviation format"));
1614  return false;
1615  }
1616  }
1617  z.z_rule = ecpyalloc(fields[i_rule]);
1618  z.z_format = cp1 = ecpyalloc(fields[i_format]);
1619  z.z_format_specifier = cp ? *cp : '\0';
1620  if (z.z_format_specifier == 'z')
1621  {
1622  if (noise)
1623  warning(_("format '%s' not handled by pre-2015 versions of zic"),
1624  z.z_format);
1625  cp1[cp - fields[i_format]] = 's';
1626  }
1627  if (max_format_len < strlen(z.z_format))
1628  max_format_len = strlen(z.z_format);
1629  hasuntil = nfields > i_untilyear;
1630  if (hasuntil)
1631  {
1634  rulesub(&z.z_untilrule,
1635  fields[i_untilyear],
1636  "only",
1637  "",
1638  (nfields > i_untilmonth) ?
1639  fields[i_untilmonth] : "Jan",
1640  (nfields > i_untilday) ? fields[i_untilday] : "1",
1641  (nfields > i_untiltime) ? fields[i_untiltime] : "0");
1643  z.z_untilrule.r_loyear);
1644  if (iscont && nzones > 0 &&
1645  z.z_untiltime > min_time &&
1646  z.z_untiltime < max_time &&
1647  zones[nzones - 1].z_untiltime > min_time &&
1648  zones[nzones - 1].z_untiltime < max_time &&
1649  zones[nzones - 1].z_untiltime >= z.z_untiltime)
1650  {
1651  error(_("Zone continuation line end time is not after end time of previous line"));
1652  return false;
1653  }
1654  }
1655  zones = growalloc(zones, sizeof *zones, nzones, &nzones_alloc);
1656  zones[nzones++] = z;
1657 
1658  /*
1659  * If there was an UNTIL field on this line, there's more information
1660  * about the zone on the next line.
1661  */
1662  return hasuntil;
1663 }
1664 
1665 static zic_t
1666 getleapdatetime(char **fields, int nfields, bool expire_line)
1667 {
1668  const char *cp;
1669  const struct lookup *lp;
1670  zic_t i,
1671  j;
1672 
1673  /* PG: make year be int not zic_t to avoid sscanf portability issues */
1674  int year;
1675  int month,
1676  day;
1677  zic_t dayoff,
1678  tod;
1679  zic_t t;
1680  char xs;
1681 
1682  dayoff = 0;
1683  cp = fields[LP_YEAR];
1684  if (sscanf(cp, "%d%c", &year, &xs) != 1)
1685  {
1686  /*
1687  * Leapin' Lizards!
1688  */
1689  error(_("invalid leaping year"));
1690  return -1;
1691  }
1692  if (!expire_line)
1693  {
1694  if (!leapseen || leapmaxyear < year)
1695  leapmaxyear = year;
1696  if (!leapseen || leapminyear > year)
1697  leapminyear = year;
1698  leapseen = true;
1699  }
1700  j = EPOCH_YEAR;
1701  while (j != year)
1702  {
1703  if (year > j)
1704  {
1705  i = len_years[isleap(j)];
1706  ++j;
1707  }
1708  else
1709  {
1710  --j;
1711  i = -len_years[isleap(j)];
1712  }
1713  dayoff = oadd(dayoff, i);
1714  }
1715  if ((lp = byword(fields[LP_MONTH], mon_names)) == NULL)
1716  {
1717  error(_("invalid month name"));
1718  return -1;
1719  }
1720  month = lp->l_value;
1721  j = TM_JANUARY;
1722  while (j != month)
1723  {
1724  i = len_months[isleap(year)][j];
1725  dayoff = oadd(dayoff, i);
1726  ++j;
1727  }
1728  cp = fields[LP_DAY];
1729  if (sscanf(cp, "%d%c", &day, &xs) != 1 ||
1730  day <= 0 || day > len_months[isleap(year)][month])
1731  {
1732  error(_("invalid day of month"));
1733  return -1;
1734  }
1735  dayoff = oadd(dayoff, day - 1);
1736  if (dayoff < min_time / SECSPERDAY)
1737  {
1738  error(_("time too small"));
1739  return -1;
1740  }
1741  if (dayoff > max_time / SECSPERDAY)
1742  {
1743  error(_("time too large"));
1744  return -1;
1745  }
1746  t = dayoff * SECSPERDAY;
1747  tod = gethms(fields[LP_TIME], _("invalid time of day"));
1748  t = tadd(t, tod);
1749  if (t < 0)
1750  error(_("leap second precedes Epoch"));
1751  return t;
1752 }
1753 
1754 static void
1755 inleap(char **fields, int nfields)
1756 {
1757  if (nfields != LEAP_FIELDS)
1758  error(_("wrong number of fields on Leap line"));
1759  else
1760  {
1761  zic_t t = getleapdatetime(fields, nfields, false);
1762 
1763  if (0 <= t)
1764  {
1765  struct lookup const *lp = byword(fields[LP_ROLL], leap_types);
1766 
1767  if (!lp)
1768  error(_("invalid Rolling/Stationary field on Leap line"));
1769  else
1770  {
1771  int correction = 0;
1772 
1773  if (!fields[LP_CORR][0]) /* infile() turns "-" into "". */
1774  correction = -1;
1775  else if (strcmp(fields[LP_CORR], "+") == 0)
1776  correction = 1;
1777  else
1778  error(_("invalid CORRECTION field on Leap line"));
1779  if (correction)
1780  leapadd(t, correction, lp->l_value);
1781  }
1782  }
1783  }
1784 }
1785 
1786 static void
1787 inexpires(char **fields, int nfields)
1788 {
1789  if (nfields != EXPIRES_FIELDS)
1790  error(_("wrong number of fields on Expires line"));
1791  else if (0 <= leapexpires)
1792  error(_("multiple Expires lines"));
1793  else
1794  leapexpires = getleapdatetime(fields, nfields, true);
1795 }
1796 
1797 static void
1798 inlink(char **fields, int nfields)
1799 {
1800  struct link l;
1801 
1802  if (nfields != LINK_FIELDS)
1803  {
1804  error(_("wrong number of fields on Link line"));
1805  return;
1806  }
1807  if (*fields[LF_TARGET] == '\0')
1808  {
1809  error(_("blank TARGET field on Link line"));
1810  return;
1811  }
1812  if (!namecheck(fields[LF_LINKNAME]))
1813  return;
1814  l.l_filename = filename;
1815  l.l_linenum = linenum;
1816  l.l_target = ecpyalloc(fields[LF_TARGET]);
1817  l.l_linkname = ecpyalloc(fields[LF_LINKNAME]);
1818  links = growalloc(links, sizeof *links, nlinks, &nlinks_alloc);
1819  links[nlinks++] = l;
1820 }
1821 
1822 static void
1823 rulesub(struct rule *rp, const char *loyearp, const char *hiyearp,
1824  const char *typep, const char *monthp, const char *dayp,
1825  const char *timep)
1826 {
1827  const struct lookup *lp;
1828  const char *cp;
1829  char *dp;
1830  char *ep;
1831  char xs;
1832 
1833  /* PG: year_tmp is to avoid sscanf portability issues */
1834  int year_tmp;
1835 
1836  if ((lp = byword(monthp, mon_names)) == NULL)
1837  {
1838  error(_("invalid month name"));
1839  return;
1840  }
1841  rp->r_month = lp->l_value;
1842  rp->r_todisstd = false;
1843  rp->r_todisut = false;
1844  dp = ecpyalloc(timep);
1845  if (*dp != '\0')
1846  {
1847  ep = dp + strlen(dp) - 1;
1848  switch (lowerit(*ep))
1849  {
1850  case 's': /* Standard */
1851  rp->r_todisstd = true;
1852  rp->r_todisut = false;
1853  *ep = '\0';
1854  break;
1855  case 'w': /* Wall */
1856  rp->r_todisstd = false;
1857  rp->r_todisut = false;
1858  *ep = '\0';
1859  break;
1860  case 'g': /* Greenwich */
1861  case 'u': /* Universal */
1862  case 'z': /* Zulu */
1863  rp->r_todisstd = true;
1864  rp->r_todisut = true;
1865  *ep = '\0';
1866  break;
1867  }
1868  }
1869  rp->r_tod = gethms(dp, _("invalid time of day"));
1870  free(dp);
1871 
1872  /*
1873  * Year work.
1874  */
1875  cp = loyearp;
1876  lp = byword(cp, begin_years);
1877  rp->r_lowasnum = lp == NULL;
1878  if (!rp->r_lowasnum)
1879  switch (lp->l_value)
1880  {
1881  case YR_MINIMUM:
1882  rp->r_loyear = ZIC_MIN;
1883  break;
1884  case YR_MAXIMUM:
1885  rp->r_loyear = ZIC_MAX;
1886  break;
1887  default: /* "cannot happen" */
1888  fprintf(stderr,
1889  _("%s: panic: Invalid l_value %d\n"),
1890  progname, lp->l_value);
1891  exit(EXIT_FAILURE);
1892  }
1893  else if (sscanf(cp, "%d%c", &year_tmp, &xs) == 1)
1894  rp->r_loyear = year_tmp;
1895  else
1896  {
1897  error(_("invalid starting year"));
1898  return;
1899  }
1900  cp = hiyearp;
1901  lp = byword(cp, end_years);
1902  rp->r_hiwasnum = lp == NULL;
1903  if (!rp->r_hiwasnum)
1904  switch (lp->l_value)
1905  {
1906  case YR_MINIMUM:
1907  rp->r_hiyear = ZIC_MIN;
1908  break;
1909  case YR_MAXIMUM:
1910  rp->r_hiyear = ZIC_MAX;
1911  break;
1912  case YR_ONLY:
1913  rp->r_hiyear = rp->r_loyear;
1914  break;
1915  default: /* "cannot happen" */
1916  fprintf(stderr,
1917  _("%s: panic: Invalid l_value %d\n"),
1918  progname, lp->l_value);
1919  exit(EXIT_FAILURE);
1920  }
1921  else if (sscanf(cp, "%d%c", &year_tmp, &xs) == 1)
1922  rp->r_hiyear = year_tmp;
1923  else
1924  {
1925  error(_("invalid ending year"));
1926  return;
1927  }
1928  if (rp->r_loyear > rp->r_hiyear)
1929  {
1930  error(_("starting year greater than ending year"));
1931  return;
1932  }
1933  if (*typep != '\0')
1934  {
1935  error(_("year type \"%s\" is unsupported; use \"-\" instead"),
1936  typep);
1937  return;
1938  }
1939 
1940  /*
1941  * Day work. Accept things such as: 1 lastSunday last-Sunday
1942  * (undocumented; warn about this) Sun<=20 Sun>=7
1943  */
1944  dp = ecpyalloc(dayp);
1945  if ((lp = byword(dp, lasts)) != NULL)
1946  {
1947  rp->r_dycode = DC_DOWLEQ;
1948  rp->r_wday = lp->l_value;
1949  rp->r_dayofmonth = len_months[1][rp->r_month];
1950  }
1951  else
1952  {
1953  if ((ep = strchr(dp, '<')) != NULL)
1954  rp->r_dycode = DC_DOWLEQ;
1955  else if ((ep = strchr(dp, '>')) != NULL)
1956  rp->r_dycode = DC_DOWGEQ;
1957  else
1958  {
1959  ep = dp;
1960  rp->r_dycode = DC_DOM;
1961  }
1962  if (rp->r_dycode != DC_DOM)
1963  {
1964  *ep++ = 0;
1965  if (*ep++ != '=')
1966  {
1967  error(_("invalid day of month"));
1968  free(dp);
1969  return;
1970  }
1971  if ((lp = byword(dp, wday_names)) == NULL)
1972  {
1973  error(_("invalid weekday name"));
1974  free(dp);
1975  return;
1976  }
1977  rp->r_wday = lp->l_value;
1978  }
1979  if (sscanf(ep, "%d%c", &rp->r_dayofmonth, &xs) != 1 ||
1980  rp->r_dayofmonth <= 0 ||
1981  (rp->r_dayofmonth > len_months[1][rp->r_month]))
1982  {
1983  error(_("invalid day of month"));
1984  free(dp);
1985  return;
1986  }
1987  }
1988  free(dp);
1989 }
1990 
1991 static void
1992 convert(const int32 val, char *const buf)
1993 {
1994  int i;
1995  int shift;
1996  unsigned char *const b = (unsigned char *) buf;
1997 
1998  for (i = 0, shift = 24; i < 4; ++i, shift -= 8)
1999  b[i] = val >> shift;
2000 }
2001 
2002 static void
2003 convert64(const zic_t val, char *const buf)
2004 {
2005  int i;
2006  int shift;
2007  unsigned char *const b = (unsigned char *) buf;
2008 
2009  for (i = 0, shift = 56; i < 8; ++i, shift -= 8)
2010  b[i] = val >> shift;
2011 }
2012 
2013 static void
2014 puttzcode(const int32 val, FILE *const fp)
2015 {
2016  char buf[4];
2017 
2018  convert(val, buf);
2019  fwrite(buf, sizeof buf, 1, fp);
2020 }
2021 
2022 static void
2023 puttzcodepass(zic_t val, FILE *fp, int pass)
2024 {
2025  if (pass == 1)
2026  puttzcode(val, fp);
2027  else
2028  {
2029  char buf[8];
2030 
2031  convert64(val, buf);
2032  fwrite(buf, sizeof buf, 1, fp);
2033  }
2034 }
2035 
2036 static int
2037 atcomp(const void *avp, const void *bvp)
2038 {
2039  const zic_t a = ((const struct attype *) avp)->at;
2040  const zic_t b = ((const struct attype *) bvp)->at;
2041 
2042  return (a < b) ? -1 : (a > b);
2043 }
2044 
2046 {
2048  ptrdiff_t base,
2052 };
2053 
2054 static struct timerange
2055 limitrange(struct timerange r, zic_t lo, zic_t hi,
2056  zic_t const *ats, unsigned char const *types)
2057 {
2058  while (0 < r.count && ats[r.base] < lo)
2059  {
2060  r.defaulttype = types[r.base];
2061  r.count--;
2062  r.base++;
2063  }
2064  while (0 < r.leapcount && trans[r.leapbase] < lo)
2065  {
2066  r.leapcount--;
2067  r.leapbase++;
2068  }
2069 
2070  if (hi < ZIC_MAX)
2071  {
2072  while (0 < r.count && hi + 1 < ats[r.base + r.count - 1])
2073  r.count--;
2074  while (0 < r.leapcount && hi + 1 < trans[r.leapbase + r.leapcount - 1])
2075  r.leapcount--;
2076  }
2077 
2078  return r;
2079 }
2080 
2081 static void
2082 writezone(const char *const name, const char *const string, char version,
2083  int defaulttype)
2084 {
2085  FILE *fp;
2086  ptrdiff_t i,
2087  j;
2088  int pass;
2089  static const struct tzhead tzh0;
2090  static struct tzhead tzh;
2091  bool dir_checked = false;
2092  zic_t one = 1;
2093  zic_t y2038_boundary = one << 31;
2094  ptrdiff_t nats = timecnt + WORK_AROUND_QTBUG_53071;
2095 
2096  /*
2097  * Allocate the ATS and TYPES arrays via a single malloc, as this is a bit
2098  * faster.
2099  */
2100  zic_t *ats = emalloc(MAXALIGN(size_product(nats, sizeof *ats + 1)));
2101  void *typesptr = ats + nats;
2102  unsigned char *types = typesptr;
2103  struct timerange rangeall,
2104  range32,
2105  range64;
2106 
2107  /*
2108  * Sort.
2109  */
2110  if (timecnt > 1)
2111  qsort(attypes, timecnt, sizeof *attypes, atcomp);
2112 
2113  /*
2114  * Optimize.
2115  */
2116  {
2117  ptrdiff_t fromi,
2118  toi;
2119 
2120  toi = 0;
2121  fromi = 0;
2122  for (; fromi < timecnt; ++fromi)
2123  {
2124  if (toi != 0
2125  && ((attypes[fromi].at
2126  + utoffs[attypes[toi - 1].type])
2127  <= (attypes[toi - 1].at
2128  + utoffs[toi == 1 ? 0
2129  : attypes[toi - 2].type])))
2130  {
2131  attypes[toi - 1].type =
2132  attypes[fromi].type;
2133  continue;
2134  }
2135  if (toi == 0
2136  || attypes[fromi].dontmerge
2137  || (utoffs[attypes[toi - 1].type]
2138  != utoffs[attypes[fromi].type])
2139  || (isdsts[attypes[toi - 1].type]
2140  != isdsts[attypes[fromi].type])
2141  || (desigidx[attypes[toi - 1].type]
2142  != desigidx[attypes[fromi].type]))
2143  attypes[toi++] = attypes[fromi];
2144  }
2145  timecnt = toi;
2146  }
2147 
2148  if (noise && timecnt > 1200)
2149  {
2150  if (timecnt > TZ_MAX_TIMES)
2151  warning(_("reference clients mishandle"
2152  " more than %d transition times"),
2153  TZ_MAX_TIMES);
2154  else
2155  warning(_("pre-2014 clients may mishandle"
2156  " more than 1200 transition times"));
2157  }
2158 
2159  /*
2160  * Transfer.
2161  */
2162  for (i = 0; i < timecnt; ++i)
2163  {
2164  ats[i] = attypes[i].at;
2165  types[i] = attypes[i].type;
2166  }
2167 
2168  /*
2169  * Correct for leap seconds.
2170  */
2171  for (i = 0; i < timecnt; ++i)
2172  {
2173  j = leapcnt;
2174  while (--j >= 0)
2175  if (ats[i] > trans[j] - corr[j])
2176  {
2177  ats[i] = tadd(ats[i], corr[j]);
2178  break;
2179  }
2180  }
2181 
2182  /*
2183  * Work around QTBUG-53071 for timestamps less than y2038_boundary - 1, by
2184  * inserting a no-op transition at time y2038_boundary - 1. This works
2185  * only for timestamps before the boundary, which should be good enough in
2186  * practice as QTBUG-53071 should be long-dead by 2038. Do this after
2187  * correcting for leap seconds, as the idea is to insert a transition just
2188  * before 32-bit pg_time_t rolls around, and this occurs at a slightly
2189  * different moment if transitions are leap-second corrected.
2190  */
2191  if (WORK_AROUND_QTBUG_53071 && timecnt != 0 && want_bloat()
2192  && ats[timecnt - 1] < y2038_boundary - 1 && strchr(string, '<'))
2193  {
2194  ats[timecnt] = y2038_boundary - 1;
2195  types[timecnt] = types[timecnt - 1];
2196  timecnt++;
2197  }
2198 
2199  rangeall.defaulttype = defaulttype;
2200  rangeall.base = rangeall.leapbase = 0;
2201  rangeall.count = timecnt;
2202  rangeall.leapcount = leapcnt;
2203  range64 = limitrange(rangeall, lo_time, hi_time, ats, types);
2204  range32 = limitrange(range64, PG_INT32_MIN, PG_INT32_MAX, ats, types);
2205 
2206  /*
2207  * Remove old file, if any, to snap links.
2208  */
2209  if (remove(name) == 0)
2210  dir_checked = true;
2211  else if (errno != ENOENT)
2212  {
2213  const char *e = strerror(errno);
2214 
2215  fprintf(stderr, _("%s: Cannot remove %s/%s: %s\n"),
2216  progname, directory, name, e);
2217  exit(EXIT_FAILURE);
2218  }
2219  fp = fopen(name, "wb");
2220  if (!fp)
2221  {
2222  int fopen_errno = errno;
2223 
2224  if (fopen_errno == ENOENT && !dir_checked)
2225  {
2226  mkdirs(name, true);
2227  fp = fopen(name, "wb");
2228  fopen_errno = errno;
2229  }
2230  if (!fp)
2231  {
2232  fprintf(stderr, _("%s: Cannot create %s/%s: %s\n"),
2233  progname, directory, name, strerror(fopen_errno));
2234  exit(EXIT_FAILURE);
2235  }
2236  }
2237  for (pass = 1; pass <= 2; ++pass)
2238  {
2239  ptrdiff_t thistimei,
2240  thistimecnt,
2241  thistimelim;
2242  int thisleapi,
2243  thisleapcnt,
2244  thisleaplim;
2245  int currenttype,
2246  thisdefaulttype;
2247  bool locut,
2248  hicut;
2249  zic_t lo;
2250  int old0;
2251  char omittype[TZ_MAX_TYPES];
2252  int typemap[TZ_MAX_TYPES];
2253  int thistypecnt,
2254  stdcnt,
2255  utcnt;
2256  char thischars[TZ_MAX_CHARS];
2257  int thischarcnt;
2258  bool toomanytimes;
2259  int indmap[TZ_MAX_CHARS];
2260 
2261  if (pass == 1)
2262  {
2263  /*
2264  * Arguably the default time type in the 32-bit data should be
2265  * range32.defaulttype, which is suited for timestamps just before
2266  * PG_INT32_MIN. However, zic traditionally used the time type of
2267  * the indefinite past instead. Internet RFC 8532 says readers
2268  * should ignore 32-bit data, so this discrepancy matters only to
2269  * obsolete readers where the traditional type might be more
2270  * appropriate even if it's "wrong". So, use the historical zic
2271  * value, unless -r specifies a low cutoff that excludes some
2272  * 32-bit timestamps.
2273  */
2274  thisdefaulttype = (lo_time <= PG_INT32_MIN
2275  ? range64.defaulttype
2276  : range32.defaulttype);
2277 
2278  thistimei = range32.base;
2279  thistimecnt = range32.count;
2280  toomanytimes = thistimecnt >> 31 >> 1 != 0;
2281  thisleapi = range32.leapbase;
2282  thisleapcnt = range32.leapcount;
2283  locut = PG_INT32_MIN < lo_time;
2284  hicut = hi_time < PG_INT32_MAX;
2285  }
2286  else
2287  {
2288  thisdefaulttype = range64.defaulttype;
2289  thistimei = range64.base;
2290  thistimecnt = range64.count;
2291  toomanytimes = thistimecnt >> 31 >> 31 >> 2 != 0;
2292  thisleapi = range64.leapbase;
2293  thisleapcnt = range64.leapcount;
2294  locut = min_time < lo_time;
2295  hicut = hi_time < max_time;
2296  }
2297  if (toomanytimes)
2298  error(_("too many transition times"));
2299 
2300  /*
2301  * Keep the last too-low transition if no transition is exactly at LO.
2302  * The kept transition will be output as a LO "transition"; see
2303  * "Output a LO_TIME transition" below. This is needed when the
2304  * output is truncated at the start, and is also useful when catering
2305  * to buggy 32-bit clients that do not use time type 0 for timestamps
2306  * before the first transition.
2307  */
2308  if (0 < thistimei && ats[thistimei] != lo_time)
2309  {
2310  thistimei--;
2311  thistimecnt++;
2312  locut = false;
2313  }
2314 
2315  thistimelim = thistimei + thistimecnt;
2316  thisleaplim = thisleapi + thisleapcnt;
2317  if (thistimecnt != 0)
2318  {
2319  if (ats[thistimei] == lo_time)
2320  locut = false;
2321  if (hi_time < ZIC_MAX && ats[thistimelim - 1] == hi_time + 1)
2322  hicut = false;
2323  }
2324  memset(omittype, true, typecnt);
2325  omittype[thisdefaulttype] = false;
2326  for (i = thistimei; i < thistimelim; i++)
2327  omittype[types[i]] = false;
2328 
2329  /*
2330  * Reorder types to make THISDEFAULTTYPE type 0. Use TYPEMAP to swap
2331  * OLD0 and THISDEFAULTTYPE so that THISDEFAULTTYPE appears as type 0
2332  * in the output instead of OLD0. TYPEMAP also omits unused types.
2333  */
2334  old0 = strlen(omittype);
2335 
2336 #ifndef LEAVE_SOME_PRE_2011_SYSTEMS_IN_THE_LURCH
2337 
2338  /*
2339  * For some pre-2011 systems: if the last-to-be-written standard (or
2340  * daylight) type has an offset different from the most recently used
2341  * offset, append an (unused) copy of the most recently used type (to
2342  * help get global "altzone" and "timezone" variables set correctly).
2343  */
2344  if (want_bloat())
2345  {
2346  int mrudst,
2347  mrustd,
2348  hidst,
2349  histd,
2350  type;
2351 
2352  hidst = histd = mrudst = mrustd = -1;
2353  for (i = thistimei; i < thistimelim; ++i)
2354  if (isdsts[types[i]])
2355  mrudst = types[i];
2356  else
2357  mrustd = types[i];
2358  for (i = old0; i < typecnt; i++)
2359  {
2360  int h = (i == old0 ? thisdefaulttype
2361  : i == thisdefaulttype ? old0 : i);
2362 
2363  if (!omittype[h])
2364  {
2365  if (isdsts[h])
2366  hidst = i;
2367  else
2368  histd = i;
2369  }
2370  }
2371  if (hidst >= 0 && mrudst >= 0 && hidst != mrudst &&
2372  utoffs[hidst] != utoffs[mrudst])
2373  {
2374  isdsts[mrudst] = -1;
2375  type = addtype(utoffs[mrudst],
2376  &chars[desigidx[mrudst]],
2377  true,
2378  ttisstds[mrudst],
2379  ttisuts[mrudst]);
2380  isdsts[mrudst] = 1;
2381  omittype[type] = false;
2382  }
2383  if (histd >= 0 && mrustd >= 0 && histd != mrustd &&
2384  utoffs[histd] != utoffs[mrustd])
2385  {
2386  isdsts[mrustd] = -1;
2387  type = addtype(utoffs[mrustd],
2388  &chars[desigidx[mrustd]],
2389  false,
2390  ttisstds[mrustd],
2391  ttisuts[mrustd]);
2392  isdsts[mrustd] = 0;
2393  omittype[type] = false;
2394  }
2395  }
2396 #endif /* !defined
2397  * LEAVE_SOME_PRE_2011_SYSTEMS_IN_THE_LURCH */
2398  thistypecnt = 0;
2399  for (i = old0; i < typecnt; i++)
2400  if (!omittype[i])
2401  typemap[i == old0 ? thisdefaulttype
2402  : i == thisdefaulttype ? old0 : i]
2403  = thistypecnt++;
2404 
2405  for (i = 0; i < sizeof indmap / sizeof indmap[0]; ++i)
2406  indmap[i] = -1;
2407  thischarcnt = stdcnt = utcnt = 0;
2408  for (i = old0; i < typecnt; i++)
2409  {
2410  char *thisabbr;
2411 
2412  if (omittype[i])
2413  continue;
2414  if (ttisstds[i])
2415  stdcnt = thistypecnt;
2416  if (ttisuts[i])
2417  utcnt = thistypecnt;
2418  if (indmap[desigidx[i]] >= 0)
2419  continue;
2420  thisabbr = &chars[desigidx[i]];
2421  for (j = 0; j < thischarcnt; ++j)
2422  if (strcmp(&thischars[j], thisabbr) == 0)
2423  break;
2424  if (j == thischarcnt)
2425  {
2426  strcpy(&thischars[thischarcnt], thisabbr);
2427  thischarcnt += strlen(thisabbr) + 1;
2428  }
2429  indmap[desigidx[i]] = j;
2430  }
2431  if (pass == 1 && !want_bloat())
2432  {
2433  utcnt = stdcnt = thisleapcnt = 0;
2434  thistimecnt = -(locut + hicut);
2435  thistypecnt = thischarcnt = 1;
2436  thistimelim = thistimei;
2437  }
2438 #define DO(field) fwrite(tzh.field, sizeof tzh.field, 1, fp)
2439  tzh = tzh0;
2440  memcpy(tzh.tzh_magic, TZ_MAGIC, sizeof tzh.tzh_magic);
2441  tzh.tzh_version[0] = version;
2442  convert(utcnt, tzh.tzh_ttisutcnt);
2443  convert(stdcnt, tzh.tzh_ttisstdcnt);
2444  convert(thisleapcnt, tzh.tzh_leapcnt);
2445  convert(locut + thistimecnt + hicut, tzh.tzh_timecnt);
2446  convert(thistypecnt, tzh.tzh_typecnt);
2447  convert(thischarcnt, tzh.tzh_charcnt);
2448  DO(tzh_magic);
2449  DO(tzh_version);
2450  DO(tzh_reserved);
2451  DO(tzh_ttisutcnt);
2452  DO(tzh_ttisstdcnt);
2453  DO(tzh_leapcnt);
2454  DO(tzh_timecnt);
2455  DO(tzh_typecnt);
2456  DO(tzh_charcnt);
2457 #undef DO
2458  if (pass == 1 && !want_bloat())
2459  {
2460  /* Output a minimal data block with just one time type. */
2461  puttzcode(0, fp); /* utoff */
2462  putc(0, fp); /* dst */
2463  putc(0, fp); /* index of abbreviation */
2464  putc(0, fp); /* empty-string abbreviation */
2465  continue;
2466  }
2467 
2468  /* PG: print current timezone abbreviations if requested */
2469  if (print_abbrevs && pass == 2)
2470  {
2471  /* Print "type" data for periods ending after print_cutoff */
2472  for (i = thistimei; i < thistimelim; ++i)
2473  {
2474  if (i == thistimelim - 1 || ats[i + 1] > print_cutoff)
2475  {
2476  unsigned char tm = types[i];
2477  char *thisabbrev = &thischars[indmap[desigidx[tm]]];
2478 
2479  fprintf(stdout, "%s\t" INT64_FORMAT "%s\n",
2480  thisabbrev,
2481  utoffs[tm],
2482  isdsts[tm] ? "\tD" : "");
2483  }
2484  }
2485  /* Print the default type if we have no transitions at all */
2486  if (thistimei >= thistimelim)
2487  {
2488  unsigned char tm = defaulttype;
2489  char *thisabbrev = &thischars[indmap[desigidx[tm]]];
2490 
2491  fprintf(stdout, "%s\t" INT64_FORMAT "%s\n",
2492  thisabbrev,
2493  utoffs[tm],
2494  isdsts[tm] ? "\tD" : "");
2495  }
2496  }
2497 
2498  /*
2499  * Output a LO_TIME transition if needed; see limitrange. But do not
2500  * go below the minimum representable value for this pass.
2501  */
2502  lo = pass == 1 && lo_time < PG_INT32_MIN ? PG_INT32_MIN : lo_time;
2503 
2504  if (locut)
2505  puttzcodepass(lo, fp, pass);
2506  for (i = thistimei; i < thistimelim; ++i)
2507  {
2508  zic_t at = ats[i] < lo ? lo : ats[i];
2509 
2510  puttzcodepass(at, fp, pass);
2511  }
2512  if (hicut)
2513  puttzcodepass(hi_time + 1, fp, pass);
2514  currenttype = 0;
2515  if (locut)
2516  putc(currenttype, fp);
2517  for (i = thistimei; i < thistimelim; ++i)
2518  {
2519  currenttype = typemap[types[i]];
2520  putc(currenttype, fp);
2521  }
2522  if (hicut)
2523  putc(currenttype, fp);
2524 
2525  for (i = old0; i < typecnt; i++)
2526  {
2527  int h = (i == old0 ? thisdefaulttype
2528  : i == thisdefaulttype ? old0 : i);
2529 
2530  if (!omittype[h])
2531  {
2532  puttzcode(utoffs[h], fp);
2533  putc(isdsts[h], fp);
2534  putc(indmap[desigidx[h]], fp);
2535  }
2536  }
2537  if (thischarcnt != 0)
2538  fwrite(thischars, sizeof thischars[0],
2539  thischarcnt, fp);
2540  for (i = thisleapi; i < thisleaplim; ++i)
2541  {
2542  zic_t todo;
2543 
2544  if (roll[i])
2545  {
2546  if (timecnt == 0 || trans[i] < ats[0])
2547  {
2548  j = 0;
2549  while (isdsts[j])
2550  if (++j >= typecnt)
2551  {
2552  j = 0;
2553  break;
2554  }
2555  }
2556  else
2557  {
2558  j = 1;
2559  while (j < timecnt &&
2560  trans[i] >= ats[j])
2561  ++j;
2562  j = types[j - 1];
2563  }
2564  todo = tadd(trans[i], -utoffs[j]);
2565  }
2566  else
2567  todo = trans[i];
2568  puttzcodepass(todo, fp, pass);
2569  puttzcode(corr[i], fp);
2570  }
2571  if (stdcnt != 0)
2572  for (i = old0; i < typecnt; i++)
2573  if (!omittype[i])
2574  putc(ttisstds[i], fp);
2575  if (utcnt != 0)
2576  for (i = old0; i < typecnt; i++)
2577  if (!omittype[i])
2578  putc(ttisuts[i], fp);
2579  }
2580  fprintf(fp, "\n%s\n", string);
2581  close_file(fp, directory, name);
2582  free(ats);
2583 }
2584 
2585 static char const *
2586 abbroffset(char *buf, zic_t offset)
2587 {
2588  char sign = '+';
2589  int seconds,
2590  minutes;
2591 
2592  if (offset < 0)
2593  {
2594  offset = -offset;
2595  sign = '-';
2596  }
2597 
2598  seconds = offset % SECSPERMIN;
2599  offset /= SECSPERMIN;
2600  minutes = offset % MINSPERHOUR;
2601  offset /= MINSPERHOUR;
2602  if (100 <= offset)
2603  {
2604  error(_("%%z UT offset magnitude exceeds 99:59:59"));
2605  return "%z";
2606  }
2607  else
2608  {
2609  char *p = buf;
2610 
2611  *p++ = sign;
2612  *p++ = '0' + offset / 10;
2613  *p++ = '0' + offset % 10;
2614  if (minutes | seconds)
2615  {
2616  *p++ = '0' + minutes / 10;
2617  *p++ = '0' + minutes % 10;
2618  if (seconds)
2619  {
2620  *p++ = '0' + seconds / 10;
2621  *p++ = '0' + seconds % 10;
2622  }
2623  }
2624  *p = '\0';
2625  return buf;
2626  }
2627 }
2628 
2629 static size_t
2630 doabbr(char *abbr, struct zone const *zp, char const *letters,
2631  bool isdst, zic_t save, bool doquotes)
2632 {
2633  char *cp;
2634  char *slashp;
2635  size_t len;
2636  char const *format = zp->z_format;
2637 
2638  slashp = strchr(format, '/');
2639  if (slashp == NULL)
2640  {
2641  char letterbuf[PERCENT_Z_LEN_BOUND + 1];
2642 
2643  if (zp->z_format_specifier == 'z')
2644  letters = abbroffset(letterbuf, zp->z_stdoff + save);
2645  else if (!letters)
2646  letters = "%s";
2647  sprintf(abbr, format, letters);
2648  }
2649  else if (isdst)
2650  {
2651  strcpy(abbr, slashp + 1);
2652  }
2653  else
2654  {
2655  memcpy(abbr, format, slashp - format);
2656  abbr[slashp - format] = '\0';
2657  }
2658  len = strlen(abbr);
2659  if (!doquotes)
2660  return len;
2661  for (cp = abbr; is_alpha(*cp); cp++)
2662  continue;
2663  if (len > 0 && *cp == '\0')
2664  return len;
2665  abbr[len + 2] = '\0';
2666  abbr[len + 1] = '>';
2667  memmove(abbr + 1, abbr, len);
2668  abbr[0] = '<';
2669  return len + 2;
2670 }
2671 
2672 static void
2674 {
2675  if (min_year > x)
2676  min_year = x;
2677  if (max_year < x)
2678  max_year = x;
2679 }
2680 
2681 static int
2682 stringoffset(char *result, zic_t offset)
2683 {
2684  int hours;
2685  int minutes;
2686  int seconds;
2687  bool negative = offset < 0;
2688  int len = negative;
2689 
2690  if (negative)
2691  {
2692  offset = -offset;
2693  result[0] = '-';
2694  }
2695  seconds = offset % SECSPERMIN;
2696  offset /= SECSPERMIN;
2697  minutes = offset % MINSPERHOUR;
2698  offset /= MINSPERHOUR;
2699  hours = offset;
2700  if (hours >= HOURSPERDAY * DAYSPERWEEK)
2701  {
2702  result[0] = '\0';
2703  return 0;
2704  }
2705  len += sprintf(result + len, "%d", hours);
2706  if (minutes != 0 || seconds != 0)
2707  {
2708  len += sprintf(result + len, ":%02d", minutes);
2709  if (seconds != 0)
2710  len += sprintf(result + len, ":%02d", seconds);
2711  }
2712  return len;
2713 }
2714 
2715 static int
2716 stringrule(char *result, struct rule *const rp, zic_t save, zic_t stdoff)
2717 {
2718  zic_t tod = rp->r_tod;
2719  int compat = 0;
2720 
2721  if (rp->r_dycode == DC_DOM)
2722  {
2723  int month,
2724  total;
2725 
2726  if (rp->r_dayofmonth == 29 && rp->r_month == TM_FEBRUARY)
2727  return -1;
2728  total = 0;
2729  for (month = 0; month < rp->r_month; ++month)
2730  total += len_months[0][month];
2731  /* Omit the "J" in Jan and Feb, as that's shorter. */
2732  if (rp->r_month <= 1)
2733  result += sprintf(result, "%d", total + rp->r_dayofmonth - 1);
2734  else
2735  result += sprintf(result, "J%d", total + rp->r_dayofmonth);
2736  }
2737  else
2738  {
2739  int week;
2740  int wday = rp->r_wday;
2741  int wdayoff;
2742 
2743  if (rp->r_dycode == DC_DOWGEQ)
2744  {
2745  wdayoff = (rp->r_dayofmonth - 1) % DAYSPERWEEK;
2746  if (wdayoff)
2747  compat = 2013;
2748  wday -= wdayoff;
2749  tod += wdayoff * SECSPERDAY;
2750  week = 1 + (rp->r_dayofmonth - 1) / DAYSPERWEEK;
2751  }
2752  else if (rp->r_dycode == DC_DOWLEQ)
2753  {
2754  if (rp->r_dayofmonth == len_months[1][rp->r_month])
2755  week = 5;
2756  else
2757  {
2758  wdayoff = rp->r_dayofmonth % DAYSPERWEEK;
2759  if (wdayoff)
2760  compat = 2013;
2761  wday -= wdayoff;
2762  tod += wdayoff * SECSPERDAY;
2763  week = rp->r_dayofmonth / DAYSPERWEEK;
2764  }
2765  }
2766  else
2767  return -1; /* "cannot happen" */
2768  if (wday < 0)
2769  wday += DAYSPERWEEK;
2770  result += sprintf(result, "M%d.%d.%d",
2771  rp->r_month + 1, week, wday);
2772  }
2773  if (rp->r_todisut)
2774  tod += stdoff;
2775  if (rp->r_todisstd && !rp->r_isdst)
2776  tod += save;
2777  if (tod != 2 * SECSPERMIN * MINSPERHOUR)
2778  {
2779  *result++ = '/';
2780  if (!stringoffset(result, tod))
2781  return -1;
2782  if (tod < 0)
2783  {
2784  if (compat < 2013)
2785  compat = 2013;
2786  }
2787  else if (SECSPERDAY <= tod)
2788  {
2789  if (compat < 1994)
2790  compat = 1994;
2791  }
2792  }
2793  return compat;
2794 }
2795 
2796 static int
2797 rule_cmp(struct rule const *a, struct rule const *b)
2798 {
2799  if (!a)
2800  return -!!b;
2801  if (!b)
2802  return 1;
2803  if (a->r_hiyear != b->r_hiyear)
2804  return a->r_hiyear < b->r_hiyear ? -1 : 1;
2805  if (a->r_month - b->r_month != 0)
2806  return a->r_month - b->r_month;
2807  return a->r_dayofmonth - b->r_dayofmonth;
2808 }
2809 
2810 static int
2811 stringzone(char *result, struct zone const *zpfirst, ptrdiff_t zonecount)
2812 {
2813  const struct zone *zp;
2814  struct rule *rp;
2815  struct rule *stdrp;
2816  struct rule *dstrp;
2817  ptrdiff_t i;
2818  const char *abbrvar;
2819  int compat = 0;
2820  int c;
2821  size_t len;
2822  int offsetlen;
2823  struct rule stdr,
2824  dstr;
2825 
2826  result[0] = '\0';
2827 
2828  /*
2829  * Internet RFC 8536 section 5.1 says to use an empty TZ string if future
2830  * timestamps are truncated.
2831  */
2832  if (hi_time < max_time)
2833  return -1;
2834 
2835  zp = zpfirst + zonecount - 1;
2836  stdrp = dstrp = NULL;
2837  for (i = 0; i < zp->z_nrules; ++i)
2838  {
2839  rp = &zp->z_rules[i];
2840  if (rp->r_hiwasnum || rp->r_hiyear != ZIC_MAX)
2841  continue;
2842  if (!rp->r_isdst)
2843  {
2844  if (stdrp == NULL)
2845  stdrp = rp;
2846  else
2847  return -1;
2848  }
2849  else
2850  {
2851  if (dstrp == NULL)
2852  dstrp = rp;
2853  else
2854  return -1;
2855  }
2856  }
2857  if (stdrp == NULL && dstrp == NULL)
2858  {
2859  /*
2860  * There are no rules running through "max". Find the latest std rule
2861  * in stdabbrrp and latest rule of any type in stdrp.
2862  */
2863  struct rule *stdabbrrp = NULL;
2864 
2865  for (i = 0; i < zp->z_nrules; ++i)
2866  {
2867  rp = &zp->z_rules[i];
2868  if (!rp->r_isdst && rule_cmp(stdabbrrp, rp) < 0)
2869  stdabbrrp = rp;
2870  if (rule_cmp(stdrp, rp) < 0)
2871  stdrp = rp;
2872  }
2873  if (stdrp != NULL && stdrp->r_isdst)
2874  {
2875  /* Perpetual DST. */
2876  dstr.r_month = TM_JANUARY;
2877  dstr.r_dycode = DC_DOM;
2878  dstr.r_dayofmonth = 1;
2879  dstr.r_tod = 0;
2880  dstr.r_todisstd = dstr.r_todisut = false;
2881  dstr.r_isdst = stdrp->r_isdst;
2882  dstr.r_save = stdrp->r_save;
2883  dstr.r_abbrvar = stdrp->r_abbrvar;
2884  stdr.r_month = TM_DECEMBER;
2885  stdr.r_dycode = DC_DOM;
2886  stdr.r_dayofmonth = 31;
2887  stdr.r_tod = SECSPERDAY + stdrp->r_save;
2888  stdr.r_todisstd = stdr.r_todisut = false;
2889  stdr.r_isdst = false;
2890  stdr.r_save = 0;
2891  stdr.r_abbrvar
2892  = (stdabbrrp ? stdabbrrp->r_abbrvar : "");
2893  dstrp = &dstr;
2894  stdrp = &stdr;
2895  }
2896  }
2897  if (stdrp == NULL && (zp->z_nrules != 0 || zp->z_isdst))
2898  return -1;
2899  abbrvar = (stdrp == NULL) ? "" : stdrp->r_abbrvar;
2900  len = doabbr(result, zp, abbrvar, false, 0, true);
2901  offsetlen = stringoffset(result + len, -zp->z_stdoff);
2902  if (!offsetlen)
2903  {
2904  result[0] = '\0';
2905  return -1;
2906  }
2907  len += offsetlen;
2908  if (dstrp == NULL)
2909  return compat;
2910  len += doabbr(result + len, zp, dstrp->r_abbrvar,
2911  dstrp->r_isdst, dstrp->r_save, true);
2912  if (dstrp->r_save != SECSPERMIN * MINSPERHOUR)
2913  {
2914  offsetlen = stringoffset(result + len,
2915  -(zp->z_stdoff + dstrp->r_save));
2916  if (!offsetlen)
2917  {
2918  result[0] = '\0';
2919  return -1;
2920  }
2921  len += offsetlen;
2922  }
2923  result[len++] = ',';
2924  c = stringrule(result + len, dstrp, dstrp->r_save, zp->z_stdoff);
2925  if (c < 0)
2926  {
2927  result[0] = '\0';
2928  return -1;
2929  }
2930  if (compat < c)
2931  compat = c;
2932  len += strlen(result + len);
2933  result[len++] = ',';
2934  c = stringrule(result + len, stdrp, dstrp->r_save, zp->z_stdoff);
2935  if (c < 0)
2936  {
2937  result[0] = '\0';
2938  return -1;
2939  }
2940  if (compat < c)
2941  compat = c;
2942  return compat;
2943 }
2944 
2945 static void
2946 outzone(const struct zone *zpfirst, ptrdiff_t zonecount)
2947 {
2948  const struct zone *zp;
2949  struct rule *rp;
2950  ptrdiff_t i,
2951  j;
2952  bool usestart,
2953  useuntil;
2954  zic_t starttime,
2955  untiltime;
2956  zic_t stdoff;
2957  zic_t save;
2958  zic_t year;
2959  zic_t startoff;
2960  bool startttisstd;
2961  bool startttisut;
2962  int type;
2963  char *startbuf;
2964  char *ab;
2965  char *envvar;
2966  int max_abbr_len;
2967  int max_envvar_len;
2968  bool prodstic; /* all rules are min to max */
2969  int compat;
2970  bool do_extend;
2971  char version;
2972  ptrdiff_t lastatmax = -1;
2973  zic_t one = 1;
2974  zic_t y2038_boundary = one << 31;
2975  zic_t max_year0;
2976  int defaulttype = -1;
2977 
2978  max_abbr_len = 2 + max_format_len + max_abbrvar_len;
2979  max_envvar_len = 2 * max_abbr_len + 5 * 9;
2980  startbuf = emalloc(max_abbr_len + 1);
2981  ab = emalloc(max_abbr_len + 1);
2982  envvar = emalloc(max_envvar_len + 1);
2983  INITIALIZE(untiltime);
2984  INITIALIZE(starttime);
2985 
2986  /*
2987  * Now. . .finally. . .generate some useful data!
2988  */
2989  timecnt = 0;
2990  typecnt = 0;
2991  charcnt = 0;
2992  prodstic = zonecount == 1;
2993 
2994  /*
2995  * Thanks to Earl Chew for noting the need to unconditionally initialize
2996  * startttisstd.
2997  */
2998  startttisstd = false;
2999  startttisut = false;
3001  if (leapseen)
3002  {
3005  }
3006  for (i = 0; i < zonecount; ++i)
3007  {
3008  zp = &zpfirst[i];
3009  if (i < zonecount - 1)
3011  for (j = 0; j < zp->z_nrules; ++j)
3012  {
3013  rp = &zp->z_rules[j];
3014  if (rp->r_lowasnum)
3015  updateminmax(rp->r_loyear);
3016  if (rp->r_hiwasnum)
3017  updateminmax(rp->r_hiyear);
3018  if (rp->r_lowasnum || rp->r_hiwasnum)
3019  prodstic = false;
3020  }
3021  }
3022 
3023  /*
3024  * Generate lots of data if a rule can't cover all future times.
3025  */
3026  compat = stringzone(envvar, zpfirst, zonecount);
3027  version = compat < 2013 ? ZIC_VERSION_PRE_2013 : ZIC_VERSION;
3028  do_extend = compat < 0;
3029  if (noise)
3030  {
3031  if (!*envvar)
3032  warning("%s %s",
3033  _("no POSIX environment variable for zone"),
3034  zpfirst->z_name);
3035  else if (compat != 0)
3036  {
3037  /*
3038  * Circa-COMPAT clients, and earlier clients, might not work for
3039  * this zone when given dates before 1970 or after 2038.
3040  */
3041  warning(_("%s: pre-%d clients may mishandle"
3042  " distant timestamps"),
3043  zpfirst->z_name, compat);
3044  }
3045  }
3046  if (do_extend)
3047  {
3048  /*
3049  * Search through a couple of extra years past the obvious 400, to
3050  * avoid edge cases. For example, suppose a non-POSIX rule applies
3051  * from 2012 onwards and has transitions in March and September, plus
3052  * some one-off transitions in November 2013. If zic looked only at
3053  * the last 400 years, it would set max_year=2413, with the intent
3054  * that the 400 years 2014 through 2413 will be repeated. The last
3055  * transition listed in the tzfile would be in 2413-09, less than 400
3056  * years after the last one-off transition in 2013-11. Two years
3057  * might be overkill, but with the kind of edge cases available we're
3058  * not sure that one year would suffice.
3059  */
3060  enum
3061  {
3062  years_of_observations = YEARSPERREPEAT + 2};
3063 
3064  if (min_year >= ZIC_MIN + years_of_observations)
3065  min_year -= years_of_observations;
3066  else
3067  min_year = ZIC_MIN;
3068  if (max_year <= ZIC_MAX - years_of_observations)
3069  max_year += years_of_observations;
3070  else
3071  max_year = ZIC_MAX;
3072 
3073  /*
3074  * Regardless of any of the above, for a "proDSTic" zone which
3075  * specifies that its rules always have and always will be in effect,
3076  * we only need one cycle to define the zone.
3077  */
3078  if (prodstic)
3079  {
3080  min_year = 1900;
3081  max_year = min_year + years_of_observations;
3082  }
3083  }
3084  max_year0 = max_year;
3085  if (want_bloat())
3086  {
3087  /*
3088  * For the benefit of older systems, generate data from 1900 through
3089  * 2038.
3090  */
3091  if (min_year > 1900)
3092  min_year = 1900;
3093  if (max_year < 2038)
3094  max_year = 2038;
3095  }
3096 
3097  for (i = 0; i < zonecount; ++i)
3098  {
3099  struct rule *prevrp = NULL;
3100 
3101  /*
3102  * A guess that may well be corrected later.
3103  */
3104  save = 0;
3105  zp = &zpfirst[i];
3106  usestart = i > 0 && (zp - 1)->z_untiltime > min_time;
3107  useuntil = i < (zonecount - 1);
3108  if (useuntil && zp->z_untiltime <= min_time)
3109  continue;
3110  stdoff = zp->z_stdoff;
3111  eat(zp->z_filename, zp->z_linenum);
3112  *startbuf = '\0';
3113  startoff = zp->z_stdoff;
3114  if (zp->z_nrules == 0)
3115  {
3116  save = zp->z_save;
3117  doabbr(startbuf, zp, NULL, zp->z_isdst, save, false);
3118  type = addtype(oadd(zp->z_stdoff, save),
3119  startbuf, zp->z_isdst, startttisstd,
3120  startttisut);
3121  if (usestart)
3122  {
3123  addtt(starttime, type);
3124  usestart = false;
3125  }
3126  else
3127  defaulttype = type;
3128  }
3129  else
3130  for (year = min_year; year <= max_year; ++year)
3131  {
3132  if (useuntil && year > zp->z_untilrule.r_hiyear)
3133  break;
3134 
3135  /*
3136  * Mark which rules to do in the current year. For those to
3137  * do, calculate rpytime(rp, year); The former TYPE field was
3138  * also considered here.
3139  */
3140  for (j = 0; j < zp->z_nrules; ++j)
3141  {
3142  rp = &zp->z_rules[j];
3143  eats(zp->z_filename, zp->z_linenum,
3144  rp->r_filename, rp->r_linenum);
3145  rp->r_todo = year >= rp->r_loyear &&
3146  year <= rp->r_hiyear;
3147  if (rp->r_todo)
3148  {
3149  rp->r_temp = rpytime(rp, year);
3150  rp->r_todo
3151  = (rp->r_temp < y2038_boundary
3152  || year <= max_year0);
3153  }
3154  }
3155  for (;;)
3156  {
3157  ptrdiff_t k;
3158  zic_t jtime,
3159  ktime;
3160  zic_t offset;
3161 
3162  INITIALIZE(ktime);
3163  if (useuntil)
3164  {
3165  /*
3166  * Turn untiltime into UT assuming the current stdoff
3167  * and save values.
3168  */
3169  untiltime = zp->z_untiltime;
3170  if (!zp->z_untilrule.r_todisut)
3171  untiltime = tadd(untiltime,
3172  -stdoff);
3173  if (!zp->z_untilrule.r_todisstd)
3174  untiltime = tadd(untiltime,
3175  -save);
3176  }
3177 
3178  /*
3179  * Find the rule (of those to do, if any) that takes
3180  * effect earliest in the year.
3181  */
3182  k = -1;
3183  for (j = 0; j < zp->z_nrules; ++j)
3184  {
3185  rp = &zp->z_rules[j];
3186  if (!rp->r_todo)
3187  continue;
3188  eats(zp->z_filename, zp->z_linenum,
3189  rp->r_filename, rp->r_linenum);
3190  offset = rp->r_todisut ? 0 : stdoff;
3191  if (!rp->r_todisstd)
3192  offset = oadd(offset, save);
3193  jtime = rp->r_temp;
3194  if (jtime == min_time ||
3195  jtime == max_time)
3196  continue;
3197  jtime = tadd(jtime, -offset);
3198  if (k < 0 || jtime < ktime)
3199  {
3200  k = j;
3201  ktime = jtime;
3202  }
3203  else if (jtime == ktime)
3204  {
3205  char const *dup_rules_msg =
3206  _("two rules for same instant");
3207 
3208  eats(zp->z_filename, zp->z_linenum,
3209  rp->r_filename, rp->r_linenum);
3210  warning("%s", dup_rules_msg);
3211  rp = &zp->z_rules[k];
3212  eats(zp->z_filename, zp->z_linenum,
3213  rp->r_filename, rp->r_linenum);
3214  error("%s", dup_rules_msg);
3215  }
3216  }
3217  if (k < 0)
3218  break; /* go on to next year */
3219  rp = &zp->z_rules[k];
3220  rp->r_todo = false;
3221  if (useuntil && ktime >= untiltime)
3222  break;
3223  save = rp->r_save;
3224  if (usestart && ktime == starttime)
3225  usestart = false;
3226  if (usestart)
3227  {
3228  if (ktime < starttime)
3229  {
3230  startoff = oadd(zp->z_stdoff,
3231  save);
3232  doabbr(startbuf, zp,
3233  rp->r_abbrvar,
3234  rp->r_isdst,
3235  rp->r_save,
3236  false);
3237  continue;
3238  }
3239  if (*startbuf == '\0'
3240  && startoff == oadd(zp->z_stdoff,
3241  save))
3242  {
3243  doabbr(startbuf,
3244  zp,
3245  rp->r_abbrvar,
3246  rp->r_isdst,
3247  rp->r_save,
3248  false);
3249  }
3250  }
3251  eats(zp->z_filename, zp->z_linenum,
3252  rp->r_filename, rp->r_linenum);
3253  doabbr(ab, zp, rp->r_abbrvar,
3254  rp->r_isdst, rp->r_save, false);
3255  offset = oadd(zp->z_stdoff, rp->r_save);
3256  if (!want_bloat() && !useuntil && !do_extend
3257  && prevrp
3258  && rp->r_hiyear == ZIC_MAX
3259  && prevrp->r_hiyear == ZIC_MAX)
3260  break;
3261  type = addtype(offset, ab, rp->r_isdst,
3262  rp->r_todisstd, rp->r_todisut);
3263  if (defaulttype < 0 && !rp->r_isdst)
3264  defaulttype = type;
3265  if (rp->r_hiyear == ZIC_MAX
3266  && !(0 <= lastatmax
3267  && ktime < attypes[lastatmax].at))
3268  lastatmax = timecnt;
3269  addtt(ktime, type);
3270  prevrp = rp;
3271  }
3272  }
3273  if (usestart)
3274  {
3275  if (*startbuf == '\0' &&
3276  zp->z_format != NULL &&
3277  strchr(zp->z_format, '%') == NULL &&
3278  strchr(zp->z_format, '/') == NULL)
3279  strcpy(startbuf, zp->z_format);
3280  eat(zp->z_filename, zp->z_linenum);
3281  if (*startbuf == '\0')
3282  error(_("cannot determine time zone abbreviation to use just after until time"));
3283  else
3284  {
3285  bool isdst = startoff != zp->z_stdoff;
3286 
3287  type = addtype(startoff, startbuf, isdst,
3288  startttisstd, startttisut);
3289  if (defaulttype < 0 && !isdst)
3290  defaulttype = type;
3291  addtt(starttime, type);
3292  }
3293  }
3294 
3295  /*
3296  * Now we may get to set starttime for the next zone line.
3297  */
3298  if (useuntil)
3299  {
3300  startttisstd = zp->z_untilrule.r_todisstd;
3301  startttisut = zp->z_untilrule.r_todisut;
3302  starttime = zp->z_untiltime;
3303  if (!startttisstd)
3304  starttime = tadd(starttime, -save);
3305  if (!startttisut)
3306  starttime = tadd(starttime, -stdoff);
3307  }
3308  }
3309  if (defaulttype < 0)
3310  defaulttype = 0;
3311  if (0 <= lastatmax)
3312  attypes[lastatmax].dontmerge = true;
3313  if (do_extend)
3314  {
3315  /*
3316  * If we're extending the explicitly listed observations for 400 years
3317  * because we can't fill the POSIX-TZ field, check whether we actually
3318  * ended up explicitly listing observations through that period. If
3319  * there aren't any near the end of the 400-year period, add a
3320  * redundant one at the end of the final year, to make it clear that
3321  * we are claiming to have definite knowledge of the lack of
3322  * transitions up to that point.
3323  */
3324  struct rule xr;
3325  struct attype *lastat;
3326 
3327  xr.r_month = TM_JANUARY;
3328  xr.r_dycode = DC_DOM;
3329  xr.r_dayofmonth = 1;
3330  xr.r_tod = 0;
3331  for (lastat = attypes, i = 1; i < timecnt; i++)
3332  if (attypes[i].at > lastat->at)
3333  lastat = &attypes[i];
3334  if (!lastat || lastat->at < rpytime(&xr, max_year - 1))
3335  {
3336  addtt(rpytime(&xr, max_year + 1),
3337  lastat ? lastat->type : defaulttype);
3338  attypes[timecnt - 1].dontmerge = true;
3339  }
3340  }
3341  writezone(zpfirst->z_name, envvar, version, defaulttype);
3342  free(startbuf);
3343  free(ab);
3344  free(envvar);
3345 }
3346 
3347 static void
3348 addtt(zic_t starttime, int type)
3349 {
3351  attypes[timecnt].at = starttime;
3352  attypes[timecnt].dontmerge = false;
3353  attypes[timecnt].type = type;
3354  ++timecnt;
3355 }
3356 
3357 static int
3358 addtype(zic_t utoff, char const *abbr, bool isdst, bool ttisstd, bool ttisut)
3359 {
3360  int i,
3361  j;
3362 
3363  if (!(-1L - 2147483647L <= utoff && utoff <= 2147483647L))
3364  {
3365  error(_("UT offset out of range"));
3366  exit(EXIT_FAILURE);
3367  }
3368  if (!want_bloat())
3369  ttisstd = ttisut = false;
3370 
3371  for (j = 0; j < charcnt; ++j)
3372  if (strcmp(&chars[j], abbr) == 0)
3373  break;
3374  if (j == charcnt)
3375  newabbr(abbr);
3376  else
3377  {
3378  /* If there's already an entry, return its index. */
3379  for (i = 0; i < typecnt; i++)
3380  if (utoff == utoffs[i] && isdst == isdsts[i] && j == desigidx[i]
3381  && ttisstd == ttisstds[i] && ttisut == ttisuts[i])
3382  return i;
3383  }
3384 
3385  /*
3386  * There isn't one; add a new one, unless there are already too many.
3387  */
3388  if (typecnt >= TZ_MAX_TYPES)
3389  {
3390  error(_("too many local time types"));
3391  exit(EXIT_FAILURE);
3392  }
3393  i = typecnt++;
3394  utoffs[i] = utoff;
3395  isdsts[i] = isdst;
3396  ttisstds[i] = ttisstd;
3397  ttisuts[i] = ttisut;
3398  desigidx[i] = j;
3399  return i;
3400 }
3401 
3402 static void
3403 leapadd(zic_t t, int correction, int rolling)
3404 {
3405  int i;
3406 
3407  if (TZ_MAX_LEAPS <= leapcnt)
3408  {
3409  error(_("too many leap seconds"));
3410  exit(EXIT_FAILURE);
3411  }
3412  for (i = 0; i < leapcnt; ++i)
3413  if (t <= trans[i])
3414  break;
3415  memmove(&trans[i + 1], &trans[i], (leapcnt - i) * sizeof *trans);
3416  memmove(&corr[i + 1], &corr[i], (leapcnt - i) * sizeof *corr);
3417  memmove(&roll[i + 1], &roll[i], (leapcnt - i) * sizeof *roll);
3418  trans[i] = t;
3419  corr[i] = correction;
3420  roll[i] = rolling;
3421  ++leapcnt;
3422 }
3423 
3424 static void
3425 adjleap(void)
3426 {
3427  int i;
3428  zic_t last = 0;
3429  zic_t prevtrans = 0;
3430 
3431  /*
3432  * propagate leap seconds forward
3433  */
3434  for (i = 0; i < leapcnt; ++i)
3435  {
3436  if (trans[i] - prevtrans < 28 * SECSPERDAY)
3437  {
3438  error(_("Leap seconds too close together"));
3439  exit(EXIT_FAILURE);
3440  }
3441  prevtrans = trans[i];
3442  trans[i] = tadd(trans[i], last);
3443  last = corr[i] += last;
3444  }
3445 
3446  if (leapexpires < 0)
3447  {
3449  if (0 <= leapexpires)
3450  warning(_("\"#expires\" is obsolescent; use \"Expires\""));
3451  }
3452 
3453  if (0 <= leapexpires)
3454  {
3455  leapexpires = oadd(leapexpires, last);
3456  if (!(leapcnt == 0 || (trans[leapcnt - 1] < leapexpires)))
3457  {
3458  error(_("last Leap time does not precede Expires time"));
3459  exit(EXIT_FAILURE);
3460  }
3461  if (leapexpires <= hi_time)
3462  hi_time = leapexpires - 1;
3463  }
3464 }
3465 
3466 /* Is A a space character in the C locale? */
3467 static bool
3469 {
3470  switch (a)
3471  {
3472  default:
3473  return false;
3474  case ' ':
3475  case '\f':
3476  case '\n':
3477  case '\r':
3478  case '\t':
3479  case '\v':
3480  return true;
3481  }
3482 }
3483 
3484 /* Is A an alphabetic character in the C locale? */
3485 static bool
3487 {
3488  switch (a)
3489  {
3490  default:
3491  return false;
3492  case 'A':
3493  case 'B':
3494  case 'C':
3495  case 'D':
3496  case 'E':
3497  case 'F':
3498  case 'G':
3499  case 'H':
3500  case 'I':
3501  case 'J':
3502  case 'K':
3503  case 'L':
3504  case 'M':
3505  case 'N':
3506  case 'O':
3507  case 'P':
3508  case 'Q':
3509  case 'R':
3510  case 'S':
3511  case 'T':
3512  case 'U':
3513  case 'V':
3514  case 'W':
3515  case 'X':
3516  case 'Y':
3517  case 'Z':
3518  case 'a':
3519  case 'b':
3520  case 'c':
3521  case 'd':
3522  case 'e':
3523  case 'f':
3524  case 'g':
3525  case 'h':
3526  case 'i':
3527  case 'j':
3528  case 'k':
3529  case 'l':
3530  case 'm':
3531  case 'n':
3532  case 'o':
3533  case 'p':
3534  case 'q':
3535  case 'r':
3536  case 's':
3537  case 't':
3538  case 'u':
3539  case 'v':
3540  case 'w':
3541  case 'x':
3542  case 'y':
3543  case 'z':
3544  return true;
3545  }
3546 }
3547 
3548 /* If A is an uppercase character in the C locale, return its lowercase
3549  counterpart. Otherwise, return A. */
3550 static char
3551 lowerit(char a)
3552 {
3553  switch (a)
3554  {
3555  default:
3556  return a;
3557  case 'A':
3558  return 'a';
3559  case 'B':
3560  return 'b';
3561  case 'C':
3562  return 'c';
3563  case 'D':
3564  return 'd';
3565  case 'E':
3566  return 'e';
3567  case 'F':
3568  return 'f';
3569  case 'G':
3570  return 'g';
3571  case 'H':
3572  return 'h';
3573  case 'I':
3574  return 'i';
3575  case 'J':
3576  return 'j';
3577  case 'K':
3578  return 'k';
3579  case 'L':
3580  return 'l';
3581  case 'M':
3582  return 'm';
3583  case 'N':
3584  return 'n';
3585  case 'O':
3586  return 'o';
3587  case 'P':
3588  return 'p';
3589  case 'Q':
3590  return 'q';
3591  case 'R':
3592  return 'r';
3593  case 'S':
3594  return 's';
3595  case 'T':
3596  return 't';
3597  case 'U':
3598  return 'u';
3599  case 'V':
3600  return 'v';
3601  case 'W':
3602  return 'w';
3603  case 'X':
3604  return 'x';
3605  case 'Y':
3606  return 'y';
3607  case 'Z':
3608  return 'z';
3609  }
3610 }
3611 
3612 /* case-insensitive equality */
3613 static bool
3614 ciequal(const char *ap, const char *bp)
3615 {
3616  while (lowerit(*ap) == lowerit(*bp++))
3617  if (*ap++ == '\0')
3618  return true;
3619  return false;
3620 }
3621 
3622 static bool
3623 itsabbr(const char *abbr, const char *word)
3624 {
3625  if (lowerit(*abbr) != lowerit(*word))
3626  return false;
3627  ++word;
3628  while (*++abbr != '\0')
3629  do
3630  {
3631  if (*word == '\0')
3632  return false;
3633  } while (lowerit(*word++) != lowerit(*abbr));
3634  return true;
3635 }
3636 
3637 /* Return true if ABBR is an initial prefix of WORD, ignoring ASCII case. */
3638 
3639 static bool
3640 ciprefix(char const *abbr, char const *word)
3641 {
3642  do
3643  if (!*abbr)
3644  return true;
3645  while (lowerit(*abbr++) == lowerit(*word++));
3646 
3647  return false;
3648 }
3649 
3650 static const struct lookup *
3651 byword(const char *word, const struct lookup *table)
3652 {
3653  const struct lookup *foundlp;
3654  const struct lookup *lp;
3655 
3656  if (word == NULL || table == NULL)
3657  return NULL;
3658 
3659  /*
3660  * If TABLE is LASTS and the word starts with "last" followed by a
3661  * non-'-', skip the "last" and look in WDAY_NAMES instead. Warn about any
3662  * usage of the undocumented prefix "last-".
3663  */
3664  if (table == lasts && ciprefix("last", word) && word[4])
3665  {
3666  if (word[4] == '-')
3667  warning(_("\"%s\" is undocumented; use \"last%s\" instead"),
3668  word, word + 5);
3669  else
3670  {
3671  word += 4;
3672  table = wday_names;
3673  }
3674  }
3675 
3676  /*
3677  * Look for exact match.
3678  */
3679  for (lp = table; lp->l_word != NULL; ++lp)
3680  if (ciequal(word, lp->l_word))
3681  return lp;
3682 
3683  /*
3684  * Look for inexact match.
3685  */
3686  foundlp = NULL;
3687  for (lp = table; lp->l_word != NULL; ++lp)
3688  if (ciprefix(word, lp->l_word))
3689  {
3690  if (foundlp == NULL)
3691  foundlp = lp;
3692  else
3693  return NULL; /* multiple inexact matches */
3694  }
3695 
3696  if (foundlp && noise)
3697  {
3698  /* Warn about any backward-compatibility issue with pre-2017c zic. */
3699  bool pre_2017c_match = false;
3700 
3701  for (lp = table; lp->l_word; lp++)
3702  if (itsabbr(word, lp->l_word))
3703  {
3704  if (pre_2017c_match)
3705  {
3706  warning(_("\"%s\" is ambiguous in pre-2017c zic"), word);
3707  break;
3708  }
3709  pre_2017c_match = true;
3710  }
3711  }
3712 
3713  return foundlp;
3714 }
3715 
3716 static char **
3717 getfields(char *cp)
3718 {
3719  char *dp;
3720  char **array;
3721  int nsubs;
3722 
3723  if (cp == NULL)
3724  return NULL;
3725  array = emalloc(size_product(strlen(cp) + 1, sizeof *array));
3726  nsubs = 0;
3727  for (;;)
3728  {
3729  while (is_space(*cp))
3730  ++cp;
3731  if (*cp == '\0' || *cp == '#')
3732  break;
3733  array[nsubs++] = dp = cp;
3734  do
3735  {
3736  if ((*dp = *cp++) != '"')
3737  ++dp;
3738  else
3739  while ((*dp = *cp++) != '"')
3740  if (*dp != '\0')
3741  ++dp;
3742  else
3743  {
3744  error(_("Odd number of quotation marks"));
3745  exit(EXIT_FAILURE);
3746  }
3747  } while (*cp && *cp != '#' && !is_space(*cp));
3748  if (is_space(*cp))
3749  ++cp;
3750  *dp = '\0';
3751  }
3752  array[nsubs] = NULL;
3753  return array;
3754 }
3755 
3756 static void
3758 {
3759  error(_("time overflow"));
3760  exit(EXIT_FAILURE);
3761 }
3762 
3763 static zic_t
3765 {
3766  if (t1 < 0 ? t2 < ZIC_MIN - t1 : ZIC_MAX - t1 < t2)
3767  time_overflow();
3768  return t1 + t2;
3769 }
3770 
3771 static zic_t
3773 {
3774  if (t1 < 0)
3775  {
3776  if (t2 < min_time - t1)
3777  {
3778  if (t1 != min_time)
3779  time_overflow();
3780  return min_time;
3781  }
3782  }
3783  else
3784  {
3785  if (max_time - t1 < t2)
3786  {
3787  if (t1 != max_time)
3788  time_overflow();
3789  return max_time;
3790  }
3791  }
3792  return t1 + t2;
3793 }
3794 
3795 /*
3796  * Given a rule, and a year, compute the date (in seconds since January 1,
3797  * 1970, 00:00 LOCAL time) in that year that the rule refers to.
3798  */
3799 
3800 static zic_t
3801 rpytime(const struct rule *rp, zic_t wantedy)
3802 {
3803  int m,
3804  i;
3805  zic_t dayoff; /* with a nod to Margaret O. */
3806  zic_t t,
3807  y;
3808 
3809  if (wantedy == ZIC_MIN)
3810  return min_time;
3811  if (wantedy == ZIC_MAX)
3812  return max_time;
3813  dayoff = 0;
3814  m = TM_JANUARY;
3815  y = EPOCH_YEAR;
3816  if (y < wantedy)
3817  {
3818  wantedy -= y;
3819  dayoff = (wantedy / YEARSPERREPEAT) * (SECSPERREPEAT / SECSPERDAY);
3820  wantedy %= YEARSPERREPEAT;
3821  wantedy += y;
3822  }
3823  else if (wantedy < 0)
3824  {
3825  dayoff = (wantedy / YEARSPERREPEAT) * (SECSPERREPEAT / SECSPERDAY);
3826  wantedy %= YEARSPERREPEAT;
3827  }
3828  while (wantedy != y)
3829  {
3830  if (wantedy > y)
3831  {
3832  i = len_years[isleap(y)];
3833  ++y;
3834  }
3835  else
3836  {
3837  --y;
3838  i = -len_years[isleap(y)];
3839  }
3840  dayoff = oadd(dayoff, i);
3841  }
3842  while (m != rp->r_month)
3843  {
3844  i = len_months[isleap(y)][m];
3845  dayoff = oadd(dayoff, i);
3846  ++m;
3847  }
3848  i = rp->r_dayofmonth;
3849  if (m == TM_FEBRUARY && i == 29 && !isleap(y))
3850  {
3851  if (rp->r_dycode == DC_DOWLEQ)
3852  --i;
3853  else
3854  {
3855  error(_("use of 2/29 in non leap-year"));
3856  exit(EXIT_FAILURE);
3857  }
3858  }
3859  --i;
3860  dayoff = oadd(dayoff, i);
3861  if (rp->r_dycode == DC_DOWGEQ || rp->r_dycode == DC_DOWLEQ)
3862  {
3863  zic_t wday;
3864 
3865 #define LDAYSPERWEEK ((zic_t) DAYSPERWEEK)
3866  wday = EPOCH_WDAY;
3867 
3868  /*
3869  * Don't trust mod of negative numbers.
3870  */
3871  if (dayoff >= 0)
3872  wday = (wday + dayoff) % LDAYSPERWEEK;
3873  else
3874  {
3875  wday -= ((-dayoff) % LDAYSPERWEEK);
3876  if (wday < 0)
3877  wday += LDAYSPERWEEK;
3878  }
3879  while (wday != rp->r_wday)
3880  if (rp->r_dycode == DC_DOWGEQ)
3881  {
3882  dayoff = oadd(dayoff, 1);
3883  if (++wday >= LDAYSPERWEEK)
3884  wday = 0;
3885  ++i;
3886  }
3887  else
3888  {
3889  dayoff = oadd(dayoff, -1);
3890  if (--wday < 0)
3891  wday = LDAYSPERWEEK - 1;
3892  --i;
3893  }
3894  if (i < 0 || i >= len_months[isleap(y)][m])
3895  {
3896  if (noise)
3897  warning(_("rule goes past start/end of month; \
3898 will not work with pre-2004 versions of zic"));
3899  }
3900  }
3901  if (dayoff < min_time / SECSPERDAY)
3902  return min_time;
3903  if (dayoff > max_time / SECSPERDAY)
3904  return max_time;
3905  t = (zic_t) dayoff * SECSPERDAY;
3906  return tadd(t, rp->r_tod);
3907 }
3908 
3909 static void
3910 newabbr(const char *string)
3911 {
3912  int i;
3913 
3914  if (strcmp(string, GRANDPARENTED) != 0)
3915  {
3916  const char *cp;
3917  const char *mp;
3918 
3919  cp = string;
3920  mp = NULL;
3921  while (is_alpha(*cp) || ('0' <= *cp && *cp <= '9')
3922  || *cp == '-' || *cp == '+')
3923  ++cp;
3924  if (noise && cp - string < 3)
3925  mp = _("time zone abbreviation has fewer than 3 characters");
3926  if (cp - string > ZIC_MAX_ABBR_LEN_WO_WARN)
3927  mp = _("time zone abbreviation has too many characters");
3928  if (*cp != '\0')
3929  mp = _("time zone abbreviation differs from POSIX standard");
3930  if (mp != NULL)
3931  warning("%s (%s)", mp, string);
3932  }
3933  i = strlen(string) + 1;
3934  if (charcnt + i > TZ_MAX_CHARS)
3935  {
3936  error(_("too many, or too long, time zone abbreviations"));
3937  exit(EXIT_FAILURE);
3938  }
3939  strcpy(&chars[charcnt], string);
3940  charcnt += i;
3941 }
3942 
3943 /* Ensure that the directories of ARGNAME exist, by making any missing
3944  ones. If ANCESTORS, do this only for ARGNAME's ancestors; otherwise,
3945  do it for ARGNAME too. Exit with failure if there is trouble.
3946  Do not consider an existing non-directory to be trouble. */
3947 static void
3948 mkdirs(char const *argname, bool ancestors)
3949 {
3950  char *name;
3951  char *cp;
3952 
3953  cp = name = ecpyalloc(argname);
3954 
3955  /*
3956  * On MS-Windows systems, do not worry about drive letters or backslashes,
3957  * as this should suffice in practice. Time zone names do not use drive
3958  * letters and backslashes. If the -d option of zic does not name an
3959  * already-existing directory, it can use slashes to separate the
3960  * already-existing ancestor prefix from the to-be-created subdirectories.
3961  */
3962 
3963  /* Do not mkdir a root directory, as it must exist. */
3964  while (*cp == '/')
3965  cp++;
3966 
3967  while (cp && ((cp = strchr(cp, '/')) || !ancestors))
3968  {
3969  if (cp)
3970  *cp = '\0';
3971 
3972  /*
3973  * Try to create it. It's OK if creation fails because the directory
3974  * already exists, perhaps because some other process just created it.
3975  * For simplicity do not check first whether it already exists, as
3976  * that is checked anyway if the mkdir fails.
3977  */
3978  if (mkdir(name, MKDIR_UMASK) != 0)
3979  {
3980  /*
3981  * For speed, skip itsdir if errno == EEXIST. Since mkdirs is
3982  * called only after open fails with ENOENT on a subfile, EEXIST
3983  * implies itsdir here.
3984  */
3985  int err = errno;
3986 
3987  if (err != EEXIST && !itsdir(name))
3988  {
3989  error(_("%s: Cannot create directory %s: %s"),
3990  progname, name, strerror(err));
3991  exit(EXIT_FAILURE);
3992  }
3993  }
3994  if (cp)
3995  *cp++ = '/';
3996  }
3997  free(name);
3998 }
3999 
4000 
4001 #ifdef WIN32
4002 /*
4003  * To run on win32
4004  */
4005 int
4006 link(const char *oldpath, const char *newpath)
4007 {
4008  if (!CopyFile(oldpath, newpath, false))
4009  {
4010  _dosmaperr(GetLastError());
4011  return -1;
4012  }
4013  return 0;
4014 }
4015 #endif
#define PG_INT32_MAX
Definition: c.h:525
#define MAXALIGN(LEN)
Definition: c.h:747
signed int int32
Definition: c.h:430
#define INT64_FORMAT
Definition: c.h:484
#define pg_attribute_printf(f, a)
Definition: c.h:175
#define pg_attribute_noreturn()
Definition: c.h:201
#define PG_INT64_MAX
Definition: c.h:528
#define PG_INT64_MIN
Definition: c.h:527
#define PG_INT32_MIN
Definition: c.h:524
struct typedefs * types
Definition: ecpg.c:29
enum COMPAT_MODE compat
Definition: ecpg.c:25
#define _(x)
Definition: elog.c:90
const char * name
Definition: encode.c:561
#define realloc(a, b)
Definition: header.h:60
#define free(a)
Definition: header.h:65
#define malloc(a)
Definition: header.h:50
#define isleap(y)
Definition: datetime.h:272
long val
Definition: informix.c:664
char sign
Definition: informix.c:668
int y
Definition: isn.c:72
int b
Definition: isn.c:70
int x
Definition: isn.c:71
int a
Definition: isn.c:69
int j
Definition: isn.c:74
int i
Definition: isn.c:73
va_end(args)
vfprintf(stderr, fmt, args)
exit(1)
va_start(args, fmt)
static struct pg_tm tm
Definition: localtime.c:104
static char format
const void size_t len
PGDLLIMPORT int optind
Definition: getopt.c:50
int getopt(int nargc, char *const *nargv, const char *ostr)
Definition: getopt.c:71
PGDLLIMPORT char * optarg
Definition: getopt.c:52
static void static void status(const char *fmt,...) pg_attribute_printf(1
Definition: pg_regress.c:225
static char * buf
Definition: pg_test_fsync.c:67
#define sprintf
Definition: port.h:240
#define strerror
Definition: port.h:251
#define fprintf
Definition: port.h:242
#define qsort(a, b, c, d)
Definition: port.h:445
#define printf(...)
Definition: port.h:244
char * c
e
Definition: preproc-init.c:82
char string[11]
Definition: preproc-type.c:52
#define SECSPERDAY
Definition: private.h:104
#define TM_AUGUST
Definition: private.h:122
#define TM_SEPTEMBER
Definition: private.h:123
#define SECSPERHOUR
Definition: private.h:103
#define TM_MARCH
Definition: private.h:117
#define TM_NOVEMBER
Definition: private.h:125
#define DAYSPERNYEAR
Definition: private.h:101
#define MAXVAL(t, b)
Definition: private.h:65
#define TM_JULY
Definition: private.h:121
#define SECSPERREPEAT
Definition: private.h:155
#define TM_THURSDAY
Definition: private.h:111
#define SECSPERMIN
Definition: private.h:97
#define TM_APRIL
Definition: private.h:118
#define TM_TUESDAY
Definition: private.h:109
#define MINVAL(t, b)
Definition: private.h:68
#define EPOCH_WDAY
Definition: private.h:131
#define MONSPERYEAR
Definition: private.h:105
#define strtoimax
Definition: private.h:49
#define TM_FEBRUARY
Definition: private.h:116
#define TM_OCTOBER
Definition: private.h:124
#define TM_FRIDAY
Definition: private.h:112
#define HOURSPERDAY
Definition: private.h:99
#define TM_MAY
Definition: private.h:119
#define EOVERFLOW
Definition: private.h:41
#define ENOTSUP
Definition: private.h:38
#define TM_SATURDAY
Definition: private.h:113
#define TM_JANUARY
Definition: private.h:115
#define DAYSPERWEEK
Definition: private.h:100
#define EPOCH_YEAR
Definition: private.h:130
#define GRANDPARENTED
Definition: private.h:30
#define TM_WEDNESDAY
Definition: private.h:110
#define TM_DECEMBER
Definition: private.h:126
#define MINSPERHOUR
Definition: private.h:98
#define INITIALIZE(x)
Definition: private.h:88
#define TM_MONDAY
Definition: private.h:108
#define YEARSPERREPEAT
Definition: private.h:95
#define TM_SUNDAY
Definition: private.h:107
#define DAYSPERLYEAR
Definition: private.h:102
#define TM_JUNE
Definition: private.h:120
#define TYPE_BIT(type)
Definition: private.h:56
static void word(struct vars *v, int dir, struct state *lp, struct state *rp)
Definition: regcomp.c:1476
#define EXIT_SUCCESS
Definition: settings.h:162
#define EXIT_FAILURE
Definition: settings.h:166
Definition: zic.c:391
bool dontmerge
Definition: zic.c:393
zic_t at
Definition: zic.c:392
unsigned char type
Definition: zic.c:394
Definition: zic.c:304
const char * l_word
Definition: zic.c:305
const int l_value
Definition: zic.c:306
Definition: localtime.c:73
bool r_todo
Definition: zic.c:81
bool r_todisut
Definition: zic.c:76
zic_t r_hiyear
Definition: zic.c:64
bool r_isdst
Definition: zic.c:77
int r_dycode
Definition: zic.c:70
bool r_lowasnum
Definition: zic.c:65
int r_dayofmonth
Definition: zic.c:71
int r_wday
Definition: zic.c:72
const char * r_filename
Definition: zic.c:59
const char * r_name
Definition: zic.c:61
zic_t r_temp
Definition: zic.c:82
lineno_t r_linenum
Definition: zic.c:60
int r_month
Definition: zic.c:68
zic_t r_loyear
Definition: zic.c:63
zic_t r_save
Definition: zic.c:78
bool r_hiwasnum
Definition: zic.c:66
zic_t r_tod
Definition: zic.c:74
bool r_todisstd
Definition: zic.c:75
const char * r_abbrvar
Definition: zic.c:79
unsigned short st_mode
Definition: win32_port.h:270
int leapbase
Definition: zic.c:2050
ptrdiff_t count
Definition: zic.c:2049
ptrdiff_t base
Definition: zic.c:2048
int leapcount
Definition: zic.c:2051
int defaulttype
Definition: zic.c:2047
Definition: tzfile.h:40
char tzh_timecnt[4]
Definition: tzfile.h:47
char tzh_ttisstdcnt[4]
Definition: tzfile.h:45
char tzh_version[1]
Definition: tzfile.h:42
char tzh_charcnt[4]
Definition: tzfile.h:49
char tzh_leapcnt[4]
Definition: tzfile.h:46
char tzh_ttisutcnt[4]
Definition: tzfile.h:44
char tzh_magic[4]
Definition: tzfile.h:41
char tzh_typecnt[4]
Definition: tzfile.h:48
Definition: zic.c:94
lineno_t z_linenum
Definition: zic.c:96
zic_t z_save
Definition: zic.c:105
struct rule z_untilrule
Definition: zic.c:110
char * z_rule
Definition: zic.c:100
ptrdiff_t z_nrules
Definition: zic.c:108
char z_format_specifier
Definition: zic.c:102
bool z_isdst
Definition: zic.c:104
zic_t z_stdoff
Definition: zic.c:99
struct rule * z_rules
Definition: zic.c:107
zic_t z_untiltime
Definition: zic.c:111
const char * z_format
Definition: zic.c:101
const char * z_name
Definition: zic.c:98
const char * z_filename
Definition: zic.c:95
#define TZ_MAGIC
Definition: tzfile.h:37
#define TZ_MAX_CHARS
Definition: tzfile.h:105
#define TZ_MAX_TYPES
Definition: tzfile.h:103
#define TZDEFRULES
Definition: tzfile.h:28
#define TZ_MAX_TIMES
Definition: tzfile.h:100
#define TZ_MAX_LEAPS
Definition: tzfile.h:108
#define TZDEFAULT
Definition: tzfile.h:27
#define stat
Definition: win32_port.h:286
#define S_IWOTH
Definition: win32_port.h:318
#define S_ISDIR(m)
Definition: win32_port.h:327
void _dosmaperr(unsigned long)
Definition: win32error.c:177
#define mkdir(a, b)
Definition: win32_port.h:80
#define symlink(oldpath, newpath)
Definition: win32_port.h:237
#define readlink(path, buf, size)
Definition: win32_port.h:238
#define S_IWGRP
Definition: win32_port.h:306
static char chars[TZ_MAX_CHARS]
Definition: zic.c:401
#define YR_MAXIMUM
Definition: zic.c:280
static const char * leapsec
Definition: zic.c:635
#define ZF_FORMAT
Definition: zic.c:215
static zic_t gethms(const char *string, const char *errstring)
Definition: zic.c:1365
#define ZFC_TILDAY
Definition: zic.c:232
#define ZIC_VERSION
Definition: zic.c:23
static ptrdiff_t const PTRDIFF_MAX
Definition: zic.c:47
#define ZIC_BLOAT_DEFAULT
Definition: zic.c:650
static void change_directory(char const *dir)
Definition: zic.c:562
static int typecnt
Definition: zic.c:196
static struct zone * zones
Definition: zic.c:287
static unsigned char desigidx[TZ_MAX_TYPES]
Definition: zic.c:398
#define ZFC_TILYEAR
Definition: zic.c:230
static bool print_abbrevs
Definition: zic.c:189
#define ZF_RULE
Definition: zic.c:214
#define ZFC_TILMONTH
Definition: zic.c:231
static zic_t getleapdatetime(char **fields, int nfields, bool expire_line)
Definition: zic.c:1666
#define ZFC_STDOFF
Definition: zic.c:227
#define DO(field)
static ptrdiff_t timecnt
Definition: zic.c:194
static zic_t tadd(zic_t t1, zic_t t2)
Definition: zic.c:3772
#define YR_ONLY
Definition: zic.c:281
#define RF_LOYEAR
Definition: zic.c:242
#define LC_EXPIRES
Definition: zic.c:206
static char * ecpyalloc(char const *str)
Definition: zic.c:446
static bool ttisuts[TZ_MAX_TYPES]
Definition: zic.c:400
#define LDAYSPERWEEK
static int atcomp(const void *avp, const void *bvp)
Definition: zic.c:2037
static zic_t comment_leapexpires
Definition: zic.c:597
static char isdsts[TZ_MAX_TYPES]
Definition: zic.c:397
static struct lookup const lasts[]
Definition: zic.c:351
static struct lookup const leap_types[]
Definition: zic.c:375
#define ZF_TILYEAR
Definition: zic.c:216
#define LC_LINK
Definition: zic.c:204
#define RF_SAVE
Definition: zic.c:248
#define LP_MONTH
Definition: zic.c:265
static void convert64(const zic_t val, char *const buf)
Definition: zic.c:2003
static void verror(const char *string, va_list args) pg_attribute_printf(1
Definition: zic.c:488
static void * erealloc(void *ptr, size_t size)
Definition: zic.c:440
static bool itsdir(char const *name)
Definition: zic.c:1106
int main(int argc, char **argv)
Definition: zic.c:654
static struct lookup const mon_names[]
Definition: zic.c:324
static zic_t print_cutoff
Definition: zic.c:190
static ptrdiff_t nlinks
Definition: zic.c:300
static zic_t min_year
Definition: zic.c:187
static int hardlinkerr(char const *target, char const *linkname)
Definition: zic.c:996
static void eat(char const *name, lineno_t num)
Definition: zic.c:482
static bool leapseen
Definition: zic.c:180
int64 zic_t
Definition: zic.c:25
static void inleap(char **fields, int nfields)
Definition: zic.c:1755
#define LP_CORR
Definition: zic.c:268
#define LP_TIME
Definition: zic.c:267
#define ZF_TILDAY
Definition: zic.c:218
#define ZONE_MAXFIELDS
Definition: zic.c:221
#define LINK_FIELDS
Definition: zic.c:258
static void mkdirs(char const *argname, bool ancestors)
Definition: zic.c:3948
#define RF_ABBRVAR
Definition: zic.c:249
#define DC_DOM
Definition: zic.c:89
static void puttzcodepass(zic_t val, FILE *fp, int pass)
Definition: zic.c:2023
int lineno_t
Definition: zic.c:55
static int bloat
Definition: zic.c:641
#define LF_LINKNAME
Definition: zic.c:257
static bool inzone(char **fields, int nfields)
Definition: zic.c:1518
static struct lookup const begin_years[]
Definition: zic.c:362
#define ZONEC_MAXFIELDS
Definition: zic.c:235
static zic_t leapminyear
Definition: zic.c:181
#define LC_RULE
Definition: zic.c:202
#define ZIC_VERSION_PRE_2013
Definition: zic.c:22
static void close_file(FILE *stream, char const *dir, char const *name)
Definition: zic.c:527
static void outzone(const struct zone *zpfirst, ptrdiff_t zonecount)
Definition: zic.c:2946
static bool componentcheck(char const *name, char const *component, char const *component_end)
Definition: zic.c:859
#define ZFC_RULE
Definition: zic.c:228
static char * relname(char const *target, char const *linkname)
Definition: zic.c:951
static int max_format_len
Definition: zic.c:185
static ptrdiff_t nzones_alloc
Definition: zic.c:289
static zic_t lo_time
Definition: zic.c:590
static int max_abbrvar_len
Definition: zic.c:184
#define ZFC_TILTIME
Definition: zic.c:233
static zic_t max_year
Definition: zic.c:186
static zic_t rpytime(const struct rule *rp, zic_t wantedy)
Definition: zic.c:3801
static bool inzcont(char **fields, int nfields)
Definition: zic.c:1556
#define LP_YEAR
Definition: zic.c:264
static ptrdiff_t nlinks_alloc
Definition: zic.c:301
#define linkat(targetdir, target, linknamedir, linkname, flag)
Definition: zic.c:116
static const char * lcltime
Definition: zic.c:633
static const char * rfilename
Definition: zic.c:191
static bool ttisstds[TZ_MAX_TYPES]
Definition: zic.c:399
static bool ciprefix(char const *abbr, char const *word)
Definition: zic.c:3640
static int stringoffset(char *result, zic_t offset)
Definition: zic.c:2682
static struct lookup const zi_line_codes[]
Definition: zic.c:312
static void inexpires(char **fields, int nfields)
Definition: zic.c:1787
static zic_t leapexpires
Definition: zic.c:594
static bool want_bloat(void)
Definition: zic.c:644
static const char * filename
Definition: zic.c:178
static int stringrule(char *result, struct rule *const rp, zic_t save, zic_t stdoff)
Definition: zic.c:2716
static void newabbr(const char *string)
Definition: zic.c:3910
static void static void static void warning(const char *string,...) pg_attribute_printf(1
Definition: zic.c:515
#define LF_TARGET
Definition: zic.c:256
static int addtype(zic_t utoff, char const *abbr, bool isdst, bool ttisstd, bool ttisut)
Definition: zic.c:3358
static bool is_alpha(char a)
Definition: zic.c:3486
static void * emalloc(size_t size)
Definition: zic.c:434
#define ZIC_MIN
Definition: zic.c:26
static const int len_months[2][MONSPERYEAR]
Definition: zic.c:381
#define RF_HIYEAR
Definition: zic.c:243
static int stringzone(char *result, struct zone const *zpfirst, ptrdiff_t zonecount)
Definition: zic.c:2811
#define DC_DOWGEQ
Definition: zic.c:90
static bool itssymlink(char const *name)
Definition: zic.c:1131
static void * growalloc(void *ptr, size_t itemsize, ptrdiff_t nitems, ptrdiff_t *nitems_alloc)
Definition: zic.c:452
static bool is_space(char a)
Definition: zic.c:3468
static bool ciequal(const char *ap, const char *bp)
Definition: zic.c:3614
#define ZF_STDOFF
Definition: zic.c:213
static void inrule(char **fields, int nfields)
Definition: zic.c:1471
static zic_t leapmaxyear
Definition: zic.c:182
#define EXPIRES_FIELDS
Definition: zic.c:273
#define ZIC_MAX
Definition: zic.c:27
#define RF_TOD
Definition: zic.c:247
#define RF_COMMAND
Definition: zic.c:244
static void eats(char const *name, lineno_t num, char const *rname, lineno_t rnum)
Definition: zic.c:473
static int charcnt
Definition: zic.c:175
static zic_t oadd(zic_t t1, zic_t t2)
Definition: zic.c:3764
static lineno_t rlinenum
Definition: zic.c:192
#define ZF_TILMONTH
Definition: zic.c:217
static ptrdiff_t nrules
Definition: zic.c:284
#define RF_NAME
Definition: zic.c:241
static bool timerange_option(char *timerange)
Definition: zic.c:602
#define DC_DOWLEQ
Definition: zic.c:91
static bool warnings
Definition: zic.c:177
static const char * directory
Definition: zic.c:634
static const char * psxrules
Definition: zic.c:632
static int leapcnt
Definition: zic.c:179
static void dolink(char const *target, char const *linkname, bool staysymlink)
Definition: zic.c:1004
static struct lookup const * byword(const char *word, const struct lookup *table)
Definition: zic.c:3651
#define LC_LEAP
Definition: zic.c:205
static zic_t utoffs[TZ_MAX_TYPES]
Definition: zic.c:396
static char roll[TZ_MAX_LEAPS]
Definition: zic.c:404
#define LC_ZONE
Definition: zic.c:203
static ptrdiff_t nrules_alloc
Definition: zic.c:285
#define RF_DAY
Definition: zic.c:246
static void writezone(const char *const name, const char *const string, char version, int defaulttype)
Definition: zic.c:2082
@ PERCENT_Z_LEN_BOUND
Definition: zic.c:162
static zic_t const max_time
Definition: zic.c:586
static void static void error(const char *string,...) pg_attribute_printf(1
Definition: zic.c:504
static char lowerit(char a)
Definition: zic.c:3551
#define MKDIR_UMASK
Definition: zic.c:37
static bool namecheck(const char *name)
Definition: zic.c:903
#define LEAP_FIELDS
Definition: zic.c:270
static bool inzsub(char **fields, int nfields, bool iscont)
Definition: zic.c:1567
static size_t size_product(size_t nitems, size_t itemsize)
Definition: zic.c:418
static struct rule * rules
Definition: zic.c:283
static zic_t getsave(char *field, bool *isdst)
Definition: zic.c:1443
static ptrdiff_t timecnt_alloc
Definition: zic.c:195
static void rulesub(struct rule *rp, const char *loyearp, const char *hiyearp, const char *typep, const char *monthp, const char *dayp, const char *timep)
Definition: zic.c:1823
@ WORK_AROUND_QTBUG_53071
Definition: zic.c:172
static void convert(const int32 val, char *const buf)
Definition: zic.c:1992
#define YR_MINIMUM
Definition: zic.c:279
static void infile(const char *name)
Definition: zic.c:1243
#define RULE_FIELDS
Definition: zic.c:250
int link(const char *target, const char *linkname)
Definition: win32link.c:18
#define LP_ROLL
Definition: zic.c:269
static zic_t hi_time
Definition: zic.c:591
static bool itsabbr(const char *abbr, const char *word)
Definition: zic.c:3623
static zic_t trans[TZ_MAX_LEAPS]
Definition: zic.c:402
static bool errors
Definition: zic.c:176
static ptrdiff_t nzones
Definition: zic.c:288
static zic_t const min_time
Definition: zic.c:585
#define ZF_NAME
Definition: zic.c:212
#define RF_MONTH
Definition: zic.c:245
#define ZIC_MAX_ABBR_LEN_WO_WARN
Definition: zic.c:30
static void addtt(zic_t starttime, int type)
Definition: zic.c:3348
static const char * progname
Definition: zic.c:193
static int rcomp(const void *cp1, const void *cp2)
Definition: zic.c:1151
static char const * abbroffset(char *buf, zic_t offset)
Definition: zic.c:2586
static void updateminmax(const zic_t x)
Definition: zic.c:2673
#define ZF_TILTIME
Definition: zic.c:219
static struct attype * attypes
static void * memcheck(void *ptr)
Definition: zic.c:426
static size_t doabbr(char *abbr, struct zone const *zp, char const *letters, bool isdst, zic_t save, bool doquotes)
Definition: zic.c:2630
static void static void static void static void usage(FILE *stream, int status) pg_attribute_noreturn()
Definition: zic.c:543
static struct lookup const wday_names[]
Definition: zic.c:340
#define LP_DAY
Definition: zic.c:266
static char ** getfields(char *cp)
Definition: zic.c:3717
static void adjleap(void)
Definition: zic.c:3425
static struct lookup const end_years[]
Definition: zic.c:368
static void associate(void)
Definition: zic.c:1158
#define ZFC_FORMAT
Definition: zic.c:229
static struct timerange limitrange(struct timerange r, zic_t lo, zic_t hi, zic_t const *ats, unsigned char const *types)
Definition: zic.c:2055
static void puttzcode(const int32 val, FILE *const fp)
Definition: zic.c:2014
static struct link * links
Definition: zic.c:299
static const int len_years[2]
Definition: zic.c:386
static void leapadd(zic_t t, int correction, int rolling)
Definition: zic.c:3403
static struct lookup const leap_line_codes[]
Definition: zic.c:318
static bool noise
Definition: zic.c:188
static void memory_exhausted(const char *msg) pg_attribute_noreturn()
Definition: zic.c:411
#define TIME_T_BITS_IN_FILE
Definition: zic.c:582
static const char * tzdefault
Definition: zic.c:636
static int rule_cmp(struct rule const *a, struct rule const *b)
Definition: zic.c:2797
static void inlink(char **fields, int nfields)
Definition: zic.c:1798
static zic_t corr[TZ_MAX_LEAPS]
Definition: zic.c:403
static void time_overflow(void)
Definition: zic.c:3757
static lineno_t linenum
Definition: zic.c:183