From f3cdcadf89474e7267d9f8f17d2bac46551b2131 Mon Sep 17 00:00:00 2001 From: Pierangelo Masarati Date: Tue, 18 Aug 2009 23:48:15 +0000 Subject: [PATCH] wrap gmtime for reentrancy (ITS#6262) --- configure.in | 1 + contrib/slapd-modules/lastmod/lastmod.c | 4 +- include/ldap_pvt.h | 37 +++++ include/lutil.h | 10 -- libraries/libldap/ldap-int.h | 1 + libraries/libldap/util-int.c | 210 ++++++++++++++++++++++++ libraries/liblutil/Makefile.in | 4 +- libraries/liblutil/csn.c | 82 --------- libraries/liblutil/utils.c | 122 -------------- servers/slapd/add.c | 2 +- servers/slapd/back-bdb/delete.c | 2 +- servers/slapd/back-ldif/ldif.c | 2 +- servers/slapd/back-monitor/conn.c | 69 ++------ servers/slapd/back-monitor/init.c | 28 +--- servers/slapd/back-monitor/time.c | 28 +--- servers/slapd/back-ndb/delete.cpp | 2 +- servers/slapd/back-sql/add.c | 2 +- servers/slapd/back-sql/operational.c | 2 +- servers/slapd/ctxcsn.c | 10 +- servers/slapd/init.c | 2 - servers/slapd/ldapsync.c | 6 +- servers/slapd/modify.c | 18 +- servers/slapd/overlays/accesslog.c | 2 +- servers/slapd/overlays/syncprov.c | 12 +- servers/slapd/proto-slap.h | 2 - servers/slapd/slapadd.c | 8 +- 26 files changed, 298 insertions(+), 370 deletions(-) delete mode 100644 libraries/liblutil/csn.c diff --git a/configure.in b/configure.in index 523d0d02c6..fdbdef06e1 100644 --- a/configure.in +++ b/configure.in @@ -1859,6 +1859,7 @@ dnl ---------------------------------------------------------------- dnl Tests for reentrant functions necessary to build -lldap_r AC_CHECK_FUNCS( \ ctime_r \ + gmtime_r localtime_r \ gethostbyname_r gethostbyaddr_r \ ) diff --git a/contrib/slapd-modules/lastmod/lastmod.c b/contrib/slapd-modules/lastmod/lastmod.c index ab4d1c9726..030bd0ddf8 100644 --- a/contrib/slapd-modules/lastmod/lastmod.c +++ b/contrib/slapd-modules/lastmod/lastmod.c @@ -367,7 +367,7 @@ best_guess( Operation *op, struct berval *bv_modifiersName, struct berval *bv_nmodifiersName ) { if ( bv_entryCSN ) { - char csnbuf[ LDAP_LUTIL_CSNSTR_BUFSIZE ]; + char csnbuf[ LDAP_PVT_CSNSTR_BUFSIZE ]; struct berval entryCSN; entryCSN.bv_val = csnbuf; @@ -836,7 +836,7 @@ lastmod_db_open( char buf[ 8192 ]; static char tmbuf[ LDAP_LUTIL_GENTIME_BUFSIZE ]; - char csnbuf[ LDAP_LUTIL_CSNSTR_BUFSIZE ]; + char csnbuf[ LDAP_PVT_CSNSTR_BUFSIZE ]; struct berval entryCSN; struct berval timestamp; diff --git a/include/ldap_pvt.h b/include/ldap_pvt.h index a5cd62ad49..bd7b21c4a6 100644 --- a/include/ldap_pvt.h +++ b/include/ldap_pvt.h @@ -91,6 +91,43 @@ ldap_pvt_ctime LDAP_P(( const time_t *tp, char *buf )); +# if defined( HAVE_GMTIME_R ) +# define USE_GMTIME_R +# define ldap_pvt_gmtime_lock() (0) +# define ldap_pvt_gmtime_unlock() (0) +# define ldap_pvt_gmtime(timep, result) gmtime_r((timep), (result)) +# else +LDAP_F( int ) +ldap_pvt_gmtime_lock LDAP_P(( void )); + +LDAP_F( int ) +ldap_pvt_gmtime_unlock LDAP_P(( void )); + +LDAP_F( struct tm * ) +ldap_pvt_gmtime LDAP_P(( + LDAP_CONST time_t *timep, + struct tm *result )); +#endif + +# if defined( HAVE_LOCALTIME_R ) +# define USE_LOCALTIME_R +# define ldap_pvt_localtime(timep, result) localtime_r((timep), (result)) +# else +LDAP_F( struct tm * ) +ldap_pvt_localtime LDAP_P(( + LDAP_CONST time_t *timep, + struct tm *result )); +# endif + +/* Get current time as a structured time */ +LDAP_F( void ) +ldap_pvt_gettime LDAP_P(( struct lutil_tm * )); + +/* use this macro to allocate buffer for ldap_pvt_csnstr */ +#define LDAP_PVT_CSNSTR_BUFSIZE 64 +LDAP_F( size_t ) +ldap_pvt_csnstr( char *buf, size_t len, unsigned int replica, unsigned int mod ); + LDAP_F( char *) ldap_pvt_get_fqdn LDAP_P(( char * )); struct hostent; /* avoid pulling in */ diff --git a/include/lutil.h b/include/lutil.h index b5815c5a2d..cda43ebb23 100644 --- a/include/lutil.h +++ b/include/lutil.h @@ -177,10 +177,6 @@ LDAP_LUTIL_F( int ) lutil_tm2time LDAP_P(( struct lutil_tm *, struct lutil_timet * )); -/* Get current time as a structured time */ -LDAP_LUTIL_F( void ) -lutil_gettime LDAP_P(( struct lutil_tm * )); - #ifdef _WIN32 LDAP_LUTIL_F( void ) lutil_slashpath LDAP_P(( char* path )); @@ -229,12 +225,6 @@ lutil_uuidstr_from_normalized( char *buf, size_t buflen ); -/* csn.c */ -/* use this macro to allocate buffer for lutil_csnstr */ -#define LDAP_LUTIL_CSNSTR_BUFSIZE 64 -LDAP_LUTIL_F( size_t ) -lutil_csnstr( char *buf, size_t len, unsigned int replica, unsigned int mod ); - /* * Sometimes not all declarations in a header file are needed. * An indicator to this is whether or not the symbol's type has diff --git a/libraries/libldap/ldap-int.h b/libraries/libldap/ldap-int.h index 6708503069..afe5b49991 100644 --- a/libraries/libldap/ldap-int.h +++ b/libraries/libldap/ldap-int.h @@ -25,6 +25,7 @@ #endif #include "../liblber/lber-int.h" +#include "lutil.h" #ifdef LDAP_R_COMPILE #include diff --git a/libraries/libldap/util-int.c b/libraries/libldap/util-int.c index 66bb82ac57..062c892fba 100644 --- a/libraries/libldap/util-int.c +++ b/libraries/libldap/util-int.c @@ -66,6 +66,15 @@ extern int h_errno; static ldap_pvt_thread_mutex_t ldap_int_ctime_mutex; # endif +/* USE_GMTIME_R and USE_LOCALTIME_R defined in ldap_pvt.h */ + +#if !defined( USE_GMTIME_R ) || !defined( USE_LOCALTIME_R ) + /* we use the same mutex for gmtime(3) and localtime(3) + * because implementations may use the same buffer + * for both functions */ + static ldap_pvt_thread_mutex_t ldap_int_gmtime_mutex; +#endif + # if defined(HAVE_GETHOSTBYNAME_R) && \ (GETHOSTBYNAME_R_NARGS < 5) || (6 < GETHOSTBYNAME_R_NARGS) /* Don't know how to handle this version, pretend it's not there */ @@ -107,6 +116,204 @@ char *ldap_pvt_ctime( const time_t *tp, char *buf ) #endif } +#ifndef USE_GMTIME_R +int +ldap_pvt_gmtime_lock( void ) +{ +# ifndef LDAP_R_COMPILE + return 0; +# else /* LDAP_R_COMPILE */ + return ldap_pvt_thread_mutex_lock( &ldap_int_gmtime_mutex ); +# endif /* LDAP_R_COMPILE */ +} + +int +ldap_pvt_gmtime_unlock( void ) +{ +# ifndef LDAP_R_COMPILE + return 0; +# else /* LDAP_R_COMPILE */ + return ldap_pvt_thread_mutex_unlock( &ldap_int_gmtime_mutex ); +# endif /* LDAP_R_COMPILE */ +} + +struct tm * +ldap_pvt_gmtime( const time_t *timep, struct tm *result ) +{ + struct tm *tm_ptr; + +# ifdef LDAP_R_COMPILE + ldap_pvt_thread_mutex_lock( &ldap_int_gmtime_mutex ); +# endif /* LDAP_R_COMPILE */ + + tm_ptr = gmtime( timep ); + if ( tm_ptr != NULL ) { + *result = *tm_ptr; + } + +# ifdef LDAP_R_COMPILE + ldap_pvt_thread_mutex_unlock( &ldap_int_gmtime_mutex ); +# endif /* LDAP_R_COMPILE */ + + return tm_ptr; +} +#endif /* !USE_GMTIME_R */ + +#ifndef USE_LOCALTIME_R +struct tm * +ldap_pvt_localtime( const time_t *timep, struct tm *result ) +{ + struct tm *tm_ptr; + +# ifdef LDAP_R_COMPILE + ldap_pvt_thread_mutex_lock( &ldap_int_gmtime_mutex ); +# endif /* LDAP_R_COMPILE */ + + tm_ptr = localtime( timep ); + if ( tm_ptr != NULL ) { + *result = *tm_ptr; + } + +# ifdef LDAP_R_COMPILE + ldap_pvt_thread_mutex_unlock( &ldap_int_gmtime_mutex ); +# endif /* LDAP_R_COMPILE */ + + return tm_ptr; +} +#endif /* !USE_LOCALTIME_R */ + +/* return a broken out time, with microseconds + * Must be mutex-protected. + */ +#ifdef _WIN32 +/* Windows SYSTEMTIME only has 10 millisecond resolution, so we + * also need to use a high resolution timer to get microseconds. + * This is pretty clunky. + */ +void +ldap_pvt_gettime( struct lutil_tm *tm ) +{ + static LARGE_INTEGER cFreq; + static LARGE_INTEGER prevCount; + static int subs; + static int offset; + LARGE_INTEGER count; + SYSTEMTIME st; + + GetSystemTime( &st ); + QueryPerformanceCounter( &count ); + + /* It shouldn't ever go backwards, but multiple CPUs might + * be able to hit in the same tick. + */ + if ( count.QuadPart <= prevCount.QuadPart ) { + subs++; + } else { + subs = 0; + prevCount = count; + } + + /* We assume Windows has at least a vague idea of + * when a second begins. So we align our microsecond count + * with the Windows millisecond count using this offset. + * We retain the submillisecond portion of our own count. + * + * Note - this also assumes that the relationship between + * the PerformanceCouunter and SystemTime stays constant; + * that assumption breaks if the SystemTime is adjusted by + * an external action. + */ + if ( !cFreq.QuadPart ) { + long long t; + int usec; + QueryPerformanceFrequency( &cFreq ); + + /* just get sub-second portion of counter */ + t = count.QuadPart % cFreq.QuadPart; + + /* convert to microseconds */ + t *= 1000000; + usec = t / cFreq.QuadPart; + + offset = usec - st.wMilliseconds * 1000; + } + + tm->tm_usub = subs; + + /* convert to microseconds */ + count.QuadPart %= cFreq.QuadPart; + count.QuadPart *= 1000000; + count.QuadPart /= cFreq.QuadPart; + count.QuadPart -= offset; + + tm->tm_usec = count.QuadPart % 1000000; + if ( tm->tm_usec < 0 ) + tm->tm_usec += 1000000; + + /* any difference larger than microseconds is + * already reflected in st + */ + + tm->tm_sec = st.wSecond; + tm->tm_min = st.wMinute; + tm->tm_hour = st.wHour; + tm->tm_mday = st.wDay; + tm->tm_mon = st.wMonth - 1; + tm->tm_year = st.wYear - 1900; +} +#else +void +ldap_pvt_gettime( struct lutil_tm *ltm ) +{ + struct timeval tv; + static struct timeval prevTv; + static int subs; + + struct tm tm; + time_t t; + + gettimeofday( &tv, NULL ); + t = tv.tv_sec; + + if ( tv.tv_sec < prevTv.tv_sec + || ( tv.tv_sec == prevTv.tv_sec && tv.tv_usec == prevTv.tv_usec )) { + subs++; + } else { + subs = 0; + prevTv = tv; + } + + ltm->tm_usub = subs; + + ldap_pvt_gmtime( &t, &tm ); + + ltm->tm_sec = tm.tm_sec; + ltm->tm_min = tm.tm_min; + ltm->tm_hour = tm.tm_hour; + ltm->tm_mday = tm.tm_mday; + ltm->tm_mon = tm.tm_mon; + ltm->tm_year = tm.tm_year; + ltm->tm_usec = tv.tv_usec; +} +#endif + +size_t +ldap_pvt_csnstr(char *buf, size_t len, unsigned int replica, unsigned int mod) +{ + struct lutil_tm tm; + int n; + + ldap_pvt_gettime( &tm ); + + n = snprintf( buf, len, + "%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_min, tm.tm_sec, tm.tm_usec, tm.tm_usub, replica, mod ); + + if( n < 0 ) return 0; + return ( (size_t) n < len ) ? n : 0; +} + #define BUFSTART (1024-32) #define BUFMAX (32*1024-32) @@ -405,6 +612,9 @@ void ldap_int_utils_init( void ) #ifdef LDAP_R_COMPILE #if !defined( USE_CTIME_R ) && !defined( HAVE_REENTRANT_FUNCTIONS ) ldap_pvt_thread_mutex_init( &ldap_int_ctime_mutex ); +#endif +#if !defined( USE_GMTIME_R ) && !defined( USE_LOCALTIME_R ) + ldap_pvt_thread_mutex_init( &ldap_int_gmtime_mutex ); #endif ldap_pvt_thread_mutex_init( &ldap_int_resolv_mutex ); diff --git a/libraries/liblutil/Makefile.in b/libraries/liblutil/Makefile.in index 4e0935f630..8dcd965e37 100644 --- a/libraries/liblutil/Makefile.in +++ b/libraries/liblutil/Makefile.in @@ -27,14 +27,14 @@ UNIX_OBJS = detach.o XLIBS = $(LIBRARY) $(LDAP_LIBLBER_LA) -SRCS = base64.c csn.c entropy.c sasl.c signal.c hash.c passfile.c \ +SRCS = base64.c entropy.c sasl.c signal.c hash.c passfile.c \ md5.c passwd.c sha1.c getpass.c lockf.c utils.c uuid.c sockpair.c \ avl.c tavl.c ldif.c fetch.c \ testavl.c \ meter.c \ @LIBSRCS@ $(@PLAT@_SRCS) -OBJS = base64.o csn.o entropy.o sasl.o signal.o hash.o passfile.o \ +OBJS = base64.o entropy.o sasl.o signal.o hash.o passfile.o \ md5.o passwd.o sha1.o getpass.o lockf.o utils.o uuid.o sockpair.o \ avl.o tavl.o ldif.o fetch.o \ meter.o \ diff --git a/libraries/liblutil/csn.c b/libraries/liblutil/csn.c deleted file mode 100644 index 19a74487ff..0000000000 --- a/libraries/liblutil/csn.c +++ /dev/null @@ -1,82 +0,0 @@ -/* csn.c - Change Sequence Number routines */ -/* $OpenLDAP$ */ -/* This work is part of OpenLDAP Software . - * - * Copyright 2000-2009 The OpenLDAP Foundation. - * Portions Copyright 2000-2003 Kurt D. Zeilenga. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted only as authorized by the OpenLDAP - * Public License. - * - * A copy of this license is available in the file LICENSE in the - * top-level directory of the distribution or, alternatively, at - * . - */ -/* Portions Copyright 2000, John E. Schimmel, All rights reserved. - * This software is not subject to any license of Mirapoint, Inc. - * - * This is free software; you can redistribute and use it - * under the same terms as OpenLDAP itself. - */ -/* This work was developed by John E. Schimmel and adapted for - * inclusion in OpenLDAP Software by Kurt D. Zeilenga. - */ - -/* This file contains routines to generate a change sequence number. - * Every add, delete, and modification is given a unique identifier - * for use in resolving conflicts during replication operations. - * - * These routines are (loosly) based upon draft-ietf-ldup-model-03.txt, - * A WORK IN PROGRESS. The format will likely change. - * - * The format of a CSN string is: yyyymmddhhmmssz#s#r#c - * where s is a counter of operations within a timeslice, r is - * the replica id (normally zero), and c is a counter of - * modifications within this operation. s, r, and c are - * represented in hex and zero padded to lengths of 6, 3, and - * 6, respectively. (In previous implementations r was only 2 digits.) - * - * Calls to this routine MUST be serialized with other calls - * to gmtime(). - */ -#include "portable.h" - -#include -#include - -#include - -/* Must be mutex-protected, because lutil_gettime needs mutex protection */ -size_t -lutil_csnstr(char *buf, size_t len, unsigned int replica, unsigned int mod) -{ - struct lutil_tm tm; - int n; - - lutil_gettime( &tm ); - - n = snprintf( buf, len, - "%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_min, tm.tm_sec, tm.tm_usec, tm.tm_usub, replica, mod ); - - if( n < 0 ) return 0; - return ( (size_t) n < len ) ? n : 0; -} - -#ifdef TEST -int -main(int argc, char **argv) -{ - char buf[ LDAP_LUTIL_CSNSTR_BUFSIZE ]; - - if ( ! lutil_csnstr( buf, (size_t) 10, 0, 0 ) ) { - fprintf(stderr, "failed lutil_csnstr\n"); - } - if ( ! lutil_csnstr( buf, sizeof(buf), 0, 0 ) ) { - fprintf(stderr, "failed lutil_csnstr\n"); - } -} -#endif diff --git a/libraries/liblutil/utils.c b/libraries/liblutil/utils.c index cccb2d1099..dd08642fa2 100644 --- a/libraries/liblutil/utils.c +++ b/libraries/liblutil/utils.c @@ -282,128 +282,6 @@ int lutil_parsetime( char *atm, struct lutil_tm *tm ) return -1; } -/* return a broken out time, with microseconds - * Must be mutex-protected. - */ -#ifdef _WIN32 -/* Windows SYSTEMTIME only has 10 millisecond resolution, so we - * also need to use a high resolution timer to get microseconds. - * This is pretty clunky. - */ -void -lutil_gettime( struct lutil_tm *tm ) -{ - static LARGE_INTEGER cFreq; - static LARGE_INTEGER prevCount; - static int subs; - static int offset; - LARGE_INTEGER count; - SYSTEMTIME st; - - GetSystemTime( &st ); - QueryPerformanceCounter( &count ); - - /* It shouldn't ever go backwards, but multiple CPUs might - * be able to hit in the same tick. - */ - if ( count.QuadPart <= prevCount.QuadPart ) { - subs++; - } else { - subs = 0; - prevCount = count; - } - - /* We assume Windows has at least a vague idea of - * when a second begins. So we align our microsecond count - * with the Windows millisecond count using this offset. - * We retain the submillisecond portion of our own count. - * - * Note - this also assumes that the relationship between - * the PerformanceCouunter and SystemTime stays constant; - * that assumption breaks if the SystemTime is adjusted by - * an external action. - */ - if ( !cFreq.QuadPart ) { - long long t; - int usec; - QueryPerformanceFrequency( &cFreq ); - - /* just get sub-second portion of counter */ - t = count.QuadPart % cFreq.QuadPart; - - /* convert to microseconds */ - t *= 1000000; - usec = t / cFreq.QuadPart; - - offset = usec - st.wMilliseconds * 1000; - } - - tm->tm_usub = subs; - - /* convert to microseconds */ - count.QuadPart %= cFreq.QuadPart; - count.QuadPart *= 1000000; - count.QuadPart /= cFreq.QuadPart; - count.QuadPart -= offset; - - tm->tm_usec = count.QuadPart % 1000000; - if ( tm->tm_usec < 0 ) - tm->tm_usec += 1000000; - - /* any difference larger than microseconds is - * already reflected in st - */ - - tm->tm_sec = st.wSecond; - tm->tm_min = st.wMinute; - tm->tm_hour = st.wHour; - tm->tm_mday = st.wDay; - tm->tm_mon = st.wMonth - 1; - tm->tm_year = st.wYear - 1900; -} -#else -void -lutil_gettime( struct lutil_tm *ltm ) -{ - struct timeval tv; - static struct timeval prevTv; - static int subs; - -#ifdef HAVE_GMTIME_R - struct tm tm_buf; -#endif - struct tm *tm; - time_t t; - - gettimeofday( &tv, NULL ); - t = tv.tv_sec; - - if ( tv.tv_sec < prevTv.tv_sec - || ( tv.tv_sec == prevTv.tv_sec && tv.tv_usec == prevTv.tv_usec )) { - subs++; - } else { - subs = 0; - prevTv = tv; - } - - ltm->tm_usub = subs; - -#ifdef HAVE_GMTIME_R - tm = gmtime_r( &t, &tm_buf ); -#else - tm = gmtime( &t ); -#endif - - ltm->tm_sec = tm->tm_sec; - ltm->tm_min = tm->tm_min; - ltm->tm_hour = tm->tm_hour; - ltm->tm_mday = tm->tm_mday; - ltm->tm_mon = tm->tm_mon; - ltm->tm_year = tm->tm_year; - ltm->tm_usec = tv.tv_usec; -} -#endif - /* strcopy is like strcpy except it returns a pointer to the trailing NUL of * the result string. This allows fast construction of catenated strings * without the overhead of strlen/strcat. diff --git a/servers/slapd/add.c b/servers/slapd/add.c index 1dcc082833..4e3a9c486b 100644 --- a/servers/slapd/add.c +++ b/servers/slapd/add.c @@ -592,7 +592,7 @@ int slap_add_opattrs( struct berval name, timestamp, csn = BER_BVNULL; struct berval nname, tmp; char timebuf[ LDAP_LUTIL_GENTIME_BUFSIZE ]; - char csnbuf[ LDAP_LUTIL_CSNSTR_BUFSIZE ]; + char csnbuf[ LDAP_PVT_CSNSTR_BUFSIZE ]; Attribute *a; if ( SLAP_LASTMOD( op->o_bd ) ) { diff --git a/servers/slapd/back-bdb/delete.c b/servers/slapd/back-bdb/delete.c index 7470f4a62c..fd569cab49 100644 --- a/servers/slapd/back-bdb/delete.c +++ b/servers/slapd/back-bdb/delete.c @@ -101,7 +101,7 @@ txnReturn: /* allocate CSN */ if ( BER_BVISNULL( &op->o_csn ) ) { struct berval csn; - char csnbuf[LDAP_LUTIL_CSNSTR_BUFSIZE]; + char csnbuf[LDAP_PVT_CSNSTR_BUFSIZE]; csn.bv_val = csnbuf; csn.bv_len = sizeof(csnbuf); diff --git a/servers/slapd/back-ldif/ldif.c b/servers/slapd/back-ldif/ldif.c index 4625af8c8d..9a4ad7ad56 100644 --- a/servers/slapd/back-ldif/ldif.c +++ b/servers/slapd/back-ldif/ldif.c @@ -1306,7 +1306,7 @@ ldif_back_delete( Operation *op, SlapReply *rs ) if ( BER_BVISEMPTY( &op->o_csn )) { struct berval csn; - char csnbuf[LDAP_LUTIL_CSNSTR_BUFSIZE]; + char csnbuf[LDAP_PVT_CSNSTR_BUFSIZE]; csn.bv_val = csnbuf; csn.bv_len = sizeof( csnbuf ); diff --git a/servers/slapd/back-monitor/conn.c b/servers/slapd/back-monitor/conn.c index d962a9fe4c..64bd4231d8 100644 --- a/servers/slapd/back-monitor/conn.c +++ b/servers/slapd/back-monitor/conn.c @@ -266,72 +266,27 @@ conn_create( monitor_subsys_t *ms ) { monitor_entry_t *mp; - struct tm *tm; + struct tm tm; char buf[ BACKMONITOR_BUFSIZE ]; char buf2[ LDAP_LUTIL_GENTIME_BUFSIZE ]; char buf3[ LDAP_LUTIL_GENTIME_BUFSIZE ]; - struct berval bv, ctmbv, mtmbv, bv2, bv3; + struct berval bv, ctmbv, mtmbv; struct berval bv_unknown= BER_BVC("unknown"); Entry *e; -#ifdef HACK_LOCAL_TIME - char ctmbuf[ LDAP_LUTIL_GENTIME_BUFSIZE ]; - char mtmbuf[ LDAP_LUTIL_GENTIME_BUFSIZE ]; -#endif -#ifdef HAVE_GMTIME_R - struct tm tm_buf; -#endif /* HAVE_GMTIME_R */ - assert( c != NULL ); assert( ep != NULL ); -#ifndef HAVE_GMTIME_R - ldap_pvt_thread_mutex_lock( &gmtime_mutex ); -#endif - -#ifdef HAVE_GMTIME_R - tm = gmtime_r( &c->c_starttime, &tm_buf ); -#else - tm = gmtime( &c->c_starttime ); -#endif - bv2.bv_len = lutil_gentime( buf2, sizeof( buf2 ), tm ); - bv2.bv_val = buf2; -#ifdef HACK_LOCAL_TIME -# ifdef HAVE_LOCALTIME_R - tm = localtime_r( &c->c_starttime, &tm_buf ); -# else - tm = localtime( &c->c_starttime ); -# endif - ctmbv.bv_len = lutil_localtime( ctmbuf, sizeof( ctmbuf ), tm, -timezone ); - ctmbv.bv_val = ctmbuf; -#else /* !HACK_LOCAL_TIME */ - ctmbv = bv2; -#endif - -#ifdef HAVE_GMTIME_R - tm = gmtime_r( &c->c_activitytime, &tm_buf ); -#else - tm = gmtime( &c->c_activitytime ); -#endif - bv3.bv_len = lutil_gentime( buf3, sizeof( buf3 ), tm ); - bv3.bv_val = buf3; -#ifdef HACK_LOCAL_TIME -# ifdef HAVE_LOCALTIME_R - tm = localtime_r( &c->c_activitytime, &tm_buf ); -# else - tm = localtime( &c->c_activitytime ); -# endif /* HAVE_LOCALTIME_R */ - mtmbv.bv_len = lutil_localtime( mtmbuf, sizeof( mtmbuf ), tm, -timezone ); - mtmbv.bv_val = mtmbuf; -#else /* !HACK_LOCAL_TIME */ - mtmbv = bv3; -#endif - -#ifndef HAVE_GMTIME_R - ldap_pvt_thread_mutex_unlock( &gmtime_mutex ); -#endif + ldap_pvt_gmtime( &c->c_starttime, &tm ); + + ctmbv.bv_len = lutil_gentime( buf2, sizeof( buf2 ), &tm ); + ctmbv.bv_val = buf2; + + ldap_pvt_gmtime( &c->c_activitytime, &tm ); + mtmbv.bv_len = lutil_gentime( buf3, sizeof( buf3 ), &tm ); + mtmbv.bv_val = buf3; bv.bv_len = snprintf( buf, sizeof( buf ), "cn=Connection %ld", c->c_connid ); @@ -450,9 +405,9 @@ conn_create( attr_merge_normalize_one( e, mi->mi_ad_monitorConnectionLocalAddress, &c->c_sock_name, NULL ); - attr_merge_normalize_one( e, mi->mi_ad_monitorConnectionStartTime, &bv2, NULL ); + attr_merge_normalize_one( e, mi->mi_ad_monitorConnectionStartTime, &ctmbv, NULL ); - attr_merge_normalize_one( e, mi->mi_ad_monitorConnectionActivityTime, &bv3, NULL ); + attr_merge_normalize_one( e, mi->mi_ad_monitorConnectionActivityTime, &mtmbv, NULL ); mp = monitor_entrypriv_create(); if ( mp == NULL ) { diff --git a/servers/slapd/back-monitor/init.c b/servers/slapd/back-monitor/init.c index dc6975ab34..0cbe5682fb 100644 --- a/servers/slapd/back-monitor/init.c +++ b/servers/slapd/back-monitor/init.c @@ -2207,10 +2207,7 @@ monitor_back_db_open( monitor_entry_t *mp; int i; struct berval bv, rdn = BER_BVC(SLAPD_MONITOR_DN); - struct tm *tms; -#ifdef HAVE_GMTIME_R - struct tm tm_buf; -#endif + struct tm tms; static char tmbuf[ LDAP_LUTIL_GENTIME_BUFSIZE ]; struct berval desc[] = { BER_BVC("This subtree contains monitoring/managing objects."), @@ -2229,27 +2226,8 @@ monitor_back_db_open( /* * Start */ -#ifndef HAVE_GMTIME_R - ldap_pvt_thread_mutex_lock( &gmtime_mutex ); -#endif -#ifdef HACK_LOCAL_TIME -# ifdef HAVE_LOCALTIME_R - tms = localtime_r( &starttime, &tm_buf ); -# else - tms = localtime( &starttime ); -# endif /* HAVE_LOCALTIME_R */ - lutil_localtime( tmbuf, sizeof(tmbuf), tms, -timezone ); -#else /* !HACK_LOCAL_TIME */ -# ifdef HAVE_GMTIME_R - tms = gmtime_r( &starttime, &tm_buf ); -# else - tms = gmtime( &starttime ); -# endif /* HAVE_GMTIME_R */ - lutil_gentime( tmbuf, sizeof(tmbuf), tms ); -#endif /* !HACK_LOCAL_TIME */ -#ifndef HAVE_GMTIME_R - ldap_pvt_thread_mutex_unlock( &gmtime_mutex ); -#endif + ldap_pvt_gmtime( &starttime, &tms ); + lutil_gentime( tmbuf, sizeof(tmbuf), &tms ); mi->mi_startTime.bv_val = tmbuf; mi->mi_startTime.bv_len = strlen( tmbuf ); diff --git a/servers/slapd/back-monitor/time.c b/servers/slapd/back-monitor/time.c index 58fe43cb47..41f4b4ff14 100644 --- a/servers/slapd/back-monitor/time.c +++ b/servers/slapd/back-monitor/time.c @@ -195,10 +195,7 @@ monitor_subsys_time_update( dnRdn( &e->e_nname, &rdn ); if ( dn_match( &rdn, &bv_current ) ) { - struct tm *tm; -#ifdef HAVE_GMTIME_R - struct tm tm_buf; -#endif + struct tm tm; char tmbuf[ LDAP_LUTIL_GENTIME_BUFSIZE ]; Attribute *a; ber_len_t len; @@ -206,27 +203,8 @@ monitor_subsys_time_update( currtime = slap_get_time(); -#ifndef HAVE_GMTIME_R - ldap_pvt_thread_mutex_lock( &gmtime_mutex ); -#endif -#ifdef HACK_LOCAL_TIME -# ifdef HAVE_LOCALTIME_R - tm = localtime_r( &currtime, &tm_buf ); -# else - tm = localtime( &currtime ); -# endif /* HAVE_LOCALTIME_R */ - lutil_localtime( tmbuf, sizeof( tmbuf ), tm, -timezone ); -#else /* !HACK_LOCAL_TIME */ -# ifdef HAVE_GMTIME_R - tm = gmtime_r( &currtime, &tm_buf ); -# else - tm = gmtime( &currtime ); -# endif /* HAVE_GMTIME_R */ - lutil_gentime( tmbuf, sizeof( tmbuf ), tm ); -#endif /* !HACK_LOCAL_TIME */ -#ifndef HAVE_GMTIME_R - ldap_pvt_thread_mutex_unlock( &gmtime_mutex ); -#endif + ldap_pvt_gmtime( &currtime, &tm ); + lutil_gentime( tmbuf, sizeof( tmbuf ), &tm ); len = strlen( tmbuf ); diff --git a/servers/slapd/back-ndb/delete.cpp b/servers/slapd/back-ndb/delete.cpp index 3c4a373c78..46eb13098a 100644 --- a/servers/slapd/back-ndb/delete.cpp +++ b/servers/slapd/back-ndb/delete.cpp @@ -58,7 +58,7 @@ ndb_back_delete( Operation *op, SlapReply *rs ) /* allocate CSN */ if ( BER_BVISNULL( &op->o_csn ) ) { struct berval csn; - char csnbuf[LDAP_LUTIL_CSNSTR_BUFSIZE]; + char csnbuf[LDAP_PVT_CSNSTR_BUFSIZE]; csn.bv_val = csnbuf; csn.bv_len = sizeof(csnbuf); diff --git a/servers/slapd/back-sql/add.c b/servers/slapd/back-sql/add.c index ae88f76e49..7f4155ea58 100644 --- a/servers/slapd/back-sql/add.c +++ b/servers/slapd/back-sql/add.c @@ -939,7 +939,7 @@ backsql_add( Operation *op, SlapReply *rs ) * NOTE: fake successful result to force contextCSN to be bumped up */ if ( op->o_sync ) { - char buf[ LDAP_LUTIL_CSNSTR_BUFSIZE ]; + char buf[ LDAP_PVT_CSNSTR_BUFSIZE ]; struct berval csn; csn.bv_val = buf; diff --git a/servers/slapd/back-sql/operational.c b/servers/slapd/back-sql/operational.c index 7071fcd8ea..95b7e61a31 100644 --- a/servers/slapd/back-sql/operational.c +++ b/servers/slapd/back-sql/operational.c @@ -70,7 +70,7 @@ backsql_operational_entryUUID( backsql_info *bi, backsql_entryID *id ) Attribute * backsql_operational_entryCSN( Operation *op ) { - char csnbuf[ LDAP_LUTIL_CSNSTR_BUFSIZE ]; + char csnbuf[ LDAP_PVT_CSNSTR_BUFSIZE ]; struct berval entryCSN; Attribute *a; diff --git a/servers/slapd/ctxcsn.c b/servers/slapd/ctxcsn.c index cb828999cc..a9738e032f 100644 --- a/servers/slapd/ctxcsn.c +++ b/servers/slapd/ctxcsn.c @@ -28,7 +28,7 @@ int slap_serverID; -/* maxcsn->bv_val must point to a char buf[LDAP_LUTIL_CSNSTR_BUFSIZE] */ +/* maxcsn->bv_val must point to a char buf[LDAP_PVT_CSNSTR_BUFSIZE] */ void slap_get_commit_csn( Operation *op, @@ -42,7 +42,7 @@ slap_get_commit_csn( if ( maxcsn ) { assert( maxcsn->bv_val != NULL ); - assert( maxcsn->bv_len >= LDAP_LUTIL_CSNSTR_BUFSIZE ); + assert( maxcsn->bv_len >= LDAP_PVT_CSNSTR_BUFSIZE ); } if ( foundit ) { *foundit = 0; @@ -167,13 +167,9 @@ slap_get_csn( { if ( csn == NULL ) return LDAP_OTHER; - /* gmtime doesn't always need a mutex, but lutil_csnstr does */ - ldap_pvt_thread_mutex_lock( &gmtime_mutex ); - csn->bv_len = lutil_csnstr( csn->bv_val, csn->bv_len, slap_serverID, 0 ); + csn->bv_len = ldap_pvt_csnstr( csn->bv_val, csn->bv_len, slap_serverID, 0 ); if ( manage_ctxcsn ) slap_queue_csn( op, csn ); - ldap_pvt_thread_mutex_unlock( &gmtime_mutex ); - return LDAP_SUCCESS; } diff --git a/servers/slapd/init.c b/servers/slapd/init.c index ae15d0515a..8018f46f1f 100644 --- a/servers/slapd/init.c +++ b/servers/slapd/init.c @@ -61,7 +61,6 @@ BerVarray default_referral = NULL; ldap_pvt_thread_pool_t connection_pool; int connection_pool_max = SLAP_MAX_WORKER_THREADS; int slap_tool_thread_max = 1; -ldap_pvt_thread_mutex_t gmtime_mutex; slap_counters_t slap_counters, *slap_counters_list; @@ -145,7 +144,6 @@ slap_init( int mode, const char *name ) LDAP_STAILQ_INIT( &slapd_rq.task_list ); LDAP_STAILQ_INIT( &slapd_rq.run_list ); - ldap_pvt_thread_mutex_init( &gmtime_mutex ); slap_passwd_init(); rc = slap_sasl_init(); diff --git a/servers/slapd/ldapsync.c b/servers/slapd/ldapsync.c index 0e08030119..267fdd1102 100644 --- a/servers/slapd/ldapsync.c +++ b/servers/slapd/ldapsync.c @@ -45,7 +45,7 @@ slap_compose_sync_cookie( } if ( numcsn == 0 || rid == -1 ) { - char cookiestr[ LDAP_LUTIL_CSNSTR_BUFSIZE + 20 ]; + char cookiestr[ LDAP_PVT_CSNSTR_BUFSIZE + 20 ]; if ( rid == -1 ) { cookiestr[0] = '\0'; len = 0; @@ -289,14 +289,14 @@ slap_init_sync_cookie_ctxcsn( struct sync_cookie *cookie ) { - char csnbuf[ LDAP_LUTIL_CSNSTR_BUFSIZE + 4 ]; + char csnbuf[ LDAP_PVT_CSNSTR_BUFSIZE + 4 ]; struct berval octet_str = BER_BVNULL; struct berval ctxcsn = BER_BVNULL; if ( cookie == NULL ) return -1; - octet_str.bv_len = snprintf( csnbuf, LDAP_LUTIL_CSNSTR_BUFSIZE + 4, + octet_str.bv_len = snprintf( csnbuf, LDAP_PVT_CSNSTR_BUFSIZE + 4, "csn=%4d%02d%02d%02d%02d%02dZ#%06x#%02x#%06x", 1900, 1, 1, 0, 0, 0, 0, 0, 0 ); octet_str.bv_val = csnbuf; diff --git a/servers/slapd/modify.c b/servers/slapd/modify.c index e4f4ff4cd1..69ce102831 100644 --- a/servers/slapd/modify.c +++ b/servers/slapd/modify.c @@ -848,21 +848,11 @@ slap_sort_vals( */ void slap_timestamp( time_t *tm, struct berval *bv ) { - struct tm *ltm; -#ifdef HAVE_GMTIME_R - struct tm ltm_buf; - - ltm = gmtime_r( tm, <m_buf ); -#else - ldap_pvt_thread_mutex_lock( &gmtime_mutex ); - ltm = gmtime( tm ); -#endif + struct tm ltm; - bv->bv_len = lutil_gentime( bv->bv_val, bv->bv_len, ltm ); + ldap_pvt_gmtime( tm, <m ); -#ifndef HAVE_GMTIME_R - ldap_pvt_thread_mutex_unlock( &gmtime_mutex ); -#endif + bv->bv_len = lutil_gentime( bv->bv_val, bv->bv_len, <m ); } /* Called for all modify and modrdn ops. If the current op was replicated @@ -876,7 +866,7 @@ void slap_mods_opattrs( struct berval name, timestamp, csn = BER_BVNULL; struct berval nname; char timebuf[ LDAP_LUTIL_GENTIME_BUFSIZE ]; - char csnbuf[ LDAP_LUTIL_CSNSTR_BUFSIZE ]; + char csnbuf[ LDAP_PVT_CSNSTR_BUFSIZE ]; Modifications *mod, **modtail, *modlast; int gotcsn = 0, gotmname = 0, gotmtime = 0; diff --git a/servers/slapd/overlays/accesslog.c b/servers/slapd/overlays/accesslog.c index 967d56fd18..fc12834ba9 100644 --- a/servers/slapd/overlays/accesslog.c +++ b/servers/slapd/overlays/accesslog.c @@ -615,7 +615,7 @@ accesslog_purge( void *ctx, void *arg ) AttributeAssertion ava = ATTRIBUTEASSERTION_INIT; purge_data pd = {0}; char timebuf[LDAP_LUTIL_GENTIME_BUFSIZE]; - char csnbuf[LDAP_LUTIL_CSNSTR_BUFSIZE]; + char csnbuf[LDAP_PVT_CSNSTR_BUFSIZE]; time_t old = slap_get_time(); connection_fake_init( &conn, &opbuf, ctx ); diff --git a/servers/slapd/overlays/syncprov.c b/servers/slapd/overlays/syncprov.c index ddb060d888..b9920698b6 100644 --- a/servers/slapd/overlays/syncprov.c +++ b/servers/slapd/overlays/syncprov.c @@ -582,8 +582,8 @@ syncprov_findcsn( Operation *op, find_csn_t mode ) slap_callback cb = {0}; Operation fop; SlapReply frs = { REP_RESULT }; - char buf[LDAP_LUTIL_CSNSTR_BUFSIZE + STRLENOF("(entryCSN<=)")]; - char cbuf[LDAP_LUTIL_CSNSTR_BUFSIZE]; + char buf[LDAP_PVT_CSNSTR_BUFSIZE + STRLENOF("(entryCSN<=)")]; + char cbuf[LDAP_PVT_CSNSTR_BUFSIZE]; struct berval maxcsn; Filter cf; AttributeAssertion eq = ATTRIBUTEASSERTION_INIT; @@ -1468,7 +1468,7 @@ syncprov_playlog( Operation *op, SlapReply *rs, sessionlog *sl, slap_overinst *on = (slap_overinst *)op->o_bd->bd_info; slog_entry *se; int i, j, ndel, num, nmods, mmods; - char cbuf[LDAP_LUTIL_CSNSTR_BUFSIZE]; + char cbuf[LDAP_PVT_CSNSTR_BUFSIZE]; BerVarray uuids; struct berval delcsn[2]; @@ -1643,7 +1643,7 @@ syncprov_op_response( Operation *op, SlapReply *rs ) if ( rs->sr_err == LDAP_SUCCESS ) { struct berval maxcsn; - char cbuf[LDAP_LUTIL_CSNSTR_BUFSIZE]; + char cbuf[LDAP_PVT_CSNSTR_BUFSIZE]; int do_check = 0, have_psearches, foundit, csn_changed = 0; /* Update our context CSN */ @@ -2786,7 +2786,7 @@ sp_cf_gen(ConfigArgs *c) } sl = si->si_logs; if ( !sl ) { - sl = ch_malloc( sizeof( sessionlog ) + LDAP_LUTIL_CSNSTR_BUFSIZE ); + sl = ch_malloc( sizeof( sessionlog ) + LDAP_PVT_CSNSTR_BUFSIZE ); sl->sl_mincsn.bv_val = (char *)(sl+1); sl->sl_mincsn.bv_len = 0; sl->sl_num = 0; @@ -2886,7 +2886,7 @@ syncprov_db_open( /* Didn't find a contextCSN, should we generate one? */ if ( !si->si_ctxcsn ) { - char csnbuf[ LDAP_LUTIL_CSNSTR_BUFSIZE ]; + char csnbuf[ LDAP_PVT_CSNSTR_BUFSIZE ]; struct berval csn; if ( SLAP_SYNC_SHADOW( op->o_bd )) { diff --git a/servers/slapd/proto-slap.h b/servers/slapd/proto-slap.h index e97fc5e2c0..bdae077569 100644 --- a/servers/slapd/proto-slap.h +++ b/servers/slapd/proto-slap.h @@ -1977,8 +1977,6 @@ LDAP_SLAPD_V (int) slap_tool_thread_max; LDAP_SLAPD_V (ldap_pvt_thread_mutex_t) entry2str_mutex; -LDAP_SLAPD_V (ldap_pvt_thread_mutex_t) gmtime_mutex; - LDAP_SLAPD_V (ldap_pvt_thread_mutex_t) ad_undef_mutex; LDAP_SLAPD_V (ldap_pvt_thread_mutex_t) oc_undef_mutex; diff --git a/servers/slapd/slapadd.c b/servers/slapd/slapadd.c index b08fd3cea2..b583891582 100644 --- a/servers/slapd/slapadd.c +++ b/servers/slapd/slapadd.c @@ -40,8 +40,8 @@ #include "slapcommon.h" -static char csnbuf[ LDAP_LUTIL_CSNSTR_BUFSIZE ]; -static char maxcsnbuf[ LDAP_LUTIL_CSNSTR_BUFSIZE * ( SLAP_SYNC_SID_MAX + 1 ) ]; +static char csnbuf[ LDAP_PVT_CSNSTR_BUFSIZE ]; +static char maxcsnbuf[ LDAP_PVT_CSNSTR_BUFSIZE * ( SLAP_SYNC_SID_MAX + 1 ) ]; int slapadd( int argc, char **argv ) @@ -120,7 +120,7 @@ slapadd( int argc, char **argv ) if ( update_ctxcsn ) { maxcsn[ 0 ].bv_val = maxcsnbuf; for ( sid = 1; sid <= SLAP_SYNC_SID_MAX; sid++ ) { - maxcsn[ sid ].bv_val = maxcsn[ sid - 1 ].bv_val + LDAP_LUTIL_CSNSTR_BUFSIZE; + maxcsn[ sid ].bv_val = maxcsn[ sid - 1 ].bv_val + LDAP_PVT_CSNSTR_BUFSIZE; maxcsn[ sid ].bv_len = 0; } } @@ -286,7 +286,7 @@ slapadd( int argc, char **argv ) nvals[1].bv_len = 0; nvals[1].bv_val = NULL; - csn.bv_len = lutil_csnstr( csnbuf, sizeof( csnbuf ), csnsid, 0 ); + csn.bv_len = ldap_pvt_csnstr( csnbuf, sizeof( csnbuf ), csnsid, 0 ); csn.bv_val = csnbuf; timestamp.bv_val = timebuf; -- 2.39.5