Diff for /servers/slapd/back-monitor/init.c between versions 1.89 and 1.89.2.16

version 1.89, 2004/12/08 18:21:37 version 1.89.2.16, 2006/01/03 22:16:21
Line 1 Line 1
 /* init.c - initialize monitor backend */  /* init.c - initialize monitor backend */
 /* $OpenLDAP: pkg/ldap/servers/slapd/back-monitor/init.c,v 1.88 2004/11/26 23:57:38 hyc Exp $ */  /* $OpenLDAP: pkg/ldap/servers/slapd/back-monitor/init.c,v 1.89.2.15 2005/11/28 18:43:06 kurt Exp $ */
 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.  /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
  *   *
  * Copyright 2001-2004 The OpenLDAP Foundation.   * Copyright 2001-2006 The OpenLDAP Foundation.
  * Portions Copyright 2001-2003 Pierangelo Masarati.   * Portions Copyright 2001-2003 Pierangelo Masarati.
  * All rights reserved.   * All rights reserved.
  *   *
Line 26 Line 26
   
 #include <lutil.h>  #include <lutil.h>
 #include "slap.h"  #include "slap.h"
   #include "config.h"
 #include "lber_pvt.h"  #include "lber_pvt.h"
 #include "back-monitor.h"  #include "back-monitor.h"
   
