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

   1 /* init.c - initialize monitor backend */
   2 /* $OpenLDAP$ */
   3 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
   4  *
   5  * Copyright 2001-2008 The OpenLDAP Foundation.
   6  * Portions Copyright 2001-2003 Pierangelo Masarati.
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted only as authorized by the OpenLDAP
  11  * Public License.
  12  *
  13  * A copy of this license is available in file LICENSE in the
  14  * top-level directory of the distribution or, alternatively, at
  15  * <http://www.OpenLDAP.org/license.html>.
  16  */
  17 /* ACKNOWLEDGEMENTS:
  18  * This work was initially developed by Pierangelo Masarati for inclusion
  19  * in OpenLDAP Software.
  20  */
  21
  22 #include "portable.h"
  23
  24 #include <stdio.h>
  25 #include <ac/string.h>
  26
  27 #include <lutil.h>
  28 #include "slap.h"
  29 #include "config.h"
  30 #include "lber_pvt.h"
  31 #include "back-monitor.h"
  32
  33 #include "config.h"
  34
  35 #undef INTEGRATE_CORE_SCHEMA
  36
  37 /*
  38  * used by many functions to add description to entries
  39  *
  40  * WARNING: be_monitor may change as new databases are added,
  41  * so it should not be used outside monitor_back_db_init()
  42  * until monitor_back_db_open is called.
  43  */
  44 BackendDB                       *be_monitor;
  45
  46 static struct monitor_subsys_t  **monitor_subsys;
  47 static int                      monitor_subsys_opened;
  48 static monitor_info_t           monitor_info;
  49 static const monitor_extra_t monitor_extra = {
  50         monitor_back_is_configured,
  51         monitor_back_get_subsys,
  52         monitor_back_get_subsys_by_dn,
  53
  54         monitor_back_register_subsys,
  55         monitor_back_register_backend,
  56         monitor_back_register_database,
  57         monitor_back_register_overlay_info,
  58         monitor_back_register_overlay,
  59         monitor_back_register_entry,
  60         monitor_back_register_entry_parent,
  61         monitor_back_register_entry_attrs,
  62         monitor_back_register_entry_callback,
  63
  64         monitor_back_unregister_entry,
  65         monitor_back_unregister_entry_parent,
  66         monitor_back_unregister_entry_attrs,
  67         monitor_back_unregister_entry_callback
  68 };
  69
  70
  71 /*
  72  * subsystem data
  73  *
  74  * the known subsystems are added to the subsystems
  75  * array at backend initialization; other subsystems
  76  * may be added by calling monitor_back_register_subsys()
  77  * before the database is opened (e.g. by other backends
  78  * or by overlays or modules).
  79  */
  80 static struct monitor_subsys_t known_monitor_subsys[] = {
  81         {
  82                 SLAPD_MONITOR_BACKEND_NAME,
  83                 BER_BVNULL, BER_BVNULL, BER_BVNULL,
  84                 { BER_BVC( "This subsystem contains information about available backends." ),
  85                         BER_BVNULL },
  86                 MONITOR_F_PERSISTENT_CH,
  87                 monitor_subsys_backend_init,
  88                 NULL,   /* destroy */
  89                 NULL,   /* update */
  90                 NULL,   /* create */
  91                 NULL    /* modify */
  92         }, {
  93                 SLAPD_MONITOR_CONN_NAME,
  94                 BER_BVNULL, BER_BVNULL, BER_BVNULL,
  95                 { BER_BVC( "This subsystem contains information about connections." ),
  96                         BER_BVNULL },
  97                 MONITOR_F_VOLATILE_CH,
  98                 monitor_subsys_conn_init,
  99                 NULL,   /* destroy */
 100                 NULL,   /* update */
 101                 NULL,   /* create */
 102                 NULL    /* modify */
 103         }, {
 104                 SLAPD_MONITOR_DATABASE_NAME,
 105                 BER_BVNULL, BER_BVNULL, BER_BVNULL,
 106                 { BER_BVC( "This subsystem contains information about configured databases." ),
 107                         BER_BVNULL },
 108                 MONITOR_F_PERSISTENT_CH,
 109                 monitor_subsys_database_init,
 110                 NULL,   /* destroy */
 111                 NULL,   /* update */
 112                 NULL,   /* create */
 113                 NULL    /* modify */
 114         }, {
 115                 SLAPD_MONITOR_LISTENER_NAME,
 116                 BER_BVNULL, BER_BVNULL, BER_BVNULL,
 117                 { BER_BVC( "This subsystem contains information about active listeners." ),
 118                         BER_BVNULL },
 119                 MONITOR_F_PERSISTENT_CH,
 120                 monitor_subsys_listener_init,
 121                 NULL,   /* destroy */
 122                 NULL,   /* update */
 123                 NULL,   /* create */
 124                 NULL    /* modify */
 125         }, {
 126                 SLAPD_MONITOR_LOG_NAME,
 127                 BER_BVNULL, BER_BVNULL, BER_BVNULL,
 128                 { BER_BVC( "This subsystem contains information about logging." ),
 129                         BER_BVC( "Set the attribute \"managedInfo\" to the desired log levels." ),
 130                         BER_BVNULL },
 131                 MONITOR_F_NONE,
 132                 monitor_subsys_log_init,
 133                 NULL,   /* destroy */
 134                 NULL,   /* update */
 135                 NULL,   /* create */
 136                 NULL,   /* modify */
 137         }, {
 138                 SLAPD_MONITOR_OPS_NAME,
 139                 BER_BVNULL, BER_BVNULL, BER_BVNULL,
 140                 { BER_BVC( "This subsystem contains information about performed operations." ),
 141                         BER_BVNULL },
 142                 MONITOR_F_PERSISTENT_CH,
 143                 monitor_subsys_ops_init,
 144                 NULL,   /* destroy */
 145                 NULL,   /* update */
 146                 NULL,   /* create */
 147                 NULL,   /* modify */
 148         }, {
 149                 SLAPD_MONITOR_OVERLAY_NAME,
 150                 BER_BVNULL, BER_BVNULL, BER_BVNULL,
 151                 { BER_BVC( "This subsystem contains information about available overlays." ),
 152                         BER_BVNULL },
 153                 MONITOR_F_PERSISTENT_CH,
 154                 monitor_subsys_overlay_init,
 155                 NULL,   /* destroy */
 156                 NULL,   /* update */
 157                 NULL,   /* create */
 158                 NULL,   /* modify */
 159         }, {
 160                 SLAPD_MONITOR_SASL_NAME,
 161                 BER_BVNULL, BER_BVNULL, BER_BVNULL,
 162                 { BER_BVC( "This subsystem contains information about SASL." ),
 163                         BER_BVNULL },
 164                 MONITOR_F_NONE,
 165                 NULL,   /* init */
 166                 NULL,   /* destroy */
 167                 NULL,   /* update */
 168                 NULL,   /* create */
 169                 NULL    /* modify */
 170         }, {
 171                 SLAPD_MONITOR_SENT_NAME,
 172                 BER_BVNULL, BER_BVNULL, BER_BVNULL,
 173                 { BER_BVC( "This subsystem contains statistics." ),
 174                         BER_BVNULL },
 175                 MONITOR_F_PERSISTENT_CH,
 176                 monitor_subsys_sent_init,
 177                 NULL,   /* destroy */
 178                 NULL,   /* update */
 179                 NULL,   /* create */
 180                 NULL,   /* modify */
 181         }, {
 182                 SLAPD_MONITOR_THREAD_NAME,
 183                 BER_BVNULL, BER_BVNULL, BER_BVNULL,
 184                 { BER_BVC( "This subsystem contains information about threads." ),
 185                         BER_BVNULL },
 186                 MONITOR_F_PERSISTENT_CH,
 187                 monitor_subsys_thread_init,
 188                 NULL,   /* destroy */
 189                 NULL,   /* update */
 190                 NULL,   /* create */
 191                 NULL    /* modify */
 192         }, {
 193                 SLAPD_MONITOR_TIME_NAME,
 194                 BER_BVNULL, BER_BVNULL, BER_BVNULL,
 195                 { BER_BVC( "This subsystem contains information about time." ),
 196                         BER_BVNULL },
 197                 MONITOR_F_PERSISTENT_CH,
 198                 monitor_subsys_time_init,
 199                 NULL,   /* destroy */
 200                 NULL,   /* update */
 201                 NULL,   /* create */
 202                 NULL,   /* modify */
 203         }, {
 204                 SLAPD_MONITOR_TLS_NAME,
 205                 BER_BVNULL, BER_BVNULL, BER_BVNULL,
 206                 { BER_BVC( "This subsystem contains information about TLS." ),
 207                         BER_BVNULL },
 208                 MONITOR_F_NONE,
 209                 NULL,   /* init */
 210                 NULL,   /* destroy */
 211                 NULL,   /* update */
 212                 NULL,   /* create */
 213                 NULL    /* modify */
 214         }, {
 215                 SLAPD_MONITOR_RWW_NAME,
 216                 BER_BVNULL, BER_BVNULL, BER_BVNULL,
 217                 { BER_BVC( "This subsystem contains information about read/write waiters." ),
 218                         BER_BVNULL },
 219                 MONITOR_F_PERSISTENT_CH,
 220                 monitor_subsys_rww_init,
 221                 NULL,   /* destroy */
 222                 NULL,   /* update */
 223                 NULL,   /* create */
 224                 NULL    /* modify */
 225         }, { NULL }
 226 };
 227
 228 int
 229 monitor_subsys_is_opened( void )
 230 {
 231         return monitor_subsys_opened;
 232 }
 233
 234 int
 235 monitor_back_register_subsys(
 236         monitor_subsys_t        *ms )
 237 {
 238         int     i = 0;
 239
 240         if ( monitor_subsys ) {
 241                 for ( ; monitor_subsys[ i ] != NULL; i++ )
 242                         /* just count'em */ ;
 243         }
 244
 245         monitor_subsys = ch_realloc( monitor_subsys,
 246                         ( 2 + i ) * sizeof( monitor_subsys_t * ) );
 247
 248         if ( monitor_subsys == NULL ) {
 249                 return -1;
 250         }
 251
 252         monitor_subsys[ i ] = ms;
 253         monitor_subsys[ i + 1 ] = NULL;
 254
 255         /* if a subsystem is registered __AFTER__ subsystem
 256          * initialization (depending on the sequence the databases
 257          * are listed in slapd.conf), init it */
 258         if ( monitor_subsys_is_opened() ) {
 259
 260                 /* FIXME: this should only be possible
 261                  * if be_monitor is already initialized */
 262                 assert( be_monitor != NULL );
 263
 264                 if ( ms->mss_open && ( *ms->mss_open )( be_monitor, ms ) ) {
 265                         return -1;
 266                 }
 267
 268                 ms->mss_flags |= MONITOR_F_OPENED;
 269         }
 270
 271         return 0;
 272 }
 273
 274 enum {
 275         LIMBO_ENTRY,
 276         LIMBO_ENTRY_PARENT,
 277         LIMBO_ATTRS,
 278         LIMBO_CB,
 279         LIMBO_BACKEND,
 280         LIMBO_DATABASE,
 281         LIMBO_OVERLAY_INFO,
 282         LIMBO_OVERLAY,
 283
 284         LIMBO_LAST
 285 };
 286
 287 typedef struct entry_limbo_t {
 288         int                     el_type;
 289         BackendInfo             *el_bi;
 290         BackendDB               *el_be;
 291         slap_overinst           *el_on;
 292         Entry                   *el_e;
 293         Attribute               *el_a;
 294         struct berval           *el_ndn;
 295         struct berval           el_nbase;
 296         int                     el_scope;
 297         struct berval           el_filter;
 298         monitor_callback_t      *el_cb;
 299         monitor_subsys_t        *el_mss;
 300         unsigned long           el_flags;
 301         struct entry_limbo_t    *el_next;
 302 } entry_limbo_t;
 303
 304 int
 305 monitor_back_is_configured( void )
 306 {
 307         return be_monitor != NULL;
 308 }
 309
 310 int
 311 monitor_back_register_backend(
 312         BackendInfo             *bi )
 313 {
 314         return -1;
 315 }
 316
 317 int
 318 monitor_back_register_overlay_info(
 319         slap_overinst           *on )
 320 {
 321         return -1;
 322 }
 323
 324 int
 325 monitor_back_register_overlay(
 326         BackendDB               *be )
 327 {
 328         return -1;
 329 }
 330
 331 int
 332 monitor_back_register_backend_limbo(
 333         BackendInfo             *bi )
 334 {
 335         return -1;
 336 }
 337
 338 int
 339 monitor_back_register_database_limbo(
 340         BackendDB               *be,
 341         struct berval   *ndn )
 342 {
 343         entry_limbo_t   **elpp, el = { 0 };
 344         monitor_info_t  *mi;
 345
 346         if ( be_monitor == NULL ) {
 347                 Debug( LDAP_DEBUG_ANY,
 348                         "monitor_back_register_database_limbo: "
 349                         "monitor database not configured.\n",
 350                         0, 0, 0 );
 351                 return -1;
 352         }
 353
 354         mi = ( monitor_info_t * )be_monitor->be_private;
 355
 356
 357         el.el_type = LIMBO_DATABASE;
 358
 359         el.el_be = be;
 360         el.el_ndn = ndn;
 361
 362         for ( elpp = &mi->mi_entry_limbo;
 363                         *elpp;
 364                         elpp = &(*elpp)->el_next )
 365                 /* go to last */;
 366
 367         *elpp = (entry_limbo_t *)ch_malloc( sizeof( entry_limbo_t ) );
 368
 369         el.el_next = NULL;
 370         **elpp = el;
 371
 372         return 0;
 373 }
 374
 375 int
 376 monitor_back_register_overlay_info_limbo(
 377         slap_overinst           *on )
 378 {
 379         return -1;
 380 }
 381
 382 int
 383 monitor_back_register_overlay_limbo(
 384         BackendDB               *be )
 385 {
 386         return -1;
 387 }
 388
 389 int
 390 monitor_back_register_entry(
 391         Entry                   *e,
 392         monitor_callback_t      *cb,
 393         monitor_subsys_t        *mss,
 394         unsigned long           flags )
 395 {
 396         monitor_info_t  *mi;
 397
 398         if ( be_monitor == NULL ) {
 399                 Debug( LDAP_DEBUG_ANY,
 400                         "monitor_back_register_entry(\"%s\"): "
 401                         "monitor database not configured.\n",
 402                         e->e_name.bv_val, 0, 0 );
 403                 return -1;
 404         }
 405
 406         mi = ( monitor_info_t * )be_monitor->be_private;
 407
 408         assert( mi != NULL );
 409         assert( e != NULL );
 410         assert( e->e_private == NULL );
 411
 412         if ( monitor_subsys_is_opened() ) {
 413                 Entry           *e_parent = NULL,
 414                                 *e_new = NULL,
 415                                 **ep = NULL;
 416                 struct berval   pdn = BER_BVNULL;
 417                 monitor_entry_t *mp = NULL,
 418                                 *mp_parent = NULL;
 419                 int             rc = 0;
 420
 421                 if ( monitor_cache_get( mi, &e->e_nname, &e_parent ) == 0 ) {
 422                         /* entry exists */
 423                         Debug( LDAP_DEBUG_ANY,
 424                                 "monitor_back_register_entry(\"%s\"): "
 425                                 "entry exists\n",
 426                                 e->e_name.bv_val, 0, 0 );
 427                         monitor_cache_release( mi, e_parent );
 428                         return -1;
 429                 }
 430
 431                 dnParent( &e->e_nname, &pdn );
 432                 if ( monitor_cache_get( mi, &pdn, &e_parent ) != 0 ) {
 433                         /* parent does not exist */
 434                         Debug( LDAP_DEBUG_ANY,
 435                                 "monitor_back_register_entry(\"%s\"): "
 436                                 "parent \"%s\" not found\n",
 437                                 e->e_name.bv_val, pdn.bv_val, 0 );
 438                         return -1;
 439                 }
 440
 441                 assert( e_parent->e_private != NULL );
 442                 mp_parent = ( monitor_entry_t * )e_parent->e_private;
 443
 444                 if ( mp_parent->mp_flags & MONITOR_F_VOLATILE ) {
 445                         /* entry is volatile; cannot append children */
 446                         Debug( LDAP_DEBUG_ANY,
 447                                 "monitor_back_register_entry(\"%s\"): "
 448                                 "parent \"%s\" is volatile\n",
 449                                 e->e_name.bv_val, e_parent->e_name.bv_val, 0 );
 450                         rc = -1;
 451                         goto done;
 452                 }
 453
 454                 mp = monitor_entrypriv_create();
 455                 if ( mp == NULL ) {
 456                         Debug( LDAP_DEBUG_ANY,
 457                                 "monitor_back_register_entry(\"%s\"): "
 458                                 "monitor_entrypriv_create() failed\n",
 459                                 e->e_name.bv_val, 0, 0 );
 460                         rc = -1;
 461                         goto done;
 462                 }
 463
 464                 e_new = entry_dup( e );
 465                 if ( e_new == NULL ) {
 466                         Debug( LDAP_DEBUG_ANY,
 467                                 "monitor_back_register_entry(\"%s\"): "
 468                                 "entry_dup() failed\n",
 469                                 e->e_name.bv_val, 0, 0 );
 470                         rc = -1;
 471                         goto done;
 472                 }
 473
 474                 e_new->e_private = ( void * )mp;
 475                 if ( mss != NULL ) {
 476                         mp->mp_info = mss;
 477                         mp->mp_flags = flags;
 478
 479                 } else {
 480                         mp->mp_info = mp_parent->mp_info;
 481                         mp->mp_flags = mp_parent->mp_flags | MONITOR_F_SUB;
 482                 }
 483                 mp->mp_cb = cb;
 484
 485                 ep = &mp_parent->mp_children;
 486                 for ( ; *ep; ) {
 487                         mp_parent = ( monitor_entry_t * )(*ep)->e_private;
 488                         ep = &mp_parent->mp_next;
 489                 }
 490                 *ep = e_new;
 491
 492                 if ( monitor_cache_add( mi, e_new ) ) {
 493                         Debug( LDAP_DEBUG_ANY,
 494                                 "monitor_back_register_entry(\"%s\"): "
 495                                 "unable to add entry\n",
 496                                 e->e_name.bv_val, 0, 0 );
 497                         rc = -1;
 498                         goto done;
 499                 }
 500
 501 done:;
 502                 if ( rc ) {
 503                         if ( mp ) {
 504                                 ch_free( mp );
 505                         }
 506                         if ( e_new ) {
 507                                 e_new->e_private = NULL;
 508                                 entry_free( e_new );
 509                         }
 510                 }
 511
 512                 if ( e_parent ) {
 513                         monitor_cache_release( mi, e_parent );
 514                 }
 515
 516         } else {
 517                 entry_limbo_t   **elpp, el = { 0 };
 518
 519                 el.el_type = LIMBO_ENTRY;
 520
 521                 el.el_e = entry_dup( e );
 522                 if ( el.el_e == NULL ) {
 523                         Debug( LDAP_DEBUG_ANY,
 524                                 "monitor_back_register_entry(\"%s\"): "
 525                                 "entry_dup() failed\n",
 526                                 e->e_name.bv_val, 0, 0 );
 527                         return -1;
 528                 }
 529
 530                 el.el_cb = cb;
 531                 el.el_mss = mss;
 532                 el.el_flags = flags;
 533
 534                 for ( elpp = &mi->mi_entry_limbo;
 535                                 *elpp;
 536                                 elpp = &(*elpp)->el_next )
 537                         /* go to last */;
 538
 539                 *elpp = (entry_limbo_t *)ch_malloc( sizeof( entry_limbo_t ) );
 540                 if ( *elpp == NULL ) {
 541                         el.el_e->e_private = NULL;
 542                         entry_free( el.el_e );
 543                         return -1;
 544                 }
 545
 546                 el.el_next = NULL;
 547                 **elpp = el;
 548         }
 549
 550         return 0;
 551 }
 552
 553 int
 554 monitor_back_register_entry_parent(
 555         Entry                   *e,
 556         monitor_callback_t      *cb,
 557         monitor_subsys_t        *mss,
 558         unsigned long           flags,
 559         struct berval           *nbase,
 560         int                     scope,
 561         struct berval           *filter )
 562 {
 563         monitor_info_t  *mi;
 564         struct berval   ndn = BER_BVNULL;
 565
 566         if ( be_monitor == NULL ) {
 567                 Debug( LDAP_DEBUG_ANY,
 568                         "monitor_back_register_entry_parent(base=\"%s\" scope=%s filter=\"%s\"): "
 569                         "monitor database not configured.\n",
 570                         BER_BVISNULL( nbase ) ? "" : nbase->bv_val,
 571                         ldap_pvt_scope2str( scope ),
 572                         BER_BVISNULL( filter ) ? "" : filter->bv_val );
 573                 return -1;
 574         }
 575
 576         mi = ( monitor_info_t * )be_monitor->be_private;
 577
 578         assert( mi != NULL );
 579         assert( e != NULL );
 580         assert( e->e_private == NULL );
 581
 582         if ( BER_BVISNULL( filter ) ) {
 583                 /* need a filter */
 584                 Debug( LDAP_DEBUG_ANY,
 585                         "monitor_back_register_entry_parent(\"\"): "
 586                         "need a valid filter\n",
 587                         0, 0, 0 );
 588                 return -1;
 589         }
 590
 591         if ( monitor_subsys_is_opened() ) {
 592                 Entry           *e_parent = NULL,
 593                                 *e_new = NULL,
 594                                 **ep = NULL;
 595                 struct berval   e_name = BER_BVNULL,
 596                                 e_nname = BER_BVNULL;
 597                 monitor_entry_t *mp = NULL,
 598                                 *mp_parent = NULL;
 599                 int             rc = 0;
 600
 601                 if ( monitor_search2ndn( nbase, scope, filter, &ndn ) ) {
 602                         /* entry does not exist */
 603                         Debug( LDAP_DEBUG_ANY,
 604                                 "monitor_back_register_entry_parent(\"\"): "
 605                                 "base=\"%s\" scope=%s filter=\"%s\": "
 606                                 "unable to find entry\n",
 607                                 nbase->bv_val ? nbase->bv_val : "\"\"",
 608                                 ldap_pvt_scope2str( scope ),
 609                                 filter->bv_val );
 610                         return -1;
 611                 }
 612
 613                 if ( monitor_cache_get( mi, &ndn, &e_parent ) != 0 ) {
 614                         /* entry does not exist */
 615                         Debug( LDAP_DEBUG_ANY,
 616                                 "monitor_back_register_entry_parent(\"%s\"): "
 617                                 "parent entry does not exist\n",
 618                                 ndn.bv_val, 0, 0 );
 619                         rc = -1;
 620                         goto done;
 621                 }
 622
 623                 assert( e_parent->e_private != NULL );
 624                 mp_parent = ( monitor_entry_t * )e_parent->e_private;
 625
 626                 if ( mp_parent->mp_flags & MONITOR_F_VOLATILE ) {
 627                         /* entry is volatile; cannot append callback */
 628                         Debug( LDAP_DEBUG_ANY,
 629                                 "monitor_back_register_entry_parent(\"%s\"): "
 630                                 "entry is volatile\n",
 631                                 e_parent->e_name.bv_val, 0, 0 );
 632                         rc = -1;
 633                         goto done;
 634                 }
 635
 636                 build_new_dn( &e_name, &e_parent->e_name, &e->e_name, NULL );
 637                 build_new_dn( &e_nname, &e_parent->e_nname, &e->e_nname, NULL );
 638
 639                 if ( monitor_cache_get( mi, &e_nname, &e_new ) == 0 ) {
 640                         /* entry already exists */
 641                         Debug( LDAP_DEBUG_ANY,
 642                                 "monitor_back_register_entry_parent(\"%s\"): "
 643                                 "entry already exists\n",
 644                                 e_name.bv_val, 0, 0 );
 645                         monitor_cache_release( mi, e_new );
 646                         e_new = NULL;
 647                         rc = -1;
 648                         goto done;
 649                 }
 650
 651                 mp = monitor_entrypriv_create();
 652                 if ( mp == NULL ) {
 653                         Debug( LDAP_DEBUG_ANY,
 654                                 "monitor_back_register_entry_parent(\"%s\"): "
 655                                 "monitor_entrypriv_create() failed\n",
 656                                 e->e_name.bv_val, 0, 0 );
 657                         rc = -1;
 658                         goto done;
 659                 }
 660
 661                 e_new = entry_dup( e );
 662                 if ( e_new == NULL ) {
 663                         Debug( LDAP_DEBUG_ANY,
 664                                 "monitor_back_register_entry(\"%s\"): "
 665                                 "entry_dup() failed\n",
 666                                 e->e_name.bv_val, 0, 0 );
 667                         rc = -1;
 668                         goto done;
 669                 }
 670                 ch_free( e_new->e_name.bv_val );
 671                 ch_free( e_new->e_nname.bv_val );
 672                 e_new->e_name = e_name;
 673                 e_new->e_nname = e_nname;
 674
 675                 e_new->e_private = ( void * )mp;
 676                 if ( mss != NULL ) {
 677                         mp->mp_info = mss;
 678                         mp->mp_flags = flags;
 679
 680                 } else {
 681                         mp->mp_info = mp_parent->mp_info;
 682                         mp->mp_flags = mp_parent->mp_flags | MONITOR_F_SUB;
 683                 }
 684                 mp->mp_cb = cb;
 685
 686                 ep = &mp_parent->mp_children;
 687                 for ( ; *ep; ) {
 688                         mp_parent = ( monitor_entry_t * )(*ep)->e_private;
 689                         ep = &mp_parent->mp_next;
 690                 }
 691                 *ep = e_new;
 692
 693                 if ( monitor_cache_add( mi, e_new ) ) {
 694                         Debug( LDAP_DEBUG_ANY,
 695                                 "monitor_back_register_entry(\"%s\"): "
 696                                 "unable to add entry\n",
 697                                 e->e_name.bv_val, 0, 0 );
 698                         rc = -1;
 699                         goto done;
 700                 }
 701
 702 done:;
 703                 if ( !BER_BVISNULL( &ndn ) ) {
 704                         ch_free( ndn.bv_val );
 705                 }
 706
 707                 if ( rc ) {
 708                         if ( mp ) {
 709                                 ch_free( mp );
 710                         }
 711                         if ( e_new ) {
 712                                 e_new->e_private = NULL;
 713                                 entry_free( e_new );
 714                         }
 715                 }
 716
 717                 if ( e_parent ) {
 718                         monitor_cache_release( mi, e_parent );
 719                 }
 720
 721         } else {
 722                 entry_limbo_t   **elpp = NULL, el = { 0 };
 723
 724                 el.el_type = LIMBO_ENTRY_PARENT;
 725
 726                 el.el_e = entry_dup( e );
 727                 if ( el.el_e == NULL ) {
 728                         Debug( LDAP_DEBUG_ANY,
 729                                 "monitor_back_register_entry(\"%s\"): "
 730                                 "entry_dup() failed\n",
 731                                 e->e_name.bv_val, 0, 0 );
 732                         goto done_limbo;
 733                 }
 734
 735                 if ( !BER_BVISNULL( nbase ) ) {
 736                         ber_dupbv( &el.el_nbase, nbase );
 737                 }
 738
 739                 el.el_scope = scope;
 740                 if ( !BER_BVISNULL( filter ) ) {
 741                         ber_dupbv( &el.el_filter, filter  );
 742                 }
 743
 744                 el.el_cb = cb;
 745                 el.el_mss = mss;
 746                 el.el_flags = flags;
 747
 748                 for ( elpp = &mi->mi_entry_limbo;
 749                                 *elpp;
 750                                 elpp = &(*elpp)->el_next )
 751                         /* go to last */;
 752
 753                 *elpp = (entry_limbo_t *)ch_malloc( sizeof( entry_limbo_t ) );
 754                 if ( *elpp == NULL ) {
 755                         goto done_limbo;
 756                 }
 757
 758 done_limbo:;
 759                 if ( *elpp != NULL ) {
 760                         el.el_next = NULL;
 761                         **elpp = el;
 762
 763                 } else {
 764                         if ( !BER_BVISNULL( &el.el_filter ) ) {
 765                                 ch_free( el.el_filter.bv_val );
 766                         }
 767                         if ( !BER_BVISNULL( &el.el_nbase ) ) {
 768                                 ch_free( el.el_nbase.bv_val );
 769                         }
 770                         entry_free( el.el_e );
 771                         return -1;
 772                 }
 773         }
 774
 775         return 0;
 776 }
 777
 778 static int
 779 monitor_search2ndn_cb( Operation *op, SlapReply *rs )
 780 {
 781         if ( rs->sr_type == REP_SEARCH ) {
 782                 struct berval   *ndn = op->o_callback->sc_private;
 783
 784                 if ( !BER_BVISNULL( ndn ) ) {
 785                         rs->sr_err = LDAP_SIZELIMIT_EXCEEDED;
 786                         ch_free( ndn->bv_val );
 787                         BER_BVZERO( ndn );
 788                         return rs->sr_err;
 789                 }
 790
 791                 ber_dupbv( ndn, &rs->sr_entry->e_nname );
 792         }
 793
 794         return 0;
 795 }
 796
 797 int
 798 monitor_search2ndn(
 799         struct berval   *nbase,
 800         int             scope,
 801         struct berval   *filter,
 802         struct berval   *ndn )
 803 {
 804         Connection      conn = { 0 };
 805         OperationBuffer opbuf;
 806         Operation       *op;
 807         void    *thrctx;
 808         SlapReply       rs = { 0 };
 809         slap_callback   cb = { NULL, monitor_search2ndn_cb, NULL, NULL };
 810         int             rc;
 811
 812         BER_BVZERO( ndn );
 813
 814         if ( be_monitor == NULL ) {
 815                 return -1;
 816         }
 817
 818         thrctx = ldap_pvt_thread_pool_context();
 819         connection_fake_init( &conn, &opbuf, thrctx );
 820         op = &opbuf.ob_op;
 821
 822         op->o_tag = LDAP_REQ_SEARCH;
 823
 824         /* use global malloc for now */
 825         if ( op->o_tmpmemctx ) {
 826                 op->o_tmpmemctx = NULL;
 827         }
 828         op->o_tmpmfuncs = &ch_mfuncs;
 829
 830         op->o_bd = be_monitor;
 831         if ( nbase == NULL || BER_BVISNULL( nbase ) ) {
 832                 ber_dupbv_x( &op->o_req_dn, &op->o_bd->be_suffix[ 0 ],
 833                                 op->o_tmpmemctx );
 834                 ber_dupbv_x( &op->o_req_ndn, &op->o_bd->be_nsuffix[ 0 ],
 835                                 op->o_tmpmemctx );
 836
 837         } else {
 838                 if ( dnPrettyNormal( NULL, nbase, &op->o_req_dn, &op->o_req_ndn,
 839                                         op->o_tmpmemctx ) ) {
 840                         return -1;
 841                 }
 842         }
 843
 844         op->o_callback = &cb;
 845         cb.sc_private = (void *)ndn;
 846
 847         op->ors_scope = scope;
 848         op->ors_filter = str2filter_x( op, filter->bv_val );
 849         if ( op->ors_filter == NULL ) {
 850                 rc = LDAP_OTHER;
 851                 goto cleanup;
 852         }
 853         ber_dupbv_x( &op->ors_filterstr, filter, op->o_tmpmemctx );
 854         op->ors_attrs = slap_anlist_no_attrs;
 855         op->ors_attrsonly = 0;
 856         op->ors_tlimit = SLAP_NO_LIMIT;
 857         op->ors_slimit = 1;
 858         op->ors_limit = NULL;
 859         op->ors_deref = LDAP_DEREF_NEVER;
 860
 861         op->o_nocaching = 1;
 862         op->o_managedsait = SLAP_CONTROL_NONCRITICAL;
 863
 864         op->o_dn = be_monitor->be_rootdn;
 865         op->o_ndn = be_monitor->be_rootndn;
 866
 867         rc = op->o_bd->be_search( op, &rs );
 868
 869 cleanup:;
 870         if ( op->ors_filter != NULL ) {
 871                 filter_free_x( op, op->ors_filter );
 872         }
 873         if ( !BER_BVISNULL( &op->ors_filterstr ) ) {
 874                 op->o_tmpfree( op->ors_filterstr.bv_val, op->o_tmpmemctx );
 875         }
 876         if ( !BER_BVISNULL( &op->o_req_dn ) ) {
 877                 op->o_tmpfree( op->o_req_dn.bv_val, op->o_tmpmemctx );
 878         }
 879         if ( !BER_BVISNULL( &op->o_req_ndn ) ) {
 880                 op->o_tmpfree( op->o_req_ndn.bv_val, op->o_tmpmemctx );
 881         }
 882
 883         if ( rc != 0 ) {
 884                 return rc;
 885         }
 886
 887         switch ( rs.sr_err ) {
 888         case LDAP_SUCCESS:
 889                 if ( BER_BVISNULL( ndn ) ) {
 890                         rc = -1;
 891                 }
 892                 break;
 893
 894         case LDAP_SIZELIMIT_EXCEEDED:
 895         default:
 896                 if ( !BER_BVISNULL( ndn ) ) {
 897                         ber_memfree( ndn->bv_val );
 898                         BER_BVZERO( ndn );
 899                 }
 900                 rc = -1;
 901                 break;
 902         }
 903
 904         return rc;
 905 }
 906
 907 int
 908 monitor_back_register_entry_attrs(
 909         struct berval           *ndn_in,
 910         Attribute               *a,
 911         monitor_callback_t      *cb,
 912         struct berval           *nbase,
 913         int                     scope,
 914         struct berval           *filter )
 915 {
 916         monitor_info_t  *mi;
 917         struct berval   ndn = BER_BVNULL;
 918         char            *fname = ( a == NULL ? "callback" : "attrs" );
 919
 920         if ( be_monitor == NULL ) {
 921                 char            buf[ SLAP_TEXT_BUFLEN ];
 922
 923                 snprintf( buf, sizeof( buf ),
 924                         "monitor_back_register_entry_%s(base=\"%s\" scope=%s filter=\"%s\"): "
 925                         "monitor database not configured.\n",
 926                         fname,
 927                         BER_BVISNULL( nbase ) ? "" : nbase->bv_val,
 928                         ldap_pvt_scope2str( scope ),
 929                         BER_BVISNULL( filter ) ? "" : filter->bv_val );
 930                 Debug( LDAP_DEBUG_ANY, "%s\n", buf, 0, 0 );
 931
 932                 return -1;
 933         }
 934
 935         mi = ( monitor_info_t * )be_monitor->be_private;
 936
 937         assert( mi != NULL );
 938
 939         if ( ndn_in != NULL ) {
 940                 ndn = *ndn_in;
 941         }
 942
 943         if ( a == NULL && cb == NULL ) {
 944                 /* nothing to do */
 945                 return -1;
 946         }
 947
 948         if ( ( ndn_in == NULL || BER_BVISNULL( &ndn ) )
 949                         && BER_BVISNULL( filter ) )
 950         {
 951                 /* need a filter */
 952                 Debug( LDAP_DEBUG_ANY,
 953                         "monitor_back_register_entry_%s(\"\"): "
 954                         "need a valid filter\n",
 955                         fname, 0, 0 );
 956                 return -1;
 957         }
 958
 959         if ( monitor_subsys_is_opened() ) {
 960                 Entry                   *e = NULL;
 961                 Attribute               **atp = NULL;
 962                 monitor_entry_t         *mp = NULL;
 963                 monitor_callback_t      **mcp = NULL;
 964                 int                     rc = 0;
 965                 int                     freeit = 0;
 966
 967                 if ( BER_BVISNULL( &ndn ) ) {
 968                         if ( monitor_search2ndn( nbase, scope, filter, &ndn ) ) {
 969                                 char            buf[ SLAP_TEXT_BUFLEN ];
 970
 971                                 snprintf( buf, sizeof( buf ),
 972                                         "monitor_back_register_entry_%s(\"\"): "
 973                                         "base=\"%s\" scope=%s filter=\"%s\": "
 974                                         "unable to find entry\n",
 975                                         fname,
 976                                         nbase->bv_val ? nbase->bv_val : "\"\"",
 977                                         ldap_pvt_scope2str( scope ),
 978                                         filter->bv_val );
 979
 980                                 /* entry does not exist */
 981                                 Debug( LDAP_DEBUG_ANY, "%s\n", buf, 0, 0 );
 982                                 return -1;
 983                         }
 984
 985                         freeit = 1;
 986                 }
 987
 988                 if ( monitor_cache_get( mi, &ndn, &e ) != 0 ) {
 989                         /* entry does not exist */
 990                         Debug( LDAP_DEBUG_ANY,
 991                                 "monitor_back_register_entry_%s(\"%s\"): "
 992                                 "entry does not exist\n",
 993                                 fname, ndn.bv_val, 0 );
 994                         rc = -1;
 995                         goto done;
 996                 }
 997
 998                 assert( e->e_private != NULL );
 999                 mp = ( monitor_entry_t * )e->e_private;
1000
1001                 if ( mp->mp_flags & MONITOR_F_VOLATILE ) {
1002                         /* entry is volatile; cannot append callback */
1003                         Debug( LDAP_DEBUG_ANY,
1004                                 "monitor_back_register_entry_%s(\"%s\"): "
1005                                 "entry is volatile\n",
1006                                 fname, e->e_name.bv_val, 0 );
1007                         rc = -1;
1008                         goto done;
1009                 }
1010
1011                 if ( a ) {
1012                         for ( atp = &e->e_attrs; *atp; atp = &(*atp)->a_next )
1013                                 /* just get to last */ ;
1014
1015                         for ( ; a != NULL; a = a->a_next ) {
1016                                 assert( a->a_desc != NULL );
1017                                 assert( a->a_vals != NULL );
1018
1019                                 if ( attr_find( e->e_attrs, a->a_desc ) ) {
1020                                         attr_merge( e, a->a_desc, a->a_vals,
1021                                                 a->a_nvals == a->a_vals ? NULL : a->a_nvals );
1022
1023                                 } else {
1024                                         *atp = attr_dup( a );
1025                                         if ( *atp == NULL ) {
1026                                                 Debug( LDAP_DEBUG_ANY,
1027                                                         "monitor_back_register_entry_%s(\"%s\"): "
1028                                                         "attr_dup() failed\n",
1029                                                         fname, e->e_name.bv_val, 0 );
1030                                                 rc = -1;
1031                                                 goto done;
1032                                         }
1033                                         atp = &(*atp)->a_next;
1034                                 }
1035                         }
1036                 }
1037
1038                 if ( cb ) {
1039                         for ( mcp = &mp->mp_cb; *mcp; mcp = &(*mcp)->mc_next )
1040                                 /* go to tail */ ;
1041
1042                         /* NOTE: we do not clear cb->mc_next, so this function
1043                          * can be used to append a list of callbacks */
1044                         (*mcp) = cb;
1045                 }
1046
1047 done:;
1048                 if ( rc ) {
1049                         if ( atp && *atp ) {
1050                                 attrs_free( *atp );
1051                                 *atp = NULL;
1052                         }
1053                 }
1054
1055                 if ( freeit ) {
1056                         ber_memfree( ndn.bv_val );
1057                 }
1058
1059                 if ( e ) {
1060                         monitor_cache_release( mi, e );
1061                 }
1062
1063         } else {
1064                 entry_limbo_t   **elpp, el = { 0 };
1065
1066                 el.el_type = LIMBO_ATTRS;
1067                 el.el_ndn = ndn_in;
1068                 if ( !BER_BVISNULL( nbase ) ) {
1069                         ber_dupbv( &el.el_nbase, nbase);
1070                 }
1071                 el.el_scope = scope;
1072                 if ( !BER_BVISNULL( filter ) ) {
1073                         ber_dupbv( &el.el_filter, filter  );
1074                 }
1075
1076                 el.el_a = attrs_dup( a );
1077                 el.el_cb = cb;
1078
1079                 for ( elpp = &mi->mi_entry_limbo;
1080                                 *elpp;
1081                                 elpp = &(*elpp)->el_next )
1082                         /* go to last */;
1083
1084                 *elpp = (entry_limbo_t *)ch_malloc( sizeof( entry_limbo_t ) );
1085                 if ( *elpp == NULL ) {
1086                         el.el_e->e_private = NULL;
1087                         entry_free( el.el_e );
1088                         return -1;
1089                 }
1090
1091                 if ( *elpp != NULL ) {
1092                         el.el_next = NULL;
1093                         **elpp = el;
1094
1095                 } else {
1096                         if ( !BER_BVISNULL( &el.el_filter ) ) {
1097                                 ch_free( el.el_filter.bv_val );
1098                         }
1099                         if ( el.el_a != NULL ) {
1100                                 attrs_free( el.el_a );
1101                         }
1102                         if ( !BER_BVISNULL( &el.el_nbase ) ) {
1103                                 ch_free( &el.el_nbase.bv_val );
1104                         }
1105                         return -1;
1106                 }
1107         }
1108
1109         return 0;
1110 }
1111
1112 int
1113 monitor_back_register_entry_callback(
1114         struct berval           *ndn,
1115         monitor_callback_t      *cb,
1116         struct berval           *nbase,
1117         int                     scope,
1118         struct berval           *filter )
1119 {
1120         return monitor_back_register_entry_attrs( ndn, NULL, cb,
1121                         nbase, scope, filter );
1122 }
1123
1124 /*
1125  * TODO: add corresponding calls to remove installed callbacks, entries
1126  * and so, in case the entity that installed them is removed (e.g. a
1127  * database, via back-config)
1128  */
1129 int
1130 monitor_back_unregister_entry(
1131         struct berval   *ndn )
1132 {
1133         monitor_info_t  *mi;
1134
1135         if ( be_monitor == NULL ) {
1136                 Debug( LDAP_DEBUG_ANY,
1137                         "monitor_back_unregister_entry(\"%s\"): "
1138                         "monitor database not configured.\n",
1139                         ndn->bv_val, 0, 0 );
1140
1141                 return -1;
1142         }
1143
1144         /* entry will be regularly freed, and resources released
1145          * according to callbacks */
1146         if ( slapd_shutdown ) {
1147                 return 0;
1148         }
1149
1150         mi = ( monitor_info_t * )be_monitor->be_private;
1151
1152         assert( mi != NULL );
1153
1154         if ( monitor_subsys_is_opened() ) {
1155                 Entry                   *e = NULL;
1156                 monitor_entry_t         *mp = NULL;
1157                 monitor_callback_t      *cb = NULL;
1158
1159                 if ( monitor_cache_remove( mi, ndn, &e ) != 0 ) {
1160                         /* entry does not exist */
1161                         Debug( LDAP_DEBUG_ANY,
1162                                 "monitor_back_unregister_entry(\"%s\"): "
1163                                 "entry removal failed.\n",
1164                                 ndn->bv_val, 0, 0 );
1165                         return -1;
1166                 }
1167
1168                 mp = (monitor_entry_t *)e->e_private;
1169                 assert( mp != NULL );
1170
1171                 for ( cb = mp->mp_cb; cb != NULL; ) {
1172                         monitor_callback_t      *next = cb->mc_next;
1173
1174                         if ( cb->mc_free ) {
1175                                 (void)cb->mc_free( e, &cb->mc_private );
1176                         }
1177                         ch_free( cb );
1178
1179                         cb = next;
1180                 }
1181
1182                 ch_free( mp );
1183                 e->e_private = NULL;
1184                 entry_free( e );
1185
1186         } else {
1187                 entry_limbo_t   **elpp;
1188
1189                 for ( elpp = &mi->mi_entry_limbo;
1190                         *elpp;
1191                         elpp = &(*elpp)->el_next )
1192                 {
1193                         entry_limbo_t   *elp = *elpp;
1194
1195                         if ( elp->el_type == LIMBO_ENTRY
1196                                 && dn_match( ndn, &elp->el_e->e_nname ) )
1197                         {
1198                                 monitor_callback_t      *cb, *next;
1199
1200                                 for ( cb = elp->el_cb; cb; cb = next ) {
1201                                         /* FIXME: call callbacks? */
1202                                         next = cb->mc_next;
1203                                         if ( cb->mc_dispose ) {
1204                                                 cb->mc_dispose( &cb->mc_private );
1205                                         }
1206                                         ch_free( cb );
1207                                 }
1208                                 assert( elp->el_e != NULL );
1209                                 elp->el_e->e_private = NULL;
1210                                 entry_free( elp->el_e );
1211                                 *elpp = elp->el_next;
1212                                 ch_free( elp );
1213                                 elpp = NULL;
1214                                 break;
1215                         }
1216                 }
1217
1218                 if ( elpp != NULL ) {
1219                         /* not found!  where did it go? */
1220                         return 1;
1221                 }
1222         }
1223
1224         return 0;
1225 }
1226
1227 int
1228 monitor_back_unregister_entry_parent(
1229         struct berval           *nrdn,
1230         monitor_callback_t      *target_cb,
1231         struct berval           *nbase,
1232         int                     scope,
1233         struct berval           *filter )
1234 {
1235         monitor_info_t  *mi;
1236         struct berval   ndn = BER_BVNULL;
1237
1238         if ( be_monitor == NULL ) {
1239                 Debug( LDAP_DEBUG_ANY,
1240                         "monitor_back_unregister_entry_parent(base=\"%s\" scope=%s filter=\"%s\"): "
1241                         "monitor database not configured.\n",
1242                         BER_BVISNULL( nbase ) ? "" : nbase->bv_val,
1243                         ldap_pvt_scope2str( scope ),
1244                         BER_BVISNULL( filter ) ? "" : filter->bv_val );
1245
1246                 return -1;
1247         }
1248
1249         /* entry will be regularly freed, and resources released
1250          * according to callbacks */
1251         if ( slapd_shutdown ) {
1252                 return 0;
1253         }
1254
1255         mi = ( monitor_info_t * )be_monitor->be_private;
1256
1257         assert( mi != NULL );
1258
1259         if ( ( nrdn == NULL || BER_BVISNULL( nrdn ) )
1260                         && BER_BVISNULL( filter ) )
1261         {
1262                 /* need a filter */
1263                 Debug( LDAP_DEBUG_ANY,
1264                         "monitor_back_unregister_entry_parent(\"\"): "
1265                         "need a valid filter\n",
1266                         0, 0, 0 );
1267                 return -1;
1268         }
1269
1270         if ( monitor_subsys_is_opened() ) {
1271                 Entry                   *e = NULL;
1272                 monitor_entry_t         *mp = NULL;
1273
1274                 if ( monitor_search2ndn( nbase, scope, filter, &ndn ) ) {
1275                         /* entry does not exist */
1276                         Debug( LDAP_DEBUG_ANY,
1277                                 "monitor_back_unregister_entry_parent(\"\"): "
1278                                 "base=\"%s\" scope=%s filter=\"%s\": "
1279                                 "unable to find entry\n",
1280                                 nbase->bv_val ? nbase->bv_val : "\"\"",
1281                                 ldap_pvt_scope2str( scope ),
1282                                 filter->bv_val );
1283                         return -1;
1284                 }
1285
1286                 if ( monitor_cache_remove( mi, &ndn, &e ) != 0 ) {
1287                         /* entry does not exist */
1288                         Debug( LDAP_DEBUG_ANY,
1289                                 "monitor_back_unregister_entry(\"%s\"): "
1290                                 "entry removal failed.\n",
1291                                 ndn.bv_val, 0, 0 );
1292                         ber_memfree( ndn.bv_val );
1293                         return -1;
1294                 }
1295                 ber_memfree( ndn.bv_val );
1296
1297                 mp = (monitor_entry_t *)e->e_private;
1298                 assert( mp != NULL );
1299
1300                 if ( target_cb != NULL ) {
1301                         monitor_callback_t      **cbp;
1302
1303                         for ( cbp = &mp->mp_cb; *cbp != NULL; cbp = &(*cbp)->mc_next ) {
1304                                 if ( *cbp == target_cb ) {
1305                                         if ( (*cbp)->mc_free ) {
1306                                                 (void)(*cbp)->mc_free( e, &(*cbp)->mc_private );
1307                                         }
1308                                         *cbp = (*cbp)->mc_next;
1309                                         ch_free( target_cb );
1310                                         break;
1311                                 }
1312                         }
1313                 }
1314
1315
1316                 ch_free( mp );
1317                 e->e_private = NULL;
1318                 entry_free( e );
1319
1320         } else {
1321                 entry_limbo_t   **elpp;
1322
1323                 for ( elpp = &mi->mi_entry_limbo;
1324                         *elpp;
1325                         elpp = &(*elpp)->el_next )
1326                 {
1327                         entry_limbo_t   *elp = *elpp;
1328
1329                         if ( elp->el_type == LIMBO_ENTRY_PARENT
1330                                 && dn_match( nrdn, &elp->el_e->e_nname )
1331                                 && dn_match( nbase, &elp->el_nbase )
1332                                 && scope == elp->el_scope
1333                                 && bvmatch( filter, &elp->el_filter ) )
1334                         {
1335                                 monitor_callback_t      *cb, *next;
1336
1337                                 for ( cb = elp->el_cb; cb; cb = next ) {
1338                                         /* FIXME: call callbacks? */
1339                                         next = cb->mc_next;
1340                                         if ( cb->mc_dispose ) {
1341                                                 cb->mc_dispose( &cb->mc_private );
1342                                         }
1343                                         ch_free( cb );
1344                                 }
1345                                 assert( elp->el_e != NULL );
1346                                 elp->el_e->e_private = NULL;
1347                                 entry_free( elp->el_e );
1348                                 if ( !BER_BVISNULL( &elp->el_nbase ) ) {
1349                                         ch_free( elp->el_nbase.bv_val );
1350                                 }
1351                                 if ( !BER_BVISNULL( &elp->el_filter ) ) {
1352                                         ch_free( elp->el_filter.bv_val );
1353                                 }
1354                                 *elpp = elp->el_next;
1355                                 ch_free( elp );
1356                                 elpp = NULL;
1357                                 break;
1358                         }
1359                 }
1360
1361                 if ( elpp != NULL ) {
1362                         /* not found!  where did it go? */
1363                         return 1;
1364                 }
1365         }
1366
1367         return 0;
1368 }
1369
1370 int
1371 monitor_back_unregister_entry_attrs(
1372         struct berval           *ndn_in,
1373         Attribute               *target_a,
1374         monitor_callback_t      *target_cb,
1375         struct berval           *nbase,
1376         int                     scope,
1377         struct berval           *filter )
1378 {
1379         monitor_info_t  *mi;
1380         struct berval   ndn = BER_BVNULL;
1381         char            *fname = ( target_a == NULL ? "callback" : "attrs" );
1382
1383         if ( be_monitor == NULL ) {
1384                 char            buf[ SLAP_TEXT_BUFLEN ];
1385
1386                 snprintf( buf, sizeof( buf ),
1387                         "monitor_back_unregister_entry_%s(base=\"%s\" scope=%s filter=\"%s\"): "
1388                         "monitor database not configured.\n",
1389                         fname,
1390                         BER_BVISNULL( nbase ) ? "" : nbase->bv_val,
1391                         ldap_pvt_scope2str( scope ),
1392                         BER_BVISNULL( filter ) ? "" : filter->bv_val );
1393                 Debug( LDAP_DEBUG_ANY, "%s\n", buf, 0, 0 );
1394
1395                 return -1;
1396         }
1397
1398         /* entry will be regularly freed, and resources released
1399          * according to callbacks */
1400         if ( slapd_shutdown ) {
1401                 return 0;
1402         }
1403
1404         mi = ( monitor_info_t * )be_monitor->be_private;
1405
1406         assert( mi != NULL );
1407
1408         if ( ndn_in != NULL ) {
1409                 ndn = *ndn_in;
1410         }
1411
1412         if ( target_a == NULL && target_cb == NULL ) {
1413                 /* nothing to do */
1414                 return -1;
1415         }
1416
1417         if ( ( ndn_in == NULL || BER_BVISNULL( &ndn ) )
1418                         && BER_BVISNULL( filter ) )
1419         {
1420                 /* need a filter */
1421                 Debug( LDAP_DEBUG_ANY,
1422                         "monitor_back_unregister_entry_%s(\"\"): "
1423                         "need a valid filter\n",
1424                         fname, 0, 0 );
1425                 return -1;
1426         }
1427
1428         if ( monitor_subsys_is_opened() ) {
1429                 Entry                   *e = NULL;
1430                 monitor_entry_t         *mp = NULL;
1431                 int                     freeit = 0;
1432
1433                 if ( BER_BVISNULL( &ndn ) ) {
1434                         if ( monitor_search2ndn( nbase, scope, filter, &ndn ) ) {
1435                                 char            buf[ SLAP_TEXT_BUFLEN ];
1436
1437                                 snprintf( buf, sizeof( buf ),
1438                                         "monitor_back_unregister_entry_%s(\"\"): "
1439                                         "base=\"%s\" scope=%d filter=\"%s\": "
1440                                         "unable to find entry\n",
1441                                         fname,
1442                                         nbase->bv_val ? nbase->bv_val : "\"\"",
1443                                         scope, filter->bv_val );
1444
1445                                 /* entry does not exist */
1446                                 Debug( LDAP_DEBUG_ANY, "%s\n", buf, 0, 0 );
1447                                 return -1;
1448                         }
1449
1450                         freeit = 1;
1451                 }
1452
1453                 if ( monitor_cache_get( mi, &ndn, &e ) != 0 ) {
1454                         /* entry does not exist */
1455                         Debug( LDAP_DEBUG_ANY,
1456                                 "monitor_back_unregister_entry(\"%s\"): "
1457                                 "entry removal failed.\n",
1458                                 ndn.bv_val, 0, 0 );
1459                         return -1;
1460                 }
1461
1462                 mp = (monitor_entry_t *)e->e_private;
1463                 assert( mp != NULL );
1464
1465                 if ( target_cb != NULL ) {
1466                         monitor_callback_t      **cbp;
1467
1468                         for ( cbp = &mp->mp_cb; *cbp != NULL; cbp = &(*cbp)->mc_next ) {
1469                                 if ( *cbp == target_cb ) {
1470                                         if ( (*cbp)->mc_free ) {
1471                                                 (void)(*cbp)->mc_free( e, &(*cbp)->mc_private );
1472                                         }
1473                                         *cbp = (*cbp)->mc_next;
1474                                         ch_free( target_cb );
1475                                         break;
1476                                 }
1477                         }
1478                 }
1479
1480                 if ( target_a != NULL ) {
1481                         Attribute       *a;
1482
1483                         for ( a = target_a; a != NULL; a = a->a_next ) {
1484                                 Modification    mod = { 0 };
1485                                 const char      *text;
1486                                 char            textbuf[ SLAP_TEXT_BUFLEN ];
1487
1488                                 mod.sm_op = LDAP_MOD_DELETE;
1489                                 mod.sm_desc = a->a_desc;
1490                                 mod.sm_values = a->a_vals;
1491                                 mod.sm_nvalues = a->a_nvals;
1492
1493                                 (void)modify_delete_values( e, &mod, 1,
1494                                         &text, textbuf, sizeof( textbuf ) );
1495                         }
1496                 }
1497
1498                 if ( freeit ) {
1499                         ber_memfree( ndn.bv_val );
1500                 }
1501
1502                 monitor_cache_release( mi, e );
1503
1504         } else {
1505                 entry_limbo_t   **elpp;
1506
1507                 for ( elpp = &mi->mi_entry_limbo;
1508                         *elpp;
1509                         elpp = &(*elpp)->el_next )
1510                 {
1511                         entry_limbo_t   *elp = *elpp;
1512
1513                         if ( elp->el_type == LIMBO_ATTRS
1514                                 && dn_match( nbase, &elp->el_nbase )
1515                                 && scope == elp->el_scope
1516                                 && bvmatch( filter, &elp->el_filter ) )
1517                         {
1518                                 monitor_callback_t      *cb, *next;
1519
1520                                 for ( cb = elp->el_cb; cb; cb = next ) {
1521                                         /* FIXME: call callbacks? */
1522                                         next = cb->mc_next;
1523                                         if ( cb->mc_dispose ) {
1524                                                 cb->mc_dispose( &cb->mc_private );
1525                                         }
1526                                         ch_free( cb );
1527                                 }
1528                                 assert( elp->el_e == NULL );
1529                                 if ( elp->el_a != NULL ) {
1530                                         attrs_free( elp->el_a );
1531                                 }
1532                                 if ( !BER_BVISNULL( &elp->el_nbase ) ) {
1533                                         ch_free( elp->el_nbase.bv_val );
1534                                 }
1535                                 if ( !BER_BVISNULL( &elp->el_filter ) ) {
1536                                         ch_free( elp->el_filter.bv_val );
1537                                 }
1538                                 *elpp = elp->el_next;
1539                                 ch_free( elp );
1540                                 elpp = NULL;
1541                                 break;
1542                         }
1543                 }
1544
1545                 if ( elpp != NULL ) {
1546                         /* not found!  where did it go? */
1547                         return 1;
1548                 }
1549         }
1550
1551         return 0;
1552 }
1553
1554 int
1555 monitor_back_unregister_entry_callback(
1556         struct berval           *ndn,
1557         monitor_callback_t      *cb,
1558         struct berval           *nbase,
1559         int                     scope,
1560         struct berval           *filter )
1561 {
1562         /* TODO: lookup entry (by ndn, if not NULL, and/or by callback);
1563          * unregister the callback; if a is not null, unregister the
1564          * given attrs.  In any case, call cb->cb_free */
1565         return monitor_back_unregister_entry_attrs( ndn,
1566                 NULL, cb, nbase, scope, filter );
1567 }
1568
1569 monitor_subsys_t *
1570 monitor_back_get_subsys( const char *name )
1571 {
1572         if ( monitor_subsys != NULL ) {
1573                 int     i;
1574
1575                 for ( i = 0; monitor_subsys[ i ] != NULL; i++ ) {
1576                         if ( strcasecmp( monitor_subsys[ i ]->mss_name, name ) == 0 ) {
1577                                 return monitor_subsys[ i ];
1578                         }
1579                 }
1580         }
1581
1582         return NULL;
1583 }
1584
1585 monitor_subsys_t *
1586 monitor_back_get_subsys_by_dn(
1587         struct berval   *ndn,
1588         int             sub )
1589 {
1590         if ( monitor_subsys != NULL ) {
1591                 int     i;
1592
1593                 if ( sub ) {
1594                         for ( i = 0; monitor_subsys[ i ] != NULL; i++ ) {
1595                                 if ( dnIsSuffix( ndn, &monitor_subsys[ i ]->mss_ndn ) ) {
1596                                         return monitor_subsys[ i ];
1597                                 }
1598                         }
1599
1600                 } else {
1601                         for ( i = 0; monitor_subsys[ i ] != NULL; i++ ) {
1602                                 if ( dn_match( ndn, &monitor_subsys[ i ]->mss_ndn ) ) {
1603                                         return monitor_subsys[ i ];
1604                                 }
1605                         }
1606                 }
1607         }
1608
1609         return NULL;
1610 }
1611
1612 int
1613 monitor_back_initialize(
1614         BackendInfo     *bi )
1615 {
1616         static char             *controls[] = {
1617                 LDAP_CONTROL_MANAGEDSAIT,
1618                 NULL
1619         };
1620
1621         static ConfigTable monitorcfg[] = {
1622                 { NULL, NULL, 0, 0, 0, ARG_IGNORED,
1623                         NULL, NULL, NULL, NULL }
1624         };
1625
1626         static ConfigOCs monitorocs[] = {
1627                 { "( OLcfgDbOc:4.1 "
1628                         "NAME 'olcMonitorConfig' "
1629                         "DESC 'Monitor backend configuration' "
1630                         "SUP olcDatabaseConfig "
1631                         ")",
1632                                 Cft_Database, monitorcfg },
1633                 { NULL, 0, NULL }
1634         };
1635
1636         struct m_s {
1637                 char    *schema;
1638                 slap_mask_t flags;
1639                 int     offset;
1640         } moc[] = {
1641                 { "( 1.3.6.1.4.1.4203.666.3.16.1 "
1642                         "NAME 'monitor' "
1643                         "DESC 'OpenLDAP system monitoring' "
1644                         "SUP top STRUCTURAL "
1645                         "MUST cn "
1646                         "MAY ( "
1647                                 "description "
1648                                 "$ seeAlso "
1649                                 "$ labeledURI "
1650                                 "$ monitoredInfo "
1651                                 "$ managedInfo "
1652                                 "$ monitorOverlay "
1653                         ") )", SLAP_OC_OPERATIONAL|SLAP_OC_HIDE,
1654                         offsetof(monitor_info_t, mi_oc_monitor) },
1655                 { "( 1.3.6.1.4.1.4203.666.3.16.2 "
1656                         "NAME 'monitorServer' "
1657                         "DESC 'Server monitoring root entry' "
1658                         "SUP monitor STRUCTURAL )", SLAP_OC_OPERATIONAL|SLAP_OC_HIDE,
1659                         offsetof(monitor_info_t, mi_oc_monitorServer) },
1660                 { "( 1.3.6.1.4.1.4203.666.3.16.3 "
1661                         "NAME 'monitorContainer' "
1662                         "DESC 'monitor container class' "
1663                         "SUP monitor STRUCTURAL )", SLAP_OC_OPERATIONAL|SLAP_OC_HIDE,
1664                         offsetof(monitor_info_t, mi_oc_monitorContainer) },
1665                 { "( 1.3.6.1.4.1.4203.666.3.16.4 "
1666                         "NAME 'monitorCounterObject' "
1667                         "DESC 'monitor counter class' "
1668                         "SUP monitor STRUCTURAL )", SLAP_OC_OPERATIONAL|SLAP_OC_HIDE,
1669                         offsetof(monitor_info_t, mi_oc_monitorCounterObject) },
1670                 { "( 1.3.6.1.4.1.4203.666.3.16.5 "
1671                         "NAME 'monitorOperation' "
1672                         "DESC 'monitor operation class' "
1673                         "SUP monitor STRUCTURAL )", SLAP_OC_OPERATIONAL|SLAP_OC_HIDE,
1674                         offsetof(monitor_info_t, mi_oc_monitorOperation) },
1675                 { "( 1.3.6.1.4.1.4203.666.3.16.6 "
1676                         "NAME 'monitorConnection' "
1677                         "DESC 'monitor connection class' "
1678                         "SUP monitor STRUCTURAL )", SLAP_OC_OPERATIONAL|SLAP_OC_HIDE,
1679                         offsetof(monitor_info_t, mi_oc_monitorConnection) },
1680                 { "( 1.3.6.1.4.1.4203.666.3.16.7 "
1681                         "NAME 'managedObject' "
1682                         "DESC 'monitor managed entity class' "
1683                         "SUP monitor STRUCTURAL )", SLAP_OC_OPERATIONAL|SLAP_OC_HIDE,
1684                         offsetof(monitor_info_t, mi_oc_managedObject) },
1685                 { "( 1.3.6.1.4.1.4203.666.3.16.8 "
1686                         "NAME 'monitoredObject' "
1687                         "DESC 'monitor monitored entity class' "
1688                         "SUP monitor STRUCTURAL )", SLAP_OC_OPERATIONAL|SLAP_OC_HIDE,
1689                         offsetof(monitor_info_t, mi_oc_monitoredObject) },
1690                 { NULL, 0, -1 }
1691         }, mat[] = {
1692                 { "( 1.3.6.1.4.1.4203.666.1.55.1 "
1693                         "NAME 'monitoredInfo' "
1694                         "DESC 'monitored info' "
1695                         /* "SUP name " */
1696                         "EQUALITY caseIgnoreMatch "
1697                         "SUBSTR caseIgnoreSubstringsMatch "
1698                         "SYNTAX 1.3.6.1.4.1.1466.115.121.1.15{32768} "
1699                         "NO-USER-MODIFICATION "
1700                         "USAGE dSAOperation )", SLAP_AT_HIDE,
1701                         offsetof(monitor_info_t, mi_ad_monitoredInfo) },
1702                 { "( 1.3.6.1.4.1.4203.666.1.55.2 "
1703                         "NAME 'managedInfo' "
1704                         "DESC 'monitor managed info' "
1705                         "SUP name )", SLAP_AT_HIDE,
1706                         offsetof(monitor_info_t, mi_ad_managedInfo) },
1707                 { "( 1.3.6.1.4.1.4203.666.1.55.3 "
1708                         "NAME 'monitorCounter' "
1709                         "DESC 'monitor counter' "
1710                         "EQUALITY integerMatch "
1711                         "ORDERING integerOrderingMatch "
1712                         "SYNTAX 1.3.6.1.4.1.1466.115.121.1.27 "
1713                         "NO-USER-MODIFICATION "
1714                         "USAGE dSAOperation )", SLAP_AT_HIDE,
1715                         offsetof(monitor_info_t, mi_ad_monitorCounter) },
1716                 { "( 1.3.6.1.4.1.4203.666.1.55.4 "
1717                         "NAME 'monitorOpCompleted' "
1718                         "DESC 'monitor completed operations' "
1719                         "SUP monitorCounter "
1720                         "NO-USER-MODIFICATION "
1721                         "USAGE dSAOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE,
1722                         offsetof(monitor_info_t, mi_ad_monitorOpCompleted) },
1723                 { "( 1.3.6.1.4.1.4203.666.1.55.5 "
1724                         "NAME 'monitorOpInitiated' "
1725                         "DESC 'monitor initiated operations' "
1726                         "SUP monitorCounter "
1727                         "NO-USER-MODIFICATION "
1728                         "USAGE dSAOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE,
1729                         offsetof(monitor_info_t, mi_ad_monitorOpInitiated) },
1730                 { "( 1.3.6.1.4.1.4203.666.1.55.6 "
1731                         "NAME 'monitorConnectionNumber' "
1732                         "DESC 'monitor connection number' "
1733                         "SUP monitorCounter "
1734                         "NO-USER-MODIFICATION "
1735                         "USAGE dSAOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE,
1736                         offsetof(monitor_info_t, mi_ad_monitorConnectionNumber) },
1737                 { "( 1.3.6.1.4.1.4203.666.1.55.7 "
1738                         "NAME 'monitorConnectionAuthzDN' "
1739                         "DESC 'monitor connection authorization DN' "
1740                         /* "SUP distinguishedName " */
1741                         "EQUALITY distinguishedNameMatch "
1742                         "SYNTAX 1.3.6.1.4.1.1466.115.121.1.12 "
1743                         "NO-USER-MODIFICATION "
1744                         "USAGE dSAOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE,
1745                         offsetof(monitor_info_t, mi_ad_monitorConnectionAuthzDN) },
1746                 { "( 1.3.6.1.4.1.4203.666.1.55.8 "
1747                         "NAME 'monitorConnectionLocalAddress' "
1748                         "DESC 'monitor connection local address' "
1749                         "SUP monitoredInfo "
1750                         "NO-USER-MODIFICATION "
1751                         "USAGE dSAOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE,
1752                         offsetof(monitor_info_t, mi_ad_monitorConnectionLocalAddress) },
1753                 { "( 1.3.6.1.4.1.4203.666.1.55.9 "
1754                         "NAME 'monitorConnectionPeerAddress' "
1755                         "DESC 'monitor connection peer address' "
1756                         "SUP monitoredInfo "
1757                         "NO-USER-MODIFICATION "
1758                         "USAGE dSAOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE,
1759                         offsetof(monitor_info_t, mi_ad_monitorConnectionPeerAddress) },
1760                 { "( 1.3.6.1.4.1.4203.666.1.55.10 "
1761                         "NAME 'monitorTimestamp' "
1762                         "DESC 'monitor timestamp' "
1763                         "EQUALITY generalizedTimeMatch "
1764                         "ORDERING generalizedTimeOrderingMatch "
1765                         "SYNTAX 1.3.6.1.4.1.1466.115.121.1.24 "
1766                         "SINGLE-VALUE "
1767                         "NO-USER-MODIFICATION "
1768                         "USAGE dSAOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE,
1769                         offsetof(monitor_info_t, mi_ad_monitorTimestamp) },
1770                 { "( 1.3.6.1.4.1.4203.666.1.55.11 "
1771                         "NAME 'monitorOverlay' "
1772                         "DESC 'name of overlays defined for a given database' "
1773                         "SUP monitoredInfo "
1774                         "NO-USER-MODIFICATION "
1775                         "USAGE dSAOperation )", SLAP_AT_HIDE,
1776                         offsetof(monitor_info_t, mi_ad_monitorOverlay) },
1777                 { "( 1.3.6.1.4.1.4203.666.1.55.12 "
1778                         "NAME 'readOnly' "
1779                         "DESC 'read/write status of a given database' "
1780                         "EQUALITY booleanMatch "
1781                         "SYNTAX 1.3.6.1.4.1.1466.115.121.1.7 "
1782                         "SINGLE-VALUE "
1783                         "USAGE dSAOperation )", SLAP_AT_HIDE,
1784                         offsetof(monitor_info_t, mi_ad_readOnly) },
1785                 { "( 1.3.6.1.4.1.4203.666.1.55.13 "
1786                         "NAME 'restrictedOperation' "
1787                         "DESC 'name of restricted operation for a given database' "
1788                         "SUP managedInfo )", SLAP_AT_HIDE,
1789                         offsetof(monitor_info_t, mi_ad_restrictedOperation ) },
1790                 { "( 1.3.6.1.4.1.4203.666.1.55.14 "
1791                         "NAME 'monitorConnectionProtocol' "
1792                         "DESC 'monitor connection protocol' "
1793                         "SUP monitoredInfo "
1794                         "NO-USER-MODIFICATION "
1795                         "USAGE dSAOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE,
1796                         offsetof(monitor_info_t, mi_ad_monitorConnectionProtocol) },
1797                 { "( 1.3.6.1.4.1.4203.666.1.55.15 "
1798                         "NAME 'monitorConnectionOpsReceived' "
1799                         "DESC 'monitor number of operations received by the connection' "
1800                         "SUP monitorCounter "
1801                         "NO-USER-MODIFICATION "
1802                         "USAGE dSAOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE,
1803                         offsetof(monitor_info_t, mi_ad_monitorConnectionOpsReceived) },
1804                 { "( 1.3.6.1.4.1.4203.666.1.55.16 "
1805                         "NAME 'monitorConnectionOpsExecuting' "
1806                         "DESC 'monitor number of operations in execution within the connection' "
1807                         "SUP monitorCounter "
1808                         "NO-USER-MODIFICATION "
1809                         "USAGE dSAOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE,
1810                         offsetof(monitor_info_t, mi_ad_monitorConnectionOpsExecuting) },
1811                 { "( 1.3.6.1.4.1.4203.666.1.55.17 "
1812                         "NAME 'monitorConnectionOpsPending' "
1813                         "DESC 'monitor number of pending operations within the connection' "
1814                         "SUP monitorCounter "
1815                         "NO-USER-MODIFICATION "
1816                         "USAGE dSAOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE,
1817                         offsetof(monitor_info_t, mi_ad_monitorConnectionOpsPending) },
1818                 { "( 1.3.6.1.4.1.4203.666.1.55.18 "
1819                         "NAME 'monitorConnectionOpsCompleted' "
1820                         "DESC 'monitor number of operations completed within the connection' "
1821                         "SUP monitorCounter "
1822                         "NO-USER-MODIFICATION "
1823                         "USAGE dSAOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE,
1824                         offsetof(monitor_info_t, mi_ad_monitorConnectionOpsCompleted) },
1825                 { "( 1.3.6.1.4.1.4203.666.1.55.19 "
1826                         "NAME 'monitorConnectionGet' "
1827                         "DESC 'number of times connection_get() was called so far' "
1828                         "SUP monitorCounter "
1829                         "NO-USER-MODIFICATION "
1830                         "USAGE dSAOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE,
1831                         offsetof(monitor_info_t, mi_ad_monitorConnectionGet) },
1832                 { "( 1.3.6.1.4.1.4203.666.1.55.20 "
1833                         "NAME 'monitorConnectionRead' "
1834                         "DESC 'number of times connection_read() was called so far' "
1835                         "SUP monitorCounter "
1836                         "NO-USER-MODIFICATION "
1837                         "USAGE dSAOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE,
1838                         offsetof(monitor_info_t, mi_ad_monitorConnectionRead) },
1839                 { "( 1.3.6.1.4.1.4203.666.1.55.21 "
1840                         "NAME 'monitorConnectionWrite' "
1841                         "DESC 'number of times connection_write() was called so far' "
1842                         "SUP monitorCounter "
1843                         "NO-USER-MODIFICATION "
1844                         "USAGE dSAOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE,
1845                         offsetof(monitor_info_t, mi_ad_monitorConnectionWrite) },
1846                 { "( 1.3.6.1.4.1.4203.666.1.55.22 "
1847                         "NAME 'monitorConnectionMask' "
1848                         "DESC 'monitor connection mask' "
1849                         "SUP monitoredInfo "
1850                         "NO-USER-MODIFICATION "
1851                         "USAGE dSAOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE,
1852                         offsetof(monitor_info_t, mi_ad_monitorConnectionMask) },
1853                 { "( 1.3.6.1.4.1.4203.666.1.55.23 "
1854                         "NAME 'monitorConnectionListener' "
1855                         "DESC 'monitor connection listener' "
1856                         "SUP monitoredInfo "
1857                         "NO-USER-MODIFICATION "
1858                         "USAGE dSAOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE,
1859                         offsetof(monitor_info_t, mi_ad_monitorConnectionListener) },
1860                 { "( 1.3.6.1.4.1.4203.666.1.55.24 "
1861                         "NAME 'monitorConnectionPeerDomain' "
1862                         "DESC 'monitor connection peer domain' "
1863                         "SUP monitoredInfo "
1864                         "NO-USER-MODIFICATION "
1865                         "USAGE dSAOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE,
1866                         offsetof(monitor_info_t, mi_ad_monitorConnectionPeerDomain) },
1867                 { "( 1.3.6.1.4.1.4203.666.1.55.25 "
1868                         "NAME 'monitorConnectionStartTime' "
1869                         "DESC 'monitor connection start time' "
1870                         "SUP monitorTimestamp "
1871                         "SINGLE-VALUE "
1872                         "NO-USER-MODIFICATION "
1873                         "USAGE dSAOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE,
1874                         offsetof(monitor_info_t, mi_ad_monitorConnectionStartTime) },
1875                 { "( 1.3.6.1.4.1.4203.666.1.55.26 "
1876                         "NAME 'monitorConnectionActivityTime' "
1877                         "DESC 'monitor connection activity time' "
1878                         "SUP monitorTimestamp "
1879                         "SINGLE-VALUE "
1880                         "NO-USER-MODIFICATION "
1881                         "USAGE dSAOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE,
1882                         offsetof(monitor_info_t, mi_ad_monitorConnectionActivityTime) },
1883                 { "( 1.3.6.1.4.1.4203.666.1.55.27 "
1884                         "NAME 'monitorIsShadow' "
1885                         "DESC 'TRUE if the database is shadow' "
1886                         "EQUALITY booleanMatch "
1887                         "SYNTAX 1.3.6.1.4.1.1466.115.121.1.7 "
1888                         "SINGLE-VALUE "
1889                         "USAGE dSAOperation )", SLAP_AT_HIDE,
1890                         offsetof(monitor_info_t, mi_ad_monitorIsShadow) },
1891                 { "( 1.3.6.1.4.1.4203.666.1.55.28 "
1892                         "NAME 'monitorUpdateRef' "
1893                         "DESC 'update referral for shadow databases' "
1894                         "SUP monitoredInfo "
1895                         "SINGLE-VALUE "
1896                         "USAGE dSAOperation )", SLAP_AT_HIDE,
1897                         offsetof(monitor_info_t, mi_ad_monitorUpdateRef) },
1898                 { "( 1.3.6.1.4.1.4203.666.1.55.29 "
1899                         "NAME 'monitorRuntimeConfig' "
1900                         "DESC 'TRUE if component allows runtime configuration' "
1901                         "EQUALITY booleanMatch "
1902                         "SYNTAX 1.3.6.1.4.1.1466.115.121.1.7 "
1903                         "SINGLE-VALUE "
1904                         "USAGE dSAOperation )", SLAP_AT_HIDE,
1905                         offsetof(monitor_info_t, mi_ad_monitorRuntimeConfig) },
1906                 { NULL, 0, -1 }
1907         };
1908
1909         static struct {
1910                 char                    *name;
1911                 char                    *oid;
1912         }               s_oid[] = {
1913                 { "olmAttributes",                      "1.3.6.1.4.1.4203.666.1.55" },
1914                 { "olmSubSystemAttributes",             "olmAttributes:0" },
1915                 { "olmGenericAttributes",               "olmSubSystemAttributes:0" },
1916                 { "olmDatabaseAttributes",              "olmSubSystemAttributes:1" },
1917
1918                 /* for example, back-bdb specific attrs
1919                  * are in "olmDatabaseAttributes:1"
1920                  *
1921                  * NOTE: developers, please record here OID assignments
1922                  * for other modules */
1923
1924                 { "olmObjectClasses",                   "1.3.6.1.4.1.4203.666.3.16" },
1925                 { "olmSubSystemObjectClasses",          "olmObjectClasses:0" },
1926                 { "olmGenericObjectClasses",            "olmSubSystemObjectClasses:0" },
1927                 { "olmDatabaseObjectClasses",           "olmSubSystemObjectClasses:1" },
1928
1929                 /* for example, back-bdb specific objectClasses
1930                  * are in "olmDatabaseObjectClasses:1"
1931                  *
1932                  * NOTE: developers, please record here OID assignments
1933                  * for other modules */
1934
1935                 { NULL }
1936         };
1937
1938         int                     i, rc;
1939         monitor_info_t          *mi = &monitor_info;
1940         ConfigArgs c;
1941         char    *argv[ 3 ];
1942
1943         argv[ 0 ] = "monitor";
1944         c.argv = argv;
1945         c.argc = 3;
1946         c.fname = argv[0];
1947
1948         for ( i = 0; s_oid[ i ].name; i++ ) {
1949                 argv[ 1 ] = s_oid[ i ].name;
1950                 argv[ 2 ] = s_oid[ i ].oid;
1951
1952                 if ( parse_oidm( &c, 0, NULL ) != 0 ) {
1953                         Debug( LDAP_DEBUG_ANY,
1954                                 "monitor_back_initialize: unable to add "
1955                                 "objectIdentifier \"%s=%s\"\n",
1956                                 s_oid[ i ].name, s_oid[ i ].oid, 0 );
1957                         return 1;
1958                 }
1959         }
1960
1961         /* schema integration */
1962         for ( i = 0; mat[ i ].schema; i++ ) {
1963                 int                     code;
1964                 AttributeDescription **ad =
1965                         ((AttributeDescription **)&(((char *)mi)[ mat[ i ].offset ]));
1966
1967                 *ad = NULL;
1968                 code = register_at( mat[ i ].schema, ad, 0 );
1969
1970                 if ( code ) {
1971                         Debug( LDAP_DEBUG_ANY,
1972                                 "monitor_back_db_init: register_at failed\n", 0, 0, 0 );
1973                         return -1;
1974                 }
1975                 (*ad)->ad_type->sat_flags |= mat[ i ].flags;
1976         }
1977
1978         for ( i = 0; moc[ i ].schema; i++ ) {
1979                 int                     code;
1980                 ObjectClass             **Oc =
1981                         ((ObjectClass **)&(((char *)mi)[ moc[ i ].offset ]));
1982
1983                 code = register_oc( moc[ i ].schema, Oc, 0 );
1984                 if ( code ) {
1985                         Debug( LDAP_DEBUG_ANY,
1986                                 "monitor_back_db_init: register_oc failed\n", 0, 0, 0 );
1987                         return -1;
1988                 }
1989                 (*Oc)->soc_flags |= moc[ i ].flags;
1990         }
1991
1992         bi->bi_controls = controls;
1993
1994         bi->bi_init = 0;
1995         bi->bi_open = 0;
1996         bi->bi_config = monitor_back_config;
1997         bi->bi_close = 0;
1998         bi->bi_destroy = 0;
1999
2000         bi->bi_db_init = monitor_back_db_init;
2001 #if 0
2002         bi->bi_db_config = monitor_back_db_config;
2003 #endif
2004         bi->bi_db_open = monitor_back_db_open;
2005         bi->bi_db_close = 0;
2006         bi->bi_db_destroy = monitor_back_db_destroy;
2007
2008         bi->bi_op_bind = monitor_back_bind;
2009         bi->bi_op_unbind = 0;
2010         bi->bi_op_search = monitor_back_search;
2011         bi->bi_op_compare = monitor_back_compare;
2012         bi->bi_op_modify = monitor_back_modify;
2013         bi->bi_op_modrdn = 0;
2014         bi->bi_op_add = 0;
2015         bi->bi_op_delete = 0;
2016         bi->bi_op_abandon = 0;
2017
2018         bi->bi_extended = 0;
2019
2020         bi->bi_entry_release_rw = 0;
2021         bi->bi_chk_referrals = 0;
2022         bi->bi_operational = monitor_back_operational;
2023
2024         /*
2025          * hooks for slap tools
2026          */
2027         bi->bi_tool_entry_open = 0;
2028         bi->bi_tool_entry_close = 0;
2029         bi->bi_tool_entry_first = 0;
2030         bi->bi_tool_entry_next = 0;
2031         bi->bi_tool_entry_get = 0;
2032         bi->bi_tool_entry_put = 0;
2033         bi->bi_tool_entry_reindex = 0;
2034         bi->bi_tool_sync = 0;
2035         bi->bi_tool_dn2id_get = 0;
2036         bi->bi_tool_entry_modify = 0;
2037
2038         bi->bi_connection_init = 0;
2039         bi->bi_connection_destroy = 0;
2040
2041         bi->bi_extra = (void *)&monitor_extra;
2042
2043         /*
2044          * configuration objectClasses (fake)
2045          */
2046         bi->bi_cf_ocs = monitorocs;
2047
2048         rc = config_register_schema( monitorcfg, monitorocs );
2049         if ( rc ) {
2050                 return rc;
2051         }
2052
2053         return 0;
2054 }
2055
2056 int
2057 monitor_back_db_init(
2058         BackendDB       *be,
2059         ConfigReply     *c)
2060 {
2061         int                     rc;
2062         struct berval           dn = BER_BVC( SLAPD_MONITOR_DN ),
2063                                 pdn,
2064                                 ndn;
2065         BackendDB               *be2;
2066
2067         monitor_subsys_t        *ms;
2068
2069         /*
2070          * database monitor can be defined once only
2071          */
2072         if ( be_monitor != NULL ) {
2073                 if (c) {
2074                         snprintf(c->msg, sizeof(c->msg),"only one monitor database allowed");
2075                 }
2076                 return( -1 );
2077         }
2078         be_monitor = be;
2079
2080         /*
2081          * register subsys
2082          */
2083         for ( ms = known_monitor_subsys; ms->mss_name != NULL; ms++ ) {
2084                 if ( monitor_back_register_subsys( ms ) ) {
2085                         return -1;
2086                 }
2087         }
2088
2089         /* indicate system schema supported */
2090         SLAP_BFLAGS(be) |= SLAP_BFLAG_MONITOR;
2091
2092         rc = dnPrettyNormal( NULL, &dn, &pdn, &ndn, NULL );
2093         if( rc != LDAP_SUCCESS ) {
2094                 Debug( LDAP_DEBUG_ANY,
2095                         "unable to normalize/pretty monitor DN \"%s\" (%d)\n",
2096                         dn.bv_val, rc, 0 );
2097                 return -1;
2098         }
2099
2100         ber_bvarray_add( &be->be_suffix, &pdn );
2101         ber_bvarray_add( &be->be_nsuffix, &ndn );
2102
2103         /* NOTE: only one monitor database is allowed,
2104          * so we use static storage */
2105         ldap_pvt_thread_mutex_init( &monitor_info.mi_cache_mutex );
2106
2107         be->be_private = &monitor_info;
2108
2109         be2 = select_backend( &ndn, 0 );
2110         if ( be2 != be ) {
2111                 char    *type = be2->bd_info->bi_type;
2112
2113                 if ( overlay_is_over( be2 ) ) {
2114                         slap_overinfo   *oi = (slap_overinfo *)be2->bd_info->bi_private;
2115                         type = oi->oi_orig->bi_type;
2116                 }
2117
2118                 if (c) {
2119                         snprintf(c->msg, sizeof(c->msg),
2120                                         "\"monitor\" database serving namingContext \"%s\" "
2121                                         "is hidden by \"%s\" database serving namingContext \"%s\".\n",
2122                                         pdn.bv_val, type, be2->be_nsuffix[ 0 ].bv_val );
2123                 }
2124                 return -1;
2125         }
2126
2127         return 0;
2128 }
2129
2130 static void
2131 monitor_back_destroy_limbo_entry(
2132         entry_limbo_t   *el,
2133         int             dispose )
2134 {
2135         if ( el->el_e ) {
2136                 entry_free( el->el_e );
2137         }
2138         if ( el->el_a ) {
2139                 attrs_free( el->el_a );
2140         }
2141         if ( !BER_BVISNULL( &el->el_nbase ) ) {
2142                 ber_memfree( el->el_nbase.bv_val );
2143         }
2144         if ( !BER_BVISNULL( &el->el_filter ) ) {
2145                 ber_memfree( el->el_filter.bv_val );
2146         }
2147
2148         /* NOTE: callbacks are not copied; so only free them
2149          * if disposing of */
2150         if ( el->el_cb && dispose != 0 ) {
2151                 monitor_callback_t *next;
2152
2153                 for ( ; el->el_cb; el->el_cb = next ) {
2154                         next = el->el_cb->mc_next;
2155                         if ( el->el_cb->mc_dispose ) {
2156                                 el->el_cb->mc_dispose( &el->el_cb->mc_private );
2157                         }
2158                         ch_free( el->el_cb );
2159                 }
2160         }
2161
2162         ch_free( el );
2163 }
2164
2165 int
2166 monitor_back_db_open(
2167         BackendDB       *be,
2168         ConfigReply     *cr)
2169 {
2170         monitor_info_t          *mi = (monitor_info_t *)be->be_private;
2171         struct monitor_subsys_t **ms;
2172         Entry                   *e, **ep, *root;
2173         monitor_entry_t         *mp;
2174         int                     i;
2175         struct berval           bv, rdn = BER_BVC(SLAPD_MONITOR_DN);
2176         struct tm               *tms;
2177 #ifdef HAVE_GMTIME_R
2178         struct tm               tm_buf;
2179 #endif
2180         static char             tmbuf[ LDAP_LUTIL_GENTIME_BUFSIZE ];
2181         struct berval   desc[] = {
2182                 BER_BVC("This subtree contains monitoring/managing objects."),
2183                 BER_BVC("This object contains information about this server."),
2184                 BER_BVC("Most of the information is held in operational"
2185                 " attributes, which must be explicitly requested."),
2186                 BER_BVNULL };
2187
2188         int                     retcode = 0;
2189
2190         assert( be_monitor != NULL );
2191         if ( be != be_monitor ) {
2192                 be_monitor = be;
2193         }
2194
2195         /*
2196          * Start
2197          */
2198 #ifndef HAVE_GMTIME_R
2199         ldap_pvt_thread_mutex_lock( &gmtime_mutex );
2200 #endif
2201 #ifdef HACK_LOCAL_TIME
2202 # ifdef HAVE_LOCALTIME_R
2203         tms = localtime_r( &starttime, &tm_buf );
2204 # else
2205         tms = localtime( &starttime );
2206 # endif /* HAVE_LOCALTIME_R */
2207         lutil_localtime( tmbuf, sizeof(tmbuf), tms, -timezone );
2208 #else /* !HACK_LOCAL_TIME */
2209 # ifdef HAVE_GMTIME_R
2210         tms = gmtime_r( &starttime, &tm_buf );
2211 # else
2212         tms = gmtime( &starttime );
2213 # endif /* HAVE_GMTIME_R */
2214         lutil_gentime( tmbuf, sizeof(tmbuf), tms );
2215 #endif /* !HACK_LOCAL_TIME */
2216 #ifndef HAVE_GMTIME_R
2217         ldap_pvt_thread_mutex_unlock( &gmtime_mutex );
2218 #endif
2219
2220         mi->mi_startTime.bv_val = tmbuf;
2221         mi->mi_startTime.bv_len = strlen( tmbuf );
2222
2223         if ( BER_BVISEMPTY( &be->be_rootdn ) ) {
2224                 BER_BVSTR( &mi->mi_creatorsName, SLAPD_ANONYMOUS );
2225                 BER_BVSTR( &mi->mi_ncreatorsName, SLAPD_ANONYMOUS );
2226         } else {
2227                 mi->mi_creatorsName = be->be_rootdn;
2228                 mi->mi_ncreatorsName = be->be_rootndn;
2229         }
2230
2231         /*
2232          * creates the "cn=Monitor" entry
2233          */
2234         e = monitor_entry_stub( NULL, NULL, &rdn, mi->mi_oc_monitorServer, mi,
2235                 NULL, NULL );
2236
2237         if ( e == NULL) {
2238                 Debug( LDAP_DEBUG_ANY,
2239                         "unable to create \"%s\" entry\n",
2240                         SLAPD_MONITOR_DN, 0, 0 );
2241                 return( -1 );
2242         }
2243
2244         attr_merge_normalize( e, slap_schema.si_ad_description, desc, NULL );
2245
2246         bv.bv_val = strchr( (char *) Versionstr, '$' );
2247         if ( bv.bv_val != NULL ) {
2248                 char    *end;
2249
2250                 bv.bv_val++;
2251                 for ( ; bv.bv_val[ 0 ] == ' '; bv.bv_val++ )
2252                         ;
2253
2254                 end = strchr( bv.bv_val, '$' );
2255                 if ( end != NULL ) {
2256                         end--;
2257
2258                         for ( ; end > bv.bv_val && end[ 0 ] == ' '; end-- )
2259                                 ;
2260
2261                         end++;
2262
2263                         bv.bv_len = end - bv.bv_val;
2264
2265                 } else {
2266                         bv.bv_len = strlen( bv.bv_val );
2267                 }
2268
2269                 if ( attr_merge_normalize_one( e, mi->mi_ad_monitoredInfo,
2270                                         &bv, NULL ) ) {
2271                         Debug( LDAP_DEBUG_ANY,
2272                                 "unable to add monitoredInfo to \"%s\" entry\n",
2273                                 SLAPD_MONITOR_DN, 0, 0 );
2274                         return( -1 );
2275                 }
2276         }
2277
2278         mp = monitor_entrypriv_create();
2279         if ( mp == NULL ) {
2280                 return -1;
2281         }
2282         e->e_private = ( void * )mp;
2283         ep = &mp->mp_children;
2284
2285         if ( monitor_cache_add( mi, e ) ) {
2286                 Debug( LDAP_DEBUG_ANY,
2287                         "unable to add entry \"%s\" to cache\n",
2288                         SLAPD_MONITOR_DN, 0, 0 );
2289                 return -1;
2290         }
2291         root = e;
2292
2293         /*
2294          * Create all the subsystem specific entries
2295          */
2296         for ( i = 0; monitor_subsys[ i ] != NULL; i++ ) {
2297                 int             len = strlen( monitor_subsys[ i ]->mss_name );
2298                 struct berval   dn;
2299                 int             rc;
2300
2301                 dn.bv_len = len + sizeof( "cn=" ) - 1;
2302                 dn.bv_val = ch_calloc( sizeof( char ), dn.bv_len + 1 );
2303                 strcpy( dn.bv_val, "cn=" );
2304                 strcat( dn.bv_val, monitor_subsys[ i ]->mss_name );
2305                 rc = dnPretty( NULL, &dn, &monitor_subsys[ i ]->mss_rdn, NULL );
2306                 free( dn.bv_val );
2307                 if ( rc != LDAP_SUCCESS ) {
2308                         Debug( LDAP_DEBUG_ANY,
2309                                 "monitor RDN \"%s\" is invalid\n",
2310                                 dn.bv_val, 0, 0 );
2311                         return( -1 );
2312                 }
2313
2314                 e = monitor_entry_stub( &root->e_name, &root->e_nname,
2315                         &monitor_subsys[ i ]->mss_rdn, mi->mi_oc_monitorContainer, mi,
2316                         NULL, NULL );
2317
2318                 if ( e == NULL) {
2319                         Debug( LDAP_DEBUG_ANY,
2320                                 "unable to create \"%s\" entry\n",
2321                                 monitor_subsys[ i ]->mss_dn.bv_val, 0, 0 );
2322                         return( -1 );
2323                 }
2324                 monitor_subsys[i]->mss_dn = e->e_name;
2325                 monitor_subsys[i]->mss_ndn = e->e_nname;
2326
2327                 if ( !BER_BVISNULL( &monitor_subsys[ i ]->mss_desc[ 0 ] ) ) {
2328                         attr_merge_normalize( e, slap_schema.si_ad_description,
2329                                         monitor_subsys[ i ]->mss_desc, NULL );
2330                 }
2331
2332                 mp = monitor_entrypriv_create();
2333                 if ( mp == NULL ) {
2334                         return -1;
2335                 }
2336                 e->e_private = ( void * )mp;
2337                 mp->mp_info = monitor_subsys[ i ];
2338                 mp->mp_flags = monitor_subsys[ i ]->mss_flags;
2339
2340                 if ( monitor_cache_add( mi, e ) ) {
2341                         Debug( LDAP_DEBUG_ANY,
2342                                 "unable to add entry \"%s\" to cache\n",
2343                                 monitor_subsys[ i ]->mss_dn.bv_val, 0, 0 );
2344                         return -1;
2345                 }
2346
2347                 *ep = e;
2348                 ep = &mp->mp_next;
2349         }
2350
2351         assert( be != NULL );
2352
2353         be->be_private = mi;
2354
2355         /*
2356          * opens the monitor backend subsystems
2357          */
2358         for ( ms = monitor_subsys; ms[ 0 ] != NULL; ms++ ) {
2359                 if ( ms[ 0 ]->mss_open && ( *ms[ 0 ]->mss_open )( be, ms[ 0 ] ) )
2360                 {
2361                         return( -1 );
2362                 }
2363                 ms[ 0 ]->mss_flags |= MONITOR_F_OPENED;
2364         }
2365
2366         monitor_subsys_opened = 1;
2367
2368         if ( mi->mi_entry_limbo ) {
2369                 entry_limbo_t   *el = mi->mi_entry_limbo;
2370
2371                 for ( ; el; ) {
2372                         entry_limbo_t   *tmp;
2373                         int             rc;
2374
2375                         switch ( el->el_type ) {
2376                         case LIMBO_ENTRY:
2377                                 rc = monitor_back_register_entry(
2378                                                 el->el_e,
2379                                                 el->el_cb,
2380                                                 el->el_mss,
2381                                                 el->el_flags );
2382                                 break;
2383
2384                         case LIMBO_ENTRY_PARENT:
2385                                 rc = monitor_back_register_entry_parent(
2386                                                 el->el_e,
2387                                                 el->el_cb,
2388                                                 el->el_mss,
2389                                                 el->el_flags,
2390                                                 &el->el_nbase,
2391                                                 el->el_scope,
2392                                                 &el->el_filter );
2393                                 break;
2394
2395
2396                         case LIMBO_ATTRS:
2397                                 rc = monitor_back_register_entry_attrs(
2398                                                 el->el_ndn,
2399                                                 el->el_a,
2400                                                 el->el_cb,
2401                                                 &el->el_nbase,
2402                                                 el->el_scope,
2403                                                 &el->el_filter );
2404                                 break;
2405
2406                         case LIMBO_CB:
2407                                 rc = monitor_back_register_entry_callback(
2408                                                 el->el_ndn,
2409                                                 el->el_cb,
2410                                                 &el->el_nbase,
2411                                                 el->el_scope,
2412                                                 &el->el_filter );
2413                                 break;
2414
2415                         case LIMBO_BACKEND:
2416                                 rc = monitor_back_register_backend( el->el_bi );
2417                                 break;
2418
2419                         case LIMBO_DATABASE:
2420                                 rc = monitor_back_register_database( el->el_be, el->el_ndn );
2421                                 break;
2422
2423                         case LIMBO_OVERLAY_INFO:
2424                                 rc = monitor_back_register_overlay_info( el->el_on );
2425                                 break;
2426
2427                         case LIMBO_OVERLAY:
2428                                 rc = monitor_back_register_overlay( el->el_be );
2429                                 break;
2430
2431                         default:
2432                                 assert( 0 );
2433                         }
2434
2435                         tmp = el;
2436                         el = el->el_next;
2437                         monitor_back_destroy_limbo_entry( tmp, rc );
2438
2439                         if ( rc != 0 ) {
2440                                 /* try all, but report error at end */
2441                                 retcode = 1;
2442                         }
2443                 }
2444
2445                 mi->mi_entry_limbo = NULL;
2446         }
2447
2448         return retcode;
2449 }
2450
2451 int
2452 monitor_back_config(
2453         BackendInfo     *bi,
2454         const char      *fname,
2455         int             lineno,
2456         int             argc,
2457         char            **argv )
2458 {
2459         /*
2460          * eventually, will hold backend specific configuration parameters
2461          */
2462         return SLAP_CONF_UNKNOWN;
2463 }
2464
2465 #if 0
2466 int
2467 monitor_back_db_config(
2468         Backend     *be,
2469         const char  *fname,
2470         int         lineno,
2471         int         argc,
2472         char        **argv )
2473 {
2474         monitor_info_t  *mi = ( monitor_info_t * )be->be_private;
2475
2476         /*
2477          * eventually, will hold database specific configuration parameters
2478          */
2479         return SLAP_CONF_UNKNOWN;
2480 }
2481 #endif
2482
2483 int
2484 monitor_back_db_destroy(
2485         BackendDB       *be,
2486         ConfigReply     *cr)
2487 {
2488         monitor_info_t  *mi = ( monitor_info_t * )be->be_private;
2489
2490         if ( mi == NULL ) {
2491                 return -1;
2492         }
2493
2494         /*
2495          * FIXME: destroys all the data
2496          */
2497         /* NOTE: mi points to static storage; don't free it */
2498
2499         (void)monitor_cache_destroy( mi );
2500
2501         if ( monitor_subsys ) {
2502                 int     i;
2503
2504                 for ( i = 0; monitor_subsys[ i ] != NULL; i++ ) {
2505                         if ( monitor_subsys[ i ]->mss_destroy ) {
2506                                 monitor_subsys[ i ]->mss_destroy( be, monitor_subsys[ i ] );
2507                         }
2508
2509                         if ( !BER_BVISNULL( &monitor_subsys[ i ]->mss_rdn ) ) {
2510                                 ch_free( monitor_subsys[ i ]->mss_rdn.bv_val );
2511                         }
2512                 }
2513
2514                 ch_free( monitor_subsys );
2515         }
2516
2517         if ( mi->mi_entry_limbo ) {
2518                 entry_limbo_t   *el = mi->mi_entry_limbo;
2519
2520                 for ( ; el; ) {
2521                         entry_limbo_t *tmp = el;
2522                         el = el->el_next;
2523                         monitor_back_destroy_limbo_entry( tmp, 1 );
2524                 }
2525         }
2526
2527         ldap_pvt_thread_mutex_destroy( &monitor_info.mi_cache_mutex );
2528
2529         be->be_private = NULL;
2530
2531         return 0;
2532 }
2533
2534 #if SLAPD_MONITOR == SLAPD_MOD_DYNAMIC
2535
2536 /* conditionally define the init_module() function */
2537 SLAP_BACKEND_INIT_MODULE( monitor )
2538
2539 #endif /* SLAPD_MONITOR == SLAPD_MOD_DYNAMIC */
2540