]> git.sur5r.net Git - openldap/commitdiff
ITS#6262
authorQuanah Gibson-Mount <quanah@openldap.org>
Mon, 19 Apr 2010 18:53:00 +0000 (18:53 +0000)
committerQuanah Gibson-Mount <quanah@openldap.org>
Mon, 19 Apr 2010 18:53:00 +0000 (18:53 +0000)
27 files changed:
CHANGES
configure.in
contrib/slapd-modules/lastmod/lastmod.c
include/ldap_pvt.h
include/lutil.h
libraries/libldap/ldap-int.h
libraries/libldap/util-int.c
libraries/liblutil/Makefile.in
libraries/liblutil/csn.c [deleted file]
libraries/liblutil/utils.c
servers/slapd/add.c
servers/slapd/back-bdb/delete.c
servers/slapd/back-ldif/ldif.c
servers/slapd/back-monitor/conn.c
servers/slapd/back-monitor/init.c
servers/slapd/back-monitor/time.c
servers/slapd/back-ndb/delete.cpp
servers/slapd/back-sql/add.c
servers/slapd/back-sql/operational.c
servers/slapd/ctxcsn.c
servers/slapd/init.c
servers/slapd/ldapsync.c
servers/slapd/modify.c
servers/slapd/overlays/accesslog.c
servers/slapd/overlays/syncprov.c
servers/slapd/proto-slap.h
servers/slapd/slapadd.c

