git.sur5r.net Git - openldap/blob - servers/slapd/back-monitor/search.c

   1 /* search.c - monitor backend search function */
   2 /*
   3  * Copyright 1998-2003 The OpenLDAP Foundation, All Rights Reserved.
   4  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
   5  */
   6 /*
   7  * Copyright 2001, Pierangelo Masarati, All rights reserved. <ando@sys-net.it>
   8  *
   9  * This work has beed deveolped for the OpenLDAP Foundation
  10  * in the hope that it may be useful to the Open Source community,
  11  * but WITHOUT ANY WARRANTY.
  12  *
  13  * Permission is granted to anyone to use this software for any purpose
  14  * on any computer system, and to alter it and redistribute it, subject
  15  * to the following restrictions:
  16  *
  17  * 1. The author and SysNet s.n.c. are not responsible for the consequences
  18  *    of use of this software, no matter how awful, even if they arise from
  19  *    flaws in it.
  20  *
  21  * 2. The origin of this software must not be misrepresented, either by
  22  *    explicit claim or by omission.  Since few users ever read sources,
  23  *    credits should appear in the documentation.
  24  *
  25  * 3. Altered versions must be plainly marked as such, and must not be
  26  *    misrepresented as being the original software.  Since few users
  27  *    ever read sources, credits should appear in the documentation.
  28  *    SysNet s.n.c. cannot be responsible for the consequences of the
  29  *    alterations.
  30  *
  31  * 4. This notice may not be removed or altered.
  32  */
  33
  34 #include "portable.h"
  35
  36 #include <stdio.h>
  37
  38 #include <ac/string.h>
  39 #include <ac/socket.h>
  40
  41 #include "slap.h"
  42 #include "back-monitor.h"
  43 #include "proto-back-monitor.h"
  44
  45 static int
  46 monitor_send_children(
  47         /*
  48         Backend         *be,
  49         Connection      *conn,
  50         Operation       *op,
  51         Filter          *filter,
  52         AttributeName   *attrs,
  53         int             attrsonly,
  54         */
  55         Operation       *op,
  56         SlapReply       *rs,
  57         Entry           *e_parent,
  58         int             sub
  59 )
  60 {
  61         struct monitorinfo      *mi =
  62                 (struct monitorinfo *) op->o_bd->be_private;
  63         Entry                   *e, *e_tmp, *e_ch;
  64         struct monitorentrypriv *mp;
  65         int                     rc;
  66
  67         mp = ( struct monitorentrypriv * )e_parent->e_private;
  68         e = mp->mp_children;
  69
  70         e_ch = NULL;
  71         if ( MONITOR_HAS_VOLATILE_CH( mp ) ) {
  72                 monitor_entry_create( mi, NULL, e_parent, &e_ch );
  73         }
  74         monitor_cache_release( mi, e_parent );
  75
  76         /* no volatile entries? */
  77         if ( e_ch == NULL ) {
  78                 /* no persistent entries? return */
  79                 if ( e == NULL ) {
  80                         return( 0 );
  81                 }
  82
  83         /* volatile entries */
  84         } else {
  85                 /* if no persistent, return only volatile */
  86                 if ( e == NULL ) {
  87                         e = e_ch;
  88                         monitor_cache_lock( e_ch );
  89
  90                 /* else append persistent to volatile */
  91                 } else {
  92                         e_tmp = e_ch;
  93                         do {
  94                                 mp = ( struct monitorentrypriv * )e_tmp->e_private;
  95                                 e_tmp = mp->mp_next;
  96
  97                                 if ( e_tmp == NULL ) {
  98                                         mp->mp_next = e;
  99                                         break;
 100                                 }
 101                         } while ( e_tmp );
 102                         e = e_ch;
 103                 }
 104         }
 105
 106         /* return entries */
 107         for ( ; e != NULL; ) {
 108                 mp = ( struct monitorentrypriv * )e->e_private;
 109
 110                 monitor_entry_update( mi, e );
 111
 112                 rc = test_filter( op, e, op->oq_search.rs_filter );
 113                 if ( rc == LDAP_COMPARE_TRUE ) {
 114                         rs->sr_entry = e;
 115                         send_search_entry( op, rs );
 116                         rs->sr_entry = NULL;
 117                 }
 118
 119                 if ( ( mp->mp_children || MONITOR_HAS_VOLATILE_CH( mp ) )
 120                                 && sub ) {
 121                         rc = monitor_send_children( op, rs, e, sub );
 122                         if ( rc ) {
 123                                 return( rc );
 124                         }
 125                 }
 126
 127                 e_tmp = mp->mp_next;
 128                 if ( e_tmp != NULL ) {
 129                         monitor_cache_lock( e_tmp );
 130                 }
 131                 monitor_cache_release( mi, e );
 132                 e = e_tmp;
 133         }
 134
 135         return( 0 );
 136 }
 137
 138 int
 139 monitor_back_search( Operation *op, SlapReply *rs )
 140 {
 141         struct monitorinfo      *mi
 142                 = (struct monitorinfo *) op->o_bd->be_private;
 143         int             rc = LDAP_SUCCESS;
 144         Entry           *e, *matched = NULL;
 145
 146 #ifdef NEW_LOGGING
 147         LDAP_LOG( BACK_MON, ENTRY,
 148                    "monitor_back_search: enter\n", 0, 0, 0 );
 149 #else
 150         Debug(LDAP_DEBUG_TRACE, "=> monitor_back_search\n%s%s%s", "", "", "");
 151 #endif
 152
 153
 154         /* get entry with reader lock */
 155         monitor_cache_dn2entry( mi, &op->o_req_ndn, &e, &matched );
 156         if ( e == NULL ) {
 157                 rs->sr_err = LDAP_NO_SUCH_OBJECT;
 158                 if ( matched ) {
 159                         rs->sr_matched = ch_strdup( matched->e_dn );
 160                         monitor_cache_release( mi, matched );
 161                 }
 162
 163                 send_ldap_result( op, rs );
 164                 rs->sr_matched = NULL;
 165
 166                 return( 0 );
 167         }
 168
 169         rs->sr_attrs = op->oq_search.rs_attrs;
 170         switch ( op->oq_search.rs_scope ) {
 171         case LDAP_SCOPE_BASE:
 172                 monitor_entry_update( mi, e );
 173                 rc = test_filter( op, e, op->oq_search.rs_filter );
 174                 if ( rc == LDAP_COMPARE_TRUE ) {
 175                         rs->sr_entry = e;
 176                         send_search_entry( op, rs );
 177                         rs->sr_entry = NULL;
 178                 }
 179                 rc = LDAP_SUCCESS;
 180                 monitor_cache_release( mi, e );
 181                 break;
 182
 183         case LDAP_SCOPE_ONELEVEL:
 184                 rc = monitor_send_children( op, rs, e, 0 );
 185                 if ( rc ) {
 186                         rc = LDAP_OTHER;
 187                 }
 188
 189                 break;
 190
 191         case LDAP_SCOPE_SUBTREE:
 192                 monitor_entry_update( mi, e );
 193                 rc = test_filter( op, e, op->oq_search.rs_filter );
 194                 if ( rc == LDAP_COMPARE_TRUE ) {
 195                         rs->sr_entry = e;
 196                         send_search_entry( op, rs );
 197                         rs->sr_entry = NULL;
 198                 }
 199
 200                 rc = monitor_send_children( op, rs, e, 1 );
 201                 if ( rc ) {
 202                         rc = LDAP_OTHER;
 203                 }
 204
 205                 break;
 206         }
 207
 208         rs->sr_attrs = NULL;
 209         rs->sr_err = rc;
 210         send_ldap_result( op, rs );
 211
 212         return( rc == LDAP_SUCCESS ? 0 : 1 );
 213 }
 214