diff --git a/servers/slapd/slapi/proto-slapi.h b/servers/slapd/slapi/proto-slapi.h index 937374ca04..f747332098 100644 --- a/servers/slapd/slapi/proto-slapi.h +++ b/servers/slapd/slapi/proto-slapi.h @@ -26,11 +26,10 @@ LDAP_BEGIN_DECL /* slapi_utils.c */ -LDAP_SLAPI_F (int) slapi_int_pblock_set_operation LDAP_P(( Slapi_PBlock *pb, Operation *op )); - -LDAP_SLAPI_F (LDAPMod **) slapi_int_modifications2ldapmods LDAP_P((Modifications **)); -LDAP_SLAPI_F (Modifications *) slapi_int_ldapmods2modifications LDAP_P((LDAPMod **)); -LDAP_SLAPI_F (void) slapi_int_free_ldapmods LDAP_P((LDAPMod **)); +LDAP_SLAPI_F (LDAPMod **) slapi_int_modifications2ldapmods LDAP_P(( Modifications **, void *ctx )); +LDAP_SLAPI_F (Modifications *) slapi_int_ldapmods2modifications LDAP_P(( LDAPMod **, void *ctx )); +LDAP_SLAPI_F (void) slapi_int_free_ldapmods LDAP_P(( LDAPMod ** )); +LDAP_SLAPI_F (int) slapi_int_count_controls LDAP_P(( LDAPControl **ctrls )); LDAP_SLAPI_F (int) slapi_int_access_allowed LDAP_P((Operation *op, Entry *entry, @@ -42,18 +41,32 @@ LDAP_SLAPI_F (int) slapi_int_access_allowed LDAP_P((Operation *op, LDAP_SLAPI_F (char **) slapi_get_supported_extended_ops LDAP_P((void)); /* slapi_ops.c */ -LDAP_SLAPI_F (int) slapi_int_connection_init LDAP_P((Slapi_PBlock *pb, int OpType, Connection **pConn)); -LDAP_SLAPI_F (void) slapi_int_connection_destroy LDAP_P(( Connection **pConn )); LDAP_SLAPI_F (int) slapi_int_response LDAP_P(( Slapi_Operation *op, SlapReply *rs )); +LDAP_SLAPI_F (void) slapi_int_connection_init_pb LDAP_P(( Slapi_PBlock *pb, ber_tag_t OpType )); +LDAP_SLAPI_F (void) slapi_int_connection_done_pb LDAP_P(( Slapi_PBlock *pb )); /* slapi_pblock.c */ -LDAP_SLAPI_F (void) slapi_pblock_check_params LDAP_P(( Slapi_PBlock *pb, int flag )); LDAP_SLAPI_F (int) slapi_pblock_delete_param LDAP_P(( Slapi_PBlock *p, int param )); LDAP_SLAPI_F (void) slapi_pblock_clear LDAP_P(( Slapi_PBlock *pb )); +LDAP_SLAPI_F (void) slapi_int_mods_free( Modifications *ml ); LDAP_SLAPI_F (int) slapi_int_pblock_get_first LDAP_P(( Backend *be, Slapi_PBlock **pb )); LDAP_SLAPI_F (int) slapi_int_pblock_get_next LDAP_P(( Slapi_PBlock **pb )); +#define PBLOCK_ASSERT_OP( _pb, _tag ) do { \ + assert( (_pb) != NULL ); \ + assert( (_pb)->pop != NULL ); \ + assert( (_pb)->pconn != NULL ); \ + if ( _tag != 0 ) \ + assert( (_pb)->pop->o_tag == (_tag)); \ + } while (0) + +#define PBLOCK_ASSERT_INTOP( _pb, _tag ) do { \ + PBLOCK_ASSERT_OP( _pb, _tag ); \ + assert( (_pb)->internal_op ); \ + assert( pb->pop == (Operation *)pb->pconn->c_pending_ops.stqh_first ); \ + } while (0) + /* plugin.c */ LDAP_SLAPI_F (int) slapi_int_register_plugin LDAP_P((Backend *be, Slapi_PBlock *pPB)); LDAP_SLAPI_F (int) slapi_int_call_plugins LDAP_P((Backend *be, int funcType, Slapi_PBlock * pPB)); diff --git a/servers/slapd/slapi/slapi.h b/servers/slapd/slapi/slapi.h index d92ec64a1d..fb0ed0f84c 100644 --- a/servers/slapd/slapi/slapi.h +++ b/servers/slapd/slapi/slapi.h @@ -112,6 +112,12 @@ struct slapi_pblock { int numParams; int curParams[PBLOCK_MAX_PARAMS]; void *curVals[PBLOCK_MAX_PARAMS]; + /* native types */ + Connection *pconn; + Operation *pop; + SlapReply rs; + int internal_op; + char textbuf[ SLAP_TEXT_BUFLEN ]; }; #endif /* !NO_PBLOCK_CLASS */ @@ -122,14 +128,6 @@ struct slapi_pblock { #define SLAPI_PLUGIN_IS_POST_FN(x) ((x) >= SLAPI_PLUGIN_POST_BIND_FN && (x) <= SLAPI_PLUGIN_BE_POST_DELETE_FN) -/* really private stuff */ -#define SLAPI_X_CONFIG_ARGV 1400 -#define SLAPI_X_INTOP_FLAGS 1401 -#define SLAPI_X_INTOP_RESULT_CALLBACK 1402 -#define SLAPI_X_INTOP_SEARCH_ENTRY_CALLBACK 1403 -#define SLAPI_X_INTOP_REFERRAL_ENTRY_CALLBACK 1404 -#define SLAPI_X_INTOP_CALLBACK_DATA 1405 - #define SLAPI_OPERATION_PARAMETERS 138 #define SLAPI_PLUGIN_DB_TEST_FN 227 @@ -170,6 +168,15 @@ struct slapi_pblock { #define SLAPI_DBSIZE 199 +/* really private stuff */ +#define SLAPI_X_CONFIG_ARGV 1400 +#define SLAPI_X_INTOP_FLAGS 1401 +#define SLAPI_X_INTOP_RESULT_CALLBACK 1402 +#define SLAPI_X_INTOP_SEARCH_ENTRY_CALLBACK 1403 +#define SLAPI_X_INTOP_REFERRAL_ENTRY_CALLBACK 1404 +#define SLAPI_X_INTOP_CALLBACK_DATA 1405 +#define SLAPI_X_OLD_RESCONTROLS 1406 + #define SLAPI_IBM_PBLOCK -3 LDAP_SLAPI_V (ldap_pvt_thread_mutex_t) slapi_hn_mutex; diff --git a/servers/slapd/slapi/slapi_ops.c b/servers/slapd/slapi/slapi_ops.c index 5358064c48..8f3a3433d0 100644 --- a/servers/slapd/slapi/slapi_ops.c +++ b/servers/slapd/slapi/slapi_ops.c @@ -31,31 +31,32 @@ #include #include -/* - * use a fake listener when faking a connection, - * so it can be used in ACLs - */ -static struct slap_listener slap_unknown_listener = { - BER_BVC("unknown"), /* FIXME: use a URI form? (e.g. slapi://) */ - BER_BVC("UNKNOWN") +#ifdef LDAP_SLAPI + +static struct slap_listener slapi_listener = { + BER_BVC("slapi://"), + BER_BVC("slapi://") }; -static void -slapi_int_mods_free( Modifications *ml ) +static LDAPControl ** +slapi_int_dup_controls( LDAPControl **controls ) { - Modifications *next; + LDAPControl **c; + size_t i; - for ( ; ml != NULL; ml = next ) { - next = ml->sml_next; + if ( controls == NULL ) + return NULL; - /* Don't free unnormalized values */ - if ( ml->sml_nvalues != NULL ) { - ber_bvarray_free( ml->sml_nvalues ); - ml->sml_nvalues = NULL; - } - slapi_ch_free((void **)&ml->sml_values); - slapi_ch_free((void **)&ml); + for ( i = 0; controls[i] != NULL; i++ ) + ; + + c = (LDAPControl **) slapi_ch_calloc( i + 1, sizeof(LDAPControl *) ); + + for ( i = 0; controls[i] != NULL; i++ ) { + c[i] = slapi_dup_control( controls[i] ); } + + return c; } static int @@ -63,42 +64,25 @@ slapi_int_result( Operation *op, SlapReply *rs ) { - LDAPControl **controls = NULL; - size_t i; + Slapi_PBlock *pb = SLAPI_OPERATION_PBLOCK( op ); plugin_result_callback prc = NULL; void *callback_data = NULL; - Slapi_PBlock *pb = SLAPI_OPERATION_PBLOCK( op ); + LDAPControl **ctrls = NULL; assert( pb != NULL ); - slapi_pblock_get( pb, SLAPI_RESCONTROLS, (void **)&controls ); slapi_pblock_get( pb, SLAPI_X_INTOP_RESULT_CALLBACK, (void **)&prc ); slapi_pblock_get( pb, SLAPI_X_INTOP_CALLBACK_DATA, &callback_data ); - assert( controls == NULL ); - - /* Copy these before they go out of scope */ - if ( rs->sr_ctrls != NULL ) { - for ( i = 0; rs->sr_ctrls[i] != NULL; i++ ) - ; - - controls = (LDAPControl **)slapi_ch_calloc( i + 1, - sizeof(LDAPControl )); - - for ( i = 0; rs->sr_ctrls[i] != NULL; i++ ) - controls[i] = slapi_dup_control( rs->sr_ctrls[i] ); - - controls[i] = NULL; - } - - slapi_pblock_set( pb, SLAPI_RESCONTROLS, (void *)controls ); - slapi_pblock_set( pb, SLAPI_PLUGIN_INTOP_RESULT, (void *)rs->sr_err ); + /* we need to duplicate controls because they might go out of scope */ + ctrls = slapi_int_dup_controls( rs->sr_ctrls ); + slapi_pblock_set( pb, SLAPI_RESCONTROLS, ctrls ); if ( prc != NULL ) { (*prc)( rs->sr_err, callback_data ); } - return LDAP_SUCCESS; + return rs->sr_err; } static int @@ -106,10 +90,10 @@ slapi_int_search_entry( Operation *op, SlapReply *rs ) { + Slapi_PBlock *pb = SLAPI_OPERATION_PBLOCK( op ); plugin_search_entry_callback psec = NULL; void *callback_data = NULL; - Slapi_PBlock *pb = SLAPI_OPERATION_PBLOCK( op ); - int rc = SLAP_CB_CONTINUE; + int rc = LDAP_SUCCESS; assert( pb != NULL ); @@ -120,7 +104,7 @@ slapi_int_search_entry( rc = (*psec)( rs->sr_entry, callback_data ); } - return LDAP_SUCCESS; + return rc; } static int @@ -170,165 +154,34 @@ slapi_int_response( Slapi_Operation *op, SlapReply *rs ) break; } - assert( rc != SLAP_CB_CONTINUE ); + assert( rc != SLAP_CB_CONTINUE ); /* never try to send a wire response */ return rc; } static int -slapi_int_get_ctrls( Operation *op, LDAPControl **controls ) +slapi_int_get_ctrls( Slapi_PBlock *pb ) { LDAPControl **c; - int rc; - SlapReply rs = { REP_RESULT }; + int rc = LDAP_SUCCESS; - op->o_ctrls = controls; - if ( op->o_ctrls == NULL ) { - return LDAP_SUCCESS; - } - - for ( c = op->o_ctrls; *c != NULL; c++ ) { - rc = slap_parse_ctrl( op, &rs, *c, &rs.sr_text ); - if ( rc != LDAP_SUCCESS ) - break; + if ( pb->pop->o_ctrls != NULL ) { + for ( c = pb->pop->o_ctrls; *c != NULL; c++ ) { + rc = slap_parse_ctrl( pb->pop, &pb->rs, *c, &pb->rs.sr_text ); + if ( rc != LDAP_SUCCESS ) + break; + } } return rc; } -/* - * To allow plugins to forward frontend requests to internal operations, - * the internal operation and connection structures should import as - * much state as practicable from the supplied parameter block. - */ - -/* - * Select the backend to be used for an internal operation, either - * from the operation target DN or from the parameter block. - */ -static int -slapi_int_pblock_get_backend( Slapi_PBlock *pb, Operation *op ) -{ - int manageDsaIt = 0, isCritical; - LDAPControl **controls = NULL; - BackendDB *be_op; - - slapi_pblock_get( pb, SLAPI_REQCONTROLS, (void **)&controls ); - - slapi_pblock_get( pb, SLAPI_MANAGEDSAIT, (void **)&manageDsaIt ); - if ( manageDsaIt != 0 ) - manageDsaIt = SLAP_CONTROL_CRITICAL; - else if ( slapi_control_present( controls, SLAPI_CONTROL_MANAGEDSAIT_OID, - NULL, &isCritical )) - manageDsaIt = isCritical ? SLAP_CONTROL_CRITICAL : SLAP_CONTROL_NONCRITICAL; - - /* let caller force a specific backend */ - slapi_pblock_get( pb, SLAPI_BACKEND, (void **)&be_op ); - if ( be_op == NULL ) { - be_op = select_backend( &op->o_req_ndn, 0, 0 ); - slapi_pblock_set( pb, SLAPI_BACKEND, (void *)be_op ); - } - - op->o_bd = frontendDB; /* but we actually use frontend DB */ - - return LDAP_SUCCESS; -} - -static int -slapi_int_pblock_get_connection( Slapi_PBlock *pb, Operation *op ) -{ - char *connDn = NULL; - Connection *conn = op->o_conn; - - slapi_pblock_get( pb, SLAPI_X_CONN_SSF, (void **)&conn->c_ssf ); - slapi_pblock_get( pb, SLAPI_X_CONN_SASL_CONTEXT, (void **)&conn->c_sasl_authctx ); - - if ( slapi_pblock_get( pb, SLAPI_CONN_DN, (void **)&connDn ) != 0 - || connDn == NULL ) - { - /* default to operation DN */ - conn->c_ndn = op->o_ndn; - conn->c_dn = op->o_ndn; - - } else { - /* NB: conn DN must be normalized */ - ber_str2bv( connDn, 0, 0, &conn->c_ndn ); - conn->c_dn = conn->c_ndn; - } - - return LDAP_SUCCESS; -} - -static int -slapi_int_pblock_get_operation( Slapi_PBlock *pb, Operation *op ) -{ - int isRoot = 0; - int isUpdateDn = 0; - char *requestorDn = NULL; - struct berval targetDn = BER_BVNULL; - LDAPControl **controls; - int rc; - BackendDB *be_op; - - /* All internal operations must specify a target DN */ - slapi_pblock_get( pb, SLAPI_TARGET_DN, (void **)&targetDn.bv_val ); - if ( targetDn.bv_val == NULL) { - return LDAP_PARAM_ERROR; - } - targetDn.bv_len = strlen( targetDn.bv_val ); - - rc = dnPrettyNormal( NULL, &targetDn, &op->o_req_dn, &op->o_req_ndn, NULL ); - if ( rc != LDAP_SUCCESS ) { - return rc; - } - - rc = slapi_int_pblock_get_backend( pb, op ); - if ( rc != LDAP_SUCCESS ) { - return rc; - } - - slapi_pblock_get( pb, SLAPI_REQUESTOR_ISROOT, (void **)&isRoot ); - slapi_pblock_get( pb, SLAPI_REQUESTOR_ISUPDATEDN, (void **)&isUpdateDn ); - /* NB: requestor DN must be normalized */ - slapi_pblock_get( pb, SLAPI_REQUESTOR_DN, (void **)&requestorDn ); - slapi_pblock_get( pb, SLAPI_BACKEND, (void **)&be_op ); - - /* Default authorization identity for internal operations is root DN */ - if ( isRoot || requestorDn == NULL ) { - assert( be_op != NULL ); - op->o_dn = be_op->be_rootdn; - op->o_ndn = be_op->be_rootndn; - isRoot = 1; - } else { - ber_str2bv( requestorDn, 0, 0, &op->o_ndn ); - op->o_dn = op->o_ndn; - } - - slapi_pblock_set( pb, SLAPI_REQUESTOR_ISROOT, (void *)isRoot ); - - rc = slapi_int_pblock_get_connection( pb, op ); - if ( rc != LDAP_SUCCESS ) { - return rc; - } - - slapi_pblock_get( pb, SLAPI_REQCONTROLS, (void **)&controls ); - rc = slapi_int_get_ctrls( op, controls ); - if ( rc != LDAP_SUCCESS ) { - return rc; - } - - return LDAP_SUCCESS; -} - -int -slapi_int_connection_init( Slapi_PBlock *pb, - int OpType, - Connection **pConn ) +void +slapi_int_connection_init_pb( Slapi_PBlock *pb, ber_tag_t OpType ) { Connection *conn; Operation *op; ber_len_t max = sockbuf_max_incoming; - int rc; conn = (Connection *) slapi_ch_calloc( 1, sizeof(Connection) ); @@ -353,7 +206,7 @@ slapi_int_connection_init( Slapi_PBlock *pb, BER_BVZERO( &conn->c_dn ); BER_BVZERO( &conn->c_ndn ); - conn->c_listener = &slap_unknown_listener; + conn->c_listener = &slapi_listener; ber_dupbv( &conn->c_peer_domain, (struct berval *)&slap_unknown_bv ); ber_dupbv( &conn->c_peer_name, (struct berval *)&slap_unknown_bv ); @@ -364,7 +217,7 @@ slapi_int_connection_init( Slapi_PBlock *pb, conn->c_sasl_sockctx = NULL; conn->c_sasl_extra = NULL; - conn->c_sb = ber_sockbuf_alloc( ); + conn->c_sb = ber_sockbuf_alloc(); ber_sockbuf_ctrl( conn->c_sb, LBER_SB_OPT_SET_MAX_INCOMING, &max ); @@ -422,326 +275,275 @@ slapi_int_connection_init( Slapi_PBlock *pb, op->o_tmpmfuncs = &ch_mfuncs; op->o_conn = conn; op->o_connid = conn->c_connid; + op->o_bd = frontendDB; - rc = slapi_int_pblock_get_operation( pb, op ); - - slapi_pblock_set( pb, SLAPI_OPERATION, op ); - slapi_pblock_set( pb, SLAPI_CONNECTION, conn ); + pb->pop = op; + pb->pconn = conn; + pb->internal_op = 1; ldap_pvt_thread_mutex_unlock( &conn->c_mutex ); - - if ( rc != LDAP_SUCCESS ) { - slapi_int_connection_destroy( &conn ); - return rc; - } - - *pConn = conn; - - return LDAP_SUCCESS; } -void slapi_int_connection_destroy( Connection **pConn ) +static void +slapi_int_set_operation_dn( Slapi_PBlock *pb ) { - Connection *conn = *pConn; - Operation *op; - Slapi_PBlock *pb; + Backend *be; + Operation *op = pb->pop; - if ( conn == NULL ) { - return; + if ( BER_BVISNULL( &op->o_ndn ) ) { + /* set to root DN */ + be = select_backend( &op->o_req_ndn, 0, 0 ); + assert( be != NULL ); + ber_dupbv( &op->o_dn, &be->be_rootdn ); + ber_dupbv( &op->o_ndn, &be->be_rootndn ); } +} - op = (Operation *)conn->c_pending_ops.stqh_first; - pb = SLAPI_OPERATION_PBLOCK( op ); +void +slapi_int_connection_done_pb( Slapi_PBlock *pb ) +{ + Connection *conn; + Operation *op; - slap_graduate_commit_csn( op ); + PBLOCK_ASSERT_INTOP( pb, 0 ); - slapi_ch_free_string( &op->o_req_dn.bv_val ); - slapi_ch_free_string( &op->o_req_ndn.bv_val ); - slapi_ch_free( (void **)&op->o_callback ); + conn = pb->pconn; + op = pb->pop; + + /* free allocated DNs */ + if ( !BER_BVISNULL( &op->o_dn ) ) + op->o_tmpfree( op->o_dn.bv_val, op->o_tmpmemctx ); + if ( !BER_BVISNULL( &op->o_ndn ) ) + op->o_tmpfree( op->o_ndn.bv_val, op->o_tmpmemctx ); + + if ( !BER_BVISNULL( &op->o_req_dn ) ) + op->o_tmpfree( op->o_req_dn.bv_val, op->o_tmpmemctx ); + if ( !BER_BVISNULL( &op->o_req_ndn ) ) + op->o_tmpfree( op->o_req_ndn.bv_val, op->o_tmpmemctx ); + + switch ( op->o_tag ) { + case LDAP_REQ_MODRDN: + if ( !BER_BVISNULL( &op->orr_newrdn )) + op->o_tmpfree( op->orr_newrdn.bv_val, op->o_tmpmemctx ); + if ( !BER_BVISNULL( &op->orr_nnewrdn )) + op->o_tmpfree( op->orr_nnewrdn.bv_val, op->o_tmpmemctx ); + if ( op->orr_newSup != NULL ) { + assert( !BER_BVISNULL( op->orr_newSup ) ); + op->o_tmpfree( op->orr_newSup->bv_val, op->o_tmpmemctx ); + op->o_tmpfree( op->orr_newSup, op->o_tmpmemctx ); + } + if ( op->orr_nnewSup != NULL ) { + assert( !BER_BVISNULL( op->orr_nnewSup ) ); + op->o_tmpfree( op->orr_nnewSup->bv_val, op->o_tmpmemctx ); + op->o_tmpfree( op->orr_nnewSup, op->o_tmpmemctx ); + } + break; + case LDAP_REQ_ADD: + slapi_int_mods_free( op->ora_modlist ); + break; + case LDAP_REQ_MODIFY: + slapi_int_mods_free( op->orm_modlist ); + break; + case LDAP_REQ_SEARCH: + if ( op->ors_attrs != NULL ) { + op->o_tmpfree( op->ors_attrs, op->o_tmpmemctx ); + op->ors_attrs = NULL; + } + break; + default: + break; + } if ( conn->c_sb != NULL ) { ber_sockbuf_free( conn->c_sb ); } - slapi_pblock_set( pb, SLAPI_OPERATION, NULL ); - slapi_pblock_set( pb, SLAPI_CONNECTION, NULL ); + slapi_ch_free( (void **)&pb->pop->o_callback ); + slapi_ch_free( (void **)&pb->pop ); + slapi_ch_free( (void **)&pb->pconn ); +} - slapi_ch_free( (void **)&op ); - slapi_ch_free( (void **)pConn ); +static int +slapi_int_func_internal_pb( Slapi_PBlock *pb, slap_operation_t which ) +{ + BI_op_bind **func; + SlapReply *rs = &pb->rs; + + PBLOCK_ASSERT_INTOP( pb, 0 ); + + rs->sr_err = slapi_int_get_ctrls( pb ); + if ( rs->sr_err != LDAP_SUCCESS ) { + return rs->sr_err; + } + + func = &pb->pop->o_bd->be_bind; + + rs->sr_err = func[which]( pb->pop, &pb->rs ); + + return rs->sr_err; } int slapi_delete_internal_pb( Slapi_PBlock *pb ) { -#ifdef LDAP_SLAPI - Connection *conn = NULL; - Operation *op = NULL; - - SlapReply rs = { REP_RESULT }; - if ( pb == NULL ) { return -1; } - rs.sr_err = slapi_int_connection_init( pb, LDAP_REQ_DELETE, &conn ); - if ( rs.sr_err != LDAP_SUCCESS ) { - slapi_pblock_set( pb, SLAPI_PLUGIN_INTOP_RESULT, (void *)rs.sr_err ); - return 0; - } + PBLOCK_ASSERT_INTOP( pb, LDAP_REQ_DELETE ); - op = conn->c_pending_ops.stqh_first; - rs.sr_err = frontendDB->be_delete( op, &rs ); - - slapi_int_connection_destroy( &conn ); + slapi_int_func_internal_pb( pb, op_delete ); + slap_graduate_commit_csn( pb->pop ); return 0; -#else - return -1; -#endif /* LDAP_SLAPI */ } int slapi_add_internal_pb( Slapi_PBlock *pb ) { -#ifdef LDAP_SLAPI - Connection *conn = NULL; - Slapi_Entry *entry = NULL; - char *dn = NULL; - LDAPMod **mods = NULL; - Operation *op = NULL; - char textbuf[ SLAP_TEXT_BUFLEN ]; - size_t textlen = sizeof( textbuf ); - - SlapReply rs = { REP_RESULT }; + SlapReply *rs; + Slapi_Entry *entry_orig = NULL; if ( pb == NULL ) { return -1; } - slapi_pblock_get( pb, SLAPI_ADD_ENTRY, (void **)&entry ); - slapi_pblock_get( pb, SLAPI_ADD_TARGET, (void **)&dn ); - slapi_pblock_get( pb, SLAPI_MODIFY_MODS, (void **)&mods ); + PBLOCK_ASSERT_INTOP( pb, LDAP_REQ_ADD ); - if ( entry != NULL ) { - if ( dn != NULL ) { - rs.sr_err = LDAP_PARAM_ERROR; + rs = &pb->rs; + + entry_orig = pb->pop->ora_e; + pb->pop->ora_e = NULL; + + if ( entry_orig != NULL ) { + if ( pb->pop->ora_modlist != NULL || !BER_BVISNULL( &pb->pop->o_req_ndn )) { + rs->sr_err = LDAP_PARAM_ERROR; goto cleanup; } - dn = slapi_entry_get_dn( entry ); - slapi_pblock_set( pb, SLAPI_ADD_TARGET, dn ); - } else if ( mods == NULL || dn == NULL ) { - rs.sr_err = LDAP_PARAM_ERROR; + assert( BER_BVISNULL( &pb->pop->o_req_dn ) ); /* shouldn't get set */ + ber_dupbv( &pb->pop->o_req_dn, &entry_orig->e_name ); + ber_dupbv( &pb->pop->o_req_ndn, &entry_orig->e_nname ); + } else if ( pb->pop->ora_modlist == NULL || BER_BVISNULL( &pb->pop->o_req_ndn )) { + rs->sr_err = LDAP_PARAM_ERROR; goto cleanup; } - rs.sr_err = slapi_int_connection_init( pb, LDAP_REQ_ADD, &conn ); - if ( rs.sr_err != LDAP_SUCCESS ) { - goto cleanup; - } - - op = (Operation *)conn->c_pending_ops.stqh_first; - op->ora_e = NULL; - op->ora_modlist = NULL; - /* * The caller can specify a new entry, or a target DN and set * of modifications, but not both. */ - op->ora_e = (Entry *)slapi_ch_calloc( 1, sizeof(*entry) ); - ber_dupbv( &op->ora_e->e_name, &op->o_req_dn ); - ber_dupbv( &op->ora_e->e_nname, &op->o_req_ndn ); + pb->pop->ora_e = (Entry *)slapi_ch_calloc( 1, sizeof(Entry) ); + ber_dupbv( &pb->pop->ora_e->e_name, &pb->pop->o_req_dn ); + ber_dupbv( &pb->pop->ora_e->e_nname, &pb->pop->o_req_ndn ); - if ( mods != NULL ) { - /* Entry just contains name; attributes are in modlist */ - op->ora_modlist = slapi_int_ldapmods2modifications( mods ); - if ( op->ora_modlist == NULL ) { - rs.sr_err = LDAP_PROTOCOL_ERROR; + if ( entry_orig != NULL ) { + assert( pb->pop->ora_modlist == NULL ); + + rs->sr_err = slap_entry2mods( entry_orig, &pb->pop->ora_modlist, + &rs->sr_text, pb->textbuf, sizeof( pb->textbuf ) ); + if ( rs->sr_err != LDAP_SUCCESS ) { goto cleanup; } } else { - rs.sr_err = slap_entry2mods( entry, &op->ora_modlist, - &rs.sr_text, textbuf, textlen ); - if ( rs.sr_err != LDAP_SUCCESS ) - goto cleanup; + assert( pb->pop->ora_modlist != NULL ); } - rs.sr_err = slap_mods_check( op->ora_modlist, &rs.sr_text, - textbuf, textlen, NULL ); - if ( rs.sr_err != LDAP_SUCCESS ) { + rs->sr_err = slap_mods_check( pb->pop->ora_modlist, &rs->sr_text, + pb->textbuf, sizeof( pb->textbuf ), NULL ); + if ( rs->sr_err != LDAP_SUCCESS ) { goto cleanup; } - rs.sr_err = frontendDB->be_add( op, &rs ); - if ( rs.sr_err == 0 ) { - if ( op->ora_e != NULL && op->o_private != NULL ) { - BackendDB *bd = op->o_bd; + if ( slapi_int_func_internal_pb( pb, op_add ) == 0 ) { + if ( pb->pop->ora_e != NULL && pb->pop->o_private != NULL ) { + BackendDB *bd = pb->pop->o_bd; /* could we use SLAPI_BACKEND instead? */ - op->o_bd = (BackendDB *)op->o_private; - op->o_private = NULL; - be_entry_release_w( op, op->ora_e ); - op->ora_e = NULL; - op->o_bd = bd; - op->o_private = NULL; + pb->pop->o_bd = (BackendDB *)pb->pop->o_private; + pb->pop->o_private = NULL; + be_entry_release_w( pb->pop, pb->pop->ora_e ); + pb->pop->ora_e = NULL; + pb->pop->o_bd = bd; + pb->pop->o_private = NULL; } } cleanup: - slapi_pblock_set( pb, SLAPI_PLUGIN_INTOP_RESULT, (void *)rs.sr_err ); + slap_graduate_commit_csn( pb->pop ); - slapi_entry_free( op->ora_e ); - slapi_int_mods_free( op->ora_modlist ); - slapi_int_connection_destroy( &conn ); + if ( pb->pop->ora_e != NULL ) { + slapi_entry_free( pb->pop->ora_e ); + pb->pop->ora_e = NULL; + } + if ( entry_orig != NULL ) { + pb->pop->ora_e = entry_orig; + slapi_int_mods_free( pb->pop->ora_modlist ); + pb->pop->ora_modlist = NULL; + } return 0; -#else - return -1; -#endif /* LDAP_SLAPI */ } int slapi_modrdn_internal_pb( Slapi_PBlock *pb ) { -#ifdef LDAP_SLAPI - struct berval newrdn = BER_BVNULL; - struct berval newsupdn = BER_BVNULL; - struct berval newSuperiorPretty = BER_BVNULL; - struct berval newSuperiorNormalized = BER_BVNULL; - Connection *conn = NULL; - Operation *op = NULL; - - char *lnewrdn; - char *newsuperior; - int deloldrdn; - - SlapReply rs = { REP_RESULT }; - if ( pb == NULL ) { return -1; } - slapi_pblock_get( pb, SLAPI_MODRDN_NEWRDN, (void **)&lnewrdn ); - slapi_pblock_get( pb, SLAPI_MODRDN_NEWSUPERIOR, (void **)&newsuperior ); - slapi_pblock_get( pb, SLAPI_MODRDN_DELOLDRDN, (void **)&deloldrdn ); + PBLOCK_ASSERT_INTOP( pb, LDAP_REQ_MODRDN ); - rs.sr_err = slapi_int_connection_init( pb, LDAP_REQ_MODRDN, &conn ); - if ( rs.sr_err != LDAP_SUCCESS ) { + if ( BER_BVISEMPTY( &pb->pop->o_req_ndn ) ) { + pb->rs.sr_err = LDAP_UNWILLING_TO_PERFORM; goto cleanup; } - op = (Operation *)conn->c_pending_ops.stqh_first; - - if ( op->o_req_dn.bv_len == 0 ) { - rs.sr_err = LDAP_UNWILLING_TO_PERFORM; - goto cleanup; - } - - newrdn.bv_val = lnewrdn; - newrdn.bv_len = strlen( lnewrdn ); - - rs.sr_err = dnPrettyNormal( NULL, &newrdn, &op->orr_newrdn, &op->orr_nnewrdn, NULL ); - if ( rs.sr_err != LDAP_SUCCESS ) { - goto cleanup; - } - - if ( rdn_validate( &op->orr_nnewrdn ) != LDAP_SUCCESS ) { - goto cleanup; - } - - if ( newsuperior != NULL ) { - newsupdn.bv_val = (char *)newsuperior; - newsupdn.bv_len = strlen( newsuperior ); - - rs.sr_err = dnPrettyNormal( NULL, &newsupdn, &newSuperiorPretty, &newSuperiorNormalized, NULL ); - if ( rs.sr_err != LDAP_SUCCESS ) - goto cleanup; - - op->orr_newSup = &newSuperiorPretty; - op->orr_nnewSup = &newSuperiorNormalized; - } else { - op->orr_newSup = NULL; - op->orr_nnewSup = NULL; - } - - op->orr_deleteoldrdn = deloldrdn; - - rs.sr_err = frontendDB->be_modrdn( op, &rs ); + slapi_int_func_internal_pb( pb, op_modrdn ); cleanup: - slapi_pblock_set( pb, SLAPI_PLUGIN_INTOP_RESULT, (void *)rs.sr_err ); - - slapi_ch_free_string( &op->orr_newrdn.bv_val ); - slapi_ch_free_string( &op->orr_nnewrdn.bv_val ); - slapi_ch_free_string( &newSuperiorPretty.bv_val ); - slapi_ch_free_string( &newSuperiorNormalized.bv_val ); - - slapi_int_connection_destroy( &conn ); + slap_graduate_commit_csn( pb->pop ); return 0; -#else - return -1; -#endif /* LDAP_SLAPI */ } int slapi_modify_internal_pb( Slapi_PBlock *pb ) { -#ifdef LDAP_SLAPI - Connection *conn = NULL; - Operation *op = NULL; - LDAPMod **mods = NULL; - char textbuf[ SLAP_TEXT_BUFLEN ]; - size_t textlen = sizeof( textbuf ); - - SlapReply rs = { REP_RESULT }; + SlapReply *rs; if ( pb == NULL ) { return -1; } - slapi_pblock_get( pb, SLAPI_MODIFY_MODS, (void **)&mods ); + PBLOCK_ASSERT_INTOP( pb, LDAP_REQ_MODIFY ); - if ( mods == NULL ) { - rs.sr_err = LDAP_PARAM_ERROR ; + rs = &pb->rs; + + if ( pb->pop->orm_modlist == NULL ) { + rs->sr_err = LDAP_PARAM_ERROR; goto cleanup; } - rs.sr_err = slapi_int_connection_init( pb, LDAP_REQ_MODIFY, &conn ); - if ( rs.sr_err != LDAP_SUCCESS ) { + if ( BER_BVISEMPTY( &pb->pop->o_req_ndn ) ) { + rs->sr_err = LDAP_UNWILLING_TO_PERFORM; goto cleanup; } - op = (Operation *)conn->c_pending_ops.stqh_first; - - if ( op->o_req_ndn.bv_len == 0 ) { - rs.sr_err = LDAP_UNWILLING_TO_PERFORM; - goto cleanup; - } - - op->orm_modlist = slapi_int_ldapmods2modifications( mods ); - - rs.sr_err = slap_mods_check( op->orm_modlist, &rs.sr_text, - textbuf, textlen, NULL ); - if ( rs.sr_err != LDAP_SUCCESS ) { + rs->sr_err = slap_mods_check( pb->pop->orm_modlist, + &rs->sr_text, pb->textbuf, sizeof( pb->textbuf ), NULL ); + if ( rs->sr_err != LDAP_SUCCESS ) { goto cleanup; } - rs.sr_err = frontendDB->be_modify( op, &rs ); + slapi_int_func_internal_pb( pb, op_modify ); cleanup: - slapi_pblock_set( pb, SLAPI_PLUGIN_INTOP_RESULT, (void *)rs.sr_err ); - - slapi_int_mods_free( op->orm_modlist ); - slapi_int_connection_destroy( &conn ); + slap_graduate_commit_csn( pb->pop ); return 0; -#else - return -1; -#endif /* LDAP_SLAPI */ } -#ifdef LDAP_SLAPI static int slapi_int_search_entry_callback( Slapi_Entry *entry, void *callback_data ) { @@ -749,9 +551,11 @@ slapi_int_search_entry_callback( Slapi_Entry *entry, void *callback_data ) Slapi_Entry **head = NULL, **tp; Slapi_PBlock *pb = (Slapi_PBlock *)callback_data; + PBLOCK_ASSERT_INTOP( pb, LDAP_REQ_SEARCH ); + entry = slapi_entry_dup( entry ); if ( entry == NULL ) { - return 1; + return LDAP_NO_MEMORY; } slapi_pblock_get( pb, SLAPI_NENTRIES, &nentries ); @@ -762,40 +566,35 @@ slapi_int_search_entry_callback( Slapi_Entry *entry, void *callback_data ) tp = (Slapi_Entry **)slapi_ch_malloc( 2 * sizeof(Slapi_Entry *) ); if ( tp == NULL ) { slapi_entry_free( entry ); - return 1; + return LDAP_NO_MEMORY; } - tp[ 0 ] = entry; + tp[0] = entry; } else { tp = (Slapi_Entry **)slapi_ch_realloc( (char *)head, sizeof(Slapi_Entry *) * ( i + 1 ) ); if ( tp == NULL ) { slapi_entry_free( entry ); - return 1; + return LDAP_NO_MEMORY; } - tp[ i - 1 ] = entry; + tp[i - 1] = entry; } - tp[ i ] = NULL; + tp[i] = NULL; slapi_pblock_set( pb, SLAPI_PLUGIN_INTOP_SEARCH_ENTRIES, (void *)tp ); slapi_pblock_set( pb, SLAPI_NENTRIES, (void *)i ); return LDAP_SUCCESS; } -#endif /* LDAP_SLAPI */ int slapi_search_internal_pb( Slapi_PBlock *pb ) { -#ifdef LDAP_SLAPI return slapi_search_internal_callback_pb( pb, (void *)pb, NULL, slapi_int_search_entry_callback, NULL ); -#else - return -1; -#endif } int @@ -805,37 +604,16 @@ slapi_search_internal_callback_pb( Slapi_PBlock *pb, plugin_search_entry_callback psec, plugin_referral_entry_callback prec ) { -#ifdef LDAP_SLAPI - Connection *conn = NULL; - Operation *op = NULL; - Filter *filter = NULL; - struct berval fstr = BER_BVNULL; - AttributeName *an = NULL; - const char *text = NULL; - - int scope = LDAP_SCOPE_BASE; - char *filStr = NULL; - char **attrs = NULL; - int attrsonly = 0; - int freeFilter = 0; - int i; - - SlapReply rs = { REP_RESULT }; + int free_filter = 0; + SlapReply *rs; if ( pb == NULL ) { return -1; } - slapi_pblock_get( pb, SLAPI_SEARCH_SCOPE, (void **)&scope ); - slapi_pblock_get( pb, SLAPI_SEARCH_FILTER, (void **)&filter ); - slapi_pblock_get( pb, SLAPI_SEARCH_STRFILTER, (void **)&filStr ); - slapi_pblock_get( pb, SLAPI_SEARCH_ATTRS, (void **)&attrs ); - slapi_pblock_get( pb, SLAPI_SEARCH_ATTRSONLY, (void **)&attrsonly ); + PBLOCK_ASSERT_INTOP( pb, LDAP_REQ_SEARCH ); - rs.sr_err = slapi_int_connection_init( pb, LDAP_REQ_SEARCH, &conn ); - if ( rs.sr_err != LDAP_SUCCESS ) { - goto cleanup; - } + rs = &pb->rs; /* search callback and arguments */ slapi_pblock_set( pb, SLAPI_X_INTOP_RESULT_CALLBACK, (void *)prc ); @@ -843,87 +621,35 @@ slapi_search_internal_callback_pb( Slapi_PBlock *pb, slapi_pblock_set( pb, SLAPI_X_INTOP_REFERRAL_ENTRY_CALLBACK, (void *)prec ); slapi_pblock_set( pb, SLAPI_X_INTOP_CALLBACK_DATA, (void *)callback_data ); - op = (Operation *)conn->c_pending_ops.stqh_first; - - switch ( scope ) { - case LDAP_SCOPE_BASE: - case LDAP_SCOPE_ONELEVEL: - case LDAP_SCOPE_SUBTREE: -#ifdef LDAP_SCOPE_SUBORDINATE - case LDAP_SCOPE_SUBORDINATE: -#endif - break; - default: - rs.sr_err = LDAP_PROTOCOL_ERROR; - goto cleanup; + if ( BER_BVISEMPTY( &pb->pop->ors_filterstr )) { + rs->sr_err = LDAP_PARAM_ERROR; + goto cleanup; } - if ( filter == NULL ) { - if ( filStr == NULL ) { - rs.sr_err = LDAP_PARAM_ERROR; + if ( pb->pop->ors_filter == NULL ) { + pb->pop->ors_filter = slapi_str2filter( pb->pop->ors_filterstr.bv_val ); + if ( pb->pop->ors_filter == NULL ) { + rs->sr_err = LDAP_PROTOCOL_ERROR; goto cleanup; } - filter = slapi_str2filter( filStr ); - if ( filter == NULL ) { - rs.sr_err = LDAP_PROTOCOL_ERROR; - goto cleanup; - } - - freeFilter = 1; + free_filter = 1; } - filter2bv( filter, &fstr ); - - for ( i = 0; attrs != NULL && attrs[i] != NULL; i++ ) { - ; /* count the number of attributes */ - } - - if ( i > 0 ) { - an = (AttributeName *)slapi_ch_calloc( (i + 1), sizeof(AttributeName) ); - for (i = 0; attrs[i] != 0; i++) { - an[i].an_desc = NULL; - an[i].an_oc = NULL; - an[i].an_oc_exclude = 0; - an[i].an_name.bv_val = attrs[i]; - an[i].an_name.bv_len = strlen(attrs[i]); - slap_bv2ad( &an[i].an_name, &an[i].an_desc, &text ); - } - an[i].an_name.bv_val = NULL; - } - - rs.sr_type = REP_RESULT; - rs.sr_err = LDAP_SUCCESS; - rs.sr_entry = NULL; /* paranoia */ - op->ors_scope = scope; - op->ors_deref = 0; - op->ors_slimit = SLAP_NO_LIMIT; - op->ors_tlimit = SLAP_NO_LIMIT; - op->ors_attrsonly = attrsonly; - op->ors_attrs = an; - op->ors_filter = filter; - op->ors_filterstr = fstr; - - rs.sr_err = frontendDB->be_search( op, &rs ); + slapi_int_func_internal_pb( pb, op_search ); cleanup: - slapi_pblock_set( pb, SLAPI_PLUGIN_INTOP_RESULT, (void *)rs.sr_err ); + if ( free_filter ) { + slapi_filter_free( pb->pop->ors_filter, 1 ); + pb->pop->ors_filter = NULL; + } + slapi_pblock_set( pb, SLAPI_X_INTOP_RESULT_CALLBACK, NULL ); slapi_pblock_set( pb, SLAPI_X_INTOP_SEARCH_ENTRY_CALLBACK, NULL ); slapi_pblock_set( pb, SLAPI_X_INTOP_REFERRAL_ENTRY_CALLBACK, NULL ); slapi_pblock_set( pb, SLAPI_X_INTOP_CALLBACK_DATA, NULL ); - if ( freeFilter && filter != NULL ) - slapi_filter_free( filter, 1 ); - slapi_ch_free_string( &fstr.bv_val ); - slapi_ch_free( (void **)&an ); - - slapi_int_connection_destroy( &conn ); - return 0; -#else - return -1; -#endif /* LDAP_SLAPI */ } /* Wrappers for old API */ @@ -940,10 +666,10 @@ slapi_search_internal_set_pb( Slapi_PBlock *pb, Slapi_ComponentId *plugin_identity, int operation_flags ) { -#ifdef LDAP_SLAPI + slapi_int_connection_init_pb( pb, LDAP_REQ_SEARCH ); slapi_pblock_set( pb, SLAPI_SEARCH_TARGET, (void *)base ); slapi_pblock_set( pb, SLAPI_SEARCH_SCOPE, (void *)scope ); - slapi_pblock_set( pb, SLAPI_SEARCH_FILTER, NULL ); + slapi_pblock_set( pb, SLAPI_SEARCH_FILTER, NULL ); slapi_pblock_set( pb, SLAPI_SEARCH_STRFILTER, (void *)filter ); slapi_pblock_set( pb, SLAPI_SEARCH_ATTRS, (void *)attrs ); slapi_pblock_set( pb, SLAPI_SEARCH_ATTRSONLY, (void *)attrsonly ); @@ -951,7 +677,11 @@ slapi_search_internal_set_pb( Slapi_PBlock *pb, slapi_pblock_set( pb, SLAPI_TARGET_UNIQUEID, (void *)uniqueid ); slapi_pblock_set( pb, SLAPI_PLUGIN_IDENTITY, (void *)plugin_identity ); slapi_pblock_set( pb, SLAPI_X_INTOP_FLAGS, (void *)operation_flags ); -#endif /* LDAP_SLAPI */ + slapi_pblock_set( pb, SLAPI_SEARCH_DEREF, (void *)0 ); + slapi_pblock_set( pb, SLAPI_SEARCH_SIZELIMIT, (void *)SLAP_NO_LIMIT ); + slapi_pblock_set( pb, SLAPI_SEARCH_TIMELIMIT, (void *)SLAP_NO_LIMIT ); + + slapi_int_set_operation_dn( pb ); } Slapi_PBlock * @@ -963,23 +693,17 @@ slapi_search_internal( char **attrs, int attrsonly ) { -#ifdef LDAP_SLAPI Slapi_PBlock *pb; pb = slapi_pblock_new(); - if ( pb == NULL ) { - return NULL; - } - slapi_search_internal_set_pb( pb, ldn, scope, filStr, attrs, attrsonly, + slapi_search_internal_set_pb( pb, ldn, scope, filStr, + attrs, attrsonly, controls, NULL, NULL, 0 ); slapi_search_internal_pb( pb ); return pb; -#else - return NULL; -#endif /* LDAP_SLAPI */ } void @@ -991,14 +715,14 @@ slapi_modify_internal_set_pb( Slapi_PBlock *pb, Slapi_ComponentId *plugin_identity, int operation_flags ) { -#ifdef LDAP_SLAPI + slapi_int_connection_init_pb( pb, LDAP_REQ_MODIFY ); slapi_pblock_set( pb, SLAPI_MODIFY_TARGET, (void *)dn ); slapi_pblock_set( pb, SLAPI_MODIFY_MODS, (void *)mods ); slapi_pblock_set( pb, SLAPI_REQCONTROLS, (void *)controls ); slapi_pblock_set( pb, SLAPI_TARGET_UNIQUEID, (void *)uniqueid ); slapi_pblock_set( pb, SLAPI_PLUGIN_IDENTITY, (void *)plugin_identity ); slapi_pblock_set( pb, SLAPI_X_INTOP_FLAGS, (void *)operation_flags ); -#endif /* LDAP_SLAPI */ + slapi_int_set_operation_dn( pb ); } /* Function : slapi_modify_internal @@ -1018,13 +742,9 @@ slapi_modify_internal( LDAPControl **controls, int log_change ) { -#ifdef LDAP_SLAPI Slapi_PBlock *pb; pb = slapi_pblock_new(); - if ( pb == NULL ) { - return NULL; - } slapi_modify_internal_set_pb( pb, ldn, mods, controls, NULL, NULL, log_change ? SLAPI_OP_FLAG_LOG_CHANGE : 0 ); @@ -1032,9 +752,6 @@ slapi_modify_internal( slapi_modify_internal_pb( pb ); return pb; -#else - return NULL; -#endif /* LDAP_SLAPI */ } int @@ -1045,17 +762,15 @@ slapi_add_internal_set_pb( Slapi_PBlock *pb, Slapi_ComponentId *plugin_identity, int operation_flags ) { -#ifdef LDAP_SLAPI + slapi_int_connection_init_pb( pb, LDAP_REQ_ADD ); slapi_pblock_set( pb, SLAPI_ADD_TARGET, (void *)dn ); slapi_pblock_set( pb, SLAPI_MODIFY_MODS, (void *)attrs ); slapi_pblock_set( pb, SLAPI_REQCONTROLS, (void *)controls ); slapi_pblock_set( pb, SLAPI_PLUGIN_IDENTITY, (void *)plugin_identity ); slapi_pblock_set( pb, SLAPI_X_INTOP_FLAGS, (void *)operation_flags ); + slapi_int_set_operation_dn( pb ); return 0; -#else - return -1; -#endif /* LDAP_SLAPI */ } Slapi_PBlock * @@ -1065,12 +780,9 @@ slapi_add_internal( LDAPControl **controls, int log_changes ) { -#ifdef LDAP_SLAPI Slapi_PBlock *pb; pb = slapi_pblock_new(); - if ( pb == NULL ) - return NULL; slapi_add_internal_set_pb( pb, dn, attrs, controls, NULL, log_changes ? SLAPI_OP_FLAG_LOG_CHANGE : 0 ); @@ -1078,9 +790,6 @@ slapi_add_internal( slapi_add_internal_pb( pb ); return pb; -#else - return NULL; -#endif /* LDAP_SLAPI */ } void @@ -1090,12 +799,12 @@ slapi_add_entry_internal_set_pb( Slapi_PBlock *pb, Slapi_ComponentId *plugin_identity, int operation_flags ) { -#ifdef LDAP_SLAPI + slapi_int_connection_init_pb( pb, LDAP_REQ_ADD ); slapi_pblock_set( pb, SLAPI_ADD_ENTRY, (void *)e ); slapi_pblock_set( pb, SLAPI_REQCONTROLS, (void *)controls ); slapi_pblock_set( pb, SLAPI_PLUGIN_IDENTITY, (void *)plugin_identity ); slapi_pblock_set( pb, SLAPI_X_INTOP_FLAGS, (void *)operation_flags ); -#endif /* LDAP_SLAPI */ + slapi_int_set_operation_dn( pb ); } Slapi_PBlock * @@ -1104,12 +813,9 @@ slapi_add_entry_internal( LDAPControl **controls, int log_changes ) { -#ifdef LDAP_SLAPI Slapi_PBlock *pb; pb = slapi_pblock_new(); - if ( pb == NULL ) - return NULL; slapi_add_entry_internal_set_pb( pb, e, controls, NULL, log_changes ? SLAPI_OP_FLAG_LOG_CHANGE : 0 ); @@ -1117,9 +823,6 @@ slapi_add_entry_internal( slapi_add_internal_pb( pb ); return pb; -#else - return NULL; -#endif /* LDAP_SLAPI */ } void @@ -1133,7 +836,7 @@ slapi_rename_internal_set_pb( Slapi_PBlock *pb, Slapi_ComponentId *plugin_identity, int operation_flags ) { -#ifdef LDAP_SLAPI + slapi_int_connection_init_pb( pb, LDAP_REQ_MODRDN ); slapi_pblock_set( pb, SLAPI_MODRDN_TARGET, (void *)olddn ); slapi_pblock_set( pb, SLAPI_MODRDN_NEWRDN, (void *)newrdn ); slapi_pblock_set( pb, SLAPI_MODRDN_NEWSUPERIOR, (void *)newsuperior ); @@ -1142,7 +845,7 @@ slapi_rename_internal_set_pb( Slapi_PBlock *pb, slapi_pblock_set( pb, SLAPI_TARGET_UNIQUEID, (void *)uniqueid ); slapi_pblock_set( pb, SLAPI_PLUGIN_IDENTITY, (void *)plugin_identity ); slapi_pblock_set( pb, SLAPI_X_INTOP_FLAGS, (void *)operation_flags ); -#endif /* LDAP_SLAPI */ + slapi_int_set_operation_dn( pb ); } /* Function : slapi_modrdn_internal @@ -1165,13 +868,9 @@ slapi_modrdn_internal( LDAPControl **controls, int log_change ) { -#ifdef LDAP_SLAPI Slapi_PBlock *pb; - pb = slapi_pblock_new(); - if ( pb == NULL ) { - return NULL; - } + pb = slapi_pblock_new (); slapi_rename_internal_set_pb( pb, olddn, lnewrdn, NULL, deloldrdn, controls, NULL, NULL, @@ -1180,9 +879,6 @@ slapi_modrdn_internal( slapi_modrdn_internal_pb( pb ); return pb; -#else - return NULL; -#endif /* LDAP_SLAPI */ } void @@ -1193,13 +889,13 @@ slapi_delete_internal_set_pb( Slapi_PBlock *pb, Slapi_ComponentId *plugin_identity, int operation_flags ) { -#ifdef LDAP_SLAPI + slapi_int_connection_init_pb( pb, LDAP_REQ_DELETE ); slapi_pblock_set( pb, SLAPI_TARGET_DN, (void *)dn ); slapi_pblock_set( pb, SLAPI_REQCONTROLS, (void *)controls ); slapi_pblock_set( pb, SLAPI_TARGET_UNIQUEID, (void *)uniqueid ); slapi_pblock_set( pb, SLAPI_PLUGIN_IDENTITY, (void *)plugin_identity ); slapi_pblock_set( pb, SLAPI_X_INTOP_FLAGS, (void *)operation_flags ); -#endif /* LDAP_SLAPI */ + slapi_int_set_operation_dn( pb ); } /* Function : slapi_delete_internal @@ -1218,12 +914,9 @@ slapi_delete_internal( LDAPControl **controls, int log_change ) { -#ifdef LDAP_SLAPI Slapi_PBlock *pb; pb = slapi_pblock_new(); - if ( pb == NULL ) - return NULL; slapi_delete_internal_set_pb( pb, ldn, controls, NULL, NULL, log_change ? SLAPI_OP_FLAG_LOG_CHANGE : 0 ); @@ -1231,8 +924,7 @@ slapi_delete_internal( slapi_delete_internal_pb( pb ); return pb; -#else - return NULL; -#endif /* LDAP_SLAPI */ } +#endif /* LDAP_SLAPI */ + diff --git a/servers/slapd/slapi/slapi_overlay.c b/servers/slapd/slapi/slapi_overlay.c index 80671dccc6..41045fb9a6 100644 --- a/servers/slapd/slapi/slapi_overlay.c +++ b/servers/slapd/slapi/slapi_overlay.c @@ -45,7 +45,11 @@ slapi_over_pblock_new ( Operation *op ) return NULL; } - slapi_int_pblock_set_operation( pb, op ); + pb->pop = op; + pb->pconn = op->o_conn; + pb->internal_op = 0; + + PBLOCK_ASSERT_OP( pb, 0 ); return pb; } @@ -57,29 +61,27 @@ slapi_op_internal_p( Operation *op, slap_callback *cb ) Slapi_PBlock *pb = NULL; slap_callback *pcb; - /* Abstraction violating check for SLAPI internal operations */ - /* allows pblock to remain consistent when invoking internal op plugins */ + /* + * Abstraction violating check for SLAPI internal operations + * allows pblock to remain consistent when invoking internal + * op plugins + */ for ( pcb = op->o_callback; pcb != NULL; pcb = pcb->sc_next ) { if ( pcb->sc_response == slapi_int_response ) { pb = (Slapi_PBlock *)pcb->sc_private; + PBLOCK_ASSERT_INTOP( pb, 0 ); internal_op = 1; break; } } if ( cb != NULL ) { - if ( !internal_op ) { - cb->sc_response = slapi_over_response; - cb->sc_cleanup = slapi_over_cleanup; - } else { - cb->sc_response = NULL; - cb->sc_cleanup = NULL; - } - if ( pb == NULL ) { pb = slapi_over_pblock_new( op ); } + cb->sc_response = slapi_over_response; + cb->sc_cleanup = slapi_over_cleanup; cb->sc_private = pb; cb->sc_next = op->o_callback; op->o_callback = cb; @@ -131,7 +133,7 @@ slapi_over_compute_output( for ( a = &rs->sr_operational_attrs; *a != NULL; a = &(*a)->a_next ) ; - *a = attr_dup( attribute ); + *a = slapi_attr_dup( attribute ); return 0; } @@ -188,149 +190,36 @@ slapi_over_search( Operation *op, SlapReply *rs, int type ) /* create a new pblock to not trample on result controls */ pb = slapi_over_pblock_new( op ); - slapi_pblock_set( pb, SLAPI_RESCONTROLS, (void *)rs->sr_ctrls ); - slapi_pblock_set( pb, SLAPI_SEARCH_RESULT_ENTRY, (void *)rs->sr_entry ); - rc = slapi_int_call_plugins( op->o_bd, type, pb ); if ( rc >= 0 ) /* 1 means no plugins called */ rc = SLAP_CB_CONTINUE; else rc = LDAP_SUCCESS; /* confusing: don't abort, but don't send */ - slapi_pblock_set( pb, SLAPI_RESCONTROLS, NULL ); /* don't free */ slapi_pblock_destroy(pb); return rc; } -static int -slapi_over_count_controls( LDAPControl **controls ) -{ - int i; - - if ( controls == NULL ) - return 0; - - for ( i = 0; controls[i] != NULL; i++ ) - ; - - return i; -} - -static int -slapi_over_merge_controls( Operation *op, SlapReply *rs ) -{ - Slapi_PBlock *pb = SLAPI_OPERATION_PBLOCK( op ); - LDAPControl **slapiControls = NULL, **mergedControls; - int nSlapiControls = 0; - int nResControls = 0; - int i; - - slapi_pblock_get( pb, SLAPI_RESCONTROLS, (void **)&slapiControls ); - nSlapiControls = slapi_over_count_controls( slapiControls ); - - if ( nSlapiControls == 0 ) { - /* short-circuit */ - return LDAP_SUCCESS; - } - - nResControls = slapi_over_count_controls( rs->sr_ctrls ); - - /* XXX this is a bit tricky, rs->sr_ctrls may have been allocated on stack */ - mergedControls = (LDAPControl **)op->o_tmpalloc( ( nResControls + nSlapiControls + 1 ) * - sizeof( LDAPControl *), op->o_tmpmemctx ); - if ( mergedControls == NULL ) { - return LDAP_NO_MEMORY; - } - - if ( rs->sr_ctrls != NULL ) { - for ( i = 0; i < nResControls; i++ ) - mergedControls[i] = rs->sr_ctrls[i]; - } - if ( slapiControls != NULL ) { - for ( i = 0; i < nSlapiControls; i++ ) - mergedControls[nResControls + i] = slapiControls[i]; - } - mergedControls[nResControls + nSlapiControls] = NULL; - - if ( slapiControls != NULL ) { - slapi_ch_free( (void **)&slapiControls ); - slapi_pblock_set( pb, SLAPI_RESCONTROLS, NULL ); /* don't free */ - } - - rs->sr_ctrls = mergedControls; - - return LDAP_SUCCESS; -} - /* * Call pre- and post-result plugins */ static int slapi_over_result( Operation *op, SlapReply *rs, int type ) { - int rc; Slapi_PBlock *pb = SLAPI_OPERATION_PBLOCK( op ); assert( rs->sr_type == REP_RESULT ); - slapi_pblock_set( pb, SLAPI_RESULT_CODE, (void *)rs->sr_err ); - slapi_pblock_set( pb, SLAPI_RESULT_TEXT, (void *)rs->sr_text ); - slapi_pblock_set( pb, SLAPI_RESULT_MATCHED, (void *)rs->sr_matched ); - - rc = slapi_int_call_plugins( op->o_bd, type, pb ); - - slapi_pblock_get( pb, SLAPI_RESULT_CODE, (void **)&rs->sr_err ); - slapi_pblock_get( pb, SLAPI_RESULT_TEXT, (void **)&rs->sr_text ); - slapi_pblock_get( pb, SLAPI_RESULT_MATCHED, (void **)&rs->sr_matched ); - - if ( type == SLAPI_PLUGIN_PRE_RESULT_FN ) { - rc = slapi_over_merge_controls( op, rs ); - } + slapi_int_call_plugins( op->o_bd, type, pb ); return SLAP_CB_CONTINUE; } -static int -slapi_op_add_init( Operation *op, SlapReply *rs ) -{ - Slapi_PBlock *pb = SLAPI_OPERATION_PBLOCK( op ); - - slapi_pblock_set( pb, SLAPI_ADD_ENTRY, (void *)op->ora_e ); - - return LDAP_SUCCESS; -} - -static int -slapi_op_bind_preop_init( Operation *op, SlapReply *rs ) -{ - Slapi_PBlock *pb = SLAPI_OPERATION_PBLOCK( op ); - - slapi_pblock_set( pb, SLAPI_BIND_TARGET, (void *)op->o_req_dn.bv_val ); - slapi_pblock_set( pb, SLAPI_BIND_METHOD, (void *)op->orb_method ); - slapi_pblock_set( pb, SLAPI_BIND_CREDENTIALS, (void *)&op->orb_cred ); - slapi_pblock_set( pb, SLAPI_CONN_DN, NULL ); - - return LDAP_SUCCESS; -} - -static int -slapi_op_bind_postop_init( Operation *op, SlapReply *rs ) -{ - Slapi_PBlock *pb = SLAPI_OPERATION_PBLOCK( op ); - - if ( rs->sr_err == LDAP_SUCCESS ) { - /* fix for ITS#2971 */ - slapi_pblock_set( pb, SLAPI_CONN_DN, op->o_conn->c_authz.sai_dn.bv_val ); - } - - return LDAP_SUCCESS; -} static int slapi_op_bind_callback( Operation *op, SlapReply *rs ) { - Slapi_PBlock *pb = SLAPI_OPERATION_PBLOCK( op ); int rc = rs->sr_err; switch ( rc ) { @@ -345,37 +234,24 @@ slapi_op_bind_callback( Operation *op, SlapReply *rs ) break; case SLAPI_BIND_ANONYMOUS: /* undocumented */ default: /* plugin sent result or no plugins called */ - if ( slapi_pblock_get( pb, SLAPI_RESULT_CODE, (void **)&rs->sr_err ) != 0 ) { - rs->sr_err = LDAP_OTHER; - } - BER_BVZERO( &op->orb_edn ); if ( rs->sr_err == LDAP_SUCCESS ) { - slapi_pblock_get( pb, SLAPI_CONN_DN, (void *)&op->orb_edn.bv_val ); - if ( BER_BVISNULL( &op->orb_edn ) ) { - if ( rc == 1 ) { - /* No plugins were called; continue processing */ - return LDAP_SUCCESS; - } - } else { - op->orb_edn.bv_len = strlen( op->orb_edn.bv_val ); + /* + * Plugin will have called slapi_pblock_set(LDAP_CONN_DN) which + * will have set conn->c_dn and conn->c_ndn + */ + if ( BER_BVISNULL( &op->o_conn->c_ndn ) && rc == 1 ) { + /* No plugins were called; continue processing */ + return LDAP_SUCCESS; } - rs->sr_err = dnPrettyNormal( NULL, &op->orb_edn, - &op->o_req_dn, &op->o_req_ndn, op->o_tmpmemctx ); - ldap_pvt_thread_mutex_lock( &op->o_conn->c_mutex ); - ber_dupbv(&op->o_conn->c_dn, &op->o_req_dn); - ber_dupbv(&op->o_conn->c_ndn, &op->o_req_ndn); - op->o_tmpfree( op->o_req_dn.bv_val, op->o_tmpmemctx ); - BER_BVZERO( &op->o_req_dn ); - op->o_tmpfree( op->o_req_ndn.bv_val, op->o_tmpmemctx ); - BER_BVZERO( &op->o_req_ndn ); - if ( !BER_BVISEMPTY( &op->o_conn->c_dn ) ) { + if ( !BER_BVISEMPTY( &op->o_conn->c_ndn ) ) { ber_len_t max = sockbuf_max_incoming_auth; ber_sockbuf_ctrl( op->o_conn->c_sb, LBER_SB_OPT_SET_MAX_INCOMING, &max ); } + ldap_pvt_thread_mutex_unlock( &op->o_conn->c_mutex ); /* log authorization identity */ Statslog( LDAP_DEBUG_STATS, @@ -385,7 +261,6 @@ slapi_op_bind_callback( Operation *op, SlapReply *rs ) ? "" : op->o_conn->c_dn.bv_val, op->orb_tmp_mech.bv_val, 0, 0 ); - ldap_pvt_thread_mutex_unlock( &op->o_conn->c_mutex ); return -1; } break; @@ -394,105 +269,6 @@ slapi_op_bind_callback( Operation *op, SlapReply *rs ) return rc; } -static int -slapi_op_compare_init( Operation *op, SlapReply *rs ) -{ - Slapi_PBlock *pb = SLAPI_OPERATION_PBLOCK( op ); - - slapi_pblock_set( pb, SLAPI_COMPARE_TYPE, (void *)op->orc_ava->aa_desc->ad_cname.bv_val ); - slapi_pblock_set( pb, SLAPI_COMPARE_VALUE, (void *)&op->orc_ava->aa_value ); - - return LDAP_SUCCESS; -} - -static int -slapi_op_modify_init( Operation *op, SlapReply *rs ) -{ - Slapi_PBlock *pb = SLAPI_OPERATION_PBLOCK( op ); - LDAPMod **modv = NULL; - - modv = slapi_int_modifications2ldapmods( &op->orm_modlist ); - slapi_pblock_set( pb, SLAPI_MODIFY_MODS, (void *)modv ); - - return LDAP_SUCCESS; -} - -static int -slapi_op_modify_callback( Operation *op, SlapReply *rs ) -{ - Slapi_PBlock *pb = SLAPI_OPERATION_PBLOCK( op ); - LDAPMod **modv = NULL; - - /* check preoperation result code */ - if ( rs->sr_err < 0 ) { - slapi_pblock_get( pb, SLAPI_RESULT_CODE, (void **)&rs->sr_err ); - return rs->sr_err; - } - - /* - * NB: it is valid for the plugin to return no modifications - * (for example, a plugin might store some attributes elsewhere - * and remove them from the modification list; if only those - * attribute types were included in the modification request, - * then slapi_int_ldapmods2modifications() above will return - * NULL). - * - * However, the post-operation plugin should still be - * called. - */ - - slapi_pblock_get( pb, SLAPI_MODIFY_MODS, (void **)&modv ); - op->orm_modlist = slapi_int_ldapmods2modifications( modv ); - - return LDAP_SUCCESS; -} - -static int -slapi_op_modify_cleanup( Operation *op, SlapReply *rs ) -{ - Slapi_PBlock *pb = SLAPI_OPERATION_PBLOCK( op ); - LDAPMod **modv = NULL; - - slapi_pblock_get( pb, SLAPI_MODIFY_MODS, (void **)&modv ); - - if ( modv != NULL ) - slapi_int_free_ldapmods( modv ); - - return LDAP_SUCCESS; -} - -static int -slapi_op_modrdn_init( Operation *op, SlapReply *rs ) -{ - Slapi_PBlock *pb = SLAPI_OPERATION_PBLOCK( op ); - - slapi_pblock_set( pb, SLAPI_MODRDN_NEWRDN, (void *)op->orr_newrdn.bv_val ); - slapi_pblock_set( pb, SLAPI_MODRDN_NEWSUPERIOR, (void *)op->orr_newSup->bv_val ); - slapi_pblock_set( pb, SLAPI_MODRDN_DELOLDRDN, (void *)op->orr_deleteoldrdn ); - - return LDAP_SUCCESS; -} - -static int -slapi_op_search_init( Operation *op, SlapReply *rs ) -{ - Slapi_PBlock *pb = SLAPI_OPERATION_PBLOCK( op ); - char **attrs; - - attrs = anlist2charray_x( op->ors_attrs, 0, op->o_tmpmemctx ); - - slapi_pblock_set( pb, SLAPI_SEARCH_SCOPE, (void *)op->ors_scope ); - slapi_pblock_set( pb, SLAPI_SEARCH_DEREF, (void *)op->ors_deref ); - slapi_pblock_set( pb, SLAPI_SEARCH_SIZELIMIT, (void *)op->ors_slimit ); - slapi_pblock_set( pb, SLAPI_SEARCH_TIMELIMIT, (void *)op->ors_tlimit ); - slapi_pblock_set( pb, SLAPI_SEARCH_FILTER, (void *)op->ors_filter ); - slapi_pblock_set( pb, SLAPI_SEARCH_STRFILTER, (void *)op->ors_filterstr.bv_val ); - slapi_pblock_set( pb, SLAPI_SEARCH_ATTRS, (void *)attrs ); - slapi_pblock_set( pb, SLAPI_SEARCH_ATTRSONLY, (void *)op->ors_attrsonly ); - - return LDAP_SUCCESS; -} - static int slapi_op_search_callback( Operation *op, SlapReply *rs ) { @@ -504,48 +280,17 @@ slapi_op_search_callback( Operation *op, SlapReply *rs ) return rs->sr_err; } - if ( slapi_int_call_plugins( op->o_bd, SLAPI_PLUGIN_COMPUTE_SEARCH_REWRITER_FN, pb ) != 0 ) { - return LDAP_SUCCESS; + rs->sr_err = LDAP_SUCCESS; + + if ( slapi_int_call_plugins( op->o_bd, SLAPI_PLUGIN_COMPUTE_SEARCH_REWRITER_FN, pb ) == 0 ) { + /* + * The plugin can set the SLAPI_SEARCH_FILTER. + * SLAPI_SEARCH_STRFILER is not normative. + */ + op->o_tmpfree( op->ors_filterstr.bv_val, op->o_tmpmemctx ); + filter2bv_x( op, op->ors_filter, &op->ors_filterstr ); } - /* - * The plugin can set the SLAPI_SEARCH_FILTER. - * SLAPI_SEARCH_STRFILER is not normative. - */ - slapi_pblock_get( pb, SLAPI_SEARCH_FILTER, (void *)&op->ors_filter ); - op->o_tmpfree( op->ors_filterstr.bv_val, op->o_tmpmemctx ); - filter2bv_x( op, op->ors_filter, &op->ors_filterstr ); - - slapi_pblock_get( pb, SLAPI_SEARCH_TARGET, (void **)&op->o_req_dn.bv_val ); - op->o_req_dn.bv_len = strlen( op->o_req_dn.bv_val ); - - if( !BER_BVISNULL( &op->o_req_ndn ) ) { - slap_sl_free( op->o_req_ndn.bv_val, op->o_tmpmemctx ); - } - rs->sr_err = dnNormalize( 0, NULL, NULL, &op->o_req_dn, &op->o_req_ndn, - op->o_tmpmemctx ); - if ( rs->sr_err != LDAP_SUCCESS ) { - send_ldap_result( op, rs ); - return rs->sr_err; - } - - slapi_pblock_get( pb, SLAPI_SEARCH_SCOPE, (void **)&op->ors_scope ); - slapi_pblock_get( pb, SLAPI_SEARCH_DEREF, (void **)&op->ors_deref ); - - return LDAP_SUCCESS; -} - -static int -slapi_op_search_cleanup( Operation *op, SlapReply *rs ) -{ - Slapi_PBlock *pb = SLAPI_OPERATION_PBLOCK( op ); - char **attrs = NULL; - - slapi_pblock_get( pb, SLAPI_SEARCH_ATTRS, (void *)&attrs ); - - if ( attrs != NULL ) - op->o_tmpfree( attrs, op->o_tmpmemctx ); - return LDAP_SUCCESS; } @@ -554,29 +299,20 @@ struct slapi_op_info { int soi_postop; /* postoperation plugin parameter */ int soi_internal_preop; /* internal preoperation plugin parameter */ int soi_internal_postop; /* internal postoperation plugin parameter */ - slap_response *soi_preop_init; /* preoperation pblock init function */ slap_response *soi_callback; /* preoperation result handler */ - slap_response *soi_postop_init; /* postoperation pblock init function */ - slap_response *soi_cleanup; /* cleanup function (not for internal ops) */ } slapi_op_dispatch_table[] = { { SLAPI_PLUGIN_PRE_BIND_FN, SLAPI_PLUGIN_POST_BIND_FN, 0, 0, - slapi_op_bind_preop_init, - slapi_op_bind_callback, - slapi_op_bind_postop_init, - NULL + slapi_op_bind_callback }, { SLAPI_PLUGIN_PRE_UNBIND_FN, SLAPI_PLUGIN_POST_UNBIND_FN, 0, 0, - NULL, - NULL, - NULL, NULL }, { @@ -584,19 +320,13 @@ struct slapi_op_info { SLAPI_PLUGIN_POST_SEARCH_FN, 0, 0, - slapi_op_search_init, - slapi_op_search_callback, - NULL, - slapi_op_search_cleanup + slapi_op_search_callback }, { SLAPI_PLUGIN_PRE_COMPARE_FN, SLAPI_PLUGIN_POST_COMPARE_FN, 0, 0, - slapi_op_compare_init, - NULL, - NULL, NULL }, { @@ -604,19 +334,13 @@ struct slapi_op_info { SLAPI_PLUGIN_POST_MODIFY_FN, SLAPI_PLUGIN_INTERNAL_PRE_MODIFY_FN, SLAPI_PLUGIN_INTERNAL_POST_MODIFY_FN, - slapi_op_modify_init, - slapi_op_modify_callback, - NULL, - slapi_op_modify_cleanup + NULL }, { SLAPI_PLUGIN_PRE_MODRDN_FN, SLAPI_PLUGIN_POST_MODRDN_FN, SLAPI_PLUGIN_INTERNAL_PRE_MODRDN_FN, SLAPI_PLUGIN_INTERNAL_POST_MODRDN_FN, - slapi_op_modrdn_init, - NULL, - NULL, NULL }, { @@ -624,9 +348,6 @@ struct slapi_op_info { SLAPI_PLUGIN_POST_ADD_FN, SLAPI_PLUGIN_INTERNAL_PRE_ADD_FN, SLAPI_PLUGIN_INTERNAL_POST_ADD_FN, - slapi_op_add_init, - NULL, - NULL, NULL }, { @@ -634,9 +355,6 @@ struct slapi_op_info { SLAPI_PLUGIN_POST_DELETE_FN, SLAPI_PLUGIN_INTERNAL_PRE_DELETE_FN, SLAPI_PLUGIN_INTERNAL_POST_DELETE_FN, - NULL, - NULL, - NULL, NULL }, { @@ -644,9 +362,6 @@ struct slapi_op_info { SLAPI_PLUGIN_POST_ABANDON_FN, 0, 0, - NULL, - NULL, - NULL, NULL }, { @@ -654,9 +369,6 @@ struct slapi_op_info { 0, 0, 0, - NULL, - NULL, - NULL, NULL } }; @@ -699,47 +411,114 @@ slapi_tag2op( ber_tag_t tag ) return op; } +/* Add SLAPI_RESCONTROLS to rs->sr_ctrls, with care, because + * rs->sr_ctrls could be allocated on the stack */ +static int +slapi_over_merge_controls( Operation *op, SlapReply *rs ) +{ + Slapi_PBlock *pb = SLAPI_OPERATION_PBLOCK( op ); + LDAPControl **ctrls = NULL; + LDAPControl **slapi_ctrls = NULL; + size_t n_slapi_ctrls = 0; + size_t n_rs_ctrls = 0; + size_t i; + + slapi_pblock_get( pb, SLAPI_RESCONTROLS, (void **)&slapi_ctrls ); + + n_slapi_ctrls = slapi_int_count_controls( slapi_ctrls ); + n_rs_ctrls = slapi_int_count_controls( rs->sr_ctrls ); + + slapi_pblock_set( pb, SLAPI_X_OLD_RESCONTROLS, (void *)rs->sr_ctrls ); + + if ( n_slapi_ctrls == 0 ) + return LDAP_SUCCESS; /* no SLAPI controls */ + + ctrls = (LDAPControl **) op->o_tmpalloc( + ( n_slapi_ctrls + n_rs_ctrls + 1 ) * sizeof(LDAPControl *), + op->o_tmpmemctx ); + + for ( i = 0; i < n_slapi_ctrls; i++ ) { + ctrls[i] = slapi_ctrls[i]; + } + if ( rs->sr_ctrls != NULL ) { + for ( i = 0; i < n_rs_ctrls; i++ ) { + ctrls[n_slapi_ctrls + i] = rs->sr_ctrls[i]; + } + } + + rs->sr_ctrls = ctrls; + + return LDAP_SUCCESS; +} + +static int +slapi_over_unmerge_controls( Operation *op, SlapReply *rs ) +{ + Slapi_PBlock *pb = SLAPI_OPERATION_PBLOCK( op ); + LDAPControl **rs_ctrls = NULL; + + slapi_pblock_get( pb, SLAPI_X_OLD_RESCONTROLS, (void **)&rs_ctrls ); + + if ( rs->sr_ctrls == NULL || rs->sr_ctrls == rs_ctrls ) { + /* no copying done */ + return LDAP_SUCCESS; + } + + op->o_tmpfree( rs->sr_ctrls, op->o_tmpmemctx ); + rs->sr_ctrls = rs_ctrls; + + return LDAP_SUCCESS; +} + static int slapi_over_response( Operation *op, SlapReply *rs ) { - int rc; + Slapi_PBlock *pb = SLAPI_OPERATION_PBLOCK( op ); + int rc = SLAP_CB_CONTINUE; - switch ( rs->sr_type ) { - case REP_RESULT: - rc = slapi_over_result( op, rs, SLAPI_PLUGIN_PRE_RESULT_FN ); - break; - case REP_SEARCH: - rc = slapi_over_search( op, rs, SLAPI_PLUGIN_PRE_ENTRY_FN ); - break; - case REP_SEARCHREF: - rc = slapi_over_search( op, rs, SLAPI_PLUGIN_PRE_REFERRAL_FN ); - break; - default: - rc = SLAP_CB_CONTINUE; - break; + if ( pb->internal_op == 0 ) { + switch ( rs->sr_type ) { + case REP_RESULT: + rc = slapi_over_result( op, rs, SLAPI_PLUGIN_PRE_RESULT_FN ); + break; + case REP_SEARCH: + rc = slapi_over_search( op, rs, SLAPI_PLUGIN_PRE_ENTRY_FN ); + break; + case REP_SEARCHREF: + rc = slapi_over_search( op, rs, SLAPI_PLUGIN_PRE_REFERRAL_FN ); + break; + default: + break; + } } + slapi_over_merge_controls( op, rs ); + return rc; } static int slapi_over_cleanup( Operation *op, SlapReply *rs ) { - int rc; + Slapi_PBlock *pb = SLAPI_OPERATION_PBLOCK( op ); + int rc = SLAP_CB_CONTINUE; - switch ( rs->sr_type ) { - case REP_RESULT: - rc = slapi_over_result( op, rs, SLAPI_PLUGIN_POST_RESULT_FN ); - break; - case REP_SEARCH: - rc = slapi_over_search( op, rs, SLAPI_PLUGIN_POST_ENTRY_FN ); - break; - case REP_SEARCHREF: - rc = slapi_over_search( op, rs, SLAPI_PLUGIN_POST_REFERRAL_FN ); - break; - default: - rc = SLAP_CB_CONTINUE; - break; + slapi_over_unmerge_controls( op, rs ); + + if ( pb->internal_op == 0 ) { + switch ( rs->sr_type ) { + case REP_RESULT: + rc = slapi_over_result( op, rs, SLAPI_PLUGIN_POST_RESULT_FN ); + break; + case REP_SEARCH: + rc = slapi_over_search( op, rs, SLAPI_PLUGIN_POST_ENTRY_FN ); + break; + case REP_SEARCHREF: + rc = slapi_over_search( op, rs, SLAPI_PLUGIN_POST_REFERRAL_FN ); + break; + default: + break; + } } return rc; @@ -791,25 +570,16 @@ slapi_op_func( Operation *op, SlapReply *rs ) if ( preop_type == 0 ) { /* no SLAPI plugin types for this operation */ - rs->sr_err = SLAP_CB_CONTINUE; - goto cleanup; + if ( !internal_op ) { + slapi_pblock_destroy(pb); + cb.sc_private = NULL; + } + op->o_callback = cb.sc_next; + return SLAP_CB_CONTINUE; } pb = SLAPI_OPERATION_PBLOCK( op ); - slapi_pblock_set( pb, SLAPI_TARGET_ADDRESS, NULL ); - slapi_pblock_set( pb, SLAPI_TARGET_UNIQUEID, NULL ); - slapi_pblock_set( pb, SLAPI_TARGET_DN, (void *)op->o_req_dn.bv_val ); - - /* - * Call preoperation plugins - */ - if ( opinfo->soi_preop_init != NULL ) { - rs->sr_err = (opinfo->soi_preop_init)( op, rs ); - if ( rs->sr_err != LDAP_SUCCESS ) - goto cleanup; - } - rs->sr_err = slapi_int_call_plugins( op->o_bd, preop_type, pb ); /* @@ -824,12 +594,10 @@ slapi_op_func( Operation *op, SlapReply *rs ) */ if ( opinfo->soi_callback == NULL ) { /* default behaviour is preop plugin can abort operation */ - if ( rs->sr_err < 0 ) { - slapi_pblock_get( pb, SLAPI_RESULT_CODE, (void **)&rs->sr_err ); + if ( rs->sr_err < 0 ) goto cleanup; - } else { + else rs->sr_err = LDAP_SUCCESS; - } } else { rc = (opinfo->soi_callback)( op, rs ); if ( rc ) @@ -852,19 +620,10 @@ slapi_op_func( Operation *op, SlapReply *rs ) /* * Call postoperation plugins */ - slapi_pblock_set( pb, SLAPI_RESULT_CODE, (void *)rs->sr_err ); - - if ( opinfo->soi_postop_init != NULL ) { - (opinfo->soi_postop_init)( op, rs ); - } - slapi_int_call_plugins( op->o_bd, postop_type, pb ); cleanup: if ( !internal_op ) { - if ( opinfo->soi_cleanup != NULL ) { - (opinfo->soi_cleanup)( op, rs ); - } slapi_pblock_destroy(pb); cb.sc_private = NULL; } @@ -880,7 +639,6 @@ slapi_over_extended( Operation *op, SlapReply *rs ) Slapi_PBlock *pb; SLAPI_FUNC callback; int rc; - struct berval reqdata = BER_BVNULL; int internal_op; slap_callback cb; @@ -896,13 +654,6 @@ slapi_over_extended( Operation *op, SlapReply *rs ) pb = SLAPI_OPERATION_PBLOCK( op ); - if ( op->ore_reqdata != NULL ) { - reqdata = *op->ore_reqdata; - } - - slapi_pblock_set( pb, SLAPI_EXT_OP_REQ_OID, (void *)op->ore_reqoid.bv_val); - slapi_pblock_set( pb, SLAPI_EXT_OP_REQ_VALUE, (void *)&reqdata); - rc = (*callback)( pb ); if ( rc == SLAPI_PLUGIN_EXTENDED_SENT_RESULT ) { slapi_pblock_destroy( pb ); @@ -912,13 +663,13 @@ slapi_over_extended( Operation *op, SlapReply *rs ) return SLAP_CB_CONTINUE; } - slapi_pblock_get( pb, SLAPI_EXT_OP_RET_OID, (void **)&rs->sr_rspoid ); - slapi_pblock_get( pb, SLAPI_EXT_OP_RET_VALUE, (void **)&rs->sr_rspdata ); + assert( rs->sr_rspoid != NULL ); - rs->sr_err = rc; send_ldap_extended( op, rs ); +#if 0 slapi_ch_free_string( (char **)&rs->sr_rspoid ); +#endif if ( rs->sr_rspdata != NULL ) ber_bvfree( rs->sr_rspdata ); @@ -1021,7 +772,7 @@ slapi_over_acl_group( if ( rc >= 0 ) /* 1 means no plugins called */ rc = SLAP_CB_CONTINUE; else - slapi_pblock_get( pb, SLAPI_RESULT_CODE, (void **)&rc ); + rc = pb->rs.sr_err; if ( !internal_op ) slapi_pblock_destroy( pb ); diff --git a/servers/slapd/slapi/slapi_pblock.c b/servers/slapd/slapi/slapi_pblock.c index ddcd67d5ec..776593d9c2 100644 --- a/servers/slapd/slapi/slapi_pblock.c +++ b/servers/slapd/slapi/slapi_pblock.c @@ -24,8 +24,22 @@ #include #include +#ifdef LDAP_SLAPI + +/* some parameters require a valid connection and operation */ +#define PBLOCK_LOCK_CONN( _pb ) do { \ + ldap_pvt_thread_mutex_lock( &(_pb)->pconn->c_mutex ); \ + } while (0) + +#define PBLOCK_UNLOCK_CONN( _pb ) do { \ + ldap_pvt_thread_mutex_unlock( &(_pb)->pconn->c_mutex ); \ + } while (0) + +/* some parameters are only settable for internal operations */ +#define PBLOCK_VALIDATE_IS_INTOP( _pb ) do { if ( (_pb)->internal_op == 0 ) break; } while ( 0 ) + static slapi_pblock_class_t -getPBlockClass( int param ) +pblock_get_param_class( int param ) { switch ( param ) { case SLAPI_PLUGIN_TYPE: @@ -109,6 +123,14 @@ getPBlockClass( int param ) case SLAPI_PLUGIN_PRE_ENTRY_FN: case SLAPI_PLUGIN_PRE_REFERRAL_FN: case SLAPI_PLUGIN_PRE_RESULT_FN: + case SLAPI_PLUGIN_INTERNAL_PRE_ADD_FN: + case SLAPI_PLUGIN_INTERNAL_PRE_MODIFY_FN: + case SLAPI_PLUGIN_INTERNAL_PRE_MODRDN_FN: + case SLAPI_PLUGIN_INTERNAL_PRE_DELETE_FN: + case SLAPI_PLUGIN_BE_PRE_ADD_FN: + case SLAPI_PLUGIN_BE_PRE_MODIFY_FN: + case SLAPI_PLUGIN_BE_PRE_MODRDN_FN: + case SLAPI_PLUGIN_BE_PRE_DELETE_FN: case SLAPI_PLUGIN_POST_BIND_FN: case SLAPI_PLUGIN_POST_UNBIND_FN: case SLAPI_PLUGIN_POST_SEARCH_FN: @@ -121,6 +143,14 @@ getPBlockClass( int param ) case SLAPI_PLUGIN_POST_ENTRY_FN: case SLAPI_PLUGIN_POST_REFERRAL_FN: case SLAPI_PLUGIN_POST_RESULT_FN: + case SLAPI_PLUGIN_INTERNAL_POST_ADD_FN: + case SLAPI_PLUGIN_INTERNAL_POST_MODIFY_FN: + case SLAPI_PLUGIN_INTERNAL_POST_MODRDN_FN: + case SLAPI_PLUGIN_INTERNAL_POST_DELETE_FN: + case SLAPI_PLUGIN_BE_POST_ADD_FN: + case SLAPI_PLUGIN_BE_POST_MODIFY_FN: + case SLAPI_PLUGIN_BE_POST_MODRDN_FN: + case SLAPI_PLUGIN_BE_POST_DELETE_FN: case SLAPI_PLUGIN_MR_FILTER_CREATE_FN: case SLAPI_PLUGIN_MR_INDEXER_CREATE_FN: case SLAPI_PLUGIN_MR_FILTER_MATCH_FN: @@ -197,7 +227,9 @@ getPBlockClass( int param ) case SLAPI_ENTRY_PRE_OP: case SLAPI_ENTRY_POST_OP: case SLAPI_RESCONTROLS: + case SLAPI_X_OLD_RESCONTROLS: case SLAPI_ADD_RESCONTROL: + case SLAPI_CONTROLS_ARG: case SLAPI_ADD_ENTRY: case SLAPI_ADD_EXISTING_DN_ENTRY: case SLAPI_ADD_PARENT_ENTRY: @@ -255,55 +287,55 @@ getPBlockClass( int param ) } static void -Lock( Slapi_PBlock *pb ) +pblock_lock( Slapi_PBlock *pb ) { ldap_pvt_thread_mutex_lock(&pb->pblockMutex); } static void -unLock( Slapi_PBlock *pb ) +pblock_unlock( Slapi_PBlock *pb ) { ldap_pvt_thread_mutex_unlock(&pb->pblockMutex); } static int -get( Slapi_PBlock *pb, int param, void **val ) +pblock_get_default( Slapi_PBlock *pb, int param, void **value ) { int i; slapi_pblock_class_t pbClass; - pbClass = getPBlockClass( param ); + pbClass = pblock_get_param_class( param ); if ( pbClass == PBLOCK_CLASS_INVALID ) { return PBLOCK_ERROR; } - Lock( pb ); - switch ( pbClass ) { case PBLOCK_CLASS_INTEGER: - *((int *)val) = 0; + *((int *)value) = 0; break; case PBLOCK_CLASS_LONG_INTEGER: - *((long *)val) = 0L; + *((long *)value) = 0L; break; case PBLOCK_CLASS_POINTER: case PBLOCK_CLASS_FUNCTION_POINTER: - *val = NULL; + *value = NULL; break; + case PBLOCK_CLASS_INVALID: + return PBLOCK_ERROR; } for ( i = 0; i < pb->numParams; i++ ) { if ( pb->curParams[i] == param ) { switch ( pbClass ) { case PBLOCK_CLASS_INTEGER: - *((int *)val) = (int)pb->curVals[i]; + *((int *)value) = (int)pb->curVals[i]; break; case PBLOCK_CLASS_LONG_INTEGER: - *((long *)val) = (long)pb->curVals[i]; + *((long *)value) = (long)pb->curVals[i]; break; case PBLOCK_CLASS_POINTER: case PBLOCK_CLASS_FUNCTION_POINTER: - *val = pb->curVals[i]; + *value = pb->curVals[i]; break; default: break; @@ -311,47 +343,53 @@ get( Slapi_PBlock *pb, int param, void **val ) break; } } - unLock( pb ); + return PBLOCK_SUCCESS; } -static int -set( Slapi_PBlock *pb, int param, void *val ) +static char * +pblock_get_authtype( AuthorizationInformation *authz, int is_tls ) { -#if defined(LDAP_SLAPI) - int i, freeit; - int addcon = 0; - slapi_pblock_class_t pbClass; + char *authType; - pbClass = getPBlockClass( param ); + switch ( authz->sai_method ) { + case LDAP_AUTH_SASL: + authType = SLAPD_AUTH_SASL; + break; + case LDAP_AUTH_SIMPLE: + authType = SLAPD_AUTH_SIMPLE; + break; + case LDAP_AUTH_NONE: + authType = SLAPD_AUTH_NONE; + break; + default: + authType = NULL; + break; + } + + if ( is_tls && authType == NULL ) { + authType = SLAPD_AUTH_SSL; + } + + return authType; +} + +static int +pblock_set_default( Slapi_PBlock *pb, int param, void *value ) +{ + slapi_pblock_class_t pbClass; + size_t i; + + pbClass = pblock_get_param_class( param ); if ( pbClass == PBLOCK_CLASS_INVALID ) { return PBLOCK_ERROR; } - Lock( pb ); - if ( pb->numParams == PBLOCK_MAX_PARAMS ) { - unLock( pb ); - return PBLOCK_ERROR; + return PBLOCK_ERROR; } - if ( param == SLAPI_ADD_RESCONTROL ) { - addcon = 1; - param = SLAPI_RES_CONTROLS; - } - - switch ( param ) { - case SLAPI_CONN_DN: - case SLAPI_CONN_AUTHMETHOD: - case SLAPI_RESULT_TEXT: - case SLAPI_RESULT_MATCHED: - freeit = 1; - break; - default: - freeit = 0; - break; - } - for( i = 0; i < pb->numParams; i++ ) { + for ( i = 0; i < pb->numParams; i++ ) { if ( pb->curParams[i] == param ) { break; } @@ -361,49 +399,744 @@ set( Slapi_PBlock *pb, int param, void *val ) pb->curParams[i] = param; pb->numParams++; } - if ( addcon ) { - LDAPControl **ctrls = pb->curVals[i]; - int j; - if ( ctrls ) { - for (j=0; ctrls[j]; j++); - ctrls = ch_realloc( ctrls, (j+2)*sizeof(LDAPControl *) ); - } else { - ctrls = ch_malloc( 2 * sizeof(LDAPControl *) ); - j = 0; + pb->curVals[i] = value; + + return PBLOCK_SUCCESS; +} + +static int +pblock_get( Slapi_PBlock *pb, int param, void **value ) +{ + int rc = PBLOCK_SUCCESS; + + pblock_lock( pb ); + + switch ( param ) { + case SLAPI_OPERATION: + *value = pb->pop; + break; + case SLAPI_OPINITIATED_TIME: + PBLOCK_ASSERT_OP( pb, 0 ); + *((time_t *)value) = pb->pop->o_time; + break; + case SLAPI_OPERATION_ID: + PBLOCK_ASSERT_OP( pb, 0 ); + *((unsigned long *)value) = pb->pop->o_opid; + break; + case SLAPI_OPERATION_TYPE: + PBLOCK_ASSERT_OP( pb, 0 ); + *((ber_tag_t *)value) = pb->pop->o_tag; + break; + case SLAPI_REQCONTROLS: + PBLOCK_ASSERT_OP( pb, 0 ); + *((LDAPControl ***)value) = pb->pop->o_ctrls; + break; + case SLAPI_REQUESTOR_DN: + PBLOCK_ASSERT_OP( pb, 0 ); + *((char **)value) = pb->pop->o_ndn.bv_val; + break; + case SLAPI_MANAGEDSAIT: + PBLOCK_ASSERT_OP( pb, 0 ); + *((int *)value) = get_manageDSAit( pb->pop ); + break; + case SLAPI_BACKEND: + PBLOCK_ASSERT_OP( pb, 0 ); + *((BackendDB **)value) = pb->pop->o_bd; + break; + case SLAPI_BE_TYPE: + PBLOCK_ASSERT_OP( pb, 0 ); + if ( pb->pop->o_bd != NULL ) + *((char **)value) = pb->pop->o_bd->bd_info->bi_type; + else + *value = NULL; + break; + case SLAPI_CONNECTION: + *value = pb->pconn; + break; + case SLAPI_X_CONN_SSF: + PBLOCK_ASSERT_OP( pb, 0 ); + *((slap_ssf_t *)value) = pb->pconn->c_ssf; + break; + case SLAPI_X_CONN_SASL_CONTEXT: + PBLOCK_ASSERT_OP( pb, 0 ); + if ( pb->pconn->c_sasl_authctx != NULL ) + *value = pb->pconn->c_sasl_authctx; + else + *value = pb->pconn->c_sasl_sockctx; + break; + case SLAPI_TARGET_DN: + PBLOCK_ASSERT_OP( pb, 0 ); + *((char **)value) = pb->pop->o_req_ndn.bv_val; + break; + case SLAPI_REQUESTOR_ISROOT: + PBLOCK_ASSERT_OP( pb, 0 ); + *((int *)value) = be_isroot( pb->pop ); + break; + case SLAPI_REQUESTOR_ISUPDATEDN: + PBLOCK_ASSERT_OP( pb, 0 ); + *((int *)value) = be_isupdate( pb->pop ); + break; + case SLAPI_CONN_AUTHTYPE: + case SLAPI_CONN_AUTHMETHOD: /* XXX should return SASL mech */ + PBLOCK_ASSERT_OP( pb, 0 ); + *((char **)value) = pblock_get_authtype( &pb->pconn->c_authz, +#ifdef HAVE_TLS + pb->pconn->c_is_tls +#else + 0 +#endif + ); + break; + case SLAPI_X_CONN_IS_UDP: + PBLOCK_ASSERT_OP( pb, 0 ); +#ifdef LDAP_CONNECTIONLESS + *((int *)value) = pb->pconn->c_is_udp; +#else + *((int *)value) = 0; +#endif + break; + case SLAPI_CONN_ID: + PBLOCK_ASSERT_OP( pb, 0 ); + *((unsigned long *)value) = pb->pconn->c_connid; + break; + case SLAPI_CONN_DN: + PBLOCK_ASSERT_OP( pb, 0 ); + *((char **)value) = pb->pconn->c_dn.bv_val; + break; + case SLAPI_CONN_CLIENTIP: + PBLOCK_ASSERT_OP( pb, 0 ); + if ( strncmp( pb->pconn->c_peer_name.bv_val, "IP=", 3 ) == 0 ) + *((char **)value) = &pb->pconn->c_peer_name.bv_val[3]; + else + *value = NULL; + break; + case SLAPI_X_CONN_CLIENTPATH: + PBLOCK_ASSERT_OP( pb, 0 ); + if ( strncmp( pb->pconn->c_peer_name.bv_val, "PATH=", 3 ) == 0 ) + *((char **)value) = &pb->pconn->c_peer_name.bv_val[5]; + else + *value = NULL; + break; + case SLAPI_CONN_SERVERIP: + PBLOCK_ASSERT_OP( pb, 0 ); + if ( strncmp( pb->pconn->c_peer_name.bv_val, "IP=", 3 ) == 0 ) + *((char **)value) = &pb->pconn->c_sock_name.bv_val[3]; + else + *value = NULL; + break; + case SLAPI_X_CONN_SERVERPATH: + PBLOCK_ASSERT_OP( pb, 0 ); + if ( strncmp( pb->pconn->c_peer_name.bv_val, "PATH=", 3 ) == 0 ) + *((char **)value) = &pb->pconn->c_sock_name.bv_val[5]; + else + *value = NULL; + break; + case SLAPI_RESULT_CODE: + case SLAPI_PLUGIN_INTOP_RESULT: + *((int *)value) = pb->rs.sr_err; + break; + case SLAPI_RESULT_TEXT: + *((const char **)value) = pb->rs.sr_text; + break; + case SLAPI_RESULT_MATCHED: + *((const char **)value) = pb->rs.sr_matched; + break; + case SLAPI_ADD_ENTRY: + PBLOCK_ASSERT_OP( pb, 0 ); + if ( pb->pop->o_tag == LDAP_REQ_ADD ) + *((Slapi_Entry **)value) = pb->pop->ora_e; + else + *value = NULL; + break; + case SLAPI_MODIFY_MODS: { + LDAPMod **mods = NULL; + + pblock_get_default( pb, param, (void **)&mods ); + if ( mods == NULL && pb->internal_op == 0 ) { + if ( pb->pop->o_tag != LDAP_REQ_MODIFY ) { + rc = PBLOCK_ERROR; + break; + } + mods = slapi_int_modifications2ldapmods( &pb->pop->orm_modlist, NULL ); + pblock_set_default( pb, param, (void *)mods ); } - ctrls[j] = val; - ctrls[j+1] = NULL; - pb->curVals[i] = ctrls; - } else { - if ( freeit ) ch_free( pb->curVals[i] ); - pb->curVals[i] = val; + *((LDAPMod ***)value) = mods; + break; + } + case SLAPI_MODRDN_NEWRDN: + PBLOCK_ASSERT_OP( pb, 0 ); + if ( pb->pop->o_tag == LDAP_REQ_MODRDN ) + *((char **)value) = pb->pop->orr_newrdn.bv_val; + else + *value = NULL; + break; + case SLAPI_MODRDN_NEWSUPERIOR: + PBLOCK_ASSERT_OP( pb, 0 ); + if ( pb->pop->o_tag == LDAP_REQ_MODRDN && pb->pop->orr_newSup != NULL ) + *((char **)value) = pb->pop->orr_newSup->bv_val; + else + *value = NULL; + break; + case SLAPI_MODRDN_DELOLDRDN: + PBLOCK_ASSERT_OP( pb, 0 ); + if ( pb->pop->o_tag == LDAP_REQ_MODRDN ) + *((int *)value) = pb->pop->orr_deleteoldrdn; + else + *((int *)value) = 0; + break; + case SLAPI_SEARCH_SCOPE: + PBLOCK_ASSERT_OP( pb, 0 ); + if ( pb->pop->o_tag == LDAP_REQ_SEARCH ) + *((int *)value) = pb->pop->ors_scope; + else + *((int *)value) = 0; + break; + case SLAPI_SEARCH_DEREF: + PBLOCK_ASSERT_OP( pb, 0 ); + if ( pb->pop->o_tag == LDAP_REQ_SEARCH ) + *((int *)value) = pb->pop->ors_deref; + else + *((int *)value) = 0; + break; + case SLAPI_SEARCH_SIZELIMIT: + PBLOCK_ASSERT_OP( pb, 0 ); + if ( pb->pop->o_tag == LDAP_REQ_SEARCH ) + *((int *)value) = pb->pop->ors_slimit; + else + *((int *)value) = 0; + break; + case SLAPI_SEARCH_TIMELIMIT: + PBLOCK_ASSERT_OP( pb, 0 ); + if ( pb->pop->o_tag == LDAP_REQ_SEARCH ) + *((int *)value) = pb->pop->ors_tlimit; + else + *((int *)value) = 0; + break; + case SLAPI_SEARCH_FILTER: + PBLOCK_ASSERT_OP( pb, 0 ); + if ( pb->pop->o_tag == LDAP_REQ_SEARCH ) + *((Slapi_Filter **)value) = pb->pop->ors_filter; + else + *((Slapi_Filter **)value) = NULL; + break; + case SLAPI_SEARCH_STRFILTER: + PBLOCK_ASSERT_OP( pb, 0 ); + if ( pb->pop->o_tag == LDAP_REQ_SEARCH ) + *((char **)value) = pb->pop->ors_filterstr.bv_val; + else + *((char **)value) = NULL; + break; + case SLAPI_SEARCH_ATTRS: { + char **attrs = NULL; + + PBLOCK_ASSERT_OP( pb, 0 ); + if ( pb->pop->o_tag != LDAP_REQ_SEARCH ) { + rc = PBLOCK_ERROR; + break; + } + pblock_get_default( pb, param, (void **)&attrs ); + if ( attrs == NULL && pb->internal_op == 0 ) { + attrs = anlist2charray_x( pb->pop->ors_attrs, 0, pb->pop->o_tmpmemctx ); + pblock_set_default( pb, param, (void *)attrs ); + } + *((char ***)attrs) = attrs; + } + case SLAPI_SEARCH_ATTRSONLY: + PBLOCK_ASSERT_OP( pb, 0 ); + if ( pb->pop->o_tag == LDAP_REQ_SEARCH ) + *((int *)value) = pb->pop->ors_attrsonly; + else + *((int *)value) = 0; + break; + case SLAPI_SEARCH_RESULT_ENTRY: + *((Slapi_Entry **)value) = pb->rs.sr_entry; + break; + case SLAPI_BIND_RET_SASLCREDS: + *((struct berval **)value) = pb->rs.sr_sasldata; + break; + case SLAPI_EXT_OP_REQ_OID: + *((const char **)value) = pb->pop->ore_reqoid.bv_val; + break; + case SLAPI_EXT_OP_REQ_VALUE: + *((struct berval **)value) = pb->pop->ore_reqdata; + break; + case SLAPI_EXT_OP_RET_OID: + *((const char **)value) = pb->rs.sr_rspoid; + break; + case SLAPI_EXT_OP_RET_VALUE: + *((struct berval **)value) = pb->rs.sr_rspdata; + break; + case SLAPI_BIND_METHOD: + if ( pb->pop->o_tag == LDAP_REQ_BIND ) + *((int *)value) = pb->pop->orb_method; + else + *((int *)value) = 0; + break; + case SLAPI_BIND_CREDENTIALS: + if ( pb->pop->o_tag == LDAP_REQ_BIND ) + *((struct berval **)value) = &pb->pop->orb_cred; + else + *value = NULL; + break; + case SLAPI_COMPARE_TYPE: + if ( pb->pop->o_tag == LDAP_REQ_COMPARE ) + *((char **)value) = pb->pop->orc_ava->aa_desc->ad_cname.bv_val; + else + *value = NULL; + break; + case SLAPI_COMPARE_VALUE: + if ( pb->pop->o_tag == LDAP_REQ_COMPARE ) + *((struct berval **)value) = &pb->pop->orc_ava->aa_value; + else + *value = NULL; + break; + default: + rc = pblock_get_default( pb, param, value ); + break; } - unLock( pb ); - return PBLOCK_SUCCESS; -#endif /* LDAP_SLAPI */ - return PBLOCK_ERROR; + pblock_unlock( pb ); + + return rc; +} + +static int +pblock_add_control( Slapi_PBlock *pb, LDAPControl *control ) +{ + LDAPControl **controls = NULL; + size_t i; + + pblock_get_default( pb, SLAPI_RESCONTROLS, (void **)&controls ); + + if ( controls != NULL ) { + for ( i = 0; controls[i] != NULL; i++ ) + ; + } else { + i = 0; + } + + controls = (LDAPControl **)slapi_ch_realloc( (char *)controls, + ( i + 2 ) * sizeof(LDAPControl *)); + controls[i] = control; + + return pblock_set_default( pb, SLAPI_RESCONTROLS, (void *)controls ); +} + +static int +pblock_set_dn( void *value, struct berval *dn, struct berval *ndn, void *memctx ) +{ + struct berval bv; + + if ( !BER_BVISNULL( dn )) { + slap_sl_free( dn->bv_val, memctx ); + BER_BVZERO( dn ); + } + if ( !BER_BVISNULL( ndn )) { + slap_sl_free( ndn->bv_val, memctx ); + BER_BVZERO( ndn ); + } + + bv.bv_val = (char *)value; + bv.bv_len = strlen( bv.bv_val ); + + return dnPrettyNormal( NULL, &bv, dn, ndn, memctx ); +} + +static int +pblock_set( Slapi_PBlock *pb, int param, void *value ) +{ + int rc = PBLOCK_SUCCESS; + + pblock_lock( pb ); + + switch ( param ) { + case SLAPI_OPERATION: + pb->pop = (Operation *)value; + break; + case SLAPI_OPINITIATED_TIME: + PBLOCK_ASSERT_OP( pb, 0 ); + pb->pop->o_time = (time_t)value; + break; + case SLAPI_OPERATION_ID: + PBLOCK_ASSERT_OP( pb, 0 ); + pb->pop->o_opid = (unsigned long)value; + break; + case SLAPI_OPERATION_TYPE: + PBLOCK_ASSERT_OP( pb, 0 ); + pb->pop->o_tag = (ber_tag_t)value; + break; + case SLAPI_REQCONTROLS: + PBLOCK_ASSERT_OP( pb, 0 ); + pb->pop->o_ctrls = (LDAPControl **)value; + break; + case SLAPI_RESCONTROLS: { + LDAPControl **ctrls = NULL; + + pblock_get_default( pb, param, (void **)&ctrls ); + if ( ctrls == NULL ) { + /* free old ones first */ + ldap_controls_free( ctrls ); + } + rc = pblock_set_default( pb, param, value ); + break; + } + case SLAPI_ADD_RESCONTROL: + PBLOCK_ASSERT_OP( pb, 0 ); + rc = pblock_add_control( pb, (LDAPControl *)value ); + break; + case SLAPI_REQUESTOR_DN: + PBLOCK_ASSERT_OP( pb, 0 ); + rc = pblock_set_dn( value, &pb->pop->o_dn, &pb->pop->o_ndn, pb->pop->o_tmpmemctx ); + break; + case SLAPI_MANAGEDSAIT: + PBLOCK_ASSERT_OP( pb, 0 ); + pb->pop->o_managedsait = (int)value; + break; + case SLAPI_BACKEND: + PBLOCK_ASSERT_OP( pb, 0 ); + pb->pop->o_bd = (BackendDB *)value; + break; + case SLAPI_CONNECTION: + pb->pconn = (Connection *)value; + break; + case SLAPI_X_CONN_SSF: + PBLOCK_ASSERT_OP( pb, 0 ); + PBLOCK_LOCK_CONN( pb ); + pb->pconn->c_ssf = (slap_ssf_t)value; + PBLOCK_UNLOCK_CONN( pb ); + break; + case SLAPI_X_CONN_SASL_CONTEXT: + PBLOCK_ASSERT_OP( pb, 0 ); + PBLOCK_LOCK_CONN( pb ); + pb->pconn->c_sasl_authctx = value; + PBLOCK_UNLOCK_CONN( pb ); + break; + case SLAPI_TARGET_DN: + PBLOCK_ASSERT_OP( pb, 0 ); + rc = pblock_set_dn( value, &pb->pop->o_req_dn, &pb->pop->o_req_ndn, pb->pop->o_tmpmemctx ); + break; + case SLAPI_CONN_ID: + PBLOCK_ASSERT_OP( pb, 0 ); + PBLOCK_LOCK_CONN( pb ); + pb->pconn->c_connid = (unsigned long)value; + PBLOCK_UNLOCK_CONN( pb ); + break; + case SLAPI_CONN_DN: + PBLOCK_ASSERT_OP( pb, 0 ); + PBLOCK_LOCK_CONN( pb ); + rc = pblock_set_dn( value, &pb->pconn->c_dn, &pb->pconn->c_ndn, NULL ); + PBLOCK_UNLOCK_CONN( pb ); + break; + case SLAPI_RESULT_CODE: + case SLAPI_PLUGIN_INTOP_RESULT: + pb->rs.sr_err = (int)value; + break; + case SLAPI_RESULT_TEXT: + snprintf( pb->textbuf, sizeof( pb->textbuf ), "%s", (char *)value ); + pb->rs.sr_text = pb->textbuf; + break; + case SLAPI_RESULT_MATCHED: + pb->rs.sr_matched = (char *)value; /* XXX should dup? */ + break; + case SLAPI_ADD_ENTRY: + PBLOCK_ASSERT_OP( pb, 0 ); + if ( pb->pop->o_tag == LDAP_REQ_ADD ) { + pb->pop->ora_e = (Slapi_Entry *)value; + } else { + rc = PBLOCK_ERROR; + } + break; + case SLAPI_MODIFY_MODS: { + Modifications **mlp; + + PBLOCK_ASSERT_OP( pb, 0 ); + rc = pblock_set_default( pb, param, value ); + if ( rc != PBLOCK_SUCCESS ) { + break; + } + + if ( pb->pop->o_tag == LDAP_REQ_MODIFY ) { + mlp = &pb->pop->orm_modlist; + } else if ( pb->pop->o_tag == LDAP_REQ_ADD ) { + mlp = &pb->pop->ora_modlist; + } else { + break; + } + + if ( *mlp != NULL ) { + if ( pb->internal_op ) + slapi_int_mods_free( *mlp ); /* caller owns values */ + else + slap_mods_free( *mlp ); /* we own values */ + *mlp = NULL; + } + *mlp = slapi_int_ldapmods2modifications( (LDAPMod **)value, NULL ); + break; + } + case SLAPI_MODRDN_NEWRDN: + PBLOCK_ASSERT_OP( pb, 0 ); + PBLOCK_VALIDATE_IS_INTOP( pb ); + if ( pb->pop->o_tag == LDAP_REQ_MODRDN ) { + rc = pblock_set_dn( value, &pb->pop->orr_newrdn, &pb->pop->orr_nnewrdn, pb->pop->o_tmpmemctx ); + if ( rc == LDAP_SUCCESS ) rc = rdn_validate( &pb->pop->orr_nnewrdn ); + } else { + rc = PBLOCK_ERROR; + } + break; + case SLAPI_MODRDN_NEWSUPERIOR: + PBLOCK_ASSERT_OP( pb, 0 ); + PBLOCK_VALIDATE_IS_INTOP( pb ); + if ( pb->pop->o_tag == LDAP_REQ_MODRDN ) { + if ( value == NULL ) { + if ( pb->pop->orr_newSup != NULL ) { + pb->pop->o_tmpfree( pb->pop->orr_newSup, pb->pop->o_tmpmemctx ); + pb->pop->orr_newSup = NULL; + } + if ( pb->pop->orr_newSup != NULL ) { + pb->pop->o_tmpfree( pb->pop->orr_nnewSup, pb->pop->o_tmpmemctx ); + pb->pop->orr_nnewSup = NULL; + } + } else { + if ( pb->pop->orr_newSup == NULL ) { + pb->pop->orr_newSup = (struct berval *)pb->pop->o_tmpalloc( + sizeof(struct berval), pb->pop->o_tmpmemctx ); + } + if ( pb->pop->orr_nnewSup == NULL ) { + pb->pop->orr_nnewSup = (struct berval *)pb->pop->o_tmpalloc( + sizeof(struct berval), pb->pop->o_tmpmemctx ); + } + rc = pblock_set_dn( value, pb->pop->orr_newSup, pb->pop->orr_nnewSup, pb->pop->o_tmpmemctx ); + } + } else { + rc = PBLOCK_ERROR; + } + break; + case SLAPI_MODRDN_DELOLDRDN: + PBLOCK_ASSERT_OP( pb, 0 ); + PBLOCK_VALIDATE_IS_INTOP( pb ); + if ( pb->pop->o_tag == LDAP_REQ_MODRDN ) + pb->pop->orr_deleteoldrdn = (int)value; + else + rc = PBLOCK_ERROR; + break; + case SLAPI_SEARCH_SCOPE: + PBLOCK_ASSERT_OP( pb, 0 ); + if ( pb->pop->o_tag == LDAP_REQ_SEARCH ) { + switch ( (int)value ) { + case LDAP_SCOPE_BASE: + case LDAP_SCOPE_ONELEVEL: + case LDAP_SCOPE_SUBTREE: +#ifdef LDAP_SCOPE_SUBORDINATE + case LDAP_SCOPE_SUBORDINATE: +#endif + pb->pop->ors_scope = (int)value; + break; + default: + rc = PBLOCK_ERROR; + break; + } + } else { + rc = PBLOCK_ERROR; + } + break; + case SLAPI_SEARCH_DEREF: + PBLOCK_ASSERT_OP( pb, 0 ); + if ( pb->pop->o_tag == LDAP_REQ_SEARCH ) + pb->pop->ors_deref = (int)value; + else + rc = PBLOCK_ERROR; + break; + case SLAPI_SEARCH_SIZELIMIT: + PBLOCK_ASSERT_OP( pb, 0 ); + if ( pb->pop->o_tag == LDAP_REQ_SEARCH ) + pb->pop->ors_slimit = (int)value; + else + rc = PBLOCK_ERROR; + break; + case SLAPI_SEARCH_TIMELIMIT: + PBLOCK_ASSERT_OP( pb, 0 ); + if ( pb->pop->o_tag == LDAP_REQ_SEARCH ) + pb->pop->ors_tlimit = (int)value; + else + rc = PBLOCK_ERROR; + break; + case SLAPI_SEARCH_FILTER: + PBLOCK_ASSERT_OP( pb, 0 ); + if ( pb->pop->o_tag == LDAP_REQ_SEARCH ) { + pb->pop->ors_filter = (Slapi_Filter *)value; + } else { + rc = PBLOCK_ERROR; + } + break; + case SLAPI_SEARCH_STRFILTER: + PBLOCK_ASSERT_OP( pb, 0 ); + if ( pb->pop->o_tag == LDAP_REQ_SEARCH ) { + pb->pop->ors_filterstr.bv_val = (char *)value; + pb->pop->ors_filterstr.bv_len = strlen((char *)value); + } else { + rc = PBLOCK_ERROR; + } + break; + case SLAPI_SEARCH_ATTRS: { + AttributeName *an = NULL; + size_t i = 0; + char **attrs = (char **)value; + + PBLOCK_ASSERT_OP( pb, 0 ); + PBLOCK_VALIDATE_IS_INTOP( pb ); + + if ( pb->pop->o_tag != LDAP_REQ_SEARCH ) { + rc = PBLOCK_ERROR; + break; + } + /* also set mapped attrs */ + rc = pblock_set_default( pb, param, value ); + if ( rc != PBLOCK_SUCCESS ) { + break; + } + if ( pb->pop->ors_attrs != NULL ) { + pb->pop->o_tmpfree( pb->pop->ors_attrs, pb->pop->o_tmpmemctx ); + pb->pop->ors_attrs = NULL; + } + if ( attrs != NULL ) { + for ( i = 0; attrs[i] != NULL; i++ ) + ; + } + if ( i ) { + an = (AttributeName *)pb->pop->o_tmpalloc( (i + 1) * + sizeof(AttributeName), pb->pop->o_tmpmemctx ); + for ( i = 0; attrs[i] != NULL; i++ ) { + an[i].an_desc = NULL; + an[i].an_oc = NULL; + an[i].an_oc_exclude = 0; + an[i].an_name.bv_val = attrs[i]; + an[i].an_name.bv_len = strlen( attrs[i] ); + slap_bv2ad( &an[i].an_name, &an[i].an_desc, &pb->rs.sr_text ); + } + an[i].an_name.bv_val = NULL; + an[i].an_name.bv_len = 0; + } + pb->pop->ors_attrs = an; + break; + } + case SLAPI_SEARCH_ATTRSONLY: + PBLOCK_ASSERT_OP( pb, 0 ); + PBLOCK_VALIDATE_IS_INTOP( pb ); + + if ( pb->pop->o_tag == LDAP_REQ_SEARCH ) + pb->pop->ors_attrsonly = (int)value; + else + rc = PBLOCK_ERROR; + break; + case SLAPI_SEARCH_RESULT_ENTRY: + PBLOCK_ASSERT_OP( pb, 0 ); + pb->rs.sr_entry = (Slapi_Entry *)value; + break; + case SLAPI_BIND_RET_SASLCREDS: + pb->rs.sr_sasldata = (struct berval *)value; + break; + case SLAPI_EXT_OP_REQ_OID: + PBLOCK_ASSERT_OP( pb, 0 ); + PBLOCK_VALIDATE_IS_INTOP( pb ); + + if ( pb->pop->o_tag == LDAP_REQ_EXTENDED ) { + pb->pop->ore_reqoid.bv_val = (char *)value; + pb->pop->ore_reqoid.bv_len = strlen((char *)value); + } else { + rc = PBLOCK_ERROR; + } + break; + case SLAPI_EXT_OP_REQ_VALUE: + PBLOCK_ASSERT_OP( pb, 0 ); + PBLOCK_VALIDATE_IS_INTOP( pb ); + + if ( pb->pop->o_tag == LDAP_REQ_EXTENDED ) + pb->pop->ore_reqdata = (struct berval *)value; + else + rc = PBLOCK_ERROR; + break; + case SLAPI_EXT_OP_RET_OID: + pb->rs.sr_rspoid = (char *)value; + break; + case SLAPI_EXT_OP_RET_VALUE: + pb->rs.sr_rspdata = (struct berval *)value; + break; + case SLAPI_BIND_METHOD: + PBLOCK_ASSERT_OP( pb, 0 ); + PBLOCK_VALIDATE_IS_INTOP( pb ); + + if ( pb->pop->o_tag == LDAP_REQ_BIND ) + pb->pop->orb_method = (int)value; + else + rc = PBLOCK_ERROR; + break; + case SLAPI_BIND_CREDENTIALS: + PBLOCK_ASSERT_OP( pb, 0 ); + PBLOCK_VALIDATE_IS_INTOP( pb ); + + if ( pb->pop->o_tag == LDAP_REQ_BIND ) + pb->pop->orb_cred = *((struct berval *)value); + else + rc = PBLOCK_ERROR; + break; + case SLAPI_COMPARE_TYPE: + PBLOCK_ASSERT_OP( pb, 0 ); + PBLOCK_VALIDATE_IS_INTOP( pb ); + + if ( pb->pop->o_tag == LDAP_REQ_COMPARE ) { + const char *text; + + pb->pop->orc_ava->aa_desc = NULL; + rc = slap_str2ad( (char *)value, &pb->pop->orc_ava->aa_desc, &text ); + } else { + rc = PBLOCK_ERROR; + } + break; + case SLAPI_COMPARE_VALUE: + PBLOCK_ASSERT_OP( pb, 0 ); + PBLOCK_VALIDATE_IS_INTOP( pb ); + + if ( pb->pop->o_tag == LDAP_REQ_COMPARE ) { + pb->pop->orc_ava->aa_value = *((struct berval *)value); + } else { + rc = PBLOCK_ERROR; + } + break; + case SLAPI_REQUESTOR_ISROOT: + case SLAPI_REQUESTOR_ISUPDATEDN: + case SLAPI_CONN_AUTHTYPE: + case SLAPI_CONN_AUTHMETHOD: + case SLAPI_X_CONN_IS_UDP: + case SLAPI_CONN_CLIENTIP: + case SLAPI_X_CONN_CLIENTPATH: + case SLAPI_CONN_SERVERIP: + case SLAPI_X_CONN_SERVERPATH: + rc = PBLOCK_ERROR; + break; + default: + rc = pblock_set_default( pb, param, value ); + break; + } + + pblock_unlock( pb ); + + return rc; } static void -clearPB( Slapi_PBlock *pb ) +pblock_clear( Slapi_PBlock *pb ) { pb->numParams = 1; } -static void -checkParams( Slapi_PBlock *pb, int flag ) -{ - pb->ckParams = flag; -} - static int -deleteParam( Slapi_PBlock *p, int param ) +pblock_delete_param( Slapi_PBlock *p, int param ) { int i; - Lock(p); + pblock_lock(p); + for ( i = 0; i < p->numParams; i++ ) { if ( p->curParams[i] == param ) { break; @@ -411,7 +1144,7 @@ deleteParam( Slapi_PBlock *p, int param ) } if (i >= p->numParams ) { - unLock( p ); + pblock_unlock( p ); return PBLOCK_ERROR; } if ( p->numParams > 1 ) { @@ -419,17 +1152,18 @@ deleteParam( Slapi_PBlock *p, int param ) p->curVals[i] = p->curVals[p->numParams]; } p->numParams--; - unLock( p ); + + pblock_unlock( p ); + return PBLOCK_SUCCESS; } Slapi_PBlock * -slapi_pblock_new() +slapi_pblock_new(void) { -#if defined(LDAP_SLAPI) Slapi_PBlock *pb; - pb = (Slapi_PBlock *) ch_malloc(sizeof(Slapi_PBlock)); + pb = (Slapi_PBlock *) ch_calloc( 1, sizeof(Slapi_PBlock) ); if ( pb != NULL ) { pb->ckParams = 1; ldap_pvt_thread_mutex_init( &pb->pblockMutex ); @@ -438,114 +1172,69 @@ slapi_pblock_new() pb->curParams[0] = SLAPI_IBM_PBLOCK; pb->curVals[0] = NULL; pb->numParams = 1; + pb->pconn = NULL; + pb->pop = NULL; + pb->internal_op = 0; } return pb; -#endif /* LDAP_SLAPI */ - return NULL; } void slapi_pblock_destroy( Slapi_PBlock* pb ) { -#if defined(LDAP_SLAPI) - char *str = NULL; - LDAPControl **rescontrols = NULL; + LDAPControl **controls = NULL; - get( pb, SLAPI_CONN_DN,(void **)&str ); - if ( str != NULL ) { - ch_free( str ); - str = NULL; + assert( pb != NULL ); + + if ( pb->internal_op ) { + slapi_int_connection_done_pb( pb ); + } else { + LDAPMod **mods = NULL; + char **attrs = NULL; + + pblock_get_default( pb, SLAPI_MODIFY_MODS, (void **)&mods ); + + if ( mods != NULL ) + slapi_int_free_ldapmods( mods ); + + pblock_get_default( pb, SLAPI_SEARCH_ATTRS, (void **)&attrs ); + + if ( attrs != NULL ) + pb->pop->o_tmpfree( attrs, pb->pop->o_tmpmemctx ); } - get( pb, SLAPI_CONN_AUTHMETHOD, (void **)&str ); - if ( str != NULL ) { - ch_free( str ); - str = NULL; - } - - get( pb, SLAPI_RESULT_TEXT, (void **)&str ); - if ( str != NULL ) { - ch_free( str ); - str = NULL; - } - - get( pb, SLAPI_RESULT_MATCHED, (void **)&str ); - if ( str != NULL ) { - ch_free( str ); - str = NULL; - } - - get( pb, SLAPI_RESCONTROLS, (void **)&rescontrols ); - if ( rescontrols != NULL ) { - ldap_controls_free( rescontrols ); - rescontrols = NULL; + pblock_get_default( pb, SLAPI_RESCONTROLS, (void **)&controls ); + if ( controls != NULL ) { + ldap_controls_free( controls ); } ldap_pvt_thread_mutex_destroy( &pb->pblockMutex ); - ch_free( pb ); -#endif /* LDAP_SLAPI */ + slapi_ch_free( (void **)&pb ); } int slapi_pblock_get( Slapi_PBlock *pb, int arg, void *value ) { -#if defined(LDAP_SLAPI) - return get( pb, arg, (void **)value ); -#endif /* LDAP_SLAPI */ - return PBLOCK_ERROR; + return pblock_get( pb, arg, (void **)value ); } int slapi_pblock_set( Slapi_PBlock *pb, int arg, void *value ) { -#if defined(LDAP_SLAPI) - void *pTmp = NULL; - - switch ( arg ) { - case SLAPI_CONN_DN: - case SLAPI_CONN_AUTHMETHOD: - case SLAPI_RESULT_TEXT: - case SLAPI_RESULT_MATCHED: - if ( value != NULL ) { - pTmp = (void *)slapi_ch_strdup((char *)value); - if ( pTmp == NULL ) { - return LDAP_NO_MEMORY; - } - } - break; - default: - pTmp = value; - break; - } - return set( pb, arg, pTmp ); -#endif /* LDAP_SLAPI */ - return LDAP_NO_MEMORY; + return pblock_set( pb, arg, value ); } void slapi_pblock_clear( Slapi_PBlock *pb ) { -#if defined(LDAP_SLAPI) - clearPB( pb ); -#endif /* LDAP_SLAPI */ + pblock_clear( pb ); } int slapi_pblock_delete_param( Slapi_PBlock *p, int param ) { -#if defined(LDAP_SLAPI) - return deleteParam( p, param ); -#endif /* LDAP_SLAPI */ - return PBLOCK_ERROR; -} - -void -slapi_pblock_check_params( Slapi_PBlock *pb, int flag ) -{ -#if defined(LDAP_SLAPI) - checkParams( pb, flag ); -#endif /* LDAP_SLAPI */ + return pblock_delete_param( p, param ); } /* @@ -554,13 +1243,9 @@ slapi_pblock_check_params( Slapi_PBlock *pb, int flag ) int slapi_int_pblock_get_first( Backend *be, Slapi_PBlock **pb ) { -#if defined(LDAP_SLAPI) assert( pb != NULL ); *pb = SLAPI_BACKEND_PBLOCK( be ); return (*pb == NULL ? LDAP_OTHER : LDAP_SUCCESS); -#else /* LDAP_SLAPI */ - return LDAP_OTHER; -#endif /* LDAP_SLAPI */ } /* @@ -569,11 +1254,9 @@ slapi_int_pblock_get_first( Backend *be, Slapi_PBlock **pb ) int slapi_int_pblock_get_next( Slapi_PBlock **pb ) { -#if defined(LDAP_SLAPI) assert( pb != NULL ); return slapi_pblock_get( *pb, SLAPI_IBM_PBLOCK, pb ); -#else /* LDAP_SLAPI */ - return LDAP_OTHER; -#endif /* LDAP_SLAPI */ } +#endif /* LDAP_SLAPI */ + diff --git a/servers/slapd/slapi/slapi_utils.c b/servers/slapd/slapi/slapi_utils.c index 0a32cafe17..ab200e88f4 100644 --- a/servers/slapd/slapi/slapi_utils.c +++ b/servers/slapd/slapi/slapi_utils.c @@ -32,6 +32,8 @@ #include +#ifdef LDAP_SLAPI + /* * server start time (should we use a struct timeval also in slapd? */ @@ -48,7 +50,6 @@ struct slapi_condvar { ldap_pvt_thread_mutex_t mutex; }; -#ifdef LDAP_SLAPI static int checkBVString(const struct berval *bv) { int i; @@ -62,7 +63,6 @@ static int checkBVString(const struct berval *bv) return 1; } -#endif /* LDAP_SLAPI */ /* * This function converts an array of pointers to berval objects to @@ -110,7 +110,6 @@ slapi_str2entry( char *s, int flags ) { -#ifdef LDAP_SLAPI Slapi_Entry *e = NULL; char *pTmpS; @@ -121,9 +120,6 @@ slapi_str2entry( } return e; -#else - return NULL; -#endif /* LDAP_SLAPI */ } char * @@ -131,7 +127,6 @@ slapi_entry2str( Slapi_Entry *e, int *len ) { -#ifdef LDAP_SLAPI char *ret; ldap_pvt_thread_mutex_lock( &entry2str_mutex ); @@ -139,29 +134,18 @@ slapi_entry2str( ldap_pvt_thread_mutex_unlock( &entry2str_mutex ); return ret; -#else /* LDAP_SLAPI */ - return NULL; -#endif /* LDAP_SLAPI */ } char * slapi_entry_get_dn( Slapi_Entry *e ) { -#ifdef LDAP_SLAPI return e->e_name.bv_val; -#else /* LDAP_SLAPI */ - return NULL; -#endif /* LDAP_SLAPI */ } int slapi_x_entry_get_id( Slapi_Entry *e ) { -#ifdef LDAP_SLAPI return e->e_id; -#else - return NOID; -#endif /* LDAP_SLAPI */ } void @@ -169,24 +153,18 @@ slapi_entry_set_dn( Slapi_Entry *e, char *ldn ) { -#ifdef LDAP_SLAPI struct berval dn = BER_BVNULL; dn.bv_val = ldn; dn.bv_len = strlen( ldn ); dnPrettyNormal( NULL, &dn, &e->e_name, &e->e_nname, NULL ); -#endif /* LDAP_SLAPI */ } Slapi_Entry * slapi_entry_dup( Slapi_Entry *e ) { -#ifdef LDAP_SLAPI return entry_dup( e ); -#else /* LDAP_SLAPI */ - return NULL; -#endif /* LDAP_SLAPI */ } int @@ -194,7 +172,6 @@ slapi_entry_attr_delete( Slapi_Entry *e, char *type ) { -#ifdef LDAP_SLAPI AttributeDescription *ad = NULL; const char *text; @@ -207,28 +184,19 @@ slapi_entry_attr_delete( } else { return -1; /* something went wrong */ } -#else /* LDAP_SLAPI */ - return -1; -#endif /* LDAP_SLAPI */ } Slapi_Entry * slapi_entry_alloc( void ) { -#ifdef LDAP_SLAPI return (Slapi_Entry *)slapi_ch_calloc( 1, sizeof(Slapi_Entry) ); -#else /* LDAP_SLAPI */ - return NULL; -#endif /* LDAP_SLAPI */ } void slapi_entry_free( Slapi_Entry *e ) { -#ifdef LDAP_SLAPI if ( e != NULL ) entry_free( e ); -#endif /* LDAP_SLAPI */ } int @@ -237,7 +205,6 @@ slapi_entry_attr_merge( char *type, struct berval **vals ) { -#ifdef LDAP_SLAPI AttributeDescription *ad = NULL; const char *text; BerVarray bv; @@ -257,9 +224,6 @@ slapi_entry_attr_merge( ch_free( bv ); return rc; -#else /* LDAP_SLAPI */ - return -1; -#endif /* LDAP_SLAPI */ } int @@ -268,7 +232,6 @@ slapi_entry_attr_find( char *type, Slapi_Attr **attr ) { -#ifdef LDAP_SLAPI AttributeDescription *ad = NULL; const char *text; int rc; @@ -284,15 +247,11 @@ slapi_entry_attr_find( } return 0; -#else /* LDAP_SLAPI */ - return -1; -#endif /* LDAP_SLAPI */ } char * slapi_entry_attr_get_charptr( const Slapi_Entry *e, const char *type ) { -#ifdef LDAP_SLAPI AttributeDescription *ad = NULL; const char *text; int rc; @@ -318,15 +277,11 @@ slapi_entry_attr_get_charptr( const Slapi_Entry *e, const char *type ) } return NULL; -#else - return -1; -#endif } int slapi_entry_attr_get_int( const Slapi_Entry *e, const char *type ) { -#ifdef LDAP_SLAPI AttributeDescription *ad = NULL; const char *text; int rc; @@ -343,15 +298,11 @@ slapi_entry_attr_get_int( const Slapi_Entry *e, const char *type ) } return slapi_value_get_int( attr->a_vals ); -#else - return 0; -#endif } long slapi_entry_attr_get_long( const Slapi_Entry *e, const char *type ) { -#ifdef LDAP_SLAPI AttributeDescription *ad = NULL; const char *text; int rc; @@ -368,15 +319,11 @@ slapi_entry_attr_get_long( const Slapi_Entry *e, const char *type ) } return slapi_value_get_long( attr->a_vals ); -#else - return 0; -#endif } unsigned int slapi_entry_attr_get_uint( const Slapi_Entry *e, const char *type ) { -#ifdef LDAP_SLAPI AttributeDescription *ad = NULL; const char *text; int rc; @@ -393,15 +340,11 @@ slapi_entry_attr_get_uint( const Slapi_Entry *e, const char *type ) } return slapi_value_get_uint( attr->a_vals ); -#else - return 0; -#endif } unsigned long slapi_entry_attr_get_ulong( const Slapi_Entry *e, const char *type ) { -#ifdef LDAP_SLAPI AttributeDescription *ad = NULL; const char *text; int rc; @@ -418,15 +361,11 @@ slapi_entry_attr_get_ulong( const Slapi_Entry *e, const char *type ) } return slapi_value_get_ulong( attr->a_vals ); -#else - return 0; -#endif } int slapi_entry_attr_hasvalue( Slapi_Entry *e, const char *type, const char *value ) { -#ifdef LDAP_SLAPI struct berval bv; AttributeDescription *ad = NULL; const char *text; @@ -447,15 +386,11 @@ slapi_entry_attr_hasvalue( Slapi_Entry *e, const char *type, const char *value ) bv.bv_len = strlen( value ); return ( slapi_attr_value_find( attr, &bv ) != -1 ); -#else - return 0; -#endif } void slapi_entry_attr_set_charptr(Slapi_Entry* e, const char *type, const char *value) { -#ifdef LDAP_SLAPI AttributeDescription *ad = NULL; const char *text; int rc; @@ -472,96 +407,69 @@ slapi_entry_attr_set_charptr(Slapi_Entry* e, const char *type, const char *value bv.bv_len = strlen(value); attr_merge_normalize_one( e, ad, &bv, NULL ); } -#endif /* LDAP_SLAPI */ } void slapi_entry_attr_set_int( Slapi_Entry* e, const char *type, int l) { -#ifdef LDAP_SLAPI char buf[64]; snprintf( buf, sizeof( buf ), "%d", l ); slapi_entry_attr_set_charptr( e, type, buf ); -#endif /* LDAP_SLAPI */ } void slapi_entry_attr_set_uint( Slapi_Entry* e, const char *type, unsigned int l) { -#ifdef LDAP_SLAPI char buf[64]; snprintf( buf, sizeof( buf ), "%u", l ); slapi_entry_attr_set_charptr( e, type, buf ); -#endif /* LDAP_SLAPI */ } void slapi_entry_attr_set_long(Slapi_Entry* e, const char *type, long l) { -#ifdef LDAP_SLAPI char buf[64]; snprintf( buf, sizeof( buf ), "%ld", l ); slapi_entry_attr_set_charptr( e, type, buf ); -#endif /* LDAP_SLAPI */ } void slapi_entry_attr_set_ulong(Slapi_Entry* e, const char *type, unsigned long l) { -#ifdef LDAP_SLAPI char buf[64]; snprintf( buf, sizeof( buf ), "%lu", l ); slapi_entry_attr_set_charptr( e, type, buf ); -#endif /* LDAP_SLAPI */ } int slapi_is_rootdse( const char *dn ) { -#ifdef LDAP_SLAPI return ( dn == NULL || dn[0] == '\0' ); -#else - return 0; -#endif } int -slapi_entry_has_children(const Slapi_Entry *e) +slapi_entry_has_children( const Slapi_Entry *e ) { -#ifdef LDAP_SLAPI - Connection *conn; - Operation *op; - int hasSubordinates = 0; - int rc; Slapi_PBlock *pb; + int hasSubordinates = 0; pb = slapi_pblock_new(); + slapi_int_connection_init_pb( pb, LDAP_REQ_SEARCH ); slapi_pblock_set( pb, SLAPI_TARGET_DN, slapi_entry_get_dn( (Entry *)e ) ); - rc = slapi_int_connection_init( pb, LDAP_REQ_SEARCH, &conn ); - if ( rc != LDAP_SUCCESS ) { - slapi_pblock_destroy( pb ); - return 0; + pb->pop->o_bd = select_backend( (struct berval *)&e->e_nname, 0, 0 ); + if ( pb->pop->o_bd != NULL ) { + pb->pop->o_bd->be_has_subordinates( pb->pop, (Entry *)e, &hasSubordinates ); } - op = conn->c_pending_ops.stqh_first; - op->o_bd = select_backend( &e->e_nname, 0, 0 ); - if ( op->o_bd != NULL ) { - op->o_bd->be_has_subordinates( op, (Entry *)e, &hasSubordinates ); - } - - slapi_int_connection_destroy( &conn ); slapi_pblock_destroy( pb ); return ( hasSubordinates == LDAP_COMPARE_TRUE ); -#else - return 0; -#endif } /* @@ -573,7 +481,6 @@ slapi_entry_has_children(const Slapi_Entry *e) */ size_t slapi_entry_size(Slapi_Entry *e) { -#ifdef LDAP_SLAPI size_t size; Attribute *a; int i; @@ -588,9 +495,6 @@ size_t slapi_entry_size(Slapi_Entry *e) size -= (size % 1024); return size; -#else - return 0; -#endif /* LDAP_SLAPI */ } /* @@ -604,7 +508,6 @@ size_t slapi_entry_size(Slapi_Entry *e) int slapi_entry_add_values( Slapi_Entry *e, const char *type, struct berval **vals ) { -#ifdef LDAP_SLAPI Modification mod; const char *text; int rc; @@ -637,28 +540,20 @@ slapi_entry_add_values( Slapi_Entry *e, const char *type, struct berval **vals ) rc = modify_add_values( e, &mod, 0, &text, textbuf, sizeof(textbuf) ); - ch_free( mod.sm_values ); + slapi_ch_free( (void **)&mod.sm_values ); return (rc == LDAP_SUCCESS) ? LDAP_SUCCESS : LDAP_CONSTRAINT_VIOLATION; -#else - return -1; -#endif /* LDAP_SLAPI */ } int slapi_entry_add_values_sv( Slapi_Entry *e, const char *type, Slapi_Value **vals ) { -#ifdef LDAP_SLAPI return slapi_entry_add_values( e, type, vals ); -#else - return -1; -#endif /* LDAP_SLAPI */ } int slapi_entry_add_valueset(Slapi_Entry *e, const char *type, Slapi_ValueSet *vs) { -#ifdef LDAP_SLAPI AttributeDescription *ad = NULL; const char *text; int rc; @@ -669,15 +564,11 @@ slapi_entry_add_valueset(Slapi_Entry *e, const char *type, Slapi_ValueSet *vs) } return attr_merge_normalize( e, ad, *vs, NULL ); -#else - return -1; -#endif /* LDAP_SLAPI */ } int slapi_entry_delete_values( Slapi_Entry *e, const char *type, struct berval **vals ) { -#ifdef LDAP_SLAPI Modification mod; const char *text; int rc; @@ -712,38 +603,26 @@ slapi_entry_delete_values( Slapi_Entry *e, const char *type, struct berval **val rc = modify_delete_values( e, &mod, 0, &text, textbuf, sizeof(textbuf) ); - ch_free( mod.sm_values ); + slapi_ch_free( (void **)&mod.sm_values ); return rc; -#else - return -1; -#endif /* LDAP_SLAPI */ } int slapi_entry_delete_values_sv( Slapi_Entry *e, const char *type, Slapi_Value **vals ) { -#ifdef LDAP_SLAPI return slapi_entry_delete_values( e, type, vals ); -#else - return -1; -#endif /* LDAP_SLAPI */ } int slapi_entry_merge_values_sv( Slapi_Entry *e, const char *type, Slapi_Value **vals ) { -#ifdef LDAP_SLAPI return slapi_entry_attr_merge( e, (char *)type, vals ); -#else - return -1; -#endif /* LDAP_SLAPI */ } int slapi_entry_add_value(Slapi_Entry *e, const char *type, const Slapi_Value *value) { -#ifdef LDAP_SLAPI AttributeDescription *ad = NULL; int rc; const char *text; @@ -759,30 +638,22 @@ slapi_entry_add_value(Slapi_Entry *e, const char *type, const Slapi_Value *value } return 0; -#else - return -1; -#endif /* LDAP_SLAPI */ } int slapi_entry_add_string(Slapi_Entry *e, const char *type, const char *value) { -#ifdef LDAP_SLAPI Slapi_Value val; val.bv_val = (char *)value; val.bv_len = strlen( value ); return slapi_entry_add_value( e, type, &val ); -#else - return -1; -#endif /* LDAP_SLAPI */ } int slapi_entry_delete_string(Slapi_Entry *e, const char *type, const char *value) { -#ifdef LDAP_SLAPI Slapi_Value *vals[2]; Slapi_Value val; @@ -792,26 +663,18 @@ slapi_entry_delete_string(Slapi_Entry *e, const char *type, const char *value) vals[1] = NULL; return slapi_entry_delete_values_sv( e, type, vals ); -#else - return -1; -#endif /* LDAP_SLAPI */ } int slapi_entry_attr_merge_sv( Slapi_Entry *e, const char *type, Slapi_Value **vals ) { -#ifdef LDAP_SLAPI return slapi_entry_attr_merge( e, (char *)type, vals ); -#else - return -1; -#endif } int slapi_entry_first_attr( const Slapi_Entry *e, Slapi_Attr **attr ) { -#ifdef LDAP_SLAPI if ( e == NULL ) { return -1; } @@ -819,15 +682,11 @@ slapi_entry_first_attr( const Slapi_Entry *e, Slapi_Attr **attr ) *attr = e->e_attrs; return ( *attr != NULL ) ? 0 : -1; -#else - return -1; -#endif } int slapi_entry_next_attr( const Slapi_Entry *e, Slapi_Attr *prevattr, Slapi_Attr **attr ) { -#ifdef LDAP_SLAPI if ( e == NULL ) { return -1; } @@ -839,15 +698,11 @@ slapi_entry_next_attr( const Slapi_Entry *e, Slapi_Attr *prevattr, Slapi_Attr ** *attr = prevattr->a_next; return ( *attr != NULL ) ? 0 : -1; -#else - return -1; -#endif } int slapi_entry_attr_replace_sv( Slapi_Entry *e, const char *type, Slapi_Value **vals ) { -#ifdef LDAP_SLAPI AttributeDescription *ad = NULL; const char *text; int rc; @@ -872,9 +727,6 @@ slapi_entry_attr_replace_sv( Slapi_Entry *e, const char *type, Slapi_Value **val } return 0; -#else - return -1; -#endif /* LDAP_SLAPI */ } /* @@ -886,7 +738,6 @@ slapi_attr_get_values( Slapi_Attr *attr, struct berval ***vals ) { -#ifdef LDAP_SLAPI int i, j; struct berval **bv; @@ -907,15 +758,11 @@ slapi_attr_get_values( *vals = (struct berval **)bv; return 0; -#else /* LDAP_SLAPI */ - return -1; -#endif /* LDAP_SLAPI */ } char * slapi_dn_normalize( char *dn ) { -#ifdef LDAP_SLAPI struct berval bdn; struct berval pdn; @@ -929,15 +776,11 @@ slapi_dn_normalize( char *dn ) } return pdn.bv_val; -#else /* LDAP_SLAPI */ - return NULL; -#endif /* LDAP_SLAPI */ } char * slapi_dn_normalize_case( char *dn ) { -#ifdef LDAP_SLAPI struct berval bdn; struct berval ndn; @@ -951,9 +794,6 @@ slapi_dn_normalize_case( char *dn ) } return ndn.bv_val; -#else /* LDAP_SLAPI */ - return NULL; -#endif /* LDAP_SLAPI */ } int @@ -961,7 +801,6 @@ slapi_dn_issuffix( char *dn, char *suffix ) { -#ifdef LDAP_SLAPI struct berval bdn, ndn; struct berval bsuffix, nsuffix; int rc; @@ -992,9 +831,6 @@ slapi_dn_issuffix( slapi_ch_free( (void **)&nsuffix.bv_val ); return rc; -#else /* LDAP_SLAPI */ - return 0; -#endif /* LDAP_SLAPI */ } int @@ -1002,7 +838,6 @@ slapi_dn_isparent( const char *parentdn, const char *childdn ) { -#ifdef LDAP_SLAPI struct berval assertedParentDN, normalizedAssertedParentDN; struct berval childDN, normalizedChildDN; struct berval normalizedParentDN; @@ -1042,9 +877,6 @@ slapi_dn_isparent( slapi_ch_free( (void **)&normalizedChildDN.bv_val ); return ( match == 0 ); -#else - return 0; -#endif /* LDAP_SLAPI */ } /* @@ -1054,7 +886,6 @@ slapi_dn_isparent( char * slapi_dn_parent( const char *_dn ) { -#ifdef LDAP_SLAPI struct berval dn, prettyDN; struct berval parentDN; @@ -1082,9 +913,6 @@ slapi_dn_parent( const char *_dn ) } return slapi_ch_strdup( parentDN.bv_val ); -#else - return NULL; -#endif /* LDAP_SLAPI */ } /* @@ -1094,7 +922,6 @@ slapi_dn_parent( const char *_dn ) */ char *slapi_dn_beparent( Slapi_PBlock *pb, const char *_dn ) { -#ifdef LDAP_SLAPI Backend *be; struct berval dn, prettyDN; struct berval normalizedDN, parentDN; @@ -1125,54 +952,38 @@ char *slapi_dn_beparent( Slapi_PBlock *pb, const char *_dn ) } return slapi_ch_strdup( parentDN.bv_val ); -#else - return NULL; -#endif /* LDAP_SLAPI */ } char * slapi_dn_ignore_case( char *dn ) { -#ifdef LDAP_SLAPI return slapi_dn_normalize_case( dn ); -#else /* LDAP_SLAPI */ - return NULL; -#endif /* LDAP_SLAPI */ } char * slapi_ch_malloc( unsigned long size ) { -#ifdef LDAP_SLAPI return ch_malloc( size ); -#else /* LDAP_SLAPI */ - return NULL; -#endif /* LDAP_SLAPI */ } void slapi_ch_free( void **ptr ) { -#ifdef LDAP_SLAPI if ( ptr == NULL || *ptr == NULL ) return; ch_free( *ptr ); *ptr = NULL; -#endif /* LDAP_SLAPI */ } void slapi_ch_free_string( char **ptr ) { -#ifdef LDAP_SLAPI slapi_ch_free( (void **)ptr ); -#endif /* LDAP_SLAPI */ } void slapi_ch_array_free( char **arrayp ) { -#ifdef LDAP_SLAPI char **p; if ( arrayp != NULL ) { @@ -1181,13 +992,11 @@ slapi_ch_array_free( char **arrayp ) } slapi_ch_free( (void **)&arrayp ); } -#endif } struct berval * slapi_ch_bvdup(const struct berval *v) { -#ifdef LDAP_SLAPI struct berval *bv; bv = (struct berval *) slapi_ch_malloc( sizeof(struct berval) ); @@ -1196,15 +1005,11 @@ slapi_ch_bvdup(const struct berval *v) AC_MEMCPY( bv->bv_val, v->bv_val, bv->bv_len ); return bv; -#else - return NULL; -#endif } struct berval ** slapi_ch_bvecdup(const struct berval **v) { -#ifdef LDAP_SLAPI int i; struct berval **rv; @@ -1223,9 +1028,6 @@ slapi_ch_bvecdup(const struct berval **v) rv[i] = NULL; return rv; -#else - return NULL; -#endif } char * @@ -1233,11 +1035,7 @@ slapi_ch_calloc( unsigned long nelem, unsigned long size ) { -#ifdef LDAP_SLAPI return ch_calloc( nelem, size ); -#else /* LDAP_SLAPI */ - return NULL; -#endif /* LDAP_SLAPI */ } char * @@ -1245,31 +1043,19 @@ slapi_ch_realloc( char *block, unsigned long size ) { -#ifdef LDAP_SLAPI return ch_realloc( block, size ); -#else /* LDAP_SLAPI */ - return NULL; -#endif /* LDAP_SLAPI */ } char * slapi_ch_strdup( char *s ) { -#ifdef LDAP_SLAPI return ch_strdup( (const char *)s ); -#else /* LDAP_SLAPI */ - return NULL; -#endif /* LDAP_SLAPI */ } size_t slapi_ch_stlen( char *s ) { -#ifdef LDAP_SLAPI return strlen( (const char *)s ); -#else /* LDAP_SLAPI */ - return 0; -#endif /* LDAP_SLAPI */ } int @@ -1279,7 +1065,6 @@ slapi_control_present( struct berval **val, int *iscritical ) { -#ifdef LDAP_SLAPI int i; int rc = 0; @@ -1298,30 +1083,6 @@ slapi_control_present( rc = 1; if ( controls[i]->ldctl_value.bv_len != 0 ) { - /* - * FIXME: according to 6.1 specification, - * "The val output parameter is set - * to point into the controls array. - * A copy of the control value is - * not made." - */ -#if 0 - struct berval *pTmpBval; - - pTmpBval = (struct berval *)slapi_ch_malloc( sizeof(struct berval)); - if ( pTmpBval == NULL ) { - rc = 0; - } else { - pTmpBval->bv_len = controls[i]->ldctl_value.bv_len; - pTmpBval->bv_val = controls[i]->ldctl_value.bv_val; - if ( val ) { - *val = pTmpBval; - } else { - slapi_ch_free( (void **)&pTmpBval ); - rc = 0; - } - } -#endif /* 0 */ if ( val ) { *val = &controls[i]->ldctl_value; } @@ -1335,12 +1096,8 @@ slapi_control_present( } return rc; -#else /* LDAP_SLAPI */ - return 0; -#endif /* LDAP_SLAPI */ } -#ifdef LDAP_SLAPI static void slapControlMask2SlapiControlOp(slap_mask_t slap_mask, unsigned long *slapi_mask) @@ -1421,20 +1178,17 @@ slapi_int_parse_control( return LDAP_SUCCESS; } -#endif /* LDAP_SLAPI */ void slapi_register_supported_control( char *controloid, unsigned long controlops ) { -#ifdef LDAP_SLAPI slap_mask_t controlmask; slapiControlOp2SlapControlMask( controlops, &controlmask ); register_supported_control( controloid, controlmask, NULL, slapi_int_parse_control, NULL ); -#endif /* LDAP_SLAPI */ } int @@ -1442,7 +1196,6 @@ slapi_get_supported_controls( char ***ctrloidsp, unsigned long **ctrlopsp ) { -#ifdef LDAP_SLAPI int i, rc; rc = get_supported_controls( ctrloidsp, (slap_mask_t **)ctrlopsp ); @@ -1456,15 +1209,11 @@ slapi_get_supported_controls( } return LDAP_SUCCESS; -#else /* LDAP_SLAPI */ - return 1; -#endif /* LDAP_SLAPI */ } LDAPControl * slapi_dup_control( LDAPControl *ctrl ) { -#ifdef LDAP_SLAPI LDAPControl *ret; ret = (LDAPControl *)slapi_ch_malloc( sizeof(*ret) ); @@ -1473,39 +1222,29 @@ slapi_dup_control( LDAPControl *ctrl ) ret->ldctl_iscritical = ctrl->ldctl_iscritical; return ret; -#else - return NULL; -#endif /* LDAP_SLAPI */ } void slapi_register_supported_saslmechanism( char *mechanism ) { -#ifdef LDAP_SLAPI /* FIXME -- can not add saslmechanism to OpenLDAP dynamically */ slapi_log_error( SLAPI_LOG_FATAL, "slapi_register_supported_saslmechanism", "OpenLDAP does not support dynamic registration of SASL mechanisms\n" ); -#endif /* LDAP_SLAPI */ } char ** slapi_get_supported_saslmechanisms( void ) { -#ifdef LDAP_SLAPI /* FIXME -- can not get the saslmechanism without a connection. */ slapi_log_error( SLAPI_LOG_FATAL, "slapi_get_supported_saslmechanisms", "can not get the SASL mechanism list " "without a connection\n" ); return NULL; -#else /* LDAP_SLAPI */ - return NULL; -#endif /* LDAP_SLAPI */ } char ** slapi_get_supported_extended_ops( void ) { -#ifdef LDAP_SLAPI int i, j, k; char **ppExtOpOID = NULL; int numExtOps = 0; @@ -1544,9 +1283,6 @@ slapi_get_supported_extended_ops( void ) ppExtOpOID[ i + k ] = NULL; return ppExtOpOID; -#else /* LDAP_SLAPI */ - return NULL; -#endif /* LDAP_SLAPI */ } void @@ -1558,40 +1294,27 @@ slapi_send_ldap_result( int nentries, struct berval **urls ) { -#ifdef LDAP_SLAPI - Operation *op; - char *extOID = NULL; - SlapReply rs = { REP_RESULT }; + SlapReply *rs; - slapi_pblock_get( pb, SLAPI_OPERATION, &op ); + assert( pb->pop != NULL ); - rs.sr_err = err; - rs.sr_matched = matched; - rs.sr_text = text; - rs.sr_ref = NULL; - rs.sr_ctrls = NULL; + rs = &pb->rs; - slapi_pblock_get( pb, SLAPI_RESCONTROLS, &rs.sr_ctrls ); + rs->sr_err = err; + rs->sr_matched = matched; + rs->sr_text = text; + rs->sr_ref = NULL; if ( err == LDAP_SASL_BIND_IN_PROGRESS ) { - slapi_pblock_get( pb, SLAPI_BIND_RET_SASLCREDS, (void *) &rs.sr_sasldata ); - send_ldap_sasl( op, &rs ); - return; + send_ldap_sasl( pb->pop, rs ); + } else if ( rs->sr_rspoid != NULL ) { + send_ldap_extended( pb->pop, rs ); + } else { + if ( pb->pop->o_tag == LDAP_REQ_SEARCH ) + rs->sr_nentries = nentries; + + send_ldap_result( pb->pop, rs ); } - - slapi_pblock_get( pb, SLAPI_EXT_OP_RET_OID, &extOID ); - if ( extOID != NULL ) { - rs.sr_rspoid = extOID; - slapi_pblock_get( pb, SLAPI_EXT_OP_RET_VALUE, &rs.sr_rspdata ); - send_ldap_extended( op, &rs ); - return; - } - - if ( op->o_tag == LDAP_REQ_SEARCH ) - rs.sr_nentries = nentries; - - send_ldap_result( op, &rs ); -#endif /* LDAP_SLAPI */ } int @@ -1602,29 +1325,31 @@ slapi_send_ldap_search_entry( char **attrs, int attrsonly ) { -#ifdef LDAP_SLAPI - Operation *pOp; - SlapReply rs = { REP_RESULT }; - int i; - AttributeName *an = NULL; - const char *text; + SlapReply rs = { REP_SEARCH }; + int i = 0; + AttributeName *an = NULL; + const char *text; + int rc; + + assert( pb->pop != NULL ); if ( attrs != NULL ) { for ( i = 0; attrs[ i ] != NULL; i++ ) { ; /* empty */ } - } else { - i = 0; } - if ( i > 0 ) { - an = (AttributeName *) ch_malloc( (i+1) * sizeof(AttributeName) ); + if ( i ) { + an = (AttributeName *) slapi_ch_malloc( (i+1) * sizeof(AttributeName) ); for ( i = 0; attrs[i] != NULL; i++ ) { - an[i].an_name.bv_val = ch_strdup( attrs[i] ); + an[i].an_name.bv_val = attrs[i]; an[i].an_name.bv_len = strlen( attrs[i] ); an[i].an_desc = NULL; - if( slap_bv2ad( &an[i].an_name, &an[i].an_desc, &text ) != LDAP_SUCCESS) + rs.sr_err = slap_bv2ad( &an[i].an_name, &an[i].an_desc, &text ); + if ( rs.sr_err != LDAP_SUCCESS) { + slapi_ch_free( (void **)&an ); return -1; + } } an[i].an_name.bv_len = 0; an[i].an_name.bv_val = NULL; @@ -1641,14 +1366,11 @@ slapi_send_ldap_search_entry( rs.sr_v2ref = NULL; rs.sr_flags = 0; - if ( slapi_pblock_get( pb, SLAPI_OPERATION, (void *)&pOp ) != 0 ) { - return LDAP_OTHER; - } + rc = send_search_entry( pb->pop, &rs ); - return send_search_entry( pOp, &rs ); -#else /* LDAP_SLAPI */ - return -1; -#endif /* LDAP_SLAPI */ + slapi_ch_free( (void **)&an ); + + return rc; } int @@ -1660,8 +1382,6 @@ slapi_send_ldap_search_reference( struct berval **v2refs ) { -#ifdef LDAP_SLAPI - Operation *pOp; SlapReply rs = { REP_SEARCHREF }; int rc; @@ -1689,32 +1409,18 @@ slapi_send_ldap_search_reference( rs.sr_v2ref = NULL; } - if ( slapi_pblock_get( pb, SLAPI_OPERATION, (void *)&pOp ) != 0 ) { - return LDAP_OTHER; - } + rc = send_search_reference( pb->pop, &rs ); - rc = send_search_reference( pOp, &rs ); - - if ( rs.sr_ref != NULL ) - slapi_ch_free( (void **)&rs.sr_ref ); - - if ( rs.sr_v2ref != NULL ) - slapi_ch_free( (void **)&rs.sr_v2ref ); + slapi_ch_free( (void **)&rs.sr_ref ); + slapi_ch_free( (void **)&rs.sr_v2ref ); return rc; -#else - return -1; -#endif /* LDAP_SLAPI */ } Slapi_Filter * slapi_str2filter( char *str ) { -#ifdef LDAP_SLAPI return str2filter( str ); -#else /* LDAP_SLAPI */ - return NULL; -#endif /* LDAP_SLAPI */ } void @@ -1722,15 +1428,12 @@ slapi_filter_free( Slapi_Filter *f, int recurse ) { -#ifdef LDAP_SLAPI filter_free( f ); -#endif /* LDAP_SLAPI */ } Slapi_Filter * slapi_filter_dup( Slapi_Filter *filter ) { -#ifdef LDAP_SLAPI Filter *f; f = (Filter *) slapi_ch_malloc( sizeof(Filter) ); @@ -1802,15 +1505,11 @@ slapi_filter_dup( Slapi_Filter *filter ) } return f; -#else - return NULL; -#endif /* LDAP_SLAPI */ } int slapi_filter_get_choice( Slapi_Filter *f ) { -#ifdef LDAP_SLAPI int rc; if ( f != NULL ) { @@ -1820,9 +1519,6 @@ slapi_filter_get_choice( Slapi_Filter *f ) } return rc; -#else /* LDAP_SLAPI */ - return -1; /* invalid filter type */ -#endif /* LDAP_SLAPI */ } int @@ -1831,7 +1527,6 @@ slapi_filter_get_ava( char **type, struct berval **bval ) { -#ifdef LDAP_SLAPI int ftype; int rc = LDAP_SUCCESS; @@ -1857,15 +1552,11 @@ slapi_filter_get_ava( } return rc; -#else /* LDAP_SLAPI */ - return -1; -#endif /* LDAP_SLAPI */ } Slapi_Filter * slapi_filter_list_first( Slapi_Filter *f ) { -#ifdef LDAP_SLAPI int ftype; if ( f == NULL ) { @@ -1880,9 +1571,6 @@ slapi_filter_list_first( Slapi_Filter *f ) } else { return NULL; } -#else /* LDAP_SLAPI */ - return NULL; -#endif /* LDAP_SLAPI */ } Slapi_Filter * @@ -1890,7 +1578,6 @@ slapi_filter_list_next( Slapi_Filter *f, Slapi_Filter *fprev ) { -#ifdef LDAP_SLAPI int ftype; if ( f == NULL ) { @@ -1906,15 +1593,11 @@ slapi_filter_list_next( } return NULL; -#else /* LDAP_SLAPI */ - return NULL; -#endif /* LDAP_SLAPI */ } int slapi_filter_get_attribute_type( Slapi_Filter *f, char **type ) { -#ifdef LDAP_SLAPI if ( f == NULL ) { return -1; } @@ -1942,15 +1625,11 @@ slapi_filter_get_attribute_type( Slapi_Filter *f, char **type ) } return 0; -#else - return -1; -#endif /* LDAP_SLAPI */ } int slapi_x_filter_set_attribute_type( Slapi_Filter *f, const char *type ) { -#ifdef LDAP_SLAPI AttributeDescription **adp, *ad = NULL; const char *text; int rc; @@ -1985,16 +1664,12 @@ slapi_x_filter_set_attribute_type( Slapi_Filter *f, const char *type ) *adp = ad; return ( rc == LDAP_SUCCESS ) ? 0 : -1; -#else - return -1; -#endif /* LDAP_SLAPI */ } int slapi_filter_get_subfilt( Slapi_Filter *f, char **type, char **initial, char ***any, char **final ) { -#ifdef LDAP_SLAPI int i; if ( f->f_choice != LDAP_FILTER_SUBSTRINGS ) { @@ -2023,15 +1698,11 @@ slapi_filter_get_subfilt( Slapi_Filter *f, char **type, char **initial, *final = f->f_sub_final.bv_val ? slapi_ch_strdup(f->f_sub_final.bv_val) : NULL; return 0; -#else - return -1; -#endif /* LDAP_SLAPI */ } Slapi_Filter * slapi_filter_join( int ftype, Slapi_Filter *f1, Slapi_Filter *f2 ) { -#ifdef LDAP_SLAPI Slapi_Filter *f = NULL; if ( ftype == LDAP_FILTER_AND || @@ -2046,9 +1717,6 @@ slapi_filter_join( int ftype, Slapi_Filter *f1, Slapi_Filter *f2 ) } return f; -#else - return NULL; -#endif /* LDAP_SLAPI */ } int @@ -2057,7 +1725,6 @@ slapi_x_filter_append( int ftype, Slapi_Filter **pNextFilter, Slapi_Filter *filterToAppend ) { -#ifdef LDAP_SLAPI if ( ftype == LDAP_FILTER_AND || ftype == LDAP_FILTER_OR || ftype == LDAP_FILTER_NOT ) @@ -2078,7 +1745,6 @@ slapi_x_filter_append( int ftype, return 0; } -#endif /* LDAP_SLAPI */ return -1; } @@ -2086,7 +1752,6 @@ int slapi_filter_test( Slapi_PBlock *pb, Slapi_Entry *e, Slapi_Filter *f, int verify_access ) { -#ifdef LDAP_SLAPI Operation *op; int rc; @@ -2124,25 +1789,17 @@ slapi_filter_test( Slapi_PBlock *pb, Slapi_Entry *e, Slapi_Filter *f, } return rc; -#else - return -1; -#endif /* LDAP_SLAPI */ } int slapi_filter_test_simple( Slapi_Entry *e, Slapi_Filter *f) { -#ifdef LDAP_SLAPI return slapi_filter_test( NULL, e, f, 0 ); -#else - return -1; -#endif } int slapi_filter_apply( Slapi_Filter *f, FILTER_APPLY_FN fn, void *arg, int *error_code ) { -#ifdef LDAP_SLAPI switch ( f->f_choice ) { case LDAP_FILTER_AND: case LDAP_FILTER_NOT: @@ -2182,37 +1839,6 @@ slapi_filter_apply( Slapi_Filter *f, FILTER_APPLY_FN fn, void *arg, int *error_c } return -1; -#else - *error_code = SLAPI_FILTER_UNKNOWN_FILTER_TYPE; - return -1; -#endif /* LDAP_SLAPI */ -} - -int -slapi_send_ldap_extended_response( - Connection *conn, - Operation *op, - int errornum, - char *respName, - struct berval *response ) -{ -#ifdef LDAP_SLAPI - SlapReply rs; - - rs.sr_err = errornum; - rs.sr_matched = NULL; - rs.sr_text = NULL; - rs.sr_ref = NULL; - rs.sr_ctrls = NULL; - rs.sr_rspoid = respName; - rs.sr_rspdata = response; - - send_ldap_extended( op, &rs ); - - return LDAP_SUCCESS; -#else /* LDAP_SLAPI */ - return -1; -#endif /* LDAP_SLAPI */ } int @@ -2220,14 +1846,10 @@ slapi_pw_find( struct berval **vals, struct berval *v ) { -#ifdef LDAP_SLAPI /* * FIXME: what's the point? */ return 1; -#else /* LDAP_SLAPI */ - return 1; -#endif /* LDAP_SLAPI */ } #define MAX_HOSTNAME 512 @@ -2235,7 +1857,6 @@ slapi_pw_find( char * slapi_get_hostname( void ) { -#ifdef LDAP_SLAPI char *hn = NULL; static int been_here = 0; static char *static_hn = NULL; @@ -2272,9 +1893,6 @@ slapi_get_hostname( void ) hn = ch_strdup( static_hn ); return hn; -#else /* LDAP_SLAPI */ - return NULL; -#endif /* LDAP_SLAPI */ } /* @@ -2289,7 +1907,6 @@ slapi_log_error( char *fmt, ... ) { -#ifdef LDAP_SLAPI int rc = LDAP_SUCCESS; va_list arglist; @@ -2298,16 +1915,12 @@ slapi_log_error( va_end( arglist ); return rc; -#else /* LDAP_SLAPI */ - return -1; -#endif /* LDAP_SLAPI */ } unsigned long slapi_timer_current_time( void ) { -#ifdef LDAP_SLAPI static int first_time = 1; #if !defined (_WIN32) struct timeval now; @@ -2344,9 +1957,6 @@ slapi_timer_current_time( void ) QueryPerformanceCounter( &now ); return (1000000*(now.QuadPart-base_time.QuadPart))/performance_freq.QuadPart; #endif /* _WIN32 */ -#else /* LDAP_SLAPI */ - return 0; -#endif /* LDAP_SLAPI */ } /* @@ -2355,13 +1965,9 @@ slapi_timer_current_time( void ) unsigned long slapi_timer_get_time( char *label ) { -#ifdef LDAP_SLAPI unsigned long start = slapi_timer_current_time(); printf("%10ld %10d usec %s\n", start, 0, label); return start; -#else /* LDAP_SLAPI */ - return 0; -#endif /* LDAP_SLAPI */ } /* @@ -2372,219 +1978,40 @@ slapi_timer_elapsed_time( char *label, unsigned long start ) { -#ifdef LDAP_SLAPI unsigned long stop = slapi_timer_current_time(); printf ("%10ld %10ld usec %s\n", stop, stop - start, label); -#endif /* LDAP_SLAPI */ } void slapi_free_search_results_internal( Slapi_PBlock *pb ) { -#ifdef LDAP_SLAPI Slapi_Entry **entries; int k = 0, nEnt = 0; slapi_pblock_get( pb, SLAPI_NENTRIES, &nEnt ); slapi_pblock_get( pb, SLAPI_PLUGIN_INTOP_SEARCH_ENTRIES, &entries ); - if ( nEnt == 0 ) { + if ( nEnt == 0 || entries == NULL ) { return; } - - if ( entries == NULL ) { - return; - } - + for ( k = 0; k < nEnt; k++ ) { slapi_entry_free( entries[k] ); + entries[k] = NULL; } slapi_ch_free( (void **)&entries ); -#endif /* LDAP_SLAPI */ -} - -#ifdef LDAP_SLAPI -/* - * Internal API to prime a Slapi_PBlock with a Backend. - */ -static int slapi_int_pblock_set_backend( Slapi_PBlock *pb, Backend *be ) -{ - slapi_pblock_set( pb, SLAPI_BACKEND, (void *)be ); - - if ( be != NULL ) { - slapi_pblock_set( pb, SLAPI_BE_TYPE, (void *)be->bd_info->bi_type ); - } - - return 0; -} - -/* - * If oldStyle is TRUE, then a value suitable for setting to - * the deprecated SLAPI_CONN_AUTHTYPE value is returned - * (pointer to static storage). - * - * If oldStyle is FALSE, then a value suitable for setting to - * the new SLAPI_CONN_AUTHMETHOD will be returned, which is - * a pointer to allocated memory and will include the SASL - * mechanism (if any). - */ -static char *Authorization2AuthType( AuthorizationInformation *authz, int is_tls, int oldStyle ) -{ - size_t len; - char *authType; - - switch ( authz->sai_method ) { - case LDAP_AUTH_SASL: - if ( oldStyle ) { - authType = SLAPD_AUTH_SASL; - } else { - len = sizeof(SLAPD_AUTH_SASL) + authz->sai_mech.bv_len; - authType = slapi_ch_malloc( len ); - snprintf( authType, len, "%s%s", SLAPD_AUTH_SASL, authz->sai_mech.bv_val ); - } - break; - case LDAP_AUTH_SIMPLE: - authType = oldStyle ? SLAPD_AUTH_SIMPLE : slapi_ch_strdup( SLAPD_AUTH_SIMPLE ); - break; - case LDAP_AUTH_NONE: - authType = oldStyle ? SLAPD_AUTH_NONE : slapi_ch_strdup( SLAPD_AUTH_NONE ); - break; - default: - authType = NULL; - break; - } - if ( is_tls && authType == NULL ) { - authType = oldStyle ? SLAPD_AUTH_SSL : slapi_ch_strdup( SLAPD_AUTH_SSL ); - } - - return authType; -} - -/* - * Internal API to prime a Slapi_PBlock with a Connection. - */ -static int slapi_int_pblock_set_connection( Slapi_PBlock *pb, Connection *conn ) -{ - char *connAuthType; - - slapi_pblock_set( pb, SLAPI_CONNECTION, (void *)conn ); - - if ( strncmp( conn->c_peer_name.bv_val, "IP=", 3 ) == 0 ) { - slapi_pblock_set( pb, SLAPI_CONN_CLIENTIP, (void *)&conn->c_peer_name.bv_val[3] ); - } else if ( strncmp( conn->c_peer_name.bv_val, "PATH=", 5 ) == 0 ) { - slapi_pblock_set( pb, SLAPI_X_CONN_CLIENTPATH, (void *)&conn->c_peer_name.bv_val[5] ); - } - - if ( strncmp( conn->c_sock_name.bv_val, "IP=", 3 ) == 0 ) { - slapi_pblock_set( pb, SLAPI_CONN_SERVERIP, (void *)&conn->c_sock_name.bv_val[3] ); - } else if ( strncmp( conn->c_sock_name.bv_val, "PATH=", 5 ) == 0 ) { - slapi_pblock_set( pb, SLAPI_X_CONN_SERVERPATH, (void *)&conn->c_sock_name.bv_val[5] ); - } - -#ifdef LDAP_CONNECTIONLESS - slapi_pblock_set( pb, SLAPI_X_CONN_IS_UDP, (void *)conn->c_is_udp ); -#endif - - slapi_pblock_set( pb, SLAPI_CONN_ID, (void *)conn->c_connid ); - - /* Returns pointer to static string */ - connAuthType = Authorization2AuthType( &conn->c_authz, -#ifdef HAVE_TLS - conn->c_is_tls, -#else - 0, -#endif - 1 ); - if ( connAuthType != NULL ) { - slapi_pblock_set(pb, SLAPI_CONN_AUTHTYPE, (void *)connAuthType); - } - - /* Returns pointer to allocated string */ - connAuthType = Authorization2AuthType( &conn->c_authz, -#ifdef HAVE_TLS - conn->c_is_tls, -#else - 0, -#endif - 0 ); - if ( connAuthType != NULL ) { - slapi_pblock_set(pb, SLAPI_CONN_AUTHMETHOD, (void *)connAuthType); - /* slapi_pblock_set dups this itself */ - slapi_ch_free( (void **)&connAuthType ); - } - - if ( conn->c_authz.sai_method != LDAP_AUTH_NONE && - conn->c_authz.sai_dn.bv_val != NULL ) { - /* slapi_pblock_set dups this itself */ - slapi_pblock_set(pb, SLAPI_CONN_DN, (void *)conn->c_authz.sai_dn.bv_val); - } - - slapi_pblock_set(pb, SLAPI_X_CONN_SSF, (void *)conn->c_ssf); - - slapi_pblock_set(pb, SLAPI_X_CONN_SASL_CONTEXT, - ( conn->c_sasl_authctx != NULL ? conn->c_sasl_authctx : - conn->c_sasl_sockctx ) ); - - return 0; -} -#endif /* LDAP_SLAPI */ - -/* - * Internal API to prime a Slapi_PBlock with an Operation. - */ -int slapi_int_pblock_set_operation( Slapi_PBlock *pb, Operation *op ) -{ -#ifdef LDAP_SLAPI - int isRoot = 0; - int isUpdateDn = 0; - char *opAuthType; - void *existingOp = NULL; - BackendDB *be_orig; - - be_orig = op->o_bd; - - if ( op->o_req_ndn.bv_len ) { - op->o_bd = select_backend( &op->o_req_ndn, 0, 0 ); - if ( op->o_bd != NULL ) { - isRoot = be_isroot( op ); - isUpdateDn = be_isupdate( op ); - } - } - - /* This should only be called once per operation */ - slapi_pblock_get( pb, SLAPI_OPERATION, &existingOp ); - assert( existingOp == NULL ); - - slapi_int_pblock_set_backend( pb, op->o_bd ); - slapi_int_pblock_set_connection( pb, op->o_conn ); - - slapi_pblock_set( pb, SLAPI_OPERATION, (void *)op ); - slapi_pblock_set( pb, SLAPI_OPINITIATED_TIME, (void *)op->o_time ); - slapi_pblock_set( pb, SLAPI_OPERATION_ID, (void *)op->o_opid ); - slapi_pblock_set( pb, SLAPI_OPERATION_TYPE, (void *)op->o_tag ); - slapi_pblock_set( pb, SLAPI_REQUESTOR_ISROOT, (void *)isRoot ); - slapi_pblock_set( pb, SLAPI_REQUESTOR_ISUPDATEDN, (void *)isUpdateDn ); - slapi_pblock_set( pb, SLAPI_REQCONTROLS, (void *)op->o_ctrls ); - slapi_pblock_set( pb, SLAPI_REQUESTOR_DN, (void *)op->o_ndn.bv_val ); - slapi_pblock_set( pb, SLAPI_MANAGEDSAIT, (void *)get_manageDSAit( op ) ); - slapi_pblock_get( pb, SLAPI_CONN_AUTHMETHOD, (void *)&opAuthType ); - if ( opAuthType != NULL ) - slapi_pblock_set( pb, SLAPI_OPERATION_AUTHTYPE, (void *)opAuthType ); - - op->o_bd = be_orig; - - return 0; -#else - return -1; -#endif } int slapi_is_connection_ssl( Slapi_PBlock *pb, int *isSSL ) { -#ifdef LDAP_SLAPI - Connection *conn; + Connection *conn = NULL; + int rc; + + rc = slapi_pblock_get( pb, SLAPI_CONNECTION, &conn ); + if ( rc != PBLOCK_SUCCESS || conn == NULL ) { + return LDAP_OTHER; + } - slapi_pblock_get( pb, SLAPI_CONNECTION, &conn ); #ifdef HAVE_TLS *isSSL = conn->c_is_tls; #else @@ -2592,9 +2019,6 @@ int slapi_is_connection_ssl( Slapi_PBlock *pb, int *isSSL ) #endif return LDAP_SUCCESS; -#else - return -1; -#endif /* LDAP_SLAPI */ } /* @@ -2603,7 +2027,6 @@ int slapi_is_connection_ssl( Slapi_PBlock *pb, int *isSSL ) int slapi_attr_get_flags( const Slapi_Attr *attr, unsigned long *flags ) { -#ifdef LDAP_SLAPI AttributeType *at; if ( attr == NULL ) @@ -2625,40 +2048,28 @@ int slapi_attr_get_flags( const Slapi_Attr *attr, unsigned long *flags ) *flags |= SLAPI_ATTR_FLAG_NOUSERMOD; return LDAP_SUCCESS; -#else - return -1; -#endif /* LDAP_SLAPI */ } int slapi_attr_flag_is_set( const Slapi_Attr *attr, unsigned long flag ) { -#ifdef LDAP_SLAPI unsigned long flags; if ( slapi_attr_get_flags( attr, &flags ) != 0 ) return 0; return (flags & flag) ? 1 : 0; -#else - return 0; -#endif /* LDAP_SLAPI */ } Slapi_Attr *slapi_attr_new( void ) { -#ifdef LDAP_SLAPI Attribute *ad; ad = (Attribute *)slapi_ch_calloc( 1, sizeof(*ad) ); return ad; -#else - return NULL; -#endif } Slapi_Attr *slapi_attr_init( Slapi_Attr *a, const char *type ) { -#ifdef LDAP_SLAPI const char *text; AttributeDescription *ad = NULL; @@ -2673,31 +2084,21 @@ Slapi_Attr *slapi_attr_init( Slapi_Attr *a, const char *type ) a->a_flags = 0; return a; -#else - return NULL; -#endif } void slapi_attr_free( Slapi_Attr **a ) { -#ifdef LDAP_SLAPI attr_free( *a ); *a = NULL; -#endif } Slapi_Attr *slapi_attr_dup( const Slapi_Attr *attr ) { -#ifdef LDAP_SLAPI return attr_dup( (Slapi_Attr *)attr ); -#else - return NULL; -#endif } int slapi_attr_add_value( Slapi_Attr *a, const Slapi_Value *v ) { -#ifdef LDAP_SLAPI struct berval nval; struct berval *nvalp; int rc; @@ -2730,9 +2131,6 @@ int slapi_attr_add_value( Slapi_Attr *a, const Slapi_Value *v ) } return rc; -#else - return -1; -#endif } int slapi_attr_type2plugin( const char *type, void **pi ) @@ -2744,7 +2142,6 @@ int slapi_attr_type2plugin( const char *type, void **pi ) int slapi_attr_get_type( const Slapi_Attr *attr, char **type ) { -#ifdef LDAP_SLAPI if ( attr == NULL ) { return LDAP_PARAM_ERROR; } @@ -2752,28 +2149,20 @@ int slapi_attr_get_type( const Slapi_Attr *attr, char **type ) *type = attr->a_desc->ad_cname.bv_val; return LDAP_SUCCESS; -#else - return -1; -#endif } int slapi_attr_get_oid_copy( const Slapi_Attr *attr, char **oidp ) { -#ifdef LDAP_SLAPI if ( attr == NULL ) { return LDAP_PARAM_ERROR; } *oidp = attr->a_desc->ad_type->sat_oid; return LDAP_SUCCESS; -#else - return -1; -#endif } int slapi_attr_value_cmp( const Slapi_Attr *a, const struct berval *v1, const struct berval *v2 ) { -#ifdef LDAP_SLAPI MatchingRule *mr; int ret; int rc; @@ -2787,14 +2176,10 @@ int slapi_attr_value_cmp( const Slapi_Attr *a, const struct berval *v1, const st return -1; return ( ret == 0 ) ? 0 : -1; -#else - return -1; -#endif } int slapi_attr_value_find( const Slapi_Attr *a, struct berval *v ) { -#ifdef LDAP_SLAPI MatchingRule *mr; struct berval *bv; int j; @@ -2816,13 +2201,11 @@ int slapi_attr_value_find( const Slapi_Attr *a, struct berval *v ) return 0; } } -#endif /* LDAP_SLAPI */ return -1; } int slapi_attr_type_cmp( const char *t1, const char *t2, int opt ) { -#ifdef LDAP_SLAPI AttributeDescription *a1 = NULL; AttributeDescription *a2 = NULL; const char *text; @@ -2856,72 +2239,44 @@ int slapi_attr_type_cmp( const char *t1, const char *t2, int opt ) } return ret; -#else - return -1; -#endif } int slapi_attr_types_equivalent( const char *t1, const char *t2 ) { -#ifdef LDAP_SLAPI return slapi_attr_type_cmp( t1, t2, SLAPI_TYPE_CMP_EXACT ); -#else - return -1; -#endif } int slapi_attr_first_value( Slapi_Attr *a, Slapi_Value **v ) { -#ifdef LDAP_SLAPI return slapi_valueset_first_value( &a->a_vals, v ); -#else - return -1; -#endif } int slapi_attr_next_value( Slapi_Attr *a, int hint, Slapi_Value **v ) { -#ifdef LDAP_SLAPI return slapi_valueset_next_value( &a->a_vals, hint, v ); -#else - return -1; -#endif } int slapi_attr_get_numvalues( const Slapi_Attr *a, int *numValues ) { -#ifdef LDAP_SLAPI *numValues = slapi_valueset_count( &a->a_vals ); return 0; -#else - return -1; -#endif } int slapi_attr_get_valueset( const Slapi_Attr *a, Slapi_ValueSet **vs ) { -#ifdef LDAP_SLAPI *vs = &((Slapi_Attr *)a)->a_vals; return 0; -#else - return -1; -#endif } int slapi_attr_get_bervals_copy( Slapi_Attr *a, struct berval ***vals ) { -#ifdef LDAP_SLAPI return slapi_attr_get_values( a, vals ); -#else - return -1; -#endif } char *slapi_attr_syntax_normalize( const char *s ) { -#ifdef LDAP_SLAPI AttributeDescription *ad = NULL; const char *text; @@ -2930,101 +2285,65 @@ char *slapi_attr_syntax_normalize( const char *s ) } return ad->ad_cname.bv_val; -#else - return -1; -#endif } Slapi_Value *slapi_value_new( void ) { -#ifdef LDAP_SLAPI struct berval *bv; bv = (struct berval *)slapi_ch_malloc( sizeof(*bv) ); return bv; -#else - return NULL; -#endif } Slapi_Value *slapi_value_new_berval(const struct berval *bval) { -#ifdef LDAP_SLAPI return ber_dupbv( NULL, (struct berval *)bval ); -#else - return NULL; -#endif } Slapi_Value *slapi_value_new_value(const Slapi_Value *v) { -#ifdef LDAP_SLAPI return slapi_value_new_berval( v ); -#else - return NULL; -#endif } Slapi_Value *slapi_value_new_string(const char *s) { -#ifdef LDAP_SLAPI struct berval bv; bv.bv_val = (char *)s; bv.bv_len = strlen( s ); return slapi_value_new_berval( &bv ); -#else - return NULL; -#endif } Slapi_Value *slapi_value_init(Slapi_Value *val) { -#ifdef LDAP_SLAPI val->bv_val = NULL; val->bv_len = 0; return val; -#else - return NULL; -#endif } Slapi_Value *slapi_value_init_berval(Slapi_Value *v, struct berval *bval) { -#ifdef LDAP_SLAPI return ber_dupbv( v, bval ); -#else - return NULL; -#endif } Slapi_Value *slapi_value_init_string(Slapi_Value *v, const char *s) { -#ifdef LDAP_SLAPI v->bv_val = slapi_ch_strdup( (char *)s ); v->bv_len = strlen( s ); return v; -#else - return NULL; -#endif } Slapi_Value *slapi_value_dup(const Slapi_Value *v) { -#ifdef LDAP_SLAPI return slapi_value_new_value( v ); -#else - return NULL; -#endif } void slapi_value_free(Slapi_Value **value) { -#ifdef LDAP_SLAPI if ( value == NULL ) { return; } @@ -3033,21 +2352,15 @@ void slapi_value_free(Slapi_Value **value) slapi_ch_free( (void **)&(*value)->bv_val ); slapi_ch_free( (void **)value ); } -#endif } const struct berval *slapi_value_get_berval( const Slapi_Value *value ) { -#ifdef LDAP_SLAPI return value; -#else - return NULL; -#endif } Slapi_Value *slapi_value_set_berval( Slapi_Value *value, const struct berval *bval ) { -#ifdef LDAP_SLAPI if ( value == NULL ) { return NULL; } @@ -3057,26 +2370,18 @@ Slapi_Value *slapi_value_set_berval( Slapi_Value *value, const struct berval *bv slapi_value_init_berval( value, (struct berval *)bval ); return value; -#else - return NULL; -#endif } Slapi_Value *slapi_value_set_value( Slapi_Value *value, const Slapi_Value *vfrom) { -#ifdef LDAP_SLAPI if ( value == NULL ) { return NULL; } return slapi_value_set_berval( value, vfrom ); -#else - return NULL; -#endif } Slapi_Value *slapi_value_set( Slapi_Value *value, void *val, unsigned long len) { -#ifdef LDAP_SLAPI if ( value == NULL ) { return NULL; } @@ -3088,141 +2393,97 @@ Slapi_Value *slapi_value_set( Slapi_Value *value, void *val, unsigned long len) AC_MEMCPY( value->bv_val, val, len ); return value; -#else - return NULL; -#endif } int slapi_value_set_string(Slapi_Value *value, const char *strVal) { -#ifdef LDAP_SLAPI if ( value == NULL ) { return -1; } slapi_value_set( value, (void *)strVal, strlen( strVal ) ); return 0; -#else - return NULL; -#endif } int slapi_value_set_int(Slapi_Value *value, int intVal) { -#ifdef LDAP_SLAPI char buf[64]; snprintf( buf, sizeof( buf ), "%d", intVal ); return slapi_value_set_string( value, buf ); -#else - return -1; -#endif } const char *slapi_value_get_string(const Slapi_Value *value) { -#ifdef LDAP_SLAPI if ( value == NULL ) return NULL; if ( value->bv_val == NULL ) return NULL; if ( !checkBVString( value ) ) return NULL; return value->bv_val; -#else - return NULL; -#endif } int slapi_value_get_int(const Slapi_Value *value) { -#ifdef LDAP_SLAPI if ( value == NULL ) return 0; if ( value->bv_val == NULL ) return 0; if ( !checkBVString( value ) ) return 0; return (int)strtol( value->bv_val, NULL, 10 ); -#else - return NULL; -#endif } unsigned int slapi_value_get_uint(const Slapi_Value *value) { -#ifdef LDAP_SLAPI if ( value == NULL ) return 0; if ( value->bv_val == NULL ) return 0; if ( !checkBVString( value ) ) return 0; return (unsigned int)strtoul( value->bv_val, NULL, 10 ); -#else - return NULL; -#endif } long slapi_value_get_long(const Slapi_Value *value) { -#ifdef LDAP_SLAPI if ( value == NULL ) return 0; if ( value->bv_val == NULL ) return 0; if ( !checkBVString( value ) ) return 0; return strtol( value->bv_val, NULL, 10 ); -#else - return NULL; -#endif } unsigned long slapi_value_get_ulong(const Slapi_Value *value) { -#ifdef LDAP_SLAPI if ( value == NULL ) return 0; if ( value->bv_val == NULL ) return 0; if ( !checkBVString( value ) ) return 0; return strtoul( value->bv_val, NULL, 10 ); -#else - return NULL; -#endif } size_t slapi_value_get_length(const Slapi_Value *value) { -#ifdef LDAP_SLAPI if ( value == NULL ) return 0; return (size_t) value->bv_len; -#else - return 0; -#endif } int slapi_value_compare(const Slapi_Attr *a, const Slapi_Value *v1, const Slapi_Value *v2) { -#ifdef LDAP_SLAPI return slapi_attr_value_cmp( a, v1, v2 ); -#else - return -1; -#endif } /* A ValueSet is a container for a BerVarray. */ Slapi_ValueSet *slapi_valueset_new( void ) { -#ifdef LDAP_SLAPI Slapi_ValueSet *vs; vs = (Slapi_ValueSet *)slapi_ch_malloc( sizeof( *vs ) ); *vs = NULL; return vs; -#else - return NULL; -#endif } void slapi_valueset_free(Slapi_ValueSet *vs) { -#ifdef LDAP_SLAPI if ( vs != NULL ) { BerVarray vp = *vs; @@ -3231,23 +2492,19 @@ void slapi_valueset_free(Slapi_ValueSet *vs) *vs = NULL; } -#endif } void slapi_valueset_init(Slapi_ValueSet *vs) { -#ifdef LDAP_SLAPI if ( vs != NULL && *vs == NULL ) { *vs = (Slapi_ValueSet)slapi_ch_calloc( 1, sizeof(struct berval) ); (*vs)->bv_val = NULL; (*vs)->bv_len = 0; } -#endif } void slapi_valueset_done(Slapi_ValueSet *vs) { -#ifdef LDAP_SLAPI BerVarray vp; if ( vs == NULL ) @@ -3258,31 +2515,23 @@ void slapi_valueset_done(Slapi_ValueSet *vs) slapi_ch_free( (void **)&vp->bv_val ); } /* but don't free *vs or vs */ -#endif } void slapi_valueset_add_value(Slapi_ValueSet *vs, const Slapi_Value *addval) { -#ifdef LDAP_SLAPI struct berval bv; ber_dupbv( &bv, (Slapi_Value *)addval ); ber_bvarray_add( vs, &bv ); -#endif } int slapi_valueset_first_value( Slapi_ValueSet *vs, Slapi_Value **v ) { -#ifdef LDAP_SLAPI return slapi_valueset_next_value( vs, 0, v ); -#else - return -1; -#endif } int slapi_valueset_next_value( Slapi_ValueSet *vs, int index, Slapi_Value **v) { -#ifdef LDAP_SLAPI int i; BerVarray vp; @@ -3297,14 +2546,12 @@ int slapi_valueset_next_value( Slapi_ValueSet *vs, int index, Slapi_Value **v) return index + 1; } } -#endif return -1; } int slapi_valueset_count( const Slapi_ValueSet *vs ) { -#ifdef LDAP_SLAPI int i; BerVarray vp; @@ -3317,30 +2564,21 @@ int slapi_valueset_count( const Slapi_ValueSet *vs ) ; return i; -#else - return 0; -#endif } void slapi_valueset_set_valueset(Slapi_ValueSet *vs1, const Slapi_ValueSet *vs2) { -#ifdef LDAP_SLAPI BerVarray vp; for ( vp = *vs2; vp->bv_val != NULL; vp++ ) { slapi_valueset_add_value( vs1, vp ); } -#endif } int slapi_access_allowed( Slapi_PBlock *pb, Slapi_Entry *e, char *attr, struct berval *val, int access ) { -#ifdef LDAP_SLAPI - Backend *be; - Connection *conn; - Operation *op; int rc; slap_access_t slap_access; AttributeDescription *ad = NULL; @@ -3381,40 +2619,26 @@ int slapi_access_allowed( Slapi_PBlock *pb, Slapi_Entry *e, char *attr, break; } - if ( slapi_pblock_get( pb, SLAPI_BACKEND, (void *)&be ) != 0 ) { - return LDAP_PARAM_ERROR; - } + assert( pb->pop != NULL ); - if ( slapi_pblock_get( pb, SLAPI_CONNECTION, (void *)&conn ) != 0 ) { - return LDAP_PARAM_ERROR; - } - - if ( slapi_pblock_get( pb, SLAPI_OPERATION, (void *)&op ) != 0 ) { - return LDAP_PARAM_ERROR; - } - - if ( access_allowed( op, e, ad, val, slap_access, NULL ) ) { + if ( access_allowed( pb->pop, e, ad, val, slap_access, NULL ) ) { return LDAP_SUCCESS; } return LDAP_INSUFFICIENT_ACCESS; -#else - return LDAP_UNWILLING_TO_PERFORM; -#endif } int slapi_acl_check_mods(Slapi_PBlock *pb, Slapi_Entry *e, LDAPMod **mods, char **errbuf) { -#ifdef LDAP_SLAPI Operation *op; int rc = LDAP_SUCCESS; - Modifications *ml, *mp; + Modifications *ml; if ( slapi_pblock_get( pb, SLAPI_OPERATION, (void *)&op ) != 0 ) { return LDAP_PARAM_ERROR; } - ml = slapi_int_ldapmods2modifications( mods ); + ml = slapi_int_ldapmods2modifications( mods, NULL ); if ( ml == NULL ) { return LDAP_OTHER; } @@ -3424,18 +2648,9 @@ int slapi_acl_check_mods(Slapi_PBlock *pb, Slapi_Entry *e, LDAPMod **mods, char } /* Careful when freeing the modlist because it has pointers into the mods array. */ - for ( ; ml != NULL; ml = mp ) { - mp = ml->sml_next; - - /* just free the containing array */ - slapi_ch_free( (void **)&ml->sml_values ); - slapi_ch_free( (void **)&ml ); - } + slapi_int_mods_free( ml ); return rc; -#else - return LDAP_UNWILLING_TO_PERFORM; -#endif } /* @@ -3446,9 +2661,11 @@ int slapi_acl_check_mods(Slapi_PBlock *pb, Slapi_Entry *e, LDAPMod **mods, char * * This function must also be called before slap_mods_check(). */ -LDAPMod **slapi_int_modifications2ldapmods(Modifications **pmodlist) +LDAPMod **slapi_int_modifications2ldapmods( + Modifications **pmodlist, + void *memctx +) { -#ifdef LDAP_SLAPI Modifications *ml, *modlist; LDAPMod **mods, *modp; int i, j; @@ -3458,10 +2675,10 @@ LDAPMod **slapi_int_modifications2ldapmods(Modifications **pmodlist) for( i = 0, ml = modlist; ml != NULL; i++, ml = ml->sml_next ) ; - mods = (LDAPMod **)ch_malloc( (i + 1) * sizeof(LDAPMod *) ); + mods = (LDAPMod **)slap_sl_malloc( (i + 1) * sizeof(LDAPMod *), memctx ); for( i = 0, ml = modlist; ml != NULL; ml = ml->sml_next ) { - mods[i] = (LDAPMod *)ch_malloc( sizeof(LDAPMod) ); + mods[i] = (LDAPMod *)slap_sl_malloc( sizeof(LDAPMod), memctx ); modp = mods[i]; modp->mod_op = ml->sml_op | LDAP_MOD_BVALUES; @@ -3472,11 +2689,12 @@ LDAPMod **slapi_int_modifications2ldapmods(Modifications **pmodlist) if ( ml->sml_values != NULL ) { for( j = 0; ml->sml_values[j].bv_val != NULL; j++ ) ; - modp->mod_bvalues = (struct berval **)ch_malloc( (j + 1) * - sizeof(struct berval *) ); + modp->mod_bvalues = (struct berval **)slap_sl_malloc( (j + 1) * + sizeof(struct berval *), memctx ); for( j = 0; ml->sml_values[j].bv_val != NULL; j++ ) { /* Take ownership of original values. */ - modp->mod_bvalues[j] = (struct berval *)ch_malloc( sizeof(struct berval) ); + modp->mod_bvalues[j] = (struct berval *)slap_sl_malloc( + sizeof(struct berval), memctx ); modp->mod_bvalues[j]->bv_len = ml->sml_values[j].bv_len; modp->mod_bvalues[j]->bv_val = ml->sml_values[j].bv_val; ml->sml_values[j].bv_len = 0; @@ -3495,9 +2713,6 @@ LDAPMod **slapi_int_modifications2ldapmods(Modifications **pmodlist) *pmodlist = NULL; return mods; -#else - return NULL; -#endif } /* @@ -3508,9 +2723,8 @@ LDAPMod **slapi_int_modifications2ldapmods(Modifications **pmodlist) * LDAPMods array; the latter MUST be freed with * slapi_int_free_ldapmods() (see below). */ -Modifications *slapi_int_ldapmods2modifications ( LDAPMod **mods ) +Modifications *slapi_int_ldapmods2modifications ( LDAPMod **mods, void *memctx ) { -#ifdef LDAP_SLAPI Modifications *modlist = NULL, **modtail; LDAPMod **modp; @@ -3532,7 +2746,7 @@ Modifications *slapi_int_ldapmods2modifications ( LDAPMod **mods ) if ( slap_str2ad( (*modp)->mod_type, &ad, &text ) != LDAP_SUCCESS ) continue; - mod = (Modifications *) ch_malloc( sizeof(Modifications) ); + mod = (Modifications *) slap_sl_malloc( sizeof(Modifications), memctx ); mod->sml_op = (*modp)->mod_op & (~LDAP_MOD_BVALUES); mod->sml_flags = 0; mod->sml_type.bv_val = (*modp)->mod_type; @@ -3551,7 +2765,7 @@ Modifications *slapi_int_ldapmods2modifications ( LDAPMod **mods ) if ( i == 0 ) { mod->sml_values = NULL; } else { - mod->sml_values = (BerVarray) ch_malloc( (i + 1) * sizeof(struct berval) ); + mod->sml_values = (BerVarray) slap_sl_malloc( (i + 1) * sizeof(struct berval), memctx ); /* NB: This implicitly trusts a plugin to return valid modifications. */ if ( (*modp)->mod_op & LDAP_MOD_BVALUES ) { @@ -3575,9 +2789,24 @@ Modifications *slapi_int_ldapmods2modifications ( LDAPMod **mods ) } return modlist; -#else - return NULL; -#endif +} + +void +slapi_int_mods_free( Modifications *ml ) +{ + Modifications *next; + + for ( ; ml != NULL; ml = next ) { + next = ml->sml_next; + + /* Don't free unnormalized values */ + if ( ml->sml_nvalues != NULL ) { + ber_bvarray_free( ml->sml_nvalues ); + ml->sml_nvalues = NULL; + } + slapi_ch_free((void **)&ml->sml_values); + slapi_ch_free((void **)&ml); + } } /* @@ -3586,9 +2815,9 @@ Modifications *slapi_int_ldapmods2modifications ( LDAPMod **mods ) * by slapi_int_ldapmods2modifications(). * */ -void slapi_int_free_ldapmods (LDAPMod **mods) +void +slapi_int_free_ldapmods ( LDAPMod **mods ) { -#ifdef LDAP_SLAPI int i, j; if (mods == NULL) @@ -3600,18 +2829,18 @@ void slapi_int_free_ldapmods (LDAPMod **mods) * Modification list. Do free the containing array. */ if ( mods[i]->mod_op & LDAP_MOD_BVALUES ) { - for ( j = 0; mods[i]->mod_values != NULL && mods[i]->mod_values[j] != NULL; j++ ) { - ch_free( mods[i]->mod_values[j] ); + if ( mods[i]->mod_bvalues != NULL ) { + for ( j = 0; mods[i]->mod_bvalues[j] != NULL; j++ ) + slapi_ch_free( (void **)&mods[i]->mod_bvalues[j] ); + slapi_ch_free( (void **)&mods[i]->mod_bvalues ); } - ch_free( mods[i]->mod_values ); } else { - ch_free( mods[i]->mod_values ); + slapi_ch_free( (void **)&mods[i]->mod_values ); } /* Don't free type, for same reasons. */ - ch_free( mods[i] ); + slapi_ch_free( (void **)&mods[i] ); } - ch_free( mods ); -#endif /* LDAP_SLAPI */ + slapi_ch_free( (void **)&mods ); } /* @@ -3631,7 +2860,6 @@ void slapi_int_free_ldapmods (LDAPMod **mods) */ int slapi_compute_add_evaluator(slapi_compute_callback_t function) { -#ifdef LDAP_SLAPI Slapi_PBlock *pPlugin = NULL; int rc; @@ -3666,9 +2894,6 @@ done: } return 0; -#else - return -1; -#endif /* LDAP_SLAPI */ } /* @@ -3676,7 +2901,6 @@ done: */ int slapi_compute_add_search_rewriter(slapi_search_rewrite_callback_t function) { -#ifdef LDAP_SLAPI Slapi_PBlock *pPlugin = NULL; int rc; @@ -3711,9 +2935,6 @@ done: } return 0; -#else - return -1; -#endif /* LDAP_SLAPI */ } /* @@ -3721,7 +2942,6 @@ done: */ int compute_evaluator(computed_attr_context *c, char *type, Slapi_Entry *e, slapi_compute_output_t outputfn) { -#ifdef LDAP_SLAPI int rc = 0; slapi_compute_callback_t *pGetPlugin, *tmpPlugin; @@ -3746,14 +2966,10 @@ int compute_evaluator(computed_attr_context *c, char *type, Slapi_Entry *e, slap slapi_ch_free( (void **)&tmpPlugin ); return rc; -#else - return 1; -#endif /* LDAP_SLAPI */ } int compute_rewrite_search_filter(Slapi_PBlock *pb) { -#ifdef LDAP_SLAPI Backend *be; int rc; @@ -3763,9 +2979,6 @@ int compute_rewrite_search_filter(Slapi_PBlock *pb) } return slapi_int_call_plugins( be, SLAPI_PLUGIN_COMPUTE_SEARCH_REWRITER_FN, pb ); -#else - return -1; -#endif /* LDAP_SLAPI */ } /* @@ -3774,7 +2987,6 @@ int compute_rewrite_search_filter(Slapi_PBlock *pb) */ int slapi_x_compute_get_pblock(computed_attr_context *c, Slapi_PBlock **pb) { -#ifdef LDAP_SLAPI if ( c == NULL ) return -1; @@ -3784,14 +2996,10 @@ int slapi_x_compute_get_pblock(computed_attr_context *c, Slapi_PBlock **pb) *pb = c->cac_pb; return 0; -#else - return -1; -#endif /* LDAP_SLAPI */ } Slapi_Mutex *slapi_new_mutex( void ) { -#ifdef LDAP_SLAPI Slapi_Mutex *m; m = (Slapi_Mutex *)slapi_ch_malloc( sizeof(*m) ); @@ -3801,40 +3009,28 @@ Slapi_Mutex *slapi_new_mutex( void ) } return m; -#else - return NULL; -#endif } void slapi_destroy_mutex( Slapi_Mutex *mutex ) { -#ifdef LDAP_SLAPI if ( mutex != NULL ) { ldap_pvt_thread_mutex_destroy( &mutex->mutex ); slapi_ch_free( (void **)&mutex); } -#endif } void slapi_lock_mutex( Slapi_Mutex *mutex ) { -#ifdef LDAP_SLAPI ldap_pvt_thread_mutex_lock( &mutex->mutex ); -#endif } int slapi_unlock_mutex( Slapi_Mutex *mutex ) { -#ifdef LDAP_SLAPI return ldap_pvt_thread_mutex_unlock( &mutex->mutex ); -#else - return -1; -#endif } Slapi_CondVar *slapi_new_condvar( Slapi_Mutex *mutex ) { -#ifdef LDAP_SLAPI Slapi_CondVar *cv; if ( mutex == NULL ) { @@ -3847,41 +3043,30 @@ Slapi_CondVar *slapi_new_condvar( Slapi_Mutex *mutex ) return NULL; } - /* XXX struct copy */ cv->mutex = mutex->mutex; return cv; -#else - return NULL; -#endif } void slapi_destroy_condvar( Slapi_CondVar *cvar ) { -#ifdef LDAP_SLAPI if ( cvar != NULL ) { ldap_pvt_thread_cond_destroy( &cvar->cond ); slapi_ch_free( (void **)&cvar ); } -#endif } int slapi_wait_condvar( Slapi_CondVar *cvar, struct timeval *timeout ) { -#ifdef LDAP_SLAPI if ( cvar == NULL ) { return -1; } return ldap_pvt_thread_cond_wait( &cvar->cond, &cvar->mutex ); -#else - return -1; -#endif } int slapi_notify_condvar( Slapi_CondVar *cvar, int notify_all ) { -#ifdef LDAP_SLAPI if ( cvar == NULL ) { return -1; } @@ -3891,9 +3076,6 @@ int slapi_notify_condvar( Slapi_CondVar *cvar, int notify_all ) } return ldap_pvt_thread_cond_signal( &cvar->cond ); -#else - return -1; -#endif } int slapi_int_access_allowed( Operation *op, @@ -3903,7 +3085,6 @@ int slapi_int_access_allowed( Operation *op, slap_access_t access, AccessControlState *state ) { -#ifdef LDAP_SLAPI int rc, slap_access = 0; slapi_acl_callback_t *pGetPlugin, *tmpPlugin; Slapi_PBlock *pb; @@ -3960,9 +3141,6 @@ int slapi_int_access_allowed( Operation *op, slapi_ch_free( (void **)&tmpPlugin ); return rc; -#else - return 1; -#endif /* LDAP_SLAPI */ } /* @@ -3970,7 +3148,6 @@ int slapi_int_access_allowed( Operation *op, */ int slapi_rdn2typeval( char *rdn, char **type, struct berval *bv ) { -#ifdef LDAP_SLAPI LDAPRDN lrdn; LDAPAVA *ava; int rc; @@ -3998,14 +3175,10 @@ int slapi_rdn2typeval( char *rdn, char **type, struct berval *bv ) ldap_rdnfree(lrdn); return 0; -#else - return -1; -#endif /* LDAP_SLAPI */ } char *slapi_dn_plus_rdn( const char *dn, const char *rdn ) { -#ifdef LDAP_SLAPI struct berval new_dn, parent_dn, newrdn; new_dn.bv_val = NULL; @@ -4019,35 +3192,26 @@ char *slapi_dn_plus_rdn( const char *dn, const char *rdn ) build_new_dn( &new_dn, &parent_dn, &newrdn, NULL ); return new_dn.bv_val; -#else - return NULL; -#endif /* LDAP_SLAPI */ } int slapi_entry_schema_check( Slapi_PBlock *pb, Slapi_Entry *e ) { -#ifdef LDAP_SLAPI Backend *be; const char *text; char textbuf[SLAP_TEXT_BUFLEN] = { '\0' }; size_t textlen = sizeof textbuf; - int rc; + int rc = LDAP_SUCCESS; - if ( slapi_pblock_get( pb, SLAPI_BACKEND, (void **)&be ) != 0 ) - return -1; - - rc = entry_schema_check( be, e, NULL, 0, - &text, textbuf, textlen ); + be = select_backend( &e->e_nname, 0, 0 ); + if ( be != NULL ) + rc = entry_schema_check( be, e, NULL, 0, + &text, textbuf, textlen ); return ( rc == LDAP_SUCCESS ) ? 0 : 1; -#else - return -1; -#endif /* LDAP_SLAPI */ } int slapi_entry_rdn_values_present( const Slapi_Entry *e ) { -#ifdef LDAP_SLAPI LDAPDN dn; int rc; int i = 0, match = 0; @@ -4073,14 +3237,10 @@ int slapi_entry_rdn_values_present( const Slapi_Entry *e ) ldap_dnfree( dn ); return ( i == match ); -#else - return 0; -#endif /* LDAP_SLAPI */ } int slapi_entry_add_rdn_values( Slapi_Entry *e ) { -#ifdef LDAP_SLAPI LDAPDN dn; int i, rc; @@ -4111,14 +3271,10 @@ int slapi_entry_add_rdn_values( Slapi_Entry *e ) ldap_dnfree( dn ); return LDAP_SUCCESS; -#else - return LDAP_OTHER; -#endif /* LDAP_SLAPI */ } const char *slapi_entry_get_uniqueid( const Slapi_Entry *e ) { -#ifdef LDAP_SLAPI Attribute *attr; attr = attr_find( e->e_attrs, slap_schema.si_ad_entryUUID ); @@ -4129,14 +3285,12 @@ const char *slapi_entry_get_uniqueid( const Slapi_Entry *e ) if ( attr->a_vals != NULL && attr->a_vals[0].bv_len != 0 ) { return slapi_value_get_string( &attr->a_vals[0] ); } -#endif /* LDAP_SLAPI */ return NULL; } void slapi_entry_set_uniqueid( Slapi_Entry *e, char *uniqueid ) { -#ifdef LDAP_SLAPI struct berval bv; attr_delete ( &e->e_attrs, slap_schema.si_ad_entryUUID ); @@ -4144,12 +3298,10 @@ void slapi_entry_set_uniqueid( Slapi_Entry *e, char *uniqueid ) bv.bv_val = uniqueid; bv.bv_len = strlen( uniqueid ); attr_merge_normalize_one( e, slap_schema.si_ad_entryUUID, &bv, NULL ); -#endif /* LDAP_SLAPI */ } LDAP *slapi_ldap_init( char *ldaphost, int ldapport, int secure, int shared ) { -#ifdef LDAP_SLAPI LDAP *ld; char *url; size_t size; @@ -4175,29 +3327,36 @@ LDAP *slapi_ldap_init( char *ldaphost, int ldapport, int secure, int shared ) slapi_ch_free_string( &url ); return ( rc == LDAP_SUCCESS ) ? ld : NULL; -#else - return NULL; -#endif /* LDAP_SLAPI */ } void slapi_ldap_unbind( LDAP *ld ) { -#ifdef LDAP_SLAPI ldap_unbind( ld ); -#endif /* LDAP_SLAPI */ } int slapi_x_backend_get_flags( const Slapi_Backend *be, unsigned long *flags ) { -#ifdef LDAP_SLAPI if ( be == NULL ) return LDAP_PARAM_ERROR; *flags = SLAP_DBFLAGS(be); return LDAP_SUCCESS; -#else - return -1; -#endif /* LDAP_SLAPI */ } +int +slapi_int_count_controls( LDAPControl **ctrls ) +{ + size_t i; + + if ( ctrls == NULL ) + return 0; + + for ( i = 0; ctrls[i] != NULL; i++ ) + ; + + return i; +} + +#endif /* LDAP_SLAPI */ +