crypto/o_time.c

   1 /*
   2  * Copyright 2001-2016 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the OpenSSL license (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 #include <openssl/e_os2.h>
  11 #include <string.h>
  12 #include <openssl/crypto.h>
  13
  14 struct tm *OPENSSL_gmtime(const time_t *timer, struct tm *result)
  15 {
  16     struct tm *ts = NULL;
  17
  18 #if defined(OPENSSL_THREADS) && defined(OPENSSL_SYS_VMS)
  19     {
  20         /*
  21          * On VMS, gmtime_r() takes a 32-bit pointer as second argument.
  22          * Since we can't know that |result| is in a space that can easily
  23          * translate to a 32-bit pointer, we must store temporarly on stack
  24          * and copy the result.  The stack is always reachable with 32-bit
  25          * pointers.
  26          */
  27 #if defined(OPENSSL_SYS_VMS) && __INITIAL_POINTER_SIZE
  28 # pragma pointer_size save
  29 # pragma pointer_size 32
  30 #endif
  31         struct tm data, *ts2 = &data;
  32 #if defined OPENSSL_SYS_VMS && __INITIAL_POINTER_SIZE
  33 # pragma pointer_size restore
  34 #endif
  35         if (gmtime_r(timer, ts2) == NULL)
  36             return NULL;
  37         memcpy(result, ts2, sizeof(struct tm));
  38         ts = result;
  39     }
  40 #elif defined(OPENSSL_THREADS) && !defined(OPENSSL_SYS_WIN32) && !defined(OPENSSL_SYS_MACOSX)
  41     if (gmtime_r(timer, result) == NULL)
  42         return NULL;
  43     ts = result;
  44 #else
  45     ts = gmtime(timer);
  46     if (ts == NULL)
  47         return NULL;
  48
  49     memcpy(result, ts, sizeof(struct tm));
  50     ts = result;
  51 #endif
  52     return ts;
  53 }
  54
  55 /*
  56  * Take a tm structure and add an offset to it. This avoids any OS issues
  57  * with restricted date types and overflows which cause the year 2038
  58  * problem.
  59  */
  60
  61 #define SECS_PER_DAY (24 * 60 * 60)
  62
  63 static long date_to_julian(int y, int m, int d);
  64 static void julian_to_date(long jd, int *y, int *m, int *d);
  65 static int julian_adj(const struct tm *tm, int off_day, long offset_sec,
  66                       long *pday, int *psec);
  67
  68 int OPENSSL_gmtime_adj(struct tm *tm, int off_day, long offset_sec)
  69 {
  70     int time_sec, time_year, time_month, time_day;
  71     long time_jd;
  72
  73     /* Convert time and offset into Julian day and seconds */
  74     if (!julian_adj(tm, off_day, offset_sec, &time_jd, &time_sec))
  75         return 0;
  76
  77     /* Convert Julian day back to date */
  78
  79     julian_to_date(time_jd, &time_year, &time_month, &time_day);
  80
  81     if (time_year < 1900 || time_year > 9999)
  82         return 0;
  83
  84     /* Update tm structure */
  85
  86     tm->tm_year = time_year - 1900;
  87     tm->tm_mon = time_month - 1;
  88     tm->tm_mday = time_day;
  89
  90     tm->tm_hour = time_sec / 3600;
  91     tm->tm_min = (time_sec / 60) % 60;
  92     tm->tm_sec = time_sec % 60;
  93
  94     return 1;
  95
  96 }
  97
  98 int OPENSSL_gmtime_diff(int *pday, int *psec,
  99                         const struct tm *from, const struct tm *to)
 100 {
 101     int from_sec, to_sec, diff_sec;
 102     long from_jd, to_jd, diff_day;
 103     if (!julian_adj(from, 0, 0, &from_jd, &from_sec))
 104         return 0;
 105     if (!julian_adj(to, 0, 0, &to_jd, &to_sec))
 106         return 0;
 107     diff_day = to_jd - from_jd;
 108     diff_sec = to_sec - from_sec;
 109     /* Adjust differences so both positive or both negative */
 110     if (diff_day > 0 && diff_sec < 0) {
 111         diff_day--;
 112         diff_sec += SECS_PER_DAY;
 113     }
 114     if (diff_day < 0 && diff_sec > 0) {
 115         diff_day++;
 116         diff_sec -= SECS_PER_DAY;
 117     }
 118
 119     if (pday)
 120         *pday = (int)diff_day;
 121     if (psec)
 122         *psec = diff_sec;
 123
 124     return 1;
 125
 126 }
 127
 128 /* Convert tm structure and offset into julian day and seconds */
 129 static int julian_adj(const struct tm *tm, int off_day, long offset_sec,
 130                       long *pday, int *psec)
 131 {
 132     int offset_hms, offset_day;
 133     long time_jd;
 134     int time_year, time_month, time_day;
 135     /* split offset into days and day seconds */
 136     offset_day = offset_sec / SECS_PER_DAY;
 137     /* Avoid sign issues with % operator */
 138     offset_hms = offset_sec - (offset_day * SECS_PER_DAY);
 139     offset_day += off_day;
 140     /* Add current time seconds to offset */
 141     offset_hms += tm->tm_hour * 3600 + tm->tm_min * 60 + tm->tm_sec;
 142     /* Adjust day seconds if overflow */
 143     if (offset_hms >= SECS_PER_DAY) {
 144         offset_day++;
 145         offset_hms -= SECS_PER_DAY;
 146     } else if (offset_hms < 0) {
 147         offset_day--;
 148         offset_hms += SECS_PER_DAY;
 149     }
 150
 151     /*
 152      * Convert date of time structure into a Julian day number.
 153      */
 154
 155     time_year = tm->tm_year + 1900;
 156     time_month = tm->tm_mon + 1;
 157     time_day = tm->tm_mday;
 158
 159     time_jd = date_to_julian(time_year, time_month, time_day);
 160
 161     /* Work out Julian day of new date */
 162     time_jd += offset_day;
 163
 164     if (time_jd < 0)
 165         return 0;
 166
 167     *pday = time_jd;
 168     *psec = offset_hms;
 169     return 1;
 170 }
 171
 172 /*
 173  * Convert date to and from julian day Uses Fliegel & Van Flandern algorithm
 174  */
 175 static long date_to_julian(int y, int m, int d)
 176 {
 177     return (1461 * (y + 4800 + (m - 14) / 12)) / 4 +
 178         (367 * (m - 2 - 12 * ((m - 14) / 12))) / 12 -
 179         (3 * ((y + 4900 + (m - 14) / 12) / 100)) / 4 + d - 32075;
 180 }
 181
 182 static void julian_to_date(long jd, int *y, int *m, int *d)
 183 {
 184     long L = jd + 68569;
 185     long n = (4 * L) / 146097;
 186     long i, j;
 187
 188     L = L - (146097 * n + 3) / 4;
 189     i = (4000 * (L + 1)) / 1461001;
 190     L = L - (1461 * i) / 4 + 31;
 191     j = (80 * L) / 2447;
 192     *d = L - (2447 * j) / 80;
 193     L = j / 11;
 194     *m = j + 2 - (12 * L);
 195     *y = 100 * (n - 49) + i + L;
 196 }