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