]>
Commit | Line | Data |
---|---|---|
0f113f3e | 1 | /* |
8020d79b | 2 | * Copyright 2001-2021 The OpenSSL Project Authors. All Rights Reserved. |
b8e35bd6 | 3 | * |
0e9725bc | 4 | * Licensed under the Apache License 2.0 (the "License"). You may not use |
b1322259 RS |
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 | |
b8e35bd6 RL |
8 | */ |
9 | ||
10 | #include <openssl/e_os2.h> | |
5cd6571f | 11 | #include <string.h> |
e52a3c3d | 12 | #include <openssl/crypto.h> |
b8e35bd6 | 13 | |
b8e35bd6 | 14 | struct tm *OPENSSL_gmtime(const time_t *timer, struct tm *result) |
0f113f3e MC |
15 | { |
16 | struct tm *ts = NULL; | |
b8e35bd6 | 17 | |
48ce800a RL |
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 | |
c9a41d7d | 23 | * translate to a 32-bit pointer, we must store temporarily on stack |
48ce800a RL |
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) | |
873019f2 GV |
41 | if (gmtime_r(timer, result) == NULL) |
42 | return NULL; | |
0f113f3e | 43 | ts = result; |
c35b8535 | 44 | #elif defined (OPENSSL_SYS_WINDOWS) && defined(_MSC_VER) && _MSC_VER >= 1400 && !defined(_WIN32_WCE) |
98c03302 MS |
45 | if (gmtime_s(result, timer)) |
46 | return NULL; | |
47 | ts = result; | |
9d70ac97 | 48 | #else |
0f113f3e MC |
49 | ts = gmtime(timer); |
50 | if (ts == NULL) | |
51 | return NULL; | |
52c4c51f | 52 | |
0f113f3e MC |
53 | memcpy(result, ts, sizeof(struct tm)); |
54 | ts = result; | |
b8e35bd6 | 55 | #endif |
0f113f3e MC |
56 | return ts; |
57 | } | |
87d3a0cd | 58 | |
0f113f3e MC |
59 | /* |
60 | * Take a tm structure and add an offset to it. This avoids any OS issues | |
87d3a0cd DSH |
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); | |
46a6cec6 | 69 | static int julian_adj(const struct tm *tm, int off_day, long offset_sec, |
0f113f3e | 70 | long *pday, int *psec); |
87d3a0cd DSH |
71 | |
72 | int OPENSSL_gmtime_adj(struct tm *tm, int off_day, long offset_sec) | |
0f113f3e MC |
73 | { |
74 | int time_sec, time_year, time_month, time_day; | |
75 | long time_jd; | |
76 | ||
0d4fb843 | 77 | /* Convert time and offset into Julian day and seconds */ |
0f113f3e MC |
78 | if (!julian_adj(tm, off_day, offset_sec, &time_jd, &time_sec)) |
79 | return 0; | |
1bf508c9 | 80 | |
0f113f3e | 81 | /* Convert Julian day back to date */ |
1bf508c9 | 82 | |
0f113f3e | 83 | julian_to_date(time_jd, &time_year, &time_month, &time_day); |
1bf508c9 | 84 | |
0f113f3e MC |
85 | if (time_year < 1900 || time_year > 9999) |
86 | return 0; | |
1bf508c9 | 87 | |
0f113f3e | 88 | /* Update tm structure */ |
1bf508c9 | 89 | |
0f113f3e MC |
90 | tm->tm_year = time_year - 1900; |
91 | tm->tm_mon = time_month - 1; | |
92 | tm->tm_mday = time_day; | |
1bf508c9 | 93 | |
0f113f3e MC |
94 | tm->tm_hour = time_sec / 3600; |
95 | tm->tm_min = (time_sec / 60) % 60; | |
96 | tm->tm_sec = time_sec % 60; | |
1bf508c9 | 97 | |
0f113f3e | 98 | return 1; |
1bf508c9 | 99 | |
1bf508c9 DSH |
100 | } |
101 | ||
46a6cec6 | 102 | int OPENSSL_gmtime_diff(int *pday, int *psec, |
0f113f3e MC |
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 | ||
1bf508c9 | 132 | /* Convert tm structure and offset into julian day and seconds */ |
46a6cec6 | 133 | static int julian_adj(const struct tm *tm, int off_day, long offset_sec, |
0f113f3e MC |
134 | long *pday, int *psec) |
135 | { | |
75de5436 | 136 | int offset_hms; |
137 | long offset_day, time_jd; | |
0f113f3e MC |
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 | |
87d3a0cd DSH |
178 | */ |
179 | static long date_to_julian(int y, int m, int d) | |
180 | { | |
0f113f3e MC |
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; | |
87d3a0cd DSH |
184 | } |
185 | ||
186 | static void julian_to_date(long jd, int *y, int *m, int *d) | |
0f113f3e MC |
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 | } |