xref: /freebsd/contrib/ntp/libntp/mktime.c (revision 30f31472f865ed8a733c0f4f7c6699f9aa68a5e5)
1 /*
2  * Copyright (c) 1987, 1989 Regents of the University of California.
3  * All rights reserved.
4  *
5  * This code is derived from software contributed to Berkeley by
6  * Arthur David Olson of the National Cancer Institute.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  * 3. All advertising materials mentioning features or use of this software
17  *    must display the following acknowledgement:
18  *	This product includes software developed by the University of
19  *	California, Berkeley and its contributors.
20  * 4. Neither the name of the University nor the names of its contributors
21  *    may be used to endorse or promote products derived from this software
22  *    without specific prior written permission.
23  *
24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34  * SUCH DAMAGE.  */
35 
36 /*static char *sccsid = "from: @(#)ctime.c	5.26 (Berkeley) 2/23/91";*/
37 /*static char *rcsid = "mktime.c,v 1.1.1.3 1998/11/15 19:23:34 kardel RELEASE_19990228_A";*/
38 
39 /*
40  * This implementation of mktime is lifted straight from the NetBSD (BSD 4.4)
41  * version.  I modified it slightly to divorce it from the internals of the
42  * ctime library.  Thus this version can't use details of the internal
43  * timezone state file to figure out strange unnormalized struct tm values,
44  * as might result from someone doing date math on the tm struct then passing
45  * it to mktime.
46  *
47  * It just does as well as it can at normalizing the tm input, then does a
48  * binary search of the time space using the system's localtime() function.
49  *
50  * The original binary search was defective in that it didn't consider the
51  * setting of tm_isdst when comparing tm values, causing the search to be
52  * flubbed for times near the dst/standard time changeover.  The original
53  * code seems to make up for this by grubbing through the timezone info
54  * whenever the binary search barfed.  Since I don't have that luxury in
55  * portable code, I have to take care of tm_isdst in the comparison routine.
56  * This requires knowing how many minutes offset dst is from standard time.
57  *
58  * So, if you live somewhere in the world where dst is not 60 minutes offset,
59  * and your vendor doesn't supply mktime(), you'll have to edit this variable
60  * by hand.  Sorry about that.
61  */
62 
63 #ifdef HAVE_CONFIG_H
64 #include <config.h>
65 #endif
66 
67 #ifndef DSTMINUTES
68 #define DSTMINUTES 60
69 #endif
70 
71 #define FALSE 0
72 #define TRUE 1
73 
74 /* some constants from tzfile.h */
75 #define SECSPERMIN      60
76 #define MINSPERHOUR     60
77 #define HOURSPERDAY     24
78 #define DAYSPERWEEK     7
79 #define DAYSPERNYEAR    365
80 #define DAYSPERLYEAR    366
81 #define SECSPERHOUR     (SECSPERMIN * MINSPERHOUR)
82 #define SECSPERDAY      ((long) SECSPERHOUR * HOURSPERDAY)
83 #define MONSPERYEAR     12
84 #define TM_YEAR_BASE    1900
85 #define isleap(y) ((((y) % 4) == 0 && ((y) % 100) != 0) || ((y) % 400) == 0)
86 
87 #ifdef HAVE_SYS_TYPES_H
88 # include <sys/types.h>
89 #endif
90 
91 #include <time.h>
92 
93 extern time_t	time();
94 
95 static int	mon_lengths[2][MONSPERYEAR] = {
96 	{ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
97 	{ 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
98 };
99 
100 static int	year_lengths[2] = {
101 	DAYSPERNYEAR, DAYSPERLYEAR
102 };
103 
104 /*
105 ** Adapted from code provided by Robert Elz, who writes:
106 **	The "best" way to do mktime I think is based on an idea of Bob
107 **	Kridle's (so its said...) from a long time ago. (mtxinu!kridle now).
108 **	It does a binary search of the time_t space.  Since time_t's are
109 **	just 32 bits, its a max of 32 iterations (even at 64 bits it
110 **	would still be very reasonable).
111 */
112 
113 #ifndef WRONG
114 #define WRONG	(-1)
115 #endif /* !defined WRONG */
116 
117 static void
118 normalize(
119 	int * tensptr,
120 	int * unitsptr,
121 	int	base
122 	)
123 {
124 	if (*unitsptr >= base) {
125 		*tensptr += *unitsptr / base;
126 		*unitsptr %= base;
127 	} else if (*unitsptr < 0) {
128 		--*tensptr;
129 		*unitsptr += base;
130 		if (*unitsptr < 0) {
131 			*tensptr -= 1 + (-*unitsptr) / base;
132 			*unitsptr = base - (-*unitsptr) % base;
133 		}
134 	}
135 }
136 
137 static struct tm *
138 mkdst(
139 	struct tm *	tmp
140 	)
141 {
142     /* jds */
143     static struct tm tmbuf;
144 
145     tmbuf = *tmp;
146     tmbuf.tm_isdst = 1;
147     tmbuf.tm_min += DSTMINUTES;
148     normalize(&tmbuf.tm_hour, &tmbuf.tm_min, MINSPERHOUR);
149     return &tmbuf;
150 }
151 
152 static int
153 tmcomp(
154 	register struct tm * atmp,
155 	register struct tm * btmp
156 	)
157 {
158 	register int	result;
159 
160 	/* compare down to the same day */
161 
162 	if ((result = (atmp->tm_year - btmp->tm_year)) == 0 &&
163 	    (result = (atmp->tm_mon - btmp->tm_mon)) == 0)
164 	    result = (atmp->tm_mday - btmp->tm_mday);
165 
166 	if(result != 0)
167 	    return result;
168 
169 	/* get rid of one-sided dst bias */
170 
171 	if(atmp->tm_isdst == 1 && !btmp->tm_isdst)
172 	    btmp = mkdst(btmp);
173 	else if(btmp->tm_isdst == 1 && !atmp->tm_isdst)
174 	    atmp = mkdst(atmp);
175 
176 	/* compare the rest of the way */
177 
178 	if ((result = (atmp->tm_hour - btmp->tm_hour)) == 0 &&
179 	    (result = (atmp->tm_min - btmp->tm_min)) == 0)
180 	    result = atmp->tm_sec - btmp->tm_sec;
181 	return result;
182 }
183 
184 
185 static time_t
186 time2(
187 	struct tm *	tmp,
188 	int * 		okayp
189 	)
190 {
191 	register int			dir;
192 	register int			bits;
193 	register int			i;
194 	register int			saved_seconds;
195 	time_t				t;
196 	struct tm			yourtm, mytm;
197 
198 	*okayp = FALSE;
199 	yourtm = *tmp;
200 	if (yourtm.tm_sec >= SECSPERMIN + 2 || yourtm.tm_sec < 0)
201 		normalize(&yourtm.tm_min, &yourtm.tm_sec, SECSPERMIN);
202 	normalize(&yourtm.tm_hour, &yourtm.tm_min, MINSPERHOUR);
203 	normalize(&yourtm.tm_mday, &yourtm.tm_hour, HOURSPERDAY);
204 	normalize(&yourtm.tm_year, &yourtm.tm_mon, MONSPERYEAR);
205 	while (yourtm.tm_mday <= 0) {
206 		--yourtm.tm_year;
207 		yourtm.tm_mday +=
208 			year_lengths[isleap(yourtm.tm_year + TM_YEAR_BASE)];
209 	}
210 	for ( ; ; ) {
211 		i = mon_lengths[isleap(yourtm.tm_year +
212 			TM_YEAR_BASE)][yourtm.tm_mon];
213 		if (yourtm.tm_mday <= i)
214 			break;
215 		yourtm.tm_mday -= i;
216 		if (++yourtm.tm_mon >= MONSPERYEAR) {
217 			yourtm.tm_mon = 0;
218 			++yourtm.tm_year;
219 		}
220 	}
221 	saved_seconds = yourtm.tm_sec;
222 	yourtm.tm_sec = 0;
223 	/*
224 	** Calculate the number of magnitude bits in a time_t
225 	** (this works regardless of whether time_t is
226 	** signed or unsigned, though lint complains if unsigned).
227 	*/
228 	for (bits = 0, t = 1; t > 0; ++bits, t <<= 1)
229 		;
230 	/*
231 	** If time_t is signed, then 0 is the median value,
232 	** if time_t is unsigned, then 1 << bits is median.
233 	*/
234 	t = (t < 0) ? 0 : ((time_t) 1 << bits);
235 	for ( ; ; ) {
236 	        mytm = *localtime(&t);
237 		dir = tmcomp(&mytm, &yourtm);
238 		if (dir != 0) {
239 			if (bits-- < 0)
240 				return WRONG;
241 			if (bits < 0)
242 				--t;
243 			else if (dir > 0)
244 				t -= (time_t) 1 << bits;
245 			else	t += (time_t) 1 << bits;
246 			continue;
247 		}
248 		if (yourtm.tm_isdst < 0 || mytm.tm_isdst == yourtm.tm_isdst)
249 			break;
250 
251 		return WRONG;
252 	}
253 	t += saved_seconds;
254 	*tmp = *localtime(&t);
255 	*okayp = TRUE;
256 	return t;
257 }
258 
259 static time_t
260 time1(
261 	struct tm * tmp
262 	)
263 {
264 	register time_t			t;
265 	int				okay;
266 
267 	if (tmp->tm_isdst > 1)
268 		tmp->tm_isdst = 1;
269 	t = time2(tmp, &okay);
270 	if (okay || tmp->tm_isdst < 0)
271 		return t;
272 
273 	return WRONG;
274 }
275 
276 time_t
277 mktime(
278 	struct tm * tmp
279 	)
280 {
281 	return time1(tmp);
282 }
283