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-2014 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 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->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 )
 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, sizeof(OperationBuffer) );
 191         op->o_hdr = &((OperationBuffer *) op)->ob_hdr;
 192         op->o_controls = ((OperationBuffer *) op)->ob_controls;
 193
 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;
 199
 200         conn->c_pending_ops.stqh_first = op;
 201
 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 );
 207
 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 );
 211
 212         LDAP_STAILQ_INIT( &conn->c_ops );
 213
 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;
 218
 219         conn->c_sb = ber_sockbuf_alloc();
 220
 221         ber_sockbuf_ctrl( conn->c_sb, LBER_SB_OPT_SET_MAX_INCOMING, &max );
 222
 223         conn->c_currentber = NULL;
 224
 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 );
 231
 232         ldap_pvt_thread_mutex_lock( &conn->c_mutex );
 233
 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;
 238
 239         conn->c_n_get = 0;
 240         conn->c_n_read = 0;
 241         conn->c_n_write = 0;
 242
 243         conn->c_protocol = LDAP_VERSION3;
 244
 245         conn->c_activitytime = conn->c_starttime = slap_get_time();
 246
 247         /*
 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.
 252          */
 253         connection_assign_nextid( conn );
 254
 255         conn->c_conn_state  = 0x01;     /* SLAP_C_ACTIVE */
 256         conn->c_struct_state = 0x02;    /* SLAP_C_USED */
 257
 258         conn->c_ssf = conn->c_transport_ssf = local_ssf;
 259         conn->c_tls_ssf = 0;
 260
 261         backend_connection_init( conn );
 262
 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;
 267
 268         /* operation object */
 269         op->o_tag = tag;
 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;
 277         op->o_conn = conn;
 278         op->o_connid = conn->c_connid;
 279         op->o_bd = frontendDB;
 280
 281         /* extensions */
 282         slapi_int_create_object_extensions( SLAPI_X_EXT_OPERATION, op );
 283         slapi_int_create_object_extensions( SLAPI_X_EXT_CONNECTION, conn );
 284
 285         pb->pb_rs = (SlapReply *)slapi_ch_calloc( 1, sizeof(SlapReply) );
 286         pb->pb_op = op;
 287         pb->pb_conn = conn;
 288         pb->pb_intop = 1;
 289
 290         ldap_pvt_thread_mutex_unlock( &conn->c_mutex );
 291 }
 292
 293 static void
 294 slapi_int_set_operation_dn( Slapi_PBlock *pb )
 295 {
 296         Backend                 *be;
 297         Operation               *op = pb->pb_op;
 298
 299         if ( BER_BVISNULL( &op->o_ndn ) ) {
 300                 /* set to root DN */
 301                 be = select_backend( &op->o_req_ndn, 1 );
 302                 if ( be != NULL ) {
 303                         ber_dupbv( &op->o_dn, &be->be_rootdn );
 304                         ber_dupbv( &op->o_ndn, &be->be_rootndn );
 305                 }
 306         }
 307 }
 308
 309 void
 310 slapi_int_connection_done_pb( Slapi_PBlock *pb )
 311 {
 312         Connection              *conn;
 313         Operation               *op;
 314
 315         PBLOCK_ASSERT_INTOP( pb, 0 );
 316
 317         conn = pb->pb_conn;
 318         op = pb->pb_op;
 319
 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 );
 325
 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 );
 330
 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 );
 341                 }
 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 );
 346                 }
 347                 slap_mods_free( op->orr_modlist, 1 );
 348                 break;
 349         case LDAP_REQ_ADD:
 350                 slap_mods_free( op->ora_modlist, 0 );
 351                 break;
 352         case LDAP_REQ_MODIFY:
 353                 slap_mods_free( op->orm_modlist, 1 );
 354                 break;
 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;
 359                 }
 360                 break;
 361         default:
 362                 break;
 363         }
 364
 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 );
 370
 371         if ( conn->c_sb != NULL ) {
 372                 ber_sockbuf_free( conn->c_sb );
 373         }
 374
 375         slapi_int_free_object_extensions( SLAPI_X_EXT_OPERATION, op );
 376         slapi_int_free_object_extensions( SLAPI_X_EXT_CONNECTION, conn );
 377
 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 );
 382 }
 383
 384 static int
 385 slapi_int_func_internal_pb( Slapi_PBlock *pb, slap_operation_t which )
 386 {
 387         SlapReply               *rs = pb->pb_rs;
 388         int                     rc;
 389
 390         PBLOCK_ASSERT_INTOP( pb, 0 );
 391
 392         rc = slapi_int_get_ctrls( pb );
 393         if ( rc != LDAP_SUCCESS ) {
 394                 rs->sr_err = rc;
 395                 return rc;
 396         }
 397
 398         pb->pb_op->o_bd = frontendDB;
 399         return (&frontendDB->be_bind)[which]( pb->pb_op, pb->pb_rs );
 400 }
 401
 402 int
 403 slapi_delete_internal_pb( Slapi_PBlock *pb )
 404 {
 405         if ( pb == NULL ) {
 406                 return -1;
 407         }
 408
 409         PBLOCK_ASSERT_INTOP( pb, LDAP_REQ_DELETE );
 410
 411         slapi_int_func_internal_pb( pb, op_delete );
 412
 413         return 0;
 414 }
 415
 416 int
 417 slapi_add_internal_pb( Slapi_PBlock *pb )
 418 {
 419         SlapReply               *rs;
 420         Slapi_Entry             *entry_orig = NULL;
 421         OpExtraDB oex;
 422         int rc;
 423
 424         if ( pb == NULL ) {
 425                 return -1;
 426         }
 427
 428         PBLOCK_ASSERT_INTOP( pb, LDAP_REQ_ADD );
 429
 430         rs = pb->pb_rs;
 431
 432         entry_orig = pb->pb_op->ora_e;
 433         pb->pb_op->ora_e = NULL;
 434
 435         /*
 436          * The caller can specify a new entry, or a target DN and set
 437          * of modifications, but not both.
 438          */
 439         if ( entry_orig != NULL ) {
 440                 if ( pb->pb_op->ora_modlist != NULL || !BER_BVISNULL( &pb->pb_op->o_req_ndn )) {
 441                         rs->sr_err = LDAP_PARAM_ERROR;
 442                         goto cleanup;
 443                 }
 444
 445                 assert( BER_BVISNULL( &pb->pb_op->o_req_dn ) ); /* shouldn't get set */
 446                 ber_dupbv( &pb->pb_op->o_req_dn, &entry_orig->e_name );
 447                 ber_dupbv( &pb->pb_op->o_req_ndn, &entry_orig->e_nname );
 448         } else if ( pb->pb_op->ora_modlist == NULL || BER_BVISNULL( &pb->pb_op->o_req_ndn )) {
 449                 rs->sr_err = LDAP_PARAM_ERROR;
 450                 goto cleanup;
 451         }
 452
 453         pb->pb_op->ora_e = (Entry *)slapi_ch_calloc( 1, sizeof(Entry) );
 454         ber_dupbv( &pb->pb_op->ora_e->e_name,  &pb->pb_op->o_req_dn );
 455         ber_dupbv( &pb->pb_op->ora_e->e_nname, &pb->pb_op->o_req_ndn );
 456
 457         if ( entry_orig != NULL ) {
 458                 assert( pb->pb_op->ora_modlist == NULL );
 459
 460                 rs->sr_err = slap_entry2mods( entry_orig, &pb->pb_op->ora_modlist,
 461                         &rs->sr_text, pb->pb_textbuf, sizeof( pb->pb_textbuf ) );
 462                 if ( rs->sr_err != LDAP_SUCCESS ) {
 463                         goto cleanup;
 464                 }
 465         } else {
 466                 assert( pb->pb_op->ora_modlist != NULL );
 467         }
 468
 469         rs->sr_err = slap_mods_check( pb->pb_op, pb->pb_op->ora_modlist, &rs->sr_text,
 470                 pb->pb_textbuf, sizeof( pb->pb_textbuf ), NULL );
 471         if ( rs->sr_err != LDAP_SUCCESS ) {
 472                 goto cleanup;
 473         }
 474
 475         /* Duplicate the values, because we may call slapi_entry_free() */
 476         rs->sr_err = slap_mods2entry( pb->pb_op->ora_modlist, &pb->pb_op->ora_e,
 477                 1, 0, &rs->sr_text, pb->pb_textbuf, sizeof( pb->pb_textbuf ) );
 478         if ( rs->sr_err != LDAP_SUCCESS ) {
 479                 goto cleanup;
 480         }
 481
 482         oex.oe.oe_key = (void *)do_add;
 483         oex.oe_db = NULL;
 484         LDAP_SLIST_INSERT_HEAD(&pb->pb_op->o_extra, &oex.oe, oe_next);
 485         rc = slapi_int_func_internal_pb( pb, op_add );
 486         LDAP_SLIST_REMOVE(&pb->pb_op->o_extra, &oex.oe, OpExtra, oe_next);
 487
 488         if ( !rc ) {
 489                 if ( pb->pb_op->ora_e != NULL && oex.oe_db != NULL ) {
 490                         BackendDB       *bd = pb->pb_op->o_bd;
 491
 492                         pb->pb_op->o_bd = oex.oe_db;
 493                         be_entry_release_w( pb->pb_op, pb->pb_op->ora_e );
 494                         pb->pb_op->ora_e = NULL;
 495                         pb->pb_op->o_bd = bd;
 496                 }
 497         }
 498
 499 cleanup:
 500
 501         if ( pb->pb_op->ora_e != NULL ) {
 502                 slapi_entry_free( pb->pb_op->ora_e );
 503                 pb->pb_op->ora_e = NULL;
 504         }
 505         if ( entry_orig != NULL ) {
 506                 pb->pb_op->ora_e = entry_orig;
 507                 slap_mods_free( pb->pb_op->ora_modlist, 1 );
 508                 pb->pb_op->ora_modlist = NULL;
 509         }
 510
 511         return 0;
 512 }
 513
 514 int
 515 slapi_modrdn_internal_pb( Slapi_PBlock *pb )
 516 {
 517         if ( pb == NULL ) {
 518                 return -1;
 519         }
 520
 521         PBLOCK_ASSERT_INTOP( pb, LDAP_REQ_MODRDN );
 522
 523         if ( BER_BVISEMPTY( &pb->pb_op->o_req_ndn ) ) {
 524                 pb->pb_rs->sr_err = LDAP_UNWILLING_TO_PERFORM;
 525                 goto cleanup;
 526         }
 527
 528         slapi_int_func_internal_pb( pb, op_modrdn );
 529
 530 cleanup:
 531
 532         return 0;
 533 }
 534
 535 int
 536 slapi_modify_internal_pb( Slapi_PBlock *pb )
 537 {
 538         SlapReply               *rs;
 539
 540         if ( pb == NULL ) {
 541                 return -1;
 542         }
 543
 544         PBLOCK_ASSERT_INTOP( pb, LDAP_REQ_MODIFY );
 545
 546         rs = pb->pb_rs;
 547
 548         if ( pb->pb_op->orm_modlist == NULL ) {
 549                 rs->sr_err = LDAP_PARAM_ERROR;
 550                 goto cleanup;
 551         }
 552
 553         if ( BER_BVISEMPTY( &pb->pb_op->o_req_ndn ) ) {
 554                 rs->sr_err = LDAP_UNWILLING_TO_PERFORM;
 555                 goto cleanup;
 556         }
 557
 558         rs->sr_err = slap_mods_check( pb->pb_op, pb->pb_op->orm_modlist,
 559                 &rs->sr_text, pb->pb_textbuf, sizeof( pb->pb_textbuf ), NULL );
 560         if ( rs->sr_err != LDAP_SUCCESS ) {
 561                 goto cleanup;
 562         }
 563
 564         slapi_int_func_internal_pb( pb, op_modify );
 565
 566 cleanup:
 567
 568         return 0;
 569 }
 570
 571 static int
 572 slapi_int_search_entry_callback( Slapi_Entry *entry, void *callback_data )
 573 {
 574         int             nentries = 0, i = 0;
 575         Slapi_Entry     **head = NULL, **tp;
 576         Slapi_PBlock    *pb = (Slapi_PBlock *)callback_data;
 577
 578         PBLOCK_ASSERT_INTOP( pb, LDAP_REQ_SEARCH );
 579
 580         entry = slapi_entry_dup( entry );
 581         if ( entry == NULL ) {
 582                 return LDAP_NO_MEMORY;
 583         }
 584
 585         slapi_pblock_get( pb, SLAPI_NENTRIES, &nentries );
 586         slapi_pblock_get( pb, SLAPI_PLUGIN_INTOP_SEARCH_ENTRIES, &head );
 587
 588         i = nentries + 1;
 589         if ( nentries == 0 ) {
 590                 tp = (Slapi_Entry **)slapi_ch_malloc( 2 * sizeof(Slapi_Entry *) );
 591                 if ( tp == NULL ) {
 592                         slapi_entry_free( entry );
 593                         return LDAP_NO_MEMORY;
 594                 }
 595
 596                 tp[0] = entry;
 597         } else {
 598                 tp = (Slapi_Entry **)slapi_ch_realloc( (char *)head,
 599                                 sizeof(Slapi_Entry *) * ( i + 1 ) );
 600                 if ( tp == NULL ) {
 601                         slapi_entry_free( entry );
 602                         return LDAP_NO_MEMORY;
 603                 }
 604                 tp[i - 1] = entry;
 605         }
 606         tp[i] = NULL;
 607
 608         slapi_pblock_set( pb, SLAPI_PLUGIN_INTOP_SEARCH_ENTRIES, (void *)tp );
 609         slapi_pblock_set( pb, SLAPI_NENTRIES, (void *)&i );
 610
 611         return LDAP_SUCCESS;
 612 }
 613
 614 int
 615 slapi_search_internal_pb( Slapi_PBlock *pb )
 616 {
 617         return slapi_search_internal_callback_pb( pb,
 618                 (void *)pb,
 619                 NULL,
 620                 slapi_int_search_entry_callback,
 621                 NULL );
 622 }
 623
 624 int
 625 slapi_search_internal_callback_pb( Slapi_PBlock *pb,
 626         void *callback_data,
 627         plugin_result_callback prc,
 628         plugin_search_entry_callback psec,
 629         plugin_referral_entry_callback prec )
 630 {
 631         int                     free_filter = 0;
 632         SlapReply               *rs;
 633
 634         if ( pb == NULL ) {
 635                 return -1;
 636         }
 637
 638         PBLOCK_ASSERT_INTOP( pb, LDAP_REQ_SEARCH );
 639
 640         rs = pb->pb_rs;
 641
 642         /* search callback and arguments */
 643         slapi_pblock_set( pb, SLAPI_X_INTOP_RESULT_CALLBACK,         (void *)prc );
 644         slapi_pblock_set( pb, SLAPI_X_INTOP_SEARCH_ENTRY_CALLBACK,   (void *)psec );
 645         slapi_pblock_set( pb, SLAPI_X_INTOP_REFERRAL_ENTRY_CALLBACK, (void *)prec );
 646         slapi_pblock_set( pb, SLAPI_X_INTOP_CALLBACK_DATA,           (void *)callback_data );
 647
 648         if ( BER_BVISEMPTY( &pb->pb_op->ors_filterstr )) {
 649                 rs->sr_err = LDAP_PARAM_ERROR;
 650                 goto cleanup;
 651         }
 652
 653         if ( pb->pb_op->ors_filter == NULL ) {
 654                 pb->pb_op->ors_filter = slapi_str2filter( pb->pb_op->ors_filterstr.bv_val );
 655                 if ( pb->pb_op->ors_filter == NULL ) {
 656                         rs->sr_err = LDAP_PROTOCOL_ERROR;
 657                         goto cleanup;
 658                 }
 659
 660                 free_filter = 1;
 661         }
 662
 663         slapi_int_func_internal_pb( pb, op_search );
 664
 665 cleanup:
 666         if ( free_filter ) {
 667                 slapi_filter_free( pb->pb_op->ors_filter, 1 );
 668                 pb->pb_op->ors_filter = NULL;
 669         }
 670
 671         slapi_pblock_delete_param( pb, SLAPI_X_INTOP_RESULT_CALLBACK );
 672         slapi_pblock_delete_param( pb, SLAPI_X_INTOP_SEARCH_ENTRY_CALLBACK );
 673         slapi_pblock_delete_param( pb, SLAPI_X_INTOP_REFERRAL_ENTRY_CALLBACK );
 674         slapi_pblock_delete_param( pb, SLAPI_X_INTOP_CALLBACK_DATA );
 675
 676         return 0;
 677 }
 678
 679 /* Wrappers for old API */
 680
 681 void
 682 slapi_search_internal_set_pb( Slapi_PBlock *pb,
 683         const char *base,
 684         int scope,
 685         const char *filter,
 686         char **attrs,
 687         int attrsonly,
 688         LDAPControl **controls,
 689         const char *uniqueid,
 690         Slapi_ComponentId *plugin_identity,
 691         int operation_flags )
 692 {
 693         int no_limit = SLAP_NO_LIMIT;
 694         int deref = LDAP_DEREF_NEVER;
 695
 696         slapi_int_connection_init_pb( pb, LDAP_REQ_SEARCH );
 697         slapi_pblock_set( pb, SLAPI_SEARCH_TARGET,    (void *)base );
 698         slapi_pblock_set( pb, SLAPI_SEARCH_SCOPE,     (void *)&scope );
 699         slapi_pblock_set( pb, SLAPI_SEARCH_FILTER,    (void *)0 );
 700         slapi_pblock_set( pb, SLAPI_SEARCH_STRFILTER, (void *)filter );
 701         slapi_pblock_set( pb, SLAPI_SEARCH_ATTRS,     (void *)attrs );
 702         slapi_pblock_set( pb, SLAPI_SEARCH_ATTRSONLY, (void *)&attrsonly );
 703         slapi_pblock_set( pb, SLAPI_REQCONTROLS,      (void *)controls );
 704         slapi_pblock_set( pb, SLAPI_TARGET_UNIQUEID,  (void *)uniqueid );
 705         slapi_pblock_set( pb, SLAPI_PLUGIN_IDENTITY,  (void *)plugin_identity );
 706         slapi_pblock_set( pb, SLAPI_X_INTOP_FLAGS,    (void *)&operation_flags );
 707         slapi_pblock_set( pb, SLAPI_SEARCH_DEREF,     (void *)&deref );
 708         slapi_pblock_set( pb, SLAPI_SEARCH_SIZELIMIT, (void *)&no_limit );
 709         slapi_pblock_set( pb, SLAPI_SEARCH_TIMELIMIT, (void *)&no_limit );
 710
 711         slapi_int_set_operation_dn( pb );
 712 }
 713
 714 Slapi_PBlock *
 715 slapi_search_internal(
 716         char *ldn,
 717         int scope,
 718         char *filStr,
 719         LDAPControl **controls,
 720         char **attrs,
 721         int attrsonly )
 722 {
 723         Slapi_PBlock *pb;
 724
 725         pb = slapi_pblock_new();
 726
 727         slapi_search_internal_set_pb( pb, ldn, scope, filStr,
 728                 attrs, attrsonly,
 729                 controls, NULL, NULL, 0 );
 730
 731         slapi_search_internal_pb( pb );
 732
 733         return pb;
 734 }
 735
 736 void
 737 slapi_modify_internal_set_pb( Slapi_PBlock *pb,
 738         const char *dn,
 739         LDAPMod **mods,
 740         LDAPControl **controls,
 741         const char *uniqueid,
 742         Slapi_ComponentId *plugin_identity,
 743         int operation_flags )
 744 {
 745         slapi_int_connection_init_pb( pb, LDAP_REQ_MODIFY );
 746         slapi_pblock_set( pb, SLAPI_MODIFY_TARGET,   (void *)dn );
 747         slapi_pblock_set( pb, SLAPI_MODIFY_MODS,     (void *)mods );
 748         slapi_pblock_set( pb, SLAPI_REQCONTROLS,     (void *)controls );
 749         slapi_pblock_set( pb, SLAPI_TARGET_UNIQUEID, (void *)uniqueid );
 750         slapi_pblock_set( pb, SLAPI_PLUGIN_IDENTITY, (void *)plugin_identity );
 751         slapi_pblock_set( pb, SLAPI_X_INTOP_FLAGS,   (void *)&operation_flags );
 752         slapi_int_set_operation_dn( pb );
 753 }
 754
 755 /* Function : slapi_modify_internal
 756  *
 757  * Description: Plugin functions call this routine to modify an entry
 758  *                              in the backend directly
 759  * Return values : LDAP_SUCCESS
 760  *                 LDAP_PARAM_ERROR
 761  *                 LDAP_NO_MEMORY
 762  *                 LDAP_OTHER
 763  *                 LDAP_UNWILLING_TO_PERFORM
 764 */
 765 Slapi_PBlock *
 766 slapi_modify_internal(
 767         char *ldn,
 768         LDAPMod **mods,
 769         LDAPControl **controls,
 770         int log_change )
 771 {
 772         Slapi_PBlock *pb;
 773
 774         pb = slapi_pblock_new();
 775
 776         slapi_modify_internal_set_pb( pb, ldn, mods, controls, NULL, NULL, 0 );
 777         slapi_pblock_set( pb, SLAPI_LOG_OPERATION, (void *)&log_change );
 778         slapi_modify_internal_pb( pb );
 779
 780         return pb;
 781 }
 782
 783 int
 784 slapi_add_internal_set_pb( Slapi_PBlock *pb,
 785         const char *dn,
 786         LDAPMod **attrs,
 787         LDAPControl **controls,
 788         Slapi_ComponentId *plugin_identity,
 789         int operation_flags )
 790 {
 791         slapi_int_connection_init_pb( pb, LDAP_REQ_ADD );
 792         slapi_pblock_set( pb, SLAPI_ADD_TARGET,      (void *)dn );
 793         slapi_pblock_set( pb, SLAPI_MODIFY_MODS,     (void *)attrs );
 794         slapi_pblock_set( pb, SLAPI_REQCONTROLS,     (void *)controls );
 795         slapi_pblock_set( pb, SLAPI_PLUGIN_IDENTITY, (void *)plugin_identity );
 796         slapi_pblock_set( pb, SLAPI_X_INTOP_FLAGS,   (void *)&operation_flags );
 797         slapi_int_set_operation_dn( pb );
 798
 799         return 0;
 800 }
 801
 802 Slapi_PBlock *
 803 slapi_add_internal(
 804         char * dn,
 805         LDAPMod **attrs,
 806         LDAPControl **controls,
 807         int log_change )
 808 {
 809         Slapi_PBlock *pb;
 810
 811         pb = slapi_pblock_new();
 812
 813         slapi_add_internal_set_pb( pb, dn, attrs, controls, NULL, 0);
 814         slapi_pblock_set( pb, SLAPI_LOG_OPERATION, (void *)&log_change );
 815         slapi_add_internal_pb( pb );
 816
 817         return pb;
 818 }
 819
 820 void
 821 slapi_add_entry_internal_set_pb( Slapi_PBlock *pb,
 822         Slapi_Entry *e,
 823         LDAPControl **controls,
 824         Slapi_ComponentId *plugin_identity,
 825         int operation_flags )
 826 {
 827         slapi_int_connection_init_pb( pb, LDAP_REQ_ADD );
 828         slapi_pblock_set( pb, SLAPI_ADD_ENTRY,       (void *)e );
 829         slapi_pblock_set( pb, SLAPI_REQCONTROLS,     (void *)controls );
 830         slapi_pblock_set( pb, SLAPI_PLUGIN_IDENTITY, (void *)plugin_identity );
 831         slapi_pblock_set( pb, SLAPI_X_INTOP_FLAGS,   (void *)&operation_flags );
 832         slapi_int_set_operation_dn( pb );
 833 }
 834
 835 Slapi_PBlock *
 836 slapi_add_entry_internal(
 837         Slapi_Entry *e,
 838         LDAPControl **controls,
 839         int log_change )
 840 {
 841         Slapi_PBlock *pb;
 842
 843         pb = slapi_pblock_new();
 844
 845         slapi_add_entry_internal_set_pb( pb, e, controls, NULL, 0 );
 846         slapi_pblock_set( pb, SLAPI_LOG_OPERATION, (void *)&log_change );
 847         slapi_add_internal_pb( pb );
 848
 849         return pb;
 850 }
 851
 852 void
 853 slapi_rename_internal_set_pb( Slapi_PBlock *pb,
 854         const char *olddn,
 855         const char *newrdn,
 856         const char *newsuperior,
 857         int deloldrdn,
 858         LDAPControl **controls,
 859         const char *uniqueid,
 860         Slapi_ComponentId *plugin_identity,
 861         int operation_flags )
 862 {
 863         slapi_int_connection_init_pb( pb, LDAP_REQ_MODRDN );
 864         slapi_pblock_set( pb, SLAPI_MODRDN_TARGET,      (void *)olddn );
 865         slapi_pblock_set( pb, SLAPI_MODRDN_NEWRDN,      (void *)newrdn );
 866         slapi_pblock_set( pb, SLAPI_MODRDN_NEWSUPERIOR, (void *)newsuperior );
 867         slapi_pblock_set( pb, SLAPI_MODRDN_DELOLDRDN,   (void *)&deloldrdn );
 868         slapi_pblock_set( pb, SLAPI_REQCONTROLS,        (void *)controls );
 869         slapi_pblock_set( pb, SLAPI_TARGET_UNIQUEID,    (void *)uniqueid );
 870         slapi_pblock_set( pb, SLAPI_PLUGIN_IDENTITY,    (void *)plugin_identity );
 871         slapi_pblock_set( pb, SLAPI_X_INTOP_FLAGS,      (void *)&operation_flags );
 872         slap_modrdn2mods( pb->pb_op, pb->pb_rs );
 873         slapi_int_set_operation_dn( pb );
 874 }
 875
 876 /* Function : slapi_modrdn_internal
 877  *
 878  * Description : Plugin functions call this routine to modify the rdn
 879  *                               of an entry in the backend directly
 880  * Return values : LDAP_SUCCESS
 881  *                 LDAP_PARAM_ERROR
 882  *                 LDAP_NO_MEMORY
 883  *                 LDAP_OTHER
 884  *                 LDAP_UNWILLING_TO_PERFORM
 885  *
 886  * NOTE: This function does not support the "newSuperior" option from LDAP V3.
 887  */
 888 Slapi_PBlock *
 889 slapi_modrdn_internal(
 890         char *olddn,
 891         char *lnewrdn,
 892         int deloldrdn,
 893         LDAPControl **controls,
 894         int log_change )
 895 {
 896         Slapi_PBlock *pb;
 897
 898         pb = slapi_pblock_new ();
 899
 900         slapi_rename_internal_set_pb( pb, olddn, lnewrdn, NULL,
 901                 deloldrdn, controls, NULL, NULL, 0 );
 902         slapi_pblock_set( pb, SLAPI_LOG_OPERATION, (void *)&log_change );
 903         slapi_modrdn_internal_pb( pb );
 904
 905         return pb;
 906 }
 907
 908 void
 909 slapi_delete_internal_set_pb( Slapi_PBlock *pb,
 910         const char *dn,
 911         LDAPControl **controls,
 912         const char *uniqueid,
 913         Slapi_ComponentId *plugin_identity,
 914         int operation_flags )
 915 {
 916         slapi_int_connection_init_pb( pb, LDAP_REQ_DELETE );
 917         slapi_pblock_set( pb, SLAPI_TARGET_DN,       (void *)dn );
 918         slapi_pblock_set( pb, SLAPI_REQCONTROLS,     (void *)controls );
 919         slapi_pblock_set( pb, SLAPI_TARGET_UNIQUEID, (void *)uniqueid );
 920         slapi_pblock_set( pb, SLAPI_PLUGIN_IDENTITY, (void *)plugin_identity );
 921         slapi_pblock_set( pb, SLAPI_X_INTOP_FLAGS,   (void *)&operation_flags );
 922         slapi_int_set_operation_dn( pb );
 923 }
 924
 925 /* Function : slapi_delete_internal
 926  *
 927  * Description : Plugin functions call this routine to delete an entry
 928  *               in the backend directly
 929  * Return values : LDAP_SUCCESS
 930  *                 LDAP_PARAM_ERROR
 931  *                 LDAP_NO_MEMORY
 932  *                 LDAP_OTHER
 933  *                 LDAP_UNWILLING_TO_PERFORM
 934 */
 935 Slapi_PBlock *
 936 slapi_delete_internal(
 937         char *ldn,
 938         LDAPControl **controls,
 939         int log_change )
 940 {
 941         Slapi_PBlock *pb;
 942
 943         pb = slapi_pblock_new();
 944
 945         slapi_delete_internal_set_pb( pb, ldn, controls, NULL, NULL, 0 );
 946         slapi_pblock_set( pb, SLAPI_LOG_OPERATION, (void *)&log_change );
 947         slapi_delete_internal_pb( pb );
 948
 949         return pb;
 950 }
 951
 952 #endif /* LDAP_SLAPI */