usr.sbin/zic/zic.c

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