sync with HEAD

diff --git a/libraries/libldap/result.c b/libraries/libldap/result.c
index 9045dd32fd09d53b9ce2c05f5dd5b5d0dead8678..1226e19316c33988643e261797a95801dd2d296d 100644 (file)
--- a/libraries/libldap/result.c
+++ b/libraries/libldap/result.c
@@ -354,8 +354,7 @@ wait4msg(
                                        ldap_pvt_thread_mutex_lock( &ld->ld_conn_mutex );
 #endif
                                        for ( lc = ld->ld_conns;
-                                               rc == LDAP_MSG_X_KEEP_LOOKING && lc != NULL;
-                                               lc = lc->lconn_next )
+                                               rc == LDAP_MSG_X_KEEP_LOOKING && lc != NULL; )
                                        {
                                                if ( lc->lconn_status == LDAP_CONNST_CONNECTED &&
                                                        ldap_is_read_ready( ld, lc->lconn_sb ) )
@@ -374,8 +373,14 @@ wait4msg(
                                                                 * sane; better restart
                                                                 * (ITS#4405) */
                                                                lc = ld->ld_conns;
+
+                                                               /* don't get to next conn! */
+                                                               break;
                                                        }
                                                }
+
+                                               /* next conn */
+                                               lc = lc->lconn_next;
                                        }
 #ifdef LDAP_R_COMPILE
                                        ldap_pvt_thread_mutex_unlock( &ld->ld_conn_mutex );

diff --git a/servers/slapd/attr.c b/servers/slapd/attr.c
index bb4b4ca6062e464c3d7a54be8088c1340b777b59..fc9579283ae1e3083308da79145e74d5bcea8b2e 100644 (file)
--- a/servers/slapd/attr.c
+++ b/servers/slapd/attr.c
@@ -208,7 +208,9 @@ attr_merge(
                 * of nvals and the value of (*a)->a_nvals must be consistent
                 */
                assert( ( nvals == NULL && (*a)->a_nvals == (*a)->a_vals )
-                               || ( nvals != NULL && (*a)->a_nvals != (*a)->a_vals ) );
+                               || ( nvals != NULL && (
+                                       ( (*a)->a_vals == NULL && (*a)->a_nvals == NULL )
+                                       || ( (*a)->a_nvals != (*a)->a_vals ) ) ) );
        }
 
        rc = value_add( &(*a)->a_vals, vals );

