* _HEAD + + + + +
* _ENTRY + + + + +
* _INIT + + + + +
+ * _ENTRY_INIT + + + + +
* _EMPTY + + + + +
* _FIRST + + + + +
* _NEXT + + + + +
(head)->slh_first = NULL; \
}
+#define LDAP_SLIST_ENTRY_INIT(var, field) { \
+ (var)->field.sle_next = NULL; \
+}
+
#define LDAP_SLIST_INSERT_AFTER(slistelm, elm, field) do { \
(elm)->field.sle_next = (slistelm)->field.sle_next; \
(slistelm)->field.sle_next = (elm); \
(head)->stqh_last = &(head)->stqh_first; \
} while (0)
+#define LDAP_STAILQ_ENTRY_INIT(var, field) { \
+ (entry)->field.stqe_next = NULL; \
+}
+
#define LDAP_STAILQ_FIRST(head) ((head)->stqh_first)
#define LDAP_STAILQ_LAST(head, type, field) \
(head)->lh_first = NULL; \
} while (0)
+#define LDAP_LIST_ENTRY_INIT(var, field) do { \
+ (var)->field.le_next = NULL; \
+ (var)->field.le_prev = NULL; \
+} while (0)
+
#define LDAP_LIST_INSERT_AFTER(listelm, elm, field) do { \
if (((elm)->field.le_next = (listelm)->field.le_next) != NULL) \
(listelm)->field.le_next->field.le_prev = \
(head)->tqh_last = &(head)->tqh_first; \
} while (0)
+#define LDAP_TAILQ_ENTRY_INIT(var, field) do { \
+ (var)->field.tqe_next = NULL; \
+ (var)->field.tqe_prev = NULL; \
+} while (0)
+
#define LDAP_TAILQ_INSERT_HEAD(head, elm, field) do { \
if (((elm)->field.tqe_next = (head)->tqh_first) != NULL) \
(head)->tqh_first->field.tqe_prev = \
(head)->cqh_last = (void *)(head); \
} while (0)
+#define LDAP_CIRCLEQ_ENTRY_INIT(var, field) do { \
+ (var)->field.cqe_next = NULL; \
+ (var)->field.cqe_prev = NULL; \
+} while (0)
+
#define LDAP_CIRCLEQ_INSERT_AFTER(head, listelm, elm, field) do { \
(elm)->field.cqe_next = (listelm)->field.cqe_next; \
(elm)->field.cqe_prev = (listelm); \
}
if ( lc ) {
- ldap_back_release_conn( op, rs, lc );
+ ldap_back_release_conn( li, lc );
}
Debug( LDAP_DEBUG_ARGS, "<== ldap_back_add(\"%s\"): %d\n",
#define LDAP_BACK_FCONN_ISTLS (0x00000008U)
#define LDAP_BACK_FCONN_BINDING (0x00000010U)
#define LDAP_BACK_FCONN_TAINTED (0x00000020U)
-#define LDAP_BACK_FCONN_ISIDASR (0x00000040U)
-#define LDAP_BACK_FCONN_CACHED (0x00000080U)
+#define LDAP_BACK_FCONN_ABANDON (0x00000040U)
+#define LDAP_BACK_FCONN_ISIDASR (0x00000080U)
+#define LDAP_BACK_FCONN_CACHED (0x00000100U)
#define LDAP_BACK_CONN_ISBOUND(lc) LDAP_BACK_CONN_ISSET((lc), LDAP_BACK_FCONN_ISBOUND)
#define LDAP_BACK_CONN_ISBOUND_SET(lc) LDAP_BACK_CONN_SET((lc), LDAP_BACK_FCONN_ISBOUND)
#define LDAP_BACK_CONN_TAINTED(lc) LDAP_BACK_CONN_ISSET((lc), LDAP_BACK_FCONN_TAINTED)
#define LDAP_BACK_CONN_TAINTED_SET(lc) LDAP_BACK_CONN_SET((lc), LDAP_BACK_FCONN_TAINTED)
#define LDAP_BACK_CONN_TAINTED_CLEAR(lc) LDAP_BACK_CONN_CLEAR((lc), LDAP_BACK_FCONN_TAINTED)
+#define LDAP_BACK_CONN_ABANDON(lc) LDAP_BACK_CONN_ISSET((lc), LDAP_BACK_FCONN_ABANDON)
+#define LDAP_BACK_CONN_ABANDON_SET(lc) LDAP_BACK_CONN_SET((lc), LDAP_BACK_FCONN_ABANDON)
+#define LDAP_BACK_CONN_ABANDON_CLEAR(lc) LDAP_BACK_CONN_CLEAR((lc), LDAP_BACK_FCONN_ABANDON)
#define LDAP_BACK_CONN_ISIDASSERT(lc) LDAP_BACK_CONN_ISSET((lc), LDAP_BACK_FCONN_ISIDASR)
#define LDAP_BACK_CONN_ISIDASSERT_SET(lc) LDAP_BACK_CONN_SET((lc), LDAP_BACK_FCONN_ISIDASR)
#define LDAP_BACK_CONN_ISIDASSERT_CLEAR(lc) LDAP_BACK_CONN_CLEAR((lc), LDAP_BACK_FCONN_ISIDASR)
#define LDAP_BACK_CONN_CACHED_CLEAR(lc) LDAP_BACK_CONN_CLEAR((lc), LDAP_BACK_FCONN_CACHED)
unsigned lc_refcnt;
- unsigned lc_binding;
unsigned lc_flags;
time_t lc_create_time;
time_t lc_time;
#define LDAP_BACK_F_USE_TLS (0x00000002U)
#define LDAP_BACK_F_PROPAGATE_TLS (0x00000004U)
#define LDAP_BACK_F_TLS_CRITICAL (0x00000008U)
+#define LDAP_BACK_F_TLS_LDAPS (0x00000010U)
+
#define LDAP_BACK_F_TLS_USE_MASK (LDAP_BACK_F_USE_TLS|LDAP_BACK_F_TLS_CRITICAL)
#define LDAP_BACK_F_TLS_PROPAGATE_MASK (LDAP_BACK_F_PROPAGATE_TLS|LDAP_BACK_F_TLS_CRITICAL)
-#define LDAP_BACK_F_TLS_MASK (LDAP_BACK_F_TLS_USE_MASK|LDAP_BACK_F_TLS_PROPAGATE_MASK)
-#define LDAP_BACK_F_CHASE_REFERRALS (0x00000010U)
-#define LDAP_BACK_F_PROXY_WHOAMI (0x00000020U)
+#define LDAP_BACK_F_TLS_MASK (LDAP_BACK_F_TLS_USE_MASK|LDAP_BACK_F_TLS_PROPAGATE_MASK|LDAP_BACK_F_TLS_LDAPS)
+#define LDAP_BACK_F_CHASE_REFERRALS (0x00000020U)
+#define LDAP_BACK_F_PROXY_WHOAMI (0x00000040U)
-#define LDAP_BACK_F_T_F (0x00000040U)
-#define LDAP_BACK_F_T_F_DISCOVER (0x00000080U)
+#define LDAP_BACK_F_T_F (0x00000080U)
+#define LDAP_BACK_F_T_F_DISCOVER (0x00000100U)
#define LDAP_BACK_F_T_F_MASK (LDAP_BACK_F_T_F)
#define LDAP_BACK_F_T_F_MASK2 (LDAP_BACK_F_T_F_MASK|LDAP_BACK_F_T_F_DISCOVER)
-#define LDAP_BACK_F_MONITOR (0x00000100U)
-#define LDAP_BACK_F_SINGLECONN (0x00000200U)
-#define LDAP_BACK_F_USE_TEMPORARIES (0x00000400U)
+#define LDAP_BACK_F_MONITOR (0x00000200U)
+#define LDAP_BACK_F_SINGLECONN (0x00000400U)
+#define LDAP_BACK_F_USE_TEMPORARIES (0x00000800U)
-#define LDAP_BACK_F_ISOPEN (0x00000800U)
+#define LDAP_BACK_F_ISOPEN (0x00001000U)
#define LDAP_BACK_F_CANCEL_ABANDON (0x00000000U)
-#define LDAP_BACK_F_CANCEL_IGNORE (0x00001000U)
-#define LDAP_BACK_F_CANCEL_EXOP (0x00002000U)
-#define LDAP_BACK_F_CANCEL_EXOP_DISCOVER (0x00004000U)
+#define LDAP_BACK_F_CANCEL_IGNORE (0x00002000U)
+#define LDAP_BACK_F_CANCEL_EXOP (0x00004000U)
+#define LDAP_BACK_F_CANCEL_EXOP_DISCOVER (0x00008000U)
#define LDAP_BACK_F_CANCEL_MASK (LDAP_BACK_F_CANCEL_IGNORE|LDAP_BACK_F_CANCEL_EXOP)
#define LDAP_BACK_F_CANCEL_MASK2 (LDAP_BACK_F_CANCEL_MASK|LDAP_BACK_F_CANCEL_EXOP_DISCOVER)
#endif /* LDAP_BACK_PRINT_CONNTREE */
static int
-ldap_back_freeconn( Operation *op, ldapconn_t *lc, int dolock );
+ldap_back_freeconn( ldapinfo_t *li, ldapconn_t *lc, int dolock );
static ldapconn_t *
ldap_back_getconn( Operation *op, SlapReply *rs, ldap_back_send_t sendok,
ldap_back_send_t sendok, struct berval *binddn, struct berval *bindcred );
static int
-ldap_back_prepare_conn( ldapconn_t **lcp, Operation *op, SlapReply *rs,
+ldap_back_prepare_conn( ldapconn_t *lc, Operation *op, SlapReply *rs,
ldap_back_send_t sendok );
static int
ldap_back_conndnlc_cmp( const void *c1, const void *c2 );
+ldapconn_t *
+ldap_back_conn_delete( ldapinfo_t *li, ldapconn_t *lc )
+{
+ if ( LDAP_BACK_PCONN_ISPRIV( lc ) ) {
+ if ( LDAP_BACK_CONN_CACHED( lc ) ) {
+ assert( lc->lc_q.tqe_prev != NULL );
+ assert( li->li_conn_priv[ LDAP_BACK_CONN2PRIV( lc ) ].lic_num > 0 );
+ li->li_conn_priv[ LDAP_BACK_CONN2PRIV( lc ) ].lic_num--;
+ LDAP_TAILQ_REMOVE( &li->li_conn_priv[ LDAP_BACK_CONN2PRIV( lc ) ].lic_priv, lc, lc_q );
+ LDAP_TAILQ_ENTRY_INIT( lc, lc_q );
+ LDAP_BACK_CONN_CACHED_CLEAR( lc );
+
+ } else {
+ assert( LDAP_BACK_CONN_TAINTED( lc ) );
+ assert( lc->lc_q.tqe_prev == NULL );
+ }
+
+ } else {
+ ldapconn_t *tmplc = NULL;
+
+ if ( LDAP_BACK_CONN_CACHED( lc ) ) {
+ assert( !LDAP_BACK_CONN_TAINTED( lc ) );
+ tmplc = avl_delete( &li->li_conninfo.lai_tree, (caddr_t)lc,
+ ldap_back_conndnlc_cmp );
+ assert( tmplc == lc );
+ LDAP_BACK_CONN_CACHED_CLEAR( lc );
+ }
+
+ assert( LDAP_BACK_CONN_TAINTED( lc ) || tmplc == lc );
+ }
+
+ return lc;
+}
+
int
ldap_back_bind( Operation *op, SlapReply *rs )
{
* connection with identity assertion */
/* NOTE: use with care */
if ( li->li_idassert_flags & LDAP_BACK_AUTH_OVERRIDE ) {
- assert( lc->lc_binding == 1 );
- lc->lc_binding = 0;
- ldap_back_release_conn( op, rs, lc );
+ ldap_back_release_conn( li, lc );
return( rc );
}
}
}
- assert( lc->lc_binding == 1 );
- lc->lc_binding = 0;
-
/* must re-insert if local DN changed as result of bind */
if ( !LDAP_BACK_CONN_ISBOUND( lc )
|| ( !dn_match( &op->o_req_ndn, &lc->lc_local_ndn )
#endif /* LDAP_BACK_PRINT_CONNTREE */
assert( lc->lc_refcnt == 1 );
- if ( LDAP_BACK_PCONN_ISPRIV( lc ) ) {
- /* this can happen, for example, if the bind fails
- * for some reason... */
- if ( lc->lc_q.tqe_prev != NULL ) {
- assert( LDAP_BACK_CONN_CACHED( lc ) );
- assert( li->li_conn_priv[ LDAP_BACK_CONN2PRIV( lc ) ].lic_num > 0 );
- LDAP_TAILQ_REMOVE( &li->li_conn_priv[ LDAP_BACK_CONN2PRIV( lc ) ].lic_priv, lc, lc_q );
- li->li_conn_priv[ LDAP_BACK_CONN2PRIV( lc ) ].lic_num--;
- lc->lc_q.tqe_prev = NULL;
- lc->lc_q.tqe_next = NULL;
-
- } else {
- assert( !LDAP_BACK_CONN_CACHED( lc ) );
- }
-
- } else {
- tmplc = avl_delete( &li->li_conninfo.lai_tree, (caddr_t)lc,
- ldap_back_conndnlc_cmp );
- assert( ( LDAP_BACK_CONN_TAINTED( lc ) && tmplc == NULL ) || lc == tmplc );
- }
- LDAP_BACK_CONN_CACHED_CLEAR( lc );
+ ldap_back_conn_delete( li, lc );
/* delete all cached connections with the current connection */
if ( LDAP_BACK_SINGLECONN( li ) ) {
}
if ( lc != NULL ) {
- ldap_back_release_conn( op, rs, lc );
+ ldap_back_release_conn( li, lc );
}
return( rc );
}
static int
-ldap_back_freeconn( Operation *op, ldapconn_t *lc, int dolock )
+ldap_back_freeconn( ldapinfo_t *li, ldapconn_t *lc, int dolock )
{
- ldapinfo_t *li = (ldapinfo_t *) op->o_bd->be_private;
-
if ( dolock ) {
ldap_pvt_thread_mutex_lock( &li->li_conninfo.lai_mutex );
}
ldap_back_print_conntree( li, ">>> ldap_back_freeconn" );
#endif /* LDAP_BACK_PRINT_CONNTREE */
- if ( LDAP_BACK_PCONN_ISPRIV( lc ) ) {
- if ( lc->lc_q.tqe_prev != NULL ) {
- assert( LDAP_BACK_CONN_CACHED( lc ) );
- assert( li->li_conn_priv[ LDAP_BACK_CONN2PRIV( lc ) ].lic_num > 0 );
- li->li_conn_priv[ LDAP_BACK_CONN2PRIV( lc ) ].lic_num--;
- LDAP_TAILQ_REMOVE( &li->li_conn_priv[ LDAP_BACK_CONN2PRIV( lc ) ].lic_priv, lc, lc_q );
- LDAP_BACK_CONN_CACHED_CLEAR( lc );
-
- } else {
- assert( !LDAP_BACK_CONN_CACHED( lc ) );
- }
- lc->lc_q.tqe_prev = NULL;
- lc->lc_q.tqe_next = NULL;
-
- } else {
- ldapconn_t *tmplc = NULL;
-
- if ( LDAP_BACK_CONN_CACHED( lc ) ) {
- tmplc = avl_delete( &li->li_conninfo.lai_tree, (caddr_t)lc,
- ldap_back_conndnlc_cmp );
- assert( tmplc == lc );
- LDAP_BACK_CONN_CACHED_CLEAR( lc );
- }
- assert( LDAP_BACK_CONN_TAINTED( lc ) || tmplc == lc );
- }
+ (void)ldap_back_conn_delete( li, lc );
if ( lc->lc_refcnt == 0 ) {
ldap_back_conn_free( (void *)lc );
#endif /* HAVE_TLS */
static int
-ldap_back_prepare_conn( ldapconn_t **lcp, Operation *op, SlapReply *rs, ldap_back_send_t sendok )
+ldap_back_prepare_conn( ldapconn_t *lc, Operation *op, SlapReply *rs, ldap_back_send_t sendok )
{
ldapinfo_t *li = (ldapinfo_t *)op->o_bd->be_private;
int version;
time_t lc_time = (time_t)(-1);
#endif /* HAVE_TLS */
- assert( lcp != NULL );
-
ldap_pvt_thread_mutex_lock( &li->li_uri_mutex );
rs->sr_err = ldap_initialize( &ld, li->li_uri );
ldap_pvt_thread_mutex_unlock( &li->li_uri_mutex );
}
#endif /* HAVE_TLS */
- if ( *lcp == NULL ) {
- *lcp = (ldapconn_t *)ch_calloc( 1, sizeof( ldapconn_t ) );
- (*lcp)->lc_flags = li->li_flags;
- }
- (*lcp)->lc_ld = ld;
- (*lcp)->lc_refcnt = 1;
- (*lcp)->lc_binding = 1;
+ lc->lc_ld = ld;
+ lc->lc_refcnt = 1;
#ifdef HAVE_TLS
if ( is_tls ) {
- LDAP_BACK_CONN_ISTLS_SET( *lcp );
+ LDAP_BACK_CONN_ISTLS_SET( lc );
} else {
- LDAP_BACK_CONN_ISTLS_CLEAR( *lcp );
+ LDAP_BACK_CONN_ISTLS_CLEAR( lc );
}
if ( lc_time != (time_t)(-1) ) {
- (*lcp)->lc_time = lc_time;
+ lc->lc_time = lc_time;
}
#endif /* HAVE_TLS */
} else {
if ( li->li_conn_ttl > 0 ) {
- (*lcp)->lc_create_time = op->o_time;
+ lc->lc_create_time = op->o_time;
}
}
ldapconn_t *lc = NULL,
lc_curr = { 0 };
int refcnt = 1,
- binding = 1,
lookupconn = !( sendok & LDAP_BACK_BINDING );
/* if the server is quarantined, and
{
LDAP_TAILQ_REMOVE( &li->li_conn_priv[ LDAP_BACK_CONN2PRIV( lc ) ].lic_priv,
lc, lc_q );
- lc->lc_q.tqe_prev = NULL;
- lc->lc_q.tqe_next = NULL;
+ LDAP_TAILQ_ENTRY_INIT( lc, lc_q );
LDAP_TAILQ_INSERT_TAIL( &li->li_conn_priv[ LDAP_BACK_CONN2PRIV( lc ) ].lic_priv,
lc, lc_q );
}
}
refcnt = ++lc->lc_refcnt;
- binding = ++lc->lc_binding;
}
}
ldap_pvt_thread_mutex_unlock( &li->li_conninfo.lai_mutex );
/* Looks like we didn't get a bind. Open a new session... */
if ( lc == NULL ) {
- if ( ldap_back_prepare_conn( &lc, op, rs, sendok ) != LDAP_SUCCESS ) {
+ lc = (ldapconn_t *)ch_calloc( 1, sizeof( ldapconn_t ) );
+ lc->lc_flags = li->li_flags;
+ lc->lc_lcflags = lc_curr.lc_lcflags;
+ if ( ldap_back_prepare_conn( lc, op, rs, sendok ) != LDAP_SUCCESS ) {
+ ch_free( lc );
return NULL;
}
if ( tmplc != NULL ) {
refcnt = ++tmplc->lc_refcnt;
- binding = ++tmplc->lc_binding;
ldap_back_conn_free( lc );
lc = tmplc;
}
LDAP_BACK_CONN_ISBOUND_CLEAR( lc );
assert( lc->lc_refcnt == 1 );
- assert( lc->lc_binding == 1 );
#if LDAP_BACK_PRINT_CONNTREE > 0
ldap_back_print_conntree( li, ">>> ldap_back_getconn(insert)" );
char buf[ SLAP_TEXT_BUFLEN ];
snprintf( buf, sizeof( buf ),
- "lc=%p inserted refcnt=%u binding=%u rc=%d",
- (void *)lc, refcnt, binding, rs->sr_err );
+ "lc=%p inserted refcnt=%u rc=%d",
+ (void *)lc, refcnt, rs->sr_err );
Debug( LDAP_DEBUG_TRACE,
"=>ldap_back_getconn: %s: %s\n",
ldap_back_print_conntree( li, ">>> ldap_back_getconn(timeout)" );
#endif /* LDAP_BACK_PRINT_CONNTREE */
- if ( LDAP_BACK_PCONN_ISPRIV( lc ) ) {
- if ( lc->lc_q.tqe_prev != NULL ) {
- assert( LDAP_BACK_CONN_CACHED( lc ) );
- assert( li->li_conn_priv[ LDAP_BACK_CONN2PRIV( lc ) ].lic_num > 0 );
- LDAP_TAILQ_REMOVE( &li->li_conn_priv[ LDAP_BACK_CONN2PRIV( lc ) ].lic_priv,
- lc, lc_q );
- li->li_conn_priv[ LDAP_BACK_CONN2PRIV( lc ) ].lic_num--;
- lc->lc_q.tqe_prev = NULL;
- lc->lc_q.tqe_next = NULL;
-
- } else {
- assert( !LDAP_BACK_CONN_CACHED( lc ) );
- }
-
- } else {
- (void)avl_delete( &li->li_conninfo.lai_tree, (caddr_t)lc,
- ldap_back_conndnlc_cmp );
- }
+ (void)ldap_back_conn_delete( li, lc );
LDAP_BACK_CONN_TAINTED_SET( lc );
- LDAP_BACK_CONN_CACHED_CLEAR( lc );
#if LDAP_BACK_PRINT_CONNTREE > 0
ldap_back_print_conntree( li, "<<< ldap_back_getconn(timeout)" );
char buf[ SLAP_TEXT_BUFLEN ];
snprintf( buf, sizeof( buf ),
- "conn %p fetched refcnt=%u binding=%u%s",
- (void *)lc, refcnt, binding, expiring ? " expiring" : "" );
+ "conn %p fetched refcnt=%u%s",
+ (void *)lc, refcnt,
+ expiring ? " expiring" : "" );
Debug( LDAP_DEBUG_TRACE,
"=>ldap_back_getconn: %s.\n", buf, 0, 0 );
}
void
ldap_back_release_conn_lock(
- Operation *op,
- SlapReply *rs,
+ ldapinfo_t *li,
ldapconn_t **lcp,
int dolock )
{
- ldapinfo_t *li = (ldapinfo_t *)op->o_bd->be_private;
ldapconn_t *lc = *lcp;
LDAP_BACK_CONN_BINDING_CLEAR( lc );
lc->lc_refcnt--;
if ( LDAP_BACK_CONN_TAINTED( lc ) ) {
- ldap_back_freeconn( op, lc, 0 );
+ ldap_back_freeconn( li, lc, 0 );
*lcp = NULL;
}
if ( dolock ) {
/* check if already bound */
rc = isbound = LDAP_BACK_CONN_ISBOUND( lc );
if ( isbound ) {
- lc->lc_binding--;
if ( dolock ) {
ldap_pvt_thread_mutex_unlock( &li->li_conninfo.lai_mutex );
}
}
}
- /* wait for pending operations to finish */
- /* FIXME: may become a bottleneck! */
- if ( lc->lc_refcnt != lc->lc_binding ) {
- if ( dolock ) {
- ldap_pvt_thread_mutex_unlock( &li->li_conninfo.lai_mutex );
- }
- ldap_pvt_thread_yield();
- goto retry_lock;
- }
-
if ( dolock ) {
ldap_pvt_thread_mutex_unlock( &li->li_conninfo.lai_mutex );
}
lc->lc_ld = NULL;
/* lc here must be the regular lc, reset and ready for init */
- rs->sr_err = ldap_back_prepare_conn( &lc, op, rs, sendok );
+ rs->sr_err = ldap_back_prepare_conn( lc, op, rs, sendok );
if ( rs->sr_err != LDAP_SUCCESS ) {
- lc->lc_binding--;
lc->lc_refcnt = 0;
}
}
}
goto retry;
}
-
- } else {
- if ( dolock ) {
- ldap_pvt_thread_mutex_lock( &li->li_conninfo.lai_mutex );
- }
- lc->lc_binding--;
- if ( dolock ) {
- ldap_pvt_thread_mutex_unlock( &li->li_conninfo.lai_mutex );
- }
}
- /* FIXME: one binding-- too many? */
- lc->lc_binding--;
assert( lc->lc_refcnt == 1 );
lc->lc_refcnt = 0;
- ldap_back_freeconn( op, lc, dolock );
+ ldap_back_freeconn( li, lc, dolock );
*lcp = NULL;
rs->sr_err = slap_map_api2result( rs );
}
done:;
- lc->lc_binding--;
LDAP_BACK_CONN_BINDING_CLEAR( lc );
rc = LDAP_BACK_CONN_ISBOUND( lc );
if ( !rc ) {
- ldap_back_release_conn_lock( op, rs, lcp, dolock );
+ ldap_back_release_conn_lock( li, lcp, dolock );
} else if ( LDAP_BACK_SAVECRED( li ) ) {
ldap_set_rebind_proc( lc->lc_ld, li->li_rebind_f, lc );
LDAP_BACK_CONN_ISBOUND_CLEAR( (*lcp) );
/* lc here must be the regular lc, reset and ready for init */
- rc = ldap_back_prepare_conn( lcp, op, rs, sendok );
+ rc = ldap_back_prepare_conn( *lcp, op, rs, sendok );
if ( rc != LDAP_SUCCESS ) {
/* freeit, because lc_refcnt == 1 */
(*lcp)->lc_refcnt = 0;
- (void)ldap_back_freeconn( op, *lcp, 0 );
+ (void)ldap_back_freeconn( li, *lcp, 0 );
*lcp = NULL;
rc = 0;
/* freeit, because lc_refcnt == 1 */
(*lcp)->lc_refcnt = 0;
LDAP_BACK_CONN_TAINTED_SET( *lcp );
- (void)ldap_back_freeconn( op, *lcp, 0 );
+ (void)ldap_back_freeconn( li, *lcp, 0 );
*lcp = NULL;
}
}
(void *)(*lcp), (*lcp)->lc_refcnt, 0 );
LDAP_BACK_CONN_TAINTED_SET( *lcp );
- ldap_back_release_conn_lock( op, rs, lcp, 0 );
+ ldap_back_release_conn_lock( li, lcp, 0 );
assert( *lcp == NULL );
if ( sendok ) {
(void)ldap_back_proxy_authz_ctrl_free( op, &ctrls );
if ( lc != NULL ) {
- ldap_back_release_conn( op, rs, lc );
+ ldap_back_release_conn( li, lc );
}
return rs->sr_err;
struct berval bv;
if ( strcmp( c->argv[ 1 ], "*" ) == 0
- || strcmp( c->argv[ 1 ], ".*" ) == 0
|| strcmp( c->argv[ 1 ], "dn:*" ) == 0
|| strcasecmp( c->argv[ 1 ], "dn.regex:.*" ) == 0 )
{
}
if ( lc != NULL ) {
- ldap_back_release_conn( &op2, rs, lc );
+ ldap_back_release_conn( (ldapinfo_t *)op2.o_bd->be_private, lc );
}
} else {
Operation *op,
SlapReply *rs )
{
- ldapinfo_t *li = (ldapinfo_t *)op->o_bd->be_private;
+ ldapinfo_t *li = (ldapinfo_t *)op->o_bd->be_private;
ldapconn_t *lc = NULL;
ber_int_t msgid;
(void)ldap_back_proxy_authz_ctrl_free( op, &ctrls );
if ( lc != NULL ) {
- ldap_back_release_conn( op, rs, lc );
+ ldap_back_release_conn( li, lc );
}
return rc;
done:;
if ( lc != NULL ) {
- ldap_back_release_conn( op, rs, lc );
+ ldap_back_release_conn( li, lc );
}
return rc;
}
if ( lc != NULL ) {
- ldap_back_release_conn( op, rs, lc );
+ ldap_back_release_conn( li, lc );
}
return rc;
}
if ( lc != NULL ) {
- ldap_back_release_conn( op, rs, lc );
+ ldap_back_release_conn( li, lc );
}
return rc;
ch_free( modv );
if ( lc != NULL ) {
- ldap_back_release_conn( op, rs, lc );
+ ldap_back_release_conn( li, lc );
}
return rc;
(void)ldap_back_proxy_authz_ctrl_free( op, &ctrls );
if ( lc != NULL ) {
- ldap_back_release_conn( op, rs, lc );
+ ldap_back_release_conn( li, lc );
}
return rc;
extern BI_entry_get_rw ldap_back_entry_get;
-void ldap_back_release_conn_lock( Operation *op, SlapReply *rs, ldapconn_t **lcp, int dolock );
-#define ldap_back_release_conn(op, rs, lc) ldap_back_release_conn_lock((op), (rs), &(lc), 1)
+void ldap_back_release_conn_lock( ldapinfo_t *li, ldapconn_t **lcp, int dolock );
+#define ldap_back_release_conn(li, lc) ldap_back_release_conn_lock((li), &(lc), 1)
int ldap_back_dobind( ldapconn_t **lcp, Operation *op, SlapReply *rs, ldap_back_send_t sendok );
int ldap_back_retry( ldapconn_t **lcp, Operation *op, SlapReply *rs, ldap_back_send_t sendok );
int ldap_back_map_result( SlapReply *rs );
extern int ldap_back_conndn_dup( void *c1, void *c2 );
extern void ldap_back_conn_free( void *c );
+extern ldapconn_t * ldap_back_conn_delete( ldapinfo_t *li, ldapconn_t *lc );
+
extern int
ldap_back_proxy_authz_ctrl(
struct berval *bound_ndn,
for ( rc = 0; rc != -1; rc = ldap_result( lc->lc_ld, msgid, LDAP_MSG_ONE, &tv, &res ) )
{
/* check for abandon */
- if ( op->o_abandon ) {
+ if ( op->o_abandon || LDAP_BACK_CONN_ABANDON( lc ) ) {
if ( rc > 0 ) {
ldap_msgfree( res );
}
}
if ( lc != NULL ) {
- ldap_back_release_conn( op, rs, lc );
+ ldap_back_release_conn( li, lc );
}
return rs->sr_err;
rc = ldap_build_entry( op, e, *ent, &bdn );
if ( rc != LDAP_SUCCESS ) {
- ch_free( *ent );
+ entry_free( *ent );
*ent = NULL;
}
}
if ( lc != NULL ) {
- ldap_back_release_conn( op, &rs, lc );
+ ldap_back_release_conn( li, lc );
}
return rc;
done:;
if ( mc ) {
- meta_back_release_conn( op, mc );
+ meta_back_release_conn( mi, mc );
}
return rs->sr_err;
#define META_NOT_CANDIDATE ((ber_tag_t)0x0)
#define META_CANDIDATE ((ber_tag_t)0x1)
#define META_BINDING ((ber_tag_t)0x2)
+#define META_RETRYING ((ber_tag_t)0x4)
typedef struct metasingleconn_t {
#define META_CND_ISSET(rs,f) ( ( (rs)->sr_tag & (f) ) == (f) )
#define META_IS_BINDING(rs) META_CND_ISSET( (rs), META_BINDING )
#define META_BINDING_SET(rs) META_CND_SET( (rs), META_BINDING )
#define META_BINDING_CLEAR(rs) META_CND_CLEAR( (rs), META_BINDING )
+#define META_IS_RETRYING(rs) META_CND_ISSET( (rs), META_RETRYING )
+#define META_RETRYING_SET(rs) META_CND_SET( (rs), META_RETRYING )
+#define META_RETRYING_CLEAR(rs) META_CND_CLEAR( (rs), META_RETRYING )
LDAP *msc_ld;
time_t msc_time;
#define META_BACK_F_ONERR_REPORT (0x00200000U)
#define META_BACK_F_ONERR_MASK (META_BACK_F_ONERR_STOP|META_BACK_F_ONERR_REPORT)
#define META_BACK_F_DEFER_ROOTDN_BIND (0x00400000U)
-#define META_BACK_F_PROXYAUTHZ_ALWAYS (0x00800000U)
+#define META_BACK_F_PROXYAUTHZ_ALWAYS (0x00800000U) /* users always proxyauthz */
+#define META_BACK_F_PROXYAUTHZ_ANON (0x01000000U) /* anonymous always proxyauthz */
+#define META_BACK_F_PROXYAUTHZ_NOANON (0x02000000U) /* anonymous remains anonymous */
-#define META_BACK_ONERR_STOP(mi) ( (mi)->mi_flags & META_BACK_F_ONERR_STOP )
-#define META_BACK_ONERR_REPORT(mi) ( (mi)->mi_flags & META_BACK_F_ONERR_REPORT )
-#define META_BACK_ONERR_CONTINUE(mi) ( !( (mi)->mi_flags & META_BACK_F_ONERR_MASK ) )
+#define META_BACK_ONERR_STOP(mi) LDAP_BACK_ISSET( (mi), META_BACK_F_ONERR_STOP )
+#define META_BACK_ONERR_REPORT(mi) LDAP_BACK_ISSET( (mi), META_BACK_F_ONERR_REPORT )
+#define META_BACK_ONERR_CONTINUE(mi) ( !LDAP_BACK_ISSET( (mi), META_BACK_F_ONERR_MASK ) )
-#define META_BACK_DEFER_ROOTDN_BIND(mi) ( (mi)->mi_flags & META_BACK_F_DEFER_ROOTDN_BIND )
-#define META_BACK_PROXYAUTHZ_ALWAYS(mi) ( (mi)->mi_flags & META_BACK_F_PROXYAUTHZ_ALWAYS )
+#define META_BACK_DEFER_ROOTDN_BIND(mi) LDAP_BACK_ISSET( (mi), META_BACK_F_DEFER_ROOTDN_BIND )
+#define META_BACK_PROXYAUTHZ_ALWAYS(mi) LDAP_BACK_ISSET( (mi), META_BACK_F_PROXYAUTHZ_ALWAYS )
+#define META_BACK_PROXYAUTHZ_ANON(mi) LDAP_BACK_ISSET( (mi), META_BACK_F_PROXYAUTHZ_ANON )
+#define META_BACK_PROXYAUTHZ_NOANON(mi) LDAP_BACK_ISSET( (mi), META_BACK_F_PROXYAUTHZ_NOANON )
int mi_version;
time_t mi_network_timeout;
extern void
meta_back_release_conn_lock(
- Operation *op,
+ metainfo_t *mi,
metaconn_t *mc,
int dolock );
-#define meta_back_release_conn(op, mc) meta_back_release_conn_lock( (op), (mc), 1 )
+#define meta_back_release_conn(mi, mc) meta_back_release_conn_lock( (mi), (mc), 1 )
extern int
meta_back_retry(
ber_dupbv( &op->orb_edn, be_root_dn( op->o_bd ) );
}
- if ( !dn_match( &op->o_req_ndn, &mc->mc_local_ndn ) ) {
+ if ( !LDAP_BACK_PCONN_ISPRIV( mc )
+ && !dn_match( &op->o_req_ndn, &mc->mc_local_ndn ) )
+ {
metaconn_t *tmpmc;
int lerr;
}
if ( mc != NULL ) {
- meta_back_release_conn( op, mc );
+ meta_back_release_conn( mi, mc );
}
/*
LDAP_BACK_CONN_BINDING_CLEAR( msc );
if ( META_BACK_ONERR_STOP( mi ) ) {
LDAP_BACK_CONN_TAINTED_SET( mc );
- meta_back_release_conn_lock( op, mc, 0 );
+ meta_back_release_conn_lock( mi, mc, 0 );
*mcp = NULL;
}
if ( dolock ) {
ldap_pvt_thread_mutex_lock( &mi->mi_conninfo.lai_mutex );
LDAP_BACK_CONN_BINDING_CLEAR( msc );
ldap_pvt_thread_mutex_unlock( &mi->mi_conninfo.lai_mutex );
- meta_back_release_conn( op, mc );
+ meta_back_release_conn( mi, mc );
}
return 0;
op->o_log_prefix, LDAP_BACK_PCONN_ID( mc ), bound );
if ( bound == 0 ) {
- meta_back_release_conn( op, mc );
+ meta_back_release_conn( mi, mc );
send_err:;
if ( sendok & LDAP_BACK_SENDERR ) {
default:
/* NOTE: rootdn can always idassert */
- if ( BER_BVISNULL( &ndn ) && mt->mt_idassert_authz == NULL ) {
+ if ( BER_BVISNULL( &ndn )
+ && mt->mt_idassert_authz == NULL
+ && !( mt->mt_idassert_flags & LDAP_BACK_AUTH_AUTHZ_ALL ) )
+ {
if ( mt->mt_idassert_flags & LDAP_BACK_AUTH_PRESCRIPTIVE ) {
rs->sr_err = LDAP_INAPPROPRIATE_AUTH;
if ( sendok & LDAP_BACK_SENDERR ) {
}
if ( mc ) {
- meta_back_release_conn( op, mc );
+ meta_back_release_conn( mi, mc );
}
return rs->sr_err;
* let the caller do what's best before
* releasing */
if ( META_BACK_ONERR_STOP( mi ) ) {
- meta_back_release_conn_lock( op, mc, 0 );
+ meta_back_release_conn_lock( mi, mc, 0 );
*mcp = NULL;
} else {
LDAP_TAILQ_REMOVE( &mi->mi_conn_priv[ LDAP_BACK_CONN2PRIV( mc ) ].mic_priv,
mc, mc_q );
mi->mi_conn_priv[ LDAP_BACK_CONN2PRIV( mc ) ].mic_num--;
- mc->mc_q.tqe_prev = NULL;
- mc->mc_q.tqe_next = NULL;
+ LDAP_TAILQ_ENTRY_INIT( mc, mc_q );
} else {
assert( !LDAP_BACK_CONN_CACHED( mc ) );
SlapReply *candidates = meta_back_candidates_get( op );
/* Internal searches are privileged and shared. So is root. */
- /* FIXME: there seems to be concurrency issues */
- if ( META_BACK_PROXYAUTHZ_ALWAYS( mi ) || op->o_do_not_cache || be_isroot( op ) ) {
- mc_curr.mc_local_ndn = op->o_bd->be_rootndn;
+ if ( ( !BER_BVISEMPTY( &op->o_ndn ) && META_BACK_PROXYAUTHZ_ALWAYS( mi ) )
+ || ( BER_BVISEMPTY( &op->o_ndn ) && META_BACK_PROXYAUTHZ_ANON( mi ) )
+ || op->o_do_not_cache || be_isroot( op ) )
+ {
LDAP_BACK_CONN_ISPRIV_SET( &mc_curr );
+ mc_curr.mc_local_ndn = op->o_bd->be_rootndn;
LDAP_BACK_PCONN_ROOTDN_SET( &mc_curr, op );
+ } else if ( BER_BVISEMPTY( &op->o_ndn ) && META_BACK_PROXYAUTHZ_NOANON( mi ) )
+ {
+ LDAP_BACK_CONN_ISANON_SET( &mc_curr );
+ BER_BVSTR( &mc_curr.mc_local_ndn, "" );
+ LDAP_BACK_PCONN_ANON_SET( &mc_curr, op );
+
} else {
mc_curr.mc_local_ndn = op->o_ndn;
/* Explicit binds must not be shared */
- if ( op->o_tag == LDAP_REQ_BIND || SLAP_IS_AUTHZ_BACKEND( op ) ) {
+ if ( !BER_BVISEMPTY( &op->o_ndn )
+ || op->o_tag == LDAP_REQ_BIND
+ || SLAP_IS_AUTHZ_BACKEND( op ) )
+ {
mc_curr.mc_conn = op->o_conn;
} else {
}
/* Explicit Bind requests always get their own conn */
- if ( !( sendok & LDAP_BACK_BINDING ) ) {
+ if ( sendok & LDAP_BACK_BINDING ) {
+ mc_curr.mc_conn = op->o_conn;
+
+ } else {
/* Searches for a metaconn in the avl tree */
retry_lock:;
ldap_pvt_thread_mutex_lock( &mi->mi_conninfo.lai_mutex );
{
LDAP_TAILQ_REMOVE( &mi->mi_conn_priv[ LDAP_BACK_CONN2PRIV( mc ) ].mic_priv,
mc, mc_q );
- mc->mc_q.tqe_prev = NULL;
- mc->mc_q.tqe_next = NULL;
+ LDAP_TAILQ_ENTRY_INIT( mc, mc_q );
LDAP_TAILQ_INSERT_TAIL( &mi->mi_conn_priv[ LDAP_BACK_CONN2PRIV( mc ) ].mic_priv,
mc, mc_q );
}
LDAP_TAILQ_REMOVE( &mi->mi_conn_priv[ LDAP_BACK_CONN2PRIV( mc ) ].mic_priv,
mc, mc_q );
mi->mi_conn_priv[ LDAP_BACK_CONN2PRIV( mc ) ].mic_num--;
- mc->mc_q.tqe_prev = NULL;
- mc->mc_q.tqe_next = NULL;
+ LDAP_TAILQ_ENTRY_INIT( mc, mc_q );
} else {
assert( !LDAP_BACK_CONN_CACHED( mc ) );
meta_back_conn_free( mc );
} else {
- meta_back_release_conn( op, mc );
+ meta_back_release_conn( mi, mc );
}
rs->sr_err = LDAP_NO_SUCH_OBJECT;
if ( i < 0 || rs->sr_err != LDAP_SUCCESS ) {
if ( mc != NULL ) {
- meta_back_release_conn( op, mc );
+ meta_back_release_conn( mi, mc );
}
if ( sendok & LDAP_BACK_SENDERR ) {
if ( dn_type == META_DNTYPE_NEWPARENT && meta_back_get_candidate( op, rs, op->orr_nnewSup ) != i )
{
if ( mc != NULL ) {
- meta_back_release_conn( op, mc );
+ meta_back_release_conn( mi, mc );
}
rs->sr_err = LDAP_UNWILLING_TO_PERFORM;
meta_back_conn_free( mc );
} else {
- meta_back_release_conn( op, mc );
+ meta_back_release_conn( mi, mc );
}
return NULL;
}
meta_back_conn_free( mc );
} else {
- meta_back_release_conn( op, mc );
+ meta_back_release_conn( mi, mc );
}
return NULL;
meta_back_conn_free( mc );
} else {
- meta_back_release_conn( op, mc );
+ meta_back_release_conn( mi, mc );
}
if ( rs->sr_err == LDAP_SUCCESS ) {
void
meta_back_release_conn_lock(
- Operation *op,
+ metainfo_t *mi,
metaconn_t *mc,
int dolock )
{
- metainfo_t *mi = ( metainfo_t * )op->o_bd->be_private;
-
assert( mc != NULL );
if ( dolock ) {
* the connection space (and eat up resources). Maybe this
* should be configurable... */
if ( LDAP_BACK_CONN_TAINTED( mc ) ) {
- Debug( LDAP_DEBUG_TRACE, "%s meta_back_release_conn: mc=%p conn=%ld tainted.\n",
- op->o_log_prefix, (void *)mc, LDAP_BACK_PCONN_ID( mc ) );
#if META_BACK_PRINT_CONNTREE > 0
meta_back_print_conntree( mi, ">>> meta_back_release_conn" );
#endif /* META_BACK_PRINT_CONNTREE */
if ( mc->mc_q.tqe_prev != NULL ) {
assert( LDAP_BACK_CONN_CACHED( mc ) );
assert( mi->mi_conn_priv[ LDAP_BACK_CONN2PRIV( mc ) ].mic_num > 0 );
- mi->mi_conn_priv[ LDAP_BACK_CONN2PRIV( mc ) ].mic_num--;
LDAP_TAILQ_REMOVE( &mi->mi_conn_priv[ LDAP_BACK_CONN2PRIV( mc ) ].mic_priv, mc, mc_q );
+ mi->mi_conn_priv[ LDAP_BACK_CONN2PRIV( mc ) ].mic_num--;
+ LDAP_TAILQ_ENTRY_INIT( mc, mc_q );
} else {
assert( !LDAP_BACK_CONN_CACHED( mc ) );
}
- mc->mc_q.tqe_prev = NULL;
- mc->mc_q.tqe_next = NULL;
} else {
metaconn_t *tmpmc;
tmpmc = avl_delete( &mi->mi_conninfo.lai_tree,
( caddr_t )mc, meta_back_conndnmc_cmp );
- if ( tmpmc == NULL ) {
- Debug( LDAP_DEBUG_TRACE, "%s: meta_back_release_conn: unable to find mc=%p\n",
- op->o_log_prefix, (void *)mc, 0 );
- } else {
- assert( tmpmc == mc );
- }
+ assert( tmpmc == NULL && tmpmc == mc );
}
LDAP_BACK_CONN_CACHED_CLEAR( mc );
}
if ( mc ) {
- meta_back_release_conn( op, mc );
+ meta_back_release_conn( mi, mc );
}
return rs->sr_err;
int i,
not_always = 0,
+ not_always_anon_proxyauthz = 0,
+ not_always_anon_non_prescriptive = 0,
rc;
for ( i = 0; i < mi->mi_ntargets; i++ ) {
if ( not_always == 0 ) {
if ( !( mt->mt_idassert_flags & LDAP_BACK_AUTH_OVERRIDE )
- || !( mt->mt_idassert_flags & LDAP_BACK_AUTH_AUTHZ_ALL ) )
+ || mt->mt_idassert_authz != NULL )
{
not_always = 1;
}
}
+
+ if ( ( mt->mt_idassert_flags & LDAP_BACK_AUTH_AUTHZ_ALL )
+ && !( mt->mt_idassert_flags & LDAP_BACK_AUTH_PRESCRIPTIVE ) )
+ {
+ Debug( LDAP_DEBUG_ANY, "meta_back_db_open(%s): "
+ "target #%d inconsistent idassert configuration "
+ "(likely authz=\"*\" used with \"non-prescriptive\" flag)\n",
+ be->be_suffix[ 0 ].bv_val, i, 0 );
+ return 1;
+ }
+
+ if ( not_always_anon_proxyauthz == 0 ) {
+ if ( !( mt->mt_idassert_flags & LDAP_BACK_AUTH_AUTHZ_ALL ) )
+ {
+ not_always_anon_proxyauthz = 1;
+ }
+ }
+
+ if ( not_always_anon_non_prescriptive == 0 ) {
+ if ( ( mt->mt_idassert_flags & LDAP_BACK_AUTH_PRESCRIPTIVE ) )
+ {
+ not_always_anon_non_prescriptive = 1;
+ }
+ }
}
if ( not_always == 0 ) {
mi->mi_flags |= META_BACK_F_PROXYAUTHZ_ALWAYS;
}
+ if ( not_always_anon_proxyauthz == 0 ) {
+ mi->mi_flags |= META_BACK_F_PROXYAUTHZ_ANON;
+
+ } else if ( not_always_anon_non_prescriptive == 0 ) {
+ mi->mi_flags |= META_BACK_F_PROXYAUTHZ_NOANON;
+ }
+
return 0;
}
free( modv );
if ( mc ) {
- meta_back_release_conn( op, mc );
+ meta_back_release_conn( mi, mc );
}
return rs->sr_err;
}
if ( mc ) {
- meta_back_release_conn( op, mc );
+ meta_back_release_conn( mi, mc );
}
return rs->sr_err;
assert( msc->msc_ld != NULL );
+retry:;
rc = ldap_sasl_bind( msc->msc_ld, binddn.bv_val, LDAP_SASL_SIMPLE, &cred,
NULL, NULL, &candidates[ candidate ].sr_msgid );
down:;
/* This is the worst thing that could happen:
* the search will wait until the retry is over. */
- if ( meta_back_retry( op, rs, mcp, candidate, LDAP_BACK_DONTSEND ) ) {
- candidates[ candidate ].sr_msgid = META_MSGID_IGNORE;
- return META_SEARCH_CANDIDATE;
+ if ( !META_IS_RETRYING( &candidates[ candidate ] ) ) {
+ META_RETRYING_SET( &candidates[ candidate ] );
+
+ ldap_pvt_thread_mutex_lock( &mi->mi_conninfo.lai_mutex );
+
+ assert( mc->mc_refcnt > 0 );
+ if ( StatslogTest( LDAP_DEBUG_ANY ) ) {
+ char buf[ SLAP_TEXT_BUFLEN ];
+
+ /* this lock is required; however,
+ * it's invoked only when logging is on */
+ ldap_pvt_thread_mutex_lock( &mt->mt_uri_mutex );
+ snprintf( buf, sizeof( buf ),
+ "retrying URI=\"%s\" DN=\"%s\"",
+ mt->mt_uri,
+ BER_BVISNULL( &msc->msc_bound_ndn ) ?
+ "" : msc->msc_bound_ndn.bv_val );
+ ldap_pvt_thread_mutex_unlock( &mt->mt_uri_mutex );
+
+ Debug( LDAP_DEBUG_ANY,
+ "%s meta_search_dobind_init[%d]: %s.\n",
+ op->o_log_prefix, candidate, buf );
+ }
+
+ meta_clear_one_candidate( op, mc, candidate );
+ LDAP_BACK_CONN_ISBOUND_CLEAR( msc );
+
+ ( void )rewrite_session_delete( mt->mt_rwmap.rwm_rw, op->o_conn );
+
+ /* mc here must be the regular mc, reset and ready for init */
+ rc = meta_back_init_one_conn( op, rs, mc, candidate,
+ LDAP_BACK_CONN_ISPRIV( mc ), LDAP_BACK_DONTSEND, 0 );
+
+ if ( rc == LDAP_SUCCESS ) {
+ LDAP_BACK_CONN_BINDING_SET( msc );
+ }
+
+ ldap_pvt_thread_mutex_unlock( &mi->mi_conninfo.lai_mutex );
+
+ if ( rc == LDAP_SUCCESS ) {
+ candidates[ candidate ].sr_msgid = META_MSGID_IGNORE;
+ goto retry;
+ }
}
if ( *mcp == NULL ) {
candidates[ candidate ].sr_err = rc;
if ( META_BACK_ONERR_STOP( mi ) ) {
LDAP_BACK_CONN_TAINTED_SET( mc );
- meta_back_release_conn_lock( op, mc, 0 );
+ meta_back_release_conn_lock( mi, mc, 0 );
*mcp = NULL;
rs->sr_err = rc;
candidates[ candidate ].sr_err = rc;
if ( META_BACK_ONERR_STOP( mi ) ) {
LDAP_BACK_CONN_TAINTED_SET( mc );
- meta_back_release_conn_lock( op, mc, 0 );
+ meta_back_release_conn_lock( mi, mc, 0 );
*mcp = NULL;
retcode = META_SEARCH_ERR;
rs->sr_err = rc;
op->o_log_prefix, (void *)mc, 0 );
#endif /* DEBUG_205 */
- meta_back_release_conn( op, mc );
+ meta_back_release_conn( mi, mc );
mc = NULL;
needbind = 0;
}
/* check for abandon */
- if ( op->o_abandon ) {
+ if ( op->o_abandon || LDAP_BACK_CONN_ABANDON( mc ) ) {
break;
}
}
/* check for abandon */
- if ( op->o_abandon || doabandon ) {
+ if ( op->o_abandon || LDAP_BACK_CONN_ABANDON( mc ) ) {
for ( i = 0; i < mi->mi_ntargets; i++ ) {
if ( candidates[ i ].sr_msgid >= 0 ) {
if ( META_IS_BINDING( &candidates[ i ] ) ) {
if ( op->o_abandon ) {
rc = SLAPD_ABANDON;
- /* let send_ldap_result play cleanup handlers (ITS#4645) */
- break;
}
+
+ /* let send_ldap_result play cleanup handlers (ITS#4645) */
+ break;
}
/* if no entry was found during this loop,
lutil_timermul( &save_tv, 2, &save_tv );
}
-#if 0
- if ( StatslogTest( LDAP_DEBUG_TRACE ) ) {
- char buf[ SLAP_TEXT_BUFLEN ];
-
- snprintf( buf, sizeof( buf ), "%s %ld.%06ld %d/%d mc=%p",
- op->o_log_prefix, save_tv.tv_sec, save_tv.tv_usec,
- ncandidates, initial_candidates, mc );
- Debug( LDAP_DEBUG_TRACE, "### %s\n", buf, 0, 0 );
- for ( i = 0; i < mi->mi_ntargets; i++ ) {
- if ( candidates[ i ].sr_msgid == META_MSGID_IGNORE ) {
- continue;
- }
-
- snprintf( buf, sizeof( buf ), "[%ld] ld=%p%s%s\n",
- i,
- mc->mc_conns[ i ].msc_ld,
- ( candidates[ i ].sr_msgid == META_MSGID_NEED_BIND ) ? " needbind" : "",
- META_IS_BINDING( &candidates[ i ] ) ? " binding" : "" );
- Debug( LDAP_DEBUG_TRACE, "### %s\n", buf, 0, 0 );
- }
- }
-#endif
-
if ( alreadybound == 0 ) {
-#if 0
- Debug( LDAP_DEBUG_TRACE, "### %s select(%ld.%06ld)\n",
- op->o_log_prefix, save_tv.tv_sec, save_tv.tv_usec );
-#endif
tv = save_tv;
(void)select( 0, NULL, NULL, NULL, &tv );
matched = op->o_bd->be_suffix[ 0 ].bv_val;
}
-#if 0
- {
- char buf[ SLAP_TEXT_BUFLEN ];
- char cnd[ SLAP_TEXT_BUFLEN ];
- int i;
-
- for ( i = 0; i < mi->mi_ntargets; i++ ) {
- if ( META_IS_CANDIDATE( &candidates[ i ] ) ) {
- cnd[ i ] = '*';
- } else {
- cnd[ i ] = ' ';
- }
- }
- cnd[ i ] = '\0';
-
- snprintf( buf, sizeof( buf ), "%s meta_back_search: is_scope=%d is_ok=%d cnd=\"%s\"\n",
- op->o_log_prefix, initial_candidates, is_ok, cnd );
-
- Debug( LDAP_DEBUG_ANY, "%s", buf, 0, 0 );
- }
-#endif
-
/*
* In case we returned at least one entry, we return LDAP_SUCCESS
* otherwise, the latter error code we got
}
if ( mc ) {
- meta_back_release_conn( op, mc );
+ meta_back_release_conn( mi, mc );
}
return rs->sr_err;
projects / openldap / commitdiff