upstream/openldap
1
0
Fork 0
mirror of https://git.openldap.org/openldap/openldap.git synced 2025-12-20 22:59:34 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

ITS#9513 Change all lutil time structs to use nanoseconds

Browse source 
Instead of microseconds
This commit is contained in:
Howard Chu 2021-03-23 16:03:13 +00:00 committed by Quanah Gibson-Mount
parent 9ac3909ead
commit 94fbd96826
10 changed files with 98 additions and 47 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
configure.ac
View file

@ -2371,6 +2371,7 @@ fi
AC_CHECK_FUNCS( \ AC_CHECK_FUNCS( \
bcopy \ bcopy \
clock_gettime \
closesocket \ closesocket \
chroot \ chroot \
endgrent \ endgrent \

2
contrib/slapd-modules/smbk5pwd/smbk5pwd.c
View file

@ -289,7 +289,7 @@ static int k5key_chk(
struct lutil_tm tm; struct lutil_tm tm;
struct lutil_timet tt; struct lutil_timet tt;
if ( lutil_parsetime( a->a_vals[0].bv_val, &tm ) == 0 && if ( lutil_parsetime( a->a_vals[0].bv_val, &tm ) == 0 &&
lutil_tm2time( &tm, &tt ) == 0 && tt.tt_usec < op->o_time ) { lutil_tm2time( &tm, &tt ) == 0 && tt.tt_sec < op->o_time ) {
/* Account is expired */ /* Account is expired */
rc = LUTIL_PASSWD_ERR; rc = LUTIL_PASSWD_ERR;
break; break;

7
include/ac/time.h
View file

@ -29,4 +29,11 @@
# include <time.h> # include <time.h>
#endif #endif
#if defined(_WIN32) && !defined(HAVE_CLOCK_GETTIME)
struct timespec {
time_t tv_sec;
int tv_nsec;
};
#endif
#endif /* _AC_TIME_H */ #endif /* _AC_TIME_H */

7
include/ldap_pvt.h
View file

@ -131,6 +131,13 @@ ldap_pvt_gettime LDAP_P(( struct lutil_tm * ));
struct timeval; struct timeval;
LDAP_F( int ) LDAP_F( int )
ldap_pvt_gettimeofday LDAP_P(( struct timeval *tv, void *unused )); ldap_pvt_gettimeofday LDAP_P(( struct timeval *tv, void *unused ));
#ifndef CLOCK_REALTIME
#define CLOCK_REALTIME 0
#endif
#define clock_gettime(clkid,tv) ldap_pvt_clock_gettime(clkid,tv)
struct timespec;
LDAP_F( int )
ldap_pvt_clock_gettime LDAP_P(( int clkid, struct timespec *tv ));
#endif #endif
/* use this macro to allocate buffer for ldap_pvt_csnstr */ /* use this macro to allocate buffer for ldap_pvt_csnstr */

4
include/lutil.h
View file

@ -172,7 +172,7 @@ typedef struct lutil_tm {
int tm_mday; /* day 1-31 */ int tm_mday; /* day 1-31 */
int tm_mon; /* month 0-11 */ int tm_mon; /* month 0-11 */
int tm_year; /* year - 1900 */ int tm_year; /* year - 1900 */
int tm_usec; /* microseconds */ int tm_nsec; /* nanoseconds */
int tm_usub; /* submicro */ int tm_usub; /* submicro */
} lutil_tm; } lutil_tm;
@ -180,7 +180,7 @@ typedef struct lutil_timet {
unsigned int tt_sec; /* seconds since epoch, 0000 or 1970 */ unsigned int tt_sec; /* seconds since epoch, 0000 or 1970 */
int tt_gsec; /* seconds since epoch, high 7 bits, maybe sign-flipped */ int tt_gsec; /* seconds since epoch, high 7 bits, maybe sign-flipped */
/* sign flipped to sort properly as unsigned ints */ /* sign flipped to sort properly as unsigned ints */
unsigned int tt_usec; /* microseconds */ unsigned int tt_nsec; /* nanoseconds */
} lutil_timet; } lutil_timet;
/* Parse a timestamp string into a structure */ /* Parse a timestamp string into a structure */

93
libraries/libldap/util-int.c
View file

@ -178,7 +178,7 @@ static int _ldap_pvt_gt_subs;
#ifdef _WIN32 #ifdef _WIN32
/* Windows SYSTEMTIME only has 10 millisecond resolution, so we /* Windows SYSTEMTIME only has 10 millisecond resolution, so we
* also need to use a high resolution timer to get microseconds. * also need to use a high resolution timer to get nanoseconds.
* This is pretty clunky. * This is pretty clunky.
*/ */
static LARGE_INTEGER _ldap_pvt_gt_freq; static LARGE_INTEGER _ldap_pvt_gt_freq;
@ -187,9 +187,10 @@ static int _ldap_pvt_gt_offset;
#define SEC_TO_UNIX_EPOCH 11644473600LL #define SEC_TO_UNIX_EPOCH 11644473600LL
#define TICKS_PER_SECOND 10000000 #define TICKS_PER_SECOND 10000000
#define BILLION 1000000000L
static int static int
ldap_pvt_gettimeusec(int *sec) ldap_pvt_gettimensec(int *sec)
{ {
LARGE_INTEGER count; LARGE_INTEGER count;
@ -200,7 +201,7 @@ ldap_pvt_gettimeusec(int *sec)
*/ */
LDAP_MUTEX_LOCK( &ldap_int_gettime_mutex ); LDAP_MUTEX_LOCK( &ldap_int_gettime_mutex );
/* We assume Windows has at least a vague idea of /* We assume Windows has at least a vague idea of
* when a second begins. So we align our microsecond count * when a second begins. So we align our nanosecond count
* with the Windows millisecond count using this offset. * with the Windows millisecond count using this offset.
* We retain the submillisecond portion of our own count. * We retain the submillisecond portion of our own count.
* *
@ -214,7 +215,7 @@ ldap_pvt_gettimeusec(int *sec)
ULARGE_INTEGER ut; ULARGE_INTEGER ut;
FILETIME ft0, ft1; FILETIME ft0, ft1;
long long t; long long t;
int usec; int nsec;
/* Initialize our offset */ /* Initialize our offset */
QueryPerformanceFrequency( &_ldap_pvt_gt_freq ); QueryPerformanceFrequency( &_ldap_pvt_gt_freq );
@ -232,13 +233,13 @@ ldap_pvt_gettimeusec(int *sec)
/* get second and fraction portion of counter */ /* get second and fraction portion of counter */
t = c2.QuadPart % (_ldap_pvt_gt_freq.QuadPart*10); t = c2.QuadPart % (_ldap_pvt_gt_freq.QuadPart*10);
/* convert to microseconds */ /* convert to nanoseconds */
t *= 1000000; t *= BILLION;
usec = t / _ldap_pvt_gt_freq.QuadPart; nsec = t / _ldap_pvt_gt_freq.QuadPart;
ut.QuadPart /= 10; ut.QuadPart /= 10;
ut.QuadPart %= 10000000; ut.QuadPart %= (10 * BILLION);
_ldap_pvt_gt_offset = usec - ut.QuadPart; _ldap_pvt_gt_offset = nsec - ut.QuadPart;
count = c2; count = c2;
} }
if ( count.QuadPart <= _ldap_pvt_gt_prev.QuadPart ) { if ( count.QuadPart <= _ldap_pvt_gt_prev.QuadPart ) {
@ -249,28 +250,28 @@ ldap_pvt_gettimeusec(int *sec)
} }
LDAP_MUTEX_UNLOCK( &ldap_int_gettime_mutex ); LDAP_MUTEX_UNLOCK( &ldap_int_gettime_mutex );
/* convert to microseconds */ /* convert to nanoseconds */
count.QuadPart %= _ldap_pvt_gt_freq.QuadPart*10; count.QuadPart %= _ldap_pvt_gt_freq.QuadPart*10;
count.QuadPart *= 1000000; count.QuadPart *= BILLION;
count.QuadPart /= _ldap_pvt_gt_freq.QuadPart; count.QuadPart /= _ldap_pvt_gt_freq.QuadPart;
count.QuadPart -= _ldap_pvt_gt_offset; count.QuadPart -= _ldap_pvt_gt_offset;
/* We've extracted the 1s and microseconds. /* We've extracted the 1s and nanoseconds.
* The 1sec digit is used to detect wraparound in microsecnds. * The 1sec digit is used to detect wraparound in nanosecnds.
*/ */
if (count.QuadPart < 0) if (count.QuadPart < 0)
count.QuadPart += 10000000; count.QuadPart += (10 * BILLION);
else if (count.QuadPart >= 10000000) else if (count.QuadPart >= (10 * BILLION))
count.QuadPart -= 10000000; count.QuadPart -= (10 * BILLION);
*sec = count.QuadPart / 1000000; *sec = count.QuadPart / BILLION;
return count.QuadPart % 1000000; return count.QuadPart % BILLION;
} }
/* emulate POSIX gettimeofday */ /* emulate POSIX clock_gettime */
int int
ldap_pvt_gettimeofday( struct timeval *tv, void *unused ) ldap_pvt_clock_gettime( int clk_id, struct timespec *tv )
{ {
FILETIME ft; FILETIME ft;
ULARGE_INTEGER ut; ULARGE_INTEGER ut;
@ -280,11 +281,11 @@ ldap_pvt_gettimeofday( struct timeval *tv, void *unused )
ut.LowPart = ft.dwLowDateTime; ut.LowPart = ft.dwLowDateTime;
ut.HighPart = ft.dwHighDateTime; ut.HighPart = ft.dwHighDateTime;
/* convert to usec */ /* convert to sec */
ut.QuadPart /= (TICKS_PER_SECOND / 1000000); ut.QuadPart /= TICKS_PER_SECOND;
tv->tv_usec = ldap_pvt_gettimeusec(&sec); tv->tv_nsec = ldap_pvt_gettimensec(&sec);
tv->tv_sec = ut.QuadPart / 1000000 - SEC_TO_UNIX_EPOCH; tv->tv_sec = ut.QuadPart - SEC_TO_UNIX_EPOCH;
/* check for carry from microseconds */ /* check for carry from microseconds */
sec0 = tv->tv_sec % 10; sec0 = tv->tv_sec % 10;
@ -294,7 +295,20 @@ ldap_pvt_gettimeofday( struct timeval *tv, void *unused )
return 0; return 0;
} }
/* return a broken out time, with microseconds /* emulate POSIX gettimeofday */
int
ldap_pvt_gettimeofday( struct timeval *tv, void *unused )
int
{
struct timespec ts;
ldap_pvt_clock_gettime( 0, &ts );
tv->tv_sec = ts.tv_spec;
tv->tv_usec = ts.tv_nsec / 1000;
return 0;
}
/* return a broken out time, with nanoseconds
*/ */
void void
ldap_pvt_gettime( struct lutil_tm *tm ) ldap_pvt_gettime( struct lutil_tm *tm )
@ -305,10 +319,10 @@ ldap_pvt_gettime( struct lutil_tm *tm )
31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
GetSystemTime( &st ); GetSystemTime( &st );
tm->tm_usec = ldap_pvt_gettimeusec(&sec); tm->tm_nsec = ldap_pvt_gettimensec(&sec);
tm->tm_usub = _ldap_pvt_gt_subs; tm->tm_usub = _ldap_pvt_gt_subs;
/* any difference larger than microseconds is /* any difference larger than nanoseconds is
* already reflected in st * already reflected in st
*/ */
tm->tm_sec = st.wSecond; tm->tm_sec = st.wSecond;
@ -318,7 +332,7 @@ ldap_pvt_gettime( struct lutil_tm *tm )
tm->tm_mon = st.wMonth - 1; tm->tm_mon = st.wMonth - 1;
tm->tm_year = st.wYear - 1900; tm->tm_year = st.wYear - 1900;
/* check for carry from microseconds */ /* check for carry from nanoseconds */
sec0 = tm->tm_sec % 10; sec0 = tm->tm_sec % 10;
if (sec0 < sec || (sec0 == 9 && !sec)) { if (sec0 < sec || (sec0 == 9 && !sec)) {
tm->tm_sec++; tm->tm_sec++;
@ -357,23 +371,36 @@ ldap_pvt_gettime( struct lutil_tm *tm )
} }
#else #else
#ifdef HAVE_CLOCK_GETTIME
static struct timespec _ldap_pvt_gt_prevTv;
#else
static struct timeval _ldap_pvt_gt_prevTv; static struct timeval _ldap_pvt_gt_prevTv;
#endif
void void
ldap_pvt_gettime( struct lutil_tm *ltm ) ldap_pvt_gettime( struct lutil_tm *ltm )
{ {
struct timeval tv;
struct tm tm; struct tm tm;
time_t t; time_t t;
#ifdef HAVE_CLOCK_GETTIME
#define FRAC tv_nsec
#define NSECS(x) x
struct timespec tv;
clock_gettime( CLOCK_REALTIME, &tv );
#else
#define FRAC tv_usec
#define NSECS(x) x * 1000
struct timeval tv;
gettimeofday( &tv, NULL ); gettimeofday( &tv, NULL );
#endif
t = tv.tv_sec; t = tv.tv_sec;
LDAP_MUTEX_LOCK( &ldap_int_gettime_mutex ); LDAP_MUTEX_LOCK( &ldap_int_gettime_mutex );
if ( tv.tv_sec < _ldap_pvt_gt_prevTv.tv_sec if ( tv.tv_sec < _ldap_pvt_gt_prevTv.tv_sec
|| ( tv.tv_sec == _ldap_pvt_gt_prevTv.tv_sec || ( tv.tv_sec == _ldap_pvt_gt_prevTv.tv_sec
&& tv.tv_usec <= _ldap_pvt_gt_prevTv.tv_usec )) { && tv.FRAC <= _ldap_pvt_gt_prevTv.FRAC )) {
_ldap_pvt_gt_subs++; _ldap_pvt_gt_subs++;
} else { } else {
_ldap_pvt_gt_subs = 0; _ldap_pvt_gt_subs = 0;
@ -391,7 +418,7 @@ ldap_pvt_gettime( struct lutil_tm *ltm )
ltm->tm_mday = tm.tm_mday; ltm->tm_mday = tm.tm_mday;
ltm->tm_mon = tm.tm_mon; ltm->tm_mon = tm.tm_mon;
ltm->tm_year = tm.tm_year; ltm->tm_year = tm.tm_year;
ltm->tm_usec = tv.tv_usec; ltm->tm_nsec = NSECS(tv.FRAC);
} }
#endif #endif
@ -406,7 +433,7 @@ ldap_pvt_csnstr(char *buf, size_t len, unsigned int replica, unsigned int mod)
n = snprintf( buf, len, n = snprintf( buf, len,
"%4d%02d%02d%02d%02d%02d.%06dZ#%06x#%03x#%06x", "%4d%02d%02d%02d%02d%02d.%06dZ#%06x#%03x#%06x",
tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour,
tm.tm_min, tm.tm_sec, tm.tm_usec, tm.tm_usub, replica, mod ); tm.tm_min, tm.tm_sec, tm.tm_nsec / 1000, tm.tm_usub, replica, mod );
if( n < 0 ) return 0; if( n < 0 ) return 0;
return ( (size_t) n < len ) ? n : 0; return ( (size_t) n < len ) ? n : 0;

12
libraries/liblutil/utils.c
View file

@ -159,7 +159,7 @@ int lutil_tm2time( struct lutil_tm *tm, struct lutil_timet *tt )
273, 304, 334 }; 273, 304, 334 };
int sec; int sec;
tt->tt_usec = tm->tm_usec; tt->tt_nsec = tm->tm_nsec;
/* special case 0000/01/01+00:00:00 is returned as zero */ /* special case 0000/01/01+00:00:00 is returned as zero */
if ( tm->tm_year == -1900 && tm->tm_mon == 0 && tm->tm_mday == 1 && if ( tm->tm_year == -1900 && tm->tm_mon == 0 && tm->tm_mday == 1 &&
@ -226,7 +226,7 @@ int lutil_tm2gtime( struct lutil_tm *tm, struct lutil_timet *tt )
int sec, year; int sec, year;
long tmp; long tmp;
tt->tt_usec = tm->tm_usec; tt->tt_nsec = tm->tm_nsec;
/* tm->tm_year is years since 1900 */ /* tm->tm_year is years since 1900 */
/* calculate days from 0000 */ /* calculate days from 0000 */
@ -350,13 +350,13 @@ int lutil_parsetime( char *atm, struct lutil_tm *tm )
i*=10; i+= *ptr++ - '0'; i*=10; i+= *ptr++ - '0';
fracs++; fracs++;
} }
tm->tm_usec = i; tm->tm_nsec = i;
if (i) { if (i) {
for (i = fracs; i<6; i++) for (i = fracs; i<9; i++)
tm->tm_usec *= 10; tm->tm_nsec *= 10;
} }
} else { } else {
tm->tm_usec = 0; tm->tm_nsec = 0;
} }
tm->tm_usub = 0; tm->tm_usub = 0;