Line 38 Line 39
  * so it should not be used outside monitor_back_db_init()   * so it should not be used outside monitor_back_db_init()
  * until monitor_back_db_open is called.   * until monitor_back_db_open is called.
  */   */
 BackendDB *be_monitor = NULL;  BackendDB                       *be_monitor;
   
 static struct monitor_subsys_t  **monitor_subsys = NULL;  static struct monitor_subsys_t  **monitor_subsys;
 static int                      monitor_subsys_opened = 0;  static int                      monitor_subsys_opened;
   static monitor_info_t           monitor_info;
   
 /*  /*
  * subsystem data   * subsystem data
Line 56  static struct monitor_subsys_t known_mon Line 58  static struct monitor_subsys_t known_mon
         {           { 
                 SLAPD_MONITOR_BACKEND_NAME,                   SLAPD_MONITOR_BACKEND_NAME, 
                 BER_BVNULL, BER_BVNULL, BER_BVNULL,                  BER_BVNULL, BER_BVNULL, BER_BVNULL,
                   { BER_BVC( "This subsystem contains information about available backends." ),
                           BER_BVNULL },
                 MONITOR_F_PERSISTENT_CH,                  MONITOR_F_PERSISTENT_CH,
                 monitor_subsys_backend_init,                  monitor_subsys_backend_init,
                   NULL,   /* destroy */
                 NULL,   /* update */                  NULL,   /* update */
                 NULL,   /* create */                  NULL,   /* create */
                 NULL    /* modify */                  NULL    /* modify */
         }, {           }, { 
                 SLAPD_MONITOR_CONN_NAME,                  SLAPD_MONITOR_CONN_NAME,
                 BER_BVNULL, BER_BVNULL, BER_BVNULL,                  BER_BVNULL, BER_BVNULL, BER_BVNULL,
                   { BER_BVC( "This subsystem contains information about connections." ),
                           BER_BVNULL },
                 MONITOR_F_VOLATILE_CH,                  MONITOR_F_VOLATILE_CH,
                 monitor_subsys_conn_init,                  monitor_subsys_conn_init,
                 monitor_subsys_conn_update,                  NULL,   /* destroy */
                 monitor_subsys_conn_create,                  NULL,   /* update */
                   NULL,   /* create */
                 NULL    /* modify */                  NULL    /* modify */
         }, {           }, { 
                 SLAPD_MONITOR_DATABASE_NAME,                      SLAPD_MONITOR_DATABASE_NAME,    
                 BER_BVNULL, BER_BVNULL, BER_BVNULL,                  BER_BVNULL, BER_BVNULL, BER_BVNULL,
                   { BER_BVC( "This subsystem contains information about configured databases." ),
                           BER_BVNULL },
                 MONITOR_F_PERSISTENT_CH,                  MONITOR_F_PERSISTENT_CH,
                 monitor_subsys_database_init,                  monitor_subsys_database_init,
                   NULL,   /* destroy */
                 NULL,   /* update */                  NULL,   /* update */
                 NULL,   /* create */                  NULL,   /* create */
                 monitor_subsys_database_modify                  NULL    /* modify */
         }, {           }, { 
                 SLAPD_MONITOR_LISTENER_NAME,                      SLAPD_MONITOR_LISTENER_NAME,    
                 BER_BVNULL, BER_BVNULL, BER_BVNULL,                  BER_BVNULL, BER_BVNULL, BER_BVNULL,
                   { BER_BVC( "This subsystem contains information about active listeners." ),
                           BER_BVNULL },
                 MONITOR_F_PERSISTENT_CH,                  MONITOR_F_PERSISTENT_CH,
                 monitor_subsys_listener_init,                  monitor_subsys_listener_init,
                   NULL,   /* destroy */
                 NULL,   /* update */                  NULL,   /* update */
                 NULL,   /* create */                  NULL,   /* create */
                 NULL    /* modify */                  NULL    /* modify */
         }, {           }, { 
                 SLAPD_MONITOR_LOG_NAME,                  SLAPD_MONITOR_LOG_NAME,
                 BER_BVNULL, BER_BVNULL, BER_BVNULL,                  BER_BVNULL, BER_BVNULL, BER_BVNULL,
                   { BER_BVC( "This subsystem contains information about logging." ),
                           BER_BVC( "Set the attribute \"managedInfo\" to the desired log levels." ),
                           BER_BVNULL },
                 MONITOR_F_NONE,                  MONITOR_F_NONE,
                 monitor_subsys_log_init,                  monitor_subsys_log_init,
                   NULL,   /* destroy */
                 NULL,   /* update */                  NULL,   /* update */
                 NULL,   /* create */                  NULL,   /* create */
                 monitor_subsys_log_modify                  NULL,   /* modify */
         }, {           }, { 
                 SLAPD_MONITOR_OPS_NAME,                  SLAPD_MONITOR_OPS_NAME,
                 BER_BVNULL, BER_BVNULL, BER_BVNULL,                  BER_BVNULL, BER_BVNULL, BER_BVNULL,
                   { BER_BVC( "This subsystem contains information about performed operations." ),
                           BER_BVNULL },
                 MONITOR_F_PERSISTENT_CH,                  MONITOR_F_PERSISTENT_CH,
                 monitor_subsys_ops_init,                  monitor_subsys_ops_init,
                 monitor_subsys_ops_update,                  NULL,   /* destroy */
                   NULL,   /* update */
                 NULL,   /* create */                  NULL,   /* create */
                 NULL,   /* modify */                  NULL,   /* modify */
         }, {           }, { 
                 SLAPD_MONITOR_OVERLAY_NAME,                  SLAPD_MONITOR_OVERLAY_NAME,
                 BER_BVNULL, BER_BVNULL, BER_BVNULL,                  BER_BVNULL, BER_BVNULL, BER_BVNULL,
                   { BER_BVC( "This subsystem contains information about available overlays." ),
                           BER_BVNULL },
                 MONITOR_F_PERSISTENT_CH,                  MONITOR_F_PERSISTENT_CH,
                 monitor_subsys_overlay_init,                  monitor_subsys_overlay_init,
                   NULL,   /* destroy */
                 NULL,   /* update */                  NULL,   /* update */
                 NULL,   /* create */                  NULL,   /* create */
                 NULL,   /* modify */                  NULL,   /* modify */
         }, {           }, { 
                 SLAPD_MONITOR_SASL_NAME,                          SLAPD_MONITOR_SASL_NAME,        
                 BER_BVNULL, BER_BVNULL, BER_BVNULL,                  BER_BVNULL, BER_BVNULL, BER_BVNULL,
                   { BER_BVC( "This subsystem contains information about SASL." ),
                           BER_BVNULL },
                 MONITOR_F_NONE,                  MONITOR_F_NONE,
                 NULL,   /* init */                  NULL,   /* init */
                   NULL,   /* destroy */
                 NULL,   /* update */                  NULL,   /* update */
                 NULL,   /* create */                  NULL,   /* create */
                 NULL    /* modify */                  NULL    /* modify */
         }, {           }, { 
                 SLAPD_MONITOR_SENT_NAME,                  SLAPD_MONITOR_SENT_NAME,
                 BER_BVNULL, BER_BVNULL, BER_BVNULL,                  BER_BVNULL, BER_BVNULL, BER_BVNULL,
                   { BER_BVC( "This subsystem contains statistics." ),
                           BER_BVNULL },
                 MONITOR_F_PERSISTENT_CH,                  MONITOR_F_PERSISTENT_CH,
                 monitor_subsys_sent_init,                  monitor_subsys_sent_init,
                 monitor_subsys_sent_update,                  NULL,   /* destroy */
                   NULL,   /* update */
                 NULL,   /* create */                  NULL,   /* create */
                 NULL,   /* modify */                  NULL,   /* modify */
         }, {           }, { 
                 SLAPD_MONITOR_THREAD_NAME,                        SLAPD_MONITOR_THREAD_NAME,      
                 BER_BVNULL, BER_BVNULL, BER_BVNULL,                  BER_BVNULL, BER_BVNULL, BER_BVNULL,
                   { BER_BVC( "This subsystem contains information about threads." ),
                           BER_BVNULL },
                 MONITOR_F_PERSISTENT_CH,                  MONITOR_F_PERSISTENT_CH,
                 monitor_subsys_thread_init,                  monitor_subsys_thread_init,
                 monitor_subsys_thread_update,                  NULL,   /* destroy */
                   NULL,   /* update */
                 NULL,   /* create */                  NULL,   /* create */
                 NULL    /* modify */                  NULL    /* modify */
         }, {           }, { 
                 SLAPD_MONITOR_TIME_NAME,                  SLAPD_MONITOR_TIME_NAME,
                 BER_BVNULL, BER_BVNULL, BER_BVNULL,                  BER_BVNULL, BER_BVNULL, BER_BVNULL,
                   { BER_BVC( "This subsystem contains information about time." ),
                           BER_BVNULL },
                 MONITOR_F_PERSISTENT_CH,                  MONITOR_F_PERSISTENT_CH,
                 monitor_subsys_time_init,                  monitor_subsys_time_init,
                 monitor_subsys_time_update,                  NULL,   /* destroy */
                   NULL,   /* update */
                 NULL,   /* create */                  NULL,   /* create */
                 NULL,   /* modify */                  NULL,   /* modify */
         }, {           }, { 
                 SLAPD_MONITOR_TLS_NAME,                  SLAPD_MONITOR_TLS_NAME,
                 BER_BVNULL, BER_BVNULL, BER_BVNULL,                  BER_BVNULL, BER_BVNULL, BER_BVNULL,
                   { BER_BVC( "This subsystem contains information about TLS." ),
                           BER_BVNULL },
                 MONITOR_F_NONE,                  MONITOR_F_NONE,
                 NULL,   /* init */                  NULL,   /* init */
                   NULL,   /* destroy */
                 NULL,   /* update */                  NULL,   /* update */
                 NULL,   /* create */                  NULL,   /* create */
                 NULL    /* modify */                  NULL    /* modify */
         }, {           }, { 
                 SLAPD_MONITOR_RWW_NAME,                  SLAPD_MONITOR_RWW_NAME,
                 BER_BVNULL, BER_BVNULL, BER_BVNULL,                  BER_BVNULL, BER_BVNULL, BER_BVNULL,
                   { BER_BVC( "This subsystem contains information about read/write waiters." ),
                           BER_BVNULL },
                 MONITOR_F_PERSISTENT_CH,                  MONITOR_F_PERSISTENT_CH,
                 monitor_subsys_rww_init,                  monitor_subsys_rww_init,
                 monitor_subsys_rww_update,                  NULL,   /* destroy */
                   NULL,   /* update */
                 NULL,   /* create */                  NULL,   /* create */
                 NULL    /* modify */                  NULL    /* modify */
         }, { NULL }          }, { NULL }
 };  };
   
 int  int
 monitor_back_register_subsys( monitor_subsys_t *ms )  monitor_back_register_subsys(
           monitor_subsys_t        *ms )
 {  {
         int     i = 0;          int     i = 0;
   
Line 187  monitor_back_register_subsys( monitor_su Line 230  monitor_back_register_subsys( monitor_su
   
                 /* FIXME: this should only be possible                  /* FIXME: this should only be possible
                  * if be_monitor is already initialized */                   * if be_monitor is already initialized */
                 assert( be_monitor );                  assert( be_monitor != NULL );
   
                 if ( ms->mss_open && ( *ms->mss_open )( be_monitor, ms ) ) {                  if ( ms->mss_open && ( *ms->mss_open )( be_monitor, ms ) ) {
                         return -1;                          return -1;
Line 201  monitor_back_register_subsys( monitor_su Line 244  monitor_back_register_subsys( monitor_su
   
 enum {  enum {
         LIMBO_ENTRY,          LIMBO_ENTRY,
           LIMBO_ENTRY_PARENT,
         LIMBO_ATTRS,          LIMBO_ATTRS,
         LIMBO_CB          LIMBO_CB
 };  };
Line 218  typedef struct entry_limbo_t { Line 262  typedef struct entry_limbo_t {
 } entry_limbo_t;  } entry_limbo_t;
   
 int  int
   monitor_back_is_configured( void )
   {
           return be_monitor != NULL;
   }
   
   int
 monitor_back_register_entry(  monitor_back_register_entry(
                 Entry                   *e,          Entry                   *e,
                 monitor_callback_t      *cb )          monitor_callback_t      *cb )
 {  {
         monitor_info_t  *mi = ( monitor_info_t * )be_monitor->be_private;          monitor_info_t  *mi;
   
           if ( be_monitor == NULL ) {
                   Debug( LDAP_DEBUG_ANY,
                           "monitor_back_register_entry(\"%s\"): "
                           "monitor database not configured.\n",
                           e->e_name.bv_val, 0, 0 );
                   return -1;
           }
   
           mi = ( monitor_info_t * )be_monitor->be_private;
   
         assert( mi != NULL );          assert( mi != NULL );
         assert( e != NULL );          assert( e != NULL );
Line 281  monitor_back_register_entry( Line 341  monitor_back_register_entry(
                 }                  }
   
                 e_new = entry_dup( e );                  e_new = entry_dup( e );
                 if ( e == NULL ) {                  if ( e_new == NULL ) {
                         Debug( LDAP_DEBUG_ANY,                          Debug( LDAP_DEBUG_ANY,
                                 "monitor_back_register_entry(\"%s\"): "                                  "monitor_back_register_entry(\"%s\"): "
                                 "entry_dup() failed\n",                                  "entry_dup() failed\n",
Line 293  monitor_back_register_entry( Line 353  monitor_back_register_entry(
                 e_new->e_private = ( void * )mp;                  e_new->e_private = ( void * )mp;
                 mp->mp_info = mp_parent->mp_info;                  mp->mp_info = mp_parent->mp_info;
                 mp->mp_flags = mp_parent->mp_flags | MONITOR_F_SUB;                  mp->mp_flags = mp_parent->mp_flags | MONITOR_F_SUB;
                   mp->mp_cb = cb;
   
                 ep = &mp_parent->mp_children;                  ep = &mp_parent->mp_children;
                 for ( ; *ep; ) {                  for ( ; *ep; ) {
Line 326  done:; Line 387  done:;
                 }                  }
   
         } else {          } else {
                 entry_limbo_t   *elp, el = { 0 };                  entry_limbo_t   **elpp, el = { 0 };
   
                 el.el_type = LIMBO_ENTRY;                  el.el_type = LIMBO_ENTRY;
   
Line 341  done:; Line 402  done:;
                                   
                 el.el_cb = cb;                  el.el_cb = cb;
   
                 elp = (entry_limbo_t *)ch_malloc( sizeof( entry_limbo_t ) );                  for ( elpp = (entry_limbo_t **)&mi->mi_entry_limbo;
                 if ( elp ) {                                  *elpp;
                                   elpp = &(*elpp)->el_next )
                           /* go to last */;
   
                   *elpp = (entry_limbo_t *)ch_malloc( sizeof( entry_limbo_t ) );
                   if ( *elpp == NULL ) {
                         el.el_e->e_private = NULL;                          el.el_e->e_private = NULL;
                         entry_free( el.el_e );                          entry_free( el.el_e );
                         return -1;                          return -1;
                 }                  }
   
                 el.el_next = (entry_limbo_t *)mi->mi_entry_limbo;                  el.el_next = NULL;
                 *elp = el;                  **elpp = el;
                 mi->mi_entry_limbo = (void *)elp;          }
   
           return 0;
   }
   
   int
   monitor_back_register_entry_parent(
           Entry                   *e,
           monitor_callback_t      *cb,
           struct berval           *base,
           int                     scope,
           struct berval           *filter )
   {
           monitor_info_t  *mi;
           struct berval   ndn = BER_BVNULL;
   
           if ( be_monitor == NULL ) {
                   Debug( LDAP_DEBUG_ANY,
                           "monitor_back_register_entry_parent(base=\"%s\" scope=%s filter=\"%s\"): "
                           "monitor database not configured.\n",
                           BER_BVISNULL( base ) ? "" : base->bv_val,
                           scope == LDAP_SCOPE_BASE ? "base" : ( scope == LDAP_SCOPE_ONELEVEL ? "one" : "subtree" ),
                           BER_BVISNULL( filter ) ? "" : filter->bv_val );
                   return -1;
           }
   
           mi = ( monitor_info_t * )be_monitor->be_private;
   
           assert( mi != NULL );
           assert( e != NULL );
           assert( e->e_private == NULL );
   
           if ( BER_BVISNULL( filter ) ) {
                   /* need a filter */
                   Debug( LDAP_DEBUG_ANY,
                           "monitor_back_register_entry_parent(\"\"): "
                           "need a valid filter\n",
                           0, 0, 0 );
                   return -1;
           }
   
           if ( monitor_subsys_opened ) {
                   Entry           *e_parent = NULL,
                                   *e_new = NULL,
                                   **ep = NULL;
                   struct berval   e_name = BER_BVNULL,
                                   e_nname = BER_BVNULL;
                   monitor_entry_t *mp = NULL,
                                   *mp_parent = NULL;
                   int             rc = 0;
   
                   if ( monitor_filter2ndn( base, scope, filter, &ndn ) ) {
                           /* entry does not exist */
                           Debug( LDAP_DEBUG_ANY,
                                   "monitor_back_register_entry_parent(\"\"): "
                                   "base=%s scope=%d filter=%s : "
                                   "unable to find entry\n",
                                   base->bv_val ? base->bv_val : "\"\"",
                                   scope, filter->bv_val );
                           return -1;
                   }
   
                   if ( monitor_cache_get( mi, &ndn, &e_parent ) != 0 ) {
                           /* entry does not exist */
                           Debug( LDAP_DEBUG_ANY,
                                   "monitor_back_register_entry_parent(\"%s\"): "
                                   "parent entry does not exist\n",
                                   ndn.bv_val, 0, 0 );
                           rc = -1;
                           goto done;
                   }
   
                   assert( e_parent->e_private != NULL );
                   mp_parent = ( monitor_entry_t * )e_parent->e_private;
   
                   if ( mp_parent->mp_flags & MONITOR_F_VOLATILE ) {
                           /* entry is volatile; cannot append callback */
                           Debug( LDAP_DEBUG_ANY,
                                   "monitor_back_register_entry_parent(\"%s\"): "
                                   "entry is volatile\n",
                                   e_parent->e_name.bv_val, 0, 0 );
                           rc = -1;
                           goto done;
                   }
   
                   build_new_dn( &e_name, &e_parent->e_name, &e->e_name, NULL );
                   build_new_dn( &e_nname, &e_parent->e_nname, &e->e_nname, NULL );
   
                   if ( monitor_cache_get( mi, &e_nname, &e_new ) == 0 ) {
                           /* entry already exists */
                           Debug( LDAP_DEBUG_ANY,
                                   "monitor_back_register_entry_parent(\"%s\"): "
                                   "entry already exists\n",
                                   e_name.bv_val, 0, 0 );
                           monitor_cache_release( mi, e_new );
                           rc = -1;
                           goto done;
                   }
   
                   mp = monitor_entrypriv_create();
                   if ( mp == NULL ) {
                           Debug( LDAP_DEBUG_ANY,
                                   "monitor_back_register_entry_parent(\"%s\"): "
                                   "monitor_entrypriv_create() failed\n",
                                   e->e_name.bv_val, 0, 0 );
                           rc = -1;
                           goto done;
                   }
   
                   e_new = entry_dup( e );
                   if ( e_new == NULL ) {
                           Debug( LDAP_DEBUG_ANY,
                                   "monitor_back_register_entry(\"%s\"): "
                                   "entry_dup() failed\n",
                                   e->e_name.bv_val, 0, 0 );
                           rc = -1;
                           goto done;
                   }
                   ch_free( e_new->e_name.bv_val );
                   ch_free( e_new->e_nname.bv_val );
                   e_new->e_name = e_name;
                   e_new->e_nname = e_nname;
                   
                   e_new->e_private = ( void * )mp;
                   mp->mp_info = mp_parent->mp_info;
                   mp->mp_flags = mp_parent->mp_flags | MONITOR_F_SUB;
                   mp->mp_cb = cb;
   
                   ep = &mp_parent->mp_children;
                   for ( ; *ep; ) {
                           mp_parent = ( monitor_entry_t * )(*ep)->e_private;
                           ep = &mp_parent->mp_next;
                   }
                   *ep = e_new;
   
                   if ( monitor_cache_add( mi, e_new ) ) {
                           Debug( LDAP_DEBUG_ANY,
                                   "monitor_back_register_entry(\"%s\"): "
                                   "unable to add entry\n",
                                   e->e_name.bv_val, 0, 0 );
                           rc = -1;
                           goto done;
                   }
   
   done:;
                   if ( !BER_BVISNULL( &ndn ) ) {
                           ch_free( ndn.bv_val );
                   }
   
                   if ( rc ) {
                           if ( mp ) {
                                   ch_free( mp );
                           }
                           if ( e_new ) {
                                   e_new->e_private = NULL;
                                   entry_free( e_new );
                           }
                   }
   
                   if ( e_parent ) {
                           monitor_cache_release( mi, e_parent );
                   }
   
           } else {
                   entry_limbo_t   **elpp, el = { 0 };
   
                   el.el_type = LIMBO_ENTRY_PARENT;
   
                   el.el_e = entry_dup( e );
                   if ( el.el_e == NULL ) {
                           Debug( LDAP_DEBUG_ANY,
                                   "monitor_back_register_entry(\"%s\"): "
                                   "entry_dup() failed\n",
                                   e->e_name.bv_val, 0, 0 );
                           return -1;
                   }
                   
                   if ( !BER_BVISNULL( base ) ) {
                           ber_dupbv( &el.el_base, base );
                   }
                   el.el_scope = scope;
                   if ( !BER_BVISNULL( filter ) ) {
                           ber_dupbv( &el.el_filter, filter );
                   }
   
                   el.el_cb = cb;
   
                   for ( elpp = (entry_limbo_t **)&mi->mi_entry_limbo;
                                   *elpp;
                                   elpp = &(*elpp)->el_next )
                           /* go to last */;
   
                   *elpp = (entry_limbo_t *)ch_malloc( sizeof( entry_limbo_t ) );
                   if ( *elpp == NULL ) {
                           el.el_e->e_private = NULL;
                           entry_free( el.el_e );
                           return -1;
                   }
   
                   el.el_next = NULL;
                   **elpp = el;
         }          }
   
         return 0;          return 0;
Line 369  monitor_filter2ndn_cb( Operation *op, Sl Line 635  monitor_filter2ndn_cb( Operation *op, Sl
 }  }
   
 int  int
 monitor_filter2ndn( struct berval *base, int scope, struct berval *filter,  monitor_filter2ndn(
                 struct berval *ndn )          struct berval   *base,
           int             scope,
           struct berval   *filter,
           struct berval   *ndn )
 {  {
         Connection      conn = { 0 };          Connection      conn = { 0 };
         char opbuf[OPERATION_BUFFER_SIZE];          OperationBuffer opbuf;
         Operation       *op;          Operation       *op;
         SlapReply       rs = { 0 };          SlapReply       rs = { 0 };
         slap_callback   cb = { NULL, monitor_filter2ndn_cb, NULL, NULL };          slap_callback   cb = { NULL, monitor_filter2ndn_cb, NULL, NULL };
         AttributeName   anlist[ 2 ];  
         int             rc;          int             rc;
   
         BER_BVZERO( ndn );          BER_BVZERO( ndn );
Line 386  monitor_filter2ndn( struct berval *base, Line 654  monitor_filter2ndn( struct berval *base,
                 return -1;                  return -1;
         }          }
   
         op = (Operation *)opbuf;          op = (Operation *) &opbuf;
         connection_fake_init( &conn, op, &conn );          connection_fake_init( &conn, op, &conn );
   
         op->o_tag = LDAP_REQ_SEARCH;          op->o_tag = LDAP_REQ_SEARCH;
   
         /* use global malloc for now */          /* use global malloc for now */
         op->o_tmpmemctx = NULL;          if ( op->o_tmpmemctx ) {
                   /* FIXME: connection_fake_init() calls slap_sl_mem_create, so we destroy it for now */
                   slap_sl_mem_destroy( NULL, op->o_tmpmemctx );
                   op->o_tmpmemctx = NULL;
           }
         op->o_tmpmfuncs = &ch_mfuncs;          op->o_tmpmfuncs = &ch_mfuncs;
   
         op->o_bd = be_monitor;          op->o_bd = be_monitor;
Line 405  monitor_filter2ndn( struct berval *base, Line 677  monitor_filter2ndn( struct berval *base,
         } else {          } else {
                 if ( dnPrettyNormal( NULL, base, &op->o_req_dn, &op->o_req_ndn,                  if ( dnPrettyNormal( NULL, base, &op->o_req_dn, &op->o_req_ndn,
                                         op->o_tmpmemctx ) ) {                                          op->o_tmpmemctx ) ) {
                         /* error */                          return -1;
                 }                  }
         }          }
   
Line 415  monitor_filter2ndn( struct berval *base, Line 687  monitor_filter2ndn( struct berval *base,
         op->ors_scope = scope;          op->ors_scope = scope;
         ber_dupbv_x( &op->ors_filterstr, filter, op->o_tmpmemctx );          ber_dupbv_x( &op->ors_filterstr, filter, op->o_tmpmemctx );
         op->ors_filter = str2filter_x( op, filter->bv_val );          op->ors_filter = str2filter_x( op, filter->bv_val );
         op->ors_attrs = anlist;          op->ors_attrs = slap_anlist_no_attrs;
         BER_BVSTR( &anlist[ 0 ].an_name, LDAP_NO_ATTRS );  
         BER_BVZERO( &anlist[ 1 ].an_name );  
         op->ors_attrsonly = 0;          op->ors_attrsonly = 0;
         op->ors_tlimit = SLAP_NO_LIMIT;          op->ors_tlimit = SLAP_NO_LIMIT;
         op->ors_slimit = 1;          op->ors_slimit = 1;
Line 427  monitor_filter2ndn( struct berval *base, Line 697  monitor_filter2ndn( struct berval *base,
         op->o_nocaching = 1;          op->o_nocaching = 1;
         op->o_managedsait = SLAP_CONTROL_NONCRITICAL;          op->o_managedsait = SLAP_CONTROL_NONCRITICAL;
   
           op->o_dn = be_monitor->be_rootdn;
           op->o_ndn = be_monitor->be_rootndn;
   
         rc = op->o_bd->be_search( op, &rs );          rc = op->o_bd->be_search( op, &rs );
   
         filter_free_x( op, op->ors_filter );          filter_free_x( op, op->ors_filter );
Line 460  monitor_filter2ndn( struct berval *base, Line 733  monitor_filter2ndn( struct berval *base,
   
 int  int
 monitor_back_register_entry_attrs(  monitor_back_register_entry_attrs(
                 struct berval           *ndn_in,          struct berval           *ndn_in,
                 Attribute               *a,          Attribute               *a,
                 monitor_callback_t      *cb,          monitor_callback_t      *cb,
                 struct berval           *base,          struct berval           *base,
                 int                     scope,          int                     scope,
                 struct berval           *filter )          struct berval           *filter )
 {  {
         monitor_info_t  *mi = ( monitor_info_t * )be_monitor->be_private;          monitor_info_t  *mi;
         struct berval   ndn = BER_BVNULL;          struct berval   ndn = BER_BVNULL;
           char            *fname = ( a == NULL ? "callback" : "attrs" );
   
           if ( be_monitor == NULL ) {
                   char            buf[ SLAP_TEXT_BUFLEN ];
   
                   snprintf( buf, sizeof( buf ),
                           "monitor_back_register_entry_%s(base=\"%s\" scope=%s filter=\"%s\"): "
                           "monitor database not configured.\n",
                           fname,
                           BER_BVISNULL( base ) ? "" : base->bv_val,
                           scope == LDAP_SCOPE_BASE ? "base" : ( scope == LDAP_SCOPE_ONELEVEL ? "one" : "subtree" ),
                           BER_BVISNULL( filter ) ? "" : filter->bv_val );
                   Debug( LDAP_DEBUG_ANY, "%s\n", buf, 0, 0 );
   
                   return -1;
           }
   
           mi = ( monitor_info_t * )be_monitor->be_private;
   
         assert( mi != NULL );          assert( mi != NULL );
   
Line 486  monitor_back_register_entry_attrs( Line 777  monitor_back_register_entry_attrs(
         {          {
                 /* need a filter */                  /* need a filter */
                 Debug( LDAP_DEBUG_ANY,                  Debug( LDAP_DEBUG_ANY,
                         "monitor_back_register_entry_*(\"\"): "                          "monitor_back_register_entry_%s(\"\"): "
                         "need a valid filter\n",                          "need a valid filter\n",
                         0, 0, 0 );                          fname, 0, 0 );
                 return -1;                  return -1;
         }          }
   
Line 502  monitor_back_register_entry_attrs( Line 793  monitor_back_register_entry_attrs(
   
                 if ( BER_BVISNULL( &ndn ) ) {                  if ( BER_BVISNULL( &ndn ) ) {
                         if ( monitor_filter2ndn( base, scope, filter, &ndn ) ) {                          if ( monitor_filter2ndn( base, scope, filter, &ndn ) ) {
                                 /* entry does not exist */                                  char            buf[ SLAP_TEXT_BUFLEN ];
                                 Debug( LDAP_DEBUG_ANY,  
                                         "monitor_back_register_entry_*(\"\"): "                                  snprintf( buf, sizeof( buf ),
                                           "monitor_back_register_entry_%s(\"\"): "
                                         "base=%s scope=%d filter=%s : "                                          "base=%s scope=%d filter=%s : "
                                         "unable to find entry\n",                                          "unable to find entry\n",
                                           fname,
                                         base->bv_val ? base->bv_val : "\"\"",                                          base->bv_val ? base->bv_val : "\"\"",
                                         scope, filter->bv_val );                                          scope, filter->bv_val );
   
                                   /* entry does not exist */
                                   Debug( LDAP_DEBUG_ANY, "%s\n", buf, 0, 0 );
                                 return -1;                                  return -1;
                         }                          }
   
Line 518  monitor_back_register_entry_attrs( Line 814  monitor_back_register_entry_attrs(
                 if ( monitor_cache_get( mi, &ndn, &e ) != 0 ) {                  if ( monitor_cache_get( mi, &ndn, &e ) != 0 ) {
                         /* entry does not exist */                          /* entry does not exist */
                         Debug( LDAP_DEBUG_ANY,                          Debug( LDAP_DEBUG_ANY,
                                 "monitor_back_register_entry_*(\"%s\"): "                                  "monitor_back_register_entry_%s(\"%s\"): "
                                 "entry does not exist\n",                                  "entry does not exist\n",
                                 ndn.bv_val, 0, 0 );                                  fname, ndn.bv_val, 0 );
                         rc = -1;                          rc = -1;
                         goto done;                          goto done;
                 }                  }
Line 531  monitor_back_register_entry_attrs( Line 827  monitor_back_register_entry_attrs(
                 if ( mp->mp_flags & MONITOR_F_VOLATILE ) {                  if ( mp->mp_flags & MONITOR_F_VOLATILE ) {
                         /* entry is volatile; cannot append callback */                          /* entry is volatile; cannot append callback */
                         Debug( LDAP_DEBUG_ANY,                          Debug( LDAP_DEBUG_ANY,
                                 "monitor_back_register_entry_*(\"%s\"): "                                  "monitor_back_register_entry_%s(\"%s\"): "
                                 "entry is volatile\n",                                  "entry is volatile\n",
                                 e->e_name.bv_val, 0, 0 );                                  fname, e->e_name.bv_val, 0 );
                         rc = -1;                          rc = -1;
                         goto done;                          goto done;
                 }                  }
Line 545  monitor_back_register_entry_attrs( Line 841  monitor_back_register_entry_attrs(
                         *atp = attrs_dup( a );                          *atp = attrs_dup( a );
                         if ( *atp == NULL ) {                          if ( *atp == NULL ) {
                                 Debug( LDAP_DEBUG_ANY,                                  Debug( LDAP_DEBUG_ANY,
                                         "monitor_back_register_entry_*(\"%s\"): "                                          "monitor_back_register_entry_%s(\"%s\"): "
                                         "attrs_dup() failed\n",                                          "attrs_dup() failed\n",
                                         e->e_name.bv_val, 0, 0 );                                          fname, e->e_name.bv_val, 0 );
                                 rc = -1;                                  rc = -1;
                                 goto done;                                  goto done;
                         }                          }
Line 579  done:; Line 875  done:;
                 }                  }
   
         } else {          } else {
                 entry_limbo_t   *elp, el = { 0 };                  entry_limbo_t   **elpp, el = { 0 };
   
                 el.el_type = LIMBO_ATTRS;                  el.el_type = LIMBO_ATTRS;
                 if ( !BER_BVISNULL( &ndn ) ) {                  if ( !BER_BVISNULL( &ndn ) ) {
Line 596  done:; Line 892  done:;
                 el.el_a = attrs_dup( a );                  el.el_a = attrs_dup( a );
                 el.el_cb = cb;                  el.el_cb = cb;
   
                 elp = (entry_limbo_t *)ch_malloc( sizeof( entry_limbo_t ) );                  for ( elpp = (entry_limbo_t **)&mi->mi_entry_limbo;
                 if ( elp == NULL ) {                                  *elpp;
                         attrs_free( a );                                  elpp = &(*elpp)->el_next )
                           /* go to last */;
   
                   *elpp = (entry_limbo_t *)ch_malloc( sizeof( entry_limbo_t ) );
                   if ( *elpp == NULL ) {
                           el.el_e->e_private = NULL;
                           entry_free( el.el_e );
                         return -1;                          return -1;
                 }                  }
   
                 el.el_next = (entry_limbo_t *)mi->mi_entry_limbo;                  el.el_next = NULL;
                 *elp = el;                  **elpp = el;
                 mi->mi_entry_limbo = (void *)elp;;  
         }          }
   
         return 0;          return 0;
Line 612  done:; Line 913  done:;
   
 int  int
 monitor_back_register_entry_callback(  monitor_back_register_entry_callback(
                 struct berval           *ndn,          struct berval           *ndn,
                 monitor_callback_t      *cb,          monitor_callback_t      *cb,
                 struct berval           *base,          struct berval           *base,
                 int                     scope,          int                     scope,
                 struct berval           *filter )          struct berval           *filter )
 {  {
         return monitor_back_register_entry_attrs( ndn, NULL, cb,          return monitor_back_register_entry_attrs( ndn, NULL, cb,
                         base, scope, filter );                          base, scope, filter );
Line 639  monitor_back_get_subsys( const char *nam Line 940  monitor_back_get_subsys( const char *nam
 }  }
   
 monitor_subsys_t *  monitor_subsys_t *
 monitor_back_get_subsys_by_dn( struct berval *ndn, int sub )  monitor_back_get_subsys_by_dn(
           struct berval   *ndn,
           int             sub )
 {  {
         if ( monitor_subsys != NULL ) {          if ( monitor_subsys != NULL ) {
                 int     i;                  int     i;
Line 665  monitor_back_get_subsys_by_dn( struct be Line 968  monitor_back_get_subsys_by_dn( struct be
   
 int  int
 monitor_back_initialize(  monitor_back_initialize(
         BackendInfo     *bi          BackendInfo     *bi )
 )  
 {  {
         monitor_subsys_t        *ms;  
         static char             *controls[] = {          static char             *controls[] = {
                 LDAP_CONTROL_MANAGEDSAIT,                  LDAP_CONTROL_MANAGEDSAIT,
                 LDAP_CONTROL_VALUESRETURNFILTER,  
                 NULL                  NULL
         };          };
   
         bi->bi_controls = controls;          static ConfigTable monitorcfg[] = {
                   { NULL, NULL, 0, 0, 0, ARG_IGNORED,
         bi->bi_init = 0;                          NULL, NULL, NULL, NULL }
         bi->bi_open = 0;          };
         bi->bi_config = monitor_back_config;  
         bi->bi_close = 0;  
         bi->bi_destroy = 0;  
   
         bi->bi_db_init = monitor_back_db_init;  
         bi->bi_db_config = monitor_back_db_config;  
         bi->bi_db_open = monitor_back_db_open;  
         bi->bi_db_close = 0;  
         bi->bi_db_destroy = monitor_back_db_destroy;  
   
         bi->bi_op_bind = monitor_back_bind;  
         bi->bi_op_unbind = 0;  
         bi->bi_op_search = monitor_back_search;  
         bi->bi_op_compare = monitor_back_compare;  
         bi->bi_op_modify = monitor_back_modify;  
         bi->bi_op_modrdn = 0;  
         bi->bi_op_add = 0;  
         bi->bi_op_delete = 0;  
         bi->bi_op_abandon = 0;  
   
         bi->bi_extended = 0;  
   
         bi->bi_entry_release_rw = 0;  
         bi->bi_chk_referrals = 0;  
         bi->bi_operational = monitor_back_operational;  
   
         /*  
          * hooks for slap tools  
          */  
         bi->bi_tool_entry_open = 0;  
         bi->bi_tool_entry_close = 0;  
         bi->bi_tool_entry_first = 0;  
         bi->bi_tool_entry_next = 0;  
         bi->bi_tool_entry_get = 0;  
         bi->bi_tool_entry_put = 0;  
         bi->bi_tool_entry_reindex = 0;  
         bi->bi_tool_sync = 0;  
         bi->bi_tool_dn2id_get = 0;  
         bi->bi_tool_id2entry_get = 0;  
         bi->bi_tool_entry_modify = 0;  
   
         bi->bi_connection_init = 0;  
         bi->bi_connection_destroy = 0;  
   
         for ( ms = known_monitor_subsys; ms->mss_name != NULL; ms++ ) {  
                 if ( monitor_back_register_subsys( ms ) ) {  
                         return -1;  
                 }  
         }  
   
         return 0;  
 }  
   
 int          static ConfigOCs monitorocs[] = {
 monitor_back_db_init(                  { "( OLcfgDbOc:4.1 "
         BackendDB       *be                          "NAME 'olcMonitorConfig' "
 )                          "DESC 'Monitor backend configuration' "
 {                          "SUP olcDatabaseConfig "
         monitor_info_t  *mi;                          ")",
         int             i, rc;                                  Cft_Database, monitorcfg },
         struct berval   dn, ndn;                  { NULL, 0, NULL }
         struct berval   bv;          };
         const char      *text;  
   
         struct m_s {          struct m_s {
                 char    *name;                  char    *name;
Line 749  monitor_back_db_init( Line 996  monitor_back_db_init(
                 slap_mask_t flags;                  slap_mask_t flags;
                 int     offset;                  int     offset;
         } moc[] = {          } moc[] = {
                 { "monitor", "( 1.3.6.1.4.1.4203.666.3.2 "                  { "monitor", "( 1.3.6.1.4.1.4203.666.3.16.1 "
                         "NAME 'monitor' "                          "NAME 'monitor' "
                         "DESC 'OpenLDAP system monitoring' "                          "DESC 'OpenLDAP system monitoring' "
                         "SUP top STRUCTURAL "                          "SUP top STRUCTURAL "
                         "MUST cn "                          "MUST cn "
                         "MAY ( "                          "MAY ( "
                                 "description "                                  "description "
                                 "$ l "  
 #if 0   /* temporarily disabled */  
                                 "$ st "  
                                 "$ street "  
                                 "$ postalAddress "  
                                 "$ postalCode "  
 #endif  
                                 "$ seeAlso "                                  "$ seeAlso "
                                 "$ labeledURI "                                  "$ labeledURI "
                                 "$ monitoredInfo "                                  "$ monitoredInfo "
Line 770  monitor_back_db_init( Line 1010  monitor_back_db_init(
                                 "$ monitorOverlay "                                  "$ monitorOverlay "
                         ") )", SLAP_OC_OPERATIONAL|SLAP_OC_HIDE,                          ") )", SLAP_OC_OPERATIONAL|SLAP_OC_HIDE,
                         offsetof(monitor_info_t, mi_oc_monitor) },                          offsetof(monitor_info_t, mi_oc_monitor) },
                 { "monitorServer", "( 1.3.6.1.4.1.4203.666.3.7 "                  { "monitorServer", "( 1.3.6.1.4.1.4203.666.3.16.2 "
                         "NAME 'monitorServer' "                          "NAME 'monitorServer' "
                         "DESC 'Server monitoring root entry' "                          "DESC 'Server monitoring root entry' "
                         "SUP monitor STRUCTURAL )", SLAP_OC_OPERATIONAL|SLAP_OC_HIDE,                          "SUP monitor STRUCTURAL )", SLAP_OC_OPERATIONAL|SLAP_OC_HIDE,
                         offsetof(monitor_info_t, mi_oc_monitorServer) },                          offsetof(monitor_info_t, mi_oc_monitorServer) },
                 { "monitorContainer", "( 1.3.6.1.4.1.4203.666.3.8 "                  { "monitorContainer", "( 1.3.6.1.4.1.4203.666.3.16.3 "
                         "NAME 'monitorContainer' "                          "NAME 'monitorContainer' "
                         "DESC 'monitor container class' "                          "DESC 'monitor container class' "
                         "SUP monitor STRUCTURAL )", SLAP_OC_OPERATIONAL|SLAP_OC_HIDE,                          "SUP monitor STRUCTURAL )", SLAP_OC_OPERATIONAL|SLAP_OC_HIDE,
                         offsetof(monitor_info_t, mi_oc_monitorContainer) },                          offsetof(monitor_info_t, mi_oc_monitorContainer) },
                 { "monitorCounterObject", "( 1.3.6.1.4.1.4203.666.3.9 "                  { "monitorCounterObject", "( 1.3.6.1.4.1.4203.666.3.16.4 "
                         "NAME 'monitorCounterObject' "                          "NAME 'monitorCounterObject' "
                         "DESC 'monitor counter class' "                          "DESC 'monitor counter class' "
                         "SUP monitor STRUCTURAL )", SLAP_OC_OPERATIONAL|SLAP_OC_HIDE,                          "SUP monitor STRUCTURAL )", SLAP_OC_OPERATIONAL|SLAP_OC_HIDE,
                         offsetof(monitor_info_t, mi_oc_monitorCounterObject) },                          offsetof(monitor_info_t, mi_oc_monitorCounterObject) },
                 { "monitorOperation", "( 1.3.6.1.4.1.4203.666.3.10 "                  { "monitorOperation", "( 1.3.6.1.4.1.4203.666.3.16.5 "
                         "NAME 'monitorOperation' "                          "NAME 'monitorOperation' "
                         "DESC 'monitor operation class' "                          "DESC 'monitor operation class' "
                         "SUP monitor STRUCTURAL )", SLAP_OC_OPERATIONAL|SLAP_OC_HIDE,                          "SUP monitor STRUCTURAL )", SLAP_OC_OPERATIONAL|SLAP_OC_HIDE,
                         offsetof(monitor_info_t, mi_oc_monitorOperation) },                          offsetof(monitor_info_t, mi_oc_monitorOperation) },
                 { "monitorConnection", "( 1.3.6.1.4.1.4203.666.3.11 "                  { "monitorConnection", "( 1.3.6.1.4.1.4203.666.3.16.6 "
                         "NAME 'monitorConnection' "                          "NAME 'monitorConnection' "
                         "DESC 'monitor connection class' "                          "DESC 'monitor connection class' "
                         "SUP monitor STRUCTURAL )", SLAP_OC_OPERATIONAL|SLAP_OC_HIDE,                          "SUP monitor STRUCTURAL )", SLAP_OC_OPERATIONAL|SLAP_OC_HIDE,
                         offsetof(monitor_info_t, mi_oc_monitorConnection) },                          offsetof(monitor_info_t, mi_oc_monitorConnection) },
                 { "managedObject", "( 1.3.6.1.4.1.4203.666.3.12 "                  { "managedObject", "( 1.3.6.1.4.1.4203.666.3.16.7 "
                         "NAME 'managedObject' "                          "NAME 'managedObject' "
                         "DESC 'monitor managed entity class' "                          "DESC 'monitor managed entity class' "
                         "SUP monitor STRUCTURAL )", SLAP_OC_OPERATIONAL|SLAP_OC_HIDE,                          "SUP monitor STRUCTURAL )", SLAP_OC_OPERATIONAL|SLAP_OC_HIDE,
                         offsetof(monitor_info_t, mi_oc_managedObject) },                          offsetof(monitor_info_t, mi_oc_managedObject) },
                 { "monitoredObject", "( 1.3.6.1.4.1.4203.666.3.14 "                  { "monitoredObject", "( 1.3.6.1.4.1.4203.666.3.16.8 "
                         "NAME 'monitoredObject' "                          "NAME 'monitoredObject' "
                         "DESC 'monitor monitored entity class' "                          "DESC 'monitor monitored entity class' "
                         "SUP monitor STRUCTURAL )", SLAP_OC_OPERATIONAL|SLAP_OC_HIDE,                          "SUP monitor STRUCTURAL )", SLAP_OC_OPERATIONAL|SLAP_OC_HIDE,
                         offsetof(monitor_info_t, mi_oc_monitoredObject) },                          offsetof(monitor_info_t, mi_oc_monitoredObject) },
                 { NULL, NULL, 0, -1 }                  { NULL, NULL, 0, -1 }
         }, mat[] = {          }, mat[] = {
                 { "monitoredInfo", "( 1.3.6.1.4.1.4203.666.1.14 "                  { "monitoredInfo", "( 1.3.6.1.4.1.4203.666.1.55.1 "
                         "NAME 'monitoredInfo' "                          "NAME 'monitoredInfo' "
                         "DESC 'monitored info' "                          "DESC 'monitored info' "
                         /* "SUP name " */                          /* "SUP name " */
Line 817  monitor_back_db_init( Line 1057  monitor_back_db_init(
                         "NO-USER-MODIFICATION "                          "NO-USER-MODIFICATION "
                         "USAGE directoryOperation )", SLAP_AT_HIDE,                          "USAGE directoryOperation )", SLAP_AT_HIDE,
                         offsetof(monitor_info_t, mi_ad_monitoredInfo) },                          offsetof(monitor_info_t, mi_ad_monitoredInfo) },
                 { "managedInfo", "( 1.3.6.1.4.1.4203.666.1.15 "                  { "managedInfo", "( 1.3.6.1.4.1.4203.666.1.55.2 "
                         "NAME 'managedInfo' "                          "NAME 'managedInfo' "
                         "DESC 'monitor managed info' "                          "DESC 'monitor managed info' "
                         "SUP name )", SLAP_AT_HIDE,                          "SUP name )", SLAP_AT_HIDE,
                         offsetof(monitor_info_t, mi_ad_managedInfo) },                          offsetof(monitor_info_t, mi_ad_managedInfo) },
                 { "monitorCounter", "( 1.3.6.1.4.1.4203.666.1.16 "                  { "monitorCounter", "( 1.3.6.1.4.1.4203.666.1.55.3 "
                         "NAME 'monitorCounter' "                          "NAME 'monitorCounter' "
                         "DESC 'monitor counter' "                          "DESC 'monitor counter' "
                         "EQUALITY integerMatch "                          "EQUALITY integerMatch "
Line 831  monitor_back_db_init( Line 1071  monitor_back_db_init(
                         "NO-USER-MODIFICATION "                          "NO-USER-MODIFICATION "
                         "USAGE directoryOperation )", SLAP_AT_HIDE,                          "USAGE directoryOperation )", SLAP_AT_HIDE,
                         offsetof(monitor_info_t, mi_ad_monitorCounter) },                          offsetof(monitor_info_t, mi_ad_monitorCounter) },
                 { "monitorOpCompleted", "( 1.3.6.1.4.1.4203.666.1.17 "                  { "monitorOpCompleted", "( 1.3.6.1.4.1.4203.666.1.55.4 "
                         "NAME 'monitorOpCompleted' "                          "NAME 'monitorOpCompleted' "
                         "DESC 'monitor completed operations' "                          "DESC 'monitor completed operations' "
                         "SUP monitorCounter "                          "SUP monitorCounter "
                         "NO-USER-MODIFICATION "                          "NO-USER-MODIFICATION "
                         "USAGE directoryOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE,                          "USAGE directoryOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE,
                         offsetof(monitor_info_t, mi_ad_monitorOpCompleted) },                          offsetof(monitor_info_t, mi_ad_monitorOpCompleted) },
                 { "monitorOpInitiated", "( 1.3.6.1.4.1.4203.666.1.18 "                  { "monitorOpInitiated", "( 1.3.6.1.4.1.4203.666.1.55.5 "
                         "NAME 'monitorOpInitiated' "                          "NAME 'monitorOpInitiated' "
                         "DESC 'monitor initiated operations' "                          "DESC 'monitor initiated operations' "
                         "SUP monitorCounter "                          "SUP monitorCounter "
                         "NO-USER-MODIFICATION "                          "NO-USER-MODIFICATION "
                         "USAGE directoryOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE,                          "USAGE directoryOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE,
                         offsetof(monitor_info_t, mi_ad_monitorOpInitiated) },                          offsetof(monitor_info_t, mi_ad_monitorOpInitiated) },
                 { "monitorConnectionNumber", "( 1.3.6.1.4.1.4203.666.1.19 "                  { "monitorConnectionNumber", "( 1.3.6.1.4.1.4203.666.1.55.6 "
                         "NAME 'monitorConnectionNumber' "                          "NAME 'monitorConnectionNumber' "
                         "DESC 'monitor connection number' "                          "DESC 'monitor connection number' "
                         "SUP monitorCounter "                          "SUP monitorCounter "
                         "NO-USER-MODIFICATION "                          "NO-USER-MODIFICATION "
                         "USAGE directoryOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE,                          "USAGE directoryOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE,
                         offsetof(monitor_info_t, mi_ad_monitorConnectionNumber) },                          offsetof(monitor_info_t, mi_ad_monitorConnectionNumber) },
                 { "monitorConnectionAuthzDN", "( 1.3.6.1.4.1.4203.666.1.20 "                  { "monitorConnectionAuthzDN", "( 1.3.6.1.4.1.4203.666.1.55.7 "
                         "NAME 'monitorConnectionAuthzDN' "                          "NAME 'monitorConnectionAuthzDN' "
                         "DESC 'monitor connection authorization DN' "                          "DESC 'monitor connection authorization DN' "
                         /* "SUP distinguishedName " */                          /* "SUP distinguishedName " */
Line 861  monitor_back_db_init( Line 1101  monitor_back_db_init(
                         "NO-USER-MODIFICATION "                          "NO-USER-MODIFICATION "
                         "USAGE directoryOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE,                          "USAGE directoryOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE,
                         offsetof(monitor_info_t, mi_ad_monitorConnectionAuthzDN) },                          offsetof(monitor_info_t, mi_ad_monitorConnectionAuthzDN) },
                 { "monitorConnectionLocalAddress", "( 1.3.6.1.4.1.4203.666.1.21 "                  { "monitorConnectionLocalAddress", "( 1.3.6.1.4.1.4203.666.1.55.8 "
                         "NAME 'monitorConnectionLocalAddress' "                          "NAME 'monitorConnectionLocalAddress' "
                         "DESC 'monitor connection local address' "                          "DESC 'monitor connection local address' "
                         "SUP monitoredInfo "                          "SUP monitoredInfo "
                         "NO-USER-MODIFICATION "                          "NO-USER-MODIFICATION "
                         "USAGE directoryOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE,                          "USAGE directoryOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE,
                         offsetof(monitor_info_t, mi_ad_monitorConnectionLocalAddress) },                          offsetof(monitor_info_t, mi_ad_monitorConnectionLocalAddress) },
                 { "monitorConnectionPeerAddress", "( 1.3.6.1.4.1.4203.666.1.22 "                  { "monitorConnectionPeerAddress", "( 1.3.6.1.4.1.4203.666.1.55.9 "
                         "NAME 'monitorConnectionPeerAddress' "                          "NAME 'monitorConnectionPeerAddress' "
                         "DESC 'monitor connection peer address' "                          "DESC 'monitor connection peer address' "
                         "SUP monitoredInfo "                          "SUP monitoredInfo "
                         "NO-USER-MODIFICATION "                          "NO-USER-MODIFICATION "
                         "USAGE directoryOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE,                          "USAGE directoryOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE,
                         offsetof(monitor_info_t, mi_ad_monitorConnectionPeerAddress) },                          offsetof(monitor_info_t, mi_ad_monitorConnectionPeerAddress) },
                 { "monitorTimestamp", "( 1.3.6.1.4.1.4203.666.1.24 "                  { "monitorTimestamp", "( 1.3.6.1.4.1.4203.666.1.55.10 "
                         "NAME 'monitorTimestamp' "                          "NAME 'monitorTimestamp' "
                         "DESC 'monitor timestamp' "                          "DESC 'monitor timestamp' "
                         "EQUALITY generalizedTimeMatch "                          "EQUALITY generalizedTimeMatch "
Line 885  monitor_back_db_init( Line 1125  monitor_back_db_init(
                         "NO-USER-MODIFICATION "                          "NO-USER-MODIFICATION "
                         "USAGE directoryOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE,                          "USAGE directoryOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE,
                         offsetof(monitor_info_t, mi_ad_monitorTimestamp) },                          offsetof(monitor_info_t, mi_ad_monitorTimestamp) },
                 { "monitorOverlay", "( 1.3.6.1.4.1.4203.666.1.27 "                  { "monitorOverlay", "( 1.3.6.1.4.1.4203.666.1.55.11 "
                         "NAME 'monitorOverlay' "                          "NAME 'monitorOverlay' "
                         "DESC 'name of overlays defined for a give database' "                          "DESC 'name of overlays defined for a given database' "
                         "SUP monitoredInfo "                          "SUP monitoredInfo "
                         "NO-USER-MODIFICATION "                          "NO-USER-MODIFICATION "
                         "USAGE directoryOperation )", SLAP_AT_HIDE,                          "USAGE directoryOperation )", SLAP_AT_HIDE,
                         offsetof(monitor_info_t, mi_ad_monitorOverlay) },                          offsetof(monitor_info_t, mi_ad_monitorOverlay) },
                 { "readOnly", "( 1.3.6.1.4.1.4203.666.1.31 "                  { "readOnly", "( 1.3.6.1.4.1.4203.666.1.55.12 "
                         "NAME 'readOnly' "                          "NAME 'readOnly' "
                         "DESC 'read/write status of a given database' "                          "DESC 'read/write status of a given database' "
                         "EQUALITY booleanMatch "                          "EQUALITY booleanMatch "
Line 900  monitor_back_db_init( Line 1140  monitor_back_db_init(
                         "SINGLE-VALUE "                          "SINGLE-VALUE "
                         "USAGE directoryOperation )", SLAP_AT_HIDE,                          "USAGE directoryOperation )", SLAP_AT_HIDE,
                         offsetof(monitor_info_t, mi_ad_readOnly) },                          offsetof(monitor_info_t, mi_ad_readOnly) },
                 { "restrictedOperation", "( 1.3.6.1.4.1.4203.666.1.32 "                  { "restrictedOperation", "( 1.3.6.1.4.1.4203.666.1.55.13 "
                         "NAME 'restrictedOperation' "                          "NAME 'restrictedOperation' "
                         "DESC 'name of restricted operation for a given database' "                          "DESC 'name of restricted operation for a given database' "
                         "SUP managedInfo )", SLAP_AT_HIDE,                          "SUP managedInfo )", SLAP_AT_HIDE,
                         offsetof(monitor_info_t, mi_ad_restrictedOperation ) },                          offsetof(monitor_info_t, mi_ad_restrictedOperation ) },
 #ifdef INTEGRATE_CORE_SCHEMA                  { "monitorConnectionProtocol", "( 1.3.6.1.4.1.4203.666.1.55.14 "
                 { NULL, NULL, 0, -1 },  /* description */                          "NAME 'monitorConnectionProtocol' "
                 { NULL, NULL, 0, -1 },  /* seeAlso */                          "DESC 'monitor connection protocol' "
                 { NULL, NULL, 0, -1 },  /* l */                          "SUP monitoredInfo "
                 { NULL, NULL, 0, -1 },  /* labeledURI */                          "NO-USER-MODIFICATION "
 #endif /* INTEGRATE_CORE_SCHEMA */                          "USAGE directoryOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE,
                 { NULL, NULL, 0, -1 }                          offsetof(monitor_info_t, mi_ad_monitorConnectionProtocol) },
         }, mat_core[] = {                  { "monitorConnectionOpsReceived", "( 1.3.6.1.4.1.4203.666.1.55.15 "
                 { "description", "( 2.5.4.13 "                          "NAME 'monitorConnectionOpsReceived' "
                         "NAME 'description' "                          "DESC 'monitor number of operations received by the connection' "
                         "DESC 'RFC2256: descriptive information' "                          "SUP monitorCounter "
                         "EQUALITY caseIgnoreMatch "                          "NO-USER-MODIFICATION "
                         "SUBSTR caseIgnoreSubstringsMatch "                          "USAGE directoryOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE,
                         "SYNTAX 1.3.6.1.4.1.1466.115.121.1.15{1024} )", 0,                          offsetof(monitor_info_t, mi_ad_monitorConnectionOpsReceived) },
                         offsetof(monitor_info_t, mi_ad_description) },                  { "monitorConnectionOpsExecuting", "( 1.3.6.1.4.1.4203.666.1.55.16 "
                 { "seeAlso", "( 2.5.4.34 "                          "NAME 'monitorConnectionOpsExecuting' "
                         "NAME 'seeAlso' "                          "DESC 'monitor number of operations in execution within the connection' "
                         "DESC 'RFC2256: DN of related object' "                          "SUP monitorCounter "
                         "SUP distinguishedName )", 0,                          "NO-USER-MODIFICATION "
                         offsetof(monitor_info_t, mi_ad_seeAlso) },                          "USAGE directoryOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE,
                 { "l", "( 2.5.4.7 "                          offsetof(monitor_info_t, mi_ad_monitorConnectionOpsExecuting) },
                         "NAME ( 'l' 'localityName' ) "                  { "monitorConnectionOpsPending", "( 1.3.6.1.4.1.4203.666.1.55.17 "
                         "DESC 'RFC2256: locality which this object resides in' "                          "NAME 'monitorConnectionOpsPending' "
                         "SUP name )", 0,                          "DESC 'monitor number of pending operations within the connection' "
                         offsetof(monitor_info_t, mi_ad_l) },                          "SUP monitorCounter "
 #ifdef MONITOR_DEFINE_LABELEDURI                          "NO-USER-MODIFICATION "
                 { "labeledURI", "( 1.3.6.1.4.1.250.1.57 "                          "USAGE directoryOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE,
                         "NAME 'labeledURI' "                          offsetof(monitor_info_t, mi_ad_monitorConnectionOpsPending) },
                         "DESC 'RFC2079: Uniform Resource Identifier with optional label' "                  { "monitorConnectionOpsCompleted", "( 1.3.6.1.4.1.4203.666.1.55.18 "
                         "EQUALITY caseExactMatch "                          "NAME 'monitorConnectionOpsCompleted' "
                         "SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 )", 0,                          "DESC 'monitor number of operations completed within the connection' "
                         offsetof(monitor_info_t, mi_ad_labeledURI) },                          "SUP monitorCounter "
 #endif /* MONITOR_DEFINE_LABELEDURI */                          "NO-USER-MODIFICATION "
                           "USAGE directoryOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE,
                           offsetof(monitor_info_t, mi_ad_monitorConnectionOpsCompleted) },
                   { "monitorConnectionGet", "( 1.3.6.1.4.1.4203.666.1.55.19 "
                           "NAME 'monitorConnectionGet' "
                           "DESC 'number of times connection_get() was called so far' "
                           "SUP monitorCounter "
                           "NO-USER-MODIFICATION "
                           "USAGE directoryOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE,
                           offsetof(monitor_info_t, mi_ad_monitorConnectionGet) },
                   { "monitorConnectionRead", "( 1.3.6.1.4.1.4203.666.1.55.20 "
                           "NAME 'monitorConnectionRead' "
                           "DESC 'number of times connection_read() was called so far' "
                           "SUP monitorCounter "
                           "NO-USER-MODIFICATION "
                           "USAGE directoryOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE,
                           offsetof(monitor_info_t, mi_ad_monitorConnectionRead) },
                   { "monitorConnectionWrite", "( 1.3.6.1.4.1.4203.666.1.55.21 "
                           "NAME 'monitorConnectionWrite' "
                           "DESC 'number of times connection_write() was called so far' "
                           "SUP monitorCounter "
                           "NO-USER-MODIFICATION "
                           "USAGE directoryOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE,
                           offsetof(monitor_info_t, mi_ad_monitorConnectionWrite) },
                   { "monitorConnectionMask", "( 1.3.6.1.4.1.4203.666.1.55.22 "
                           "NAME 'monitorConnectionMask' "
                           "DESC 'monitor connection mask' "
                           "SUP monitoredInfo "
                           "NO-USER-MODIFICATION "
                           "USAGE directoryOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE,
                           offsetof(monitor_info_t, mi_ad_monitorConnectionMask) },
                   { "monitorConnectionListener", "( 1.3.6.1.4.1.4203.666.1.55.23 "
                           "NAME 'monitorConnectionListener' "
                           "DESC 'monitor connection listener' "
                           "SUP monitoredInfo "
                           "NO-USER-MODIFICATION "
                           "USAGE directoryOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE,
                           offsetof(monitor_info_t, mi_ad_monitorConnectionListener) },
                   { "monitorConnectionPeerDomain", "( 1.3.6.1.4.1.4203.666.1.55.24 "
                           "NAME 'monitorConnectionPeerDomain' "
                           "DESC 'monitor connection peer domain' "
                           "SUP monitoredInfo "
                           "NO-USER-MODIFICATION "
                           "USAGE directoryOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE,
                           offsetof(monitor_info_t, mi_ad_monitorConnectionPeerDomain) },
                   { "monitorConnectionStartTime", "( 1.3.6.1.4.1.4203.666.1.55.25 "
                           "NAME 'monitorConnectionStartTime' "
                           "DESC 'monitor connection start time' "
                           "SUP monitorTimestamp "
                           "SINGLE-VALUE "
                           "NO-USER-MODIFICATION "
                           "USAGE directoryOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE,
                           offsetof(monitor_info_t, mi_ad_monitorConnectionStartTime) },
                   { "monitorConnectionActivityTime", "( 1.3.6.1.4.1.4203.666.1.55.26 "
                           "NAME 'monitorConnectionActivityTime' "
                           "DESC 'monitor connection activity time' "
                           "SUP monitorTimestamp "
                           "SINGLE-VALUE "
                           "NO-USER-MODIFICATION "
                           "USAGE directoryOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE,
                           offsetof(monitor_info_t, mi_ad_monitorConnectionActivityTime) },
                   { "monitorIsShadow", "( 1.3.6.1.4.1.4203.666.1.55.27 "
                           "NAME 'monitorIsShadow' "
                           "DESC 'TRUE if the database is shadow' "
                           "EQUALITY booleanMatch "
                           "SYNTAX 1.3.6.1.4.1.1466.115.121.1.7 "
                           "SINGLE-VALUE "
                           "USAGE directoryOperation )", SLAP_AT_HIDE,
                           offsetof(monitor_info_t, mi_ad_monitorIsShadow) },
                   { "monitorUpdateRef", "( 1.3.6.1.4.1.4203.666.1.55.28 "
                           "NAME 'monitorUpdateRef' "
                           "DESC 'update referral for shadow databases' "
                           "SUP monitoredInfo "
                           "SINGLE-VALUE "
                           "USAGE directoryOperation )", SLAP_AT_HIDE,
                           offsetof(monitor_info_t, mi_ad_monitorUpdateRef) },
                   { "monitorRuntimeConfig", "( 1.3.6.1.4.1.4203.666.1.55.29 "
                           "NAME 'monitorRuntimeConfig' "
                           "DESC 'TRUE if component allows runtime configuration' "
                           "EQUALITY booleanMatch "
                           "SYNTAX 1.3.6.1.4.1.1466.115.121.1.7 "
                           "SINGLE-VALUE "
                           "USAGE directoryOperation )", SLAP_AT_HIDE,
                           offsetof(monitor_info_t, mi_ad_monitorRuntimeConfig) },
                 { NULL, NULL, 0, -1 }                  { NULL, NULL, 0, -1 }
         };          };
           
         /*  
          * database monitor can be defined once only  
          */  
         if ( be_monitor ) {  
                 Debug( LDAP_DEBUG_ANY,  
                         "only one monitor backend is allowed\n", 0, 0, 0 );  
                 return( -1 );  
         }  
         be_monitor = be;  
   
         /* indicate system schema supported */          int                     i, rc;
         SLAP_BFLAGS(be) |= SLAP_BFLAG_MONITOR;          const char              *text;
           monitor_info_t          *mi = &monitor_info;
         dn.bv_val = SLAPD_MONITOR_DN;  
         dn.bv_len = sizeof( SLAPD_MONITOR_DN ) - 1;  
   
         rc = dnNormalize( 0, NULL, NULL, &dn, &ndn, NULL );  
         if( rc != LDAP_SUCCESS ) {  
                 Debug( LDAP_DEBUG_ANY,  
                         "unable to normalize monitor DN \"%s\"\n",  
                         SLAPD_MONITOR_DN, 0, 0 );  
                 return -1;  
         }  
   
         ber_dupbv( &bv, &dn );  
         ber_bvarray_add( &be->be_suffix, &bv );  
         ber_bvarray_add( &be->be_nsuffix, &ndn );  
   
         mi = ( monitor_info_t * )ch_calloc( sizeof( monitor_info_t ), 1 );  
         if ( mi == NULL ) {  
                 Debug( LDAP_DEBUG_ANY,  
                         "unable to initialize monitor backend\n", 0, 0, 0 );  
                 return -1;  
         }  
   
         memset( mi, 0, sizeof( monitor_info_t ) );  
   
         ldap_pvt_thread_mutex_init( &mi->mi_cache_mutex );  
   
         be->be_private = mi;  
           
 #ifdef INTEGRATE_CORE_SCHEMA  
         /* prepare for schema integration */  
         for ( k = 0; mat[ k ].name != NULL; k++ );  
 #endif /* INTEGRATE_CORE_SCHEMA */  
   
         for ( i = 0; mat_core[ i ].name != NULL; i++ ) {  
                 AttributeDescription    **ad;  
                 const char              *text;  
   
                 ad = ((AttributeDescription **)&(((char *)mi)[ mat_core[ i ].offset ]));  
                 ad[ 0 ] = NULL;  
   
                 switch (slap_str2ad( mat_core[ i ].name, ad, &text ) ) {  
                 case LDAP_SUCCESS:  
                         break;  
   
 #ifdef INTEGRATE_CORE_SCHEMA  
                 case LDAP_UNDEFINED_TYPE:  
                         mat[ k ] = mat_core[ i ];  
                         k++;  
                         break;  
 #endif /* INTEGRATE_CORE_SCHEMA */  
   
                 default:  
                         Debug( LDAP_DEBUG_ANY,  
                                 "monitor_back_db_init: %s: %s\n",  
                                 mat_core[ i ].name, text, 0 );  
                         return( -1 );  
                 }  
         }  
   
         /* schema integration */          /* schema integration */
         for ( i = 0; mat[ i ].name; i++ ) {          for ( i = 0; mat[ i ].name; i++ ) {
Line 1036  monitor_back_db_init( Line 1291  monitor_back_db_init(
                         return -1;                          return -1;
                 }                  }
   
                 code = at_add(at, &err);                  code = at_add(at, 0, NULL, &err);
                 if ( code ) {                  if ( code ) {
                         Debug( LDAP_DEBUG_ANY, "monitor_back_db_init: "                          Debug( LDAP_DEBUG_ANY, "monitor_back_db_init: "
                                 "%s in attributeType \"%s\"\n",                                  "%s in attributeType \"%s\"\n",
Line 1079  monitor_back_db_init( Line 1334  monitor_back_db_init(
                         return -1;                          return -1;
                 }                  }
   
                 code = oc_add(oc, 0, &err);                  code = oc_add(oc, 0, NULL, &err);
                 if ( code ) {                  if ( code ) {
                         Debug( LDAP_DEBUG_ANY,                          Debug( LDAP_DEBUG_ANY,
                                 "objectclass \"%s\": %s \"%s\"\n" ,                                  "objectclass \"%s\": %s \"%s\"\n" ,
Line 1102  monitor_back_db_init( Line 1357  monitor_back_db_init(
                 ((ObjectClass **)&(((char *)mi)[ moc[ i ].offset ]))[ 0 ] = Oc;                  ((ObjectClass **)&(((char *)mi)[ moc[ i ].offset ]))[ 0 ] = Oc;
         }          }
   
           bi->bi_controls = controls;
   
           bi->bi_init = 0;
           bi->bi_open = 0;
           bi->bi_config = monitor_back_config;
           bi->bi_close = 0;
           bi->bi_destroy = 0;
   
           bi->bi_db_init = monitor_back_db_init;
   #if 0
           bi->bi_db_config = monitor_back_db_config;
   #endif
           bi->bi_db_open = monitor_back_db_open;
           bi->bi_db_close = 0;
           bi->bi_db_destroy = monitor_back_db_destroy;
   
           bi->bi_op_bind = monitor_back_bind;
           bi->bi_op_unbind = 0;
           bi->bi_op_search = monitor_back_search;
           bi->bi_op_compare = monitor_back_compare;
           bi->bi_op_modify = monitor_back_modify;
           bi->bi_op_modrdn = 0;
           bi->bi_op_add = 0;
           bi->bi_op_delete = 0;
           bi->bi_op_abandon = 0;
   
           bi->bi_extended = 0;
   
           bi->bi_entry_release_rw = 0;
           bi->bi_chk_referrals = 0;
           bi->bi_operational = monitor_back_operational;
   
           /*
            * hooks for slap tools
            */
           bi->bi_tool_entry_open = 0;
           bi->bi_tool_entry_close = 0;
           bi->bi_tool_entry_first = 0;
           bi->bi_tool_entry_next = 0;
           bi->bi_tool_entry_get = 0;
           bi->bi_tool_entry_put = 0;
           bi->bi_tool_entry_reindex = 0;
           bi->bi_tool_sync = 0;
           bi->bi_tool_dn2id_get = 0;
           bi->bi_tool_id2entry_get = 0;
           bi->bi_tool_entry_modify = 0;
   
           bi->bi_connection_init = 0;
           bi->bi_connection_destroy = 0;
   
           /*
            * configuration objectClasses (fake)
            */
           bi->bi_cf_ocs = monitorocs;
   
           rc = config_register_schema( monitorcfg, monitorocs );
           if ( rc ) {
                   return rc;
           }
   
           return 0;
   }
   
   int
   monitor_back_db_init(
           BackendDB       *be )
   {
           int                     rc;
           struct berval           dn = BER_BVC( SLAPD_MONITOR_DN ),
                                   pdn,
                                   ndn;
           BackendDB               *be2;
   
           monitor_subsys_t        *ms;
   
           /*
            * register subsys
            */
           for ( ms = known_monitor_subsys; ms->mss_name != NULL; ms++ ) {
                   if ( monitor_back_register_subsys( ms ) ) {
                           return -1;
                   }
           }
   
           /*
            * database monitor can be defined once only
            */
           if ( be_monitor != NULL ) {
                   Debug( LDAP_DEBUG_ANY,
                           "only one monitor database is allowed\n", 0, 0, 0 );
                   return( -1 );
           }
           be_monitor = be;
   
           /* indicate system schema supported */
           SLAP_BFLAGS(be) |= SLAP_BFLAG_MONITOR;
   
           rc = dnPrettyNormal( NULL, &dn, &pdn, &ndn, NULL );
           if( rc != LDAP_SUCCESS ) {
                   Debug( LDAP_DEBUG_ANY,
                           "unable to normalize/pretty monitor DN \"%s\" (%d)\n",
                           dn.bv_val, rc, 0 );
                   return -1;
           }
   
           ber_bvarray_add( &be->be_suffix, &pdn );
           ber_bvarray_add( &be->be_nsuffix, &ndn );
   
           /* NOTE: only one monitor database is allowed,
            * so we use static storage */
           ldap_pvt_thread_mutex_init( &monitor_info.mi_cache_mutex );
   
           be->be_private = &monitor_info;
   
           be2 = select_backend( &ndn, 0, 0 );
           if ( be2 != be ) {
                   char    *type = be2->bd_info->bi_type;
   
                   if ( overlay_is_over( be2 ) ) {
                           slap_overinfo   *oi = (slap_overinfo *)be2->bd_info->bi_private;
                           type = oi->oi_orig->bi_type;
                   }
   
                   Debug( LDAP_DEBUG_ANY,
                           "\"monitor\" database serving namingContext \"%s\" "
                           "is hidden by \"%s\" database serving namingContext \"%s\".\n",
                           pdn.bv_val, type, be2->be_nsuffix[ 0 ].bv_val );
                   return -1;
           }
   
         return 0;          return 0;
 }  }
   
 int  int
 monitor_back_db_open(  monitor_back_db_open(
         BackendDB       *be          BackendDB       *be )
 )  
 {  {
         monitor_info_t          *mi = (monitor_info_t *)be->be_private;          monitor_info_t          *mi = (monitor_info_t *)be->be_private;
         struct monitor_subsys_t **ms;          struct monitor_subsys_t **ms;
         Entry                   *e, **ep;          Entry                   *e, **ep;
         monitor_entry_t         *mp;          monitor_entry_t         *mp;
         int                     i;          int                     i;
         char                    buf[ BACKMONITOR_BUFSIZE ],          char                    buf[ BACKMONITOR_BUFSIZE ];
                                 *end_of_line;  
         struct berval           bv;          struct berval           bv;
         struct tm               *tms;          struct tm               *tms;
 #ifdef HAVE_GMTIME_R  #ifdef HAVE_GMTIME_R
Line 1124  monitor_back_db_open( Line 1507  monitor_back_db_open(
 #endif  #endif
         static char             tmbuf[ LDAP_LUTIL_GENTIME_BUFSIZE ];          static char             tmbuf[ LDAP_LUTIL_GENTIME_BUFSIZE ];
   
         assert( be_monitor );          assert( be_monitor != NULL );
         if ( be != be_monitor ) {          if ( be != be_monitor ) {
                 be_monitor = be;                  be_monitor = be;
         }          }
Line 1171  monitor_back_db_open( Line 1554  monitor_back_db_open(
                 "objectClass: %s\n"                  "objectClass: %s\n"
                 "structuralObjectClass: %s\n"                  "structuralObjectClass: %s\n"
                 "cn: Monitor\n"                  "cn: Monitor\n"
                 "%s: This subtree contains monitoring/managing objects.\n"                  "description: This subtree contains monitoring/managing objects.\n"
                 "%s: This object contains information about this server.\n"                  "description: This object contains information about this server.\n"
 #if 0                  "description: Most of the information is held in operational"
                 "%s: createTimestamp reflects the time this server instance was created.\n"                  " attributes, which must be explicitly requested.\n"
                 "%s: modifyTimestamp reflects the time this server instance was last accessed.\n"  
 #endif  
                 "creatorsName: %s\n"                  "creatorsName: %s\n"
                 "modifiersName: %s\n"                  "modifiersName: %s\n"
                 "createTimestamp: %s\n"                  "createTimestamp: %s\n"
Line 1184  monitor_back_db_open( Line 1565  monitor_back_db_open(
                 SLAPD_MONITOR_DN,                  SLAPD_MONITOR_DN,
                 mi->mi_oc_monitorServer->soc_cname.bv_val,                  mi->mi_oc_monitorServer->soc_cname.bv_val,
                 mi->mi_oc_monitorServer->soc_cname.bv_val,                  mi->mi_oc_monitorServer->soc_cname.bv_val,
                 mi->mi_ad_description->ad_cname.bv_val,  
                 mi->mi_ad_description->ad_cname.bv_val,  
 #if 0  
                 mi->mi_ad_description->ad_cname.bv_val,  
                 mi->mi_ad_description->ad_cname.bv_val,  
 #endif  
                 mi->mi_creatorsName.bv_val,                  mi->mi_creatorsName.bv_val,
                 mi->mi_creatorsName.bv_val,                  mi->mi_creatorsName.bv_val,
                 mi->mi_startTime.bv_val,                  mi->mi_startTime.bv_val,
Line 1203  monitor_back_db_open( Line 1578  monitor_back_db_open(
                 return( -1 );                  return( -1 );
         }          }
   
         bv.bv_val = (char *) Versionstr;          bv.bv_val = strchr( (char *) Versionstr, '$' );
         end_of_line = strchr( Versionstr, '\n' );          if ( bv.bv_val != NULL ) {
         if ( end_of_line ) {                  char    *end;
                 bv.bv_len = end_of_line - Versionstr;  
         } else {  
                 bv.bv_len = strlen( Versionstr );  
         }  
   
         if ( attr_merge_normalize_one( e, mi->mi_ad_monitoredInfo,                  bv.bv_val++;
                                 &bv, NULL ) ) {                  for ( ; bv.bv_val[ 0 ] == ' '; bv.bv_val++ )
                 Debug( LDAP_DEBUG_ANY,                          ;
                         "unable to add monitoredInfo to \"%s\" entry\n",  
                         SLAPD_MONITOR_DN, 0, 0 );                  end = strchr( bv.bv_val, '$' );
                 return( -1 );                  if ( end != NULL ) {
         }                          end--;
   
                           for ( ; end > bv.bv_val && end[ 0 ] == ' '; end-- )
                                   ;
   
                           end++;
   
                           bv.bv_len = end - bv.bv_val;
   
         if ( mi->mi_l.bv_len ) {                  } else {
                 if ( attr_merge_normalize_one( e, mi->mi_ad_l, &mi->mi_l, NULL ) ) {                          bv.bv_len = strlen( bv.bv_val );
                   }
   
                   if ( attr_merge_normalize_one( e, mi->mi_ad_monitoredInfo,
                                           &bv, NULL ) ) {
                         Debug( LDAP_DEBUG_ANY,                          Debug( LDAP_DEBUG_ANY,
                                 "unable to add locality to \"%s\" entry\n",                                  "unable to add monitoredInfo to \"%s\" entry\n",
                                 SLAPD_MONITOR_DN, 0, 0 );                                  SLAPD_MONITOR_DN, 0, 0 );
                         return( -1 );                          return( -1 );
                 }                  }
Line 1304  monitor_back_db_open( Line 1686  monitor_back_db_open(
                         return( -1 );                          return( -1 );
                 }                  }
   
                   if ( !BER_BVISNULL( &monitor_subsys[ i ]->mss_desc[ 0 ] ) ) {
                           attr_merge_normalize( e, slap_schema.si_ad_description,
                                           monitor_subsys[ i ]->mss_desc, NULL );
                   }
   
                 mp = monitor_entrypriv_create();                  mp = monitor_entrypriv_create();
                 if ( mp == NULL ) {                  if ( mp == NULL ) {
                         return -1;                          return -1;
Line 1323  monitor_back_db_open( Line 1710  monitor_back_db_open(
                 ep = &mp->mp_next;                  ep = &mp->mp_next;
         }          }
   
         assert( be );          assert( be != NULL );
   
         be->be_private = mi;          be->be_private = mi;
                   
Line 1353  monitor_back_db_open( Line 1740  monitor_back_db_open(
                                                 el->el_cb );                                                  el->el_cb );
                                 break;                                  break;
   
                           case LIMBO_ENTRY_PARENT:
                                   monitor_back_register_entry_parent(
                                                   el->el_e,
                                                   el->el_cb,
                                                   &el->el_base,
                                                   el->el_scope,
                                                   &el->el_filter );
                                   break;
                                   
   
                         case LIMBO_ATTRS:                          case LIMBO_ATTRS:
                                 monitor_back_register_entry_attrs(                                  monitor_back_register_entry_attrs(
                                                 &el->el_ndn,                                                  &el->el_ndn,
Line 1409  monitor_back_config( Line 1806  monitor_back_config(
         const char      *fname,          const char      *fname,
         int             lineno,          int             lineno,
         int             argc,          int             argc,
         char            **argv          char            **argv )
 )  
 {  {
         /*          /*
          * eventually, will hold backend specific configuration parameters           * eventually, will hold backend specific configuration parameters
Line 1418  monitor_back_config( Line 1814  monitor_back_config(
         return SLAP_CONF_UNKNOWN;          return SLAP_CONF_UNKNOWN;
 }  }
   
   #if 0
 int  int
 monitor_back_db_config(  monitor_back_db_config(
         Backend     *be,          Backend     *be,
         const char  *fname,          const char  *fname,
         int         lineno,          int         lineno,
         int         argc,          int         argc,
         char        **argv          char        **argv )
 )  
 {  {
         monitor_info_t  *mi = ( monitor_info_t * )be->be_private;          monitor_info_t  *mi = ( monitor_info_t * )be->be_private;
   
         /*          /*
          * eventually, will hold database specific configuration parameters           * eventually, will hold database specific configuration parameters
          */           */
         if ( strcasecmp( argv[ 0 ], "l" ) == 0 ) {          return SLAP_CONF_UNKNOWN;
                 if ( argc != 2 ) {  
                         return 1;  
                 }  
                   
                 ber_str2bv( argv[ 1 ], 0, 1, &mi->mi_l );  
   
         } else {  
                 return SLAP_CONF_UNKNOWN;  
         }  
   
         return( 0 );  
 }  }
   #endif
   
 int  int
 monitor_back_db_destroy(  monitor_back_db_destroy(
         BackendDB       *be          BackendDB       *be )
 )  
 {  {
           monitor_info_t  *mi = ( monitor_info_t * )be->be_private;
   
           if ( mi == NULL ) {
                   return -1;
           }
   
         /*          /*
          * FIXME: destroys all the data           * FIXME: destroys all the data
          */           */
           /* NOTE: mi points to static storage; don't free it */
           
           (void)monitor_cache_destroy( mi );
   
           if ( monitor_subsys ) {
                   int     i;
   
                   for ( i = 0; monitor_subsys[ i ] != NULL; i++ ) {
                           if ( monitor_subsys[ i ]->mss_destroy ) {
                                   monitor_subsys[ i ]->mss_destroy( be, monitor_subsys[ i ] );
                           }
   
                           if ( !BER_BVISNULL( &monitor_subsys[ i ]->mss_rdn ) ) {
                                   ch_free( monitor_subsys[ i ]->mss_rdn.bv_val );
                           }
   
                           if ( !BER_BVISNULL( &monitor_subsys[ i ]->mss_dn ) ) {
                                   ch_free( monitor_subsys[ i ]->mss_dn.bv_val );
                           }
   
                           if ( !BER_BVISNULL( &monitor_subsys[ i ]->mss_ndn ) ) {
                                   ch_free( monitor_subsys[ i ]->mss_ndn.bv_val );
                           }
                   }
   
                   ch_free( monitor_subsys );
           }
           
           ldap_pvt_thread_mutex_destroy( &monitor_info.mi_cache_mutex );
   
           be->be_private = NULL;
   
         return 0;          return 0;
 }  }
   

Removed from v.1.89  
changed lines
  Added in v.1.89.2.16


______________
© Copyright 1998-2020, OpenLDAP Foundation, info@OpenLDAP.org