Make pg_interpret_timezone_abbrev() check sp->defaulttype too.

This omission caused it to not recognize the furthest-back zone
abbreviation when working with timezone data compiled with relatively
recent zic (2018f or newer).  Older versions of zic produced a dummy
DST transition at the Big Bang, so that the oldest abbreviation could
always be found in the sp->types[] array; but newer versions don't do
that, so that we must examine defaulttype as well as the types[] array
to be sure of seeing all the abbreviations.

While this has been broken for six or so years, we'd managed not
to notice for two reasons: (1) many platforms are still using
ancient zic for compatibility reasons, so that the issue did not
manifest in builds using --with-system-tzdata; (2) the oldest
zone abbreviation is almost always "LMT", which we weren't
supporting anyway (but an upcoming patch will accept that).

While at it, update pg_next_dst_boundary() to use sp->defaulttype
as the time type for non-DST zones and times before the oldest
DST transition.  The existing code there predates upstream's
invention of the sp->defaulttype field, and its heuristic for
finding the oldest time type has now been subsumed into the
code that sets sp->defaulttype.

Possibly this should be back-patched, but I'm not currently aware
of any visible consequences of this bug in released branches.

Per report from Aleksander Alekseev and additional investigation.

Discussion: https://postgr.es/m/CAJ7c6TOATjJqvhnYsui0=CO5XFMF4dvTGH+skzB--jNhqSQu5g@mail.gmail.com

diff --git a/src/timezone/localtime.c b/src/timezone/localtime.c
index 0bc160ea7d79fb73eabfe45bc1a2d4e658857543..21516c65082ed84571c3c5458417261f0223fbc1 100644 (file)
--- a/src/timezone/localtime.c
+++ b/src/timezone/localtime.c
@@ -1624,15 +1624,8 @@ pg_next_dst_boundary(const pg_time_t *timep,
        sp = &tz->state;
        if (sp->timecnt == 0)
        {
-               /* non-DST zone, use lowest-numbered standard type */
-               i = 0;
-               while (sp->ttis[i].tt_isdst)
-                       if (++i >= sp->typecnt)
-                       {
-                               i = 0;
-                               break;
-                       }
-               ttisp = &sp->ttis[i];
+               /* non-DST zone, use the defaulttype */
+               ttisp = &sp->ttis[sp->defaulttype];
                *before_gmtoff = ttisp->tt_utoff;
                *before_isdst = ttisp->tt_isdst;
                return 0;
@@ -1692,15 +1685,8 @@ pg_next_dst_boundary(const pg_time_t *timep,
        }
        if (t < sp->ats[0])
        {
-               /* For "before", use lowest-numbered standard type */
-               i = 0;
-               while (sp->ttis[i].tt_isdst)
-                       if (++i >= sp->typecnt)
-                       {
-                               i = 0;
-                               break;
-                       }
-               ttisp = &sp->ttis[i];
+               /* For "before", use the defaulttype */
+               ttisp = &sp->ttis[sp->defaulttype];
                *before_gmtoff = ttisp->tt_utoff;
                *before_isdst = ttisp->tt_isdst;
                *boundary = sp->ats[0];
@@ -1793,7 +1779,9 @@ pg_interpret_timezone_abbrev(const char *abbrev,
         * abbreviation should get us what we want, since extrapolation would just
         * be repeating the newest or oldest meanings.
         *
-        * Use binary search to locate the first transition > cutoff time.
+        * Use binary search to locate the first transition > cutoff time.  (Note
+        * that sp->timecnt could be zero, in which case this loop does nothing
+        * and only the defaulttype entry will be checked.)
         */
        {
                int                     lo = 0;
@@ -1827,7 +1815,19 @@ pg_interpret_timezone_abbrev(const char *abbrev,
        }
 
        /*
-        * Not there, so scan forwards to find the first one after.
+        * Not found yet; check the defaulttype, which is notionally the era
+        * before any of the entries in sp->types[].
+        */
+       ttisp = &sp->ttis[sp->defaulttype];
+       if (ttisp->tt_desigidx == abbrind)
+       {
+               *gmtoff = ttisp->tt_utoff;
+               *isdst = ttisp->tt_isdst;
+               return true;
+       }
+
+       /*
+        * Not there, so scan forwards to find the first one after the cutoff.
         */
        for (i = cutoff; i < sp->timecnt; i++)
        {