15
servers/slapd/main.c
View file

@ -382,12 +382,21 @@ static BER_logger *ber_logger;
static void debug_print( const char *data ) static void debug_print( const char *data )
{ {
char buf[4136]; /* 4096 + 40 */ char buf[4136]; /* 4096 + 40 */
#ifdef HAVE_CLOCK_GETTIME
struct timespec tv;
#define TS "%08x"
#define Tfrac tv.tv_nsec
clock_gettime( CLOCK_REALTIME, &tv );
#else
struct timeval tv; struct timeval tv;
#define TS "%05x"
#define Tfrac tv.tv_usec
gettimeofday( &tv, NULL ); gettimeofday( &tv, NULL );
#endif
buf[sizeof(buf)-1] = '\0'; buf[sizeof(buf)-1] = '\0';
snprintf( buf, sizeof(buf)-1, "%lx.%05x %p %s", snprintf( buf, sizeof(buf)-1, "%lx." TS " %p %s",
(long)tv.tv_sec, tv.tv_usec, (void *)ldap_pvt_thread_self(), data ); (long)tv.tv_sec, Tfrac, (void *)ldap_pvt_thread_self(), data );
ber_logger( buf ); ber_logger( buf );
} }

2
servers/slapd/overlays/ppolicy.c
View file

