From dfc517b05395d925a4d7b1ce9633a849f9468e70 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Thu, 23 Feb 2006 15:52:24 +0000
Subject: r13658: More moving around of files:  - Collect the generic utility
 functions into a lib/util/ (a la GLib is 		for the GNOME folks) 
 - Remove even more files from include/ (This used to be commit
 ba62880f5b05c2a505dc7f54676b231197a7e707)

---
 source4/lib/util/time.c | 596 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 596 insertions(+)
 create mode 100644 source4/lib/util/time.c

(limited to 'source4/lib/util/time.c')

diff --git a/source4/lib/util/time.c b/source4/lib/util/time.c
new file mode 100644
index 0000000000..7721a2c456
--- /dev/null
+++ b/source4/lib/util/time.c
@@ -0,0 +1,596 @@
+/* 
+   Unix SMB/CIFS implementation.
+   time handling functions
+
+   Copyright (C) Andrew Tridgell 		1992-2004
+   Copyright (C) Stefan (metze) Metzmacher	2002   
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include "includes.h"
+#include "system/time.h"
+
+#ifndef TIME_T_MIN
+/* we use 0 here, because (time_t)-1 means error */
+#define TIME_T_MIN 0
+#endif
+
+/*
+ * we use the INT32_MAX here as on 64 bit systems,
+ * gmtime() fails with INT64_MAX
+ */
+
+#ifndef TIME_T_MAX
+#define TIME_T_MAX MIN(INT32_MAX,_TYPE_MAXIMUM(time_t))
+#endif
+
+/*******************************************************************
+ External access to time_t_min and time_t_max.
+********************************************************************/
+time_t get_time_t_max(void)
+{
+	return TIME_T_MAX;
+}
+
+/*******************************************************************
+a gettimeofday wrapper
+********************************************************************/
+void GetTimeOfDay(struct timeval *tval)
+{
+#ifdef HAVE_GETTIMEOFDAY_TZ
+	gettimeofday(tval,NULL);
+#else
+	gettimeofday(tval);
+#endif
+}
+
+
+#define TIME_FIXUP_CONSTANT 11644473600LL
+
+/****************************************************************************
+interpret an 8 byte "filetime" structure to a time_t
+It's originally in "100ns units since jan 1st 1601"
+****************************************************************************/
+time_t nt_time_to_unix(NTTIME nt)
+{
+	if (nt == 0) {
+		return 0;
+	}
+	if (nt == -1LL) {
+		return (time_t)-1;
+	}
+	nt += 1000*1000*10/2;
+	nt /= 1000*1000*10;
+	nt -= TIME_FIXUP_CONSTANT;
+
+	if (TIME_T_MIN > nt || nt > TIME_T_MAX) {
+		return 0;
+	}
+
+	return (time_t)nt;
+}
+
+
+/****************************************************************************
+put a 8 byte filetime from a time_t
+This takes GMT as input
+****************************************************************************/
+void unix_to_nt_time(NTTIME *nt, time_t t)
+{
+	uint64_t t2; 
+
+	if (t == (time_t)-1) {
+		*nt = (NTTIME)-1LL;
+		return;
+	}		
+	if (t == 0) {
+		*nt = 0;
+		return;
+	}		
+
+	t2 = t;
+	t2 += TIME_FIXUP_CONSTANT;
+	t2 *= 1000*1000*10;
+
+	*nt = t2;
+}
+
+
+/****************************************************************************
+check if it's a null unix time
+****************************************************************************/
+BOOL null_time(time_t t)
+{
+	return t == 0 || 
+		t == (time_t)0xFFFFFFFF || 
+		t == (time_t)-1;
+}
+
+
+/****************************************************************************
+check if it's a null NTTIME
+****************************************************************************/
+BOOL null_nttime(NTTIME t)
+{
+	return t == 0 || t == (NTTIME)-1;
+}
+
+/*******************************************************************
+  create a 16 bit dos packed date
+********************************************************************/
+static uint16_t make_dos_date1(struct tm *t)
+{
+	uint16_t ret=0;
+	ret = (((uint_t)(t->tm_mon+1)) >> 3) | ((t->tm_year-80) << 1);
+	ret = ((ret&0xFF)<<8) | (t->tm_mday | (((t->tm_mon+1) & 0x7) << 5));
+	return ret;
+}
+
+/*******************************************************************
+  create a 16 bit dos packed time
+********************************************************************/
+static uint16_t make_dos_time1(struct tm *t)
+{
+	uint16_t ret=0;
+	ret = ((((uint_t)t->tm_min >> 3)&0x7) | (((uint_t)t->tm_hour) << 3));
+	ret = ((ret&0xFF)<<8) | ((t->tm_sec/2) | ((t->tm_min & 0x7) << 5));
+	return ret;
+}
+
+/*******************************************************************
+  create a 32 bit dos packed date/time from some parameters
+  This takes a GMT time and returns a packed localtime structure
+********************************************************************/
+static uint32_t make_dos_date(time_t unixdate, int zone_offset)
+{
+	struct tm *t;
+	uint32_t ret=0;
+
+	if (unixdate == 0) {
+		return 0;
+	}
+
+	unixdate -= zone_offset;
+
+	t = gmtime(&unixdate);
+	if (!t) {
+		return 0xFFFFFFFF;
+	}
+
+	ret = make_dos_date1(t);
+	ret = ((ret&0xFFFF)<<16) | make_dos_time1(t);
+
+	return ret;
+}
+
+/*******************************************************************
+put a dos date into a buffer (time/date format)
+This takes GMT time and puts local time in the buffer
+********************************************************************/
+void push_dos_date(uint8_t *buf, int offset, time_t unixdate, int zone_offset)
+{
+	uint32_t x = make_dos_date(unixdate, zone_offset);
+	SIVAL(buf,offset,x);
+}
+
+/*******************************************************************
+put a dos date into a buffer (date/time format)
+This takes GMT time and puts local time in the buffer
+********************************************************************/
+void push_dos_date2(uint8_t *buf,int offset,time_t unixdate, int zone_offset)
+{
+	uint32_t x;
+	x = make_dos_date(unixdate, zone_offset);
+	x = ((x&0xFFFF)<<16) | ((x&0xFFFF0000)>>16);
+	SIVAL(buf,offset,x);
+}
+
+/*******************************************************************
+put a dos 32 bit "unix like" date into a buffer. This routine takes
+GMT and converts it to LOCAL time before putting it (most SMBs assume
+localtime for this sort of date)
+********************************************************************/
+void push_dos_date3(uint8_t *buf,int offset,time_t unixdate, int zone_offset)
+{
+	if (!null_time(unixdate)) {
+		unixdate -= zone_offset;
+	}
+	SIVAL(buf,offset,unixdate);
+}
+
+/*******************************************************************
+  interpret a 32 bit dos packed date/time to some parameters
+********************************************************************/
+static void interpret_dos_date(uint32_t date,int *year,int *month,int *day,int *hour,int *minute,int *second)
+{
+	uint32_t p0,p1,p2,p3;
+
+	p0=date&0xFF; p1=((date&0xFF00)>>8)&0xFF; 
+	p2=((date&0xFF0000)>>16)&0xFF; p3=((date&0xFF000000)>>24)&0xFF;
+
+	*second = 2*(p0 & 0x1F);
+	*minute = ((p0>>5)&0xFF) + ((p1&0x7)<<3);
+	*hour = (p1>>3)&0xFF;
+	*day = (p2&0x1F);
+	*month = ((p2>>5)&0xFF) + ((p3&0x1)<<3) - 1;
+	*year = ((p3>>1)&0xFF) + 80;
+}
+
+/*******************************************************************
+  create a unix date (int GMT) from a dos date (which is actually in
+  localtime)
+********************************************************************/
+time_t pull_dos_date(const uint8_t *date_ptr, int zone_offset)
+{
+	uint32_t dos_date=0;
+	struct tm t;
+	time_t ret;
+
+	dos_date = IVAL(date_ptr,0);
+
+	if (dos_date == 0) return (time_t)0;
+  
+	interpret_dos_date(dos_date,&t.tm_year,&t.tm_mon,
+			   &t.tm_mday,&t.tm_hour,&t.tm_min,&t.tm_sec);
+	t.tm_isdst = -1;
+  
+	ret = timegm(&t);
+
+	ret += zone_offset;
+
+	return ret;
+}
+
+/*******************************************************************
+like make_unix_date() but the words are reversed
+********************************************************************/
+time_t pull_dos_date2(const uint8_t *date_ptr, int zone_offset)
+{
+	uint32_t x,x2;
+
+	x = IVAL(date_ptr,0);
+	x2 = ((x&0xFFFF)<<16) | ((x&0xFFFF0000)>>16);
+	SIVAL(&x,0,x2);
+
+	return pull_dos_date((void *)&x, zone_offset);
+}
+
+/*******************************************************************
+  create a unix GMT date from a dos date in 32 bit "unix like" format
+  these generally arrive as localtimes, with corresponding DST
+  ******************************************************************/
+time_t pull_dos_date3(const uint8_t *date_ptr, int zone_offset)
+{
+	time_t t = (time_t)IVAL(date_ptr,0);
+	if (!null_time(t)) {
+		t += zone_offset;
+	}
+	return t;
+}
+
+
+/***************************************************************************
+return a HTTP/1.0 time string
+  ***************************************************************************/
+char *http_timestring(TALLOC_CTX *mem_ctx, time_t t)
+{
+	char *buf;
+	char tempTime[60];
+	struct tm *tm = localtime(&t);
+
+	if (!tm) {
+		return talloc_asprintf(mem_ctx,"%ld seconds since the Epoch",(long)t);
+	}
+
+#ifndef HAVE_STRFTIME
+	buf = talloc_strdup(mem_ctx, asctime(tm));
+	if (buf[strlen(buf)-1] == '\n') {
+		buf[strlen(buf)-1] = 0;
+	}
+#else
+	strftime(tempTime, sizeof(tempTime)-1, "%a, %d %b %Y %H:%M:%S %Z", tm);
+	buf = talloc_strdup(mem_ctx, tempTime);
+#endif /* !HAVE_STRFTIME */
+
+	return buf;
+}
+
+/****************************************************************************
+ Return the date and time as a string
+****************************************************************************/
+char *timestring(TALLOC_CTX *mem_ctx, time_t t)
+{
+	char *TimeBuf;
+	char tempTime[80];
+	struct tm *tm;
+
+	tm = localtime(&t);
+	if (!tm) {
+		return talloc_asprintf(mem_ctx,
+				       "%ld seconds since the Epoch",
+				       (long)t);
+	}
+
+#ifdef HAVE_STRFTIME
+	/* some versions of gcc complain about using %c. This is a bug
+	   in the gcc warning, not a bug in this code. See a recent
+	   strftime() manual page for details.
+	 */
+	strftime(tempTime,sizeof(tempTime)-1,"%c %Z",tm);
+	TimeBuf = talloc_strdup(mem_ctx, tempTime);
+#else
+	TimeBuf = talloc_strdup(mem_ctx, asctime(tm));
+#endif
+
+	return TimeBuf;
+}
+
+/*
+  return a talloced string representing a NTTIME for human consumption
+*/
+const char *nt_time_string(TALLOC_CTX *mem_ctx, NTTIME nt)
+{
+	time_t t;
+	if (nt == 0) {
+		return "NTTIME(0)";
+	}
+	t = nt_time_to_unix(nt);
+	return timestring(mem_ctx, t);
+}
+
+
+/*
+  put a NTTIME into a packet
+*/
+void push_nttime(uint8_t *base, uint16_t offset, NTTIME t)
+{
+	SBVAL(base, offset,   t);
+}
+
+/*
+  pull a NTTIME from a packet
+*/
+NTTIME pull_nttime(uint8_t *base, uint16_t offset)
+{
+	NTTIME ret = BVAL(base, offset);
+	return ret;
+}
+
+/*
+  parse a nttime as a large integer in a string and return a NTTIME
+*/
+NTTIME nttime_from_string(const char *s)
+{
+	return strtoull(s, NULL, 0);
+}
+
+/*
+  return (tv1 - tv2) in microseconds
+*/
+int64_t usec_time_diff(struct timeval *tv1, struct timeval *tv2)
+{
+	int64_t sec_diff = tv1->tv_sec - tv2->tv_sec;
+	return (sec_diff * 1000000) + (int64_t)(tv1->tv_usec - tv2->tv_usec);
+}
+
+
+/*
+  return a zero timeval
+*/
+struct timeval timeval_zero(void)
+{
+	struct timeval tv;
+	tv.tv_sec = 0;
+	tv.tv_usec = 0;
+	return tv;
+}
+
+/*
+  return True if a timeval is zero
+*/
+BOOL timeval_is_zero(const struct timeval *tv)
+{
+	return tv->tv_sec == 0 && tv->tv_usec == 0;
+}
+
+/*
+  return a timeval for the current time
+*/
+struct timeval timeval_current(void)
+{
+	struct timeval tv;
+	GetTimeOfDay(&tv);
+	return tv;
+}
+
+/*
+  return a timeval struct with the given elements
+*/
+struct timeval timeval_set(uint32_t secs, uint32_t usecs)
+{
+	struct timeval tv;
+	tv.tv_sec = secs;
+	tv.tv_usec = usecs;
+	return tv;
+}
+
+
+/*
+  return a timeval ofs microseconds after tv
+*/
+struct timeval timeval_add(const struct timeval *tv,
+			   uint32_t secs, uint32_t usecs)
+{
+	struct timeval tv2 = *tv;
+	const uint_t million = 1000000;
+	tv2.tv_sec += secs;
+	tv2.tv_usec += usecs;
+	tv2.tv_sec += tv2.tv_usec / million;
+	tv2.tv_usec = tv2.tv_usec % million;
+	return tv2;
+}
+
+/*
+  return the sum of two timeval structures
+*/
+struct timeval timeval_sum(const struct timeval *tv1,
+			   const struct timeval *tv2)
+{
+	return timeval_add(tv1, tv2->tv_sec, tv2->tv_usec);
+}
+
+/*
+  return a timeval secs/usecs into the future
+*/
+struct timeval timeval_current_ofs(uint32_t secs, uint32_t usecs)
+{
+	struct timeval tv = timeval_current();
+	return timeval_add(&tv, secs, usecs);
+}
+
+/*
+  compare two timeval structures. 
+  Return -1 if tv1 < tv2
+  Return 0 if tv1 == tv2
+  Return 1 if tv1 > tv2
+*/
+int timeval_compare(const struct timeval *tv1, const struct timeval *tv2)
+{
+	if (tv1->tv_sec  > tv2->tv_sec)  return 1;
+	if (tv1->tv_sec  < tv2->tv_sec)  return -1;
+	if (tv1->tv_usec > tv2->tv_usec) return 1;
+	if (tv1->tv_usec < tv2->tv_usec) return -1;
+	return 0;
+}
+
+/*
+  return True if a timer is in the past
+*/
+BOOL timeval_expired(const struct timeval *tv)
+{
+	struct timeval tv2 = timeval_current();
+	if (tv2.tv_sec > tv->tv_sec) return True;
+	if (tv2.tv_sec < tv->tv_sec) return False;
+	return (tv2.tv_usec >= tv->tv_usec);
+}
+
+/*
+  return the number of seconds elapsed between two times
+*/
+double timeval_elapsed2(const struct timeval *tv1, const struct timeval *tv2)
+{
+	return (tv2->tv_sec - tv1->tv_sec) + 
+	       (tv2->tv_usec - tv1->tv_usec)*1.0e-6;
+}
+
+/*
+  return the number of seconds elapsed since a given time
+*/
+double timeval_elapsed(const struct timeval *tv)
+{
+	struct timeval tv2 = timeval_current();
+	return timeval_elapsed2(tv, &tv2);
+}
+
+/*
+  return the lesser of two timevals
+*/
+struct timeval timeval_min(const struct timeval *tv1,
+			   const struct timeval *tv2)
+{
+	if (tv1->tv_sec < tv2->tv_sec) return *tv1;
+	if (tv1->tv_sec > tv2->tv_sec) return *tv2;
+	if (tv1->tv_usec < tv2->tv_usec) return *tv1;
+	return *tv2;
+}
+
+/*
+  return the greater of two timevals
+*/
+struct timeval timeval_max(const struct timeval *tv1,
+			   const struct timeval *tv2)
+{
+	if (tv1->tv_sec > tv2->tv_sec) return *tv1;
+	if (tv1->tv_sec < tv2->tv_sec) return *tv2;
+	if (tv1->tv_usec > tv2->tv_usec) return *tv1;
+	return *tv2;
+}
+
+/*
+  return the difference between two timevals as a timeval
+  if tv1 comes after tv2, then return a zero timeval
+  (this is *tv2 - *tv1)
+*/
+struct timeval timeval_until(const struct timeval *tv1,
+			     const struct timeval *tv2)
+{
+	struct timeval t;
+	if (timeval_compare(tv1, tv2) >= 0) {
+		return timeval_zero();
+	}
+	t.tv_sec = tv2->tv_sec - tv1->tv_sec;
+	if (tv1->tv_usec > tv2->tv_usec) {
+		t.tv_sec--;
+		t.tv_usec = 1000000 - (tv1->tv_usec - tv2->tv_usec);
+	} else {
+		t.tv_usec = tv2->tv_usec - tv1->tv_usec;
+	}
+	return t;
+}
+
+
+/*
+  convert a timeval to a NTTIME
+*/
+NTTIME timeval_to_nttime(const struct timeval *tv)
+{
+	return 10*(tv->tv_usec + 
+		  ((TIME_FIXUP_CONSTANT + (uint64_t)tv->tv_sec) * 1000000));
+}
+
+/*******************************************************************
+yield the difference between *A and *B, in seconds, ignoring leap seconds
+********************************************************************/
+static int tm_diff(struct tm *a, struct tm *b)
+{
+	int ay = a->tm_year + (1900 - 1);
+	int by = b->tm_year + (1900 - 1);
+	int intervening_leap_days =
+		(ay/4 - by/4) - (ay/100 - by/100) + (ay/400 - by/400);
+	int years = ay - by;
+	int days = 365*years + intervening_leap_days + (a->tm_yday - b->tm_yday);
+	int hours = 24*days + (a->tm_hour - b->tm_hour);
+	int minutes = 60*hours + (a->tm_min - b->tm_min);
+	int seconds = 60*minutes + (a->tm_sec - b->tm_sec);
+
+	return seconds;
+}
+
+/*******************************************************************
+  return the UTC offset in seconds west of UTC, or 0 if it cannot be determined
+  ******************************************************************/
+int get_time_zone(time_t t)
+{
+	struct tm *tm = gmtime(&t);
+	struct tm tm_utc;
+	if (!tm)
+		return 0;
+	tm_utc = *tm;
+	tm = localtime(&t);
+	if (!tm)
+		return 0;
+	return tm_diff(&tm_utc,tm);
+}
-- 
cgit 


