1 | /* |
2 | * Copyright 2001-2018 The OpenSSL Project Authors. All Rights Reserved. |
3 | * |
4 | * Licensed under the Apache License 2.0 (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 temporarily 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 | #elif defined (OPENSSL_SYS_WINDOWS) && defined(_MSC_VER) && _MSC_VER >= 1400 |
45 | if (gmtime_s(result, timer)) |
46 | return NULL; |
47 | ts = result; |
48 | #else |
49 | ts = gmtime(timer); |
50 | if (ts == NULL) |
51 | return NULL; |
52 | |
53 | memcpy(result, ts, sizeof(struct tm)); |
54 | ts = result; |
55 | #endif |
56 | return ts; |
57 | } |
58 | |
59 | /* |
60 | * Take a tm structure and add an offset to it. This avoids any OS issues |
61 | * with restricted date types and overflows which cause the year 2038 |
62 | * problem. |
63 | */ |
64 | |
65 | #define SECS_PER_DAY (24 * 60 * 60) |
66 | |
67 | static long date_to_julian(int y, int m, int d); |
68 | static void julian_to_date(long jd, int *y, int *m, int *d); |
69 | static int julian_adj(const struct tm *tm, int off_day, long offset_sec, |
70 | long *pday, int *psec); |
71 | |
72 | int OPENSSL_gmtime_adj(struct tm *tm, int off_day, long offset_sec) |
73 | { |
74 | int time_sec, time_year, time_month, time_day; |
75 | long time_jd; |
76 | |
77 | /* Convert time and offset into Julian day and seconds */ |
78 | if (!julian_adj(tm, off_day, offset_sec, &time_jd, &time_sec)) |
79 | return 0; |
80 | |
81 | /* Convert Julian day back to date */ |
82 | |
83 | julian_to_date(time_jd, &time_year, &time_month, &time_day); |
84 | |
85 | if (time_year < 1900 || time_year > 9999) |
86 | return 0; |
87 | |
88 | /* Update tm structure */ |
89 | |
90 | tm->tm_year = time_year - 1900; |
91 | tm->tm_mon = time_month - 1; |
92 | tm->tm_mday = time_day; |
93 | |
94 | tm->tm_hour = time_sec / 3600; |
95 | tm->tm_min = (time_sec / 60) % 60; |
96 | tm->tm_sec = time_sec % 60; |
97 | |
98 | return 1; |
99 | |
100 | } |
101 | |
102 | int OPENSSL_gmtime_diff(int *pday, int *psec, |
103 | const struct tm *from, const struct tm *to) |
104 | { |
105 | int from_sec, to_sec, diff_sec; |
106 | long from_jd, to_jd, diff_day; |
107 | if (!julian_adj(from, 0, 0, &from_jd, &from_sec)) |
108 | return 0; |
109 | if (!julian_adj(to, 0, 0, &to_jd, &to_sec)) |
110 | return 0; |
111 | diff_day = to_jd - from_jd; |
112 | diff_sec = to_sec - from_sec; |
113 | /* Adjust differences so both positive or both negative */ |
114 | if (diff_day > 0 && diff_sec < 0) { |
115 | diff_day--; |
116 | diff_sec += SECS_PER_DAY; |
117 | } |
118 | if (diff_day < 0 && diff_sec > 0) { |
119 | diff_day++; |
120 | diff_sec -= SECS_PER_DAY; |
121 | } |
122 | |
123 | if (pday) |
124 | *pday = (int)diff_day; |
125 | if (psec) |
126 | *psec = diff_sec; |
127 | |
128 | return 1; |
129 | |
130 | } |
131 | |
132 | /* Convert tm structure and offset into julian day and seconds */ |
133 | static int julian_adj(const struct tm *tm, int off_day, long offset_sec, |
134 | long *pday, int *psec) |
135 | { |
136 | int offset_hms, offset_day; |
137 | long time_jd; |
138 | int time_year, time_month, time_day; |
139 | /* split offset into days and day seconds */ |
140 | offset_day = offset_sec / SECS_PER_DAY; |
141 | /* Avoid sign issues with % operator */ |
142 | offset_hms = offset_sec - (offset_day * SECS_PER_DAY); |
143 | offset_day += off_day; |
144 | /* Add current time seconds to offset */ |
145 | offset_hms += tm->tm_hour * 3600 + tm->tm_min * 60 + tm->tm_sec; |
146 | /* Adjust day seconds if overflow */ |
147 | if (offset_hms >= SECS_PER_DAY) { |
148 | offset_day++; |
149 | offset_hms -= SECS_PER_DAY; |
150 | } else if (offset_hms < 0) { |
151 | offset_day--; |
152 | offset_hms += SECS_PER_DAY; |
153 | } |
154 | |
155 | /* |
156 | * Convert date of time structure into a Julian day number. |
157 | */ |
158 | |
159 | time_year = tm->tm_year + 1900; |
160 | time_month = tm->tm_mon + 1; |
161 | time_day = tm->tm_mday; |
162 | |
163 | time_jd = date_to_julian(time_year, time_month, time_day); |
164 | |
165 | /* Work out Julian day of new date */ |
166 | time_jd += offset_day; |
167 | |
168 | if (time_jd < 0) |
169 | return 0; |
170 | |
171 | *pday = time_jd; |
172 | *psec = offset_hms; |
173 | return 1; |
174 | } |
175 | |
176 | /* |
177 | * Convert date to and from julian day Uses Fliegel & Van Flandern algorithm |
178 | */ |
179 | static long date_to_julian(int y, int m, int d) |
180 | { |
181 | return (1461 * (y + 4800 + (m - 14) / 12)) / 4 + |
182 | (367 * (m - 2 - 12 * ((m - 14) / 12))) / 12 - |
183 | (3 * ((y + 4900 + (m - 14) / 12) / 100)) / 4 + d - 32075; |
184 | } |
185 | |
186 | static void julian_to_date(long jd, int *y, int *m, int *d) |
187 | { |
188 | long L = jd + 68569; |
189 | long n = (4 * L) / 146097; |
190 | long i, j; |
191 | |
192 | L = L - (146097 * n + 3) / 4; |
193 | i = (4000 * (L + 1)) / 1461001; |
194 | L = L - (1461 * i) / 4 + 31; |
195 | j = (80 * L) / 2447; |
196 | *d = L - (2447 * j) / 80; |
197 | L = j / 11; |
198 | *m = j + 2 - (12 * L); |
199 | *y = 100 * (n - 49) + i + L; |
200 | } |
201 | |