}
attrs[ i ] = NULL;
- ldap_add_s( lc->conns[ candidate ]->ld, mdn.bv_val, attrs );
+ ldap_add_s( lc->conns[ candidate ].ld, mdn.bv_val, attrs );
for ( --i; i >= 0; --i ) {
free( attrs[ i ]->mod_vals.modv_bvals );
free( attrs[ i ] );
int candidate;
#define META_NOT_CANDIDATE 0
#define META_CANDIDATE 1
+#define META_LAST_CONN -1
LDAP *ld;
struct berval bound_dn;
#define META_ANONYMOUS 2
};
+#define META_LAST(lsc) ((lsc)->candidate == META_LAST_CONN)
+
struct metaconn {
struct slap_conn *conn;
struct rewrite_info *rwinfo;
#define META_BOUND_NONE -1
#define META_BOUND_ALL -2
/* supersedes the connection stuff */
- struct metasingleconn **conns;
+ struct metasingleconn *conns;
};
struct metatarget {
/*
* Skip non-candidates
*/
- if ( lc->conns[ i ]->candidate != META_CANDIDATE ) {
+ if ( lc->conns[ i ].candidate != META_CANDIDATE ) {
continue;
}
realdn, realndn, realcred, realmethod, i );
if ( lerr != LDAP_SUCCESS ) {
err = lerr;
- ( void )meta_clear_one_candidate( lc->conns[ i ], 1 );
+ ( void )meta_clear_one_candidate( &lc->conns[ i ], 1 );
} else {
rc = LDAP_SUCCESS;
}
return LDAP_OTHER;
}
- rc = ldap_bind_s( lc->conns[ candidate ]->ld, mdn.bv_val, cred->bv_val, method );
+ rc = ldap_bind_s( lc->conns[ candidate ].ld, mdn.bv_val, cred->bv_val, method );
if ( rc != LDAP_SUCCESS ) {
rc = ldap_back_map_result( rc );
} else {
- ber_dupbv( &lc->conns[ candidate ]->bound_dn, dn );
- lc->conns[ candidate ]->bound = META_BOUND;
+ ber_dupbv( &lc->conns[ candidate ].bound_dn, dn );
+ lc->conns[ candidate ].bound = META_BOUND;
lc->bound_target = candidate;
if ( li->cache.ttl != META_DNCACHE_DISABLED
int
meta_back_dobind( struct metaconn *lc, Operation *op )
{
- struct metasingleconn **lsc;
+ struct metasingleconn *lsc;
int bound = 0, i;
/*
return 1;
}
- for ( i = 0, lsc = lc->conns; lsc[ 0 ] != NULL; ++i, ++lsc ) {
+ for ( i = 0, lsc = lc->conns; !META_LAST(lsc); ++i, ++lsc ) {
int rc;
/*
* Not a candidate or something wrong with this target ...
*/
- if ( lsc[ 0 ]->ld == NULL ) {
+ if ( lsc->ld == NULL ) {
continue;
}
/*
* If the target is already bound it is skipped
*/
- if ( lsc[ 0 ]->bound == META_BOUND && lc->bound_target == i ) {
+ if ( lsc->bound == META_BOUND && lc->bound_target == i ) {
++bound;
continue;
}
* (note: if the target was already bound, the anonymous
* bind clears the previous bind).
*/
- if ( lsc[ 0 ]->bound_dn.bv_val ) {
- ch_free( lsc[ 0 ]->bound_dn.bv_val );
- lsc[ 0 ]->bound_dn.bv_val = NULL;
- lsc[ 0 ]->bound_dn.bv_len = 0;
+ if ( lsc->bound_dn.bv_val ) {
+ ch_free( lsc->bound_dn.bv_val );
+ lsc->bound_dn.bv_val = NULL;
+ lsc->bound_dn.bv_len = 0;
}
- rc = ldap_bind_s( lsc[ 0 ]->ld, 0, NULL, LDAP_AUTH_SIMPLE );
+ rc = ldap_bind_s( lsc->ld, 0, NULL, LDAP_AUTH_SIMPLE );
if ( rc != LDAP_SUCCESS ) {
#ifdef NEW_LOGGING
"meta_back_dobind: (anonymous)"
" bind as \"%s\" failed"
" with error \"%s\"\n",
- lsc[ 0 ]->bound_dn.bv_val,
+ lsc->bound_dn.bv_val,
ldap_err2string( rc ), 0 );
#else /* !NEW_LOGGING */
Debug( LDAP_DEBUG_ANY,
"==>meta_back_dobind: (anonymous)"
" bind as \"%s\" failed"
" with error \"%s\"\n%s",
- lsc[ 0 ]->bound_dn.bv_val,
+ lsc->bound_dn.bv_val,
ldap_err2string( rc ), "" );
#endif /* !NEW_LOGGING */
* due to technical reasons (remote host down?)
* so better clear the handle
*/
- ( void )meta_clear_one_candidate( lsc[ 0 ], 1 );
+ ( void )meta_clear_one_candidate( lsc, 1 );
continue;
} /* else */
- lsc[ 0 ]->bound = META_ANONYMOUS;
+ lsc->bound = META_ANONYMOUS;
++bound;
}
int
meta_back_is_valid( struct metaconn *lc, int candidate )
{
- struct metasingleconn **lsc;
+ struct metasingleconn *lsc;
int i;
assert( lc );
return 0;
}
- for ( i = 0, lsc = lc->conns;
- lsc[ 0 ] != NULL && i < candidate;
+ for ( i = 0, lsc = lc->conns; !META_LAST(lsc) && i < candidate;
++i, ++lsc );
- if ( lsc[ 0 ] ) {
- return( lsc[ 0 ]->ld != NULL );
+ if ( !META_LAST(lsc) ) {
+ return( lsc->ld != NULL );
}
return 0;
meta_back_op_result( struct metaconn *lc, Operation *op )
{
int i, rerr = LDAP_SUCCESS;
- struct metasingleconn **lsc;
+ struct metasingleconn *lsc;
char *rmsg = NULL;
char *rmatch = NULL;
- for ( i = 0, lsc = lc->conns; lsc[ 0 ] != NULL; ++i, ++lsc ) {
+ for ( i = 0, lsc = lc->conns; !META_LAST(lsc); ++i, ++lsc ) {
int err = LDAP_SUCCESS;
char *msg = NULL;
char *match = NULL;
- ldap_get_option( lsc[ 0 ]->ld, LDAP_OPT_ERROR_NUMBER, &err );
+ ldap_get_option( lsc->ld, LDAP_OPT_ERROR_NUMBER, &err );
if ( err != LDAP_SUCCESS ) {
/*
* better check the type of error. In some cases
* success if at least one of the targets gave
* positive result ...
*/
- ldap_get_option( lsc[ 0 ]->ld,
+ ldap_get_option( lsc->ld,
LDAP_OPT_ERROR_STRING, &msg );
- ldap_get_option( lsc[ 0 ]->ld,
+ ldap_get_option( lsc->ld,
LDAP_OPT_MATCHED_DN, &match );
err = ldap_back_map_result( err );
if ( i == candidate ) {
continue;
}
- meta_clear_one_candidate( lc->conns[ i ], reallyclean );
+ meta_clear_one_candidate( &lc->conns[ i ], reallyclean );
}
return 0;
{
struct metainfo *li = ( struct metainfo * )be->be_private;
struct metaconn *lc;
- struct metasingleconn **lsc;
+ struct metasingleconn *lsc;
char *match = NULL, *err = NULL, *mmatch = NULL;
int candidates = 0, last = 0, i, count, rc;
int cres = LDAP_SUCCESS, rres = LDAP_SUCCESS;
/*
* start an asynchronous compare for each candidate target
*/
- for ( i = 0, lsc = lc->conns; lsc[ 0 ] != NULL; ++i, ++lsc ) {
+ for ( i = 0, lsc = lc->conns; !META_LAST(lsc); ++i, ++lsc ) {
char *mdn = NULL;
struct berval mapped_attr = ava->aa_desc->ad_cname;
struct berval mapped_value = ava->aa_value;
- if ( lsc[ 0 ]->candidate != META_CANDIDATE ) {
+ if ( lsc->candidate != META_CANDIDATE ) {
continue;
}
&ava->aa_value, &mapped_value, 0 );
if ( mapped_value.bv_val == NULL ) {
- lsc[ 0 ]->candidate = META_NOT_CANDIDATE;
+ lsc->candidate = META_NOT_CANDIDATE;
continue;
}
/*
ldap_back_map( &li->targets[ i ]->at_map,
&ava->aa_desc->ad_cname, &mapped_attr, 0 );
if ( mapped_attr.bv_val == NULL ) {
- lsc[ 0 ]->candidate = META_NOT_CANDIDATE;
+ lsc->candidate = META_NOT_CANDIDATE;
continue;
}
}
* that returns determines the result; a constraint on unicity
* of the result ought to be enforced
*/
- msgid[ i ] = ldap_compare( lc->conns[ i ]->ld, mdn,
+ msgid[ i ] = ldap_compare( lc->conns[ i ].ld, mdn,
mapped_attr.bv_val, mapped_value.bv_val );
if ( msgid[ i ] == -1 ) {
- lsc[ 0 ]->candidate = META_NOT_CANDIDATE;
+ lsc->candidate = META_NOT_CANDIDATE;
continue;
}
/*
* FIXME: should we check for abandon?
*/
- for ( i = 0, lsc = lc->conns; lsc[ 0 ] != NULL; lsc++, i++ ) {
+ for ( i = 0, lsc = lc->conns; !META_LAST(lsc); lsc++, i++ ) {
int lrc;
LDAPMessage *res = NULL;
- if ( lsc[ 0 ]->candidate != META_CANDIDATE ) {
+ if ( lsc->candidate != META_CANDIDATE ) {
continue;
}
- lrc = ldap_result( lsc[ 0 ]->ld, msgid[ i ],
+ lrc = ldap_result( lsc->ld, msgid[ i ],
0, NULL, &res );
if ( lrc == 0 ) {
goto finish;
}
- cres = ldap_result2error( lsc[ 0 ]->ld,
- res, 1 );
+ cres = ldap_result2error( lsc->ld, res, 1 );
switch ( cres ) {
case LDAP_COMPARE_TRUE:
case LDAP_COMPARE_FALSE:
if ( err != NULL ) {
free( err );
}
- ldap_get_option( lsc[ 0 ]->ld,
+ ldap_get_option( lsc->ld,
LDAP_OPT_ERROR_STRING, &err );
if ( match != NULL ) {
free( match );
}
- ldap_get_option( lsc[ 0 ]->ld,
+ ldap_get_option( lsc->ld,
LDAP_OPT_MATCHED_DN, &match );
last = i;
break;
}
- lsc[ 0 ]->candidate = META_NOT_CANDIDATE;
+ lsc->candidate = META_NOT_CANDIDATE;
--candidates;
} else {
- lsc[ 0 ]->candidate = META_NOT_CANDIDATE;
+ lsc->candidate = META_NOT_CANDIDATE;
--candidates;
if ( res ) {
ldap_msgfree( res );
metaconn_alloc( int ntargets )
{
struct metaconn *lc;
- int i;
assert( ntargets > 0 );
/*
* make it a null-terminated array ...
*/
- lc->conns = ch_calloc( sizeof( struct metasingleconn * ), ntargets+1 );
+ lc->conns = ch_calloc( sizeof( struct metasingleconn ), ntargets+1 );
if ( lc->conns == NULL ) {
free( lc );
return NULL;
}
-
- for ( i = 0; i < ntargets; i++ ) {
- lc->conns[ i ] =
- ch_calloc( sizeof( struct metasingleconn ), 1 );
- if ( lc->conns[ i ] == NULL ) {
- charray_free( ( char ** )lc->conns );
- free( lc->conns );
- free( lc );
- return NULL;
- }
- }
+ lc->conns[ ntargets ].candidate = META_LAST_CONN;
lc->bound_target = META_BOUND_NONE;
}
if ( lc->conns ) {
- int i;
-
- for ( i = 0; lc->conns[ i ] != NULL; ++i ) {
- free( lc->conns[ i ] );
- }
- charray_free( ( char ** )lc->conns );
+ ch_free( lc->conns );
}
free( lc );
* sends the appropriate result.
*/
err = init_one_conn( conn, op, li->targets[ i ],
- vers, lc->conns[ i ] );
+ vers, &lc->conns[ i ] );
if ( err != LDAP_SUCCESS ) {
/*
* be init'd, should the other ones
* be tried?
*/
- ( void )meta_clear_one_candidate( lc->conns[ i ], 1 );
+ ( void )meta_clear_one_candidate( &lc->conns[ i ], 1 );
if ( new_conn ) {
metaconn_free( lc );
}
* also init'd
*/
int lerr = init_one_conn( conn, op, li->targets[ i ],
- vers, lc->conns[ i ] );
+ vers, &lc->conns[ i ] );
if ( lerr != LDAP_SUCCESS ) {
/*
* be init'd, should the other ones
* be tried?
*/
- ( void )meta_clear_one_candidate( lc->conns[ i ], 1 );
+ ( void )meta_clear_one_candidate( &lc->conns[ i ], 1 );
err = lerr;
continue;
}
*/
int lerr = init_one_conn( conn, op,
li->targets[ i ],
- vers, lc->conns[ i ] );
+ vers, &lc->conns[ i ] );
if ( lerr != LDAP_SUCCESS ) {
/*
* be init'd, should the other ones
* be tried?
*/
- ( void )meta_clear_one_candidate( lc->conns[ i ], 1 );
+ ( void )meta_clear_one_candidate( &lc->conns[ i ], 1 );
err = lerr;
continue;
}
return -1;
}
- ldap_delete_s( lc->conns[ candidate ]->ld, mdn );
+ ldap_delete_s( lc->conns[ candidate ].ld, mdn );
if ( mdn != dn->bv_val ) {
free( mdn );
struct metaconn *lc
)
{
- struct metasingleconn **lsc;
+ struct metasingleconn *lsc;
- for ( lsc = lc->conns; lsc[ 0 ] != NULL; lsc++ ) {
- if ( lsc[ 0 ]->ld != NULL ) {
- ldap_unbind( lsc[ 0 ]->ld );
+ for ( lsc = lc->conns; !META_LAST(lsc); lsc++ ) {
+ if ( lsc->ld != NULL ) {
+ ldap_unbind( lsc->ld );
}
- if ( lsc[ 0 ]->bound_dn.bv_val ) {
- ber_memfree( lsc[ 0 ]->bound_dn.bv_val );
+ if ( lsc->bound_dn.bv_val ) {
+ ber_memfree( lsc->bound_dn.bv_val );
}
- free( lsc[ 0 ] );
+ free( lsc );
}
free( lc->conns );
free( lc );
}
modv[ i ] = 0;
- ldap_modify_s( lc->conns[ candidate ]->ld, mdn, modv );
+ ldap_modify_s( lc->conns[ candidate ].ld, mdn, modv );
if ( mdn != dn->bv_val ) {
free( mdn );
return -1;
}
- ldap_set_option( lc->conns[ nsCandidate ]->ld,
+ ldap_set_option( lc->conns[ nsCandidate ].ld,
LDAP_OPT_PROTOCOL_VERSION, &version );
/*
return -1;
}
- ldap_rename2_s( lc->conns[ candidate ]->ld, mdn, newrdn->bv_val,
+ ldap_rename2_s( lc->conns[ candidate ].ld, mdn, newrdn->bv_val,
mnewSuperior, deleteoldrdn );
if ( mdn != dn->bv_val ) {
{
struct metainfo *li = ( struct metainfo * )be->be_private;
struct metaconn *lc;
- struct metasingleconn **lsc;
+ struct metasingleconn *lsc;
struct timeval tv;
LDAPMessage *res, *e;
int count, rc = 0, *msgid, sres = LDAP_NO_SUCH_OBJECT;
/*
* Inits searches
*/
- for ( i = 0, lsc = lc->conns; lsc[ 0 ] != NULL; ++i, ++lsc ) {
+ for ( i = 0, lsc = lc->conns; !META_LAST(lsc); ++i, ++lsc ) {
char *realbase = ( char * )base->bv_val;
int realscope = scope;
ber_len_t suffixlen;
char *mapped_filter, **mapped_attrs;
- if ( lsc[ 0 ]->candidate != META_CANDIDATE ) {
+ if ( lsc->candidate != META_CANDIDATE ) {
continue;
}
if ( deref != -1 ) {
- ldap_set_option( lsc[ 0 ]->ld, LDAP_OPT_DEREF,
+ ldap_set_option( lsc->ld, LDAP_OPT_DEREF,
( void * )&deref);
}
if ( tlimit != -1 ) {
- ldap_set_option( lsc[ 0 ]->ld, LDAP_OPT_TIMELIMIT,
+ ldap_set_option( lsc->ld, LDAP_OPT_TIMELIMIT,
( void * )&tlimit);
}
if ( slimit != -1 ) {
- ldap_set_option( lsc[ 0 ]->ld, LDAP_OPT_SIZELIMIT,
+ ldap_set_option( lsc->ld, LDAP_OPT_SIZELIMIT,
( void * )&slimit);
}
/*
* this target is no longer candidate
*/
- lsc[ 0 ]->candidate = META_NOT_CANDIDATE;
+ lsc->candidate = META_NOT_CANDIDATE;
continue;
}
break;
/*
* this target is no longer candidate
*/
- lsc[ 0 ]->candidate = META_NOT_CANDIDATE;
+ lsc->candidate = META_NOT_CANDIDATE;
continue;
}
/*
* Starts the search
*/
- msgid[ i ] = ldap_search( lsc[ 0 ]->ld, mbase, realscope,
+ msgid[ i ] = ldap_search( lsc->ld, mbase, realscope,
mapped_filter, mapped_attrs, attrsonly );
if ( msgid[ i ] == -1 ) {
- lsc[ 0 ]->candidate = META_NOT_CANDIDATE;
+ lsc->candidate = META_NOT_CANDIDATE;
continue;
}
/* check for abandon */
ab = op->o_abandon;
- for ( i = 0, lsc = lc->conns; lsc[ 0 ] != NULL; lsc++, i++ ) {
- if ( lsc[ 0 ]->candidate != META_CANDIDATE ) {
+ for ( i = 0, lsc = lc->conns; !META_LAST(lsc); lsc++, i++ ) {
+ if ( lsc->candidate != META_CANDIDATE ) {
continue;
}
if ( ab ) {
- ldap_abandon( lsc[ 0 ]->ld, msgid[ i ] );
+ ldap_abandon( lsc->ld, msgid[ i ] );
rc = 0;
break;
}
goto finish;
}
- rc = ldap_result( lsc[ 0 ]->ld, msgid[ i ],
+ rc = ldap_result( lsc->ld, msgid[ i ],
0, &tv, &res );
if ( rc == 0 ) {
/* anything else needs be done? */
goto finish;
} else if ( rc == LDAP_RES_SEARCH_ENTRY ) {
- e = ldap_first_entry( lsc[ 0 ]->ld, res );
+ e = ldap_first_entry( lsc->ld, res );
meta_send_entry(be, op, lc, i, e, attrs,
attrsonly);
count++;
ldap_msgfree( res );
gotit = 1;
} else {
- sres = ldap_result2error( lsc[ 0 ]->ld,
+ sres = ldap_result2error( lsc->ld,
res, 1 );
sres = ldap_back_map_result( sres );
if ( err != NULL ) {
free( err );
}
- ldap_get_option( lsc[ 0 ]->ld,
+ ldap_get_option( lsc->ld,
LDAP_OPT_ERROR_STRING, &err );
if ( match != NULL ) {
free( match );
}
- ldap_get_option( lsc[ 0 ]->ld,
+ ldap_get_option( lsc->ld,
LDAP_OPT_MATCHED_DN, &match );
#ifdef NEW_LOGGING
* When no candidates are left,
* the outer cycle finishes
*/
- lsc[ 0 ]->candidate = META_NOT_CANDIDATE;
+ lsc->candidate = META_NOT_CANDIDATE;
--candidates;
}
}
* Cleanup rewrite session
*/
for ( i = 0; i < li->ntargets; ++i ) {
- if ( lc->conns[ i ]->ld == NULL ) {
- free( lc->conns[ i ] );
+ if ( lc->conns[ i ].ld == NULL ) {
continue;
}
rewrite_session_delete( li->targets[ i ]->rwinfo, conn );
- meta_clear_one_candidate( lc->conns[ i ], 1 );
- free( lc->conns[ i ] );
+ meta_clear_one_candidate( &lc->conns[ i ], 1 );
}
free( lc->conns );