From aa04388943fe5d7d8c873a6ee8a4cc9af2491532 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Tue, 28 Feb 2006 13:12:39 +0000
Subject: r13752: Add doxyfile and fix formatting of comments. Current output
 is available at http://samba.org/~jelmer/util-api/ (This used to be commit
 90812203df151a5e62394306827c72adfe13c63c)

---
 source4/lib/util/time.c | 105 +++++++++++++++++++++++++-----------------------
 1 file changed, 55 insertions(+), 50 deletions(-)

(limited to 'source4/lib/util/time.c')

diff --git a/source4/lib/util/time.c b/source4/lib/util/time.c
index 7721a2c456..a56175cda9 100644
--- a/source4/lib/util/time.c
+++ b/source4/lib/util/time.c
@@ -23,6 +23,11 @@
 #include "includes.h"
 #include "system/time.h"
 
+/**
+ * @file
+ * @brief time handling functions
+ */
+
 #ifndef TIME_T_MIN
 /* we use 0 here, because (time_t)-1 means error */
 #define TIME_T_MIN 0
@@ -37,17 +42,17 @@
 #define TIME_T_MAX MIN(INT32_MAX,_TYPE_MAXIMUM(time_t))
 #endif
 
-/*******************************************************************
+/**
  External access to time_t_min and time_t_max.
-********************************************************************/
+**/
 time_t get_time_t_max(void)
 {
 	return TIME_T_MAX;
 }
 