diff --git a/servers/slapd/back-ldap/bind.c b/servers/slapd/back-ldap/bind.c
index 3df85b3cce1ab5fa340e6d332419dbdce2f99cac..51d3456d456fb75de7d6c10261514e0b7b718509 100644 (file)
--- a/servers/slapd/back-ldap/bind.c
+++ b/servers/slapd/back-ldap/bind.c
@@ -921,7 +921,9 @@ ldap_back_dobind_int(
 {      
        ldapinfo_t      *li = (ldapinfo_t *)op->o_bd->be_private;
 
-       int             rc, binding = 0;
+       int             rc,
+                       isbound,
+                       binding = 0;
        ber_int_t       msgid;
 
        assert( retries >= 0 );
@@ -933,8 +935,8 @@ retry_lock:;
 
        if ( binding == 0 ) {
                /* check if already bound */
-               rc = LDAP_BACK_CONN_ISBOUND( lc );
-               if ( rc ) {
+               rc = isbound = LDAP_BACK_CONN_ISBOUND( lc );
+               if ( isbound ) {
                        lc->lc_binding--;
                        if ( dolock ) {
                                ldap_pvt_thread_mutex_unlock( &li->li_conninfo.lai_mutex );
@@ -995,8 +997,7 @@ retry_lock:;
         */
        if ( op->o_conn != NULL &&
                !op->o_do_not_cache &&
-               ( BER_BVISNULL( &lc->lc_bound_ndn ) ||
-                       ( li->li_idassert_flags & LDAP_BACK_AUTH_OVERRIDE ) ) )
+               ( !isbound || ( li->li_idassert_flags & LDAP_BACK_AUTH_OVERRIDE ) ) )
        {
                (void)ldap_back_proxy_authz_bind( lc, op, rs, sendok );
                goto done;
@@ -1417,14 +1418,16 @@ ldap_back_retry( ldapconn_t **lcp, Operation *op, SlapReply *rs, ldap_back_send_
                if ( rc != LDAP_SUCCESS ) {
                        rc = 0;
                        /* freeit, because lc_refcnt == 1 */
-                       (void)ldap_back_conn_free( *lcp );
+                       (*lcp)->lc_refcnt = 0;
+                       (void)ldap_back_freeconn( op, *lcp, 0 );
                        *lcp = NULL;
 
                } else {
                        rc = ldap_back_dobind_int( *lcp, op, rs, sendok, 0, 0 );
                        if ( rc == 0 && *lcp != NULL ) {
                                /* freeit, because lc_refcnt == 1 */
-                               (void)ldap_back_conn_free( *lcp );
+                               (*lcp)->lc_refcnt = 0;
+                               (void)ldap_back_freeconn( op, *lcp, 0 );
                                *lcp = NULL;
                        }
                }

diff --git a/servers/slapd/back-monitor/thread.c b/servers/slapd/back-monitor/thread.c
index 47b39c82d0e475fe45f53370361a3e04c111653f..3ca7207388e0b306cd61b55e380a9ea7a2fa5a97 100644 (file)
--- a/servers/slapd/back-monitor/thread.c
+++ b/servers/slapd/back-monitor/thread.c
@@ -152,8 +152,6 @@ monitor_subsys_thread_init(
                        ms->mss_ndn.bv_val, 0, 0 );
                return( -1 );
        }
-       BER_BVSTR( &bv, "0" );
-       attr_merge_normalize_one( e, mi->mi_ad_monitoredInfo, &bv, NULL );
 
        mp = monitor_entrypriv_create();
        if ( mp == NULL ) {
@@ -188,8 +186,6 @@ monitor_subsys_thread_init(
                        bv.bv_val, ms->mss_ndn.bv_val, 0 );
                return( -1 );
        }
-       BER_BVSTR( &bv, "0" );
-       attr_merge_normalize_one( e, mi->mi_ad_monitoredInfo, &bv, NULL );
 
        mp = monitor_entrypriv_create();
        if ( mp == NULL ) {
@@ -224,23 +220,25 @@ monitor_subsys_thread_update(
 {
        monitor_info_t  *mi = ( monitor_info_t * )op->o_bd->be_private;
        Attribute               *a;
+       BerVarray               vals = NULL;
        char                    buf[ BACKMONITOR_BUFSIZE ];
        enum {
                MT_UNKNOWN,
+               MT_MAX,
                MT_BACKLOAD,
                MT_RUNQUEUE,
                MT_TASKLIST,
-               MT_MAX                          /* unused */
+
+               MT_LAST
        };
        static slap_verbmasks   mt[] = {
+               { BER_BVC( "cn=max" ),          MT_MAX          },
                { BER_BVC( "cn=backload" ),     MT_BACKLOAD     },
                { BER_BVC( "cn=runqueue" ),     MT_RUNQUEUE     },
                { BER_BVC( "cn=tasklist" ),     MT_TASKLIST     },
-               { BER_BVC( "cn=max" ),          MT_UNKNOWN      },
                { BER_BVNULL,                   MT_UNKNOWN      }
        };
        struct berval           rdn, bv;
-       ber_len_t               len;
        int                     which, i;
        struct re_s             *re;
 
@@ -256,80 +254,91 @@ monitor_subsys_thread_update(
        }
 
        a = attr_find( e->e_attrs, mi->mi_ad_monitoredInfo );
-       if ( a == NULL ) {
-               return rs->sr_err = LDAP_OTHER;
-       }
 
        switch ( mt[ which ].mask ) {
+       case MT_MAX:
+               if ( a == NULL ) {
+                       return rs->sr_err = LDAP_OTHER;
+               }
+               bv.bv_val = buf;
+               bv.bv_len = snprintf( buf, sizeof( buf ), "%d", connection_pool_max );
+               if ( bv.bv_len >= sizeof( buf ) ) {
+                       /* FIXME? */
+                       break;
+               }
+               ber_bvreplace( &a->a_vals[ 0 ], &bv );
+               break;
+
        case MT_BACKLOAD:
-               snprintf( buf, sizeof( buf ), "%d", 
+               if ( a == NULL ) {
+                       return rs->sr_err = LDAP_OTHER;
+               }
+               bv.bv_val = buf;
+               bv.bv_len = snprintf( buf, sizeof( buf ), "%d", 
                        ldap_pvt_thread_pool_backload( &connection_pool ) );
-               len = strlen( buf );
-               if ( len > a->a_vals[ 0 ].bv_len ) {
-                       a->a_vals[ 0 ].bv_val = ber_memrealloc( a->a_vals[ 0 ].bv_val, len + 1 );
+               if ( bv.bv_len >= sizeof( buf ) ) {
+                       /* FIXME? */
+                       break;
                }
-               a->a_vals[ 0 ].bv_len = len;
-               AC_MEMCPY( a->a_vals[ 0 ].bv_val, buf, len + 1 );
+               ber_bvreplace( &a->a_vals[ 0 ], &bv );
                break;
 
        case MT_RUNQUEUE:
-               for ( i = 0; !BER_BVISNULL( &a->a_vals[ i ] ); i++ ) {
-                       ch_free( a->a_vals[ i ].bv_val );
-                       BER_BVZERO( &a->a_vals[ i ] );
-               }
-               if ( a->a_nvals != a->a_vals ) {
-                       ber_bvarray_free( a->a_nvals );
+               if ( a != NULL ) {
+                       if ( a->a_nvals != a->a_vals ) {
+                               ber_bvarray_free( a->a_nvals );
+                       }
+                       ber_bvarray_free( a->a_vals );
+                       a->a_vals = NULL;
+                       a->a_nvals = NULL;
                }
-               a->a_nvals = NULL;
+
+               i = 0;
                bv.bv_val = buf;
                ldap_pvt_thread_mutex_lock( &slapd_rq.rq_mutex );
-               i = 0;
                LDAP_STAILQ_FOREACH( re, &slapd_rq.run_list, rnext ) {
                        bv.bv_len = snprintf( buf, sizeof( buf ), "{%d}%s(%s)",
                                i, re->tname, re->tspec );
                        if ( bv.bv_len < sizeof( buf ) ) {
-                               value_add_one( &a->a_vals, &bv );
+                               value_add_one( &vals, &bv );
                        }
                        i++;
                }
                ldap_pvt_thread_mutex_unlock( &slapd_rq.rq_mutex );
 
-               /* don't leave 'round attributes with no values */
-               if ( BER_BVISNULL( &a->a_vals[ 0 ] ) ) {
-                       BER_BVSTR( &bv, "{0}()" );
-                       value_add_one( &a->a_vals, &bv );
+               if ( vals ) {
+                       attr_merge_normalize( e, mi->mi_ad_monitoredInfo, vals, NULL );
+                       ber_bvarray_free( vals );
                }
-               a->a_nvals = a->a_vals;
                break;
 
        case MT_TASKLIST:
-               for ( i = 0; !BER_BVISNULL( &a->a_vals[ i ] ); i++ ) {
-                       ch_free( a->a_vals[ i ].bv_val );
-                       BER_BVZERO( &a->a_vals[ i ] );
-               }
-               if ( a->a_nvals != a->a_vals ) {
-                       ber_bvarray_free( a->a_nvals );
+               if ( a != NULL ) {
+                       if ( a->a_nvals != a->a_vals ) {
+                               ber_bvarray_free( a->a_nvals );
+                       }
+                       ber_bvarray_free( a->a_vals );
+                       a->a_vals = NULL;
+                       a->a_nvals = NULL;
                }
-               a->a_nvals = NULL;
+
+               i = 0;
                bv.bv_val = buf;
                ldap_pvt_thread_mutex_lock( &slapd_rq.rq_mutex );
-               i = 0;
                LDAP_STAILQ_FOREACH( re, &slapd_rq.task_list, tnext ) {
                        bv.bv_len = snprintf( buf, sizeof( buf ), "{%d}%s(%s)",
                                i, re->tname, re->tspec );
                        if ( bv.bv_len < sizeof( buf ) ) {
-                               value_add_one( &a->a_vals, &bv );
+                               value_add_one( &vals, &bv );
                        }
                        i++;
                }
                ldap_pvt_thread_mutex_unlock( &slapd_rq.rq_mutex );
 
-               /* don't leave 'round attributes with no values */
-               if ( BER_BVISNULL( &a->a_vals[ 0 ] ) ) {
-                       BER_BVSTR( &bv, "{0}()" );
-                       value_add_one( &a->a_vals, &bv );
+               if ( vals ) {
+                       attr_merge_normalize( e, mi->mi_ad_monitoredInfo, vals, NULL );
+                       ber_bvarray_free( vals );
                }
-               a->a_nvals = a->a_vals;
                break;
        }
 

diff --git a/servers/slapd/backover.c b/servers/slapd/backover.c
index f14b327019ee72e5a25a283346ff22911a15a439..3ffd18828508066aff7add1f0da3246b26808a82 100644 (file)
--- a/servers/slapd/backover.c
+++ b/servers/slapd/backover.c
@@ -210,10 +210,13 @@ over_db_destroy(
 
        rc = over_db_func( be, db_destroy );
 
-       for (next = on->on_next; on; on=next) {
-               next = on->on_next;
-               free( on );
+       if ( on ) {
+               for (next = on->on_next; on; on=next) {
+                       next = on->on_next;
+                       free( on );
+               }
        }
+
        free( oi );
        return rc;
 }

diff --git a/servers/slapd/connection.c b/servers/slapd/connection.c
index e9e60db17c687ad972bbe0eb33db695e95eec51e..16433b2533a052bbcc1c608fb96c377047dcae5f 100644 (file)
--- a/servers/slapd/connection.c
+++ b/servers/slapd/connection.c
@@ -653,7 +653,7 @@ void connection2anonymous( Connection *c )
 static void
 connection_destroy( Connection *c )
 {
-       ber_socket_t    sd, inval = AC_SOCKET_INVALID;
+       ber_socket_t    sd;
        unsigned long   connid;
        const char              *close_reason;
        Sockbuf                 *sb;
@@ -731,23 +731,17 @@ connection_destroy( Connection *c )
        }
 
        ber_sockbuf_ctrl( sb, LBER_SB_OPT_GET_FD, &sd );
-       slapd_sd_lock();
-
-       ber_sockbuf_ctrl( sb, LBER_SB_OPT_SET_FD, &inval );
-       ber_sockbuf_free( sb );
 
        /* c must be fully reset by this point; when we call slapd_remove
         * it may get immediately reused by a new connection.
         */
        if ( sd != AC_SOCKET_INVALID ) {
-               slapd_remove( sd, 1, 0, 1 );
+               slapd_remove( sd, sb, 1, 0, 0 );
 
                Statslog( LDAP_DEBUG_STATS, (close_reason
                                                                         ? "conn=%lu fd=%ld closed (%s)\n"
                                                                         : "conn=%lu fd=%ld closed\n"),
                        connid, (long) sd, close_reason, 0, 0 );
-       } else {
-               slapd_sd_unlock();
        }
 }
 
@@ -1219,7 +1213,7 @@ void connection_client_stop(
        ber_socket_t s )
 {
        Connection *c;
-       ber_socket_t inval = AC_SOCKET_INVALID;
+       Sockbuf *sb;
 
        /* get (locked) connection */
        c = connection_get( s );
@@ -1230,15 +1224,13 @@ void connection_client_stop(
        c->c_conn_state = SLAP_C_INVALID;
        c->c_struct_state = SLAP_C_UNUSED;
        c->c_close_reason = "?";                        /* should never be needed */
-       slapd_sd_lock();
-       ber_sockbuf_ctrl( c->c_sb, LBER_SB_OPT_SET_FD, &inval );
-       ber_sockbuf_free( c->c_sb );
-       slapd_remove( s, 0, 1, 1 );
+       sb = c->c_sb;
        c->c_sb = ber_sockbuf_alloc( );
        {
                ber_len_t max = sockbuf_max_incoming;
                ber_sockbuf_ctrl( c->c_sb, LBER_SB_OPT_SET_MAX_INCOMING, &max );
        }
+       slapd_remove( s, sb, 0, 1, 0 );
 
        connection_return( c );
 }

diff --git a/servers/slapd/daemon.c b/servers/slapd/daemon.c
index b84d7c5caaee3ac9f14f98749228577abb613dcb..fecc89284678df966b18eca417e54136c00097a7 100644 (file)
--- a/servers/slapd/daemon.c
+++ b/servers/slapd/daemon.c
@@ -501,6 +501,7 @@ void slapd_sd_unlock()
  */
 void slapd_remove(
        ber_socket_t s,
+       Sockbuf *sb,
        int wasactive,
        int wake,
        int locked )
@@ -527,7 +528,8 @@ void slapd_remove(
 
        SLAP_DEL_SOCK(s);
 
-       tcp_close(s);
+       if ( sb )
+               ber_sockbuf_free(sb);
 
        /* If we ran out of file descriptors, we dropped a listener from
         * the select() loop. Now that we're removing a session from our
@@ -1264,7 +1266,7 @@ close_listeners(
                Listener *lr = slap_listeners[l];
 
                if ( lr->sl_sd != AC_SOCKET_INVALID ) {
-                       if ( remove ) slapd_remove( lr->sl_sd, 0, 0, 0 );
+                       if ( remove ) slapd_remove( lr->sl_sd, NULL, 0, 0, 0 );
 
 #ifdef LDAP_PF_LOCAL
                        if ( lr->sl_sa.sa_addr.sa_family == AF_LOCAL ) {

diff --git a/servers/slapd/proto-slap.h b/servers/slapd/proto-slap.h
index 99934a9f80b9664d59c55be93c770a888d274825..640fc982ce1b545f15184799dcfccad824928b75 100644 (file)
--- a/servers/slapd/proto-slap.h
+++ b/servers/slapd/proto-slap.h
@@ -713,8 +713,8 @@ LDAP_SLAPD_F (int) slapd_daemon_init( const char *urls );
 LDAP_SLAPD_F (int) slapd_daemon_destroy(void);
 LDAP_SLAPD_F (int) slapd_daemon(void);
 LDAP_SLAPD_F (Listener **)     slapd_get_listeners LDAP_P((void));
-LDAP_SLAPD_F (void) slapd_remove LDAP_P((ber_socket_t s, int wasactive,
-       int wake, int locked ));
+LDAP_SLAPD_F (void) slapd_remove LDAP_P((ber_socket_t s, Sockbuf *sb,
+       int wasactive, int wake, int locked ));
 LDAP_SLAPD_F (void) slapd_sd_lock();
 LDAP_SLAPD_F (void) slapd_sd_unlock();