diff --git a/CHANGES b/CHANGES
index d6df7fd781b0c90c752772c3c387f1db573004c8..bd77ab2c0d9210ef26256b0114da4468aba0cd69 100644 (file)
--- a/CHANGES
+++ b/CHANGES
@@ -6,6 +6,7 @@ OpenLDAP 2.4.22 Engineering
        Added slapd syncrepl TCP keepalive (ITS#6389)
        Added slapo-ldap idassert-passthru (ITS#6456)
        Added slapo-pbind
+       Fixed libldap gmtime re-entrancy (ITS#6262)
        Fixed libldap GnuTLS serial length (ITS#6460)
        Fixed libldap MozNSS context and PEM support (ITS#6432)
        Fixed libldap referral on bind behavior(ITS#6510)
@@ -16,6 +17,7 @@ OpenLDAP 2.4.22 Engineering
        Fixed slapd glued misplaced entries (ITS#6506)
        Fixed slapd glued paged cookies (ITS#6507)
        Fixed slapd glued paged results (ITS#6504)
+       Fixed slapd gmtime re-entrancy (ITS#6262)
        Fixed slapd ignore controls with unrecognized flags (ITS#6480)
        Fixed slapd REP_ENTRY flag handling (ITS#5340)
        Fixed slapd sasl auxprop_lookup (ITS#6441)
index 6d5a738f73806eca1b4b4ef5ff2751233769124e..ba05a5abf6ecfeba4e6a32401019f635b8eae177 100644 (file)
@@ -1836,6 +1836,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 \
 )
 
index d4d108ccb03f3a8a1d9f30207a761d31d9172fd7..4e972c07815c5715cb6bc2c287de5aed9d4cc27d 100644 (file)
@@ -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;
 
index e0d8ccd61e61630e885dca603d8b367c5467058a..3256e058e0e051958df5ab54be9f1a6377907f16 100644 (file)
@@ -91,6 +91,47 @@ ldap_pvt_ctime LDAP_P((
        const time_t *tp,
        char *buf ));
 
+# if defined( HAVE_GMTIME_R )
+#   define USE_GMTIME_R
+#   define ldap_pvt_gmtime(timep, result) gmtime_r((timep), (result))
+# else
+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
+
+#if defined( USE_GMTIME_R ) && defined( USE_LOCALTIME_R )
+#   define ldap_pvt_gmtime_lock() (0)
+#   define ldap_pvt_gmtime_unlock() (0)
+#else
+LDAP_F( int )
+ldap_pvt_gmtime_lock LDAP_P(( void ));
+
+LDAP_F( int )
+ldap_pvt_gmtime_unlock LDAP_P(( void ));
+#endif /* USE_GMTIME_R && USE_LOCALTIME_R */
+
+/* Get current time as a structured time */
+struct lutil_tm;
+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 <netdb.h> */
index 8bfc9cce46f80439218d77c9fa239eac6577a2fc..e078aaef88edae0385ef69dda12a03205109e743 100644 (file)
@@ -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 ));
@@ -231,12 +227,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
index 577da5ac49ef140b65d25c406a38138177bba26f..55b039c739e6a184814e5d7492ddfbb8e9fe9b85 100644 (file)
@@ -25,6 +25,7 @@
 #endif
 
 #include "../liblber/lber-int.h"
+#include "lutil.h"
 
 #ifdef LDAP_R_COMPILE
 #include <ldap_pvt_thread.h>
index c71aa6d73984ec01905383dafe991d5967431cfd..0704f9a9516c95d5f6de9460a4b9a3ff6acaf864 100644 (file)
@@ -66,6 +66,20 @@ 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 */
+
+#ifdef LDAP_DEVEL
+       /* to be released with 2.5 */
+#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
+#else /* ! LDAP_DEVEL */
+       ldap_pvt_thread_mutex_t ldap_int_gmtime_mutex;
+#endif /* ! LDAP_DEVEL */
+
 # 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 +121,212 @@ char *ldap_pvt_ctime( const time_t *tp, char *buf )
 #endif 
 }
 
+#if !defined( USE_GMTIME_R ) || !defined( USE_LOCALTIME_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 */
+}
+#endif /* !USE_GMTIME_R || !USE_LOCALTIME_R */
+
+#ifndef USE_GMTIME_R
+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 = NULL;
+
+       } else {
+               *result = *tm_ptr;
+       }
+
+# ifdef LDAP_R_COMPILE
+       ldap_pvt_thread_mutex_unlock( &ldap_int_gmtime_mutex );
+# endif /* LDAP_R_COMPILE */
+
+       return result;
+}
+#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 = NULL;
+
+       } else {
+               *result = *tm_ptr;
+       }
+
+# ifdef LDAP_R_COMPILE
+       ldap_pvt_thread_mutex_unlock( &ldap_int_gmtime_mutex );
+# endif /* LDAP_R_COMPILE */
+
+       return result;
+}
+#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 +625,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 );
 
index d21b248227e2b229f597cf31ab7ea4e226e645c5..b527966ebb36aea762524a5d715c375fe552bc4d 100644 (file)
@@ -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 (file)
index 75c5f20..0000000
+++ /dev/null
@@ -1,82 +0,0 @@
-/* csn.c - Change Sequence Number routines */
-/* $OpenLDAP$ */
-/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
- *
- * Copyright 2000-2010 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
- * <http://www.OpenLDAP.org/license.html>.
- */
-/* 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 <stdio.h>
-#include <ac/time.h>
-
-#include <lutil.h>
-
-/* 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
index 09e02c031b0fe86c04d40822aeadd62557f1290e..0fdd00027ca4ddae0a42d9f6ca1ce26203b11e1a 100644 (file)
@@ -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.
index b3be45ceb1ec4bdd64c8e4e26c2de032aced9c7f..e8e42bd52a390e4935e99ae779d43aaa885089cc 100644 (file)
@@ -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 ) ) {
index f59ab26df1af59630d67e3079a1aac754ee5231f..0a32934d5d0b6b803dad5d5006a729403d74295e 100644 (file)
@@ -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);
index 6d4cc61030b5210ac124fb0612a473b7efd73171..671550919b578513d6ccb31059889af965cfa632 100644 (file)
@@ -1324,7 +1324,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 );
index 2b1bdb04eebe3b194de72df3311824609c37c94a..8f2a70fa10ae410ff44035a4b643feeab9900221 100644 (file)
@@ -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 ) {
index 8dc5a429ada8506030b7afc7b94768bca6298b16..1648cbe1bb6677fc2e05a48b2462b837101ae3cf 100644 (file)
@@ -2208,10 +2208,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."),
@@ -2230,27 +2227,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 );
index 6734009cfdceb57596edc9a0a8451a285fb92b01..9daa415d22db8fdd81a7d187b12365935f2022c6 100644 (file)
@@ -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 );
 
index 9eedc9b0df3ad5900af916f77c81cac4f649f352..c5adf46ea3e164ec56192200c2c1cd47ebd6a147 100644 (file)
@@ -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);
index ac7224535288f5214311af07cfaa62aead0c5ac4..f4dda1e9ce8f51b48af91b58edd1ca5116e5344a 100644 (file)
@@ -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;
index c9a554ea4077eb999b621db2a0fbb1f5ea9330b7..eee3aea706e9896ebfc8b099afb235847727a6c7 100644 (file)
@@ -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;
 
index 13f764d54418c6408d1861171ab06258d5870f9e..26f59dc837f4e0bd7c24983e409a41ee94c04a99 100644 (file)
@@ -30,7 +30,7 @@ const struct berval slap_ldapsync_bv = BER_BVC("ldapsync");
 const struct berval slap_ldapsync_cn_bv = BER_BVC("cn=ldapsync");
 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,
@@ -44,7 +44,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;
@@ -209,13 +209,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;
 }
index 4460e465cc0f5cdb5ad0fd93f01116ba21cc4289..d3eb808a88595b057121c6b7e8d09cfc076e1ba8 100644 (file)
@@ -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();
index d65c1f05ee984dae9f9933962e48a5951c8ce42c..69efb953f838ba99c0626cd8d3ecab83b1f73147 100644 (file)
@@ -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;
index 92e9fc233654c3bcf10543a5f8135291d57f6d52..f8c6394b40354bf9201edc1fb3cfe2dc5753da42 100644 (file)
@@ -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, &ltm_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, &ltm );
 
-#ifndef HAVE_GMTIME_R
-       ldap_pvt_thread_mutex_unlock( &gmtime_mutex );
-#endif
+       bv->bv_len = lutil_gentime( bv->bv_val, bv->bv_len, &ltm );
 }
 
 /* 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;
 
index df7c9573a48768cb859387ee415c04f6b60bc512..0d1de46bb02e19529e4091c50062d0c626a589bc 100644 (file)
@@ -616,7 +616,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 );
index 4ee8a23abcb2659c304c3fa5f0fda151079a3b2c..ce071ca0ff16401f19f1935eb008716f660b3814 100644 (file)
@@ -591,8 +591,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;
@@ -1535,7 +1535,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];
 
@@ -1710,7 +1710,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;
 
                ldap_pvt_thread_mutex_lock( &si->si_resp_mutex );
@@ -2860,7 +2860,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;
@@ -2966,7 +2966,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 )) {
index fb8b29515e3a84760d4340510f1c7ec6527fc05d..fa225d9e7ed485393e20967bf3984fd9fcac6d6f 100644 (file)
@@ -1986,7 +1986,10 @@ 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;
+#ifndef LDAP_DEVEL
+       /* to be removed with 2.5 */
+#define gmtime_mutex ldap_int_gmtime_mutex
+#endif /* ! LDAP_DEVEL */
 
 LDAP_SLAPD_V (ldap_pvt_thread_mutex_t) ad_undef_mutex;
 LDAP_SLAPD_V (ldap_pvt_thread_mutex_t) oc_undef_mutex;
index ddac37f926cbcabacc480bc6c2e5788e8b766329..fe205eafb5f00bff907d0a83a8c2c3845be565a6 100644 (file)
@@ -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;
                }
        }
@@ -293,7 +293,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;