-/*******************************************************************
+/**
 a gettimeofday wrapper
-********************************************************************/
+**/
 void GetTimeOfDay(struct timeval *tval)
 {
 #ifdef HAVE_GETTIMEOFDAY_TZ
@@ -60,10 +65,10 @@ void GetTimeOfDay(struct timeval *tval)
 
 #define TIME_FIXUP_CONSTANT 11644473600LL
 
-/****************************************************************************
+/**
 interpret an 8 byte "filetime" structure to a time_t
 It's originally in "100ns units since jan 1st 1601"
-****************************************************************************/
+**/
 time_t nt_time_to_unix(NTTIME nt)
 {
 	if (nt == 0) {
@@ -84,10 +89,10 @@ time_t nt_time_to_unix(NTTIME nt)
 }
 
 
-/****************************************************************************
+/**
 put a 8 byte filetime from a time_t
 This takes GMT as input
-****************************************************************************/
+**/
 void unix_to_nt_time(NTTIME *nt, time_t t)
 {
 	uint64_t t2; 
@@ -109,9 +114,9 @@ void unix_to_nt_time(NTTIME *nt, time_t t)
 }
 
 
-/****************************************************************************
+/**
 check if it's a null unix time
-****************************************************************************/
+**/
 BOOL null_time(time_t t)
 {
 	return t == 0 || 
@@ -120,9 +125,9 @@ BOOL null_time(time_t t)
 }
 
 
-/****************************************************************************
+/**
 check if it's a null NTTIME
-****************************************************************************/
+**/
 BOOL null_nttime(NTTIME t)
 {
 	return t == 0 || t == (NTTIME)-1;
@@ -176,20 +181,20 @@ static uint32_t make_dos_date(time_t unixdate, int zone_offset)
 	return ret;
 }
 
-/*******************************************************************
+/**
 put a dos date into a buffer (time/date format)
 This takes GMT time and puts local time in the buffer
-********************************************************************/
+**/
 void push_dos_date(uint8_t *buf, int offset, time_t unixdate, int zone_offset)
 {
 	uint32_t x = make_dos_date(unixdate, zone_offset);
 	SIVAL(buf,offset,x);
 }
 
-/*******************************************************************
+/**
 put a dos date into a buffer (date/time format)
 This takes GMT time and puts local time in the buffer
-********************************************************************/
+**/
 void push_dos_date2(uint8_t *buf,int offset,time_t unixdate, int zone_offset)
 {
 	uint32_t x;
@@ -198,11 +203,11 @@ void push_dos_date2(uint8_t *buf,int offset,time_t unixdate, int zone_offset)
 	SIVAL(buf,offset,x);
 }
 
-/*******************************************************************
+/**
 put a dos 32 bit "unix like" date into a buffer. This routine takes
 GMT and converts it to LOCAL time before putting it (most SMBs assume
 localtime for this sort of date)
-********************************************************************/
+**/
 void push_dos_date3(uint8_t *buf,int offset,time_t unixdate, int zone_offset)
 {
 	if (!null_time(unixdate)) {
@@ -229,10 +234,10 @@ static void interpret_dos_date(uint32_t date,int *year,int *month,int *day,int *
 	*year = ((p3>>1)&0xFF) + 80;
 }
 
-/*******************************************************************
+/**
   create a unix date (int GMT) from a dos date (which is actually in
   localtime)
-********************************************************************/
+**/
 time_t pull_dos_date(const uint8_t *date_ptr, int zone_offset)
 {
 	uint32_t dos_date=0;
@@ -254,9 +259,9 @@ time_t pull_dos_date(const uint8_t *date_ptr, int zone_offset)
 	return ret;
 }
 
-/*******************************************************************
+/**
 like make_unix_date() but the words are reversed
-********************************************************************/
+**/
 time_t pull_dos_date2(const uint8_t *date_ptr, int zone_offset)
 {
 	uint32_t x,x2;
@@ -268,10 +273,10 @@ time_t pull_dos_date2(const uint8_t *date_ptr, int zone_offset)
 	return pull_dos_date((void *)&x, zone_offset);
 }
 
-/*******************************************************************
+/**
   create a unix GMT date from a dos date in 32 bit "unix like" format
   these generally arrive as localtimes, with corresponding DST
-  ******************************************************************/
+**/
 time_t pull_dos_date3(const uint8_t *date_ptr, int zone_offset)
 {
 	time_t t = (time_t)IVAL(date_ptr,0);
@@ -282,9 +287,9 @@ time_t pull_dos_date3(const uint8_t *date_ptr, int zone_offset)
 }
 
 
-/***************************************************************************
+/**
 return a HTTP/1.0 time string
-  ***************************************************************************/
+**/
 char *http_timestring(TALLOC_CTX *mem_ctx, time_t t)
 {
 	char *buf;
@@ -308,9 +313,9 @@ char *http_timestring(TALLOC_CTX *mem_ctx, time_t t)
 	return buf;
 }
 
-/****************************************************************************
+/**
  Return the date and time as a string
-****************************************************************************/
+**/
 char *timestring(TALLOC_CTX *mem_ctx, time_t t)
 {
 	char *TimeBuf;
@@ -338,7 +343,7 @@ char *timestring(TALLOC_CTX *mem_ctx, time_t t)
 	return TimeBuf;
 }
 
-/*
+/**
   return a talloced string representing a NTTIME for human consumption
 */
 const char *nt_time_string(TALLOC_CTX *mem_ctx, NTTIME nt)
@@ -352,7 +357,7 @@ const char *nt_time_string(TALLOC_CTX *mem_ctx, NTTIME nt)
 }
 
 
-/*
+/**
   put a NTTIME into a packet
 */
 void push_nttime(uint8_t *base, uint16_t offset, NTTIME t)
@@ -360,7 +365,7 @@ void push_nttime(uint8_t *base, uint16_t offset, NTTIME t)
 	SBVAL(base, offset,   t);
 }
 
-/*
+/**
   pull a NTTIME from a packet
 */
 NTTIME pull_nttime(uint8_t *base, uint16_t offset)
@@ -369,7 +374,7 @@ NTTIME pull_nttime(uint8_t *base, uint16_t offset)
 	return ret;
 }
 
-/*
+/**
   parse a nttime as a large integer in a string and return a NTTIME
 */
 NTTIME nttime_from_string(const char *s)
@@ -377,7 +382,7 @@ NTTIME nttime_from_string(const char *s)
 	return strtoull(s, NULL, 0);
 }
 
