Sync zoneinfo database with tz{code,data}2009k from elsie.
[dragonfly.git] / usr.sbin / zic / zic.c
index c4a83b1..6d6cfc2 100644 (file)
@@ -1,25 +1,33 @@
-#ifndef lint
-#ifndef NOID
-static char    elsieid[] = "@(#)zic.c  7.96";
-#endif /* !defined NOID */
-#endif /* !defined lint */
-
 /*
- * @(#)zic.c   7.96
- * $FreeBSD: src/usr.sbin/zic/zic.c,v 1.11 1999/08/28 01:21:20 peter Exp $
- * $DragonFly: src/usr.sbin/zic/zic.c,v 1.6 2004/12/18 22:48:15 swildner Exp $
- */
-#include "private.h"
-#include "tzfile.h"
+** This file is in the public domain, so clarified as of
+** 2006-07-17 by Arthur David Olson.
+**
+** @(#)zic.c   8.20
+** $FreeBSD: src/usr.sbin/zic/zic.c,v 1.11 1999/08/28 01:21:20 peter Exp $
+** $DragonFly: src/usr.sbin/zic/zic.c,v 1.7 2008/10/19 20:15:58 swildner Exp $
+*/
+
 #include <err.h>
 #include <locale.h>
 #include <sys/stat.h>                  /* for umask manifest constants */
 #include <sys/types.h>
 #include <unistd.h>
+#include "private.h"
+#include "tzfile.h"
 
+#define        ZIC_VERSION     '2'
+
+typedef int_fast64_t   zic_t;
+
+#ifndef ZIC_MAX_ABBR_LEN_WO_WARN
+#define ZIC_MAX_ABBR_LEN_WO_WARN       6
+#endif /* !defined ZIC_MAX_ABBR_LEN_WO_WARN */
+
+#define MKDIR_UMASK (S_IRUSR|S_IWUSR|S_IXUSR|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH)
 /*
 ** On some ancient hosts, predicates like `isspace(C)' are defined
-** only if isascii(C) || C == EOF.  Modern hosts obey the C Standard,
+** only if isascii(C) || C == EOF. Modern hosts obey the C Standard,
 ** which says they are defined only if C == ((unsigned char) C) || C == EOF.
 ** Neither the C Standard nor Posix require that `isascii' exist.
 ** For portability, we check both ancient and modern requirements.
@@ -30,6 +38,11 @@ static char  elsieid[] = "@(#)zic.c  7.96";
 #define isascii(x) 1
 #endif
 
+#define OFFSET_STRLEN_MAXIMUM  (7 + INT_STRLEN_MAXIMUM(long))
+#define RULE_STRLEN_MAXIMUM    8       /* "Mdd.dd.d" */
+
+#define end(cp)        (strchr((cp), '\0'))
+
 struct rule {
        const char *    r_filename;
        int             r_linenum;
@@ -38,6 +51,8 @@ struct rule {
        int             r_loyear;       /* for example, 1986 */
        int             r_hiyear;       /* for example, 1986 */
        const char *    r_yrtype;
+       int             r_lowasnum;
+       int             r_hiwasnum;
 
        int             r_month;        /* 0..11 */
 
@@ -54,7 +69,7 @@ struct rule {
        const char *    r_abbrvar;      /* variable part of abbreviation */
 
        int             r_todo;         /* a rule to do (used in outzone) */
-       time_t          r_temp;         /* used in outzone */
+       zic_t           r_temp;         /* used in outzone */
 };
 
 /*
@@ -80,20 +95,21 @@ struct zone {
        int             z_nrules;
 
        struct rule     z_untilrule;
-       time_t          z_untiltime;
+       zic_t           z_untiltime;
 };
 
-static void    addtt(time_t starttime, int type);
+static void    addtt(zic_t starttime, int type);
 static int     addtype(long gmtoff, const char *abbr, int isdst,
                        int ttisstd, int ttisgmt);
-static void    leapadd(time_t t, int positive, int rolling, int count);
+static void    leapadd(zic_t t, int positive, int rolling, int count);
 static void    adjleap(void);
 static void    associate(void);
 static int     ciequal(const char *ap, const char *bp);
 static void    convert(long val, char *buf);
-static void    dolink(const char *fromfile, const char *tofile);
+static void    convert64(zic_t val, char *buf);
+static void    dolink(const char *fromfield, const char *tofield);
 static void    doabbr(char *abbr, const char *format,
-                      const char *letters, int isdst);
+                      const char *letters, int isdst, int doquotes);
 static void    eat(const char *name, int num);
 static void    eats(const char *name, int num,
                     const char *rname, int rnum);
@@ -109,6 +125,7 @@ static void inrule(char **fields, int nfields);
 static int     inzcont(char **fields, int nfields);
 static int     inzone(char **fields, int nfields);
 static int     inzsub(char **fields, int nfields, int iscont);
+static int     is32(zic_t x);
 static int     itsabbr(const char *abbr, const char *word);
 static int     itsdir(const char *name);
 static int     lowerit(int c);
@@ -118,35 +135,40 @@ static void       newabbr(const char *abbr);
 static long    oadd(long t1, long t2);
 static void    outzone(const struct zone *zp, int ntzones);
 static void    puttzcode(long code, FILE *fp);
+static void    puttzcode64(zic_t code, FILE *fp);
 static int     rcomp(const void *leftp, const void *rightp);
-static time_t  rpytime(const struct rule *rp, int wantedy);
+static zic_t   rpytime(const struct rule *rp, int wantedy);
 static void    rulesub(struct rule *rp,
                        const char *loyearp, const char *hiyearp,
                        const char *typep, const char *monthp,
                        const char *dayp, const char *timep);
+static int     stringoffset(char *result, long offset);
+static int     stringrule(char *result, const struct rule *rp,
+                          long dstoff, long gmtoff);
+static void    stringzone(char *result,
+                       const struct zone *zp, int ntzones);
 static void    setboundaries(void);
 static void    setgroup(gid_t *flag, const char *name);
 static void    setuser(uid_t *flag, const char *name);
-static time_t  tadd(time_t t1, long t2);
+static zic_t   tadd(const zic_t t1, const long t2);
 static void    usage(void);
-static void    writezone(const char *name);
+static void    writezone(const char *name, const char *string);
 static int     yearistype(int year, const char *type);
 
-#if !(HAVE_STRERROR - 0)
-static char *  strerror(int);
-#endif /* !(HAVE_STRERROR - 0) */
-
 static int             charcnt;
 static int             errors;
 static const char *    filename;
 static int             leapcnt;
+static int             leapseen;
+static int             leapminyear;
+static int             leapmaxyear;
 static int             linenum;
-static time_t          max_time;
+static int             max_abbrvar_len;
+static int             max_format_len;
+static zic_t           max_time;
 static int             max_year;
-static int             max_year_representable;
-static time_t          min_time;
+static zic_t           min_time;
 static int             min_year;
-static int             min_year_representable;
 static int             noise;
 static const char *    rfilename;
 static int             rlinenum;
@@ -333,7 +355,7 @@ static const int    len_years[2] = {
 };
 
 static struct attype {
-       time_t          at;
+       zic_t           at;
        unsigned char   type;
 }                      attypes[TZ_MAX_TIMES];
 static long            gmtoffs[TZ_MAX_TYPES];
@@ -342,7 +364,7 @@ static unsigned char        abbrinds[TZ_MAX_TYPES];
 static char            ttisstds[TZ_MAX_TYPES];
 static char            ttisgmts[TZ_MAX_TYPES];
 static char            chars[TZ_MAX_CHARS];
-static time_t          trans[TZ_MAX_LEAPS];
+static zic_t           trans[TZ_MAX_LEAPS];
 static long            corr[TZ_MAX_LEAPS];
 static char            roll[TZ_MAX_LEAPS];
 
@@ -367,18 +389,6 @@ memcheck(char * const ptr)
 ** Error handling.
 */
 
-#if !(HAVE_STRERROR - 0)
-static char *
-strerror(int errnum)
-{
-       extern char *   sys_errlist[];
-       extern int      sys_nerr;
-
-       return (errnum > 0 && errnum <= sys_nerr) ?
-               sys_errlist[errnum] : _("Unknown system error");
-}
-#endif /* !(HAVE_STRERROR - 0) */
-
 static void
 eats(const char * const name, const int num,
      const char * const rname, const int rnum)
@@ -392,7 +402,7 @@ eats(const char * const name, const int num,
 static void
 eat(const char * const name, const int num)
 {
-       eats(name, num, (char *) NULL, -1);
+       eats(name, num, NULL, -1);
 }
 
 static void
@@ -428,8 +438,8 @@ static void
 usage(void)
 {
        fprintf(stderr, "%s\n%s\n",
-_("usage: zic [-s] [-v] [-l localtime] [-p posixrules] [-d directory]"),
-_("           [-L leapseconds] [-y yearistype] [filename ... ]"));
+_("usage: zic [-v] [-l localtime] [-p posixrules] [-d directory]"),
+_("           [-L leapseconds] [-y yearistype] [filename ...]"));
        exit(EXIT_FAILURE);
 }
 
@@ -438,7 +448,6 @@ static const char * lcltime;
 static const char *    directory;
 static const char *    leapsec;
 static const char *    yitcommand;
-static int             sflag = FALSE;
 static int             Dflag;
 static uid_t           uflag = (uid_t)-1;
 static gid_t           gflag = (gid_t)-1;
@@ -455,13 +464,6 @@ main(int argc, char *argv[])
 #ifdef unix
        umask(umask(S_IWGRP | S_IWOTH) | (S_IWGRP | S_IWOTH));
 #endif /* defined unix */
-#if HAVE_GETTEXT - 0
-       setlocale(LC_MESSAGES, "");
-#ifdef TZ_DOMAINDIR
-       bindtextdomain(TZ_DOMAIN, TZ_DOMAINDIR);
-#endif /* defined TEXTDOMAINDIR */
-       textdomain(TZ_DOMAIN);
-#endif /* HAVE_GETTEXT - 0 */
        while ((c = getopt(argc, argv, "Dd:g:l:m:p:L:u:vsy:")) != -1)
                switch (c) {
                        default:
@@ -520,7 +522,7 @@ _("more than one -L option specified"));
                                noise = TRUE;
                                break;
                        case 's':
-                               sflag = TRUE;
+                               warnx(_("-s ignored\n"));
                                break;
                }
        if (optind == argc - 1 && strcmp(argv[optind], "=") == 0)
@@ -553,34 +555,45 @@ _("more than one -L option specified"));
        /*
        ** Make links.
        */
-       for (i = 0; i < nlinks; ++i)
+       for (i = 0; i < nlinks; ++i) {
+               eat(links[i].l_filename, links[i].l_linenum);
                dolink(links[i].l_from, links[i].l_to);
-       if (lcltime != NULL)
+               if (noise)
+                       for (j = 0; j < nlinks; ++j)
+                               if (strcmp(links[i].l_to,
+                                       links[j].l_from) == 0)
+                                               warning(_("link to link"));
+       }
+       if (lcltime != NULL) {
+               eat("command line", 1);
                dolink(lcltime, TZDEFAULT);
-       if (psxrules != NULL)
+       }
+       if (psxrules != NULL) {
+               eat("command line", 1);
                dolink(psxrules, TZDEFRULES);
+       }
        return (errors == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
 }
 
 static void
-dolink(const char * const fromfile, const char * const tofile)
+dolink(const char * const fromfield, const char * const tofield)
 {
        char *fromname;
        char *toname;
 
-       if (fromfile[0] == '/')
-               fromname = ecpyalloc(fromfile);
+       if (fromfield[0] == '/')
+               fromname = ecpyalloc(fromfield);
        else {
                fromname = ecpyalloc(directory);
                fromname = ecatalloc(fromname, "/");
-               fromname = ecatalloc(fromname, fromfile);
+               fromname = ecatalloc(fromname, fromfield);
        }
-       if (tofile[0] == '/')
-               toname = ecpyalloc(tofile);
+       if (tofield[0] == '/')
+               toname = ecpyalloc(tofield);
        else {
                toname = ecpyalloc(directory);
                toname = ecatalloc(toname, "/");
-               toname = ecatalloc(toname, tofile);
+               toname = ecatalloc(toname, tofield);
        }
        /*
        ** We get to be careful here since
@@ -593,14 +606,29 @@ dolink(const char * const fromfile, const char * const tofile)
 
                if (mkdirs(toname) != 0)
                        exit(EXIT_FAILURE);
+
                result = link(fromname, toname);
-#if (HAVE_SYMLINK - 0) 
-               if (result != 0) {
-                       result = symlink(fromname, toname);
-                       if (result == 0)
+#if HAVE_SYMLINK
+               if (result != 0 &&
+                       access(fromname, F_OK) == 0 &&
+                       !itsdir(fromname)) {
+                               const char *s = tofield;
+                               char * symlinkcontents = NULL;
+
+                               while ((s = strchr(s+1, '/')) != NULL)
+                                       symlinkcontents =
+                                               ecatalloc(symlinkcontents,
+                                               "../");
+                               symlinkcontents =
+                                       ecatalloc(symlinkcontents,
+                                       fromname);
+                               result = symlink(symlinkcontents,
+                                       toname);
+                               if (result == 0)
 warning(_("hard link failed, symbolic link used"));
+                               ifree(symlinkcontents);
                }
-#endif
+#endif /* HAVE_SYMLINK */
                if (result != 0) {
                        err(EXIT_FAILURE, _("can't link from %s to %s"),
                            fromname, toname);
@@ -610,43 +638,17 @@ warning(_("hard link failed, symbolic link used"));
        ifree(toname);
 }
 
-#ifndef INT_MAX
-#define INT_MAX        ((int) (((unsigned)~0)>>1))
-#endif /* !defined INT_MAX */
-
-#ifndef INT_MIN
-#define INT_MIN        ((int) ~(((unsigned)~0)>>1))
-#endif /* !defined INT_MIN */
-
-/*
-** The tz file format currently allows at most 32-bit quantities.
-** This restriction should be removed before signed 32-bit values
-** wrap around in 2038, but unfortunately this will require a
-** change to the tz file format.
-*/
-
-#define MAX_BITS_IN_FILE       32
-#define TIME_T_BITS_IN_FILE    ((TYPE_BIT(time_t) < MAX_BITS_IN_FILE) ? TYPE_BIT(time_t) : MAX_BITS_IN_FILE)
+#define TIME_T_BITS_IN_FILE    64
 
 static void
 setboundaries(void)
 {
-       if (TYPE_SIGNED(time_t)) {
-               min_time = ~ (time_t) 0;
-               min_time <<= TIME_T_BITS_IN_FILE - 1;
-               max_time = ~ (time_t) 0 - min_time;
-               if (sflag)
-                       min_time = 0;
-       } else {
-               min_time = 0;
-               max_time = 2 - sflag;
-               max_time <<= TIME_T_BITS_IN_FILE - 1;
-               --max_time;
-       }
-       min_year = TM_YEAR_BASE + gmtime(&min_time)->tm_year;
-       max_year = TM_YEAR_BASE + gmtime(&max_time)->tm_year;
-       min_year_representable = min_year;
-       max_year_representable = max_year;
+       int     i;
+
+       min_time = -1;
+       for (i = 0; i < TIME_T_BITS_IN_FILE - 1; ++i)
+               min_time *= 2;
+       max_time = -(min_time + 1);
 }
 
 static int
@@ -740,7 +742,7 @@ associate(void)
                        */
                        eat(zp->z_filename, zp->z_linenum);
                        zp->z_stdoff = gethms(zp->z_rule, _("unruly zone"),
-                                             TRUE);
+                               TRUE);
                        /*
                        ** Note, though, that if there's no rule,
                        ** a '%s' in the format is a bad thing.
@@ -843,7 +845,8 @@ _("panic: invalid l_value %d"), lp->l_value);
 static long
 gethms(const char *string, const char * const errstring, const int signable)
 {
-       int     hh, mm, ss, sign;
+       long    hh;
+       int     mm, ss, sign;
 
        if (string == NULL || *string == '\0')
                return 0;
@@ -853,25 +856,32 @@ gethms(const char *string, const char * const errstring, const int signable)
                sign = -1;
                ++string;
        } else  sign = 1;
-       if (sscanf(string, scheck(string, "%d"), &hh) == 1)
+       if (sscanf(string, scheck(string, "%ld"), &hh) == 1)
                mm = ss = 0;
-       else if (sscanf(string, scheck(string, "%d:%d"), &hh, &mm) == 2)
+       else if (sscanf(string, scheck(string, "%ld:%d"), &hh, &mm) == 2)
                ss = 0;
-       else if (sscanf(string, scheck(string, "%d:%d:%d"),
+       else if (sscanf(string, scheck(string, "%ld:%d:%d"),
                &hh, &mm, &ss) != 3) {
                        error(errstring);
                        return 0;
        }
-       if ((hh < 0 || hh >= HOURSPERDAY ||
+       if (hh < 0 ||
                mm < 0 || mm >= MINSPERHOUR ||
-               ss < 0 || ss > SECSPERMIN) &&
-               !(hh == HOURSPERDAY && mm == 0 && ss == 0)) {
+               ss < 0 || ss > SECSPERMIN) {
                        error(errstring);
                        return 0;
        }
-       return eitol(sign) *
-               (eitol(hh * MINSPERHOUR + mm) *
-               eitol(SECSPERMIN) + eitol(ss));
+       if (LONG_MAX / SECSPERHOUR < hh) {
+               error(_("time overflow"));
+               return 0;
+       }
+       if (noise && hh == HOURSPERDAY && mm == 0 && ss == 0)
+               warning(_("24:00 not handled by pre-1998 versions of zic"));
+       if (noise && (hh > HOURSPERDAY ||
+               (hh == HOURSPERDAY && (mm != 0 || ss != 0))))
+warning(_("values over 24 hours not handled by pre-2007 versions of zic"));
+       return oadd(eitol(sign) * hh * eitol(SECSPERHOUR),
+                   eitol(sign) * (eitol(mm) * eitol(SECSPERMIN) + eitol(ss)));
 }
 
 static void
@@ -894,6 +904,8 @@ inrule(char ** const fields, const int nfields)
                fields[RF_MONTH], fields[RF_DAY], fields[RF_TOD]);
        r.r_name = ecpyalloc(fields[RF_NAME]);
        r.r_abbrvar = ecpyalloc(fields[RF_ABBRVAR]);
+       if (max_abbrvar_len < strlen(r.r_abbrvar))
+               max_abbrvar_len = strlen(r.r_abbrvar);
        rules = (struct rule *) (void *) erealloc((char *) rules,
                (int) ((nrules + 1) * sizeof *rules));
        rules[nrules++] = r;
@@ -992,6 +1004,8 @@ inzsub(char ** const fields, const int nfields, const int iscont)
        }
        z.z_rule = ecpyalloc(fields[i_rule]);
        z.z_format = ecpyalloc(fields[i_format]);
+       if (max_format_len < strlen(z.z_format))
+               max_format_len = strlen(z.z_format);
        hasuntil = nfields > i_untilyear;
        if (hasuntil) {
                z.z_untilrule.r_filename = filename;
@@ -1012,7 +1026,9 @@ inzsub(char ** const fields, const int nfields, const int iscont)
                        zones[nzones - 1].z_untiltime > min_time &&
                        zones[nzones - 1].z_untiltime < max_time &&
                        zones[nzones - 1].z_untiltime >= z.z_untiltime) {
-                               error(_("Zone continuation line end time is not after end time of previous line"));
+                               error(_(
+"Zone continuation line end time is not after end time of previous line"
+                                       ));
                                return FALSE;
                }
        }
@@ -1034,7 +1050,7 @@ inleap(char ** const fields, const int nfields)
        int i, j;
        int year, month, day;
        long dayoff, tod;
-       time_t t;
+       zic_t t;
 
        if (nfields != LEAP_FIELDS) {
                error(_("wrong number of fields on Leap line"));
@@ -1043,12 +1059,17 @@ inleap(char ** const fields, const int nfields)
        dayoff = 0;
        cp = fields[LP_YEAR];
        if (sscanf(cp, scheck(cp, "%d"), &year) != 1) {
-                       /*
-                        * Leapin' Lizards!
-                        */
-                       error(_("invalid leaping year"));
-                       return;
+               /*
+               ** Leapin' Lizards!
+               */
+               error(_("invalid leaping year"));
+               return;
        }
