git.sur5r.net Git - openldap/blob - servers/slapd/slapi/slapi_ops.c

   1 /* $OpenLDAP$ */
   2 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
   3  *
   4  * Copyright 2002-2005 The OpenLDAP Foundation.
   5  * Portions Copyright 1997,2002-2003 IBM Corporation.
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted only as authorized by the OpenLDAP
  10  * Public License.
  11  *
  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>.
  15  */
  16 /* ACKNOWLEDGEMENTS:
  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:
  20  *   Luke Howard
  21  */
  22
  23 #include "portable.h"
  24
  25 #include <ac/string.h>
  26 #include <ac/stdarg.h>
  27 #include <ac/ctype.h>
  28 #include <ac/unistd.h>
  29
  30 #include <slap.h>
  31 #include <lber_pvt.h>
  32 #include <slapi.h>
  33
  34 #ifdef LDAP_SLAPI
  35
  36 static struct slap_listener slapi_listener = {
  37         BER_BVC("slapi://"),
  38         BER_BVC("slapi://")
  39 };
  40
  41 static LDAPControl **
  42 slapi_int_dup_controls( LDAPControl **controls )
  43 {
  44         LDAPControl **c;
  45         size_t i;
  46
  47         if ( controls == NULL )
  48                 return NULL;
  49
  50         for ( i = 0; controls[i] != NULL; i++ )
  51                 ;
  52
  53         c = (LDAPControl **) slapi_ch_calloc( i + 1, sizeof(LDAPControl *) );
  54
  55         for ( i = 0; controls[i] != NULL; i++ ) {
  56                 c[i] = slapi_dup_control( controls[i] );
  57         }
  58
  59         return c;
  60 }
  61
  62 static int
  63 slapi_int_result(
  64         Operation       *op,
  65         SlapReply       *rs )
  66 {
  67         Slapi_PBlock            *pb = SLAPI_OPERATION_PBLOCK( op );
  68         plugin_result_callback  prc = NULL;
  69         void                    *callback_data = NULL;
  70         LDAPControl             **ctrls = NULL;
  71
  72         assert( pb != NULL );
  73
  74         slapi_pblock_get( pb, SLAPI_X_INTOP_RESULT_CALLBACK, (void **)&prc );
  75         slapi_pblock_get( pb, SLAPI_X_INTOP_CALLBACK_DATA,   &callback_data );
  76
  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 );
  80
  81         if ( prc != NULL ) {
  82                 (*prc)( rs->sr_err, callback_data );
  83         }
  84
  85         return rs->sr_err;
  86 }
  87
  88 static int
  89 slapi_int_search_entry(
  90         Operation       *op,
  91         SlapReply       *rs )
  92 {
  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;
  97
  98         assert( pb != NULL );
  99
 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 );
 102
 103         if ( psec != NULL ) {
 104                 rc = (*psec)( rs->sr_entry, callback_data );
 105         }
 106
 107         return rc;
 108 }
 109
 110 static int
 111 slapi_int_search_reference(
 112         Operation       *op,
 113         SlapReply       *rs )
 114 {
 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 );
 119
 120         assert( pb != NULL );
 121
 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 );
 124
 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 ) {
 129                                 break;
 130                         }
 131                 }
 132         }
 133
 134         return rc;
 135 }
 136
 137 int
 138 slapi_int_response( Slapi_Operation *op, SlapReply *rs )
 139 {
 140         int                             rc;
 141
 142         switch ( rs->sr_type ) {
 143         case REP_RESULT:
 144                 rc = slapi_int_result( op, rs );
 145                 break;
 146         case REP_SEARCH:
 147                 rc = slapi_int_search_entry( op, rs );
 148                 break;
 149         case REP_SEARCHREF:
 150                 rc = slapi_int_search_reference( op, rs );
 151                 break;
 152         default:
 153                 rc = LDAP_OTHER;
 154                 break;
 155         }
 156
 157         assert( rc != SLAP_CB_CONTINUE ); /* never try to send a wire response */
 158
 159         return rc;
 160 }
 161
 162 static int
 163 slapi_int_get_ctrls( Slapi_PBlock *pb )
 164 {
 165         LDAPControl             **c;
 166         int                     rc = LDAP_SUCCESS;
 167
 168         if ( pb->pop->o_ctrls != NULL ) {
 169                 for ( c = pb->pop->o_ctrls; *c != NULL; c++ ) {
 170                         rc = slap_parse_ctrl( pb->pop, &pb->rs, *c, &pb->rs.sr_text );
 171                         if ( rc != LDAP_SUCCESS )
 172                                 break;
 173                 }
 174         }
 175
 176         return rc;
 177 }
 178
 179 void
 180 slapi_int_connection_init_pb( Slapi_PBlock *pb, ber_tag_t tag )
 181 {
 182         Connection              *conn;
 183         Operation               *op;
 184         ber_len_t               max = sockbuf_max_incoming;
 185
 186         conn = (Connection *) slapi_ch_calloc( 1, sizeof(Connection) );
 187
 188         LDAP_STAILQ_INIT( &conn->c_pending_ops );
 189
 190         op = (Operation *) slapi_ch_calloc( 1, OPERATION_BUFFER_SIZE );
 191         op->o_hdr = (Opheader *)(op + 1);
 192         op->o_hdr->oh_extensions = NULL;
 193         op->o_controls = (void **)(op->o_hdr + 1);
 194
 195         op->o_callback = (slap_callback *) slapi_ch_calloc( 1, sizeof(slap_callback) );
 196         op->o_callback->sc_response = slapi_int_response;
 197         op->o_callback->sc_cleanup = NULL;
 198         op->o_callback->sc_private = pb;
 199         op->o_callback->sc_next = NULL;
 200
 201         conn->c_pending_ops.stqh_first = op;
 202
 203         /* connection object authorization information */
 204         conn->c_authtype = LDAP_AUTH_NONE;
 205         BER_BVZERO( &conn->c_authmech );
 206         BER_BVZERO( &conn->c_dn );
 207         BER_BVZERO( &conn->c_ndn );
 208
 209         conn->c_listener = &slapi_listener;
 210         ber_dupbv( &conn->c_peer_domain, (struct berval *)&slap_unknown_bv );
 211         ber_dupbv( &conn->c_peer_name, (struct berval *)&slap_unknown_bv );
 212
 213         LDAP_STAILQ_INIT( &conn->c_ops );
 214
 215         BER_BVZERO( &conn->c_sasl_bind_mech );
 216         conn->c_sasl_authctx = NULL;
 217         conn->c_sasl_sockctx = NULL;
 218         conn->c_sasl_extra = NULL;
 219
 220         conn->c_sb = ber_sockbuf_alloc();
 221
 222         ber_sockbuf_ctrl( conn->c_sb, LBER_SB_OPT_SET_MAX_INCOMING, &max );
 223
 224         conn->c_currentber = NULL;
 225
 226         /* should check status of thread calls */
 227         ldap_pvt_thread_mutex_init( &conn->c_mutex );
 228         ldap_pvt_thread_mutex_init( &conn->c_write_mutex );
 229         ldap_pvt_thread_cond_init( &conn->c_write_cv );
 230
 231         ldap_pvt_thread_mutex_lock( &conn->c_mutex );
 232
 233         conn->c_n_ops_received = 0;
 234         conn->c_n_ops_executing = 0;
 235         conn->c_n_ops_pending = 0;
 236         conn->c_n_ops_completed = 0;
 237
 238         conn->c_n_get = 0;
 239         conn->c_n_read = 0;
 240         conn->c_n_write = 0;
 241
 242         conn->c_protocol = LDAP_VERSION3;
 243
 244         conn->c_activitytime = conn->c_starttime = slap_get_time();
 245
 246         /*
 247          * A real connection ID is required, because syncrepl associates
 248          * pending CSNs with unique ( connection, operation ) tuples.
 249          * Setting a fake connection ID will cause slap_get_commit_csn()
 250          * to return a stale value.
 251          */
 252         connection_assign_nextid( conn );
 253
 254         conn->c_conn_state  = 0x01;     /* SLAP_C_ACTIVE */
 255         conn->c_struct_state = 0x02;    /* SLAP_C_USED */
 256
 257         conn->c_ssf = conn->c_transport_ssf = 0;
 258         conn->c_tls_ssf = 0;
 259
 260         backend_connection_init( conn );
 261
 262         conn->c_send_ldap_result = slap_send_ldap_result;
 263         conn->c_send_search_entry = slap_send_search_entry;
 264         conn->c_send_ldap_extended = slap_send_ldap_extended;
 265         conn->c_send_search_reference = slap_send_search_reference;
 266
 267         /* operation object */
 268         op->o_tag = tag;
 269         op->o_protocol = LDAP_VERSION3;
 270         BER_BVZERO( &op->o_authmech );
 271         op->o_time = slap_get_time();
 272         op->o_do_not_cache = 1;
 273         op->o_threadctx = ldap_pvt_thread_pool_context();
 274         op->o_tmpmemctx = NULL;
 275         op->o_tmpmfuncs = &ch_mfuncs;
 276         op->o_conn = conn;
 277         op->o_connid = conn->c_connid;
 278         op->o_bd = frontendDB;
 279
 280         pb->pop = op;
 281         pb->pconn = conn;
 282         pb->internal_op = 1;
 283
 284         ldap_pvt_thread_mutex_unlock( &conn->c_mutex );
 285 }
 286
 287 static void
 288 slapi_int_set_operation_dn( Slapi_PBlock *pb )
 289 {
 290         Backend                 *be;
 291         Operation               *op = pb->pop;
 292
 293         if ( BER_BVISNULL( &op->o_ndn ) ) {
 294                 /* set to root DN */
 295                 be = select_backend( &op->o_req_ndn, 0, 0 );
 296                 if ( be != NULL ) {
 297                         ber_dupbv( &op->o_dn, &be->be_rootdn );
 298                         ber_dupbv( &op->o_ndn, &be->be_rootndn );
 299                 }
 300         }
 301 }
 302
 303 void
 304 slapi_int_connection_done_pb( Slapi_PBlock *pb )
 305 {
 306         Connection              *conn;
 307         Operation               *op;
 308
 309         PBLOCK_ASSERT_INTOP( pb, 0 );
 310
 311         conn = pb->pconn;
 312         op = pb->pop;
 313
 314         /* free allocated DNs */
 315         if ( !BER_BVISNULL( &op->o_dn ) )
 316                 op->o_tmpfree( op->o_dn.bv_val, op->o_tmpmemctx );
 317         if ( !BER_BVISNULL( &op->o_ndn ) )
 318                 op->o_tmpfree( op->o_ndn.bv_val, op->o_tmpmemctx );
 319
 320         if ( !BER_BVISNULL( &op->o_req_dn ) )
 321                 op->o_tmpfree( op->o_req_dn.bv_val, op->o_tmpmemctx );
 322         if ( !BER_BVISNULL( &op->o_req_ndn ) )
 323                 op->o_tmpfree( op->o_req_ndn.bv_val, op->o_tmpmemctx );
 324
 325         switch ( op->o_tag ) {
 326         case LDAP_REQ_MODRDN:
 327                 if ( !BER_BVISNULL( &op->orr_newrdn ))
 328                         op->o_tmpfree( op->orr_newrdn.bv_val, op->o_tmpmemctx );
 329                 if ( !BER_BVISNULL( &op->orr_nnewrdn ))
 330                         op->o_tmpfree( op->orr_nnewrdn.bv_val, op->o_tmpmemctx );
 331                 if ( op->orr_newSup != NULL ) {
 332                         assert( !BER_BVISNULL( op->orr_newSup ) );
 333                         op->o_tmpfree( op->orr_newSup->bv_val, op->o_tmpmemctx );
 334                         op->o_tmpfree( op->orr_newSup, op->o_tmpmemctx );
 335                 }
 336                 if ( op->orr_nnewSup != NULL ) {
 337                         assert( !BER_BVISNULL( op->orr_nnewSup ) );
 338                         op->o_tmpfree( op->orr_nnewSup->bv_val, op->o_tmpmemctx );
 339                         op->o_tmpfree( op->orr_nnewSup, op->o_tmpmemctx );
 340                 }
 341                 break;
 342         case LDAP_REQ_ADD:
 343                 slapi_int_mods_free( op->ora_modlist );
 344                 break;
 345         case LDAP_REQ_MODIFY:
 346                 slapi_int_mods_free( op->orm_modlist );
 347                 break;
 348         case LDAP_REQ_SEARCH:
 349                 if ( op->ors_attrs != NULL ) {
 350                         op->o_tmpfree( op->ors_attrs, op->o_tmpmemctx );
 351                         op->ors_attrs = NULL;
 352                 }
 353                 break;
 354         default:
 355                 break;
 356         }
 357
 358         slapi_ch_free_string( &conn->c_authmech.bv_val );
 359         slapi_ch_free_string( &conn->c_dn.bv_val );
 360         slapi_ch_free_string( &conn->c_ndn.bv_val );
 361
 362         if ( conn->c_sb != NULL ) {
 363                 ber_sockbuf_free( conn->c_sb );
 364         }
 365
 366         slapi_ch_free( (void **)&pb->pop->o_callback );
 367         slapi_ch_free( (void **)&pb->pop );
 368         slapi_ch_free( (void **)&pb->pconn );
 369 }
 370
 371 static int
 372 slapi_int_func_internal_pb( Slapi_PBlock *pb, slap_operation_t which )
 373 {
 374         BI_op_bind              **func;
 375         SlapReply               *rs = &pb->rs;
 376         int                     rc;
 377
 378         PBLOCK_ASSERT_INTOP( pb, 0 );
 379
 380         rc = slapi_int_get_ctrls( pb );
 381         if ( rc != LDAP_SUCCESS ) {
 382                 rs->sr_err = rc;
 383                 return rc;
 384         }
 385
 386         func = &pb->pop->o_bd->be_bind;
 387
 388         return func[which]( pb->pop, &pb->rs );
 389 }
 390
 391 int
 392 slapi_delete_internal_pb( Slapi_PBlock *pb )
 393 {
 394         if ( pb == NULL ) {
 395                 return -1;
 396         }
 397
 398         PBLOCK_ASSERT_INTOP( pb, LDAP_REQ_DELETE );
 399
 400         slapi_int_func_internal_pb( pb, op_delete );
 401         slap_graduate_commit_csn( pb->pop );
 402
 403         return 0;
 404 }
 405
 406 int
 407 slapi_add_internal_pb( Slapi_PBlock *pb )
 408 {
 409         SlapReply               *rs;
 410         Slapi_Entry             *entry_orig = NULL;
 411
 412         if ( pb == NULL ) {
 413                 return -1;
 414         }
 415
 416         PBLOCK_ASSERT_INTOP( pb, LDAP_REQ_ADD );
 417
 418         rs = &pb->rs;
 419
 420         entry_orig = pb->pop->ora_e;
 421         pb->pop->ora_e = NULL;
 422
 423         if ( entry_orig != NULL ) {
 424                 if ( pb->pop->ora_modlist != NULL || !BER_BVISNULL( &pb->pop->o_req_ndn )) {
 425                         rs->sr_err = LDAP_PARAM_ERROR;
 426                         goto cleanup;
 427                 }
 428
 429                 assert( BER_BVISNULL( &pb->pop->o_req_dn ) ); /* shouldn't get set */
 430                 ber_dupbv( &pb->pop->o_req_dn, &entry_orig->e_name );
 431                 ber_dupbv( &pb->pop->o_req_ndn, &entry_orig->e_nname );
 432         } else if ( pb->pop->ora_modlist == NULL || BER_BVISNULL( &pb->pop->o_req_ndn )) {
 433                 rs->sr_err = LDAP_PARAM_ERROR;
 434                 goto cleanup;
 435         }
 436
 437         /*
 438          * The caller can specify a new entry, or a target DN and set
 439          * of modifications, but not both.
 440          */
 441         pb->pop->ora_e = (Entry *)slapi_ch_calloc( 1, sizeof(Entry) );
 442         ber_dupbv( &pb->pop->ora_e->e_name,  &pb->pop->o_req_dn );
 443         ber_dupbv( &pb->pop->ora_e->e_nname, &pb->pop->o_req_ndn );
 444
 445         if ( entry_orig != NULL ) {
 446                 assert( pb->pop->ora_modlist == NULL );
 447
 448                 rs->sr_err = slap_entry2mods( entry_orig, &pb->pop->ora_modlist,
 449                         &rs->sr_text, pb->textbuf, sizeof( pb->textbuf ) );
 450                 if ( rs->sr_err != LDAP_SUCCESS ) {
 451                         goto cleanup;
 452                 }
 453         } else {
 454                 assert( pb->pop->ora_modlist != NULL );
 455         }
 456
 457         rs->sr_err = slap_mods_check( pb->pop->ora_modlist, &rs->sr_text,
 458                 pb->textbuf, sizeof( pb->textbuf ), NULL );
 459         if ( rs->sr_err != LDAP_SUCCESS ) {
 460                 goto cleanup;
 461         }
 462
 463         if ( slapi_int_func_internal_pb( pb, op_add ) == 0 ) {
 464                 if ( pb->pop->ora_e != NULL && pb->pop->o_private != NULL ) {
 465                         BackendDB       *bd = pb->pop->o_bd;
 466
 467                         /* could we use SLAPI_BACKEND instead? */
 468                         pb->pop->o_bd = (BackendDB *)pb->pop->o_private;
 469                         pb->pop->o_private = NULL;
 470                         be_entry_release_w( pb->pop, pb->pop->ora_e );
 471                         pb->pop->ora_e = NULL;
 472                         pb->pop->o_bd = bd;
 473                         pb->pop->o_private = NULL;
 474                 }
 475         }
 476
 477 cleanup:
 478         slap_graduate_commit_csn( pb->pop );
 479
 480         if ( pb->pop->ora_e != NULL ) {
 481                 slapi_entry_free( pb->pop->ora_e );
 482                 pb->pop->ora_e = NULL;
 483         }
 484         if ( entry_orig != NULL ) {
 485                 pb->pop->ora_e = entry_orig;
 486                 slapi_int_mods_free( pb->pop->ora_modlist );
 487                 pb->pop->ora_modlist = NULL;
 488         }
 489
 490         return 0;
 491 }
 492
 493 int
 494 slapi_modrdn_internal_pb( Slapi_PBlock *pb )
 495 {
 496         if ( pb == NULL ) {
 497                 return -1;
 498         }
 499
 500         PBLOCK_ASSERT_INTOP( pb, LDAP_REQ_MODRDN );
 501
 502         if ( BER_BVISEMPTY( &pb->pop->o_req_ndn ) ) {
 503                 pb->rs.sr_err = LDAP_UNWILLING_TO_PERFORM;
 504                 goto cleanup;
 505         }
 506
 507         slapi_int_func_internal_pb( pb, op_modrdn );
 508
 509 cleanup:
 510         slap_graduate_commit_csn( pb->pop );
 511
 512         return 0;
 513 }
 514
 515 int
 516 slapi_modify_internal_pb( Slapi_PBlock *pb )
 517 {
 518         SlapReply               *rs;
 519
 520         if ( pb == NULL ) {
 521                 return -1;
 522         }
 523
 524         PBLOCK_ASSERT_INTOP( pb, LDAP_REQ_MODIFY );
 525
 526         rs = &pb->rs;
 527
 528         if ( pb->pop->orm_modlist == NULL ) {
 529                 rs->sr_err = LDAP_PARAM_ERROR;
 530                 goto cleanup;
 531         }
 532
 533         if ( BER_BVISEMPTY( &pb->pop->o_req_ndn ) ) {
 534                 rs->sr_err = LDAP_UNWILLING_TO_PERFORM;
 535                 goto cleanup;
 536         }
 537
 538         rs->sr_err = slap_mods_check( pb->pop->orm_modlist,
 539                 &rs->sr_text, pb->textbuf, sizeof( pb->textbuf ), NULL );
 540         if ( rs->sr_err != LDAP_SUCCESS ) {
 541                 goto cleanup;
 542         }
 543
 544         slapi_int_func_internal_pb( pb, op_modify );
 545
 546 cleanup:
 547         slap_graduate_commit_csn( pb->pop );
 548
 549         return 0;
 550 }
 551
 552 static int
 553 slapi_int_search_entry_callback( Slapi_Entry *entry, void *callback_data )
 554 {
 555         int             nentries = 0, i = 0;
 556         Slapi_Entry     **head = NULL, **tp;
 557         Slapi_PBlock    *pb = (Slapi_PBlock *)callback_data;
 558
 559         PBLOCK_ASSERT_INTOP( pb, LDAP_REQ_SEARCH );
 560
 561         entry = slapi_entry_dup( entry );
 562         if ( entry == NULL ) {
 563                 return LDAP_NO_MEMORY;
 564         }
 565
 566         slapi_pblock_get( pb, SLAPI_NENTRIES, &nentries );
 567         slapi_pblock_get( pb, SLAPI_PLUGIN_INTOP_SEARCH_ENTRIES, &head );
 568
 569         i = nentries + 1;
 570         if ( nentries == 0 ) {
 571                 tp = (Slapi_Entry **)slapi_ch_malloc( 2 * sizeof(Slapi_Entry *) );
 572                 if ( tp == NULL ) {
 573                         slapi_entry_free( entry );
 574                         return LDAP_NO_MEMORY;
 575                 }
 576
 577                 tp[0] = entry;
 578         } else {
 579                 tp = (Slapi_Entry **)slapi_ch_realloc( (char *)head,
 580                                 sizeof(Slapi_Entry *) * ( i + 1 ) );
 581                 if ( tp == NULL ) {
 582                         slapi_entry_free( entry );
 583                         return LDAP_NO_MEMORY;
 584                 }
 585                 tp[i - 1] = entry;
 586         }
 587         tp[i] = NULL;
 588
 589         slapi_pblock_set( pb, SLAPI_PLUGIN_INTOP_SEARCH_ENTRIES, (void *)tp );
 590         slapi_pblock_set( pb, SLAPI_NENTRIES, (void *)i );
 591
 592         return LDAP_SUCCESS;
 593 }
 594
 595 int
 596 slapi_search_internal_pb( Slapi_PBlock *pb )
 597 {
 598         return slapi_search_internal_callback_pb( pb,
 599                 (void *)pb,
 600                 NULL,
 601                 slapi_int_search_entry_callback,
 602                 NULL );
 603 }
 604
 605 int
 606 slapi_search_internal_callback_pb( Slapi_PBlock *pb,
 607         void *callback_data,
 608         plugin_result_callback prc,
 609         plugin_search_entry_callback psec,
 610         plugin_referral_entry_callback prec )
 611 {
 612         int                     free_filter = 0;
 613         SlapReply               *rs;
 614
 615         if ( pb == NULL ) {
 616                 return -1;
 617         }
 618
 619         PBLOCK_ASSERT_INTOP( pb, LDAP_REQ_SEARCH );
 620
 621         rs = &pb->rs;
 622
 623         /* search callback and arguments */
 624         slapi_pblock_set( pb, SLAPI_X_INTOP_RESULT_CALLBACK,         (void *)prc );
 625         slapi_pblock_set( pb, SLAPI_X_INTOP_SEARCH_ENTRY_CALLBACK,   (void *)psec );
 626         slapi_pblock_set( pb, SLAPI_X_INTOP_REFERRAL_ENTRY_CALLBACK, (void *)prec );
 627         slapi_pblock_set( pb, SLAPI_X_INTOP_CALLBACK_DATA,           (void *)callback_data );
 628
 629         if ( BER_BVISEMPTY( &pb->pop->ors_filterstr )) {
 630                 rs->sr_err = LDAP_PARAM_ERROR;
 631                 goto cleanup;
 632         }
 633
 634         if ( pb->pop->ors_filter == NULL ) {
 635                 pb->pop->ors_filter = slapi_str2filter( pb->pop->ors_filterstr.bv_val );
 636                 if ( pb->pop->ors_filter == NULL ) {
 637                         rs->sr_err = LDAP_PROTOCOL_ERROR;
 638                         goto cleanup;
 639                 }
 640
 641                 free_filter = 1;
 642         }
 643
 644         slapi_int_func_internal_pb( pb, op_search );
 645
 646 cleanup:
 647         if ( free_filter ) {
 648                 slapi_filter_free( pb->pop->ors_filter, 1 );
 649                 pb->pop->ors_filter = NULL;
 650         }
 651
 652         slapi_pblock_delete_param( pb, SLAPI_X_INTOP_RESULT_CALLBACK );
 653         slapi_pblock_delete_param( pb, SLAPI_X_INTOP_SEARCH_ENTRY_CALLBACK );
 654         slapi_pblock_delete_param( pb, SLAPI_X_INTOP_REFERRAL_ENTRY_CALLBACK );
 655         slapi_pblock_delete_param( pb, SLAPI_X_INTOP_CALLBACK_DATA );
 656
 657         return 0;
 658 }
 659
 660 /* Wrappers for old API */
 661
 662 void
 663 slapi_search_internal_set_pb( Slapi_PBlock *pb,
 664         const char *base,
 665         int scope,
 666         const char *filter,
 667         char **attrs,
 668         int attrsonly,
 669         LDAPControl **controls,
 670         const char *uniqueid,
 671         Slapi_ComponentId *plugin_identity,
 672         int operation_flags )
 673 {
 674         slapi_int_connection_init_pb( pb, LDAP_REQ_SEARCH );
 675         slapi_pblock_set( pb, SLAPI_SEARCH_TARGET,    (void *)base );
 676         slapi_pblock_set( pb, SLAPI_SEARCH_SCOPE,     (void *)scope );
 677         slapi_pblock_set( pb, SLAPI_SEARCH_FILTER,    NULL );
 678         slapi_pblock_set( pb, SLAPI_SEARCH_STRFILTER, (void *)filter );
 679         slapi_pblock_set( pb, SLAPI_SEARCH_ATTRS,     (void *)attrs );
 680         slapi_pblock_set( pb, SLAPI_SEARCH_ATTRSONLY, (void *)attrsonly );
 681         slapi_pblock_set( pb, SLAPI_REQCONTROLS,      (void *)controls );
 682         slapi_pblock_set( pb, SLAPI_TARGET_UNIQUEID,  (void *)uniqueid );
 683         slapi_pblock_set( pb, SLAPI_PLUGIN_IDENTITY,  (void *)plugin_identity );
 684         slapi_pblock_set( pb, SLAPI_X_INTOP_FLAGS,    (void *)operation_flags );
 685         slapi_pblock_set( pb, SLAPI_SEARCH_DEREF,     (void *)0 );
 686         slapi_pblock_set( pb, SLAPI_SEARCH_SIZELIMIT, (void *)SLAP_NO_LIMIT );
 687         slapi_pblock_set( pb, SLAPI_SEARCH_TIMELIMIT, (void *)SLAP_NO_LIMIT );
 688
 689         slapi_int_set_operation_dn( pb );
 690 }
 691
 692 Slapi_PBlock *
 693 slapi_search_internal(
 694         char *ldn,
 695         int scope,
 696         char *filStr,
 697         LDAPControl **controls,
 698         char **attrs,
 699         int attrsonly )
 700 {
 701         Slapi_PBlock *pb;
 702
 703         pb = slapi_pblock_new();
 704
 705         slapi_search_internal_set_pb( pb, ldn, scope, filStr,
 706                 attrs, attrsonly,
 707                 controls, NULL, NULL, 0 );
 708
 709         slapi_search_internal_pb( pb );
 710
 711         return pb;
 712 }
 713
 714 void
 715 slapi_modify_internal_set_pb( Slapi_PBlock *pb,
 716         const char *dn,
 717         LDAPMod **mods,
 718         LDAPControl **controls,
 719         const char *uniqueid,
 720         Slapi_ComponentId *plugin_identity,
 721         int operation_flags )
 722 {
 723         slapi_int_connection_init_pb( pb, LDAP_REQ_MODIFY );
 724         slapi_pblock_set( pb, SLAPI_MODIFY_TARGET,   (void *)dn );
 725         slapi_pblock_set( pb, SLAPI_MODIFY_MODS,     (void *)mods );
 726         slapi_pblock_set( pb, SLAPI_REQCONTROLS,     (void *)controls );
 727         slapi_pblock_set( pb, SLAPI_TARGET_UNIQUEID, (void *)uniqueid );
 728         slapi_pblock_set( pb, SLAPI_PLUGIN_IDENTITY, (void *)plugin_identity );
 729         slapi_pblock_set( pb, SLAPI_X_INTOP_FLAGS,   (void *)operation_flags );
 730         slapi_int_set_operation_dn( pb );
 731 }
 732
 733 /* Function : slapi_modify_internal
 734  *
 735  * Description: Plugin functions call this routine to modify an entry
 736  *                              in the backend directly
 737  * Return values : LDAP_SUCCESS
 738  *                 LDAP_PARAM_ERROR
 739  *                 LDAP_NO_MEMORY
 740  *                 LDAP_OTHER
 741  *                 LDAP_UNWILLING_TO_PERFORM
 742 */
 743 Slapi_PBlock *
 744 slapi_modify_internal(
 745         char *ldn,
 746         LDAPMod **mods,
 747         LDAPControl **controls,
 748         int log_change )
 749 {
 750         Slapi_PBlock *pb;
 751
 752         pb = slapi_pblock_new();
 753
 754         slapi_modify_internal_set_pb( pb, ldn, mods, controls, NULL, NULL, 0 );
 755         slapi_pblock_set( pb, SLAPI_LOG_OPERATION, (void *)log_change );
 756         slapi_modify_internal_pb( pb );
 757
 758         return pb;
 759 }
 760
 761 int
 762 slapi_add_internal_set_pb( Slapi_PBlock *pb,
 763         const char *dn,
 764         LDAPMod **attrs,
 765         LDAPControl **controls,
 766         Slapi_ComponentId *plugin_identity,
 767         int operation_flags )
 768 {
 769         slapi_int_connection_init_pb( pb, LDAP_REQ_ADD );
 770         slapi_pblock_set( pb, SLAPI_ADD_TARGET,      (void *)dn );
 771         slapi_pblock_set( pb, SLAPI_MODIFY_MODS,     (void *)attrs );
 772         slapi_pblock_set( pb, SLAPI_REQCONTROLS,     (void *)controls );
 773         slapi_pblock_set( pb, SLAPI_PLUGIN_IDENTITY, (void *)plugin_identity );
 774         slapi_pblock_set( pb, SLAPI_X_INTOP_FLAGS,   (void *)operation_flags );
 775         slapi_int_set_operation_dn( pb );
 776
 777         return 0;
 778 }
 779
 780 Slapi_PBlock *
 781 slapi_add_internal(
 782         char * dn,
 783         LDAPMod **attrs,
 784         LDAPControl **controls,
 785         int log_change )
 786 {
 787         Slapi_PBlock *pb;
 788
 789         pb = slapi_pblock_new();
 790
 791         slapi_add_internal_set_pb( pb, dn, attrs, controls, NULL, 0);
 792         slapi_pblock_set( pb, SLAPI_LOG_OPERATION, (void *)log_change );
 793         slapi_add_internal_pb( pb );
 794
 795         return pb;
 796 }
 797
 798 void
 799 slapi_add_entry_internal_set_pb( Slapi_PBlock *pb,
 800         Slapi_Entry *e,
 801         LDAPControl **controls,
 802         Slapi_ComponentId *plugin_identity,
 803         int operation_flags )
 804 {
 805         slapi_int_connection_init_pb( pb, LDAP_REQ_ADD );
 806         slapi_pblock_set( pb, SLAPI_ADD_ENTRY,       (void *)e );
 807         slapi_pblock_set( pb, SLAPI_REQCONTROLS,     (void *)controls );
 808         slapi_pblock_set( pb, SLAPI_PLUGIN_IDENTITY, (void *)plugin_identity );
 809         slapi_pblock_set( pb, SLAPI_X_INTOP_FLAGS,   (void *)operation_flags );
 810         slapi_int_set_operation_dn( pb );
 811 }
 812
 813 Slapi_PBlock *
 814 slapi_add_entry_internal(
 815         Slapi_Entry *e,
 816         LDAPControl **controls,
 817         int log_change )
 818 {
 819         Slapi_PBlock *pb;
 820
 821         pb = slapi_pblock_new();
 822
 823         slapi_add_entry_internal_set_pb( pb, e, controls, NULL, 0 );
 824         slapi_pblock_set( pb, SLAPI_LOG_OPERATION, (void *)log_change );
 825         slapi_add_internal_pb( pb );
 826
 827         return pb;
 828 }
 829
 830 void
 831 slapi_rename_internal_set_pb( Slapi_PBlock *pb,
 832         const char *olddn,
 833         const char *newrdn,
 834         const char *newsuperior,
 835         int deloldrdn,
 836         LDAPControl **controls,
 837         const char *uniqueid,
 838         Slapi_ComponentId *plugin_identity,
 839         int operation_flags )
 840 {
 841         slapi_int_connection_init_pb( pb, LDAP_REQ_MODRDN );
 842         slapi_pblock_set( pb, SLAPI_MODRDN_TARGET,      (void *)olddn );
 843         slapi_pblock_set( pb, SLAPI_MODRDN_NEWRDN,      (void *)newrdn );
 844         slapi_pblock_set( pb, SLAPI_MODRDN_NEWSUPERIOR, (void *)newsuperior );
 845         slapi_pblock_set( pb, SLAPI_MODRDN_DELOLDRDN,   (void *)deloldrdn );
 846         slapi_pblock_set( pb, SLAPI_REQCONTROLS,        (void *)controls );
 847         slapi_pblock_set( pb, SLAPI_TARGET_UNIQUEID,    (void *)uniqueid );
 848         slapi_pblock_set( pb, SLAPI_PLUGIN_IDENTITY,    (void *)plugin_identity );
 849         slapi_pblock_set( pb, SLAPI_X_INTOP_FLAGS,      (void *)operation_flags );
 850         slapi_int_set_operation_dn( pb );
 851 }
 852
 853 /* Function : slapi_modrdn_internal
 854  *
 855  * Description : Plugin functions call this routine to modify the rdn
 856  *                               of an entry in the backend directly
 857  * Return values : LDAP_SUCCESS
 858  *                 LDAP_PARAM_ERROR
 859  *                 LDAP_NO_MEMORY
 860  *                 LDAP_OTHER
 861  *                 LDAP_UNWILLING_TO_PERFORM
 862  *
 863  * NOTE: This function does not support the "newSuperior" option from LDAP V3.
 864  */
 865 Slapi_PBlock *
 866 slapi_modrdn_internal(
 867         char *olddn,
 868         char *lnewrdn,
 869         int deloldrdn,
 870         LDAPControl **controls,
 871         int log_change )
 872 {
 873         Slapi_PBlock *pb;
 874
 875         pb = slapi_pblock_new ();
 876
 877         slapi_rename_internal_set_pb( pb, olddn, lnewrdn, NULL,
 878                 deloldrdn, controls, NULL, NULL, 0 );
 879         slapi_pblock_set( pb, SLAPI_LOG_OPERATION, (void *)log_change );
 880         slapi_modrdn_internal_pb( pb );
 881
 882         return pb;
 883 }
 884
 885 void
 886 slapi_delete_internal_set_pb( Slapi_PBlock *pb,
 887         const char *dn,
 888         LDAPControl **controls,
 889         const char *uniqueid,
 890         Slapi_ComponentId *plugin_identity,
 891         int operation_flags )
 892 {
 893         slapi_int_connection_init_pb( pb, LDAP_REQ_DELETE );
 894         slapi_pblock_set( pb, SLAPI_TARGET_DN,       (void *)dn );
 895         slapi_pblock_set( pb, SLAPI_REQCONTROLS,     (void *)controls );
 896         slapi_pblock_set( pb, SLAPI_TARGET_UNIQUEID, (void *)uniqueid );
 897         slapi_pblock_set( pb, SLAPI_PLUGIN_IDENTITY, (void *)plugin_identity );
 898         slapi_pblock_set( pb, SLAPI_X_INTOP_FLAGS,   (void *)operation_flags );
 899         slapi_int_set_operation_dn( pb );
 900 }
 901
 902 /* Function : slapi_delete_internal
 903  *
 904  * Description : Plugin functions call this routine to delete an entry
 905  *               in the backend directly
 906  * Return values : LDAP_SUCCESS
 907  *                 LDAP_PARAM_ERROR
 908  *                 LDAP_NO_MEMORY
 909  *                 LDAP_OTHER
 910  *                 LDAP_UNWILLING_TO_PERFORM
 911 */
 912 Slapi_PBlock *
 913 slapi_delete_internal(
 914         char *ldn,
 915         LDAPControl **controls,
 916         int log_change )
 917 {
 918         Slapi_PBlock *pb;
 919
 920         pb = slapi_pblock_new();
 921
 922         slapi_delete_internal_set_pb( pb, ldn, controls, NULL, NULL, 0 );
 923         slapi_pblock_set( pb, SLAPI_LOG_OPERATION, (void *)log_change );
 924         slapi_delete_internal_pb( pb );
 925
 926         return pb;
 927 }
 928
 929 #endif /* LDAP_SLAPI */
 930