Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

source: branches/samba-3.3.x/source/lib/time.c@ 206

Visit:

Last change on this file since 206 was 206, checked in by Herwig Bauernfeind, 16 years ago
Import Samba 3.3 branch at 3.0.0 level (psmedley's port)
File size: 36.8 KB

Line
1	/*
2	Unix SMB/CIFS implementation.
3	time handling functions
4
5	Copyright (C) Andrew Tridgell 1992-2004
6	Copyright (C) Stefan (metze) Metzmacher 2002
7	Copyright (C) Jeremy Allison 2007
8
9	This program is free software; you can redistribute it and/or modify
10	it under the terms of the GNU General Public License as published by
11	the Free Software Foundation; either version 3 of the License, or
12	(at your option) any later version.
13
14	This program is distributed in the hope that it will be useful,
15	but WITHOUT ANY WARRANTY; without even the implied warranty of
16	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17	GNU General Public License for more details.
18
19	You should have received a copy of the GNU General Public License
20	along with this program. If not, see <http://www.gnu.org/licenses/>.
21	*/
22
23	#include "includes.h"
24
25	/**
26	* @file
27	* @brief time handling functions
28	*/
29
30
31	#ifndef TIME_T_MIN
32	#define TIME_T_MIN ((time_t)0 < (time_t) -1 ? (time_t) 0 \
33	: ~ (time_t) 0 << (sizeof (time_t) * CHAR_BIT - 1))
34	#endif
35	#ifndef TIME_T_MAX
36	#define TIME_T_MAX (~ (time_t) 0 - TIME_T_MIN)
37	#endif
38
39	#define NTTIME_INFINITY (NTTIME)0x8000000000000000LL
40
41	/***************************************************************************
42	External access to time_t_min and time_t_max.
43	****************************************************************************/
44
45	time_t get_time_t_max(void)
46	{
47	return TIME_T_MAX;
48	}
49
50	/***************************************************************************
51	A gettimeofday wrapper.
52	****************************************************************************/
53
54	void GetTimeOfDay(struct timeval *tval)
55	{
56	#ifdef HAVE_GETTIMEOFDAY_TZ
57	gettimeofday(tval,NULL);
58	#else
59	gettimeofday(tval);
60	#endif
61	}
62
63	#if (SIZEOF_LONG == 8)
64	#define TIME_FIXUP_CONSTANT_INT 11644473600L
65	#elif (SIZEOF_LONG_LONG == 8)
66	#define TIME_FIXUP_CONSTANT_INT 11644473600LL
67	#endif
68
69	/****************************************************************************
70	Interpret an 8 byte "filetime" structure to a time_t
71	It's originally in "100ns units since jan 1st 1601"
72
73	An 8 byte value of 0xffffffffffffffff will be returned as a timespec of
74
75	tv_sec = 0
76	tv_nsec = 0;
77
78	Returns GMT.
79	****************************************************************************/
80
81	time_t nt_time_to_unix(NTTIME nt)
82	{
83	return convert_timespec_to_time_t(nt_time_to_unix_timespec(&nt));
84	}
85
86	/****************************************************************************
87	Put a 8 byte filetime from a time_t. Uses GMT.
88	****************************************************************************/
89
90	void unix_to_nt_time(NTTIME *nt, time_t t)
91	{
92	uint64_t t2;
93
94	if (t == (time_t)-1) {
95	*nt = (NTTIME)-1LL;
96	return;
97	}
98
99	if (t == TIME_T_MAX) {
100	*nt = 0x7fffffffffffffffLL;
101	return;
102	}
103
104	if (t == 0) {
105	*nt = 0;
106	return;
107	}
108
109	t2 = t;
110	t2 += TIME_FIXUP_CONSTANT_INT;
111	t2 = 10001000*10;
112
113	*nt = t2;
114	}
115
116	/****************************************************************************
117	Check if it's a null unix time.
118	****************************************************************************/
119
120	bool null_time(time_t t)
121	{
122	return t == 0 \|\|
123	t == (time_t)0xFFFFFFFF \|\|
124	t == (time_t)-1;
125	}
126
127	/****************************************************************************
128	Check if it's a null NTTIME.
129	****************************************************************************/
130
131	bool null_nttime(NTTIME t)
132	{
133	return t == 0 \|\| t == (NTTIME)-1;
134	}
135
136	/****************************************************************************
137	Check if it's a null timespec.
138	****************************************************************************/
139
140	bool null_timespec(struct timespec ts)
141	{
142	return ts.tv_sec == 0 \|\|
143	ts.tv_sec == (time_t)0xFFFFFFFF \|\|
144	ts.tv_sec == (time_t)-1;
145	}
146
147	/*******************************************************************
148	create a 16 bit dos packed date
149	********************************************************************/
150	static uint16_t make_dos_date1(struct tm *t)
151	{
152	uint16_t ret=0;
153	ret = (((unsigned int)(t->tm_mon+1)) >> 3) \| ((t->tm_year-80) << 1);
154	ret = ((ret&0xFF)<<8) \| (t->tm_mday \| (((t->tm_mon+1) & 0x7) << 5));
155	return ret;
156	}
157
158	/*******************************************************************
159	create a 16 bit dos packed time
160	********************************************************************/
161	static uint16_t make_dos_time1(struct tm *t)
162	{
163	uint16_t ret=0;
164	ret = ((((unsigned int)t->tm_min >> 3)&0x7) \| (((unsigned int)t->tm_hour) << 3));
165	ret = ((ret&0xFF)<<8) \| ((t->tm_sec/2) \| ((t->tm_min & 0x7) << 5));
166	return ret;
167	}
168
169	/*******************************************************************
170	create a 32 bit dos packed date/time from some parameters
171	This takes a GMT time and returns a packed localtime structure
172	********************************************************************/
173	static uint32_t make_dos_date(time_t unixdate, int zone_offset)
174	{
175	struct tm *t;
176	uint32_t ret=0;
177
178	if (unixdate == 0) {
179	return 0;
180	}
181
182	unixdate -= zone_offset;
183
184	t = gmtime(&unixdate);
185	if (!t) {
186	return 0xFFFFFFFF;
187	}
188
189	ret = make_dos_date1(t);
190	ret = ((ret&0xFFFF)<<16) \| make_dos_time1(t);
191
192	return ret;
193	}
194
195	/**
196	put a dos date into a buffer (time/date format)
197	This takes GMT time and puts local time in the buffer
198	**/
199	void push_dos_date(uint8_t *buf, int offset, time_t unixdate, int zone_offset)
200	{
201	uint32_t x = make_dos_date(unixdate, zone_offset);
202	SIVAL(buf,offset,x);
203	}
204
205	/**
206	put a dos date into a buffer (date/time format)
207	This takes GMT time and puts local time in the buffer
208	**/
209	void push_dos_date2(uint8_t *buf,int offset,time_t unixdate, int zone_offset)
210	{
211	uint32_t x;
212	x = make_dos_date(unixdate, zone_offset);
213	x = ((x&0xFFFF)<<16) \| ((x&0xFFFF0000)>>16);
214	SIVAL(buf,offset,x);
215	}
216
217	/**
218	put a dos 32 bit "unix like" date into a buffer. This routine takes
219	GMT and converts it to LOCAL time before putting it (most SMBs assume
220	localtime for this sort of date)
221	**/
222	void push_dos_date3(uint8_t *buf,int offset,time_t unixdate, int zone_offset)
223	{
224	if (!null_time(unixdate)) {
225	unixdate -= zone_offset;
226	}
227	SIVAL(buf,offset,unixdate);
228	}
229
230	/*******************************************************************
231	interpret a 32 bit dos packed date/time to some parameters
232	********************************************************************/
233	static void interpret_dos_date(uint32_t date,int year,int month,int day,int hour,int minute,int second)
234	{
235	uint32_t p0,p1,p2,p3;
236
237	p0=date&0xFF; p1=((date&0xFF00)>>8)&0xFF;
238	p2=((date&0xFF0000)>>16)&0xFF; p3=((date&0xFF000000)>>24)&0xFF;
239
240	second = 2(p0 & 0x1F);
241	*minute = ((p0>>5)&0xFF) + ((p1&0x7)<<3);
242	*hour = (p1>>3)&0xFF;
243	*day = (p2&0x1F);
244	*month = ((p2>>5)&0xFF) + ((p3&0x1)<<3) - 1;
245	*year = ((p3>>1)&0xFF) + 80;
246	}
247
248	/**
249	create a unix date (int GMT) from a dos date (which is actually in
250	localtime)
251	**/
252	time_t pull_dos_date(const uint8_t *date_ptr, int zone_offset)
253	{
254	uint32_t dos_date=0;
255	struct tm t;
256	time_t ret;
257
258	dos_date = IVAL(date_ptr,0);
259
260	if (dos_date == 0) return (time_t)0;
261
262	interpret_dos_date(dos_date,&t.tm_year,&t.tm_mon,
263	&t.tm_mday,&t.tm_hour,&t.tm_min,&t.tm_sec);
264	t.tm_isdst = -1;
265
266	ret = timegm(&t);
267
268	ret += zone_offset;
269
270	return ret;
271	}
272
273	/**
274	like make_unix_date() but the words are reversed
275	**/
276	time_t pull_dos_date2(const uint8_t *date_ptr, int zone_offset)
277	{
278	uint32_t x,x2;
279
280	x = IVAL(date_ptr,0);
281	x2 = ((x&0xFFFF)<<16) \| ((x&0xFFFF0000)>>16);
282	SIVAL(&x,0,x2);
283
284	return pull_dos_date((const uint8_t *)&x, zone_offset);
285	}
286
287	/**
288	create a unix GMT date from a dos date in 32 bit "unix like" format
289	these generally arrive as localtimes, with corresponding DST
290	**/
291	time_t pull_dos_date3(const uint8_t *date_ptr, int zone_offset)
292	{
293	time_t t = (time_t)IVAL(date_ptr,0);
294	if (!null_time(t)) {
295	t += zone_offset;
296	}
297	return t;
298	}
299
300	/***************************************************************************
301	Return a HTTP/1.0 time string.
302	***************************************************************************/
303
304	char *http_timestring(time_t t)
305	{
306	fstring buf;
307	struct tm *tm = localtime(&t);
308
309	if (t == TIME_T_MAX) {
310	fstrcpy(buf, "never");
311	} else if (!tm) {
312	fstr_sprintf(buf, "%ld seconds since the Epoch", (long)t);
313	} else {
314	#ifndef HAVE_STRFTIME
315	const char *asct = asctime(tm);
316	fstrcpy(buf, asct ? asct : "unknown");
317	}
318	if(buf[strlen(buf)-1] == '\n') {
319	buf[strlen(buf)-1] = 0;
320	#else /* !HAVE_STRFTIME */
321	strftime(buf, sizeof(buf)-1, "%a, %d %b %Y %H:%M:%S %Z", tm);
322	#endif /* !HAVE_STRFTIME */
323	}
324	return talloc_strdup(talloc_tos(), buf);
325	}
326
327
328	/**
329	Return the date and time as a string
330	**/
331	char timestring(TALLOC_CTX mem_ctx, time_t t)
332	{
333	char *TimeBuf;
334	char tempTime[80];
335	struct tm *tm;
336
337	tm = localtime(&t);
338	if (!tm) {
339	return talloc_asprintf(mem_ctx,
340	"%ld seconds since the Epoch",
341	(long)t);
342	}
343
344	#ifdef HAVE_STRFTIME
345	/* some versions of gcc complain about using %c. This is a bug
346	in the gcc warning, not a bug in this code. See a recent
347	strftime() manual page for details.
348	*/
349	strftime(tempTime,sizeof(tempTime)-1,"%c %Z",tm);
350	TimeBuf = talloc_strdup(mem_ctx, tempTime);
351	#else
352	TimeBuf = talloc_strdup(mem_ctx, asctime(tm));
353	#endif
354
355	return TimeBuf;
356	}
357
358	/**
359	return a talloced string representing a NTTIME for human consumption
360	*/
361	const char nt_time_string(TALLOC_CTX mem_ctx, NTTIME nt)
362	{
363	time_t t;
364	if (nt == 0) {
365	return "NTTIME(0)";
366	}
367	t = nt_time_to_unix(nt);
368	return timestring(mem_ctx, t);
369	}
370
371
372	/**
373	parse a nttime as a large integer in a string and return a NTTIME
374	*/
375	NTTIME nttime_from_string(const char *s)
376	{
377	return strtoull(s, NULL, 0);
378	}
379
380	/**
381	return (tv1 - tv2) in microseconds
382	*/
383	int64_t usec_time_diff(struct timeval tv1, struct timeval tv2)
384	{
385	int64_t sec_diff = tv1->tv_sec - tv2->tv_sec;
386	return (sec_diff * 1000000) + (int64_t)(tv1->tv_usec - tv2->tv_usec);
387	}
388
389
390	/**
391	return a zero timeval
392	*/
393	struct timeval timeval_zero(void)
394	{
395	struct timeval tv;
396	tv.tv_sec = 0;
397	tv.tv_usec = 0;
398	return tv;
399	}
400
401	/**
402	return True if a timeval is zero
403	*/
404	bool timeval_is_zero(const struct timeval *tv)
405	{
406	return tv->tv_sec == 0 && tv->tv_usec == 0;
407	}
408
409	/**
410	return a timeval for the current time
411	*/
412	struct timeval timeval_current(void)
413	{
414	struct timeval tv;
415	GetTimeOfDay(&tv);
416	return tv;
417	}
418
419	/**
420	return a timeval struct with the given elements
421	*/
422	struct timeval timeval_set(uint32_t secs, uint32_t usecs)
423	{
424	struct timeval tv;
425	tv.tv_sec = secs;
426	tv.tv_usec = usecs;
427	return tv;
428	}
429
430
431	/**
432	return a timeval ofs microseconds after tv
433	*/
434	struct timeval timeval_add(const struct timeval *tv,
435	uint32_t secs, uint32_t usecs)
436	{
437	struct timeval tv2 = *tv;
438	const unsigned int million = 1000000;
439	tv2.tv_sec += secs;
440	tv2.tv_usec += usecs;
441	tv2.tv_sec += tv2.tv_usec / million;
442	tv2.tv_usec = tv2.tv_usec % million;
443	return tv2;
444	}
445
446	/**
447	return the sum of two timeval structures
448	*/
449	struct timeval timeval_sum(const struct timeval *tv1,
450	const struct timeval *tv2)
451	{
452	return timeval_add(tv1, tv2->tv_sec, tv2->tv_usec);
453	}
454
455	/**
456	return a timeval secs/usecs into the future
457	*/
458	struct timeval timeval_current_ofs(uint32_t secs, uint32_t usecs)
459	{
460	struct timeval tv = timeval_current();
461	return timeval_add(&tv, secs, usecs);
462	}
463
464	/**
465	compare two timeval structures.
466	Return -1 if tv1 < tv2
467	Return 0 if tv1 == tv2
468	Return 1 if tv1 > tv2
469	*/
470	int timeval_compare(const struct timeval tv1, const struct timeval tv2)
471	{
472	if (tv1->tv_sec > tv2->tv_sec) return 1;
473	if (tv1->tv_sec < tv2->tv_sec) return -1;
474	if (tv1->tv_usec > tv2->tv_usec) return 1;
475	if (tv1->tv_usec < tv2->tv_usec) return -1;
476	return 0;
477	}
478
479	/**
480	return True if a timer is in the past
481	*/
482	bool timeval_expired(const struct timeval *tv)
483	{
484	struct timeval tv2 = timeval_current();
485	if (tv2.tv_sec > tv->tv_sec) return True;
486	if (tv2.tv_sec < tv->tv_sec) return False;
487	return (tv2.tv_usec >= tv->tv_usec);
488	}
489
490	/**
491	return the number of seconds elapsed between two times
492	*/
493	double timeval_elapsed2(const struct timeval tv1, const struct timeval tv2)
494	{
495	return (tv2->tv_sec - tv1->tv_sec) +
496	(tv2->tv_usec - tv1->tv_usec)*1.0e-6;
497	}
498
499	/**
500	return the number of seconds elapsed since a given time
501	*/
502	double timeval_elapsed(const struct timeval *tv)
503	{
504	struct timeval tv2 = timeval_current();
505	return timeval_elapsed2(tv, &tv2);
506	}
507
508	/**
509	return the lesser of two timevals
510	*/
511	struct timeval timeval_min(const struct timeval *tv1,
512	const struct timeval *tv2)
513	{
514	if (tv1->tv_sec < tv2->tv_sec) return *tv1;
515	if (tv1->tv_sec > tv2->tv_sec) return *tv2;
516	if (tv1->tv_usec < tv2->tv_usec) return *tv1;
517	return *tv2;
518	}
519
520	/**
521	return the greater of two timevals
522	*/
523	struct timeval timeval_max(const struct timeval *tv1,
524	const struct timeval *tv2)
525	{
526	if (tv1->tv_sec > tv2->tv_sec) return *tv1;
527	if (tv1->tv_sec < tv2->tv_sec) return *tv2;
528	if (tv1->tv_usec > tv2->tv_usec) return *tv1;
529	return *tv2;
530	}
531
532	/**
533	return the difference between two timevals as a timeval
534	if tv1 comes after tv2, then return a zero timeval
535	(this is tv2 - tv1)
536	*/
537	struct timeval timeval_until(const struct timeval *tv1,
538	const struct timeval *tv2)
539	{
540	struct timeval t;
541	if (timeval_compare(tv1, tv2) >= 0) {
542	return timeval_zero();
543	}
544	t.tv_sec = tv2->tv_sec - tv1->tv_sec;
545	if (tv1->tv_usec > tv2->tv_usec) {
546	t.tv_sec--;
547	t.tv_usec = 1000000 - (tv1->tv_usec - tv2->tv_usec);
548	} else {
549	t.tv_usec = tv2->tv_usec - tv1->tv_usec;
550	}
551	return t;
552	}
553
554
555	/**
556	convert a timeval to a NTTIME
557	*/
558	NTTIME timeval_to_nttime(const struct timeval *tv)
559	{
560	return 10*(tv->tv_usec +
561	((TIME_FIXUP_CONSTANT_INT + (uint64_t)tv->tv_sec) * 1000000));
562	}
563
564	/**************************************************************
565	Handle conversions between time_t and uint32, taking care to
566	preserve the "special" values.
567	**************************************************************/
568
569	uint32 convert_time_t_to_uint32(time_t t)
570	{
571	#if (defined(SIZEOF_TIME_T) && (SIZEOF_TIME_T == 8))
572	/* time_t is 64-bit. */
573	if (t == 0x8000000000000000LL) {
574	return 0x80000000;
575	} else if (t == 0x7FFFFFFFFFFFFFFFLL) {
576	return 0x7FFFFFFF;
577	}
578	#endif
579	return (uint32)t;
580	}
581
582	time_t convert_uint32_to_time_t(uint32 u)
583	{
584	#if (defined(SIZEOF_TIME_T) && (SIZEOF_TIME_T == 8))
585	/* time_t is 64-bit. */
586	if (u == 0x80000000) {
587	return (time_t)0x8000000000000000LL;
588	} else if (u == 0x7FFFFFFF) {
589	return (time_t)0x7FFFFFFFFFFFFFFFLL;
590	}
591	#endif
592	return (time_t)u;
593	}
594
595	/*******************************************************************
596	Yield the difference between A and B, in seconds, ignoring leap seconds.
597	********************************************************************/
598
599	static int tm_diff(struct tm a, struct tm b)
600	{
601	int ay = a->tm_year + (1900 - 1);
602	int by = b->tm_year + (1900 - 1);
603	int intervening_leap_days =
604	(ay/4 - by/4) - (ay/100 - by/100) + (ay/400 - by/400);
605	int years = ay - by;
606	int days = 365*years + intervening_leap_days + (a->tm_yday - b->tm_yday);
607	int hours = 24*days + (a->tm_hour - b->tm_hour);
608	int minutes = 60*hours + (a->tm_min - b->tm_min);
609	int seconds = 60*minutes + (a->tm_sec - b->tm_sec);
610
611	return seconds;
612	}
613
614	int extra_time_offset=0;
615
616	/*******************************************************************
617	Return the UTC offset in seconds west of UTC, or 0 if it cannot be determined.
618	********************************************************************/
619
620	int get_time_zone(time_t t)
621	{
622	struct tm *tm = gmtime(&t);
623	struct tm tm_utc;
624	if (!tm)
625	return 0;
626	tm_utc = *tm;
627	tm = localtime(&t);
628	if (!tm)
629	return 0;
630	return tm_diff(&tm_utc,tm)+60*extra_time_offset;
631	}
632
633	/****************************************************************************
634	Check if NTTIME is 0.
635	****************************************************************************/
636
637	bool nt_time_is_zero(const NTTIME *nt)
638	{
639	return (*nt == 0);
640	}
641
642	/****************************************************************************
643	Convert ASN.1 GeneralizedTime string to unix-time.
644	Returns 0 on failure; Currently ignores timezone.
645	****************************************************************************/
646
647	time_t generalized_to_unix_time(const char *str)
648	{
649	struct tm tm;
650
651	ZERO_STRUCT(tm);
652
653	if (sscanf(str, "%4d%2d%2d%2d%2d%2d",
654	&tm.tm_year, &tm.tm_mon, &tm.tm_mday,
655	&tm.tm_hour, &tm.tm_min, &tm.tm_sec) != 6) {
656	return 0;
657	}
658	tm.tm_year -= 1900;
659	tm.tm_mon -= 1;
660
661	return timegm(&tm);
662	}
663
664	/*******************************************************************
665	Accessor function for the server time zone offset.
666	set_server_zone_offset() must have been called first.
667	******************************************************************/
668
669	static int server_zone_offset;
670
671	int get_server_zone_offset(void)
672	{
673	return server_zone_offset;
674	}
675
676	/*******************************************************************
677	Initialize the server time zone offset. Called when a client connects.
678	******************************************************************/
679
680	int set_server_zone_offset(time_t t)
681	{
682	server_zone_offset = get_time_zone(t);
683	return server_zone_offset;
684	}
685
686	/****************************************************************************
687	Return the date and time as a string
688	****************************************************************************/
689
690	char current_timestring(TALLOC_CTX ctx, bool hires)
691	{
692	fstring TimeBuf;
693	struct timeval tp;
694	time_t t;
695	struct tm *tm;
696
697	if (hires) {
698	GetTimeOfDay(&tp);
699	t = (time_t)tp.tv_sec;
700	} else {
701	t = time(NULL);
702	}
703	tm = localtime(&t);
704	if (!tm) {
705	if (hires) {
706	slprintf(TimeBuf,
707	sizeof(TimeBuf)-1,
708	"%ld.%06ld seconds since the Epoch",
709	(long)tp.tv_sec,
710	(long)tp.tv_usec);
711	} else {
712	slprintf(TimeBuf,
713	sizeof(TimeBuf)-1,
714	"%ld seconds since the Epoch",
715	(long)t);
716	}
717	} else {
718	#ifdef HAVE_STRFTIME
719	if (hires) {
720	strftime(TimeBuf,sizeof(TimeBuf)-1,"%Y/%m/%d %H:%M:%S",tm);
721	slprintf(TimeBuf+strlen(TimeBuf),
722	sizeof(TimeBuf)-1 - strlen(TimeBuf),
723	".%06ld",
724	(long)tp.tv_usec);
725	} else {
726	strftime(TimeBuf,sizeof(TimeBuf)-1,"%Y/%m/%d %H:%M:%S",tm);
727	}
728	#else
729	if (hires) {
730	const char *asct = asctime(tm);
731	slprintf(TimeBuf,
732	sizeof(TimeBuf)-1,
733	"%s.%06ld",
734	asct ? asct : "unknown",
735	(long)tp.tv_usec);
736	} else {
737	const char *asct = asctime(tm);
738	fstrcpy(TimeBuf, asct ? asct : "unknown");
739	}
740	#endif
741	}
742	return talloc_strdup(ctx, TimeBuf);
743	}
744
745
746	/*******************************************************************
747	Put a dos date into a buffer (time/date format).
748	This takes GMT time and puts local time in the buffer.
749	********************************************************************/
750
751	static void put_dos_date(char *buf,int offset,time_t unixdate, int zone_offset)
752	{
753	uint32 x = make_dos_date(unixdate, zone_offset);
754	SIVAL(buf,offset,x);
755	}
756
757	/*******************************************************************
758	Put a dos date into a buffer (date/time format).
759	This takes GMT time and puts local time in the buffer.
760	********************************************************************/
761
762	static void put_dos_date2(char *buf,int offset,time_t unixdate, int zone_offset)
763	{
764	uint32 x = make_dos_date(unixdate, zone_offset);
765	x = ((x&0xFFFF)<<16) \| ((x&0xFFFF0000)>>16);
766	SIVAL(buf,offset,x);
767	}
768
769	/*******************************************************************
770	Put a dos 32 bit "unix like" date into a buffer. This routine takes
771	GMT and converts it to LOCAL time before putting it (most SMBs assume
772	localtime for this sort of date)
773	********************************************************************/
774
775	static void put_dos_date3(char *buf,int offset,time_t unixdate, int zone_offset)
776	{
777	if (!null_mtime(unixdate)) {
778	unixdate -= zone_offset;
779	}
780	SIVAL(buf,offset,unixdate);
781	}
782
783
784	/***************************************************************************
785	Server versions of the above functions.
786	***************************************************************************/
787
788	void srv_put_dos_date(char *buf,int offset,time_t unixdate)
789	{
790	put_dos_date(buf, offset, unixdate, server_zone_offset);
791	}
792
793	void srv_put_dos_date2(char *buf,int offset, time_t unixdate)
794	{
795	put_dos_date2(buf, offset, unixdate, server_zone_offset);
796	}
797
798	void srv_put_dos_date3(char *buf,int offset,time_t unixdate)
799	{
800	put_dos_date3(buf, offset, unixdate, server_zone_offset);
801	}
802
803	/****************************************************************************
804	Take a Unix time and convert to an NTTIME structure and place in buffer
805	pointed to by p.
806	****************************************************************************/
807
808	void put_long_date_timespec(char *p, struct timespec ts)
809	{
810	NTTIME nt;
811	unix_timespec_to_nt_time(&nt, ts);
812	SIVAL(p, 0, nt & 0xFFFFFFFF);
813	SIVAL(p, 4, nt >> 32);
814	}
815
816	void put_long_date(char *p, time_t t)
817	{
818	struct timespec ts;
819	ts.tv_sec = t;
820	ts.tv_nsec = 0;
821	put_long_date_timespec(p, ts);
822	}
823
824	/****************************************************************************
825	Return the best approximation to a 'create time' under UNIX from a stat
826	structure.
827	****************************************************************************/
828
829	static time_t calc_create_time(const SMB_STRUCT_STAT *st)
830	{
831	time_t ret, ret1;
832
833	ret = MIN(st->st_ctime, st->st_mtime);
834	ret1 = MIN(ret, st->st_atime);
835
836	if(ret1 != (time_t)0) {
837	return ret1;
838	}
839
840	/*
841	* One of ctime, mtime or atime was zero (probably atime).
842	* Just return MIN(ctime, mtime).
843	*/
844	return ret;
845	}
846
847	/****************************************************************************
848	Return the 'create time' from a stat struct if it exists (birthtime) or else
849	use the best approximation.
850	****************************************************************************/
851
852	struct timespec get_create_timespec(const SMB_STRUCT_STAT *pst,bool fake_dirs)
853	{
854	struct timespec ret;
855
856	if(S_ISDIR(pst->st_mode) && fake_dirs) {
857	ret.tv_sec = 315493200L; /* 1/1/1980 */
858	ret.tv_nsec = 0;
859	return ret;
860	}
861
862	#if defined(HAVE_STAT_ST_BIRTHTIMESPEC)
863	ret = pst->st_birthtimespec;
864	#elif defined(HAVE_STAT_ST_BIRTHTIMENSEC)
865	ret.tv_sec = pst->st_birthtime;
866	ret.tv_nsec = pst->st_birthtimenspec;
867	#elif defined(HAVE_STAT_ST_BIRTHTIME)
868	ret.tv_sec = pst->st_birthtime;
869	ret.tv_nsec = 0;
870	#else
871	ret.tv_sec = calc_create_time(pst);
872	ret.tv_nsec = 0;
873	#endif
874
875	/* Deal with systems that don't initialize birthtime correctly.
876	* Pointed out by SATOH Fumiyasu <fumiyas@osstech.jp>.
877	*/
878	if (null_timespec(ret)) {
879	ret.tv_sec = calc_create_time(pst);
880	ret.tv_nsec = 0;
881	}
882	return ret;
883	}
884
885	/****************************************************************************
886	Get/Set all the possible time fields from a stat struct as a timespec.
887	****************************************************************************/
888
889	struct timespec get_atimespec(const SMB_STRUCT_STAT *pst)
890	{
891	#if !defined(HAVE_STAT_HIRES_TIMESTAMPS)
892	struct timespec ret;
893
894	/* Old system - no ns timestamp. */
895	ret.tv_sec = pst->st_atime;
896	ret.tv_nsec = 0;
897	return ret;
898	#else
899	#if defined(HAVE_STAT_ST_ATIM)
900	return pst->st_atim;
901	#elif defined(HAVE_STAT_ST_ATIMENSEC)
902	struct timespec ret;
903	ret.tv_sec = pst->st_atime;
904	ret.tv_nsec = pst->st_atimensec;
905	return ret;
906	#else
907	#error CONFIGURE_ERROR_IN_DETECTING_TIMESPEC_IN_STAT
908	#endif
909	#endif
910	}
911
912	void set_atimespec(SMB_STRUCT_STAT *pst, struct timespec ts)
913	{
914	#if !defined(HAVE_STAT_HIRES_TIMESTAMPS)
915	/* Old system - no ns timestamp. */
916	pst->st_atime = ts.tv_sec;
917	#else
918	#if defined(HAVE_STAT_ST_ATIM)
919	pst->st_atim = ts;
920	#elif defined(HAVE_STAT_ST_ATIMENSEC)
921	pst->st_atime = ts.tv_sec;
922	pst->st_atimensec = ts.tv_nsec
923	#else
924	#error CONFIGURE_ERROR_IN_DETECTING_TIMESPEC_IN_STAT
925	#endif
926	#endif
927	}
928
929	struct timespec get_mtimespec(const SMB_STRUCT_STAT *pst)
930	{
931	#if !defined(HAVE_STAT_HIRES_TIMESTAMPS)
932	struct timespec ret;
933
934	/* Old system - no ns timestamp. */
935	ret.tv_sec = pst->st_mtime;
936	ret.tv_nsec = 0;
937	return ret;
938	#else
939	#if defined(HAVE_STAT_ST_MTIM)
940	return pst->st_mtim;
941	#elif defined(HAVE_STAT_ST_MTIMENSEC)
942	struct timespec ret;
943	ret.tv_sec = pst->st_mtime;
944	ret.tv_nsec = pst->st_mtimensec;
945	return ret;
946	#else
947	#error CONFIGURE_ERROR_IN_DETECTING_TIMESPEC_IN_STAT
948	#endif
949	#endif
950	}
951
952	void set_mtimespec(SMB_STRUCT_STAT *pst, struct timespec ts)
953	{
954	#if !defined(HAVE_STAT_HIRES_TIMESTAMPS)
955	/* Old system - no ns timestamp. */
956	pst->st_mtime = ts.tv_sec;
957	#else
958	#if defined(HAVE_STAT_ST_MTIM)
959	pst->st_mtim = ts;
960	#elif defined(HAVE_STAT_ST_MTIMENSEC)
961	pst->st_mtime = ts.tv_sec;
962	pst->st_mtimensec = ts.tv_nsec
963	#else
964	#error CONFIGURE_ERROR_IN_DETECTING_TIMESPEC_IN_STAT
965	#endif
966	#endif
967	}
968
969	struct timespec get_ctimespec(const SMB_STRUCT_STAT *pst)
970	{
971	#if !defined(HAVE_STAT_HIRES_TIMESTAMPS)
972	struct timespec ret;
973
974	/* Old system - no ns timestamp. */
975	ret.tv_sec = pst->st_ctime;
976	ret.tv_nsec = 0;
977	return ret;
978	#else
979	#if defined(HAVE_STAT_ST_CTIM)
980	return pst->st_ctim;
981	#elif defined(HAVE_STAT_ST_CTIMENSEC)
982	struct timespec ret;
983	ret.tv_sec = pst->st_ctime;
984	ret.tv_nsec = pst->st_ctimensec;
985	return ret;
986	#else
987	#error CONFIGURE_ERROR_IN_DETECTING_TIMESPEC_IN_STAT
988	#endif
989	#endif
990	}
991
992	void set_ctimespec(SMB_STRUCT_STAT *pst, struct timespec ts)
993	{
994	#if !defined(HAVE_STAT_HIRES_TIMESTAMPS)
995	/* Old system - no ns timestamp. */
996	pst->st_ctime = ts.tv_sec;
997	#else
998	#if defined(HAVE_STAT_ST_CTIM)
999	pst->st_ctim = ts;
1000	#elif defined(HAVE_STAT_ST_CTIMENSEC)
1001	pst->st_ctime = ts.tv_sec;
1002	pst->st_ctimensec = ts.tv_nsec
1003	#else
1004	#error CONFIGURE_ERROR_IN_DETECTING_TIMESPEC_IN_STAT
1005	#endif
1006	#endif
1007	}
1008
1009	void dos_filetime_timespec(struct timespec *tsp)
1010	{
1011	tsp->tv_sec &= ~1;
1012	tsp->tv_nsec = 0;
1013	}
1014
1015	/*******************************************************************
1016	Create a unix date (int GMT) from a dos date (which is actually in
1017	localtime).
1018	********************************************************************/
1019
1020	static time_t make_unix_date(const void *date_ptr, int zone_offset)
1021	{
1022	uint32 dos_date=0;
1023	struct tm t;
1024	time_t ret;
1025
1026	dos_date = IVAL(date_ptr,0);
1027
1028	if (dos_date == 0) {
1029	return 0;
1030	}
1031
1032	interpret_dos_date(dos_date,&t.tm_year,&t.tm_mon,
1033	&t.tm_mday,&t.tm_hour,&t.tm_min,&t.tm_sec);
1034	t.tm_isdst = -1;
1035
1036	ret = timegm(&t);
1037
1038	ret += zone_offset;
1039
1040	return(ret);
1041	}
1042
1043	/*******************************************************************
1044	Like make_unix_date() but the words are reversed.
1045	********************************************************************/
1046
1047	static time_t make_unix_date2(const void *date_ptr, int zone_offset)
1048	{
1049	uint32 x,x2;
1050
1051	x = IVAL(date_ptr,0);
1052	x2 = ((x&0xFFFF)<<16) \| ((x&0xFFFF0000)>>16);
1053	SIVAL(&x,0,x2);
1054
1055	return(make_unix_date((const void *)&x, zone_offset));
1056	}
1057
1058	/*******************************************************************
1059	Create a unix GMT date from a dos date in 32 bit "unix like" format
1060	these generally arrive as localtimes, with corresponding DST.
1061	******************************************************************/
1062
1063	static time_t make_unix_date3(const void *date_ptr, int zone_offset)
1064	{
1065	time_t t = (time_t)IVAL(date_ptr,0);
1066	if (!null_mtime(t)) {
1067	t += zone_offset;
1068	}
1069	return(t);
1070	}
1071
1072	time_t srv_make_unix_date(const void *date_ptr)
1073	{
1074	return make_unix_date(date_ptr, server_zone_offset);
1075	}
1076
1077	time_t srv_make_unix_date2(const void *date_ptr)
1078	{
1079	return make_unix_date2(date_ptr, server_zone_offset);
1080	}
1081
1082	time_t srv_make_unix_date3(const void *date_ptr)
1083	{
1084	return make_unix_date3(date_ptr, server_zone_offset);
1085	}
1086
1087	time_t convert_timespec_to_time_t(struct timespec ts)
1088	{
1089	/* 1 ns == 1,000,000,000 - one thousand millionths of a second.
1090	increment if it's greater than 500 millionth of a second. */
1091	if (ts.tv_nsec > 500000000) {
1092	return ts.tv_sec + 1;
1093	}
1094	return ts.tv_sec;
1095	}
1096
1097	struct timespec convert_time_t_to_timespec(time_t t)
1098	{
1099	struct timespec ts;
1100	ts.tv_sec = t;
1101	ts.tv_nsec = 0;
1102	return ts;
1103	}
1104
1105	/****************************************************************************
1106	Convert a normalized timeval to a timespec.
1107	****************************************************************************/
1108
1109	struct timespec convert_timeval_to_timespec(const struct timeval tv)
1110	{
1111	struct timespec ts;
1112	ts.tv_sec = tv.tv_sec;
1113	ts.tv_nsec = tv.tv_usec * 1000;
1114	return ts;
1115	}
1116
1117	/****************************************************************************
1118	Convert a normalized timespec to a timeval.
1119	****************************************************************************/
1120
1121	struct timeval convert_timespec_to_timeval(const struct timespec ts)
1122	{
1123	struct timeval tv;
1124	tv.tv_sec = ts.tv_sec;
1125	tv.tv_usec = ts.tv_nsec / 1000;
1126	return tv;
1127	}
1128
1129	/****************************************************************************
1130	Return a timespec for the current time
1131	****************************************************************************/
1132
1133	struct timespec timespec_current(void)
1134	{
1135	struct timeval tv;
1136	struct timespec ts;
1137	GetTimeOfDay(&tv);
1138	ts.tv_sec = tv.tv_sec;
1139	ts.tv_nsec = tv.tv_usec * 1000;
1140	return ts;
1141	}
1142
1143	/****************************************************************************
1144	Return the lesser of two timespecs.
1145	****************************************************************************/
1146
1147	struct timespec timespec_min(const struct timespec *ts1,
1148	const struct timespec *ts2)
1149	{
1150	if (ts1->tv_sec < ts2->tv_sec) return *ts1;
1151	if (ts1->tv_sec > ts2->tv_sec) return *ts2;
1152	if (ts1->tv_nsec < ts2->tv_nsec) return *ts1;
1153	return *ts2;
1154	}
1155
1156	/****************************************************************************
1157	compare two timespec structures.
1158	Return -1 if ts1 < ts2
1159	Return 0 if ts1 == ts2
1160	Return 1 if ts1 > ts2
1161	****************************************************************************/
1162
1163	int timespec_compare(const struct timespec ts1, const struct timespec ts2)
1164	{
1165	if (ts1->tv_sec > ts2->tv_sec) return 1;
1166	if (ts1->tv_sec < ts2->tv_sec) return -1;
1167	if (ts1->tv_nsec > ts2->tv_nsec) return 1;
1168	if (ts1->tv_nsec < ts2->tv_nsec) return -1;
1169	return 0;
1170	}
1171
1172	/****************************************************************************
1173	Interprets an nt time into a unix struct timespec.
1174	Differs from nt_time_to_unix in that an 8 byte value of 0xffffffffffffffff
1175	will be returned as (time_t)-1, whereas nt_time_to_unix returns 0 in this case.
1176	****************************************************************************/
1177
1178	struct timespec interpret_long_date(const char *p)
1179	{
1180	NTTIME nt;
1181	nt = IVAL(p,0) + ((uint64_t)IVAL(p,4) << 32);
1182	if (nt == (uint64_t)-1) {
1183	struct timespec ret;
1184	ret.tv_sec = (time_t)-1;
1185	ret.tv_nsec = 0;
1186	return ret;
1187	}
1188	return nt_time_to_unix_timespec(&nt);
1189	}
1190
1191	/***************************************************************************
1192	Client versions of the above functions.
1193	***************************************************************************/
1194
1195	void cli_put_dos_date(struct cli_state cli, char buf, int offset, time_t unixdate)
1196	{
1197	put_dos_date(buf, offset, unixdate, cli->serverzone);
1198	}
1199
1200	void cli_put_dos_date2(struct cli_state cli, char buf, int offset, time_t unixdate)
1201	{
1202	put_dos_date2(buf, offset, unixdate, cli->serverzone);
1203	}
1204
1205	void cli_put_dos_date3(struct cli_state cli, char buf, int offset, time_t unixdate)
1206	{
1207	put_dos_date3(buf, offset, unixdate, cli->serverzone);
1208	}
1209
1210	time_t cli_make_unix_date(struct cli_state cli, const void date_ptr)
1211	{
1212	return make_unix_date(date_ptr, cli->serverzone);
1213	}
1214
1215	time_t cli_make_unix_date2(struct cli_state cli, const void date_ptr)
1216	{
1217	return make_unix_date2(date_ptr, cli->serverzone);
1218	}
1219
1220	time_t cli_make_unix_date3(struct cli_state cli, const void date_ptr)
1221	{
1222	return make_unix_date3(date_ptr, cli->serverzone);
1223	}
1224
1225	/* Large integer version. */
1226	struct timespec nt_time_to_unix_timespec(NTTIME *nt)
1227	{
1228	int64 d;
1229	struct timespec ret;
1230
1231	if (nt == 0 \|\| nt == (int64)-1) {
1232	ret.tv_sec = 0;
1233	ret.tv_nsec = 0;
1234	return ret;
1235	}
1236
1237	d = (int64)*nt;
1238	/* d is now in 100ns units, since jan 1st 1601".
1239	Save off the ns fraction. */
1240
1241	/*
1242	* Take the last seven decimal digits and multiply by 100.
1243	* to convert from 100ns units to 1ns units.
1244	*/
1245	ret.tv_nsec = (long) ((d % (1000 * 1000 * 10)) * 100);
1246
1247	/* Convert to seconds */
1248	d /= 1000100010;
1249
1250	/* Now adjust by 369 years to make the secs since 1970 */
1251	d -= TIME_FIXUP_CONSTANT_INT;
1252
1253	if (d <= (int64)TIME_T_MIN) {
1254	ret.tv_sec = TIME_T_MIN;
1255	ret.tv_nsec = 0;
1256	return ret;
1257	}
1258
1259	if (d >= (int64)TIME_T_MAX) {
1260	ret.tv_sec = TIME_T_MAX;
1261	ret.tv_nsec = 0;
1262	return ret;
1263	}
1264
1265	ret.tv_sec = (time_t)d;
1266	return ret;
1267	}
1268	/****************************************************************************
1269	Check if two NTTIMEs are the same.
1270	****************************************************************************/
1271
1272	bool nt_time_equals(const NTTIME nt1, const NTTIME nt2)
1273	{
1274	return (nt1 == nt2);
1275	}
1276
1277	/*******************************************************************
1278	Re-read the smb serverzone value.
1279	******************************************************************/
1280
1281	static struct timeval start_time_hires;
1282
1283	void TimeInit(void)
1284	{
1285	set_server_zone_offset(time(NULL));
1286
1287	DEBUG(4,("TimeInit: Serverzone is %d\n", server_zone_offset));
1288
1289	/* Save the start time of this process. */
1290	if (start_time_hires.tv_sec == 0 && start_time_hires.tv_usec == 0) {
1291	GetTimeOfDay(&start_time_hires);
1292	}
1293	}
1294
1295	/**********************************************************************
1296	Return a timeval struct of the uptime of this process. As TimeInit is
1297	done before a daemon fork then this is the start time from the parent
1298	daemon start. JRA.
1299	***********************************************************************/
1300
1301	void get_process_uptime(struct timeval *ret_time)
1302	{
1303	struct timeval time_now_hires;
1304
1305	GetTimeOfDay(&time_now_hires);
1306	ret_time->tv_sec = time_now_hires.tv_sec - start_time_hires.tv_sec;
1307	if (time_now_hires.tv_usec < start_time_hires.tv_usec) {
1308	ret_time->tv_sec -= 1;
1309	ret_time->tv_usec = 1000000 + (time_now_hires.tv_usec - start_time_hires.tv_usec);
1310	} else {
1311	ret_time->tv_usec = time_now_hires.tv_usec - start_time_hires.tv_usec;
1312	}
1313	}
1314
1315	/****************************************************************************
1316	Convert a NTTIME structure to a time_t.
1317	It's originally in "100ns units".
1318
1319	This is an absolute version of the one above.
1320	By absolute I mean, it doesn't adjust from 1/1/1601 to 1/1/1970
1321	if the NTTIME was 5 seconds, the time_t is 5 seconds. JFM
1322	****************************************************************************/
1323
1324	time_t nt_time_to_unix_abs(const NTTIME *nt)
1325	{
1326	uint64 d;
1327
1328	if (*nt == 0) {
1329	return (time_t)0;
1330	}
1331
1332	if (*nt == (uint64)-1) {
1333	return (time_t)-1;
1334	}
1335
1336	if (*nt == NTTIME_INFINITY) {
1337	return (time_t)-1;
1338	}
1339
1340	/* reverse the time */
1341	/* it's a negative value, turn it to positive */
1342	d=~*nt;
1343
1344	d += 1000100010/2;
1345	d /= 1000100010;
1346
1347	if (!(TIME_T_MIN <= ((time_t)d) && ((time_t)d) <= TIME_T_MAX)) {
1348	return (time_t)0;
1349	}
1350
1351	return (time_t)d;
1352	}
1353
1354	time_t uint64s_nt_time_to_unix_abs(const uint64_t *src)
1355	{
1356	NTTIME nttime;
1357	nttime = *src;
1358	return nt_time_to_unix_abs(&nttime);
1359	}
1360
1361	/****************************************************************************
1362	Put a 8 byte filetime from a struct timespec. Uses GMT.
1363	****************************************************************************/
1364
1365	void unix_timespec_to_nt_time(NTTIME *nt, struct timespec ts)
1366	{
1367	uint64 d;
1368
1369	if (ts.tv_sec ==0 && ts.tv_nsec == 0) {
1370	*nt = 0;
1371	return;
1372	}
1373	if (ts.tv_sec == TIME_T_MAX) {
1374	*nt = 0x7fffffffffffffffLL;
1375	return;
1376	}
1377	if (ts.tv_sec == (time_t)-1) {
1378	*nt = (uint64)-1;
1379	return;
1380	}
1381
1382	d = ts.tv_sec;
1383	d += TIME_FIXUP_CONSTANT_INT;
1384	d = 10001000*10;
1385	/* d is now in 100ns units. */
1386	d += (ts.tv_nsec / 100);
1387
1388	*nt = d;
1389	}
1390
1391	/****************************************************************************
1392	Convert a time_t to a NTTIME structure
1393
1394	This is an absolute version of the one above.
1395	By absolute I mean, it doesn't adjust from 1/1/1970 to 1/1/1601
1396	If the time_t was 5 seconds, the NTTIME is 5 seconds. JFM
1397	****************************************************************************/
1398
1399	void unix_to_nt_time_abs(NTTIME *nt, time_t t)
1400	{
1401	double d;
1402
1403	if (t==0) {
1404	*nt = 0;
1405	return;
1406	}
1407
1408	if (t == TIME_T_MAX) {
1409	*nt = 0x7fffffffffffffffLL;
1410	return;
1411	}
1412
1413	if (t == (time_t)-1) {
1414	/* that's what NT uses for infinite */
1415	*nt = NTTIME_INFINITY;
1416	return;
1417	}
1418
1419	d = (double)(t);
1420	d *= 1.0e7;
1421
1422	*nt = (NTTIME)d;
1423
1424	/* convert to a negative value */
1425	nt=~nt;
1426	}
1427
1428
1429	/****************************************************************************
1430	Check if it's a null mtime.
1431	****************************************************************************/
1432
1433	bool null_mtime(time_t mtime)
1434	{
1435	if (mtime == 0 \|\| mtime == (time_t)0xFFFFFFFF \|\| mtime == (time_t)-1)
1436	return(True);
1437	return(False);
1438	}
1439
1440	/****************************************************************************
1441	Utility function that always returns a const string even if localtime
1442	and asctime fail.
1443	****************************************************************************/
1444
1445	const char *time_to_asc(const time_t t)
1446	{
1447	const char *asct;
1448	struct tm *lt = localtime(&t);
1449
1450	if (!lt) {
1451	return "unknown time";
1452	}
1453
1454	asct = asctime(lt);
1455	if (!asct) {
1456	return "unknown time";
1457	}
1458	return asct;
1459	}
1460
1461	const char *display_time(NTTIME nttime)
1462	{
1463	float high;
1464	float low;
1465	int sec;
1466	int days, hours, mins, secs;
1467
1468	if (nttime==0)
1469	return "Now";
1470
1471	if (nttime==NTTIME_INFINITY)
1472	return "Never";
1473
1474	high = 65536;
1475	high = high/10000;
1476	high = high*65536;
1477	high = high/1000;
1478	high = high * (~(nttime >> 32));
1479
1480	low = ~(nttime & 0xFFFFFFFF);
1481	low = low/(1000100010);
1482
1483	sec=(int)(high+low);
1484
1485	days=sec/(606024);
1486	hours=(sec - (days606024)) / (6060);
1487	mins=(sec - (days606024) - (hours60*60) ) / 60;
1488	secs=sec - (days606024) - (hours6060) - (mins60);
1489
1490	return talloc_asprintf(talloc_tos(), "%u days, %u hours, %u minutes, "
1491	"%u seconds", days, hours, mins, secs);
1492	}
1493
1494	bool nt_time_is_set(const NTTIME *nt)
1495	{
1496	if (*nt == 0x7FFFFFFFFFFFFFFFLL) {
1497	return False;
1498	}
1499
1500	if (*nt == NTTIME_INFINITY) {
1501	return False;
1502	}
1503
1504	return True;
1505	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: