git.sur5r.net Git - openldap/blob - contrib/slapd-modules/noopsrch/noopsrch.c

   1 /* noopsrch.c - LDAP Control that counts entries a search would return */
   2 /* $OpenLDAP$ */
   3 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
   4  *
   5  * Copyright 2010-2013 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 initially developed by Pierangelo Masarati for inclusion
  18  * in OpenLDAP Software.
  19  */
  20
  21 #include "portable.h"
  22
  23 /* define SLAPD_OVER_NOOPSRCH=2 to build as run-time loadable module */
  24 #ifdef SLAPD_OVER_NOOPSRCH
  25
  26 /*
  27  * Control OID
  28  */
  29 #define LDAP_CONTROL_X_NOOPSRCH         "1.3.6.1.4.1.4203.666.5.18"
  30
  31 #include "slap.h"
  32 #include "ac/string.h"
  33
  34 #define o_noopsrch                      o_ctrlflag[noopsrch_cid]
  35 #define o_ctrlnoopsrch          o_controls[noopsrch_cid]
  36
  37 static int noopsrch_cid;
  38 static slap_overinst noopsrch;
  39
  40 static int
  41 noopsrch_parseCtrl (
  42         Operation *op,
  43         SlapReply *rs,
  44         LDAPControl *ctrl )
  45 {
  46         if ( op->o_noopsrch != SLAP_CONTROL_NONE ) {
  47                 rs->sr_text = "No-op Search control specified multiple times";
  48                 return LDAP_PROTOCOL_ERROR;
  49         }
  50
  51         if ( !BER_BVISNULL( &ctrl->ldctl_value ) ) {
  52                 rs->sr_text = "No-op Search control value is present";
  53                 return LDAP_PROTOCOL_ERROR;
  54         }
  55
  56         op->o_ctrlnoopsrch = (void *)NULL;
  57
  58         op->o_noopsrch = ctrl->ldctl_iscritical
  59                 ? SLAP_CONTROL_CRITICAL
  60                 : SLAP_CONTROL_NONCRITICAL;
  61
  62         rs->sr_err = LDAP_SUCCESS;
  63
  64         return rs->sr_err;
  65 }
  66
  67 int dummy;
  68
  69 typedef struct noopsrch_cb_t {
  70         slap_overinst   *nc_on;
  71         ber_int_t               nc_nentries;
  72         ber_int_t               nc_nsearchref;
  73         AttributeName   *nc_save_attrs;
  74         int                             *nc_pdummy;
  75         int                             nc_save_slimit;
  76 } noopsrch_cb_t;
  77
  78 static int
  79 noopsrch_response( Operation *op, SlapReply *rs )
  80 {
  81         noopsrch_cb_t           *nc = (noopsrch_cb_t *)op->o_callback->sc_private;
  82
  83         /* if the control is global, limits are not computed yet  */
  84         if ( nc->nc_pdummy == &dummy ) {
  85                 nc->nc_save_slimit = op->ors_slimit;
  86                 op->ors_slimit = SLAP_NO_LIMIT;
  87                 nc->nc_pdummy = NULL;
  88         }
  89
  90         if ( rs->sr_type == REP_SEARCH ) {
  91                 nc->nc_nentries++;
  92 #ifdef NOOPSRCH_DEBUG
  93                 Debug( LDAP_DEBUG_TRACE, "noopsrch_response(REP_SEARCH): nentries=%d\n", nc->nc_nentries, 0, 0 );
  94 #endif
  95                 return 0;
  96
  97         } else if ( rs->sr_type == REP_SEARCHREF ) {
  98                 nc->nc_nsearchref++;
  99                 return 0;
 100
 101         } else if ( rs->sr_type == REP_RESULT ) {
 102                 BerElementBuffer        berbuf;
 103                 BerElement                      *ber = (BerElement *) &berbuf;
 104                 struct berval           ctrlval;
 105                 LDAPControl                     *ctrl, *ctrlsp[2];
 106                 int                                     rc = rs->sr_err;
 107
 108                 if ( nc->nc_save_slimit >= 0 && nc->nc_nentries >= nc->nc_save_slimit ) {
 109                         rc = LDAP_SIZELIMIT_EXCEEDED;
 110                 }
 111
 112 #ifdef NOOPSRCH_DEBUG
 113                 Debug( LDAP_DEBUG_TRACE, "noopsrch_response(REP_RESULT): err=%d nentries=%d nref=%d\n", rc, nc->nc_nentries, nc->nc_nsearchref );
 114 #endif
 115
 116                 ber_init2( ber, NULL, LBER_USE_DER );
 117
 118                 ber_printf( ber, "{iii}", rc, nc->nc_nentries, nc->nc_nsearchref );
 119                 if ( ber_flatten2( ber, &ctrlval, 0 ) == -1 ) {
 120                         ber_free_buf( ber );
 121                         if ( op->o_noopsrch == SLAP_CONTROL_CRITICAL ) {
 122                                 return LDAP_CONSTRAINT_VIOLATION;
 123                         }
 124                         return SLAP_CB_CONTINUE;
 125                 }
 126
 127                 ctrl = op->o_tmpcalloc( 1,
 128                         sizeof( LDAPControl ) + ctrlval.bv_len + 1,
 129                         op->o_tmpmemctx );
 130                 ctrl->ldctl_value.bv_val = (char *)&ctrl[ 1 ];
 131                 ctrl->ldctl_oid = LDAP_CONTROL_X_NOOPSRCH;
 132                 ctrl->ldctl_iscritical = 0;
 133                 ctrl->ldctl_value.bv_len = ctrlval.bv_len;
 134                 AC_MEMCPY( ctrl->ldctl_value.bv_val, ctrlval.bv_val, ctrlval.bv_len );
 135                 ctrl->ldctl_value.bv_val[ ctrl->ldctl_value.bv_len ] = '\0';
 136
 137                 ber_free_buf( ber );
 138
 139                 ctrlsp[0] = ctrl;
 140                 ctrlsp[1] = NULL;
 141                 slap_add_ctrls( op, rs, ctrlsp );
 142
 143                 return SLAP_CB_CONTINUE;
 144         }
 145 }
 146
 147 static int
 148 noopsrch_cleanup( Operation *op, SlapReply *rs )
 149 {
 150         if ( rs->sr_type == REP_RESULT || rs->sr_err == SLAPD_ABANDON ) {
 151                 noopsrch_cb_t           *nc = (noopsrch_cb_t *)op->o_callback->sc_private;
 152                 op->ors_attrs = nc->nc_save_attrs;
 153                 if ( nc->nc_pdummy == NULL ) {
 154                         op->ors_slimit = nc->nc_save_slimit;
 155                 }
 156
 157                 op->o_tmpfree( op->o_callback, op->o_tmpmemctx );
 158                 op->o_callback = NULL;
 159         }
 160
 161         return SLAP_CB_CONTINUE;
 162 }
 163
 164 static int
 165 noopsrch_op_search( Operation *op, SlapReply *rs )
 166 {
 167         if ( op->o_noopsrch != SLAP_CONTROL_NONE ) {
 168                 slap_callback *sc;
 169                 noopsrch_cb_t *nc;
 170
 171                 sc = op->o_tmpcalloc( 1, sizeof( slap_callback ) + sizeof( noopsrch_cb_t ), op->o_tmpmemctx );
 172
 173                 nc = (noopsrch_cb_t *)&sc[ 1 ];
 174                 nc->nc_on = (slap_overinst *)op->o_bd->bd_info;
 175                 nc->nc_nentries = 0;
 176                 nc->nc_nsearchref = 0;
 177                 nc->nc_save_attrs = op->ors_attrs;
 178                 nc->nc_pdummy = &dummy;
 179
 180                 sc->sc_response = noopsrch_response;
 181                 sc->sc_cleanup = noopsrch_cleanup;
 182                 sc->sc_private = (void *)nc;
 183
 184                 op->ors_attrs = slap_anlist_no_attrs;
 185
 186                 sc->sc_next = op->o_callback->sc_next;
 187                 op->o_callback->sc_next = sc;
 188         }
 189
 190         return SLAP_CB_CONTINUE;
 191 }
 192
 193 static int noopsrch_cnt;
 194
 195 static int
 196 noopsrch_db_init( BackendDB *be, ConfigReply *cr)
 197 {
 198         if ( noopsrch_cnt++ == 0 ) {
 199                 int rc;
 200
 201                 rc = register_supported_control( LDAP_CONTROL_X_NOOPSRCH,
 202                         SLAP_CTRL_SEARCH | SLAP_CTRL_GLOBAL_SEARCH, NULL,
 203                         noopsrch_parseCtrl, &noopsrch_cid );
 204                 if ( rc != LDAP_SUCCESS ) {
 205                         Debug( LDAP_DEBUG_ANY,
 206                                 "noopsrch_initialize: Failed to register control '%s' (%d)\n",
 207                                 LDAP_CONTROL_X_NOOPSRCH, rc, 0 );
 208                         return rc;
 209                 }
 210         }
 211
 212         return LDAP_SUCCESS;
 213 }
 214
 215 static int
 216 noopsrch_db_destroy( BackendDB *be, ConfigReply *cr )
 217 {
 218         assert( noopsrch_cnt > 0 );
 219
 220 #ifdef SLAP_CONFIG_DELETE
 221         overlay_unregister_control( be, LDAP_CONTROL_X_NOOPSRCH );
 222         if ( --noopsrch_cnt == 0 ) {
 223                 unregister_supported_control( LDAP_CONTROL_X_NOOPSRCH );
 224         }
 225
 226 #endif /* SLAP_CONFIG_DELETE */
 227
 228         return 0;
 229 }
 230
 231 #if SLAPD_OVER_NOOPSRCH == SLAPD_MOD_DYNAMIC
 232 static
 233 #endif /* SLAPD_OVER_NOOPSRCH == SLAPD_MOD_DYNAMIC */
 234 int
 235 noopsrch_initialize( void )
 236 {
 237
 238         noopsrch.on_bi.bi_type = "noopsrch";
 239
 240         noopsrch.on_bi.bi_db_init = noopsrch_db_init;
 241         noopsrch.on_bi.bi_db_destroy = noopsrch_db_destroy;
 242         noopsrch.on_bi.bi_op_search = noopsrch_op_search;
 243
 244         return overlay_register( &noopsrch );
 245 }
 246
 247 #if SLAPD_OVER_NOOPSRCH == SLAPD_MOD_DYNAMIC
 248 int
 249 init_module( int argc, char *argv[] )
 250 {
 251         return noopsrch_initialize();
 252 }
 253 #endif /* SLAPD_OVER_NOOPSRCH == SLAPD_MOD_DYNAMIC */
 254
 255 #endif /* SLAPD_OVER_NOOPSRCH */