-/*
+/**
   return (tv1 - tv2) in microseconds
 */
 int64_t usec_time_diff(struct timeval *tv1, struct timeval *tv2)
@@ -387,7 +392,7 @@ int64_t usec_time_diff(struct timeval *tv1, struct timeval *tv2)
 }
 
 
-/*
+/**
   return a zero timeval
 */
 struct timeval timeval_zero(void)
@@ -398,7 +403,7 @@ struct timeval timeval_zero(void)
 	return tv;
 }
 
-/*
+/**
   return True if a timeval is zero
 */
 BOOL timeval_is_zero(const struct timeval *tv)
@@ -406,7 +411,7 @@ BOOL timeval_is_zero(const struct timeval *tv)
 	return tv->tv_sec == 0 && tv->tv_usec == 0;
 }
 
-/*
+/**
   return a timeval for the current time
 */
 struct timeval timeval_current(void)
@@ -416,7 +421,7 @@ struct timeval timeval_current(void)
 	return tv;
 }
 
-/*
+/**
   return a timeval struct with the given elements
 */
 struct timeval timeval_set(uint32_t secs, uint32_t usecs)
@@ -428,7 +433,7 @@ struct timeval timeval_set(uint32_t secs, uint32_t usecs)
 }
 
 
-/*
+/**
   return a timeval ofs microseconds after tv
 */
 struct timeval timeval_add(const struct timeval *tv,
@@ -443,7 +448,7 @@ struct timeval timeval_add(const struct timeval *tv,
 	return tv2;
 }
 
-/*
+/**
   return the sum of two timeval structures
 */
 struct timeval timeval_sum(const struct timeval *tv1,
@@ -452,7 +457,7 @@ struct timeval timeval_sum(const struct timeval *tv1,
 	return timeval_add(tv1, tv2->tv_sec, tv2->tv_usec);
 }
 
-/*
+/**
   return a timeval secs/usecs into the future
 */
 struct timeval timeval_current_ofs(uint32_t secs, uint32_t usecs)
@@ -461,7 +466,7 @@ struct timeval timeval_current_ofs(uint32_t secs, uint32_t usecs)
 	return timeval_add(&tv, secs, usecs);
 }
 
-/*
+/**
   compare two timeval structures. 
   Return -1 if tv1 < tv2
   Return 0 if tv1 == tv2
@@ -476,7 +481,7 @@ int timeval_compare(const struct timeval *tv1, const struct timeval *tv2)
 	return 0;
 }
 
-/*
+/**
   return True if a timer is in the past
 */
 BOOL timeval_expired(const struct timeval *tv)
@@ -487,7 +492,7 @@ BOOL timeval_expired(const struct timeval *tv)
 	return (tv2.tv_usec >= tv->tv_usec);
 }
 
