PageRenderTime 64ms CodeModel.GetById 47ms app.highlight 13ms RepoModel.GetById 2ms app.codeStats 0ms

/contrib/ntp/libntp/mktime.c

https://bitbucket.org/freebsd/freebsd-head/
C | 303 lines | 190 code | 33 blank | 80 comment | 49 complexity | a97d4114ae0271994ad7c6bc7e475de4 MD5 | raw file
  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
 38/*
 39 * This implementation of mktime is lifted straight from the NetBSD (BSD 4.4)
 40 * version.  I modified it slightly to divorce it from the internals of the
 41 * ctime library.  Thus this version can't use details of the internal
 42 * timezone state file to figure out strange unnormalized struct tm values,
 43 * as might result from someone doing date math on the tm struct then passing
 44 * it to mktime.
 45 *
 46 * It just does as well as it can at normalizing the tm input, then does a
 47 * binary search of the time space using the system's localtime() function.
 48 *
 49 * The original binary search was defective in that it didn't consider the
 50 * setting of tm_isdst when comparing tm values, causing the search to be
 51 * flubbed for times near the dst/standard time changeover.  The original
 52 * code seems to make up for this by grubbing through the timezone info
 53 * whenever the binary search barfed.  Since I don't have that luxury in
 54 * portable code, I have to take care of tm_isdst in the comparison routine.
 55 * This requires knowing how many minutes offset dst is from standard time.
 56 *
 57 * So, if you live somewhere in the world where dst is not 60 minutes offset,
 58 * and your vendor doesn't supply mktime(), you'll have to edit this variable
 59 * by hand.  Sorry about that.
 60 */
 61
 62#include "ntp_machine.h"
 63
 64#if !defined(HAVE_MKTIME) || !defined(HAVE_TIMEGM)
 65
 66#ifndef DSTMINUTES
 67#define DSTMINUTES 60
 68#endif
 69
 70#define FALSE 0
 71#define TRUE 1
 72
 73/* some constants from tzfile.h */
 74#define SECSPERMIN      60
 75#define MINSPERHOUR     60
 76#define HOURSPERDAY     24
 77#define DAYSPERWEEK     7
 78#define DAYSPERNYEAR    365
 79#define DAYSPERLYEAR    366
 80#define SECSPERHOUR     (SECSPERMIN * MINSPERHOUR)
 81#define SECSPERDAY      ((long) SECSPERHOUR * HOURSPERDAY)
 82#define MONSPERYEAR     12
 83#define TM_YEAR_BASE    1900
 84#define isleap(y) ((((y) % 4) == 0 && ((y) % 100) != 0) || ((y) % 400) == 0)
 85
 86static int	mon_lengths[2][MONSPERYEAR] = {
 87	{ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
 88	{ 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
 89};
 90
 91static int	year_lengths[2] = {
 92	DAYSPERNYEAR, DAYSPERLYEAR
 93};
 94
 95/*
 96** Adapted from code provided by Robert Elz, who writes:
 97**	The "best" way to do mktime I think is based on an idea of Bob
 98**	Kridle's (so its said...) from a long time ago. (mtxinu!kridle now).
 99**	It does a binary search of the time_t space.  Since time_t's are
100**	just 32 bits, its a max of 32 iterations (even at 64 bits it
101**	would still be very reasonable).
102*/
103
104#ifndef WRONG
105#define WRONG	(-1)
106#endif /* !defined WRONG */
107
108static void
109normalize(
110	int * tensptr,
111	int * unitsptr,
112	int	base
113	)
114{
115	if (*unitsptr >= base) {
116		*tensptr += *unitsptr / base;
117		*unitsptr %= base;
118	} else if (*unitsptr < 0) {
119		--*tensptr;
120		*unitsptr += base;
121		if (*unitsptr < 0) {
122			*tensptr -= 1 + (-*unitsptr) / base;
123			*unitsptr = base - (-*unitsptr) % base;
124		}
125	}
126}
127
128static struct tm *
129mkdst(
130	struct tm *	tmp
131	)
132{
133    /* jds */
134    static struct tm tmbuf;
135
136    tmbuf = *tmp;
137    tmbuf.tm_isdst = 1;
138    tmbuf.tm_min += DSTMINUTES;
139    normalize(&tmbuf.tm_hour, &tmbuf.tm_min, MINSPERHOUR);
140    return &tmbuf;
141}
142
143static int
144tmcomp(
145	register struct tm * atmp,
146	register struct tm * btmp
147	)
148{
149	register int	result;
150
151	/* compare down to the same day */
152
153	if ((result = (atmp->tm_year - btmp->tm_year)) == 0 &&
154	    (result = (atmp->tm_mon - btmp->tm_mon)) == 0)
155	    result = (atmp->tm_mday - btmp->tm_mday);
156
157	if(result != 0)
158	    return result;
159
160	/* get rid of one-sided dst bias */
161
162	if(atmp->tm_isdst == 1 && !btmp->tm_isdst)
163	    btmp = mkdst(btmp);
164	else if(btmp->tm_isdst == 1 && !atmp->tm_isdst)
165	    atmp = mkdst(atmp);
166
167	/* compare the rest of the way */
168
169	if ((result = (atmp->tm_hour - btmp->tm_hour)) == 0 &&
170	    (result = (atmp->tm_min - btmp->tm_min)) == 0)
171	    result = atmp->tm_sec - btmp->tm_sec;
172	return result;
173}
174
175
176static time_t
177time2(
178	struct tm *	tmp,
179	int * 		okayp,
180	int		usezn
181	)
182{
183	register int			dir;
184	register int			bits;
185	register int			i;
186	register int			saved_seconds;
187	time_t				t;
188	struct tm			yourtm, mytm;
189
190	*okayp = FALSE;
191	yourtm = *tmp;
192	if (yourtm.tm_sec >= SECSPERMIN + 2 || yourtm.tm_sec < 0)
193		normalize(&yourtm.tm_min, &yourtm.tm_sec, SECSPERMIN);
194	normalize(&yourtm.tm_hour, &yourtm.tm_min, MINSPERHOUR);
195	normalize(&yourtm.tm_mday, &yourtm.tm_hour, HOURSPERDAY);
196	normalize(&yourtm.tm_year, &yourtm.tm_mon, MONSPERYEAR);
197	while (yourtm.tm_mday <= 0) {
198		--yourtm.tm_year;
199		yourtm.tm_mday +=
200			year_lengths[isleap(yourtm.tm_year + TM_YEAR_BASE)];
201	}
202	for ( ; ; ) {
203		i = mon_lengths[isleap(yourtm.tm_year +
204			TM_YEAR_BASE)][yourtm.tm_mon];
205		if (yourtm.tm_mday <= i)
206			break;
207		yourtm.tm_mday -= i;
208		if (++yourtm.tm_mon >= MONSPERYEAR) {
209			yourtm.tm_mon = 0;
210			++yourtm.tm_year;
211		}
212	}
213	saved_seconds = yourtm.tm_sec;
214	yourtm.tm_sec = 0;
215	/*
216	** Calculate the number of magnitude bits in a time_t
217	** (this works regardless of whether time_t is
218	** signed or unsigned, though lint complains if unsigned).
219	*/
220	for (bits = 0, t = 1; t > 0; ++bits, t <<= 1)
221		;
222	/*
223	** If time_t is signed, then 0 is the median value,
224	** if time_t is unsigned, then 1 << bits is median.
225	*/
226	t = (t < 0) ? 0 : ((time_t) 1 << bits);
227	for ( ; ; ) {
228		if (usezn)
229	        	mytm = *localtime(&t);
230		else
231	        	mytm = *gmtime(&t);
232		dir = tmcomp(&mytm, &yourtm);
233		if (dir != 0) {
234			if (bits-- < 0)
235				return WRONG;
236			if (bits < 0)
237				--t;
238			else if (dir > 0)
239				t -= (time_t) 1 << bits;
240			else	t += (time_t) 1 << bits;
241			continue;
242		}
243		if (yourtm.tm_isdst < 0 || mytm.tm_isdst == yourtm.tm_isdst)
244			break;
245
246		return WRONG;
247	}
248	t += saved_seconds;
249	if (usezn)
250		*tmp = *localtime(&t);
251	else
252		*tmp = *gmtime(&t);
253	*okayp = TRUE;
254	return t;
255}
256#else
257int mktime_bs;
258#endif /* !HAVE_MKTIME || !HAVE_TIMEGM */
259
260#ifndef HAVE_MKTIME
261static time_t
262time1(
263	struct tm * tmp
264	)
265{
266	register time_t			t;
267	int				okay;
268
269	if (tmp->tm_isdst > 1)
270		tmp->tm_isdst = 1;
271	t = time2(tmp, &okay, 1);
272	if (okay || tmp->tm_isdst < 0)
273		return t;
274
275	return WRONG;
276}
277
278time_t
279mktime(
280	struct tm * tmp
281	)
282{
283	return time1(tmp);
284}
285#endif /* !HAVE_MKTIME */
286
287#ifndef HAVE_TIMEGM
288time_t
289timegm(
290	struct tm * tmp
291	)
292{
293	register time_t			t;
294	int				okay;
295
296	tmp->tm_isdst = 0;
297	t = time2(tmp, &okay, 0);
298	if (okay || tmp->tm_isdst < 0)
299		return t;
300
301	return WRONG;
302}
303#endif /* !HAVE_TIMEGM */