]> git.sur5r.net Git - openldap/blob - servers/slapd/back-wt/search.c
Do not require ac/string.h for lber_pvt.h
[openldap] / servers / slapd / back-wt / search.c
1 /* OpenLDAP WiredTiger backend */
2 /* $OpenLDAP$ */
3 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
4  *
5  * Copyright 2002-2018 The OpenLDAP Foundation.
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 developed by HAMANO Tsukasa <hamano@osstech.co.jp>
18  * based on back-bdb for inclusion in OpenLDAP Software.
19  * WiredTiger is a product of MongoDB Inc.
20  */
21
22 #include "portable.h"
23
24 #include <stdio.h>
25 #include <ac/string.h>
26
27 #include "back-wt.h"
28 #include "idl.h"
29
30 static int search_aliases(
31         Operation *op,
32         SlapReply *rs,
33         Entry *e,
34         WT_SESSION *session,
35         ID *ids,
36         ID *scopes,
37         ID *stack )
38 {
39         /* TODO: search_aliases does not implement yet. */
40         WT_IDL_ZERO( ids );
41         return 0;
42 }
43
44 static int base_candidate(
45         BackendDB *be,
46         Entry *e,
47         ID *ids )
48 {
49         Debug(LDAP_DEBUG_ARGS,
50                   LDAP_XSTRING(base_candidate)
51                   ": base: \"%s\" (0x%08lx)\n",
52                   e->e_nname.bv_val, (long) e->e_id, 0);
53
54         ids[0] = 1;
55         ids[1] = e->e_id;
56         return 0;
57 }
58
59 /* Look for "objectClass Present" in this filter.
60  * Also count depth of filter tree while we're at it.
61  */
62 static int oc_filter(
63         Filter *f,
64         int cur,
65         int *max )
66 {
67         int rc = 0;
68
69         assert( f != NULL );
70
71         if( cur > *max ) *max = cur;
72
73         switch( f->f_choice ) {
74         case LDAP_FILTER_PRESENT:
75                 if (f->f_desc == slap_schema.si_ad_objectClass) {
76                         rc = 1;
77                 }
78                 break;
79
80         case LDAP_FILTER_AND:
81         case LDAP_FILTER_OR:
82                 cur++;
83                 for ( f=f->f_and; f; f=f->f_next ) {
84                         (void) oc_filter(f, cur, max);
85                 }
86                 break;
87
88         default:
89                 break;
90         }
91         return rc;
92 }
93
94 static void search_stack_free( void *key, void *data )
95 {
96         ber_memfree_x(data, NULL);
97 }
98
99 static void *search_stack( Operation *op )
100 {
101         struct wt_info *wi = (struct wt_info *) op->o_bd->be_private;
102         void *ret = NULL;
103
104         if ( op->o_threadctx ) {
105                 ldap_pvt_thread_pool_getkey( op->o_threadctx, (void *)search_stack,
106                                                                          &ret, NULL );
107         } else {
108                 ret = wi->wi_search_stack;
109         }
110
111         if ( !ret ) {
112                 ret = ch_malloc( wi->wi_search_stack_depth * WT_IDL_UM_SIZE
113                                                  * sizeof( ID ) );
114                 if ( op->o_threadctx ) {
115                         ldap_pvt_thread_pool_setkey( op->o_threadctx, (void *)search_stack,
116                                                                                  ret, search_stack_free, NULL, NULL );
117                 } else {
118                         wi->wi_search_stack = ret;
119                 }
120         }
121         return ret;
122 }
123
124 static int search_candidates(
125         Operation *op,
126         SlapReply *rs,
127         Entry *e,
128         wt_ctx *wc,
129         ID  *ids,
130         ID  *scopes )
131 {
132     struct wt_info *wi = (struct wt_info *) op->o_bd->be_private;
133         int rc, depth = 1;
134         Filter f, rf, xf, nf;
135         ID *stack;
136         AttributeAssertion aa_ref = ATTRIBUTEASSERTION_INIT;
137         Filter sf;
138         AttributeAssertion aa_subentry = ATTRIBUTEASSERTION_INIT;
139
140         Debug(LDAP_DEBUG_TRACE,
141                   LDAP_XSTRING(wt_search_candidates)
142                   ": base=\"%s\" (0x%08lx) scope=%d\n",
143                   e->e_nname.bv_val, (long) e->e_id, op->oq_search.rs_scope );
144
145         xf.f_or = op->oq_search.rs_filter;
146         xf.f_choice = LDAP_FILTER_OR;
147         xf.f_next = NULL;
148
149         /* If the user's filter uses objectClass=*,
150      * these clauses are redundant.
151      */
152         if (!oc_filter(op->oq_search.rs_filter, 1, &depth)
153                 && !get_subentries_visibility(op)) {
154                 if( !get_manageDSAit(op) && !get_domainScope(op) ) {
155                         /* match referral objects */
156                         struct berval bv_ref = BER_BVC( "referral" );
157                         rf.f_choice = LDAP_FILTER_EQUALITY;
158                         rf.f_ava = &aa_ref;
159                         rf.f_av_desc = slap_schema.si_ad_objectClass;
160                         rf.f_av_value = bv_ref;
161                         rf.f_next = xf.f_or;
162                         xf.f_or = &rf;
163                         depth++;
164                 }
165         }
166
167         f.f_next = NULL;
168         f.f_choice = LDAP_FILTER_AND;
169         f.f_and = &nf;
170         /* Dummy; we compute scope separately now */
171         nf.f_choice = SLAPD_FILTER_COMPUTED;
172         nf.f_result = LDAP_SUCCESS;
173         nf.f_next = ( xf.f_or == op->oq_search.rs_filter )
174                 ? op->oq_search.rs_filter : &xf ;
175         /* Filter depth increased again, adding dummy clause */
176         depth++;
177
178         if( get_subentries_visibility( op ) ) {
179                 struct berval bv_subentry = BER_BVC( "subentry" );
180                 sf.f_choice = LDAP_FILTER_EQUALITY;
181                 sf.f_ava = &aa_subentry;
182                 sf.f_av_desc = slap_schema.si_ad_objectClass;
183                 sf.f_av_value = bv_subentry;
184                 sf.f_next = nf.f_next;
185                 nf.f_next = &sf;
186         }
187
188         /* Allocate IDL stack, plus 1 more for former tmp */
189         if ( depth+1 > wi->wi_search_stack_depth ) {
190                 stack = ch_malloc( (depth + 1) * WT_IDL_UM_SIZE * sizeof( ID ) );
191         } else {
192                 stack = search_stack( op );
193         }
194
195     if( op->ors_deref & LDAP_DEREF_SEARCHING ) {
196                 rc = search_aliases( op, rs, e, wc->session, ids, scopes, stack );
197                 if ( WT_IDL_IS_ZERO( ids ) && rc == LDAP_SUCCESS )
198                         rc = wt_dn2idl( op, wc->session, &e->e_nname, e, ids, stack );
199         } else {
200                 rc = wt_dn2idl(op, wc->session, &e->e_nname, e, ids, stack );
201         }
202
203         if ( rc == LDAP_SUCCESS ) {
204                 rc = wt_filter_candidates( op, wc, &f, ids,
205                                                                    stack, stack+WT_IDL_UM_SIZE );
206         }
207
208         if ( depth+1 > wi->wi_search_stack_depth ) {
209                 ch_free( stack );
210         }
211
212     if( rc ) {
213                 Debug(LDAP_DEBUG_TRACE,
214                           LDAP_XSTRING(wt_search_candidates)
215                           ": failed (rc=%d)\n",
216                           rc, NULL, NULL );
217
218         } else {
219                 Debug(LDAP_DEBUG_TRACE,
220                           LDAP_XSTRING(wt_search_candidates)
221                           ": id=%ld first=%ld last=%ld\n",
222                           (long) ids[0],
223                           (long) WT_IDL_FIRST(ids),
224                           (long) WT_IDL_LAST(ids));
225         }
226         return 0;
227 }
228
229 static int
230 parse_paged_cookie( Operation *op, SlapReply *rs )
231 {
232         int     rc = LDAP_SUCCESS;
233         PagedResultsState *ps = op->o_pagedresults_state;
234
235         /* this function must be invoked only if the pagedResults
236      * control has been detected, parsed and partially checked
237      * by the frontend */
238         assert( get_pagedresults( op ) > SLAP_CONTROL_IGNORED );
239
240         /* cookie decoding/checks deferred to backend... */
241         if ( ps->ps_cookieval.bv_len ) {
242                 PagedResultsCookie reqcookie;
243                 if( ps->ps_cookieval.bv_len != sizeof( reqcookie ) ) {
244                         /* bad cookie */
245                         rs->sr_text = "paged results cookie is invalid";
246                         rc = LDAP_PROTOCOL_ERROR;
247                         goto done;
248                 }
249
250                 AC_MEMCPY( &reqcookie, ps->ps_cookieval.bv_val, sizeof( reqcookie ));
251
252                 if ( reqcookie > ps->ps_cookie ) {
253                         /* bad cookie */
254                         rs->sr_text = "paged results cookie is invalid";
255                         rc = LDAP_PROTOCOL_ERROR;
256                         goto done;
257
258                 } else if ( reqcookie < ps->ps_cookie ) {
259                         rs->sr_text = "paged results cookie is invalid or old";
260                         rc = LDAP_UNWILLING_TO_PERFORM;
261                         goto done;
262                 }
263
264         } else {
265                 /* we're going to use ps_cookie */
266                 op->o_conn->c_pagedresults_state.ps_cookie = 0;
267         }
268
269 done:;
270
271         return rc;
272 }
273
274 static void
275 send_paged_response(
276         Operation   *op,
277         SlapReply   *rs,
278         ID      *lastid,
279         int     tentries )
280 {
281         LDAPControl *ctrls[2];
282         BerElementBuffer berbuf;
283         BerElement  *ber = (BerElement *)&berbuf;
284         PagedResultsCookie respcookie;
285         struct berval cookie;
286
287         Debug(LDAP_DEBUG_ARGS,
288                   LDAP_XSTRING(send_paged_response)
289                   ": lastid=0x%08lx nentries=%d\n",
290                   lastid ? *lastid : 0, rs->sr_nentries, NULL );
291
292         ctrls[1] = NULL;
293
294         ber_init2( ber, NULL, LBER_USE_DER );
295
296         if ( lastid ) {
297                 respcookie = ( PagedResultsCookie )(*lastid);
298                 cookie.bv_len = sizeof( respcookie );
299                 cookie.bv_val = (char *)&respcookie;
300
301         } else {
302                 respcookie = ( PagedResultsCookie )0;
303                 BER_BVSTR( &cookie, "" );
304         }
305
306         op->o_conn->c_pagedresults_state.ps_cookie = respcookie;
307         op->o_conn->c_pagedresults_state.ps_count =
308                 ((PagedResultsState *)op->o_pagedresults_state)->ps_count +
309                 rs->sr_nentries;
310
311         /* return size of 0 -- no estimate */
312         ber_printf( ber, "{iO}", 0, &cookie );
313
314         ctrls[0] = op->o_tmpalloc( sizeof(LDAPControl), op->o_tmpmemctx );
315         if ( ber_flatten2( ber, &ctrls[0]->ldctl_value, 0 ) == -1 ) {
316                 goto done;
317         }
318
319         ctrls[0]->ldctl_oid = LDAP_CONTROL_PAGEDRESULTS;
320         ctrls[0]->ldctl_iscritical = 0;
321
322         slap_add_ctrls( op, rs, ctrls );
323         rs->sr_err = LDAP_SUCCESS;
324         send_ldap_result( op, rs );
325
326 done:
327         (void) ber_free_buf( ber );
328 }
329
330 int
331 wt_search( Operation *op, SlapReply *rs )
332 {
333     struct wt_info *wi = (struct wt_info *) op->o_bd->be_private;
334         ID id, cursor;
335         ID lastid = NOID;
336         AttributeName *attrs;
337         OpExtra *oex;
338         int manageDSAit;
339         wt_ctx *wc;
340         int rc;
341         Entry *e = NULL;
342         Entry *base = NULL;
343         slap_mask_t mask;
344         time_t stoptime;
345
346         ID candidates[WT_IDL_UM_SIZE];
347         ID iscopes[WT_IDL_DB_SIZE];
348         ID scopes[WT_IDL_DB_SIZE];
349         int tentries = 0;
350         unsigned nentries = 0;
351
352         Debug( LDAP_DEBUG_ARGS, "==> " LDAP_XSTRING(wt_search) ": %s\n",
353                    op->o_req_dn.bv_val, 0, 0 );
354     attrs = op->oq_search.rs_attrs;
355
356         manageDSAit = get_manageDSAit( op );
357
358         wc = wt_ctx_get(op, wi);
359         if( !wc ){
360         Debug( LDAP_DEBUG_ANY,
361                            LDAP_XSTRING(wt_search)
362                            ": wt_ctx_get failed: %d\n",
363                            rc, 0, 0 );
364                 send_ldap_error( op, rs, LDAP_OTHER, "internal error" );
365         return rc;
366         }
367
368         /* get entry */
369         rc = wt_dn2entry(op->o_bd, wc, &op->o_req_ndn, &e);
370         switch( rc ) {
371         case 0:
372                 break;
373         case WT_NOTFOUND:
374                 Debug( LDAP_DEBUG_ARGS,
375                            "<== " LDAP_XSTRING(wt_search)
376                            ": no such object %s\n",
377                            op->o_req_dn.bv_val, 0, 0);
378                 rs->sr_err = LDAP_REFERRAL;
379                 rs->sr_flags = REP_MATCHED_MUSTBEFREED | REP_REF_MUSTBEFREED;
380                 send_ldap_result( op, rs );
381                 goto done;
382         default:
383                 /* TODO: error handling */
384                 Debug( LDAP_DEBUG_ANY,
385                            LDAP_XSTRING(wt_delete)
386                            ": error at wt_dn2entry() rc=%d\n",
387                            rc, 0, 0 );
388                 send_ldap_error( op, rs, LDAP_OTHER, "internal error" );
389                 goto done;
390         }
391
392         if ( op->ors_deref & LDAP_DEREF_FINDING ) {
393                 /* not implement yet */
394         }
395
396         if ( e == NULL ) {
397                 // TODO
398         }
399
400         /* NOTE: __NEW__ "search" access is required
401      * on searchBase object */
402         if ( ! access_allowed_mask( op, e, slap_schema.si_ad_entry,
403                                                                 NULL, ACL_SEARCH, NULL, &mask ) )
404         {
405                 if ( !ACL_GRANT( mask, ACL_DISCLOSE ) ) {
406                         rs->sr_err = LDAP_NO_SUCH_OBJECT;
407                 } else {
408                         rs->sr_err = LDAP_INSUFFICIENT_ACCESS;
409                 }
410
411                 send_ldap_result( op, rs );
412                 goto done;
413         }
414
415         if ( !manageDSAit && is_entry_referral( e ) ) {
416                 /* entry is a referral */
417                 /* TODO: */
418         }
419
420         if ( get_assert( op ) &&
421                  ( test_filter( op, e, get_assertion( op )) != LDAP_COMPARE_TRUE ))
422         {
423                 rs->sr_err = LDAP_ASSERTION_FAILED;
424                 send_ldap_result( op, rs );
425                 goto done;
426         }
427
428         /* compute it anyway; root does not use it */
429         stoptime = op->o_time + op->ors_tlimit;
430
431         base = e;
432
433         e = NULL;
434
435         /* select candidates */
436         if ( op->oq_search.rs_scope == LDAP_SCOPE_BASE ) {
437                 rs->sr_err = base_candidate( op->o_bd, base, candidates );
438         }else{
439                 WT_IDL_ZERO( candidates );
440                 WT_IDL_ZERO( scopes );
441                 rc = search_candidates( op, rs, base,
442                                                                 wc, candidates, scopes );
443                 switch(rc){
444                 case 0:
445                 case WT_NOTFOUND:
446                         break;
447                 default:
448                         Debug( LDAP_DEBUG_ANY,
449                                    LDAP_XSTRING(wt_search) ": error search_candidates\n",
450                                    0, 0, 0 );
451                         send_ldap_error( op, rs, LDAP_OTHER, "internal error" );
452                         goto done;
453                 }
454         }
455
456         /* start cursor at beginning of candidates.
457      */
458         cursor = 0;
459
460         if ( candidates[0] == 0 ) {
461                 Debug( LDAP_DEBUG_TRACE,
462                            LDAP_XSTRING(wt_search) ": no candidates\n",
463                            0, 0, 0 );
464                 goto nochange;
465         }
466
467         if ( op->ors_limit &&
468                  op->ors_limit->lms_s_unchecked != -1 &&
469                  WT_IDL_N(candidates) > (unsigned) op->ors_limit->lms_s_unchecked )
470         {
471                 rs->sr_err = LDAP_ADMINLIMIT_EXCEEDED;
472                 send_ldap_result( op, rs );
473                 rs->sr_err = LDAP_SUCCESS;
474                 goto done;
475         }
476
477         if ( op->ors_limit == NULL  /* isroot == TRUE */ ||
478                  !op->ors_limit->lms_s_pr_hide )
479         {
480                 tentries = WT_IDL_N(candidates);
481         }
482
483         if ( get_pagedresults( op ) > SLAP_CONTROL_IGNORED ) {
484                 /* TODO: pageresult */
485                 PagedResultsState *ps = op->o_pagedresults_state;
486                 /* deferred cookie parsing */
487                 rs->sr_err = parse_paged_cookie( op, rs );
488                 if ( rs->sr_err != LDAP_SUCCESS ) {
489                         send_ldap_result( op, rs );
490                         goto done;
491                 }
492
493                 cursor = (ID) ps->ps_cookie;
494                 if ( cursor && ps->ps_size == 0 ) {
495                         rs->sr_err = LDAP_SUCCESS;
496                         rs->sr_text = "search abandoned by pagedResult size=0";
497                         send_ldap_result( op, rs );
498                         goto done;
499                 }
500                 id = wt_idl_first( candidates, &cursor );
501                 if ( id == NOID ) {
502                         Debug( LDAP_DEBUG_TRACE,
503                                    LDAP_XSTRING(wt_search)
504                                    ": no paged results candidates\n",
505                                    0, 0, 0 );
506                         send_paged_response( op, rs, &lastid, 0 );
507
508                         rs->sr_err = LDAP_OTHER;
509                         goto done;
510                 }
511                 nentries = ps->ps_count;
512                 if ( id == (ID)ps->ps_cookie )
513                         id = wt_idl_next( candidates, &cursor );
514                 goto loop_begin;
515         }
516
517         for ( id = wt_idl_first( candidates, &cursor );
518                   id != NOID ; id = wt_idl_next( candidates, &cursor ) )
519         {
520                 int scopeok;
521
522 loop_begin:
523
524                 /* check for abandon */
525                 if ( op->o_abandon ) {
526                         rs->sr_err = SLAPD_ABANDON;
527                         send_ldap_result( op, rs );
528                         goto done;
529                 }
530
531                 /* mostly needed by internal searches,
532          * e.g. related to syncrepl, for whom
533          * abandon does not get set... */
534                 if ( slapd_shutdown ) {
535                         rs->sr_err = LDAP_UNAVAILABLE;
536                         send_ldap_disconnect( op, rs );
537                         goto done;
538                 }
539
540                 /* check time limit */
541                 if ( op->ors_tlimit != SLAP_NO_LIMIT
542                          && slap_get_time() > stoptime )
543                 {
544                         rs->sr_err = LDAP_TIMELIMIT_EXCEEDED;
545                         rs->sr_ref = rs->sr_v2ref;
546                         send_ldap_result( op, rs );
547                         rs->sr_err = LDAP_SUCCESS;
548                         goto done;
549                 }
550
551                 nentries++;
552
553         fetch_entry_retry:
554
555                 rc = wt_id2entry(op->o_bd, wc->session, id, &e);
556                 /* TODO: error handling */
557                 if ( e == NULL ) {
558                         /* TODO: */
559                         goto loop_continue;
560                 }
561                 if ( is_entry_subentry( e ) ) {
562             if( op->oq_search.rs_scope != LDAP_SCOPE_BASE ) {
563                                 if(!get_subentries_visibility( op )) {
564                                         /* only subentries are visible */
565                                         goto loop_continue;
566                                 }
567
568                         } else if ( get_subentries( op ) &&
569                                                 !get_subentries_visibility( op ))
570                         {
571                                 /* only subentries are visible */
572                                 goto loop_continue;
573                         }
574
575                 } else if ( get_subentries_visibility( op )) {
576                         /* only subentries are visible */
577                         goto loop_continue;
578                 }
579
580                 scopeok = 0;
581                 switch( op->ors_scope ) {
582                 case LDAP_SCOPE_BASE:
583                         /* This is always true, yes? */
584                         if ( id == base->e_id ) scopeok = 1;
585                         break;
586                 case LDAP_SCOPE_ONELEVEL:
587                         scopeok = 1;
588                         break;
589                 case LDAP_SCOPE_SUBTREE:
590                         scopeok = 1;
591                         break;
592                 }
593
594                 /* aliases were already dereferenced in candidate list */
595                 if ( op->ors_deref & LDAP_DEREF_SEARCHING ) {
596                         /* but if the search base is an alias, and we didn't
597                          * deref it when finding, return it.
598                          */
599                         if ( is_entry_alias(e) &&
600                                  ((op->ors_deref & LDAP_DEREF_FINDING) ||
601                                   !bvmatch(&e->e_nname, &op->o_req_ndn)))
602                         {
603                                 goto loop_continue;
604                         }
605                         /* TODO: alias handling */
606                 }
607
608                 /* Not in scope, ignore it */
609                 if ( !scopeok )
610                 {
611                         Debug( LDAP_DEBUG_TRACE,
612                                    LDAP_XSTRING(wt_search)
613                                    ": %ld scope not okay\n",
614                                    (long) id, 0, 0 );
615                         goto loop_continue;
616                 }
617
618                 /*
619          * if it's a referral, add it to the list of referrals. only do
620          * this for non-base searches, and don't check the filter
621          * explicitly here since it's only a candidate anyway.
622          */
623                 if ( !manageDSAit && op->oq_search.rs_scope != LDAP_SCOPE_BASE
624                          && is_entry_referral( e ) )
625                 {
626                         /* TODO: referral */
627                 }
628
629                 if ( !manageDSAit && is_entry_glue( e )) {
630                         goto loop_continue;
631                 }
632
633                 /* if it matches the filter and scope, send it */
634                 rs->sr_err = test_filter( op, e, op->oq_search.rs_filter );
635                 if ( rs->sr_err == LDAP_COMPARE_TRUE ) {
636                         /* check size limit */
637                         if ( get_pagedresults(op) > SLAP_CONTROL_IGNORED ) {
638                                 /* TODO: */
639                         }
640
641                         if (e) {
642                                 /* safe default */
643                                 rs->sr_attrs = op->oq_search.rs_attrs;
644                                 rs->sr_operational_attrs = NULL;
645                                 rs->sr_ctrls = NULL;
646                                 rs->sr_entry = e;
647                                 RS_ASSERT( e->e_private != NULL );
648                                 rs->sr_flags = REP_ENTRY_MUSTRELEASE;
649                                 rs->sr_err = LDAP_SUCCESS;
650                                 rs->sr_err = send_search_entry( op, rs );
651                                 rs->sr_attrs = NULL;
652                                 rs->sr_entry = NULL;
653                                 e = NULL;
654                         }
655                         switch ( rs->sr_err ) {
656                         case LDAP_SUCCESS:  /* entry sent ok */
657                                 break;
658                         default:
659                                 /* TODO: error handling */
660                                 break;
661                         }
662                 } else {
663                         Debug( LDAP_DEBUG_TRACE,
664                                    LDAP_XSTRING(wt_search)
665                                    ": %ld does not match filter\n",
666                                    (long) id, 0, 0 );
667                 }
668
669         loop_continue:
670                 if( e ) {
671                         wt_entry_return( e );
672                         e = NULL;
673                 }
674         }
675
676 nochange:
677     rs->sr_ctrls = NULL;
678         rs->sr_ref = rs->sr_v2ref;
679         rs->sr_err = (rs->sr_v2ref == NULL) ? LDAP_SUCCESS : LDAP_REFERRAL;
680         rs->sr_rspoid = NULL;
681         if ( get_pagedresults(op) > SLAP_CONTROL_IGNORED ) {
682                 /* not implement yet */
683                 /* send_paged_response( op, rs, NULL, 0 ); */
684         } else {
685                 send_ldap_result( op, rs );
686         }
687
688         rs->sr_err = LDAP_SUCCESS;
689
690 done:
691
692         if( base ) {
693                 wt_entry_return( base );
694         }
695
696         if( e ) {
697                 wt_entry_return( e );
698         }
699
700     return rs->sr_err;
701 }
702
703 /*
704  * Local variables:
705  * indent-tabs-mode: t
706  * tab-width: 4
707  * c-basic-offset: 4
708  * End:
709  */