Context Navigation

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

Visit:

Last change on this file since 221 was 221, checked in by Herwig Bauernfeind, 16 years ago
Update Samba 3.3 to 3.3.1
File size: 40.0 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	#elif defined(HAVE_STAT_ST_ATIME_N)
907	struct timespec ret;
908	ret.tv_sec = pst->st_atime;
909	ret.tv_nsec = pst->st_atime_n;
910	return ret;
911	#elif defined(HAVE_STAT_ST_UATIME)
912	struct timespec ret;
913	ret.tv_sec = pst->st_atime;
914	ret.tv_nsec = pst->st_uatime * 1000;
915	return ret;
916	#elif defined(HAVE_STAT_ST_ATIMESPEC)
917	return pst->st_atimespec;
918	#else
919	#error CONFIGURE_ERROR_IN_DETECTING_TIMESPEC_IN_STAT
920	#endif
921	#endif
922	}
923
924	void set_atimespec(SMB_STRUCT_STAT *pst, struct timespec ts)
925	{
926	#if !defined(HAVE_STAT_HIRES_TIMESTAMPS)
927	/* Old system - no ns timestamp. */
928	pst->st_atime = ts.tv_sec;
929	#else
930	#if defined(HAVE_STAT_ST_ATIM)
931	pst->st_atim = ts;
932	#elif defined(HAVE_STAT_ST_ATIMENSEC)
933	pst->st_atime = ts.tv_sec;
934	pst->st_atimensec = ts.tv_nsec;
935	#elif defined(HAVE_STAT_ST_ATIME_N)
936	pst->st_atime = ts.tv_sec;
937	pst->st_atime_n = ts.tv_nsec;
938	#elif defined(HAVE_STAT_ST_UATIME)
939	pst->st_atime = ts.tv_sec;
940	pst->st_uatime = ts.tv_nsec / 1000;
941	#elif defined(HAVE_STAT_ST_ATIMESPEC)
942	pst->st_atimespec = ts;
943	#else
944	#error CONFIGURE_ERROR_IN_DETECTING_TIMESPEC_IN_STAT
945	#endif
946	#endif
947	}
948
949	struct timespec get_mtimespec(const SMB_STRUCT_STAT *pst)
950	{
951	#if !defined(HAVE_STAT_HIRES_TIMESTAMPS)
952	struct timespec ret;
953
954	/* Old system - no ns timestamp. */
955	ret.tv_sec = pst->st_mtime;
956	ret.tv_nsec = 0;
957	return ret;
958	#else
959	#if defined(HAVE_STAT_ST_MTIM)
960	return pst->st_mtim;
961	#elif defined(HAVE_STAT_ST_MTIMENSEC)
962	struct timespec ret;
963	ret.tv_sec = pst->st_mtime;
964	ret.tv_nsec = pst->st_mtimensec;
965	return ret;
966	#elif defined(HAVE_STAT_ST_MTIME_N)
967	struct timespec ret;
968	ret.tv_sec = pst->st_mtime;
969	ret.tv_nsec = pst->st_mtime_n;
970	return ret;
971	#elif defined(HAVE_STAT_ST_UMTIME)
972	struct timespec ret;
973	ret.tv_sec = pst->st_mtime;
974	ret.tv_nsec = pst->st_umtime * 1000;
975	return ret;
976	#elif defined(HAVE_STAT_ST_MTIMESPEC)
977	return pst->st_mtimespec;
978	#else
979	#error CONFIGURE_ERROR_IN_DETECTING_TIMESPEC_IN_STAT
980	#endif
981	#endif
982	}
983
984	void set_mtimespec(SMB_STRUCT_STAT *pst, struct timespec ts)
985	{
986	#if !defined(HAVE_STAT_HIRES_TIMESTAMPS)
987	/* Old system - no ns timestamp. */
988	pst->st_mtime = ts.tv_sec;
989	#else
990	#if defined(HAVE_STAT_ST_MTIM)
991	pst->st_mtim = ts;
992	#elif defined(HAVE_STAT_ST_MTIMENSEC)
993	pst->st_mtime = ts.tv_sec;
994	pst->st_mtimensec = ts.tv_nsec;
995	#elif defined(HAVE_STAT_ST_MTIME_N)
996	pst->st_mtime = ts.tv_sec;
997	pst->st_mtime_n = ts.tv_nsec;
998	#elif defined(HAVE_STAT_ST_UMTIME)
999	pst->st_mtime = ts.tv_sec;
1000	pst->st_umtime = ts.tv_nsec / 1000;
1001	#elif defined(HAVE_STAT_ST_MTIMESPEC)
1002	pst->st_mtimespec = ts;
1003	#else
1004	#error CONFIGURE_ERROR_IN_DETECTING_TIMESPEC_IN_STAT
1005	#endif
1006	#endif
1007	}
1008
1009	struct timespec get_ctimespec(const SMB_STRUCT_STAT *pst)
1010	{
1011	#if !defined(HAVE_STAT_HIRES_TIMESTAMPS)
1012	struct timespec ret;
1013
1014	/* Old system - no ns timestamp. */
1015	ret.tv_sec = pst->st_ctime;
1016	ret.tv_nsec = 0;
1017	return ret;
1018	#else
1019	#if defined(HAVE_STAT_ST_CTIM)
1020	return pst->st_ctim;
1021	#elif defined(HAVE_STAT_ST_CTIMENSEC)
1022	struct timespec ret;
1023	ret.tv_sec = pst->st_ctime;
1024	ret.tv_nsec = pst->st_ctimensec;
1025	return ret;
1026	#elif defined(HAVE_STAT_ST_CTIME_N)
1027	struct timespec ret;
1028	ret.tv_sec = pst->st_ctime;
1029	ret.tv_nsec = pst->st_ctime_n;
1030	return ret;
1031	#elif defined(HAVE_STAT_ST_UCTIME)
1032	struct timespec ret;
1033	ret.tv_sec = pst->st_ctime;
1034	ret.tv_nsec = pst->st_uctime * 1000;
1035	return ret;
1036	#elif defined(HAVE_STAT_ST_CTIMESPEC)
1037	return pst->st_ctimespec;
1038	#else
1039	#error CONFIGURE_ERROR_IN_DETECTING_TIMESPEC_IN_STAT
1040	#endif
1041	#endif
1042	}
1043
1044	void set_ctimespec(SMB_STRUCT_STAT *pst, struct timespec ts)
1045	{
1046	#if !defined(HAVE_STAT_HIRES_TIMESTAMPS)
1047	/* Old system - no ns timestamp. */
1048	pst->st_ctime = ts.tv_sec;
1049	#else
1050	#if defined(HAVE_STAT_ST_CTIM)
1051	pst->st_ctim = ts;
1052	#elif defined(HAVE_STAT_ST_CTIMENSEC)
1053	pst->st_ctime = ts.tv_sec;
1054	pst->st_ctimensec = ts.tv_nsec;
1055	#elif defined(HAVE_STAT_ST_CTIME_N)
1056	pst->st_ctime = ts.tv_sec;
1057	pst->st_ctime_n = ts.tv_nsec;
1058	#elif defined(HAVE_STAT_ST_UCTIME)
1059	pst->st_ctime = ts.tv_sec;
1060	pst->st_uctime = ts.tv_nsec / 1000;
1061	#elif defined(HAVE_STAT_ST_CTIMESPEC)
1062	pst->st_ctimespec = ts;
1063	#else
1064	#error CONFIGURE_ERROR_IN_DETECTING_TIMESPEC_IN_STAT
1065	#endif
1066	#endif
1067	}
1068
1069	void dos_filetime_timespec(struct timespec *tsp)
1070	{
1071	tsp->tv_sec &= ~1;
1072	tsp->tv_nsec = 0;
1073	}
1074
1075	/*******************************************************************
1076	Create a unix date (int GMT) from a dos date (which is actually in
1077	localtime).
1078	********************************************************************/
1079
1080	static time_t make_unix_date(const void *date_ptr, int zone_offset)
1081	{
1082	uint32 dos_date=0;
1083	struct tm t;
1084	time_t ret;
1085
1086	dos_date = IVAL(date_ptr,0);
1087
1088	if (dos_date == 0) {
1089	return 0;
1090	}
1091
1092	interpret_dos_date(dos_date,&t.tm_year,&t.tm_mon,
1093	&t.tm_mday,&t.tm_hour,&t.tm_min,&t.tm_sec);
1094	t.tm_isdst = -1;
1095
1096	ret = timegm(&t);
1097
1098	ret += zone_offset;
1099
1100	return(ret);
1101	}
1102
1103	/*******************************************************************
1104	Like make_unix_date() but the words are reversed.
1105	********************************************************************/
1106
1107	static time_t make_unix_date2(const void *date_ptr, int zone_offset)
1108	{
1109	uint32 x,x2;
1110
1111	x = IVAL(date_ptr,0);
1112	x2 = ((x&0xFFFF)<<16) \| ((x&0xFFFF0000)>>16);
1113	SIVAL(&x,0,x2);
1114
1115	return(make_unix_date((const void *)&x, zone_offset));
1116	}
1117
1118	/*******************************************************************
1119	Create a unix GMT date from a dos date in 32 bit "unix like" format
1120	these generally arrive as localtimes, with corresponding DST.
1121	******************************************************************/
1122
1123	static time_t make_unix_date3(const void *date_ptr, int zone_offset)
1124	{
1125	time_t t = (time_t)IVAL(date_ptr,0);
1126	if (!null_mtime(t)) {
1127	t += zone_offset;
1128	}
1129	return(t);
1130	}
1131
1132	time_t srv_make_unix_date(const void *date_ptr)
1133	{
1134	return make_unix_date(date_ptr, server_zone_offset);
1135	}
1136
1137	time_t srv_make_unix_date2(const void *date_ptr)
1138	{
1139	return make_unix_date2(date_ptr, server_zone_offset);
1140	}
1141
1142	time_t srv_make_unix_date3(const void *date_ptr)
1143	{
1144	return make_unix_date3(date_ptr, server_zone_offset);
1145	}
1146
1147	time_t convert_timespec_to_time_t(struct timespec ts)
1148	{
1149	/* 1 ns == 1,000,000,000 - one thousand millionths of a second.
1150	increment if it's greater than 500 millionth of a second. */
1151	if (ts.tv_nsec > 500000000) {
1152	return ts.tv_sec + 1;
1153	}
1154	return ts.tv_sec;
1155	}
1156
1157	struct timespec convert_time_t_to_timespec(time_t t)
1158	{
1159	struct timespec ts;
1160	ts.tv_sec = t;
1161	ts.tv_nsec = 0;
1162	return ts;
1163	}
1164
1165	/****************************************************************************
1166	Convert a normalized timeval to a timespec.
1167	****************************************************************************/
1168
1169	struct timespec convert_timeval_to_timespec(const struct timeval tv)
1170	{
1171	struct timespec ts;
1172	ts.tv_sec = tv.tv_sec;
1173	ts.tv_nsec = tv.tv_usec * 1000;
1174	return ts;
1175	}
1176
1177	/****************************************************************************
1178	Convert a normalized timespec to a timeval.
1179	****************************************************************************/
1180
1181	struct timeval convert_timespec_to_timeval(const struct timespec ts)
1182	{
1183	struct timeval tv;
1184	tv.tv_sec = ts.tv_sec;
1185	tv.tv_usec = ts.tv_nsec / 1000;
1186	return tv;
1187	}
1188
1189	/****************************************************************************
1190	Return a timespec for the current time
1191	****************************************************************************/
1192
1193	struct timespec timespec_current(void)
1194	{
1195	struct timeval tv;
1196	struct timespec ts;
1197	GetTimeOfDay(&tv);
1198	ts.tv_sec = tv.tv_sec;
1199	ts.tv_nsec = tv.tv_usec * 1000;
1200	return ts;
1201	}
1202
1203	/****************************************************************************
1204	Return the lesser of two timespecs.
1205	****************************************************************************/
1206
1207	struct timespec timespec_min(const struct timespec *ts1,
1208	const struct timespec *ts2)
1209	{
1210	if (ts1->tv_sec < ts2->tv_sec) return *ts1;
1211	if (ts1->tv_sec > ts2->tv_sec) return *ts2;
1212	if (ts1->tv_nsec < ts2->tv_nsec) return *ts1;
1213	return *ts2;
1214	}
1215
1216	/****************************************************************************
1217	compare two timespec structures.
1218	Return -1 if ts1 < ts2
1219	Return 0 if ts1 == ts2
1220	Return 1 if ts1 > ts2
1221	****************************************************************************/
1222
1223	int timespec_compare(const struct timespec ts1, const struct timespec ts2)
1224	{
1225	if (ts1->tv_sec > ts2->tv_sec) return 1;
1226	if (ts1->tv_sec < ts2->tv_sec) return -1;
1227	if (ts1->tv_nsec > ts2->tv_nsec) return 1;
1228	if (ts1->tv_nsec < ts2->tv_nsec) return -1;
1229	return 0;
1230	}
1231
1232	/****************************************************************************
1233	Interprets an nt time into a unix struct timespec.
1234	Differs from nt_time_to_unix in that an 8 byte value of 0xffffffffffffffff
1235	will be returned as (time_t)-1, whereas nt_time_to_unix returns 0 in this case.
1236	****************************************************************************/
1237
1238	struct timespec interpret_long_date(const char *p)
1239	{
1240	NTTIME nt;
1241	nt = IVAL(p,0) + ((uint64_t)IVAL(p,4) << 32);
1242	if (nt == (uint64_t)-1) {
1243	struct timespec ret;
1244	ret.tv_sec = (time_t)-1;
1245	ret.tv_nsec = 0;
1246	return ret;
1247	}
1248	return nt_time_to_unix_timespec(&nt);
1249	}
1250
1251	/***************************************************************************
1252	Client versions of the above functions.
1253	***************************************************************************/
1254
1255	void cli_put_dos_date(struct cli_state cli, char buf, int offset, time_t unixdate)
1256	{
1257	put_dos_date(buf, offset, unixdate, cli->serverzone);
1258	}
1259
1260	void cli_put_dos_date2(struct cli_state cli, char buf, int offset, time_t unixdate)
1261	{
1262	put_dos_date2(buf, offset, unixdate, cli->serverzone);
1263	}
1264
1265	void cli_put_dos_date3(struct cli_state cli, char buf, int offset, time_t unixdate)
1266	{
1267	put_dos_date3(buf, offset, unixdate, cli->serverzone);
1268	}
1269
1270	time_t cli_make_unix_date(struct cli_state cli, const void date_ptr)
1271	{
1272	return make_unix_date(date_ptr, cli->serverzone);
1273	}
1274
1275	time_t cli_make_unix_date2(struct cli_state cli, const void date_ptr)
1276	{
1277	return make_unix_date2(date_ptr, cli->serverzone);
1278	}
1279
1280	time_t cli_make_unix_date3(struct cli_state cli, const void date_ptr)
1281	{
1282	return make_unix_date3(date_ptr, cli->serverzone);
1283	}
1284
1285	/* Large integer version. */
1286	struct timespec nt_time_to_unix_timespec(NTTIME *nt)
1287	{
1288	int64 d;
1289	struct timespec ret;
1290
1291	if (nt == 0 \|\| nt == (int64)-1) {
1292	ret.tv_sec = 0;
1293	ret.tv_nsec = 0;
1294	return ret;
1295	}
1296
1297	d = (int64)*nt;
1298	/* d is now in 100ns units, since jan 1st 1601".
1299	Save off the ns fraction. */
1300
1301	/*
1302	* Take the last seven decimal digits and multiply by 100.
1303	* to convert from 100ns units to 1ns units.
1304	*/
1305	ret.tv_nsec = (long) ((d % (1000 * 1000 * 10)) * 100);
1306
1307	/* Convert to seconds */
1308	d /= 1000100010;
1309
1310	/* Now adjust by 369 years to make the secs since 1970 */
1311	d -= TIME_FIXUP_CONSTANT_INT;
1312
1313	if (d <= (int64)TIME_T_MIN) {
1314	ret.tv_sec = TIME_T_MIN;
1315	ret.tv_nsec = 0;
1316	return ret;
1317	}
1318
1319	if (d >= (int64)TIME_T_MAX) {
1320	ret.tv_sec = TIME_T_MAX;
1321	ret.tv_nsec = 0;
1322	return ret;
1323	}
1324
1325	ret.tv_sec = (time_t)d;
1326	return ret;
1327	}
1328	/****************************************************************************
1329	Check if two NTTIMEs are the same.
1330	****************************************************************************/
1331
1332	bool nt_time_equals(const NTTIME nt1, const NTTIME nt2)
1333	{
1334	return (nt1 == nt2);
1335	}
1336
1337	/*******************************************************************
1338	Re-read the smb serverzone value.
1339	******************************************************************/
1340
1341	static struct timeval start_time_hires;
1342
1343	void TimeInit(void)
1344	{
1345	set_server_zone_offset(time(NULL));
1346
1347	DEBUG(4,("TimeInit: Serverzone is %d\n", server_zone_offset));
1348
1349	/* Save the start time of this process. */
1350	if (start_time_hires.tv_sec == 0 && start_time_hires.tv_usec == 0) {
1351	GetTimeOfDay(&start_time_hires);
1352	}
1353	}
1354
1355	/**********************************************************************
1356	Return a timeval struct of the uptime of this process. As TimeInit is
1357	done before a daemon fork then this is the start time from the parent
1358	daemon start. JRA.
1359	***********************************************************************/
1360
1361	void get_process_uptime(struct timeval *ret_time)
1362	{
1363	struct timeval time_now_hires;
1364
1365	GetTimeOfDay(&time_now_hires);
1366	ret_time->tv_sec = time_now_hires.tv_sec - start_time_hires.tv_sec;
1367	if (time_now_hires.tv_usec < start_time_hires.tv_usec) {
1368	ret_time->tv_sec -= 1;
1369	ret_time->tv_usec = 1000000 + (time_now_hires.tv_usec - start_time_hires.tv_usec);
1370	} else {
1371	ret_time->tv_usec = time_now_hires.tv_usec - start_time_hires.tv_usec;
1372	}
1373	}
1374
1375	/****************************************************************************
1376	Convert a NTTIME structure to a time_t.
1377	It's originally in "100ns units".
1378
1379	This is an absolute version of the one above.
1380	By absolute I mean, it doesn't adjust from 1/1/1601 to 1/1/1970
1381	if the NTTIME was 5 seconds, the time_t is 5 seconds. JFM
1382	****************************************************************************/
1383
1384	time_t nt_time_to_unix_abs(const NTTIME *nt)
1385	{
1386	uint64 d;
1387
1388	if (*nt == 0) {
1389	return (time_t)0;
1390	}
1391
1392	if (*nt == (uint64)-1) {
1393	return (time_t)-1;
1394	}
1395
1396	if (*nt == NTTIME_INFINITY) {
1397	return (time_t)-1;
1398	}
1399
1400	/* reverse the time */
1401	/* it's a negative value, turn it to positive */
1402	d=~*nt;
1403
1404	d += 1000100010/2;
1405	d /= 1000100010;
1406
1407	if (!(TIME_T_MIN <= ((time_t)d) && ((time_t)d) <= TIME_T_MAX)) {
1408	return (time_t)0;
1409	}
1410
1411	return (time_t)d;
1412	}
1413
1414	time_t uint64s_nt_time_to_unix_abs(const uint64_t *src)
1415	{
1416	NTTIME nttime;
1417	nttime = *src;
1418	return nt_time_to_unix_abs(&nttime);
1419	}
1420
1421	/****************************************************************************
1422	Put a 8 byte filetime from a struct timespec. Uses GMT.
1423	****************************************************************************/
1424
1425	void unix_timespec_to_nt_time(NTTIME *nt, struct timespec ts)
1426	{
1427	uint64 d;
1428
1429	if (ts.tv_sec ==0 && ts.tv_nsec == 0) {
1430	*nt = 0;
1431	return;
1432	}
1433	if (ts.tv_sec == TIME_T_MAX) {
1434	*nt = 0x7fffffffffffffffLL;
1435	return;
1436	}
1437	if (ts.tv_sec == (time_t)-1) {
1438	*nt = (uint64)-1;
1439	return;
1440	}
1441
1442	d = ts.tv_sec;
1443	d += TIME_FIXUP_CONSTANT_INT;
1444	d = 10001000*10;
1445	/* d is now in 100ns units. */
1446	d += (ts.tv_nsec / 100);
1447
1448	*nt = d;
1449	}
1450
1451	/****************************************************************************
1452	Convert a time_t to a NTTIME structure
1453
1454	This is an absolute version of the one above.
1455	By absolute I mean, it doesn't adjust from 1/1/1970 to 1/1/1601
1456	If the time_t was 5 seconds, the NTTIME is 5 seconds. JFM
1457	****************************************************************************/
1458
1459	void unix_to_nt_time_abs(NTTIME *nt, time_t t)
1460	{
1461	double d;
1462
1463	if (t==0) {
1464	*nt = 0;
1465	return;
1466	}
1467
1468	if (t == TIME_T_MAX) {
1469	*nt = 0x7fffffffffffffffLL;
1470	return;
1471	}
1472
1473	if (t == (time_t)-1) {
1474	/* that's what NT uses for infinite */
1475	*nt = NTTIME_INFINITY;
1476	return;
1477	}
1478
1479	d = (double)(t);
1480	d *= 1.0e7;
1481
1482	*nt = (NTTIME)d;
1483
1484	/* convert to a negative value */
1485	nt=~nt;
1486	}
1487
1488
1489	/****************************************************************************
1490	Check if it's a null mtime.
1491	****************************************************************************/
1492
1493	bool null_mtime(time_t mtime)
1494	{
1495	if (mtime == 0 \|\| mtime == (time_t)0xFFFFFFFF \|\| mtime == (time_t)-1)
1496	return(True);
1497	return(False);
1498	}
1499
1500	/****************************************************************************
1501	Utility function that always returns a const string even if localtime
1502	and asctime fail.
1503	****************************************************************************/
1504
1505	const char *time_to_asc(const time_t t)
1506	{
1507	const char *asct;
1508	struct tm *lt = localtime(&t);
1509
1510	if (!lt) {
1511	return "unknown time";
1512	}
1513
1514	asct = asctime(lt);
1515	if (!asct) {
1516	return "unknown time";
1517	}
1518	return asct;
1519	}
1520
1521	const char *display_time(NTTIME nttime)
1522	{
1523	float high;
1524	float low;
1525	int sec;
1526	int days, hours, mins, secs;
1527
1528	if (nttime==0)
1529	return "Now";
1530
1531	if (nttime==NTTIME_INFINITY)
1532	return "Never";
1533
1534	high = 65536;
1535	high = high/10000;
1536	high = high*65536;
1537	high = high/1000;
1538	high = high * (~(nttime >> 32));
1539
1540	low = ~(nttime & 0xFFFFFFFF);
1541	low = low/(1000100010);
1542
1543	sec=(int)(high+low);
1544
1545	days=sec/(606024);
1546	hours=(sec - (days606024)) / (6060);
1547	mins=(sec - (days606024) - (hours60*60) ) / 60;
1548	secs=sec - (days606024) - (hours6060) - (mins60);
1549
1550	return talloc_asprintf(talloc_tos(), "%u days, %u hours, %u minutes, "
1551	"%u seconds", days, hours, mins, secs);
1552	}
1553
1554	bool nt_time_is_set(const NTTIME *nt)
1555	{
1556	if (*nt == 0x7FFFFFFFFFFFFFFFLL) {
1557	return False;
1558	}
1559
1560	if (*nt == NTTIME_INFINITY) {
1561	return False;
1562	}
1563
1564	return True;
1565	}

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

Download in other formats: