From 48d1046a356a6eaf2803f447c2c3f07194d05116 Mon Sep 17 00:00:00 2001 From: Luke Howard Date: Mon, 25 Jul 2005 04:19:33 +0000 Subject: [PATCH] Make slapi_pblock directly overlaid on operation/connection/slapreply structures This removes a lot of copying. It's still a bit tricky where the internal slapd data types are different to those exposed via SLAPI (eg. modifications) or the internal values are not allocated on the heap (eg. controls). Some copying is necessary in these cases. --- servers/slapd/slapi/proto-slapi.h | 29 +- servers/slapd/slapi/slapi.h | 23 +- servers/slapd/slapi/slapi_ops.c | 800 ++++++-------------- servers/slapd/slapi/slapi_overlay.c | 533 ++++--------- servers/slapd/slapi/slapi_pblock.c | 977 ++++++++++++++++++++---- servers/slapd/slapi/slapi_utils.c | 1081 +++------------------------ 6 files changed, 1374 insertions(+), 2069 deletions(-) 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 }; - - op->o_ctrls = controls; - if ( op->o_ctrls == NULL ) { - return LDAP_SUCCESS; - } + int rc = 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; +static void +slapi_int_set_operation_dn( Slapi_PBlock *pb ) +{ + Backend *be; + Operation *op = pb->pop; - return LDAP_SUCCESS; + 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 ); + } } -void slapi_int_connection_destroy( Connection **pConn ) +void +slapi_int_connection_done_pb( Slapi_PBlock *pb ) { - Connection *conn = *pConn; + Connection *conn; Operation *op; - Slapi_PBlock *pb; - if ( conn == NULL ) { - return; + PBLOCK_ASSERT_INTOP( pb, 0 ); + + 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; } - op = (Operation *)conn->c_pending_ops.stqh_first; - pb = SLAPI_OPERATION_PBLOCK( op ); + if ( conn->c_sb != NULL ) { + ber_sockbuf_free( conn->c_sb ); + } - slap_graduate_commit_csn( op ); + slapi_ch_free( (void **)&pb->pop->o_callback ); + slapi_ch_free( (void **)&pb->pop ); + slapi_ch_free( (void **)&pb->pconn ); +} + +static int +slapi_int_func_internal_pb( Slapi_PBlock *pb, slap_operation_t which ) +{ + BI_op_bind **func; + SlapReply *rs = &pb->rs; - 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 ); + PBLOCK_ASSERT_INTOP( pb, 0 ); - if ( conn->c_sb != NULL ) { - ber_sockbuf_free( conn->c_sb ); + rs->sr_err = slapi_int_get_ctrls( pb ); + if ( rs->sr_err != LDAP_SUCCESS ) { + return rs->sr_err; } - slapi_pblock_set( pb, SLAPI_OPERATION, NULL ); - slapi_pblock_set( pb, SLAPI_CONNECTION, NULL ); + func = &pb->pop->o_bd->be_bind; + + rs->sr_err = func[which]( pb->pop, &pb->rs ); - slapi_ch_free( (void **)&op ); - slapi_ch_free( (void **)pConn ); + 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; - } - - op = conn->c_pending_ops.stqh_first; - rs.sr_err = frontendDB->be_delete( op, &rs ); + PBLOCK_ASSERT_INTOP( pb, LDAP_REQ_DELETE ); - 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 ); + + rs = &pb->rs; - if ( entry != NULL ) { - if ( dn != NULL ) { - rs.sr_err = LDAP_PARAM_ERROR; + 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; - goto cleanup; - } - - rs.sr_err = slapi_int_connection_init( pb, LDAP_REQ_ADD, &conn ); - if ( rs.sr_err != LDAP_SUCCESS ) { + 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; } - 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 ); - - 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; + 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 ( 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 ; - goto cleanup; - } + rs = &pb->rs; - rs.sr_err = slapi_int_connection_init( pb, LDAP_REQ_MODIFY, &conn ); - if ( rs.sr_err != LDAP_SUCCESS ) { + if ( pb->pop->orm_modlist == NULL ) { + rs->sr_err = LDAP_PARAM_ERROR; 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; + if ( BER_BVISEMPTY( &pb->pop->o_req_ndn ) ) { + 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 ); + slapi_int_func_internal_pb( pb, op_search ); - 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; +cleanup: + if ( free_filter ) { + slapi_filter_free( pb->pop->ors_filter, 1 ); + pb->pop->ors_filter = 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 ); - -cleanup: - slapi_pblock_set( pb, SLAPI_PLUGIN_INTOP_RESULT, (void *)rs.sr_err ); 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; - } - - /* - * 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 ); + rs->sr_err = LDAP_SUCCESS; - 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; + 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 ); } - 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,99 +343,800 @@ get( Slapi_PBlock *pb, int param, void **val ) break; } } - unLock( pb ); + return PBLOCK_SUCCESS; } +static char * +pblock_get_authtype( AuthorizationInformation *authz, int is_tls ) +{ + char *authType; + + 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 -set( Slapi_PBlock *pb, int param, void *val ) +pblock_set_default( Slapi_PBlock *pb, int param, void *value ) { -#if defined(LDAP_SLAPI) - int i, freeit; - int addcon = 0; slapi_pblock_class_t pbClass; + size_t i; - pbClass = getPBlockClass( param ); + 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; + for ( i = 0; i < pb->numParams; i++ ) { + if ( pb->curParams[i] == param ) { + break; + } } + if ( i >= pb->numParams ) { + pb->curParams[i] = param; + pb->numParams++; + } + + 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_CONN_DN: - case SLAPI_CONN_AUTHMETHOD: + 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: - freeit = 1; + *((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 ); + } + *((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: - freeit = 0; + rc = pblock_get_default( pb, param, value ); break; } - for( i = 0; i < pb->numParams; i++ ) { - if ( pb->curParams[i] == param ) { + + 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; - if ( i >= pb->numParams ) { - pb->curParams[i] = param; - pb->numParams++; + 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; } - if ( addcon ) { - LDAPControl **ctrls = pb->curVals[i]; - int j; + 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 ( ctrls ) { - for (j=0; ctrls[j]; j++); - ctrls = ch_realloc( ctrls, (j+2)*sizeof(LDAPControl *) ); + 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 { - ctrls = ch_malloc( 2 * sizeof(LDAPControl *) ); - j = 0; + rc = PBLOCK_ERROR; } - ctrls[j] = val; - ctrls[j+1] = NULL; - pb->curVals[i] = ctrls; - } else { - if ( freeit ) ch_free( pb->curVals[i] ); - pb->curVals[i] = val; + 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; } - unLock( pb ); - return PBLOCK_SUCCESS; -#endif /* LDAP_SLAPI */ - return PBLOCK_ERROR; -} + pblock_unlock( pb ); -static void -clearPB( Slapi_PBlock *pb ) -{ - pb->numParams = 1; + return rc; } static void -checkParams( Slapi_PBlock *pb, int flag ) +pblock_clear( Slapi_PBlock *pb ) { - pb->ckParams = flag; + pb->numParams = 1; } 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; - - get( pb, SLAPI_CONN_DN,(void **)&str ); - if ( str != NULL ) { - ch_free( str ); - str = NULL; - } + LDAPControl **controls = NULL; - get( pb, SLAPI_CONN_AUTHMETHOD, (void **)&str ); - if ( str != NULL ) { - ch_free( str ); - str = NULL; - } + assert( pb != NULL ); - get( pb, SLAPI_RESULT_TEXT, (void **)&str ); - if ( str != NULL ) { - ch_free( str ); - str = 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 ); - get( pb, SLAPI_RESULT_MATCHED, (void **)&str ); - if ( str != NULL ) { - ch_free( str ); - str = NULL; + pblock_get_default( pb, SLAPI_SEARCH_ATTRS, (void **)&attrs ); + + if ( attrs != NULL ) + pb->pop->o_tmpfree( attrs, pb->pop->o_tmpmemctx ); } - 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; - } - - 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 ); + 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 ); } - 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; - 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; + send_ldap_result( pb->pop, rs ); } - - 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( pOp, &rs ); - - if ( rs.sr_ref != NULL ) - slapi_ch_free( (void **)&rs.sr_ref ); + rc = send_search_reference( pb->pop, &rs ); - 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 ) { - return; - } - - if ( entries == NULL ) { + if ( nEnt == 0 || 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 ) +int slapi_is_connection_ssl( Slapi_PBlock *pb, int *isSSL ) { - 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 ); + Connection *conn = NULL; + int rc; - /* 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); + rc = slapi_pblock_get( pb, SLAPI_CONNECTION, &conn ); + if ( rc != PBLOCK_SUCCESS || conn == NULL ) { + return LDAP_OTHER; } - /* 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; - - 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; - } - - if ( slapi_pblock_get( pb, SLAPI_CONNECTION, (void *)&conn ) != 0 ) { - return LDAP_PARAM_ERROR; - } + assert( pb->pop != NULL ); - 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; - - if ( slapi_pblock_get( pb, SLAPI_BACKEND, (void **)&be ) != 0 ) - return -1; + int rc = LDAP_SUCCESS; - 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 */ + -- 2.39.5