2 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
4 * Copyright 2002-2011 The OpenLDAP Foundation.
5 * Portions Copyright 1997,2002-2003 IBM Corporation.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted only as authorized by the OpenLDAP
12 * A copy of this license is available in the file LICENSE in the
13 * top-level directory of the distribution or, alternatively, at
14 * <http://www.OpenLDAP.org/license.html>.
17 * This work was initially developed by IBM Corporation for use in
18 * IBM products and subsequently ported to OpenLDAP Software by
19 * Steve Omrani. Additional significant contributors include:
25 #include <ac/string.h>
26 #include <ac/stdarg.h>
28 #include <ac/unistd.h>
36 static struct Listener slapi_listener = {
42 slapi_int_dup_controls( LDAPControl **controls )
47 if ( controls == NULL )
50 for ( i = 0; controls[i] != NULL; i++ )
53 c = (LDAPControl **) slapi_ch_calloc( i + 1, sizeof(LDAPControl *) );
55 for ( i = 0; controls[i] != NULL; i++ ) {
56 c[i] = slapi_dup_control( controls[i] );
67 Slapi_PBlock *pb = SLAPI_OPERATION_PBLOCK( op );
68 plugin_result_callback prc = NULL;
69 void *callback_data = NULL;
70 LDAPControl **ctrls = NULL;
74 slapi_pblock_get( pb, SLAPI_X_INTOP_RESULT_CALLBACK, (void **)&prc );
75 slapi_pblock_get( pb, SLAPI_X_INTOP_CALLBACK_DATA, &callback_data );
77 /* we need to duplicate controls because they might go out of scope */
78 ctrls = slapi_int_dup_controls( rs->sr_ctrls );
79 slapi_pblock_set( pb, SLAPI_RESCONTROLS, ctrls );
82 (*prc)( rs->sr_err, callback_data );
89 slapi_int_search_entry(
93 Slapi_PBlock *pb = SLAPI_OPERATION_PBLOCK( op );
94 plugin_search_entry_callback psec = NULL;
95 void *callback_data = NULL;
96 int rc = LDAP_SUCCESS;
100 slapi_pblock_get( pb, SLAPI_X_INTOP_SEARCH_ENTRY_CALLBACK, (void **)&psec );
101 slapi_pblock_get( pb, SLAPI_X_INTOP_CALLBACK_DATA, &callback_data );
103 if ( psec != NULL ) {
104 rc = (*psec)( rs->sr_entry, callback_data );
111 slapi_int_search_reference(
115 int i, rc = LDAP_SUCCESS;
116 plugin_referral_entry_callback prec = NULL;
117 void *callback_data = NULL;
118 Slapi_PBlock *pb = SLAPI_OPERATION_PBLOCK( op );
120 assert( pb != NULL );
122 slapi_pblock_get( pb, SLAPI_X_INTOP_REFERRAL_ENTRY_CALLBACK, (void **)&prec );
123 slapi_pblock_get( pb, SLAPI_X_INTOP_CALLBACK_DATA, &callback_data );
125 if ( prec != NULL ) {
126 for ( i = 0; rs->sr_ref[i].bv_val != NULL; i++ ) {
127 rc = (*prec)( rs->sr_ref[i].bv_val, callback_data );
128 if ( rc != LDAP_SUCCESS ) {
138 slapi_int_response( Slapi_Operation *op, SlapReply *rs )
142 switch ( rs->sr_type ) {
144 rc = slapi_int_result( op, rs );
147 rc = slapi_int_search_entry( op, rs );
150 rc = slapi_int_search_reference( op, rs );
157 assert( rc != SLAP_CB_CONTINUE ); /* never try to send a wire response */
163 slapi_int_get_ctrls( Slapi_PBlock *pb )
166 int rc = LDAP_SUCCESS;
168 if ( pb->pb_op->o_ctrls != NULL ) {
169 for ( c = pb->pb_op->o_ctrls; *c != NULL; c++ ) {
170 rc = slap_parse_ctrl( pb->pb_op, pb->pb_rs, *c, &pb->pb_rs->sr_text );
171 if ( rc != LDAP_SUCCESS )
180 slapi_int_connection_init_pb( Slapi_PBlock *pb, ber_tag_t tag )
184 ber_len_t max = sockbuf_max_incoming;
186 conn = (Connection *) slapi_ch_calloc( 1, sizeof(Connection) );
188 LDAP_STAILQ_INIT( &conn->c_pending_ops );
190 op = (Operation *) slapi_ch_calloc( 1, sizeof(OperationBuffer) );
191 op->o_hdr = &((OperationBuffer *) op)->ob_hdr;
192 op->o_controls = ((OperationBuffer *) op)->ob_controls;
194 op->o_callback = (slap_callback *) slapi_ch_calloc( 1, sizeof(slap_callback) );
195 op->o_callback->sc_response = slapi_int_response;
196 op->o_callback->sc_cleanup = NULL;
197 op->o_callback->sc_private = pb;
198 op->o_callback->sc_next = NULL;
200 conn->c_pending_ops.stqh_first = op;
202 /* connection object authorization information */
203 conn->c_authtype = LDAP_AUTH_NONE;
204 BER_BVZERO( &conn->c_authmech );
205 BER_BVZERO( &conn->c_dn );
206 BER_BVZERO( &conn->c_ndn );
208 conn->c_listener = &slapi_listener;
209 ber_dupbv( &conn->c_peer_domain, (struct berval *)&slap_unknown_bv );
210 ber_dupbv( &conn->c_peer_name, (struct berval *)&slap_unknown_bv );
212 LDAP_STAILQ_INIT( &conn->c_ops );
214 BER_BVZERO( &conn->c_sasl_bind_mech );
215 conn->c_sasl_authctx = NULL;
216 conn->c_sasl_sockctx = NULL;
217 conn->c_sasl_extra = NULL;
219 conn->c_sb = ber_sockbuf_alloc();
221 ber_sockbuf_ctrl( conn->c_sb, LBER_SB_OPT_SET_MAX_INCOMING, &max );
223 conn->c_currentber = NULL;
225 /* should check status of thread calls */
226 ldap_pvt_thread_mutex_init( &conn->c_mutex );
227 ldap_pvt_thread_mutex_init( &conn->c_write1_mutex );
228 ldap_pvt_thread_mutex_init( &conn->c_write2_mutex );
229 ldap_pvt_thread_cond_init( &conn->c_write1_cv );
230 ldap_pvt_thread_cond_init( &conn->c_write2_cv );
232 ldap_pvt_thread_mutex_lock( &conn->c_mutex );
234 conn->c_n_ops_received = 0;
235 conn->c_n_ops_executing = 0;
236 conn->c_n_ops_pending = 0;
237 conn->c_n_ops_completed = 0;
243 conn->c_protocol = LDAP_VERSION3;
245 conn->c_activitytime = conn->c_starttime = slap_get_time();
248 * A real connection ID is required, because syncrepl associates
249 * pending CSNs with unique ( connection, operation ) tuples.
250 * Setting a fake connection ID will cause slap_get_commit_csn()
251 * to return a stale value.
253 connection_assign_nextid( conn );
255 conn->c_conn_state = 0x01; /* SLAP_C_ACTIVE */
256 conn->c_struct_state = 0x02; /* SLAP_C_USED */
258 conn->c_ssf = conn->c_transport_ssf = local_ssf;
261 backend_connection_init( conn );
263 conn->c_send_ldap_result = slap_send_ldap_result;
264 conn->c_send_search_entry = slap_send_search_entry;
265 conn->c_send_ldap_extended = slap_send_ldap_extended;
266 conn->c_send_search_reference = slap_send_search_reference;
268 /* operation object */
270 op->o_protocol = LDAP_VERSION3;
271 BER_BVZERO( &op->o_authmech );
272 op->o_time = slap_get_time();
273 op->o_do_not_cache = 1;
274 op->o_threadctx = ldap_pvt_thread_pool_context();
275 op->o_tmpmemctx = NULL;
276 op->o_tmpmfuncs = &ch_mfuncs;
278 op->o_connid = conn->c_connid;
279 op->o_bd = frontendDB;
282 slapi_int_create_object_extensions( SLAPI_X_EXT_OPERATION, op );
283 slapi_int_create_object_extensions( SLAPI_X_EXT_CONNECTION, conn );
285 pb->pb_rs = (SlapReply *)slapi_ch_calloc( 1, sizeof(SlapReply) );
290 ldap_pvt_thread_mutex_unlock( &conn->c_mutex );
294 slapi_int_set_operation_dn( Slapi_PBlock *pb )
297 Operation *op = pb->pb_op;
299 if ( BER_BVISNULL( &op->o_ndn ) ) {
301 be = select_backend( &op->o_req_ndn, 1 );
303 ber_dupbv( &op->o_dn, &be->be_rootdn );
304 ber_dupbv( &op->o_ndn, &be->be_rootndn );
310 slapi_int_connection_done_pb( Slapi_PBlock *pb )
315 PBLOCK_ASSERT_INTOP( pb, 0 );
320 /* free allocated DNs */
321 if ( !BER_BVISNULL( &op->o_dn ) )
322 op->o_tmpfree( op->o_dn.bv_val, op->o_tmpmemctx );
323 if ( !BER_BVISNULL( &op->o_ndn ) )
324 op->o_tmpfree( op->o_ndn.bv_val, op->o_tmpmemctx );
326 if ( !BER_BVISNULL( &op->o_req_dn ) )
327 op->o_tmpfree( op->o_req_dn.bv_val, op->o_tmpmemctx );
328 if ( !BER_BVISNULL( &op->o_req_ndn ) )
329 op->o_tmpfree( op->o_req_ndn.bv_val, op->o_tmpmemctx );
331 switch ( op->o_tag ) {
332 case LDAP_REQ_MODRDN:
333 if ( !BER_BVISNULL( &op->orr_newrdn ))
334 op->o_tmpfree( op->orr_newrdn.bv_val, op->o_tmpmemctx );
335 if ( !BER_BVISNULL( &op->orr_nnewrdn ))
336 op->o_tmpfree( op->orr_nnewrdn.bv_val, op->o_tmpmemctx );
337 if ( op->orr_newSup != NULL ) {
338 assert( !BER_BVISNULL( op->orr_newSup ) );
339 op->o_tmpfree( op->orr_newSup->bv_val, op->o_tmpmemctx );
340 op->o_tmpfree( op->orr_newSup, op->o_tmpmemctx );
342 if ( op->orr_nnewSup != NULL ) {
343 assert( !BER_BVISNULL( op->orr_nnewSup ) );
344 op->o_tmpfree( op->orr_nnewSup->bv_val, op->o_tmpmemctx );
345 op->o_tmpfree( op->orr_nnewSup, op->o_tmpmemctx );
347 slap_mods_free( op->orr_modlist, 1 );
350 slap_mods_free( op->ora_modlist, 0 );
352 case LDAP_REQ_MODIFY:
353 slap_mods_free( op->orm_modlist, 1 );
355 case LDAP_REQ_SEARCH:
356 if ( op->ors_attrs != NULL ) {
357 op->o_tmpfree( op->ors_attrs, op->o_tmpmemctx );
358 op->ors_attrs = NULL;
365 slapi_ch_free_string( &conn->c_authmech.bv_val );
366 slapi_ch_free_string( &conn->c_dn.bv_val );
367 slapi_ch_free_string( &conn->c_ndn.bv_val );
368 slapi_ch_free_string( &conn->c_peer_domain.bv_val );
369 slapi_ch_free_string( &conn->c_peer_name.bv_val );
371 if ( conn->c_sb != NULL ) {
372 ber_sockbuf_free( conn->c_sb );
375 slapi_int_free_object_extensions( SLAPI_X_EXT_OPERATION, op );
376 slapi_int_free_object_extensions( SLAPI_X_EXT_CONNECTION, conn );
378 slapi_ch_free( (void **)&pb->pb_op->o_callback );
379 slapi_ch_free( (void **)&pb->pb_op );
380 slapi_ch_free( (void **)&pb->pb_conn );
381 slapi_ch_free( (void **)&pb->pb_rs );
385 slapi_int_func_internal_pb( Slapi_PBlock *pb, slap_operation_t which )
388 SlapReply *rs = pb->pb_rs;
391 PBLOCK_ASSERT_INTOP( pb, 0 );
393 rc = slapi_int_get_ctrls( pb );
394 if ( rc != LDAP_SUCCESS ) {
399 pb->pb_op->o_bd = frontendDB;
400 func = &frontendDB->be_bind;
402 return func[which]( pb->pb_op, pb->pb_rs );
406 slapi_delete_internal_pb( Slapi_PBlock *pb )
412 PBLOCK_ASSERT_INTOP( pb, LDAP_REQ_DELETE );
414 slapi_int_func_internal_pb( pb, op_delete );
420 slapi_add_internal_pb( Slapi_PBlock *pb )
423 Slapi_Entry *entry_orig = NULL;
431 PBLOCK_ASSERT_INTOP( pb, LDAP_REQ_ADD );
435 entry_orig = pb->pb_op->ora_e;
436 pb->pb_op->ora_e = NULL;
439 * The caller can specify a new entry, or a target DN and set
440 * of modifications, but not both.
442 if ( entry_orig != NULL ) {
443 if ( pb->pb_op->ora_modlist != NULL || !BER_BVISNULL( &pb->pb_op->o_req_ndn )) {
444 rs->sr_err = LDAP_PARAM_ERROR;
448 assert( BER_BVISNULL( &pb->pb_op->o_req_dn ) ); /* shouldn't get set */
449 ber_dupbv( &pb->pb_op->o_req_dn, &entry_orig->e_name );
450 ber_dupbv( &pb->pb_op->o_req_ndn, &entry_orig->e_nname );
451 } else if ( pb->pb_op->ora_modlist == NULL || BER_BVISNULL( &pb->pb_op->o_req_ndn )) {
452 rs->sr_err = LDAP_PARAM_ERROR;
456 pb->pb_op->ora_e = (Entry *)slapi_ch_calloc( 1, sizeof(Entry) );
457 ber_dupbv( &pb->pb_op->ora_e->e_name, &pb->pb_op->o_req_dn );
458 ber_dupbv( &pb->pb_op->ora_e->e_nname, &pb->pb_op->o_req_ndn );
460 if ( entry_orig != NULL ) {
461 assert( pb->pb_op->ora_modlist == NULL );
463 rs->sr_err = slap_entry2mods( entry_orig, &pb->pb_op->ora_modlist,
464 &rs->sr_text, pb->pb_textbuf, sizeof( pb->pb_textbuf ) );
465 if ( rs->sr_err != LDAP_SUCCESS ) {
469 assert( pb->pb_op->ora_modlist != NULL );
472 rs->sr_err = slap_mods_check( pb->pb_op, pb->pb_op->ora_modlist, &rs->sr_text,
473 pb->pb_textbuf, sizeof( pb->pb_textbuf ), NULL );
474 if ( rs->sr_err != LDAP_SUCCESS ) {
478 /* Duplicate the values, because we may call slapi_entry_free() */
479 rs->sr_err = slap_mods2entry( pb->pb_op->ora_modlist, &pb->pb_op->ora_e,
480 1, 0, &rs->sr_text, pb->pb_textbuf, sizeof( pb->pb_textbuf ) );
481 if ( rs->sr_err != LDAP_SUCCESS ) {
485 oex.oe.oe_key = (void *)do_add;
487 LDAP_SLIST_INSERT_HEAD(&pb->pb_op->o_extra, &oex.oe, oe_next);
488 rc = slapi_int_func_internal_pb( pb, op_add );
489 LDAP_SLIST_REMOVE(&pb->pb_op->o_extra, &oex.oe, OpExtra, oe_next);
492 if ( pb->pb_op->ora_e != NULL && oex.oe_db != NULL ) {
493 BackendDB *bd = pb->pb_op->o_bd;
495 pb->pb_op->o_bd = oex.oe_db;
496 be_entry_release_w( pb->pb_op, pb->pb_op->ora_e );
497 pb->pb_op->ora_e = NULL;
498 pb->pb_op->o_bd = bd;
504 if ( pb->pb_op->ora_e != NULL ) {
505 slapi_entry_free( pb->pb_op->ora_e );
506 pb->pb_op->ora_e = NULL;
508 if ( entry_orig != NULL ) {
509 pb->pb_op->ora_e = entry_orig;
510 slap_mods_free( pb->pb_op->ora_modlist, 1 );
511 pb->pb_op->ora_modlist = NULL;
518 slapi_modrdn_internal_pb( Slapi_PBlock *pb )
524 PBLOCK_ASSERT_INTOP( pb, LDAP_REQ_MODRDN );
526 if ( BER_BVISEMPTY( &pb->pb_op->o_req_ndn ) ) {
527 pb->pb_rs->sr_err = LDAP_UNWILLING_TO_PERFORM;
531 slapi_int_func_internal_pb( pb, op_modrdn );
539 slapi_modify_internal_pb( Slapi_PBlock *pb )
547 PBLOCK_ASSERT_INTOP( pb, LDAP_REQ_MODIFY );
551 if ( pb->pb_op->orm_modlist == NULL ) {
552 rs->sr_err = LDAP_PARAM_ERROR;
556 if ( BER_BVISEMPTY( &pb->pb_op->o_req_ndn ) ) {
557 rs->sr_err = LDAP_UNWILLING_TO_PERFORM;
561 rs->sr_err = slap_mods_check( pb->pb_op, pb->pb_op->orm_modlist,
562 &rs->sr_text, pb->pb_textbuf, sizeof( pb->pb_textbuf ), NULL );
563 if ( rs->sr_err != LDAP_SUCCESS ) {
567 slapi_int_func_internal_pb( pb, op_modify );
575 slapi_int_search_entry_callback( Slapi_Entry *entry, void *callback_data )
577 int nentries = 0, i = 0;
578 Slapi_Entry **head = NULL, **tp;
579 Slapi_PBlock *pb = (Slapi_PBlock *)callback_data;
581 PBLOCK_ASSERT_INTOP( pb, LDAP_REQ_SEARCH );
583 entry = slapi_entry_dup( entry );
584 if ( entry == NULL ) {
585 return LDAP_NO_MEMORY;
588 slapi_pblock_get( pb, SLAPI_NENTRIES, &nentries );
589 slapi_pblock_get( pb, SLAPI_PLUGIN_INTOP_SEARCH_ENTRIES, &head );
592 if ( nentries == 0 ) {
593 tp = (Slapi_Entry **)slapi_ch_malloc( 2 * sizeof(Slapi_Entry *) );
595 slapi_entry_free( entry );
596 return LDAP_NO_MEMORY;
601 tp = (Slapi_Entry **)slapi_ch_realloc( (char *)head,
602 sizeof(Slapi_Entry *) * ( i + 1 ) );
604 slapi_entry_free( entry );
605 return LDAP_NO_MEMORY;
611 slapi_pblock_set( pb, SLAPI_PLUGIN_INTOP_SEARCH_ENTRIES, (void *)tp );
612 slapi_pblock_set( pb, SLAPI_NENTRIES, (void *)&i );
618 slapi_search_internal_pb( Slapi_PBlock *pb )
620 return slapi_search_internal_callback_pb( pb,
623 slapi_int_search_entry_callback,
628 slapi_search_internal_callback_pb( Slapi_PBlock *pb,
630 plugin_result_callback prc,
631 plugin_search_entry_callback psec,
632 plugin_referral_entry_callback prec )
641 PBLOCK_ASSERT_INTOP( pb, LDAP_REQ_SEARCH );
645 /* search callback and arguments */
646 slapi_pblock_set( pb, SLAPI_X_INTOP_RESULT_CALLBACK, (void *)prc );
647 slapi_pblock_set( pb, SLAPI_X_INTOP_SEARCH_ENTRY_CALLBACK, (void *)psec );
648 slapi_pblock_set( pb, SLAPI_X_INTOP_REFERRAL_ENTRY_CALLBACK, (void *)prec );
649 slapi_pblock_set( pb, SLAPI_X_INTOP_CALLBACK_DATA, (void *)callback_data );
651 if ( BER_BVISEMPTY( &pb->pb_op->ors_filterstr )) {
652 rs->sr_err = LDAP_PARAM_ERROR;
656 if ( pb->pb_op->ors_filter == NULL ) {
657 pb->pb_op->ors_filter = slapi_str2filter( pb->pb_op->ors_filterstr.bv_val );
658 if ( pb->pb_op->ors_filter == NULL ) {
659 rs->sr_err = LDAP_PROTOCOL_ERROR;
666 slapi_int_func_internal_pb( pb, op_search );
670 slapi_filter_free( pb->pb_op->ors_filter, 1 );
671 pb->pb_op->ors_filter = NULL;
674 slapi_pblock_delete_param( pb, SLAPI_X_INTOP_RESULT_CALLBACK );
675 slapi_pblock_delete_param( pb, SLAPI_X_INTOP_SEARCH_ENTRY_CALLBACK );
676 slapi_pblock_delete_param( pb, SLAPI_X_INTOP_REFERRAL_ENTRY_CALLBACK );
677 slapi_pblock_delete_param( pb, SLAPI_X_INTOP_CALLBACK_DATA );
682 /* Wrappers for old API */
685 slapi_search_internal_set_pb( Slapi_PBlock *pb,
691 LDAPControl **controls,
692 const char *uniqueid,
693 Slapi_ComponentId *plugin_identity,
694 int operation_flags )
696 int no_limit = SLAP_NO_LIMIT;
697 int deref = LDAP_DEREF_NEVER;
699 slapi_int_connection_init_pb( pb, LDAP_REQ_SEARCH );
700 slapi_pblock_set( pb, SLAPI_SEARCH_TARGET, (void *)base );
701 slapi_pblock_set( pb, SLAPI_SEARCH_SCOPE, (void *)&scope );
702 slapi_pblock_set( pb, SLAPI_SEARCH_FILTER, (void *)0 );
703 slapi_pblock_set( pb, SLAPI_SEARCH_STRFILTER, (void *)filter );
704 slapi_pblock_set( pb, SLAPI_SEARCH_ATTRS, (void *)attrs );
705 slapi_pblock_set( pb, SLAPI_SEARCH_ATTRSONLY, (void *)&attrsonly );
706 slapi_pblock_set( pb, SLAPI_REQCONTROLS, (void *)controls );
707 slapi_pblock_set( pb, SLAPI_TARGET_UNIQUEID, (void *)uniqueid );
708 slapi_pblock_set( pb, SLAPI_PLUGIN_IDENTITY, (void *)plugin_identity );
709 slapi_pblock_set( pb, SLAPI_X_INTOP_FLAGS, (void *)&operation_flags );
710 slapi_pblock_set( pb, SLAPI_SEARCH_DEREF, (void *)&deref );
711 slapi_pblock_set( pb, SLAPI_SEARCH_SIZELIMIT, (void *)&no_limit );
712 slapi_pblock_set( pb, SLAPI_SEARCH_TIMELIMIT, (void *)&no_limit );
714 slapi_int_set_operation_dn( pb );
718 slapi_search_internal(
722 LDAPControl **controls,
728 pb = slapi_pblock_new();
730 slapi_search_internal_set_pb( pb, ldn, scope, filStr,
732 controls, NULL, NULL, 0 );
734 slapi_search_internal_pb( pb );
740 slapi_modify_internal_set_pb( Slapi_PBlock *pb,
743 LDAPControl **controls,
744 const char *uniqueid,
745 Slapi_ComponentId *plugin_identity,
746 int operation_flags )
748 slapi_int_connection_init_pb( pb, LDAP_REQ_MODIFY );
749 slapi_pblock_set( pb, SLAPI_MODIFY_TARGET, (void *)dn );
750 slapi_pblock_set( pb, SLAPI_MODIFY_MODS, (void *)mods );
751 slapi_pblock_set( pb, SLAPI_REQCONTROLS, (void *)controls );
752 slapi_pblock_set( pb, SLAPI_TARGET_UNIQUEID, (void *)uniqueid );
753 slapi_pblock_set( pb, SLAPI_PLUGIN_IDENTITY, (void *)plugin_identity );
754 slapi_pblock_set( pb, SLAPI_X_INTOP_FLAGS, (void *)&operation_flags );
755 slapi_int_set_operation_dn( pb );
758 /* Function : slapi_modify_internal
760 * Description: Plugin functions call this routine to modify an entry
761 * in the backend directly
762 * Return values : LDAP_SUCCESS
766 * LDAP_UNWILLING_TO_PERFORM
769 slapi_modify_internal(
772 LDAPControl **controls,
777 pb = slapi_pblock_new();
779 slapi_modify_internal_set_pb( pb, ldn, mods, controls, NULL, NULL, 0 );
780 slapi_pblock_set( pb, SLAPI_LOG_OPERATION, (void *)&log_change );
781 slapi_modify_internal_pb( pb );
787 slapi_add_internal_set_pb( Slapi_PBlock *pb,
790 LDAPControl **controls,
791 Slapi_ComponentId *plugin_identity,
792 int operation_flags )
794 slapi_int_connection_init_pb( pb, LDAP_REQ_ADD );
795 slapi_pblock_set( pb, SLAPI_ADD_TARGET, (void *)dn );
796 slapi_pblock_set( pb, SLAPI_MODIFY_MODS, (void *)attrs );
797 slapi_pblock_set( pb, SLAPI_REQCONTROLS, (void *)controls );
798 slapi_pblock_set( pb, SLAPI_PLUGIN_IDENTITY, (void *)plugin_identity );
799 slapi_pblock_set( pb, SLAPI_X_INTOP_FLAGS, (void *)&operation_flags );
800 slapi_int_set_operation_dn( pb );
809 LDAPControl **controls,
814 pb = slapi_pblock_new();
816 slapi_add_internal_set_pb( pb, dn, attrs, controls, NULL, 0);
817 slapi_pblock_set( pb, SLAPI_LOG_OPERATION, (void *)&log_change );
818 slapi_add_internal_pb( pb );
824 slapi_add_entry_internal_set_pb( Slapi_PBlock *pb,
826 LDAPControl **controls,
827 Slapi_ComponentId *plugin_identity,
828 int operation_flags )
830 slapi_int_connection_init_pb( pb, LDAP_REQ_ADD );
831 slapi_pblock_set( pb, SLAPI_ADD_ENTRY, (void *)e );
832 slapi_pblock_set( pb, SLAPI_REQCONTROLS, (void *)controls );
833 slapi_pblock_set( pb, SLAPI_PLUGIN_IDENTITY, (void *)plugin_identity );
834 slapi_pblock_set( pb, SLAPI_X_INTOP_FLAGS, (void *)&operation_flags );
835 slapi_int_set_operation_dn( pb );
839 slapi_add_entry_internal(
841 LDAPControl **controls,
846 pb = slapi_pblock_new();
848 slapi_add_entry_internal_set_pb( pb, e, controls, NULL, 0 );
849 slapi_pblock_set( pb, SLAPI_LOG_OPERATION, (void *)&log_change );
850 slapi_add_internal_pb( pb );
856 slapi_rename_internal_set_pb( Slapi_PBlock *pb,
859 const char *newsuperior,
861 LDAPControl **controls,
862 const char *uniqueid,
863 Slapi_ComponentId *plugin_identity,
864 int operation_flags )
866 slapi_int_connection_init_pb( pb, LDAP_REQ_MODRDN );
867 slapi_pblock_set( pb, SLAPI_MODRDN_TARGET, (void *)olddn );
868 slapi_pblock_set( pb, SLAPI_MODRDN_NEWRDN, (void *)newrdn );
869 slapi_pblock_set( pb, SLAPI_MODRDN_NEWSUPERIOR, (void *)newsuperior );
870 slapi_pblock_set( pb, SLAPI_MODRDN_DELOLDRDN, (void *)&deloldrdn );
871 slapi_pblock_set( pb, SLAPI_REQCONTROLS, (void *)controls );
872 slapi_pblock_set( pb, SLAPI_TARGET_UNIQUEID, (void *)uniqueid );
873 slapi_pblock_set( pb, SLAPI_PLUGIN_IDENTITY, (void *)plugin_identity );
874 slapi_pblock_set( pb, SLAPI_X_INTOP_FLAGS, (void *)&operation_flags );
875 slap_modrdn2mods( pb->pb_op, pb->pb_rs );
876 slapi_int_set_operation_dn( pb );
879 /* Function : slapi_modrdn_internal
881 * Description : Plugin functions call this routine to modify the rdn
882 * of an entry in the backend directly
883 * Return values : LDAP_SUCCESS
887 * LDAP_UNWILLING_TO_PERFORM
889 * NOTE: This function does not support the "newSuperior" option from LDAP V3.
892 slapi_modrdn_internal(
896 LDAPControl **controls,
901 pb = slapi_pblock_new ();
903 slapi_rename_internal_set_pb( pb, olddn, lnewrdn, NULL,
904 deloldrdn, controls, NULL, NULL, 0 );
905 slapi_pblock_set( pb, SLAPI_LOG_OPERATION, (void *)&log_change );
906 slapi_modrdn_internal_pb( pb );
912 slapi_delete_internal_set_pb( Slapi_PBlock *pb,
914 LDAPControl **controls,
915 const char *uniqueid,
916 Slapi_ComponentId *plugin_identity,
917 int operation_flags )
919 slapi_int_connection_init_pb( pb, LDAP_REQ_DELETE );
920 slapi_pblock_set( pb, SLAPI_TARGET_DN, (void *)dn );
921 slapi_pblock_set( pb, SLAPI_REQCONTROLS, (void *)controls );
922 slapi_pblock_set( pb, SLAPI_TARGET_UNIQUEID, (void *)uniqueid );
923 slapi_pblock_set( pb, SLAPI_PLUGIN_IDENTITY, (void *)plugin_identity );
924 slapi_pblock_set( pb, SLAPI_X_INTOP_FLAGS, (void *)&operation_flags );
925 slapi_int_set_operation_dn( pb );
928 /* Function : slapi_delete_internal
930 * Description : Plugin functions call this routine to delete an entry
931 * in the backend directly
932 * Return values : LDAP_SUCCESS
936 * LDAP_UNWILLING_TO_PERFORM
939 slapi_delete_internal(
941 LDAPControl **controls,
946 pb = slapi_pblock_new();
948 slapi_delete_internal_set_pb( pb, ldn, controls, NULL, NULL, 0 );
949 slapi_pblock_set( pb, SLAPI_LOG_OPERATION, (void *)&log_change );
950 slapi_delete_internal_pb( pb );
955 #endif /* LDAP_SLAPI */