+       if (!leapseen || leapmaxyear < year)
+               leapmaxyear = year;
+       if (!leapseen || leapminyear > year)
+               leapminyear = year;
+       leapseen = TRUE;
        j = EPOCH_YEAR;
        while (j != year) {
                if (year > j) {
@@ -1078,18 +1099,19 @@ inleap(char ** const fields, const int nfields)
                        return;
        }
        dayoff = oadd(dayoff, eitol(day - 1));
-       if (dayoff < 0 && !TYPE_SIGNED(time_t)) {
+       if (dayoff < 0 && !TYPE_SIGNED(zic_t)) {
                error(_("time before zero"));
                return;
        }
-       t = (time_t) dayoff * SECSPERDAY;
-       /*
-       ** Cheap overflow check.
-       */
-       if (t / SECSPERDAY != dayoff) {
-               error(_("time overflow"));
+       if (dayoff < min_time / SECSPERDAY) {
+               error(_("time too small"));
+               return;
+       }
+       if (dayoff > max_time / SECSPERDAY) {
+               error(_("time too large"));
                return;
        }
+       t = (zic_t) dayoff * SECSPERDAY;
        tod = gethms(fields[LP_TIME], _("invalid time of day"), FALSE);
        cp = fields[LP_CORR];
        {
@@ -1113,7 +1135,9 @@ inleap(char ** const fields, const int nfields)
                        return;
                }
                if ((lp = byword(fields[LP_ROLL], leap_types)) == NULL) {
-                       error(_("illegal Rolling/Stationary field on Leap line"));
+                       error(_(
+                               "illegal Rolling/Stationary field on Leap line"
+                               ));
                        return;
                }
                leapadd(tadd(t, tod), positive, lp->l_value, count);
@@ -1197,7 +1221,8 @@ rulesub(struct rule * const rp,
        */
        cp = loyearp;
        lp = byword(cp, begin_years);
-       if (lp != NULL) switch ((int) lp->l_value) {
+       rp->r_lowasnum = lp == NULL;
+       if (!rp->r_lowasnum) switch ((int) lp->l_value) {
                case YR_MINIMUM:
                        rp->r_loyear = INT_MIN;
                        break;
@@ -1210,14 +1235,11 @@ rulesub(struct rule * const rp,
        } else if (sscanf(cp, scheck(cp, "%d"), &rp->r_loyear) != 1) {
                error(_("invalid starting year"));
                return;
-       } else if (noise) {
-               if (rp->r_loyear < min_year_representable)
-                       warning(_("starting year too low to be represented"));
-               else if (rp->r_loyear > max_year_representable)
-                       warning(_("starting year too high to be represented"));
        }
        cp = hiyearp;
-       if ((lp = byword(cp, end_years)) != NULL) switch ((int) lp->l_value) {
+       lp = byword(cp, end_years);
+       rp->r_hiwasnum = lp == NULL;
+       if (!rp->r_hiwasnum) switch ((int) lp->l_value) {
                case YR_MINIMUM:
                        rp->r_hiyear = INT_MIN;
                        break;
@@ -1233,11 +1255,6 @@ rulesub(struct rule * const rp,
        } else if (sscanf(cp, scheck(cp, "%d"), &rp->r_hiyear) != 1) {
                error(_("invalid ending year"));
                return;
-       } else if (noise) {
-               if (rp->r_loyear < min_year_representable)
-                       warning(_("starting year too low to be represented"));
-               else if (rp->r_loyear > max_year_representable)
-                       warning(_("starting year too high to be represented"));
        }
        if (rp->r_loyear > rp->r_hiyear) {
                error(_("starting year greater than ending year"));
@@ -1252,8 +1269,6 @@ rulesub(struct rule * const rp,
                }
                rp->r_yrtype = ecpyalloc(typep);
        }
-       if (rp->r_loyear < min_year && rp->r_loyear > 0)
-               min_year = rp->r_loyear;
        /*
        ** Day work.
        ** Accept things such as:
@@ -1305,12 +1320,22 @@ static void
 convert(const long val, char * const buf)
 {
        int i;
-       long shift;
+       int shift;
 
        for (i = 0, shift = 24; i < 4; ++i, shift -= 8)
                buf[i] = val >> shift;
 }
 
+static void
+convert64(const zic_t val, char * const buf)
+{
+       int     i;
+       int     shift;
+
+       for (i = 0, shift = 56; i < 8; ++i, shift -= 8)
+               buf[i] = val >> shift;
+}
+
 static void
 puttzcode(const long val, FILE * const fp)
 {
@@ -1320,28 +1345,43 @@ puttzcode(const long val, FILE * const fp)
        fwrite((void *) buf, (size_t) sizeof buf, (size_t) 1, fp);
 }
 
+static void
+puttzcode64(const zic_t val, FILE * const fp)
+{
+       char    buf[8];
+
+       convert64(val, buf);
+       fwrite((void *) buf, (size_t) sizeof buf, (size_t) 1, fp);
+}
+
 static int
-atcomp(const void *avp, const void *bvp)
+atcomp(const void * avp, const void * bvp)
 {
-       const struct attype *ap = avp;
-       const struct attype *bp = bvp;
+       const zic_t     a = ((const struct attype *) avp)->at;
+       const zic_t     b = ((const struct attype *) bvp)->at;
 
-       if (ap->at < bp->at)
-               return -1;
-       else if (ap->at > bp->at)
-               return 1;
-       else    return 0;
+       return (a < b) ? -1 : (a > b);
+}
+
+static int
+is32(const zic_t x)
+{
+       return INT32_MIN <= x && x <= INT32_MAX;
 }
 
 static void
-writezone(const char * const name)
+writezone(const char * const name, const char * const string)
 {
-       FILE * fp;
-       int i, j;
-       static char *fullname;
-       static struct tzhead tzh;
-       time_t ats[TZ_MAX_TIMES];
-       unsigned char types[TZ_MAX_TIMES];
+       FILE *                  fp;
+       int                     i, j;
+       int                     leapcnt32, leapi32;
+       int                     timecnt32, timei32;
+       int                     pass;
+       static char *           fullname;
+       static const struct tzhead tzh0;
+       static struct tzhead    tzh;
+       zic_t                   ats[TZ_MAX_TIMES];
+       unsigned char           types[TZ_MAX_TIMES];
 
        /*
        ** Sort.
@@ -1364,14 +1404,13 @@ writezone(const char * const name)
                        while (fromi < timecnt && attypes[fromi].type == 0)
                                ++fromi;        /* handled by default rule */
                for ( ; fromi < timecnt; ++fromi) {
-                       if (toi != 0
-                           && ((attypes[fromi].at
-                                + gmtoffs[attypes[toi - 1].type])
-                               <= (attypes[toi - 1].at
-                                   + gmtoffs[toi == 1 ? 0
-                                             : attypes[toi - 2].type]))) {
-                               attypes[toi - 1].type = attypes[fromi].type;
-                               continue;
+                       if (toi != 0 && ((attypes[fromi].at +
+                               gmtoffs[attypes[toi - 1].type]) <=
+                               (attypes[toi - 1].at + gmtoffs[toi == 1 ? 0
+                               : attypes[toi - 2].type]))) {
+                                       attypes[toi - 1].type =
+                                               attypes[fromi].type;
+                                       continue;
                        }
                        if (toi == 0 ||
                                attypes[toi - 1].type != attypes[fromi].type)
@@ -1386,82 +1425,194 @@ writezone(const char * const name)
                ats[i] = attypes[i].at;
                types[i] = attypes[i].type;
        }
+       /*
+       ** Correct for leap seconds.
+       */
+       for (i = 0; i < timecnt; ++i) {
+               j = leapcnt;
+               while (--j >= 0)
+                       if (ats[i] > trans[j] - corr[j]) {
+                               ats[i] = tadd(ats[i], corr[j]);
+                               break;
+                       }
+       }
+       /*
+       ** Figure out 32-bit-limited starts and counts.
+       */
+       timecnt32 = timecnt;
+       timei32 = 0;
+       leapcnt32 = leapcnt;
+       leapi32 = 0;
+       while (timecnt32 > 0 && !is32(ats[timecnt32 - 1]))
+               --timecnt32;
+       while (timecnt32 > 0 && !is32(ats[timei32])) {
+               --timecnt32;
+               ++timei32;
+       }
+       while (leapcnt32 > 0 && !is32(trans[leapcnt32 - 1]))
+               --leapcnt32;
+       while (leapcnt32 > 0 && !is32(trans[leapi32])) {
+               --leapcnt32;
+               ++leapi32;
+       }
        fullname = erealloc(fullname,
                (int) (strlen(directory) + 1 + strlen(name) + 1));
        sprintf(fullname, "%s/%s", directory, name);
-
        /*
-        * Remove old file, if any, to snap links.
-        */
+       ** Remove old file, if any, to snap links.
+       */
        if (!itsdir(fullname) && remove(fullname) != 0 && errno != ENOENT)
                err(EXIT_FAILURE, _("can't remove %s"), fullname);
-
        if ((fp = fopen(fullname, "wb")) == NULL) {
                if (mkdirs(fullname) != 0)
                        exit(EXIT_FAILURE);
                if ((fp = fopen(fullname, "wb")) == NULL)
                        err(EXIT_FAILURE, _("can't create %s"), fullname);
        }
-       convert(eitol(typecnt), tzh.tzh_ttisgmtcnt);
-       convert(eitol(typecnt), tzh.tzh_ttisstdcnt);
-       convert(eitol(leapcnt), tzh.tzh_leapcnt);
-       convert(eitol(timecnt), tzh.tzh_timecnt);
-       convert(eitol(typecnt), tzh.tzh_typecnt);
-       convert(eitol(charcnt), tzh.tzh_charcnt);
-       strncpy(tzh.tzh_magic, TZ_MAGIC, sizeof tzh.tzh_magic);
-#define DO(field)      fwrite((void *) tzh.field, (size_t) sizeof tzh.field, (size_t) 1, fp)
-       DO(tzh_magic);
-       DO(tzh_reserved);
-       DO(tzh_ttisgmtcnt);
-       DO(tzh_ttisstdcnt);
-       DO(tzh_leapcnt);
-       DO(tzh_timecnt);
-       DO(tzh_typecnt);
-       DO(tzh_charcnt);
-#undef DO
-       for (i = 0; i < timecnt; ++i) {
-               j = leapcnt;
-               while (--j >= 0)
-                       if (ats[i] >= trans[j]) {
-                               ats[i] = tadd(ats[i], corr[j]);
-                               break;
+       for (pass = 1; pass <= 2; ++pass) {
+               int     thistimei, thistimecnt;
+               int     thisleapi, thisleapcnt;
+               int     thistimelim, thisleaplim;
+               int     writetype[TZ_MAX_TIMES];
+               int     typemap[TZ_MAX_TYPES];
+               int     thistypecnt;
+               char    thischars[TZ_MAX_CHARS];
+               char    thischarcnt;
+               int     indmap[TZ_MAX_CHARS];
+
+               if (pass == 1) {
+                       thistimei = timei32;
+                       thistimecnt = timecnt32;
+                       thisleapi = leapi32;
+                       thisleapcnt = leapcnt32;
+               } else {
+                       thistimei = 0;
+                       thistimecnt = timecnt;
+                       thisleapi = 0;
+                       thisleapcnt = leapcnt;
+               }
+               thistimelim = thistimei + thistimecnt;
+               thisleaplim = thisleapi + thisleapcnt;
+               for (i = 0; i < typecnt; ++i)
+                       writetype[i] = thistimecnt == timecnt;
+               if (thistimecnt == 0) {
+                       /*
+                       ** No transition times fall in the current
+                       ** (32- or 64-bit) window.
+                       */
+                       if (typecnt != 0)
+                               writetype[typecnt - 1] = TRUE;
+               } else {
+                       for (i = thistimei - 1; i < thistimelim; ++i)
+                               if (i >= 0)
+                                       writetype[types[i]] = TRUE;
+                       /*
+                       ** For America/Godthab and Antarctica/Palmer
+                       */
+                       if (thistimei == 0)
+                               writetype[0] = TRUE;
+               }
+               thistypecnt = 0;
+               for (i = 0; i < typecnt; ++i)
+                       typemap[i] = writetype[i] ?  thistypecnt++ : -1;
+               for (i = 0; i < sizeof indmap / sizeof indmap[0]; ++i)
+                       indmap[i] = -1;
+               thischarcnt = 0;
+               for (i = 0; i < typecnt; ++i) {
+                       char *  thisabbr;
+
+                       if (!writetype[i])
+                               continue;
+                       if (indmap[abbrinds[i]] >= 0)
+                               continue;
+                       thisabbr = &chars[abbrinds[i]];
+                       for (j = 0; j < thischarcnt; ++j)
+                               if (strcmp(&thischars[j], thisabbr) == 0)
+                                       break;
+                       if (j == thischarcnt) {
+                               strcpy(&thischars[(int) thischarcnt],
+                                       thisabbr);
+                               thischarcnt += strlen(thisabbr) + 1;
                        }
-               puttzcode((long) ats[i], fp);
-       }
-       if (timecnt > 0)
-               fwrite((void *) types, (size_t) sizeof types[0],
-                       (size_t) timecnt, fp);
-       for (i = 0; i < typecnt; ++i) {
-               puttzcode((long) gmtoffs[i], fp);
-               putc(isdsts[i], fp);
-               putc(abbrinds[i], fp);
-       }
-       if (charcnt != 0)
-               fwrite((void *) chars, (size_t) sizeof chars[0],
-                       (size_t) charcnt, fp);
-       for (i = 0; i < leapcnt; ++i) {
-               if (roll[i]) {
-                       if (timecnt == 0 || trans[i] < ats[0]) {
-                               j = 0;
-                               while (isdsts[j])
-                                       if (++j >= typecnt) {
-                                               j = 0;
-                                               break;
-                                       }
-                       } else {
-                               j = 1;
-                               while (j < timecnt && trans[i] >= ats[j])
-                                       ++j;
-                               j = types[j - 1];
+                       indmap[abbrinds[i]] = j;
+               }
+#define DO(field)      fwrite((void *) tzh.field, \
+                               (size_t) sizeof tzh.field, (size_t) 1, fp)
+               tzh = tzh0;
+               strncpy(tzh.tzh_magic, TZ_MAGIC, sizeof tzh.tzh_magic);
+               tzh.tzh_version[0] = ZIC_VERSION;
+               convert(eitol(thistypecnt), tzh.tzh_ttisgmtcnt);
+               convert(eitol(thistypecnt), tzh.tzh_ttisstdcnt);
+               convert(eitol(thisleapcnt), tzh.tzh_leapcnt);
+               convert(eitol(thistimecnt), tzh.tzh_timecnt);
+               convert(eitol(thistypecnt), tzh.tzh_typecnt);
+               convert(eitol(thischarcnt), tzh.tzh_charcnt);
+               DO(tzh_magic);
+               DO(tzh_version);
+               DO(tzh_reserved);
+               DO(tzh_ttisgmtcnt);
+               DO(tzh_ttisstdcnt);
+               DO(tzh_leapcnt);
+               DO(tzh_timecnt);
+               DO(tzh_typecnt);
+               DO(tzh_charcnt);
+#undef DO
+               for (i = thistimei; i < thistimelim; ++i)
+                       if (pass == 1)
+                               puttzcode((long) ats[i], fp);
+                       else    puttzcode64(ats[i], fp);
+               for (i = thistimei; i < thistimelim; ++i) {
+                       unsigned char   uc;
+
+                       uc = typemap[types[i]];
+                       fwrite((void *) &uc,
+                               (size_t) sizeof uc,
+                               (size_t) 1,
+                               fp);
+               }
+               for (i = 0; i < typecnt; ++i)
+                       if (writetype[i]) {
+                               puttzcode(gmtoffs[i], fp);
+                               putc(isdsts[i], fp);
+                               putc((unsigned char) indmap[abbrinds[i]], fp);
                        }
-                       puttzcode((long) tadd(trans[i], -gmtoffs[j]), fp);
-               } else  puttzcode((long) trans[i], fp);
-               puttzcode((long) corr[i], fp);
-       }
-       for (i = 0; i < typecnt; ++i)
-               putc(ttisstds[i], fp);
-       for (i = 0; i < typecnt; ++i)
-               putc(ttisgmts[i], fp);
+               if (thischarcnt != 0)
+                       fwrite((void *) thischars,
+                               (size_t) sizeof thischars[0],
+                               (size_t) thischarcnt, fp);
+               for (i = thisleapi; i < thisleaplim; ++i) {
+                       register zic_t  todo;
+
+                       if (roll[i]) {
+                               if (timecnt == 0 || trans[i] < ats[0]) {
+                                       j = 0;
+                                       while (isdsts[j])
+                                               if (++j >= typecnt) {
+                                                       j = 0;
+                                                       break;
+                                               }
+                               } else {
+                                       j = 1;
+                                       while (j < timecnt &&
+                                               trans[i] >= ats[j])
+                                                       ++j;
+                                       j = types[j - 1];
+                               }
+                               todo = tadd(trans[i], -gmtoffs[j]);
+                       } else  todo = trans[i];
+                       if (pass == 1)
+                               puttzcode((long) todo, fp);
+                       else    puttzcode64(todo, fp);
+                       puttzcode(corr[i], fp);
+               }
+               for (i = 0; i < typecnt; ++i)
+                       if (writetype[i])
+                               putc(ttisstds[i], fp);
+               for (i = 0; i < typecnt; ++i)
+                       if (writetype[i])
+                               putc(ttisgmts[i], fp);
+       }
+       fprintf(fp, "\n%s\n", string);
        if (ferror(fp) || fclose(fp))
                errx(EXIT_FAILURE, _("error writing %s"), fullname);
        if (chmod(fullname, mflag) < 0)
@@ -1475,17 +1626,210 @@ writezone(const char * const name)
 
 static void
 doabbr(char * const abbr, const char * const format,
-       const char * const letters, const int isdst)
+       const char * const letters, const int isdst, const int doquotes)
 {
-       if (strchr(format, '/') == NULL) {
+       char *  cp;
+       char *  slashp;
+       int     len;
+
+       slashp = strchr(format, '/');
+       if (slashp == NULL) {
                if (letters == NULL)
                        strcpy(abbr, format);
                else    sprintf(abbr, format, letters);
-       } else if (isdst)
-               strcpy(abbr, strchr(format, '/') + 1);
-       else {
-               strcpy(abbr, format);
-               *strchr(abbr, '/') = '\0';
+       } else if (isdst) {
+               strcpy(abbr, slashp + 1);
+       } else {
+               if (slashp > format)
+                       strncpy(abbr, format,
+                               (unsigned) (slashp - format));
+               abbr[slashp - format] = '\0';
+       }
+       if (!doquotes)
+               return;
+       for (cp = abbr; *cp != '\0'; ++cp)
+               if (strchr("ABCDEFGHIJKLMNOPQRSTUVWXYZ", *cp) == NULL &&
+                       strchr("abcdefghijklmnopqrstuvwxyz", *cp) == NULL)
+                               break;
+       len = strlen(abbr);
+       if (len > 0 && *cp == '\0')
+               return;
+       abbr[len + 2] = '\0';
+       abbr[len + 1] = '>';
+       for ( ; len > 0; --len)
+               abbr[len] = abbr[len - 1];
+       abbr[0] = '<';
+}
+
+static void
+updateminmax(const int x)
+{
+       if (min_year > x)
+               min_year = x;
+       if (max_year < x)
+               max_year = x;
+}
+
+static int
+stringoffset(char *result, long offset)
+{
+       int     hours;
+       int     minutes;
+       int     seconds;
+
+       result[0] = '\0';
+       if (offset < 0) {
+               strcpy(result, "-");
+               offset = -offset;
+       }
+       seconds = offset % SECSPERMIN;
+       offset /= SECSPERMIN;
+       minutes = offset % MINSPERHOUR;
+       offset /= MINSPERHOUR;
+       hours = offset;
+       if (hours >= HOURSPERDAY) {
+               result[0] = '\0';
+               return -1;
+       }
+       sprintf(end(result), "%d", hours);
+       if (minutes != 0 || seconds != 0) {
+               sprintf(end(result), ":%02d", minutes);
+               if (seconds != 0)
+                       sprintf(end(result), ":%02d", seconds);
+       }
+       return 0;
+}
+
+static int
+stringrule(char *result, const struct rule * const rp, const long dstoff,
+          const long gmtoff)
+{
+       long    tod;
+
+       result = end(result);
+       if (rp->r_dycode == DC_DOM) {
+               int     month, total;
+
+               if (rp->r_dayofmonth == 29 && rp->r_month == TM_FEBRUARY)
+                       return -1;
+               total = 0;
+               for (month = 0; month < rp->r_month; ++month)
+                       total += len_months[0][month];
+               sprintf(result, "J%d", total + rp->r_dayofmonth);
+       } else {
+               int     week;
+
+               if (rp->r_dycode == DC_DOWGEQ) {
+                       week = 1 + rp->r_dayofmonth / DAYSPERWEEK;
+                       if ((week - 1) * DAYSPERWEEK + 1 != rp->r_dayofmonth)
+                               return -1;
+               } else if (rp->r_dycode == DC_DOWLEQ) {
+                       if (rp->r_dayofmonth == len_months[1][rp->r_month])
+                               week = 5;
+                       else {
+                               week = 1 + rp->r_dayofmonth / DAYSPERWEEK;
+                               if (week * DAYSPERWEEK - 1 != rp->r_dayofmonth)
+                                       return -1;
+                       }
+               } else  return -1;      /* "cannot happen" */
+               sprintf(result, "M%d.%d.%d",
+                       rp->r_month + 1, week, rp->r_wday);
+       }
+       tod = rp->r_tod;
+       if (rp->r_todisgmt)
+               tod += gmtoff;
+       if (rp->r_todisstd && rp->r_stdoff == 0)
+               tod += dstoff;
+       if (tod < 0) {
+               result[0] = '\0';
+               return -1;
+       }
+       if (tod != 2 * SECSPERMIN * MINSPERHOUR) {
+               strcat(result, "/");
+               if (stringoffset(end(result), tod) != 0)
+                       return -1;
+       }
+       return 0;
+}
+
+static void
+stringzone(char *result, const struct zone * const zpfirst,
+          const int zonecount)
+{
+       const struct zone *     zp;
+       struct rule *           rp;
+       struct rule *           stdrp;
+       struct rule *           dstrp;
+       int                     i;
+       const char *            abbrvar;
+
+       result[0] = '\0';
+       zp = zpfirst + zonecount - 1;
+       stdrp = dstrp = NULL;
+       for (i = 0; i < zp->z_nrules; ++i) {
+               rp = &zp->z_rules[i];
+               if (rp->r_hiwasnum || rp->r_hiyear != INT_MAX)
+                       continue;
+               if (rp->r_yrtype != NULL)
+                       continue;
+               if (rp->r_stdoff == 0) {
+                       if (stdrp == NULL)
+                               stdrp = rp;
+                       else    return;
+               } else {
+                       if (dstrp == NULL)
+                               dstrp = rp;
+                       else    return;
+               }
+       }
+       if (stdrp == NULL && dstrp == NULL) {
+               /*
+               ** There are no rules running through "max".
+               ** Let's find the latest rule.
+               */
+               for (i = 0; i < zp->z_nrules; ++i) {
+                       rp = &zp->z_rules[i];
+                       if (stdrp == NULL || rp->r_hiyear > stdrp->r_hiyear ||
+                               (rp->r_hiyear == stdrp->r_hiyear &&
+                               rp->r_month > stdrp->r_month))
+                                       stdrp = rp;
+               }
+               if (stdrp != NULL && stdrp->r_stdoff != 0)
+                       return; /* We end up in DST (a POSIX no-no). */
+               /*
+               ** Horrid special case: if year is 2037,
+               ** presume this is a zone handled on a year-by-year basis;
+               ** do not try to apply a rule to the zone.
+               */
+               if (stdrp != NULL && stdrp->r_hiyear == 2037)
+                       return;
+       }
+       if (stdrp == NULL && (zp->z_nrules != 0 || zp->z_stdoff != 0))
+               return;
+       abbrvar = (stdrp == NULL) ? "" : stdrp->r_abbrvar;
+       doabbr(result, zp->z_format, abbrvar, FALSE, TRUE);
+       if (stringoffset(end(result), -zp->z_gmtoff) != 0) {
+               result[0] = '\0';
+               return;
+       }
+       if (dstrp == NULL)
+               return;
+       doabbr(end(result), zp->z_format, dstrp->r_abbrvar, TRUE, TRUE);
+       if (dstrp->r_stdoff != SECSPERMIN * MINSPERHOUR)
+               if (stringoffset(end(result),
+                       -(zp->z_gmtoff + dstrp->r_stdoff)) != 0) {
+                               result[0] = '\0';
+                               return;
+               }
+       strcat(result, ",");
+       if (stringrule(result, dstrp, dstrp->r_stdoff, zp->z_gmtoff) != 0) {
+               result[0] = '\0';
+               return;
+       }
+       strcat(result, ",");
+       if (stringrule(result, stdrp, dstrp->r_stdoff, zp->z_gmtoff) != 0) {
+               result[0] = '\0';
+               return;
        }
 }
 
@@ -1496,7 +1840,7 @@ outzone(const struct zone * const zpfirst, const int zonecount)
        struct rule *rp;
        int i, j;
        int usestart, useuntil;
-       time_t starttime, untiltime;
+       zic_t starttime, untiltime;
        long gmtoff;
        long stdoff;
        int year;
@@ -1504,8 +1848,17 @@ outzone(const struct zone * const zpfirst, const int zonecount)
        int startttisstd;
        int startttisgmt;
        int type;
-       char startbuf[BUFSIZ];
-
+       char *startbuf;
+       char *ab;
+       char *envvar;
+       int max_abbr_len;
+       int max_envvar_len;
+
+       max_abbr_len = 2 + max_format_len + max_abbrvar_len;
+       max_envvar_len = 2 * max_abbr_len + 5 * 9;
+       startbuf = emalloc(max_abbr_len + 1);
+       ab = emalloc(max_abbr_len + 1);
+       envvar = emalloc(max_envvar_len + 1);
        INITIALIZE(untiltime);
        INITIALIZE(starttime);
        /*
@@ -1515,16 +1868,62 @@ outzone(const struct zone * const zpfirst, const int zonecount)
        typecnt = 0;
        charcnt = 0;
        /*
-       ** A guess that may well be corrected later.
-       */
-       stdoff = 0;
-       /*
-       ** Thanks to Earl Chew (earl@dnd.icp.nec.com.au)
+       ** Thanks to Earl Chew
        ** for noting the need to unconditionally initialize startttisstd.
        */
        startttisstd = FALSE;
        startttisgmt = FALSE;
+       min_year = max_year = EPOCH_YEAR;
+       if (leapseen) {
+               updateminmax(leapminyear);
+               updateminmax(leapmaxyear + (leapmaxyear < INT_MAX));
+       }
+       for (i = 0; i < zonecount; ++i) {
+               zp = &zpfirst[i];
+               if (i < zonecount - 1)
+                       updateminmax(zp->z_untilrule.r_loyear);
+               for (j = 0; j < zp->z_nrules; ++j) {
+                       rp = &zp->z_rules[j];
+                       if (rp->r_lowasnum)
+                               updateminmax(rp->r_loyear);
+                       if (rp->r_hiwasnum)
+                               updateminmax(rp->r_hiyear);
+               }
+       }
+       /*
+       ** Generate lots of data if a rule can't cover all future times.
+       */
+       stringzone(envvar, zpfirst, zonecount);
+       if (noise && envvar[0] == '\0') {
+               char *  wp;
+
+wp = ecpyalloc(_("no POSIX environment variable for zone"));
+               wp = ecatalloc(wp, " ");
+               wp = ecatalloc(wp, zpfirst->z_name);
+               warning(wp);
+               ifree(wp);
+       }
+       if (envvar[0] == '\0') {
+               if (min_year >= INT_MIN + YEARSPERREPEAT)
+                       min_year -= YEARSPERREPEAT;
+               else    min_year = INT_MIN;
+               if (max_year <= INT_MAX - YEARSPERREPEAT)
+                       max_year += YEARSPERREPEAT;
+               else    max_year = INT_MAX;
+       }
+       /*
+       ** For the benefit of older systems,
+       ** generate data from 1900 through 2037.
+       */
+       if (min_year > 1900)
+               min_year = 1900;
+       if (max_year < 2037)
+               max_year = 2037;
        for (i = 0; i < zonecount; ++i) {
+               /*
+               ** A guess that may well be corrected later.
+               */
+               stdoff = 0;
                zp = &zpfirst[i];
                usestart = i > 0 && (zp - 1)->z_untiltime > min_time;
                useuntil = i < (zonecount - 1);
@@ -1537,15 +1936,14 @@ outzone(const struct zone * const zpfirst, const int zonecount)
                if (zp->z_nrules == 0) {
                        stdoff = zp->z_stdoff;
                        doabbr(startbuf, zp->z_format,
-                               (char *) NULL, stdoff != 0);
+                               NULL, stdoff != 0, FALSE);
                        type = addtype(oadd(zp->z_gmtoff, stdoff),
                                startbuf, stdoff != 0, startttisstd,
                                startttisgmt);
                        if (usestart) {
                                addtt(starttime, type);
                                usestart = FALSE;
-                       }
-                       else if (stdoff != 0)
+                       } else if (stdoff != 0)
                                addtt(min_time, type);
                } else for (year = min_year; year <= max_year; ++year) {
                        if (useuntil && year > zp->z_untilrule.r_hiyear)
@@ -1566,9 +1964,8 @@ outzone(const struct zone * const zpfirst, const int zonecount)
                        }
                        for ( ; ; ) {
                                int k;
-                               time_t jtime, ktime;
+                               zic_t jtime, ktime;
                                long offset;
-                               char buf[BUFSIZ];
 
                                INITIALIZE(ktime);
                                if (useuntil) {
@@ -1624,23 +2021,27 @@ outzone(const struct zone * const zpfirst, const int zonecount)
                                                        stdoff);
                                                doabbr(startbuf, zp->z_format,
                                                        rp->r_abbrvar,
-                                                       rp->r_stdoff != 0);
+                                                       rp->r_stdoff != 0,
+                                                       FALSE);
                                                continue;
                                        }
                                        if (*startbuf == '\0' &&
-                                           startoff == oadd(zp->z_gmtoff,
-                                           stdoff)) {
-                                               doabbr(startbuf, zp->z_format,
-                                                       rp->r_abbrvar,
-                                                       rp->r_stdoff != 0);
+                                               startoff == oadd(zp->z_gmtoff,
+                                               stdoff)) {
+                                                       doabbr(startbuf,
+                                                               zp->z_format,
+                                                               rp->r_abbrvar,
+                                                               rp->r_stdoff !=
+                                                               0,
+                                                               FALSE);
                                        }
                                }
                                eats(zp->z_filename, zp->z_linenum,
                                        rp->r_filename, rp->r_linenum);
-                               doabbr(buf, zp->z_format, rp->r_abbrvar,
-                                       rp->r_stdoff != 0);
+                               doabbr(ab, zp->z_format, rp->r_abbrvar,
+                                       rp->r_stdoff != 0, FALSE);
                                offset = oadd(zp->z_gmtoff, rp->r_stdoff);
-                               type = addtype(offset, buf, rp->r_stdoff != 0,
+                               type = addtype(offset, ab, rp->r_stdoff != 0,
                                        rp->r_todisstd, rp->r_todisgmt);
                                addtt(ktime, type);
                        }
@@ -1673,11 +2074,14 @@ error(_("can't determine time zone abbreviation to use just after until time"));
                                starttime = tadd(starttime, -gmtoff);
                }
        }
-       writezone(zpfirst->z_name);
+       writezone(zpfirst->z_name, envvar);
+       ifree(startbuf);
+       ifree(ab);
+       ifree(envvar);
 }
 
 static void
-addtt(const time_t starttime, int type)
+addtt(const zic_t starttime, int type)
 {
        if (starttime <= min_time ||
                (timecnt == 1 && attypes[0].at < min_time)) {
@@ -1739,6 +2143,10 @@ addtype(const long gmtoff, const char * const abbr, const int isdst,
                error(_("too many local time types"));
                exit(EXIT_FAILURE);
        }
+       if (! (-1L - 2147483647L <= gmtoff && gmtoff <= 2147483647L)) {
+               error(_("UTC offset out of range"));
+               exit(EXIT_FAILURE);
+       }
        gmtoffs[i] = gmtoff;
        isdsts[i] = isdst;
        ttisstds[i] = ttisstd;
@@ -1755,7 +2163,7 @@ addtype(const long gmtoff, const char * const abbr, const int isdst,
 }
 
 static void
-leapadd(const time_t t, const int positive, const int rolling, int count)
+leapadd(const zic_t t, const int positive, const int rolling, int count)
 {
        int i, j;
 
@@ -1810,11 +2218,13 @@ yearistype(const int year, const char * const type)
        buf = erealloc(buf, (int) (132 + strlen(yitcommand) + strlen(type)));
        sprintf(buf, "%s %d %s", yitcommand, year, type);
        result = system(buf);
-       if (result == 0)
-               return TRUE;
-       if (result == (1 << 8))
-               return FALSE;
-       error(_("wild result from command execution"));
+       if (WIFEXITED(result)) switch (WEXITSTATUS(result)) {
+               case 0:
+                       return TRUE;
+               case 1:
+                       return FALSE;
+       }
+       error(_("Wild result from command execution"));
        warnx(_("command was '%s', result was %d"), buf, result);
        for ( ; ; )
                exit(EXIT_FAILURE);
@@ -1890,8 +2300,9 @@ getfields(char *cp)
                emalloc((int) ((strlen(cp) + 1) * sizeof *array));
        nsubs = 0;
        for ( ; ; ) {
-               while (isascii(*cp) && isspace((unsigned char) *cp))
-                       ++cp;
+               while (isascii((unsigned char) *cp) &&
+                       isspace((unsigned char) *cp))
+                               ++cp;
                if (*cp == '\0' || *cp == '#')
                        break;
                array[nsubs++] = dp = cp;
@@ -1901,7 +2312,12 @@ getfields(char *cp)
                        else while ((*dp = *cp++) != '"')
                                if (*dp != '\0')
                                        ++dp;
-                               else    error(_("odd number of quotation marks"));
+                               else {
+                                       error(_(
+                                               "Odd number of quotation marks"
+                                               ));
+                                       exit(1);
+                               }
                } while (*cp != '\0' && *cp != '#' &&
                        (!isascii(*cp) || !isspace((unsigned char) *cp)));
                if (isascii(*cp) && isspace((unsigned char) *cp))
@@ -1925,10 +2341,10 @@ oadd(const long t1, const long t2)
        return t;
 }
 
-static time_t
-tadd(const time_t t1, const long t2)
+static zic_t
+tadd(const zic_t t1, const long t2)
 {
-       time_t t;
+       zic_t t;
 
        if (t1 == max_time && t2 > 0)
                return max_time;
@@ -1947,12 +2363,12 @@ tadd(const time_t t1, const long t2)
 ** 1970, 00:00 LOCAL time - in that year that the rule refers to.
 */
 
-static time_t
+static zic_t
 rpytime(const struct rule * const rp, const int wantedy)
 {
        int y, m, i;
        long dayoff;                    /* with a nod to Margaret O. */
-       time_t t;
+       zic_t t;
 
        if (wantedy == INT_MIN)
                return min_time;
@@ -2015,18 +2431,16 @@ rpytime(const struct rule * const rp, const int wantedy)
                                --i;
                        }
                if (i < 0 || i >= len_months[isleap(y)][m]) {
-                       error(_("no day in month matches rule"));
-                       exit(EXIT_FAILURE);
+                       if (noise)
+                               warning(_("rule goes past start/end of month--\
+will not work with pre-2004 versions of zic"));
                }
        }
-       if (dayoff < 0 && !TYPE_SIGNED(time_t))
+       if (dayoff < min_time / SECSPERDAY)
                return min_time;
-       t = (time_t) dayoff * SECSPERDAY;
-       /*
-       ** Cheap overflow check.
-       */
-       if (t / SECSPERDAY != dayoff)
-               return (dayoff > 0) ? max_time : min_time;
+       if (dayoff > max_time / SECSPERDAY)
+               return max_time;
+       t = (zic_t) dayoff * SECSPERDAY;
        return tadd(t, rp->r_tod);
 }
 
@@ -2035,6 +2449,44 @@ newabbr(const char * const string)
 {
        int i;
 
+       if (strcmp(string, GRANDPARENTED) != 0) {
+               const char *    cp;
+               char *          wp;
+
+               /*
+               ** Want one to ZIC_MAX_ABBR_LEN_WO_WARN alphabetics
+               ** optionally followed by a + or - and a number from 1 to 14.
+               */
+               cp = string;
+               wp = NULL;
+               while (isascii((unsigned char) *cp) &&
+                       isalpha((unsigned char) *cp))
+                               ++cp;
+               if (cp - string == 0)
+wp = _("time zone abbreviation lacks alphabetic at start");
+               if (noise && cp - string > 3)
+wp = _("time zone abbreviation has more than 3 alphabetics");
+               if (cp - string > ZIC_MAX_ABBR_LEN_WO_WARN)
+wp = _("time zone abbreviation has too many alphabetics");
+               if (wp == NULL && (*cp == '+' || *cp == '-')) {
+                       ++cp;
+                       if (isascii((unsigned char) *cp) &&
+                               isdigit((unsigned char) *cp))
+                                       if (*cp++ == '1' &&
+                                               *cp >= '0' && *cp <= '4')
+                                                       ++cp;
+               }
+               if (*cp != '\0')
+wp = _("time zone abbreviation differs from POSIX standard");
+               if (wp != NULL) {
+                       wp = ecpyalloc(wp);
+                       wp = ecatalloc(wp, " (");
+                       wp = ecatalloc(wp, string);
+                       wp = ecatalloc(wp, ")");
+                       warning(wp);
+                       ifree(wp);
+               }
+       }
        i = strlen(string) + 1;
        if (charcnt + i > TZ_MAX_CHARS) {
                error(_("too many, or too long, time zone abbreviations"));
@@ -2045,7 +2497,7 @@ newabbr(const char * const string)
 }
 
 static int
-mkdirs(char * const argname)
+mkdirs(char *argname)
 {
        char *name;
        char *cp;
@@ -2072,10 +2524,8 @@ mkdirs(char * const argname)
                        ** created by some other multiprocessor, so we get
                        ** to do extra checking.
                        */
-                       if (mkdir(name, (S_IRUSR | S_IWUSR | S_IXUSR 
-                                        | S_IRGRP | S_IXGRP | S_IROTH
-                                        | S_IXOTH)) != 0
-                               && (errno != EEXIST || !itsdir(name))) {
+                       if ((mkdir(name, MKDIR_UMASK) != 0) &&
+                               (errno != EEXIST || !itsdir(name))) {
                                warn(_("can't create directory %s"), name);
                                ifree(name);
                                return -1;
@@ -2148,5 +2598,5 @@ setuser(uid_t *flag, const char *name)
 }
 
 /*
-** UNIX was a registered trademark of UNIX System Laboratories in 1993.
+** UNIX was a registered trademark of The Open Group in 2003.
 */