use timegm from musl

1 files changed, 191 insertions, 60 deletions

diff --git a/crypto/compat/timegm.c b/crypto/compat/timegm.c
index 2007140..81286bd 100644
--- a/crypto/compat/timegm.c
+++ b/crypto/compat/timegm.c
@@ -1,71 +1,202 @@
 /*
- * timegm shims based on example code from in the glibc timegm manpage.
+ * ----------------------------------------------------------------------
+ * Copyright © 2005-2014 Rich Felker, et al.
  *
- * These should be replaced with lockless versions that do not require
- * modifying global state.
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * ----------------------------------------------------------------------
  */
 
+#include <errno.h>
+#include <limits.h>
 #include <time.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-
-#ifdef _WIN32
-#include <windows.h>
-time_t
-timegm(struct tm *tm)
+
+/* 2000-03-01 (mod 400 year, immediately after feb29 */
+#define LEAPOCH (946684800LL + 86400*(31+29))
+
+#define DAYS_PER_400Y (365*400 + 97)
+#define DAYS_PER_100Y (365*100 + 24)
+#define DAYS_PER_4Y   (365*4   + 1)
+
+int __month_to_secs(int month, int is_leap)
 {
-        time_t ret;
-        char *tz, *buf;
-        static volatile HANDLE mtx = NULL;
-
-        if (!mtx) {
-                HANDLE p = CreateMutex(NULL, FALSE, NULL);
-                if (InterlockedCompareExchangePointer(
-                    (void **)&mtx, (void *)p, NULL))
-                        CloseHandle(p);
+        static const int secs_through_month[] = {
+                0, 31*86400, 59*86400, 90*86400,
+                120*86400, 151*86400, 181*86400, 212*86400,
+                243*86400, 273*86400, 304*86400, 334*86400 };
+        int t = secs_through_month[month];
+        if (is_leap && month >= 2) t+=86400;
+        return t;
+}
+
+long long __year_to_secs(long long year, int *is_leap)
+{
+        if (year-2ULL <= 136) {
+                int y = year;
+                int leaps = (y-68)>>2;
+                if (!((y-68)&3)) {
+                        leaps--;
+                        if (is_leap) *is_leap = 1;
+                } else if (is_leap) *is_leap = 0;
+                return 31536000*(y-70) + 86400*leaps;
+        }
+
+        int cycles, centuries, leaps, rem;
+
+        if (!is_leap) is_leap = &(int){0};
+        cycles = (year-100) / 400;
+        rem = (year-100) % 400;
+        if (rem < 0) {
+                cycles--;
+                rem += 400;
+        }
+        if (!rem) {
+                *is_leap = 1;
+                centuries = 0;
+                leaps = 0;
+        } else {
+                if (rem >= 200) {
+                        if (rem >= 300) centuries = 3, rem -= 300;
+                        else centuries = 2, rem -= 200;
+                } else {
+                        if (rem >= 100) centuries = 1, rem -= 100;
+                        else centuries = 0;
+                }
+                if (!rem) {
+                        *is_leap = 0;
+                        leaps = 0;
+                } else {
+                        leaps = rem / 4U;
+                        rem %= 4U;
+                        *is_leap = !rem;
+                }
         }
-        WaitForSingleObject(mtx, INFINITE);
-        tz = getenv("TZ");
-        if (tz) {
-                if (asprintf(&buf, "TZ=%s", tz) == -1)
-                        buf = NULL;
+
+        leaps += 97*cycles + 24*centuries - *is_leap;
+
+        return (year-100) * 31536000LL + leaps * 86400LL + 946684800 + 86400;
+}
+
+long long __tm_to_secs(const struct tm *tm)
+{
+        int is_leap;
+        long long year = tm->tm_year;
+        int month = tm->tm_mon;
+        if (month >= 12 || month < 0) {
+                int adj = month / 12;
+                month %= 12;
+                if (month < 0) {
+                        adj--;
+                        month += 12;
+                }
+                year += adj;
         }
-        putenv("TZ=UTC");
-        tzset();
-        ret = mktime(tm);
-        if (buf) {
-                putenv(buf);
-                free(buf);
-        } else
-                putenv("TZ=");
-        tzset();
-        ReleaseMutex(mtx);
-        return ret;
+        long long t = __year_to_secs(year, &is_leap);
+        t += __month_to_secs(month, is_leap);
+        t += 86400LL * (tm->tm_mday-1);
+        t += 3600LL * tm->tm_hour;
+        t += 60LL * tm->tm_min;
+        t += tm->tm_sec;
+        return t;
 }
-#else
-#include <pthread.h>
-time_t
-timegm(struct tm *tm)
+
+int __secs_to_tm(long long t, struct tm *tm)
 {
-        time_t ret;
-        char *tz;
-        static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
-
-        pthread_mutex_lock(&mtx);
-        tz = getenv("TZ");
-        if (tz)
-                tz = strdup(tz);
-        setenv("TZ", "", 1);
-        tzset();
-        ret = mktime(tm);
-        if (tz) {
-                setenv("TZ", tz, 1);
-                free(tz);
-        } else
-                unsetenv("TZ");
-        tzset();
-        pthread_mutex_unlock(&mtx);
-        return ret;
+        long long days, secs;
+        int remdays, remsecs, remyears;
+        int qc_cycles, c_cycles, q_cycles;
+        int years, months;
+        int wday, yday, leap;
+        static const char days_in_month[] = {31,30,31,30,31,31,30,31,30,31,31,29};
+
+        /* Reject time_t values whose year would overflow int */
+        if (t < INT_MIN * 31622400LL || t > INT_MAX * 31622400LL)
+                return -1;
+
+        secs = t - LEAPOCH;
+        days = secs / 86400;
+        remsecs = secs % 86400;
+        if (remsecs < 0) {
+                remsecs += 86400;
+                days--;
+        }
+
+        wday = (3+days)%7;
+        if (wday < 0) wday += 7;
+
+        qc_cycles = days / DAYS_PER_400Y;
+        remdays = days % DAYS_PER_400Y;
+        if (remdays < 0) {
+                remdays += DAYS_PER_400Y;
+                qc_cycles--;
+        }
+
+        c_cycles = remdays / DAYS_PER_100Y;
+        if (c_cycles == 4) c_cycles--;
+        remdays -= c_cycles * DAYS_PER_100Y;
+
+        q_cycles = remdays / DAYS_PER_4Y;
+        if (q_cycles == 25) q_cycles--;
+        remdays -= q_cycles * DAYS_PER_4Y;
+
+        remyears = remdays / 365;
+        if (remyears == 4) remyears--;
+        remdays -= remyears * 365;
+
+        leap = !remyears && (q_cycles || !c_cycles);
+        yday = remdays + 31 + 28 + leap;
+        if (yday >= 365+leap) yday -= 365+leap;
+
+        years = remyears + 4*q_cycles + 100*c_cycles + 400*qc_cycles;
+
+        for (months=0; days_in_month[months] <= remdays; months++)
+                remdays -= days_in_month[months];
+
+        if (years+100 > INT_MAX || years+100 < INT_MIN)
+                return -1;
+
+        tm->tm_year = years + 100;
+        tm->tm_mon = months + 2;
+        if (tm->tm_mon >= 12) {
+                tm->tm_mon -=12;
+                tm->tm_year++;
+        }
+        tm->tm_mday = remdays + 1;
+        tm->tm_wday = wday;
+        tm->tm_yday = yday;
+
+        tm->tm_hour = remsecs / 3600;
+        tm->tm_min = remsecs / 60 % 60;
+        tm->tm_sec = remsecs % 60;
+
+        return 0;
+}
+
+time_t timegm(struct tm *tm)
+{
+        struct tm new;
+        long long t = __tm_to_secs(tm);
+        if (__secs_to_tm(t, &new) < 0) {
+                errno = EOVERFLOW;
+                return -1;
+        }
+        *tm = new;
+        tm->tm_isdst = 0;
+        return t;
 }
-#endif