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                         rs->sr_attrs = attrs;
 116                         send_search_entry( op, rs );
 117                         rs->sr_entry = NULL;
 118                         rs->sr_attrs = NULL;
 119                 }
 120
 121                 if ( ( mp->mp_children || MONITOR_HAS_VOLATILE_CH( mp ) )
 122                                 && sub ) {
 123                         rc = monitor_send_children( op, rs, e, sub );
 124                         if ( rc ) {
 125                                 return( rc );
 126                         }
 127                 }
 128
 129                 e_tmp = mp->mp_next;
 130                 if ( e_tmp != NULL ) {
 131                         monitor_cache_lock( e_tmp );
 132                 }
 133                 monitor_cache_release( mi, e );
 134                 e = e_tmp;
 135         }
 136
 137         return( 0 );
 138 }
 139
 140 int
 141 monitor_back_search( Operation *op, SlapReply *rs )
 142 {
 143         struct monitorinfo      *mi
 144                 = (struct monitorinfo *) op->o_bd->be_private;
 145         int             rc = LDAP_SUCCESS;
 146         Entry           *e, *matched = NULL;
 147
 148 #ifdef NEW_LOGGING
 149         LDAP_LOG( BACK_MON, ENTRY,
 150                    "monitor_back_search: enter\n", 0, 0, 0 );
 151 #else
 152         Debug(LDAP_DEBUG_TRACE, "=> monitor_back_search\n%s%s%s", "", "", "");
 153 #endif
 154
 155
 156         /* get entry with reader lock */
 157         monitor_cache_dn2entry( mi, &op->o_req_ndn, &e, &matched );
 158         if ( e == NULL ) {
 159                 rs->sr_err = LDAP_NO_SUCH_OBJECT;
 160                 if ( matched ) {
 161                         rs->sr_matched = ch_strdup( matched->e_dn );
 162                         monitor_cache_release( mi, matched );
 163                 }
 164
 165                 send_ldap_result( op, rs );
 166                 rs->sr_matched = NULL;
 167
 168                 return( 0 );
 169         }
 170
 171         switch ( op->oq_search.rs_scope ) {
 172         case LDAP_SCOPE_BASE:
 173                 monitor_entry_update( mi, e );
 174                 rc = test_filter( op, e, op->oq_search.rs_filter );
 175                 if ( rc == LDAP_COMPARE_TRUE ) {
 176                         rs->sr_entry = e;
 177                         rs->sr_attrs = attrs;
 178                         send_search_entry( op, rs );
 179                         rs->sr_entry = NULL;
 180                         rs->sr_attrs = NULL;
 181                 }
 182                 rc = LDAP_SUCCESS;
 183                 monitor_cache_release( mi, e );
 184                 break;
 185
 186         case LDAP_SCOPE_ONELEVEL:
 187                 rc = monitor_send_children( op, rs, e, 0 );
 188                 if ( rc ) {
 189                         rc = LDAP_OTHER;
 190                 }
 191
 192                 break;
 193
 194         case LDAP_SCOPE_SUBTREE:
 195                 monitor_entry_update( mi, e );
 196                 rc = test_filter( op, e, op->oq_search.rs_filter );
 197                 if ( rc == LDAP_COMPARE_TRUE ) {
 198                         rs->sr_entry = e;
 199                         rs->sr_attrs = attrs;
 200                         send_search_entry( op, rs );
 201                         rs->sr_entry = NULL;
 202                         rs->sr_attrs = NULL;
 203                 }
 204
 205                 rc = monitor_send_children( op, rs, e, 1 );
 206                 if ( rc ) {
 207                         rc = LDAP_OTHER;
 208                 }
 209
 210                 break;
 211         }
 212
 213         rs->sr_err = rc;
 214         send_ldap_result( op, rs );
 215
 216         return( rc == LDAP_SUCCESS ? 0 : 1 );
 217 }
 218