@ -1500,7 +1500,7 @@ ppolicy_bind_response( Operation *op, SlapReply *rs )
strcpy(nowstr_usec, nowstr); strcpy(nowstr_usec, nowstr);
timestamp_usec.bv_val = nowstr_usec; timestamp_usec.bv_val = nowstr_usec;
timestamp_usec.bv_len = timestamp.bv_len; timestamp_usec.bv_len = timestamp.bv_len;
snprintf( timestamp_usec.bv_val + timestamp_usec.bv_len-1, sizeof(".123456Z"), ".%06dZ", now_usec.tt_usec ); snprintf( timestamp_usec.bv_val + timestamp_usec.bv_len-1, sizeof(".123456Z"), ".%06dZ", now_usec.tt_nsec / 1000 );
timestamp_usec.bv_len += STRLENOF(".123456"); timestamp_usec.bv_len += STRLENOF(".123456");
if ( rs->sr_err == LDAP_INVALID_CREDENTIALS && ppb->pp.pwdMaxRecordedFailure ) { if ( rs->sr_err == LDAP_INVALID_CREDENTIALS && ppb->pp.pwdMaxRecordedFailure ) {

2
tests/progs/slapd-watcher.c
View file

@ -425,7 +425,7 @@ void get_csns(
if (j < numservers) { if (j < numservers) {
ber_bvreplace( &c->vals[j], &bvs[i] ); ber_bvreplace( &c->vals[j], &bvs[i] );
lutil_parsetime(bvs[i].bv_val, &tm); lutil_parsetime(bvs[i].bv_val, &tm);
c->tvs[j].tv_usec = tm.tm_usec; c->tvs[j].tv_usec = tm.tm_nsec / 1000;
lutil_tm2time( &tm, &tt ); lutil_tm2time( &tm, &tt );
c->tvs[j].tv_sec = tt.tt_sec; c->tvs[j].tv_sec = tt.tt_sec;
} }