reset upstream subtrees to yocto 2.6
Reset the following subtrees on thud HEAD:
poky: 87e3a9739d
meta-openembedded: 6094ae18c8
meta-security: 31dc4e7532
meta-raspberrypi: a48743dc36
meta-xilinx: c42016e2e6
Also re-apply backports that didn't make it into thud:
poky:
17726d0 systemd-systemctl-native: handle Install wildcards
meta-openembedded:
4321a5d libtinyxml2: update to 7.0.1
042f0a3 libcereal: Add native and nativesdk classes
e23284f libcereal: Allow empty package
030e8d4 rsyslog: curl-less build with fmhttp PACKAGECONFIG
179a1b9 gtest: update to 1.8.1
Squashed OpenBMC subtree compatibility updates:
meta-aspeed:
Brad Bishop (1):
aspeed: add yocto 2.6 compatibility
meta-ibm:
Brad Bishop (1):
ibm: prepare for yocto 2.6
meta-ingrasys:
Brad Bishop (1):
ingrasys: set layer compatibility to yocto 2.6
meta-openpower:
Brad Bishop (1):
openpower: set layer compatibility to yocto 2.6
meta-phosphor:
Brad Bishop (3):
phosphor: set layer compatibility to thud
phosphor: libgpg-error: drop patches
phosphor: react to fitimage artifact rename
Ed Tanous (4):
Dropbear: upgrade options for latest upgrade
yocto2.6: update openssl options
busybox: remove upstream watchdog patch
systemd: Rebase CONFIG_CGROUP_BPF patch
Change-Id: I7b1fe71cca880d0372a82d94b5fd785323e3a9e7
Signed-off-by: Brad Bishop <bradleyb@fuzziesquirrel.com>
diff --git a/meta-openembedded/meta-oe/recipes-dbs/postgresql/files/0001-Sync-our-copy-of-the-timezone-library-with-IANA-rele.patch b/meta-openembedded/meta-oe/recipes-dbs/postgresql/files/0001-Sync-our-copy-of-the-timezone-library-with-IANA-rele.patch
new file mode 100644
index 0000000..6d8c46e
--- /dev/null
+++ b/meta-openembedded/meta-oe/recipes-dbs/postgresql/files/0001-Sync-our-copy-of-the-timezone-library-with-IANA-rele.patch
@@ -0,0 +1,1164 @@
+From 12bfb778ce688fc662a6cb35f6298734fcf4856f Mon Sep 17 00:00:00 2001
+From: Tom Lane <tgl@sss.pgh.pa.us>
+Date: Fri, 19 Oct 2018 19:36:34 -0400
+Subject: [PATCH] Sync our copy of the timezone library with IANA release
+ tzcode2018f.
+
+About half of this is purely cosmetic changes to reduce the diff between
+our code and theirs, like inserting "const" markers where they have them.
+
+The other half is tracking actual code changes in zic.c and localtime.c.
+I don't think any of these represent near-term compatibility hazards, but
+it seems best to stay up to date.
+
+I also fixed longstanding bugs in our code for producing the
+known_abbrevs.txt list, which by chance hadn't been exposed before,
+but which resulted in some garbage output after applying the upstream
+changes in zic.c. Notably, because upstream removed their old phony
+transitions at the Big Bang, it's now necessary to cope with TZif files
+containing no DST transition times at all.
+
+Upstream-Status: Backport
+Signed-off-by: Armin Kuster <akuster@mvista.com>
+
+---
+ src/timezone/README | 2 +-
+ src/timezone/localtime.c | 126 ++++++++++++------
+ src/timezone/pgtz.h | 10 +-
+ src/timezone/private.h | 3 +
+ src/timezone/strftime.c | 10 +-
+ src/timezone/tzfile.h | 7 +-
+ src/timezone/zic.c | 330 ++++++++++++++++++++++++++---------------------
+ 7 files changed, 291 insertions(+), 197 deletions(-)
+
+Index: postgresql-10.5/src/timezone/README
+===================================================================
+--- postgresql-10.5.orig/src/timezone/README
++++ postgresql-10.5/src/timezone/README
+@@ -55,7 +55,7 @@ match properly on the old version.
+ Time Zone code
+ ==============
+
+-The code in this directory is currently synced with tzcode release 2018e.
++The code in this directory is currently synced with tzcode release 2018f.
+ There are many cosmetic (and not so cosmetic) differences from the
+ original tzcode library, but diffs in the upstream version should usually
+ be propagated to our version. Here are some notes about that.
+Index: postgresql-10.5/src/timezone/localtime.c
+===================================================================
+--- postgresql-10.5.orig/src/timezone/localtime.c
++++ postgresql-10.5/src/timezone/localtime.c
+@@ -1,3 +1,5 @@
++/* Convert timestamp from pg_time_t to struct pg_tm. */
++
+ /*
+ * This file is in the public domain, so clarified as of
+ * 1996-06-05 by Arthur David Olson.
+@@ -117,7 +119,7 @@ init_ttinfo(struct ttinfo *s, int32 gmto
+ }
+
+ static int32
+-detzcode(const char *codep)
++detzcode(const char *const codep)
+ {
+ int32 result;
+ int i;
+@@ -143,7 +145,7 @@ detzcode(const char *codep)
+ }
+
+ static int64
+-detzcode64(const char *codep)
++detzcode64(const char *const codep)
+ {
+ uint64 result;
+ int i;
+@@ -258,8 +260,13 @@ tzloadbody(char const *name, char *canon
+ int32 charcnt = detzcode(up->tzhead.tzh_charcnt);
+ char const *p = up->buf + tzheadsize;
+
++ /*
++ * Although tzfile(5) currently requires typecnt to be nonzero,
++ * support future formats that may allow zero typecnt in files that
++ * have a TZ string and no transitions.
++ */
+ if (!(0 <= leapcnt && leapcnt < TZ_MAX_LEAPS
+- && 0 < typecnt && typecnt < TZ_MAX_TYPES
++ && 0 <= typecnt && typecnt < TZ_MAX_TYPES
+ && 0 <= timecnt && timecnt < TZ_MAX_TIMES
+ && 0 <= charcnt && charcnt < TZ_MAX_CHARS
+ && (ttisstdcnt == typecnt || ttisstdcnt == 0)
+@@ -416,8 +423,7 @@ tzloadbody(char const *name, char *canon
+ struct state *ts = &lsp->u.st;
+
+ up->buf[nread - 1] = '\0';
+- if (tzparse(&up->buf[1], ts, false)
+- && ts->typecnt == 2)
++ if (tzparse(&up->buf[1], ts, false))
+ {
+ /*
+ * Attempt to reuse existing abbreviations. Without this,
+@@ -430,7 +436,7 @@ tzloadbody(char const *name, char *canon
+ int gotabbr = 0;
+ int charcnt = sp->charcnt;
+
+- for (i = 0; i < 2; i++)
++ for (i = 0; i < ts->typecnt; i++)
+ {
+ char *tsabbr = ts->chars + ts->ttis[i].tt_abbrind;
+ int j;
+@@ -455,7 +461,7 @@ tzloadbody(char const *name, char *canon
+ }
+ }
+ }
+- if (gotabbr == 2)
++ if (gotabbr == ts->typecnt)
+ {
+ sp->charcnt = charcnt;
+
+@@ -470,7 +476,8 @@ tzloadbody(char const *name, char *canon
+ sp->timecnt--;
+
+ for (i = 0; i < ts->timecnt; i++)
+- if (sp->ats[sp->timecnt - 1] < ts->ats[i])
++ if (sp->timecnt == 0
++ || sp->ats[sp->timecnt - 1] < ts->ats[i])
+ break;
+ while (i < ts->timecnt
+ && sp->timecnt < TZ_MAX_TIMES)
+@@ -481,11 +488,13 @@ tzloadbody(char const *name, char *canon
+ sp->timecnt++;
+ i++;
+ }
+- sp->ttis[sp->typecnt++] = ts->ttis[0];
+- sp->ttis[sp->typecnt++] = ts->ttis[1];
++ for (i = 0; i < ts->typecnt; i++)
++ sp->ttis[sp->typecnt++] = ts->ttis[i];
+ }
+ }
+ }
++ if (sp->typecnt == 0)
++ return EINVAL;
+ if (sp->timecnt > 1)
+ {
+ for (i = 1; i < sp->timecnt; ++i)
+@@ -507,6 +516,18 @@ tzloadbody(char const *name, char *canon
+ }
+
+ /*
++ * Infer sp->defaulttype from the data. Although this default type is
++ * always zero for data from recent tzdb releases, things are trickier for
++ * data from tzdb 2018e or earlier.
++ *
++ * The first set of heuristics work around bugs in 32-bit data generated
++ * by tzdb 2013c or earlier. The workaround is for zones like
++ * Australia/Macquarie where timestamps before the first transition have a
++ * time type that is not the earliest standard-time type. See:
++ * https://mm.icann.org/pipermail/tz/2013-May/019368.html
++ */
++
++ /*
+ * If type 0 is unused in transitions, it's the type to use for early
+ * times.
+ */
+@@ -529,6 +550,11 @@ tzloadbody(char const *name, char *canon
+ }
+
+ /*
++ * The next heuristics are for data generated by tzdb 2018e or earlier,
++ * for zones like EST5EDT where the first transition is to DST.
++ */
++
++ /*
+ * If no result yet, find the first standard type. If there is none, punt
+ * to type zero.
+ */
+@@ -542,7 +568,14 @@ tzloadbody(char const *name, char *canon
+ break;
+ }
+ }
++
++ /*
++ * A simple 'sp->defaulttype = 0;' would suffice here if we didn't have to
++ * worry about 2018e-or-earlier data. Even simpler would be to remove the
++ * defaulttype member and just use 0 in its place.
++ */
+ sp->defaulttype = i;
++
+ return 0;
+ }
+
+@@ -601,10 +634,11 @@ static const int year_lengths[2] = {
+ };
+
+ /*
+- * Given a pointer into a time zone string, scan until a character that is not
+- * a valid character in a zone name is found. Return a pointer to that
+- * character.
++ * Given a pointer into a timezone string, scan until a character that is not
++ * a valid character in a time zone abbreviation is found.
++ * Return a pointer to that character.
+ */
++
+ static const char *
+ getzname(const char *strp)
+ {
+@@ -617,15 +651,17 @@ getzname(const char *strp)
+ }
+
+ /*
+- * Given a pointer into an extended time zone string, scan until the ending
+- * delimiter of the zone name is located. Return a pointer to the delimiter.
++ * Given a pointer into an extended timezone string, scan until the ending
++ * delimiter of the time zone abbreviation is located.
++ * Return a pointer to the delimiter.
+ *
+ * As with getzname above, the legal character set is actually quite
+ * restricted, with other characters producing undefined results.
+ * We don't do any checking here; checking is done later in common-case code.
+ */
++
+ static const char *
+-getqzname(const char *strp, int delim)
++getqzname(const char *strp, const int delim)
+ {
+ int c;
+
+@@ -635,13 +671,14 @@ getqzname(const char *strp, int delim)
+ }
+
+ /*
+- * Given a pointer into a time zone string, extract a number from that string.
++ * Given a pointer into a timezone string, extract a number from that string.
+ * Check that the number is within a specified range; if it is not, return
+ * NULL.
+ * Otherwise, return a pointer to the first character not part of the number.
+ */
++
+ static const char *
+-getnum(const char *strp, int *nump, int min, int max)
++getnum(const char *strp, int *const nump, const int min, const int max)
+ {
+ char c;
+ int num;
+@@ -663,14 +700,15 @@ getnum(const char *strp, int *nump, int
+ }
+
+ /*
+- * Given a pointer into a time zone string, extract a number of seconds,
++ * Given a pointer into a timezone string, extract a number of seconds,
+ * in hh[:mm[:ss]] form, from the string.
+ * If any error occurs, return NULL.
+ * Otherwise, return a pointer to the first character not part of the number
+ * of seconds.
+ */
++
+ static const char *
+-getsecs(const char *strp, int32 *secsp)
++getsecs(const char *strp, int32 *const secsp)
+ {
+ int num;
+
+@@ -704,13 +742,14 @@ getsecs(const char *strp, int32 *secsp)
+ }
+
+ /*
+- * Given a pointer into a time zone string, extract an offset, in
++ * Given a pointer into a timezone string, extract an offset, in
+ * [+-]hh[:mm[:ss]] form, from the string.
+ * If any error occurs, return NULL.
+ * Otherwise, return a pointer to the first character not part of the time.
+ */
++
+ static const char *
+-getoffset(const char *strp, int32 *offsetp)
++getoffset(const char *strp, int32 *const offsetp)
+ {
+ bool neg = false;
+
+@@ -730,13 +769,14 @@ getoffset(const char *strp, int32 *offse
+ }
+
+ /*
+- * Given a pointer into a time zone string, extract a rule in the form
++ * Given a pointer into a timezone string, extract a rule in the form
+ * date[/time]. See POSIX section 8 for the format of "date" and "time".
+ * If a valid rule is not found, return NULL.
+ * Otherwise, return a pointer to the first character not part of the rule.
+ */
++
+ static const char *
+-getrule(const char *strp, struct rule *rulep)
++getrule(const char *strp, struct rule *const rulep)
+ {
+ if (*strp == 'J')
+ {
+@@ -795,9 +835,10 @@ getrule(const char *strp, struct rule *r
+ * Given a year, a rule, and the offset from UT at the time that rule takes
+ * effect, calculate the year-relative time that rule takes effect.
+ */
++
+ static int32
+-transtime(int year, const struct rule *rulep,
+- int32 offset)
++transtime(const int year, const struct rule *const rulep,
++ const int32 offset)
+ {
+ bool leapyear;
+ int32 value;
+@@ -981,7 +1022,7 @@ tzparse(const char *name, struct state *
+ {
+ dstname = name;
+ name = getzname(name);
+- dstlen = name - dstname; /* length of DST zone name */
++ dstlen = name - dstname; /* length of DST abbr. */
+ }
+ if (!dstlen)
+ return false;
+@@ -1023,8 +1064,8 @@ tzparse(const char *name, struct state *
+ /*
+ * Two transitions per year, from EPOCH_YEAR forward.
+ */
+- init_ttinfo(&sp->ttis[0], -dstoffset, true, stdlen + 1);
+- init_ttinfo(&sp->ttis[1], -stdoffset, false, 0);
++ init_ttinfo(&sp->ttis[0], -stdoffset, false, 0);
++ init_ttinfo(&sp->ttis[1], -dstoffset, true, stdlen + 1);
+ sp->defaulttype = 0;
+ timecnt = 0;
+ janfirst = 0;
+@@ -1073,19 +1114,15 @@ tzparse(const char *name, struct state *
+ if (!increment_overflow_time
+ (&sp->ats[timecnt],
+ janoffset + starttime))
+- sp->types[timecnt++] = reversed;
+- else if (janoffset)
+- sp->defaulttype = reversed;
++ sp->types[timecnt++] = !reversed;
+ sp->ats[timecnt] = janfirst;
+ if (!increment_overflow_time
+ (&sp->ats[timecnt],
+ janoffset + endtime))
+ {
+- sp->types[timecnt++] = !reversed;
++ sp->types[timecnt++] = reversed;
+ yearlim = year + YEARSPERREPEAT + 1;
+ }
+- else if (janoffset)
+- sp->defaulttype = !reversed;
+ }
+ if (increment_overflow_time
+ (&janfirst, janoffset + yearsecs))
+@@ -1094,7 +1131,10 @@ tzparse(const char *name, struct state *
+ }
+ sp->timecnt = timecnt;
+ if (!timecnt)
++ {
++ sp->ttis[0] = sp->ttis[1];
+ sp->typecnt = 1; /* Perpetual DST. */
++ }
+ else if (YEARSPERREPEAT < year - yearbeg)
+ sp->goback = sp->goahead = true;
+ }
+@@ -1163,7 +1203,6 @@ tzparse(const char *name, struct state *
+ * otherwise, add the standard time offset to the
+ * transition time.
+ */
+-
+ /*
+ * Transitions from DST to DDST will effectively disappear
+ * since POSIX provides for only one DST offset.
+@@ -1217,7 +1256,7 @@ tzparse(const char *name, struct state *
+ }
+
+ static void
+-gmtload(struct state *sp)
++gmtload(struct state *const sp)
+ {
+ if (tzload(gmt, NULL, sp, true) != 0)
+ tzparse(gmt, sp, true);
+@@ -1232,7 +1271,7 @@ gmtload(struct state *sp)
+ */
+ static struct pg_tm *
+ localsub(struct state const *sp, pg_time_t const *timep,
+- struct pg_tm *tmp)
++ struct pg_tm *const tmp)
+ {
+ const struct ttinfo *ttisp;
+ int i;
+@@ -1300,6 +1339,11 @@ localsub(struct state const *sp, pg_time
+ }
+ ttisp = &sp->ttis[i];
+
++ /*
++ * To get (wrong) behavior that's compatible with System V Release 2.0
++ * you'd replace the statement below with t += ttisp->tt_gmtoff;
++ * timesub(&t, 0L, sp, tmp);
++ */
+ result = timesub(&t, ttisp->tt_gmtoff, sp, tmp);
+ if (result)
+ {
+@@ -1322,8 +1366,10 @@ pg_localtime(const pg_time_t *timep, con
+ *
+ * Except we have a private "struct state" for GMT, so no sp is passed in.
+ */
++
+ static struct pg_tm *
+-gmtsub(pg_time_t const *timep, int32 offset, struct pg_tm *tmp)
++gmtsub(pg_time_t const *timep, int32 offset,
++ struct pg_tm *tmp)
+ {
+ struct pg_tm *result;
+
+@@ -1337,6 +1383,7 @@ gmtsub(pg_time_t const *timep, int32 off
+ gmt_is_set = true;
+ gmtload(gmtptr);
+ }
++
+ result = timesub(timep, offset, gmtptr, tmp);
+
+ /*
+@@ -1361,6 +1408,7 @@ pg_gmtime(const pg_time_t *timep)
+ * Return the number of leap years through the end of the given year
+ * where, to make the math easy, the answer for year zero is defined as zero.
+ */
++
+ static int
+ leaps_thru_end_of_nonneg(int y)
+ {
+Index: postgresql-10.5/src/timezone/pgtz.h
+===================================================================
+--- postgresql-10.5.orig/src/timezone/pgtz.h
++++ postgresql-10.5/src/timezone/pgtz.h
+@@ -49,10 +49,16 @@ struct state
+ pg_time_t ats[TZ_MAX_TIMES];
+ unsigned char types[TZ_MAX_TIMES];
+ struct ttinfo ttis[TZ_MAX_TYPES];
+- char chars[BIGGEST(BIGGEST(TZ_MAX_CHARS + 1, 3 /* sizeof gmt */ ),
++ char chars[BIGGEST(BIGGEST(TZ_MAX_CHARS + 1, 4 /* sizeof gmt */ ),
+ (2 * (TZ_STRLEN_MAX + 1)))];
+ struct lsinfo lsis[TZ_MAX_LEAPS];
+- int defaulttype; /* for early times or if no transitions */
++
++ /*
++ * The time type to use for early times or if no transitions. It is always
++ * zero for recent tzdb releases. It might be nonzero for data from tzdb
++ * 2018e or earlier.
++ */
++ int defaulttype;
+ };
+
+
+Index: postgresql-10.5/src/timezone/private.h
+===================================================================
+--- postgresql-10.5.orig/src/timezone/private.h
++++ postgresql-10.5/src/timezone/private.h
+@@ -1,4 +1,7 @@
++/* Private header for tzdb code. */
++
+ #ifndef PRIVATE_H
++
+ #define PRIVATE_H
+
+ /*
+Index: postgresql-10.5/src/timezone/strftime.c
+===================================================================
+--- postgresql-10.5.orig/src/timezone/strftime.c
++++ postgresql-10.5/src/timezone/strftime.c
+@@ -1,4 +1,4 @@
+-/* Convert a broken-down timestamp to a string. */
++/* Convert a broken-down timestamp to a string. */
+
+ /*
+ * Copyright 1989 The Regents of the University of California.
+@@ -115,7 +115,7 @@ static char *_add(const char *, char *,
+ static char *_conv(int, const char *, char *, const char *);
+ static char *_fmt(const char *, const struct pg_tm *, char *, const char *,
+ enum warn *);
+-static char *_yconv(int, int, bool, bool, char *, const char *);
++static char *_yconv(int, int, bool, bool, char *, char const *);
+
+
+ size_t
+@@ -441,7 +441,8 @@ _fmt(const char *format, const struct pg
+
+ /*
+ * C99 and later say that %Z must be replaced by the empty
+- * string if the time zone is not determinable.
++ * string if the time zone abbreviation is not
++ * determinable.
+ */
+ continue;
+ case 'z':
+@@ -519,6 +520,7 @@ _add(const char *str, char *pt, const ch
+ * same output as %Y, and that %Y contains at least 4 bytes,
+ * with more only if necessary.
+ */
++
+ static char *
+ _yconv(int a, int b, bool convert_top, bool convert_yy,
+ char *pt, const char *ptlim)
+@@ -526,7 +528,7 @@ _yconv(int a, int b, bool convert_top, b
+ int lead;
+ int trail;
+
+-#define DIVISOR 100
++#define DIVISOR 100
+ trail = a % DIVISOR + b % DIVISOR;
+ lead = a / DIVISOR + b / DIVISOR + trail / DIVISOR;
+ trail %= DIVISOR;
+Index: postgresql-10.5/src/timezone/tzfile.h
+===================================================================
+--- postgresql-10.5.orig/src/timezone/tzfile.h
++++ postgresql-10.5/src/timezone/tzfile.h
+@@ -1,4 +1,7 @@
++/* Layout and location of TZif files. */
++
+ #ifndef TZFILE_H
++
+ #define TZFILE_H
+
+ /*
+@@ -21,14 +24,14 @@
+ * Information about time zone files.
+ */
+
+-#define TZDEFAULT "localtime"
++#define TZDEFAULT "/etc/localtime"
+ #define TZDEFRULES "posixrules"
+
+ /*
+ * Each file begins with. . .
+ */
+
+-#define TZ_MAGIC "TZif"
++#define TZ_MAGIC "TZif"
+
+ struct tzhead
+ {
+Index: postgresql-10.5/src/timezone/zic.c
+===================================================================
+--- postgresql-10.5.orig/src/timezone/zic.c
++++ postgresql-10.5/src/timezone/zic.c
+@@ -1,3 +1,5 @@
++/* Compile .zi time zone data into TZif binary files. */
++
+ /*
+ * This file is in the public domain, so clarified as of
+ * 2006-07-17 by Arthur David Olson.
+@@ -130,8 +132,7 @@ static void adjleap(void);
+ static void associate(void);
+ static void dolink(const char *, const char *, bool);
+ static char **getfields(char *buf);
+-static zic_t gethms(const char *string, const char *errstring,
+- bool);
++static zic_t gethms(const char *string, const char *errstring);
+ static zic_t getstdoff(char *, bool *);
+ static void infile(const char *filename);
+ static void inleap(char **fields, int nfields);
+@@ -162,7 +163,7 @@ enum
+ PERCENT_Z_LEN_BOUND = sizeof "+995959" - 1};
+
+ /* If true, work around a bug in Qt 5.6.1 and earlier, which mishandles
+- tz binary files whose POSIX-TZ-style strings contain '<'; see
++ TZif files whose POSIX-TZ-style strings contain '<'; see
+ QTBUG-53071 <https://bugreports.qt.io/browse/QTBUG-53071>. This
+ workaround will no longer be needed when Qt 5.6.1 and earlier are
+ obsolete, say in the year 2021. */
+@@ -211,7 +212,7 @@ static int typecnt;
+ #define ZF_RULE 3
+ #define ZF_FORMAT 4
+ #define ZF_TILYEAR 5
+-#define ZF_TILMONTH 6
++#define ZF_TILMONTH 6
+ #define ZF_TILDAY 7
+ #define ZF_TILTIME 8
+ #define ZONE_MINFIELDS 5
+@@ -224,12 +225,12 @@ static int typecnt;
+ #define ZFC_GMTOFF 0
+ #define ZFC_RULE 1
+ #define ZFC_FORMAT 2
+-#define ZFC_TILYEAR 3
++#define ZFC_TILYEAR 3
+ #define ZFC_TILMONTH 4
+ #define ZFC_TILDAY 5
+-#define ZFC_TILTIME 6
+-#define ZONEC_MINFIELDS 3
+-#define ZONEC_MAXFIELDS 7
++#define ZFC_TILTIME 6
++#define ZONEC_MINFIELDS 3
++#define ZONEC_MAXFIELDS 7
+
+ /*
+ * Which files are which on a Rule line.
+@@ -244,7 +245,7 @@ static int typecnt;
+ #define RF_TOD 7
+ #define RF_STDOFF 8
+ #define RF_ABBRVAR 9
+-#define RULE_FIELDS 10
++#define RULE_FIELDS 10
+
+ /*
+ * Which fields are which on a Link line.
+@@ -252,7 +253,7 @@ static int typecnt;
+
+ #define LF_FROM 1
+ #define LF_TO 2
+-#define LINK_FIELDS 3
++#define LINK_FIELDS 3
+
+ /*
+ * Which fields are which on a Leap line.
+@@ -264,7 +265,7 @@ static int typecnt;
+ #define LP_TIME 4
+ #define LP_CORR 5
+ #define LP_ROLL 6
+-#define LEAP_FIELDS 7
++#define LEAP_FIELDS 7
+
+ /*
+ * Year synonyms.
+@@ -998,48 +999,6 @@ dolink(char const *fromfield, char const
+ static zic_t const min_time = MINVAL(zic_t, TIME_T_BITS_IN_FILE);
+ static zic_t const max_time = MAXVAL(zic_t, TIME_T_BITS_IN_FILE);
+
+-/*
+- * Estimated time of the Big Bang, in seconds since the POSIX epoch.
+- * rounded downward to the negation of a power of two that is
+- * comfortably outside the error bounds.
+- *
+- * For the time of the Big Bang, see:
+- *
+- * Ade PAR, Aghanim N, Armitage-Caplan C et al. Planck 2013 results.
+- * I. Overview of products and scientific results.
+- * arXiv:1303.5062 2013-03-20 20:10:01 UTC
+- * <https://arxiv.org/pdf/1303.5062v1> [PDF]
+- *
+- * Page 36, Table 9, row Age/Gyr, column Planck+WP+highL+BAO 68% limits
+- * gives the value 13.798 plus-or-minus 0.037 billion years.
+- * Multiplying this by 1000000000 and then by 31557600 (the number of
+- * seconds in an astronomical year) gives a value that is comfortably
+- * less than 2**59, so BIG_BANG is - 2**59.
+- *
+- * BIG_BANG is approximate, and may change in future versions.
+- * Please do not rely on its exact value.
+- */
+-
+-#ifndef BIG_BANG
+-#define BIG_BANG (- (((zic_t) 1) << 59))
+-#endif
+-
+-/* If true, work around GNOME bug 730332
+- <https://bugzilla.gnome.org/show_bug.cgi?id=730332>
+- by refusing to output time stamps before BIG_BANG.
+- Such time stamps are physically suspect anyway.
+-
+- The GNOME bug is scheduled to be fixed in GNOME 3.22, and if so
+- this workaround will no longer be needed when GNOME 3.21 and
+- earlier are obsolete, say in the year 2021. */
+-enum
+-{
+-WORK_AROUND_GNOME_BUG_730332 = true};
+-
+-static const zic_t early_time = (WORK_AROUND_GNOME_BUG_730332
+- ? BIG_BANG
+- : MINVAL(zic_t, TIME_T_BITS_IN_FILE));
+-
+ /* Return true if NAME is a directory. */
+ static bool
+ itsdir(char const *name)
+@@ -1281,8 +1240,9 @@ infile(const char *name)
+ * A null string maps to zero.
+ * Call error with errstring and return zero on errors.
+ */
++
+ static zic_t
+-gethms(char const *string, char const *errstring, bool signable)
++gethms(char const *string, char const *errstring)
+ {
+ /* PG: make hh be int not zic_t to avoid sscanf portability issues */
+ int hh;
+@@ -1299,9 +1259,7 @@ gethms(char const *string, char const *e
+
+ if (string == NULL || *string == '\0')
+ return 0;
+- if (!signable)
+- sign = 1;
+- else if (*string == '-')
++ if (*string == '-')
+ {
+ sign = -1;
+ ++string;
+@@ -1384,7 +1342,7 @@ getstdoff(char *field, bool *isdst)
+ break;
+ }
+ }
+- stdoff = gethms(field, _("invalid saved time"), true);
++ stdoff = gethms(field, _("invalid saved time"));
+ *isdst = dst < 0 ? stdoff != 0 : dst;
+ return stdoff;
+ }
+@@ -1399,10 +1357,29 @@ inrule(char **fields, int nfields)
+ error(_("wrong number of fields on Rule line"));
+ return;
+ }
+- if (*fields[RF_NAME] == '\0')
++ switch (*fields[RF_NAME])
+ {
+- error(_("nameless rule"));
+- return;
++ case '\0':
++ case ' ':
++ case '\f':
++ case '\n':
++ case '\r':
++ case '\t':
++ case '\v':
++ case '+':
++ case '-':
++ case '0':
++ case '1':
++ case '2':
++ case '3':
++ case '4':
++ case '5':
++ case '6':
++ case '7':
++ case '8':
++ case '9':
++ error(_("Invalid rule name \"%s\""), fields[RF_NAME]);
++ return;
+ }
+ r.r_filename = filename;
+ r.r_linenum = linenum;
+@@ -1507,7 +1484,7 @@ inzsub(char **fields, int nfields, bool
+ }
+ z.z_filename = filename;
+ z.z_linenum = linenum;
+- z.z_gmtoff = gethms(fields[i_gmtoff], _("invalid UT offset"), true);
++ z.z_gmtoff = gethms(fields[i_gmtoff], _("invalid UT offset"));
+ if ((cp = strchr(fields[i_format], '%')) != NULL)
+ {
+ if ((*++cp != 's' && *cp != 'z') || strchr(cp, '%')
+@@ -1649,7 +1626,7 @@ inleap(char **fields, int nfields)
+ return;
+ }
+ t = dayoff * SECSPERDAY;
+- tod = gethms(fields[LP_TIME], _("invalid time of day"), false);
++ tod = gethms(fields[LP_TIME], _("invalid time of day"));
+ cp = fields[LP_CORR];
+ {
+ bool positive;
+@@ -1757,7 +1734,7 @@ rulesub(struct rule *rp, const char *loy
+ break;
+ }
+ }
+- rp->r_tod = gethms(dp, _("invalid time of day"), false);
++ rp->r_tod = gethms(dp, _("invalid time of day"));
+ free(dp);
+
+ /*
+@@ -1942,7 +1919,43 @@ is32(const zic_t x)
+ }
+
+ static void
+-writezone(const char *const name, const char *const string, char version)
++swaptypes(int i, int j)
++{
++ {
++ zic_t t = gmtoffs[i];
++
++ gmtoffs[i] = gmtoffs[j];
++ gmtoffs[j] = t;
++ }
++ {
++ char t = isdsts[i];
++
++ isdsts[i] = isdsts[j];
++ isdsts[j] = t;
++ }
++ {
++ unsigned char t = abbrinds[i];
++
++ abbrinds[i] = abbrinds[j];
++ abbrinds[j] = t;
++ }
++ {
++ bool t = ttisstds[i];
++
++ ttisstds[i] = ttisstds[j];
++ ttisstds[j] = t;
++ }
++ {
++ bool t = ttisgmts[i];
++
++ ttisgmts[i] = ttisgmts[j];
++ ttisgmts[j] = t;
++ }
++}
++
++static void
++writezone(const char *const name, const char *const string, char version,
++ int defaulttype)
+ {
+ FILE *fp;
+ ptrdiff_t i,
+@@ -1977,14 +1990,12 @@ writezone(const char *const name, const
+
+ toi = 0;
+ fromi = 0;
+- while (fromi < timecnt && attypes[fromi].at < early_time)
+- ++fromi;
+ for (; fromi < timecnt; ++fromi)
+ {
+- if (toi > 1 && ((attypes[fromi].at +
+- gmtoffs[attypes[toi - 1].type]) <=
+- (attypes[toi - 1].at +
+- gmtoffs[attypes[toi - 2].type])))
++ 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;
+@@ -2019,8 +2030,8 @@ writezone(const char *const name, const
+ }
+
+ /*
+- * Work around QTBUG-53071 for time stamps less than y2038_boundary - 1,
+- * by inserting a no-op transition at time y2038_boundary - 1. This works
++ * Work around QTBUG-53071 for timestamps less than y2038_boundary - 1, by
++ * inserting a no-op transition at time y2038_boundary - 1. This works
+ * only for timestamps before the boundary, which should be good enough in
+ * practice as QTBUG-53071 should be long-dead by 2038.
+ */
+@@ -2116,7 +2127,8 @@ writezone(const char *const name, const
+ int thisleapi,
+ thisleapcnt,
+ thisleaplim;
+- int writetype[TZ_MAX_TYPES];
++ int old0;
++ char omittype[TZ_MAX_TYPES];
+ int typemap[TZ_MAX_TYPES];
+ int thistypecnt;
+ char thischars[TZ_MAX_CHARS];
+@@ -2144,28 +2156,19 @@ writezone(const char *const name, const
+ error(_("too many transition times"));
+ 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;
++ memset(omittype, true, typecnt);
++ omittype[defaulttype] = false;
++ for (i = thistimei; i < thistimelim; i++)
++ omittype[types[i]] = false;
++
++ /*
++ * Reorder types to make DEFAULTTYPE type 0. Use TYPEMAP to swap OLD0
++ * and DEFAULTTYPE so that DEFAULTTYPE appears as type 0 in the output
++ * instead of OLD0. TYPEMAP also omits unused types.
++ */
++ old0 = strlen(omittype);
++ swaptypes(old0, defaulttype);
+
+- /*
+- * For America/Godthab and Antarctica/Palmer
+- */
+- if (thistimei == 0)
+- writetype[0] = true;
+- }
+ #ifndef LEAVE_SOME_PRE_2011_SYSTEMS_IN_THE_LURCH
+
+ /*
+@@ -2187,8 +2190,8 @@ writezone(const char *const name, const
+ mrudst = types[i];
+ else
+ mrustd = types[i];
+- for (i = 0; i < typecnt; ++i)
+- if (writetype[i])
++ for (i = old0; i < typecnt; i++)
++ if (!omittype[i])
+ {
+ if (isdsts[i])
+ hidst = i;
+@@ -2205,7 +2208,7 @@ writezone(const char *const name, const
+ ttisstds[mrudst],
+ ttisgmts[mrudst]);
+ isdsts[mrudst] = 1;
+- writetype[type] = true;
++ omittype[type] = false;
+ }
+ if (histd >= 0 && mrustd >= 0 && histd != mrustd &&
+ gmtoffs[histd] != gmtoffs[mrustd])
+@@ -2217,22 +2220,26 @@ writezone(const char *const name, const
+ ttisstds[mrustd],
+ ttisgmts[mrustd]);
+ isdsts[mrustd] = 0;
+- writetype[type] = true;
++ omittype[type] = false;
+ }
+ }
+ #endif /* !defined
+ * LEAVE_SOME_PRE_2011_SYSTEMS_IN_THE_LURCH */
+ thistypecnt = 0;
+- for (i = 0; i < typecnt; ++i)
+- typemap[i] = writetype[i] ? thistypecnt++ : -1;
++ for (i = old0; i < typecnt; i++)
++ if (!omittype[i])
++ typemap[i == old0 ? defaulttype
++ : i == defaulttype ? old0 : i]
++ = thistypecnt++;
++
+ for (i = 0; i < sizeof indmap / sizeof indmap[0]; ++i)
+ indmap[i] = -1;
+ thischarcnt = 0;
+- for (i = 0; i < typecnt; ++i)
++ for (i = old0; i < typecnt; i++)
+ {
+ char *thisabbr;
+
+- if (!writetype[i])
++ if (omittype[i])
+ continue;
+ if (indmap[abbrinds[i]] >= 0)
+ continue;
+@@ -2267,23 +2274,16 @@ writezone(const char *const name, const
+ DO(tzh_typecnt);
+ DO(tzh_charcnt);
+ #undef DO
+- for (i = thistimei; i < thistimelim; ++i)
+- if (pass == 1)
+
+- /*
+- * Output an INT32_MIN "transition" if appropriate; see above.
+- */
+- puttzcode(((ats[i] < PG_INT32_MIN) ?
+- PG_INT32_MIN : ats[i]), fp);
+- else
++ /* PG: print current timezone abbreviations if requested */
++ if (print_abbrevs && pass == 2)
++ {
++ /* Print "type" data for periods ending after print_cutoff */
++ for (i = thistimei; i < thistimelim; ++i)
+ {
+- puttzcode64(ats[i], fp);
+-
+- /* Print current timezone abbreviations if requested */
+- if (print_abbrevs &&
+- (i == thistimelim - 1 || ats[i + 1] > print_cutoff))
++ if (i == thistimelim - 1 || ats[i + 1] > print_cutoff)
+ {
+- unsigned char tm = typemap[types[i]];
++ unsigned char tm = types[i];
+ char *thisabbrev = &thischars[indmap[abbrinds[tm]]];
+
+ /* filter out assorted junk entries */
+@@ -2295,6 +2295,32 @@ writezone(const char *const name, const
+ isdsts[tm] ? "\tD" : "");
+ }
+ }
++ /* Print the default type if we have no transitions at all */
++ if (thistimei >= thistimelim)
++ {
++ unsigned char tm = defaulttype;
++ char *thisabbrev = &thischars[indmap[abbrinds[tm]]];
++
++ /* filter out assorted junk entries */
++ if (strcmp(thisabbrev, GRANDPARENTED) != 0 &&
++ strcmp(thisabbrev, "zzz") != 0)
++ fprintf(stdout, "%s\t" INT64_FORMAT "%s\n",
++ thisabbrev,
++ gmtoffs[tm],
++ isdsts[tm] ? "\tD" : "");
++ }
++ }
++
++ for (i = thistimei; i < thistimelim; ++i)
++ if (pass == 1)
++
++ /*
++ * Output an INT32_MIN "transition" if appropriate; see above.
++ */
++ puttzcode(((ats[i] < PG_INT32_MIN) ?
++ PG_INT32_MIN : ats[i]), fp);
++ else
++ puttzcode64(ats[i], fp);
+ for (i = thistimei; i < thistimelim; ++i)
+ {
+ unsigned char uc;
+@@ -2302,8 +2328,8 @@ writezone(const char *const name, const
+ uc = typemap[types[i]];
+ fwrite(&uc, sizeof uc, 1, fp);
+ }
+- for (i = 0; i < typecnt; ++i)
+- if (writetype[i])
++ for (i = old0; i < typecnt; i++)
++ if (!omittype[i])
+ {
+ puttzcode(gmtoffs[i], fp);
+ putc(isdsts[i], fp);
+@@ -2346,12 +2372,13 @@ writezone(const char *const name, const
+ puttzcode64(todo, fp);
+ puttzcode(corr[i], fp);
+ }
+- for (i = 0; i < typecnt; ++i)
+- if (writetype[i])
++ for (i = old0; i < typecnt; i++)
++ if (!omittype[i])
+ putc(ttisstds[i], fp);
+- for (i = 0; i < typecnt; ++i)
+- if (writetype[i])
++ for (i = old0; i < typecnt; i++)
++ if (!omittype[i])
+ putc(ttisgmts[i], fp);
++ swaptypes(old0, defaulttype);
+ }
+ fprintf(fp, "\n%s\n", string);
+ close_file(fp, directory, name);
+@@ -2757,6 +2784,7 @@ outzone(const struct zone *zpfirst, ptrd
+ zic_t one = 1;
+ zic_t y2038_boundary = one << 31;
+ zic_t max_year0;
++ int defaulttype = -1;
+
+ max_abbr_len = 2 + max_format_len + max_abbrvar_len;
+ max_envvar_len = 2 * max_abbr_len + 5 * 9;
+@@ -2880,9 +2908,9 @@ outzone(const struct zone *zpfirst, ptrd
+ */
+ stdoff = 0;
+ zp = &zpfirst[i];
+- usestart = i > 0 && (zp - 1)->z_untiltime > early_time;
++ usestart = i > 0 && (zp - 1)->z_untiltime > min_time;
+ useuntil = i < (zonecount - 1);
+- if (useuntil && zp->z_untiltime <= early_time)
++ if (useuntil && zp->z_untiltime <= min_time)
+ continue;
+ gmtoff = zp->z_gmtoff;
+ eat(zp->z_filename, zp->z_linenum);
+@@ -2901,7 +2929,7 @@ outzone(const struct zone *zpfirst, ptrd
+ usestart = false;
+ }
+ else
+- addtt(early_time, type);
++ defaulttype = type;
+ }
+ else
+ for (year = min_year; year <= max_year; ++year)
+@@ -3032,6 +3060,8 @@ outzone(const struct zone *zpfirst, ptrd
+ offset = oadd(zp->z_gmtoff, rp->r_stdoff);
+ type = addtype(offset, ab, rp->r_isdst,
+ rp->r_todisstd, rp->r_todisgmt);
++ if (defaulttype < 0 && !rp->r_isdst)
++ defaulttype = type;
+ if (rp->r_hiyear == ZIC_MAX
+ && !(0 <= lastatmax
+ && ktime < attypes[lastatmax].at))
+@@ -3050,11 +3080,15 @@ outzone(const struct zone *zpfirst, ptrd
+ if (*startbuf == '\0')
+ error(_("cannot determine time zone abbreviation to use just after until time"));
+ else
+- addtt(starttime,
+- addtype(startoff, startbuf,
+- startoff != zp->z_gmtoff,
+- startttisstd,
+- startttisgmt));
++ {
++ bool isdst = startoff != zp->z_gmtoff;
++
++ type = addtype(startoff, startbuf, isdst,
++ startttisstd, startttisgmt);
++ if (defaulttype < 0 && !isdst)
++ defaulttype = type;
++ addtt(starttime, type);
++ }
+ }
+
+ /*
+@@ -3071,6 +3105,8 @@ outzone(const struct zone *zpfirst, ptrd
+ starttime = tadd(starttime, -gmtoff);
+ }
+ }
++ if (defaulttype < 0)
++ defaulttype = 0;
+ if (0 <= lastatmax)
+ attypes[lastatmax].dontmerge = true;
+ if (do_extend)
+@@ -3100,7 +3136,7 @@ outzone(const struct zone *zpfirst, ptrd
+ attypes[timecnt - 1].dontmerge = true;
+ }
+ }
+- writezone(zpfirst->z_name, envvar, version);
++ writezone(zpfirst->z_name, envvar, version, defaulttype);
+ free(startbuf);
+ free(ab);
+ free(envvar);
+@@ -3109,21 +3145,6 @@ outzone(const struct zone *zpfirst, ptrd
+ static void
+ addtt(zic_t starttime, int type)
+ {
+- if (starttime <= early_time
+- || (timecnt == 1 && attypes[0].at < early_time))
+- {
+- gmtoffs[0] = gmtoffs[type];
+- isdsts[0] = isdsts[type];
+- ttisstds[0] = ttisstds[type];
+- ttisgmts[0] = ttisgmts[type];
+- if (abbrinds[type] != 0)
+- strcpy(chars, &chars[abbrinds[type]]);
+- abbrinds[0] = 0;
+- charcnt = strlen(chars) + 1;
+- typecnt = 1;
+- timecnt = 0;
+- type = 0;
+- }
+ attypes = growalloc(attypes, sizeof *attypes, timecnt, &timecnt_alloc);
+ attypes[timecnt].at = starttime;
+ attypes[timecnt].dontmerge = false;
+@@ -3361,7 +3382,7 @@ is_alpha(char a)
+ }
+
+ /* If A is an uppercase character in the C locale, return its lowercase
+- * counterpart. Otherwise, return A. */
++ counterpart. Otherwise, return A. */
+ static char
+ lowerit(char a)
+ {
+@@ -3628,6 +3649,18 @@ rpytime(const struct rule *rp, zic_t wan
+ dayoff = 0;
+ m = TM_JANUARY;
+ y = EPOCH_YEAR;
++ if (y < wantedy)
++ {
++ wantedy -= y;
++ dayoff = (wantedy / YEARSPERREPEAT) * (SECSPERREPEAT / SECSPERDAY);
++ wantedy %= YEARSPERREPEAT;
++ wantedy += y;
++ }
++ else if (wantedy < 0)
++ {
++ dayoff = (wantedy / YEARSPERREPEAT) * (SECSPERREPEAT / SECSPERDAY);
++ wantedy %= YEARSPERREPEAT;
++ }
+ while (wantedy != y)
+ {
+ if (wantedy > y)
+@@ -3706,7 +3739,6 @@ will not work with pre-2004 versions of
+ if (dayoff > max_time / SECSPERDAY)
+ return max_time;
+ t = (zic_t) dayoff * SECSPERDAY;
+-
+ return tadd(t, rp->r_tod);
+ }
+