-/*
+/**
   return the number of seconds elapsed between two times
 */
 double timeval_elapsed2(const struct timeval *tv1, const struct timeval *tv2)
@@ -496,7 +501,7 @@ double timeval_elapsed2(const struct timeval *tv1, const struct timeval *tv2)
 	       (tv2->tv_usec - tv1->tv_usec)*1.0e-6;
 }
 
-/*
+/**
   return the number of seconds elapsed since a given time
 */
 double timeval_elapsed(const struct timeval *tv)
@@ -505,7 +510,7 @@ double timeval_elapsed(const struct timeval *tv)
 	return timeval_elapsed2(tv, &tv2);
 }
 
-/*
+/**
   return the lesser of two timevals
 */
 struct timeval timeval_min(const struct timeval *tv1,
@@ -517,7 +522,7 @@ struct timeval timeval_min(const struct timeval *tv1,
 	return *tv2;
 }
 
-/*
+/**
   return the greater of two timevals
 */
 struct timeval timeval_max(const struct timeval *tv1,
@@ -529,7 +534,7 @@ struct timeval timeval_max(const struct timeval *tv1,
 	return *tv2;
 }
 
-/*
+/**
   return the difference between two timevals as a timeval
   if tv1 comes after tv2, then return a zero timeval
   (this is *tv2 - *tv1)
@@ -552,7 +557,7 @@ struct timeval timeval_until(const struct timeval *tv1,
 }
 
 
-/*
+/**
   convert a timeval to a NTTIME
 */
 NTTIME timeval_to_nttime(const struct timeval *tv)
@@ -579,9 +584,9 @@ static int tm_diff(struct tm *a, struct tm *b)
 	return seconds;
 }
 
-/*******************************************************************
+/**
   return the UTC offset in seconds west of UTC, or 0 if it cannot be determined
-  ******************************************************************/
+ */
 int get_time_zone(time_t t)
 {
 	struct tm *tm = gmtime(&t);
-- 
cgit 


From af30a32b6924b0f2b701186e435defbca2ebd1aa Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Sun, 5 Mar 2006 17:15:19 +0000
Subject: r13840: Mark some functions as public. (This used to be commit
 9a188eb1f48a50d92a67a4fc2b3899b90074059a)

---
 source4/lib/util/time.c | 68 ++++++++++++++++++++++++-------------------------
 1 file changed, 34 insertions(+), 34 deletions(-)

(limited to 'source4/lib/util/time.c')

diff --git a/source4/lib/util/time.c b/source4/lib/util/time.c
index a56175cda9..4897d2fa95 100644
--- a/source4/lib/util/time.c
+++ b/source4/lib/util/time.c
@@ -45,7 +45,7 @@
 /**
  External access to time_t_min and time_t_max.
 **/
-time_t get_time_t_max(void)
+_PUBLIC_ time_t get_time_t_max(void)
 {
 	return TIME_T_MAX;
 }
@@ -53,7 +53,7 @@ time_t get_time_t_max(void)
 /**
 a gettimeofday wrapper
 **/
-void GetTimeOfDay(struct timeval *tval)
+_PUBLIC_ void GetTimeOfDay(struct timeval *tval)
 {
 #ifdef HAVE_GETTIMEOFDAY_TZ
 	gettimeofday(tval,NULL);
@@ -69,7 +69,7 @@ void GetTimeOfDay(struct timeval *tval)
 interpret an 8 byte "filetime" structure to a time_t
 It's originally in "100ns units since jan 1st 1601"
 **/
-time_t nt_time_to_unix(NTTIME nt)
+_PUBLIC_ time_t nt_time_to_unix(NTTIME nt)
 {
 	if (nt == 0) {
 		return 0;
@@ -93,7 +93,7 @@ time_t nt_time_to_unix(NTTIME nt)
 put a 8 byte filetime from a time_t
 This takes GMT as input
 **/
-void unix_to_nt_time(NTTIME *nt, time_t t)
+_PUBLIC_ void unix_to_nt_time(NTTIME *nt, time_t t)
 {
 	uint64_t t2; 
 
@@ -117,7 +117,7 @@ void unix_to_nt_time(NTTIME *nt, time_t t)
 /**
 check if it's a null unix time
 **/
-BOOL null_time(time_t t)
+_PUBLIC_ BOOL null_time(time_t t)
 {
 	return t == 0 || 
 		t == (time_t)0xFFFFFFFF || 
@@ -128,7 +128,7 @@ BOOL null_time(time_t t)
 /**
 check if it's a null NTTIME
 **/
-BOOL null_nttime(NTTIME t)
+_PUBLIC_ BOOL null_nttime(NTTIME t)
 {
 	return t == 0 || t == (NTTIME)-1;
 }
@@ -185,7 +185,7 @@ static uint32_t make_dos_date(time_t unixdate, int zone_offset)
 put a dos date into a buffer (time/date format)
 This takes GMT time and puts local time in the buffer
 **/
-void push_dos_date(uint8_t *buf, int offset, time_t unixdate, int zone_offset)
+_PUBLIC_ void push_dos_date(uint8_t *buf, int offset, time_t unixdate, int zone_offset)
 {
 	uint32_t x = make_dos_date(unixdate, zone_offset);
 	SIVAL(buf,offset,x);
@@ -195,7 +195,7 @@ void push_dos_date(uint8_t *buf, int offset, time_t unixdate, int zone_offset)
 put a dos date into a buffer (date/time format)
 This takes GMT time and puts local time in the buffer
 **/
-void push_dos_date2(uint8_t *buf,int offset,time_t unixdate, int zone_offset)
+_PUBLIC_ void push_dos_date2(uint8_t *buf,int offset,time_t unixdate, int zone_offset)
 {
 	uint32_t x;
 	x = make_dos_date(unixdate, zone_offset);
@@ -208,7 +208,7 @@ put a dos 32 bit "unix like" date into a buffer. This routine takes
 GMT and converts it to LOCAL time before putting it (most SMBs assume
 localtime for this sort of date)
 **/
-void push_dos_date3(uint8_t *buf,int offset,time_t unixdate, int zone_offset)
+_PUBLIC_ void push_dos_date3(uint8_t *buf,int offset,time_t unixdate, int zone_offset)
 {
 	if (!null_time(unixdate)) {
 		unixdate -= zone_offset;
@@ -238,7 +238,7 @@ static void interpret_dos_date(uint32_t date,int *year,int *month,int *day,int *
   create a unix date (int GMT) from a dos date (which is actually in
   localtime)
 **/
-time_t pull_dos_date(const uint8_t *date_ptr, int zone_offset)
+_PUBLIC_ time_t pull_dos_date(const uint8_t *date_ptr, int zone_offset)
 {
 	uint32_t dos_date=0;
 	struct tm t;
@@ -262,7 +262,7 @@ time_t pull_dos_date(const uint8_t *date_ptr, int zone_offset)
 /**
 like make_unix_date() but the words are reversed
 **/
-time_t pull_dos_date2(const uint8_t *date_ptr, int zone_offset)
+_PUBLIC_ time_t pull_dos_date2(const uint8_t *date_ptr, int zone_offset)
 {
 	uint32_t x,x2;
 
@@ -277,7 +277,7 @@ time_t pull_dos_date2(const uint8_t *date_ptr, int zone_offset)
   create a unix GMT date from a dos date in 32 bit "unix like" format
   these generally arrive as localtimes, with corresponding DST
 **/
-time_t pull_dos_date3(const uint8_t *date_ptr, int zone_offset)
+_PUBLIC_ time_t pull_dos_date3(const uint8_t *date_ptr, int zone_offset)
 {
 	time_t t = (time_t)IVAL(date_ptr,0);
 	if (!null_time(t)) {
@@ -290,7 +290,7 @@ time_t pull_dos_date3(const uint8_t *date_ptr, int zone_offset)
 /**
 return a HTTP/1.0 time string
 **/
-char *http_timestring(TALLOC_CTX *mem_ctx, time_t t)
+_PUBLIC_ char *http_timestring(TALLOC_CTX *mem_ctx, time_t t)
 {
 	char *buf;
 	char tempTime[60];
@@ -316,7 +316,7 @@ char *http_timestring(TALLOC_CTX *mem_ctx, time_t t)
 /**
  Return the date and time as a string
 **/
-char *timestring(TALLOC_CTX *mem_ctx, time_t t)
+_PUBLIC_ char *timestring(TALLOC_CTX *mem_ctx, time_t t)
 {
 	char *TimeBuf;
 	char tempTime[80];
@@ -346,7 +346,7 @@ char *timestring(TALLOC_CTX *mem_ctx, time_t t)
 /**
   return a talloced string representing a NTTIME for human consumption
 */
-const char *nt_time_string(TALLOC_CTX *mem_ctx, NTTIME nt)
+_PUBLIC_ const char *nt_time_string(TALLOC_CTX *mem_ctx, NTTIME nt)
 {
 	time_t t;
 	if (nt == 0) {
@@ -360,7 +360,7 @@ const char *nt_time_string(TALLOC_CTX *mem_ctx, NTTIME nt)
 /**
   put a NTTIME into a packet
 */
-void push_nttime(uint8_t *base, uint16_t offset, NTTIME t)
+_PUBLIC_ void push_nttime(uint8_t *base, uint16_t offset, NTTIME t)
 {
 	SBVAL(base, offset,   t);
 }
@@ -368,7 +368,7 @@ void push_nttime(uint8_t *base, uint16_t offset, NTTIME t)
 /**
   pull a NTTIME from a packet
 */
-NTTIME pull_nttime(uint8_t *base, uint16_t offset)
+_PUBLIC_ NTTIME pull_nttime(uint8_t *base, uint16_t offset)
 {
 	NTTIME ret = BVAL(base, offset);
 	return ret;
@@ -377,7 +377,7 @@ NTTIME pull_nttime(uint8_t *base, uint16_t offset)
 /**
   parse a nttime as a large integer in a string and return a NTTIME
 */
-NTTIME nttime_from_string(const char *s)
+_PUBLIC_ NTTIME nttime_from_string(const char *s)
 {
 	return strtoull(s, NULL, 0);
 }
@@ -385,7 +385,7 @@ NTTIME nttime_from_string(const char *s)
 /**
   return (tv1 - tv2) in microseconds
 */
-int64_t usec_time_diff(struct timeval *tv1, struct timeval *tv2)
+_PUBLIC_ int64_t usec_time_diff(struct timeval *tv1, struct timeval *tv2)
 {
 	int64_t sec_diff = tv1->tv_sec - tv2->tv_sec;
 	return (sec_diff * 1000000) + (int64_t)(tv1->tv_usec - tv2->tv_usec);
@@ -395,7 +395,7 @@ int64_t usec_time_diff(struct timeval *tv1, struct timeval *tv2)
 /**
   return a zero timeval
 */
-struct timeval timeval_zero(void)
+_PUBLIC_ struct timeval timeval_zero(void)
 {
 	struct timeval tv;
 	tv.tv_sec = 0;
@@ -406,7 +406,7 @@ struct timeval timeval_zero(void)
 /**
   return True if a timeval is zero
 */
-BOOL timeval_is_zero(const struct timeval *tv)
+_PUBLIC_ BOOL timeval_is_zero(const struct timeval *tv)
 {
 	return tv->tv_sec == 0 && tv->tv_usec == 0;
 }
@@ -414,7 +414,7 @@ BOOL timeval_is_zero(const struct timeval *tv)
 /**
   return a timeval for the current time
 */
-struct timeval timeval_current(void)
+_PUBLIC_ struct timeval timeval_current(void)
 {
 	struct timeval tv;
 	GetTimeOfDay(&tv);
@@ -424,7 +424,7 @@ struct timeval timeval_current(void)
 /**
   return a timeval struct with the given elements
 */
-struct timeval timeval_set(uint32_t secs, uint32_t usecs)
+_PUBLIC_ struct timeval timeval_set(uint32_t secs, uint32_t usecs)
 {
 	struct timeval tv;
 	tv.tv_sec = secs;
@@ -436,7 +436,7 @@ struct timeval timeval_set(uint32_t secs, uint32_t usecs)
 /**
   return a timeval ofs microseconds after tv
 */
-struct timeval timeval_add(const struct timeval *tv,
+_PUBLIC_ struct timeval timeval_add(const struct timeval *tv,
 			   uint32_t secs, uint32_t usecs)
 {
 	struct timeval tv2 = *tv;
@@ -460,7 +460,7 @@ struct timeval timeval_sum(const struct timeval *tv1,
 /**
   return a timeval secs/usecs into the future
 */
-struct timeval timeval_current_ofs(uint32_t secs, uint32_t usecs)
+_PUBLIC_ struct timeval timeval_current_ofs(uint32_t secs, uint32_t usecs)
 {
 	struct timeval tv = timeval_current();
 	return timeval_add(&tv, secs, usecs);
@@ -472,7 +472,7 @@ struct timeval timeval_current_ofs(uint32_t secs, uint32_t usecs)
   Return 0 if tv1 == tv2
   Return 1 if tv1 > tv2
 */
-int timeval_compare(const struct timeval *tv1, const struct timeval *tv2)
+_PUBLIC_ int timeval_compare(const struct timeval *tv1, const struct timeval *tv2)
 {
 	if (tv1->tv_sec  > tv2->tv_sec)  return 1;
 	if (tv1->tv_sec  < tv2->tv_sec)  return -1;
@@ -484,7 +484,7 @@ int timeval_compare(const struct timeval *tv1, const struct timeval *tv2)
 /**
   return True if a timer is in the past
 */
-BOOL timeval_expired(const struct timeval *tv)
+_PUBLIC_ BOOL timeval_expired(const struct timeval *tv)
 {
 	struct timeval tv2 = timeval_current();
 	if (tv2.tv_sec > tv->tv_sec) return True;
@@ -495,7 +495,7 @@ BOOL timeval_expired(const struct timeval *tv)
 /**
   return the number of seconds elapsed between two times
 */
-double timeval_elapsed2(const struct timeval *tv1, const struct timeval *tv2)
+_PUBLIC_ double timeval_elapsed2(const struct timeval *tv1, const struct timeval *tv2)
 {
 	return (tv2->tv_sec - tv1->tv_sec) + 
 	       (tv2->tv_usec - tv1->tv_usec)*1.0e-6;
@@ -504,7 +504,7 @@ double timeval_elapsed2(const struct timeval *tv1, const struct timeval *tv2)
 /**
   return the number of seconds elapsed since a given time
 */
-double timeval_elapsed(const struct timeval *tv)
+_PUBLIC_ double timeval_elapsed(const struct timeval *tv)
 {
 	struct timeval tv2 = timeval_current();
 	return timeval_elapsed2(tv, &tv2);
@@ -513,7 +513,7 @@ double timeval_elapsed(const struct timeval *tv)
 /**
   return the lesser of two timevals
 */
-struct timeval timeval_min(const struct timeval *tv1,
+_PUBLIC_ struct timeval timeval_min(const struct timeval *tv1,
 			   const struct timeval *tv2)
 {
 	if (tv1->tv_sec < tv2->tv_sec) return *tv1;
@@ -525,7 +525,7 @@ struct timeval timeval_min(const struct timeval *tv1,
 /**
   return the greater of two timevals
 */
-struct timeval timeval_max(const struct timeval *tv1,
+_PUBLIC_ struct timeval timeval_max(const struct timeval *tv1,
 			   const struct timeval *tv2)
 {
 	if (tv1->tv_sec > tv2->tv_sec) return *tv1;
@@ -539,7 +539,7 @@ struct timeval timeval_max(const struct timeval *tv1,
   if tv1 comes after tv2, then return a zero timeval
   (this is *tv2 - *tv1)
 */
-struct timeval timeval_until(const struct timeval *tv1,
+_PUBLIC_ struct timeval timeval_until(const struct timeval *tv1,
 			     const struct timeval *tv2)
 {
 	struct timeval t;
@@ -560,7 +560,7 @@ struct timeval timeval_until(const struct timeval *tv1,
 /**
   convert a timeval to a NTTIME
 */
-NTTIME timeval_to_nttime(const struct timeval *tv)
+_PUBLIC_ NTTIME timeval_to_nttime(const struct timeval *tv)
 {
 	return 10*(tv->tv_usec + 
 		  ((TIME_FIXUP_CONSTANT + (uint64_t)tv->tv_sec) * 1000000));
@@ -587,7 +587,7 @@ static int tm_diff(struct tm *a, struct tm *b)
 /**
   return the UTC offset in seconds west of UTC, or 0 if it cannot be determined
  */
-int get_time_zone(time_t t)
+_PUBLIC_ int get_time_zone(time_t t)
 {
 	struct tm *tm = gmtime(&t);
 	struct tm tm_utc;
-- 
cgit 


From b56789c3491d227dd4107a37de701101c780a0f9 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Fri, 5 May 2006 13:02:14 +0000
Subject: r15457: Get rid of more usages of uint_t (This used to be commit
 849818dcdeb8eaf2eb22fea3896a4f7c777d8c5f)

---
 source4/lib/util/time.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'source4/lib/util/time.c')

diff --git a/source4/lib/util/time.c b/source4/lib/util/time.c
index 4897d2fa95..6ad3a229e3 100644
--- a/source4/lib/util/time.c
+++ b/source4/lib/util/time.c
@@ -139,7 +139,7 @@ _PUBLIC_ BOOL null_nttime(NTTIME t)
 static uint16_t make_dos_date1(struct tm *t)
 {
 	uint16_t ret=0;
-	ret = (((uint_t)(t->tm_mon+1)) >> 3) | ((t->tm_year-80) << 1);
+	ret = (((unsigned int)(t->tm_mon+1)) >> 3) | ((t->tm_year-80) << 1);
 	ret = ((ret&0xFF)<<8) | (t->tm_mday | (((t->tm_mon+1) & 0x7) << 5));
 	return ret;
 }
@@ -150,7 +150,7 @@ static uint16_t make_dos_date1(struct tm *t)
 static uint16_t make_dos_time1(struct tm *t)
 {
 	uint16_t ret=0;
-	ret = ((((uint_t)t->tm_min >> 3)&0x7) | (((uint_t)t->tm_hour) << 3));
+	ret = ((((unsigned int)t->tm_min >> 3)&0x7) | (((unsigned int)t->tm_hour) << 3));
 	ret = ((ret&0xFF)<<8) | ((t->tm_sec/2) | ((t->tm_min & 0x7) << 5));
 	return ret;
 }
@@ -440,7 +440,7 @@ _PUBLIC_ struct timeval timeval_add(const struct timeval *tv,
 			   uint32_t secs, uint32_t usecs)
 {
 	struct timeval tv2 = *tv;
-	const uint_t million = 1000000;
+	const unsigned int million = 1000000;
 	tv2.tv_sec += secs;
 	tv2.tv_usec += usecs;
 	tv2.tv_sec += tv2.tv_usec / million;
-- 
cgit 


From d630105b563aca913750200ea6e9ad17241ac51d Mon Sep 17 00:00:00 2001
From: Rafal Szczesniak <mimir@samba.org>
Date: Mon, 18 Sep 2006 17:32:13 +0000
Subject: r18614: a bit of work done while on the plane.

a new function converting NTTIME to struct timeval

rafal
(This used to be commit e9ebbb8661ac6efc5bf07798a64cdb9f7c7eea50)
---
 source4/lib/util/time.c | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

(limited to 'source4/lib/util/time.c')

diff --git a/source4/lib/util/time.c b/source4/lib/util/time.c
index 6ad3a229e3..d3cdecdfe3 100644
--- a/source4/lib/util/time.c
+++ b/source4/lib/util/time.c
@@ -566,6 +566,28 @@ _PUBLIC_ NTTIME timeval_to_nttime(const struct timeval *tv)
 		  ((TIME_FIXUP_CONSTANT + (uint64_t)tv->tv_sec) * 1000000));
 }
 
+/**
+  convert a NTTIME to a timeval
+*/
+_PUBLIC_ void nttime_to_timeval(struct timeval *tv, NTTIME t)
+{
+	if (tv == NULL) return;
+
+	t += 10/2;
+	t /= 10;
+	t -= TIME_FIXUP_CONSTANT*1000*1000;
+
+	tv->tv_sec  = t / 1000000;
+
+	if (TIME_T_MIN > tv->tv_sec || tv->tv_sec > TIME_T_MAX) {
+		tv->tv_sec  = 0;
+		tv->tv_usec = 0;
+		return;
+	}
+	
+	tv->tv_usec = t - tv->tv_sec*1000000;
+}
+
 /*******************************************************************
 yield the difference between *A and *B, in seconds, ignoring leap seconds
 ********************************************************************/
-- 
cgit 


From 0479a2f1cbae51fcd8dbdc3c148c808421fb4d25 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Tue, 10 Jul 2007 02:07:03 +0000
Subject: r23792: convert Samba4 to GPLv3

There are still a few tidyups of old FSF addresses to come (in both s3
and s4). More commits soon.
(This used to be commit fcf38a38ac691abd0fa51b89dc951a08e89fdafa)
---
 source4/lib/util/time.c | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

(limited to 'source4/lib/util/time.c')

diff --git a/source4/lib/util/time.c b/source4/lib/util/time.c
index d3cdecdfe3..e5d7e2bca5 100644
--- a/source4/lib/util/time.c
+++ b/source4/lib/util/time.c
@@ -7,7 +7,7 @@
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
+   the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
    
    This program is distributed in the hope that it will be useful,
@@ -16,8 +16,7 @@
    GNU General Public License for more details.
    
    You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "includes.h"
-- 
cgit 


From 4fb038b0b8e7a4bb69ac0d9022684eeaca8a491a Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Mon, 27 Aug 2007 17:21:16 +0000
Subject: r24710: Use standard boolean type for easier use by external users.
 (This used to be commit 99f4124137d4a61216e8189f26d4da32882c0f4a)

---
 source4/lib/util/time.c | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

(limited to 'source4/lib/util/time.c')

diff --git a/source4/lib/util/time.c b/source4/lib/util/time.c
index e5d7e2bca5..c800fffea0 100644
--- a/source4/lib/util/time.c
+++ b/source4/lib/util/time.c
@@ -116,7 +116,7 @@ _PUBLIC_ void unix_to_nt_time(NTTIME *nt, time_t t)
 /**
 check if it's a null unix time
 **/
-_PUBLIC_ BOOL null_time(time_t t)
+_PUBLIC_ bool null_time(time_t t)
 {
 	return t == 0 || 
 		t == (time_t)0xFFFFFFFF || 
@@ -127,7 +127,7 @@ _PUBLIC_ BOOL null_time(time_t t)
 /**
 check if it's a null NTTIME
 **/
-_PUBLIC_ BOOL null_nttime(NTTIME t)
+_PUBLIC_ bool null_nttime(NTTIME t)
 {
 	return t == 0 || t == (NTTIME)-1;
 }
@@ -403,9 +403,9 @@ _PUBLIC_ struct timeval timeval_zero(void)
 }
 
 /**
-  return True if a timeval is zero
+  return true if a timeval is zero
 */
-_PUBLIC_ BOOL timeval_is_zero(const struct timeval *tv)
+_PUBLIC_ bool timeval_is_zero(const struct timeval *tv)
 {
 	return tv->tv_sec == 0 && tv->tv_usec == 0;
 }
@@ -481,13 +481,13 @@ _PUBLIC_ int timeval_compare(const struct timeval *tv1, const struct timeval *tv
 }
 
 /**
-  return True if a timer is in the past
+  return true if a timer is in the past
 */
-_PUBLIC_ BOOL timeval_expired(const struct timeval *tv)
+_PUBLIC_ bool timeval_expired(const struct timeval *tv)
 {
 	struct timeval tv2 = timeval_current();
-	if (tv2.tv_sec > tv->tv_sec) return True;
-	if (tv2.tv_sec < tv->tv_sec) return False;
+	if (tv2.tv_sec > tv->tv_sec) return true;
+	if (tv2.tv_sec < tv->tv_sec) return false;
 	return (tv2.tv_usec >= tv->tv_usec);
 }
 
-- 
cgit 


From bb84655d65bf22305cfab26a6b14b148cb060722 Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Tue, 4 Sep 2007 02:08:36 +0000
Subject: r24941: Simplify samdb_result_nttime(), and remove
 nttime_from_string()

Andrew Bartlett
(This used to be commit bcd994a139e2e8fb2e97c8b897c987ff234e0b0a)
---
 source4/lib/util/time.c | 8 --------
 1 file changed, 8 deletions(-)

(limited to 'source4/lib/util/time.c')

diff --git a/source4/lib/util/time.c b/source4/lib/util/time.c
index c800fffea0..4601833a3d 100644
--- a/source4/lib/util/time.c
+++ b/source4/lib/util/time.c
@@ -373,14 +373,6 @@ _PUBLIC_ NTTIME pull_nttime(uint8_t *base, uint16_t offset)
 	return ret;
 }
 
-/**
-  parse a nttime as a large integer in a string and return a NTTIME
-*/
-_PUBLIC_ NTTIME nttime_from_string(const char *s)
-{
-	return strtoull(s, NULL, 0);
-}
-
 /**
   return (tv1 - tv2) in microseconds
 */
-- 
cgit 


From cd962355abad90a2161765a7be7d26e63572cab7 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Fri, 7 Sep 2007 15:08:14 +0000
Subject: r25000: Fix some more C++ compatibility warnings. (This used to be
 commit 08bb1ef643ab906f1645cf6f32763dc73b1884e4)

---
 source4/lib/util/time.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source4/lib/util/time.c')

diff --git a/source4/lib/util/time.c b/source4/lib/util/time.c
index 4601833a3d..fc51498009 100644
--- a/source4/lib/util/time.c
+++ b/source4/lib/util/time.c
@@ -269,7 +269,7 @@ _PUBLIC_ time_t pull_dos_date2(const uint8_t *date_ptr, int zone_offset)
 	x2 = ((x&0xFFFF)<<16) | ((x&0xFFFF0000)>>16);
 	SIVAL(&x,0,x2);
 
-	return pull_dos_date((void *)&x, zone_offset);
+	return pull_dos_date((const uint8_t *)&x, zone_offset);
 }
 
 /**
-- 
cgit 


From 3525f77e56966d688a11e3f4520e9cd799fd4f23 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Sat, 9 Feb 2008 14:24:24 +0100
Subject: Move nt_time_equal() to libutil. (This used to be commit
 9705263a6c58d4ade556d17db2009dbb85291b22)

---
 source4/lib/util/time.c | 8 ++++++++
 1 file changed, 8 insertions(+)

(limited to 'source4/lib/util/time.c')

diff --git a/source4/lib/util/time.c b/source4/lib/util/time.c
index fc51498009..a181885806 100644
--- a/source4/lib/util/time.c
+++ b/source4/lib/util/time.c
@@ -612,3 +612,11 @@ _PUBLIC_ int get_time_zone(time_t t)
 		return 0;
 	return tm_diff(&tm_utc,tm);
 }
+
+/**
+  check if 2 NTTIMEs are equal.
+*/
+bool nt_time_equal(NTTIME *t1, NTTIME *t2)
+{
+	return *t1 == *t2;
+}
-- 
cgit 


From 9a975a868e949e61cb011422363cd07b4ec0ce43 Mon Sep 17 00:00:00 2001
From: James Peach <jpeach@samba.org>
Date: Tue, 20 May 2008 10:54:45 -0700
Subject: smbtorture: Add RAW-BENCH-TCON benchmark.

Add a simple test to benchmark the rate at which a server can accept
new tree connections. You can tune the length of time to run the
benchmark for and the number of parallel connections to make.
(This used to be commit ea3f4b93057e85c4ea516cc77dd0f293016d520c)
---
 source4/lib/util/time.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source4/lib/util/time.c')

diff --git a/source4/lib/util/time.c b/source4/lib/util/time.c
index a181885806..978d73cc0a 100644
--- a/source4/lib/util/time.c
+++ b/source4/lib/util/time.c
@@ -376,7 +376,7 @@ _PUBLIC_ NTTIME pull_nttime(uint8_t *base, uint16_t offset)
 /**
   return (tv1 - tv2) in microseconds
 */
-_PUBLIC_ int64_t usec_time_diff(struct timeval *tv1, struct timeval *tv2)
+_PUBLIC_ int64_t usec_time_diff(const struct timeval *tv1, const struct timeval *tv2)
 {
 	int64_t sec_diff = tv1->tv_sec - tv2->tv_sec;
 	return (sec_diff * 1000000) + (int64_t)(tv1->tv_usec - tv2->tv_usec);
-- 
cgit