2012-09-18 22:56:03 +04:00
/*
2002-01-30 09:08:46 +03:00
Unix SMB / CIFS implementation .
1996-05-31 19:13:29 +04:00
time handling functions
2006-09-06 22:32:20 +04:00
Copyright ( C ) Andrew Tridgell 1992 - 2004
2012-09-18 22:56:03 +04:00
Copyright ( C ) Stefan ( metze ) Metzmacher 2002
2007-03-06 02:40:03 +03:00
Copyright ( C ) Jeremy Allison 2007
2006-09-06 22:32:20 +04:00
1996-05-31 19:13:29 +04:00
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
2007-07-09 23:25:36 +04:00
the Free Software Foundation ; either version 3 of the License , or
1996-05-31 19:13:29 +04:00
( at your option ) any later version .
2012-09-18 22:56:03 +04:00
1996-05-31 19:13:29 +04:00
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 .
2012-09-18 22:56:03 +04:00
1996-05-31 19:13:29 +04:00
You should have received a copy of the GNU General Public License
2007-07-10 04:52:41 +04:00
along with this program . If not , see < http : //www.gnu.org/licenses/>.
1996-05-31 19:13:29 +04:00
*/
# include "includes.h"
2006-09-06 22:32:20 +04:00
/**
* @ file
* @ brief time handling functions
*/
1996-05-31 19:13:29 +04:00
2007-03-01 23:52:14 +03:00
# define NTTIME_INFINITY (NTTIME)0x8000000000000000LL
2006-08-25 00:51:57 +04:00
# if (SIZEOF_LONG == 8)
# define TIME_FIXUP_CONSTANT_INT 11644473600L
# elif (SIZEOF_LONG_LONG == 8)
# define TIME_FIXUP_CONSTANT_INT 11644473600LL
# endif
1996-05-31 19:13:29 +04:00
2006-08-24 20:44:00 +04:00
2006-09-06 22:32:20 +04:00
/**
parse a nttime as a large integer in a string and return a NTTIME
*/
NTTIME nttime_from_string ( const char * s )
2005-09-30 21:13:37 +04:00
{
2006-09-06 22:32:20 +04:00
return strtoull ( s , NULL , 0 ) ;
2005-09-30 21:13:37 +04:00
}
2007-05-19 03:38:56 +04:00
/**************************************************************
Handle conversions between time_t and uint32 , taking care to
preserve the " special " values .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2010-05-21 04:38:04 +04:00
uint32_t convert_time_t_to_uint32_t ( time_t t )
2007-05-19 03:38:56 +04:00
{
# if (defined(SIZEOF_TIME_T) && (SIZEOF_TIME_T == 8))
/* time_t is 64-bit. */
if ( t = = 0x8000000000000000LL ) {
return 0x80000000 ;
} else if ( t = = 0x7FFFFFFFFFFFFFFFLL ) {
return 0x7FFFFFFF ;
}
# endif
2008-10-22 05:41:24 +04:00
return ( uint32_t ) t ;
2007-05-19 03:38:56 +04:00
}
2010-05-21 04:38:04 +04:00
time_t convert_uint32_t_to_time_t ( uint32_t u )
2007-05-19 03:38:56 +04:00
{
# if (defined(SIZEOF_TIME_T) && (SIZEOF_TIME_T == 8))
/* time_t is 64-bit. */
if ( u = = 0x80000000 ) {
return ( time_t ) 0x8000000000000000LL ;
} else if ( u = = 0x7FFFFFFF ) {
2007-05-19 03:56:34 +04:00
return ( time_t ) 0x7FFFFFFFFFFFFFFFLL ;
2007-05-19 03:38:56 +04:00
}
# endif
return ( time_t ) u ;
}
2005-11-05 07:21:55 +03:00
/****************************************************************************
2006-09-06 22:32:20 +04:00
Check if NTTIME is 0.
2005-11-05 07:21:55 +03:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2007-10-19 04:40:25 +04:00
bool nt_time_is_zero ( const NTTIME * nt )
2005-09-30 21:13:37 +04:00
{
2006-09-06 22:32:20 +04:00
return ( * nt = = 0 ) ;
2005-09-30 21:13:37 +04:00
}
2005-03-24 02:26:33 +03:00
/****************************************************************************
2005-11-05 07:21:55 +03:00
Convert ASN .1 GeneralizedTime string to unix - time .
2012-09-18 22:56:03 +04:00
Returns 0 on failure ; Currently ignores timezone .
2005-03-24 02:26:33 +03:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2005-11-05 07:21:55 +03:00
2005-03-24 02:26:33 +03:00
time_t generalized_to_unix_time ( const char * str )
2012-09-18 22:56:03 +04:00
{
2005-03-24 02:26:33 +03:00
struct tm tm ;
ZERO_STRUCT ( tm ) ;
2012-09-18 22:56:03 +04:00
if ( sscanf ( str , " %4d%2d%2d%2d%2d%2d " ,
& tm . tm_year , & tm . tm_mon , & tm . tm_mday ,
2005-03-24 02:26:33 +03:00
& tm . tm_hour , & tm . tm_min , & tm . tm_sec ) ! = 6 ) {
return 0 ;
}
tm . tm_year - = 1900 ;
tm . tm_mon - = 1 ;
return timegm ( & tm ) ;
}
2006-02-10 04:43:33 +03:00
2006-09-06 22:32:20 +04:00
/*******************************************************************
Accessor function for the server time zone offset .
set_server_zone_offset ( ) must have been called first .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2006-02-10 04:43:33 +03:00
2006-09-06 22:32:20 +04:00
static int server_zone_offset ;
2006-02-10 04:43:33 +03:00
2006-09-06 22:32:20 +04:00
int get_server_zone_offset ( void )
{
return server_zone_offset ;
2006-02-10 04:43:33 +03:00
}
2006-09-06 22:32:20 +04:00
/*******************************************************************
Initialize the server time zone offset . Called when a client connects .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
int set_server_zone_offset ( time_t t )
2006-08-24 20:44:00 +04:00
{
2006-09-06 22:32:20 +04:00
server_zone_offset = get_time_zone ( t ) ;
return server_zone_offset ;
2006-08-24 20:44:00 +04:00
}
2006-09-06 22:32:20 +04:00
/***************************************************************************
Server versions of the above functions .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void srv_put_dos_date ( char * buf , int offset , time_t unixdate )
2006-08-24 20:44:00 +04:00
{
2010-01-08 13:03:31 +03:00
push_dos_date ( ( uint8_t * ) buf , offset , unixdate , server_zone_offset ) ;
2006-09-06 22:32:20 +04:00
}
void srv_put_dos_date2 ( char * buf , int offset , time_t unixdate )
{
2010-01-08 13:03:31 +03:00
push_dos_date2 ( ( uint8_t * ) buf , offset , unixdate , server_zone_offset ) ;
2006-09-06 22:32:20 +04:00
}
void srv_put_dos_date3 ( char * buf , int offset , time_t unixdate )
{
2010-01-08 13:03:31 +03:00
push_dos_date3 ( ( uint8_t * ) buf , offset , unixdate , server_zone_offset ) ;
2006-09-06 22:32:20 +04:00
}
2009-08-25 07:57:37 +04:00
void round_timespec ( enum timestamp_set_resolution res , struct timespec * ts )
{
switch ( res ) {
case TIMESTAMP_SET_SECONDS :
round_timespec_to_sec ( ts ) ;
break ;
case TIMESTAMP_SET_MSEC :
round_timespec_to_usec ( ts ) ;
break ;
case TIMESTAMP_SET_NT_OR_BETTER :
/* No rounding needed. */
break ;
}
}
2006-09-06 22:32:20 +04:00
/****************************************************************************
2012-09-18 22:56:03 +04:00
Take a Unix time and convert to an NTTIME structure and place in buffer
2009-08-25 07:57:37 +04:00
pointed to by p , rounded to the correct resolution .
2006-09-06 22:32:20 +04:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2009-08-25 07:57:37 +04:00
void put_long_date_timespec ( enum timestamp_set_resolution res , char * p , struct timespec ts )
2006-09-06 22:32:20 +04:00
{
NTTIME nt ;
2009-08-25 07:57:37 +04:00
round_timespec ( res , & ts ) ;
2014-06-18 16:21:06 +04:00
nt = unix_timespec_to_nt_time ( ts ) ;
2012-09-19 01:35:39 +04:00
SBVAL ( p , 0 , nt ) ;
2006-09-06 22:32:20 +04:00
}
void put_long_date ( char * p , time_t t )
{
struct timespec ts ;
ts . tv_sec = t ;
ts . tv_nsec = 0 ;
2009-08-25 07:57:37 +04:00
put_long_date_timespec ( TIMESTAMP_SET_SECONDS , p , ts ) ;
2006-08-24 20:44:00 +04:00
}
2006-09-06 22:32:20 +04:00
void dos_filetime_timespec ( struct timespec * tsp )
2006-07-11 22:01:26 +04:00
{
2006-09-06 22:32:20 +04:00
tsp - > tv_sec & = ~ 1 ;
tsp - > tv_nsec = 0 ;
2006-07-11 22:01:26 +04:00
}
2006-09-06 22:32:20 +04:00
/*******************************************************************
Create a unix date ( int GMT ) from a dos date ( which is actually in
localtime ) .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2006-06-15 01:36:49 +04:00
2010-08-05 15:06:11 +04:00
time_t make_unix_date ( const void * date_ptr , int zone_offset )
2006-06-15 01:36:49 +04:00
{
2011-10-26 10:54:11 +04:00
return pull_dos_date ( date_ptr , zone_offset ) ;
2006-09-06 22:32:20 +04:00
}
/*******************************************************************
Like make_unix_date ( ) but the words are reversed .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2009-05-06 03:28:44 +04:00
time_t make_unix_date2 ( const void * date_ptr , int zone_offset )
2006-09-06 22:32:20 +04:00
{
2011-10-26 10:54:11 +04:00
return pull_dos_date2 ( date_ptr , zone_offset ) ;
2006-09-06 22:32:20 +04:00
}
/*******************************************************************
Create a unix GMT date from a dos date in 32 bit " unix like " format
these generally arrive as localtimes , with corresponding DST .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2009-05-06 07:59:22 +04:00
time_t make_unix_date3 ( const void * date_ptr , int zone_offset )
2006-09-06 22:32:20 +04:00
{
2011-10-26 10:54:11 +04:00
return pull_dos_date3 ( date_ptr , zone_offset ) ;
2006-09-06 22:32:20 +04:00
}
2007-01-30 22:26:01 +03:00
time_t srv_make_unix_date ( const void * date_ptr )
2006-09-06 22:32:20 +04:00
{
return make_unix_date ( date_ptr , server_zone_offset ) ;
}
2007-01-30 22:26:01 +03:00
time_t srv_make_unix_date2 ( const void * date_ptr )
2006-09-06 22:32:20 +04:00
{
return make_unix_date2 ( date_ptr , server_zone_offset ) ;
}
2007-01-30 22:26:01 +03:00
time_t srv_make_unix_date3 ( const void * date_ptr )
2006-09-06 22:32:20 +04:00
{
return make_unix_date3 ( date_ptr , server_zone_offset ) ;
}
/****************************************************************************
Interprets an nt time into a unix struct timespec .
Differs from nt_time_to_unix in that an 8 byte value of 0xffffffffffffffff
will be returned as ( time_t ) - 1 , whereas nt_time_to_unix returns 0 in this case .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2007-01-30 22:26:01 +03:00
struct timespec interpret_long_date ( const char * p )
2006-09-06 22:32:20 +04:00
{
NTTIME nt ;
2014-06-16 19:00:33 +04:00
nt = BVAL ( p , 0 ) ;
2006-09-06 22:32:20 +04:00
if ( nt = = ( uint64_t ) - 1 ) {
struct timespec ret ;
ret . tv_sec = ( time_t ) - 1 ;
ret . tv_nsec = 0 ;
return ret ;
}
2014-06-18 16:21:06 +04:00
return nt_time_to_unix_timespec ( nt ) ;
2006-09-06 22:32:20 +04:00
}
/*******************************************************************
Re - read the smb serverzone value .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
static struct timeval start_time_hires ;
void TimeInit ( void )
{
set_server_zone_offset ( time ( NULL ) ) ;
DEBUG ( 4 , ( " TimeInit: Serverzone is %d \n " , server_zone_offset ) ) ;
/* Save the start time of this process. */
if ( start_time_hires . tv_sec = = 0 & & start_time_hires . tv_usec = = 0 ) {
GetTimeOfDay ( & start_time_hires ) ;
}
}
/**********************************************************************
Return a timeval struct of the uptime of this process . As TimeInit is
done before a daemon fork then this is the start time from the parent
daemon start . JRA .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void get_process_uptime ( struct timeval * ret_time )
{
struct timeval time_now_hires ;
GetTimeOfDay ( & time_now_hires ) ;
ret_time - > tv_sec = time_now_hires . tv_sec - start_time_hires . tv_sec ;
if ( time_now_hires . tv_usec < start_time_hires . tv_usec ) {
ret_time - > tv_sec - = 1 ;
ret_time - > tv_usec = 1000000 + ( time_now_hires . tv_usec - start_time_hires . tv_usec ) ;
} else {
ret_time - > tv_usec = time_now_hires . tv_usec - start_time_hires . tv_usec ;
}
}
2010-04-22 14:33:29 +04:00
/**
* @ brief Get the startup time of the server .
*
* @ param [ out ] ret_time A pointer to a timveal structure to set the startup
* time .
*/
void get_startup_time ( struct timeval * ret_time )
{
ret_time - > tv_sec = start_time_hires . tv_sec ;
ret_time - > tv_usec = start_time_hires . tv_usec ;
}
2006-09-06 22:32:20 +04:00
/****************************************************************************
Convert a NTTIME structure to a time_t .
It ' s originally in " 100ns units " .
This is an absolute version of the one above .
By absolute I mean , it doesn ' t adjust from 1 / 1 / 1601 to 1 / 1 / 1970
if the NTTIME was 5 seconds , the time_t is 5 seconds . JFM
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
time_t nt_time_to_unix_abs ( const NTTIME * nt )
{
2008-10-22 05:41:24 +04:00
uint64_t d ;
2006-09-06 22:32:20 +04:00
if ( * nt = = 0 ) {
return ( time_t ) 0 ;
}
2008-10-22 05:41:24 +04:00
if ( * nt = = ( uint64_t ) - 1 ) {
2006-09-06 22:32:20 +04:00
return ( time_t ) - 1 ;
}
2007-03-01 23:52:14 +03:00
if ( * nt = = NTTIME_INFINITY ) {
return ( time_t ) - 1 ;
}
2006-09-06 22:32:20 +04:00
/* reverse the time */
/* it's a negative value, turn it to positive */
d = ~ * nt ;
d + = 1000 * 1000 * 10 / 2 ;
d / = 1000 * 1000 * 10 ;
if ( ! ( TIME_T_MIN < = ( ( time_t ) d ) & & ( ( time_t ) d ) < = TIME_T_MAX ) ) {
return ( time_t ) 0 ;
}
return ( time_t ) d ;
}
2008-06-16 15:36:53 +04:00
time_t uint64s_nt_time_to_unix_abs ( const uint64_t * src )
{
NTTIME nttime ;
nttime = * src ;
return nt_time_to_unix_abs ( & nttime ) ;
}
2006-09-06 22:32:20 +04:00
/****************************************************************************
Convert a time_t to a NTTIME structure
This is an absolute version of the one above .
By absolute I mean , it doesn ' t adjust from 1 / 1 / 1970 to 1 / 1 / 1601
2007-01-12 05:48:37 +03:00
If the time_t was 5 seconds , the NTTIME is 5 seconds . JFM
2006-09-06 22:32:20 +04:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void unix_to_nt_time_abs ( NTTIME * nt , time_t t )
{
double d ;
if ( t = = 0 ) {
* nt = 0 ;
return ;
}
if ( t = = TIME_T_MAX ) {
* nt = 0x7fffffffffffffffLL ;
return ;
}
2012-09-18 22:56:03 +04:00
2006-09-06 22:32:20 +04:00
if ( t = = ( time_t ) - 1 ) {
/* that's what NT uses for infinite */
2007-03-01 23:52:14 +03:00
* nt = NTTIME_INFINITY ;
2006-09-06 22:32:20 +04:00
return ;
2012-09-18 22:56:03 +04:00
}
2006-09-06 22:32:20 +04:00
d = ( double ) ( t ) ;
d * = 1.0e7 ;
2007-12-21 00:17:16 +03:00
* nt = ( NTTIME ) d ;
2006-09-06 22:32:20 +04:00
/* convert to a negative value */
* nt = ~ * nt ;
}
/****************************************************************************
Utility function that always returns a const string even if localtime
and asctime fail .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2007-03-06 02:40:03 +03:00
const char * time_to_asc ( const time_t t )
2006-09-06 22:32:20 +04:00
{
const char * asct ;
2007-03-06 02:40:03 +03:00
struct tm * lt = localtime ( & t ) ;
2006-09-06 22:32:20 +04:00
if ( ! lt ) {
return " unknown time " ;
}
asct = asctime ( lt ) ;
if ( ! asct ) {
return " unknown time " ;
}
return asct ;
}
const char * display_time ( NTTIME nttime )
{
float high ;
float low ;
int sec ;
int days , hours , mins , secs ;
if ( nttime = = 0 )
return " Now " ;
2007-03-01 23:52:14 +03:00
if ( nttime = = NTTIME_INFINITY )
2006-09-06 22:32:20 +04:00
return " Never " ;
2012-09-18 22:56:03 +04:00
high = 65536 ;
2006-09-06 22:32:20 +04:00
high = high / 10000 ;
high = high * 65536 ;
high = high / 1000 ;
high = high * ( ~ ( nttime > > 32 ) ) ;
low = ~ ( nttime & 0xFFFFFFFF ) ;
low = low / ( 1000 * 1000 * 10 ) ;
2007-12-21 00:17:16 +03:00
sec = ( int ) ( high + low ) ;
2006-09-06 22:32:20 +04:00
days = sec / ( 60 * 60 * 24 ) ;
hours = ( sec - ( days * 60 * 60 * 24 ) ) / ( 60 * 60 ) ;
mins = ( sec - ( days * 60 * 60 * 24 ) - ( hours * 60 * 60 ) ) / 60 ;
secs = sec - ( days * 60 * 60 * 24 ) - ( hours * 60 * 60 ) - ( mins * 60 ) ;
2007-09-04 14:15:04 +04:00
return talloc_asprintf ( talloc_tos ( ) , " %u days, %u hours, %u minutes, "
" %u seconds " , days , hours , mins , secs ) ;
2006-09-06 22:32:20 +04:00
}
2007-10-19 04:40:25 +04:00
bool nt_time_is_set ( const NTTIME * nt )
2006-09-06 22:32:20 +04:00
{
if ( * nt = = 0x7FFFFFFFFFFFFFFFLL ) {
2008-10-22 05:41:24 +04:00
return false ;
2006-09-06 22:32:20 +04:00
}
2007-03-01 23:52:14 +03:00
if ( * nt = = NTTIME_INFINITY ) {
2008-10-22 05:41:24 +04:00
return false ;
2006-09-06 22:32:20 +04:00
}
2008-10-22 05:41:24 +04:00
return true ;
2006-09-06 22:32:20 +04:00
}