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