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

   1 /* init.c - initialize monitor backend */
   2 /*
   3  * Copyright 1998-2003 The OpenLDAP Foundation, All Rights Reserved.
   4  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
   5  */
   6 /*
   7  * Copyright 2001, Pierangelo Masarati, All rights reserved. <ando@sys-net.it>
   8  *
   9  * This work has beed deveolped for the OpenLDAP Foundation
  10  * in the hope that it may be useful to the Open Source community,
  11  * but WITHOUT ANY WARRANTY.
  12  *
  13  * Permission is granted to anyone to use this software for any purpose
  14  * on any computer system, and to alter it and redistribute it, subject
  15  * to the following restrictions:
  16  *
  17  * 1. The author and SysNet s.n.c. are not responsible for the consequences
  18  *    of use of this software, no matter how awful, even if they arise from
  19  *    flaws in it.
  20  *
  21  * 2. The origin of this software must not be misrepresented, either by
  22  *    explicit claim or by omission.  Since few users ever read sources,
  23  *    credits should appear in the documentation.
  24  *
  25  * 3. Altered versions must be plainly marked as such, and must not be
  26  *    misrepresented as being the original software.  Since few users
  27  *    ever read sources, credits should appear in the documentation.
  28  *    SysNet s.n.c. cannot be responsible for the consequences of the
  29  *    alterations.
  30  *
  31  * 4. This notice may not be removed or altered.
  32  */
  33
  34 #include "portable.h"
  35
  36 #include <stdio.h>
  37 #include <ac/string.h>
  38
  39 #include "slap.h"
  40 #include "lber_pvt.h"
  41 #include "back-monitor.h"
  42
  43 /*
  44  * used by many functions to add description to entries
  45  */
  46 AttributeDescription *monitor_ad_desc = NULL;
  47 BackendDB *be_monitor = NULL;
  48
  49 /*
  50  * subsystem data
  51  */
  52 struct monitorsubsys monitor_subsys[] = {
  53         {
  54                 SLAPD_MONITOR_LISTENER, SLAPD_MONITOR_LISTENER_NAME,
  55                 BER_BVNULL, BER_BVNULL, BER_BVNULL,
  56                 MONITOR_F_PERSISTENT_CH,
  57                 monitor_subsys_listener_init,
  58                 NULL,   /* update */
  59                 NULL,   /* create */
  60                 NULL    /* modify */
  61         }, {
  62                 SLAPD_MONITOR_DATABASE, SLAPD_MONITOR_DATABASE_NAME,
  63                 BER_BVNULL, BER_BVNULL, BER_BVNULL,
  64                 MONITOR_F_PERSISTENT_CH,
  65                 monitor_subsys_database_init,
  66                 NULL,   /* update */
  67                 NULL,   /* create */
  68                 NULL    /* modify */
  69         }, {
  70                 SLAPD_MONITOR_BACKEND, SLAPD_MONITOR_BACKEND_NAME,
  71                 BER_BVNULL, BER_BVNULL, BER_BVNULL,
  72                 MONITOR_F_PERSISTENT_CH,
  73                 monitor_subsys_backend_init,
  74                 NULL,   /* update */
  75                 NULL,   /* create */
  76                 NULL    /* modify */
  77         }, {
  78                 SLAPD_MONITOR_THREAD, SLAPD_MONITOR_THREAD_NAME,
  79                 BER_BVNULL, BER_BVNULL, BER_BVNULL,
  80                 MONITOR_F_NONE,
  81                 monitor_subsys_thread_init,
  82                 monitor_subsys_thread_update,
  83                 NULL,   /* create */
  84                 NULL    /* modify */
  85         }, {
  86                 SLAPD_MONITOR_SASL, SLAPD_MONITOR_SASL_NAME,
  87                 BER_BVNULL, BER_BVNULL, BER_BVNULL,
  88                 MONITOR_F_NONE,
  89                 NULL,   /* init */
  90                 NULL,   /* update */
  91                 NULL,   /* create */
  92                 NULL    /* modify */
  93         }, {
  94                 SLAPD_MONITOR_TLS, SLAPD_MONITOR_TLS_NAME,
  95                 BER_BVNULL, BER_BVNULL, BER_BVNULL,
  96                 MONITOR_F_NONE,
  97                 NULL,   /* init */
  98                 NULL,   /* update */
  99                 NULL,   /* create */
 100                 NULL    /* modify */
 101         }, {
 102                 SLAPD_MONITOR_CONN, SLAPD_MONITOR_CONN_NAME,
 103                 BER_BVNULL, BER_BVNULL, BER_BVNULL,
 104                 MONITOR_F_VOLATILE_CH,
 105                 monitor_subsys_conn_init,
 106                 monitor_subsys_conn_update,
 107                 monitor_subsys_conn_create,
 108                 NULL    /* modify */
 109         }, {
 110                 SLAPD_MONITOR_READW, SLAPD_MONITOR_READW_NAME,
 111                 BER_BVNULL, BER_BVNULL, BER_BVNULL,
 112                 MONITOR_F_NONE,
 113                 NULL,   /* init */
 114                 monitor_subsys_readw_update,
 115                 NULL,   /* create */
 116                 NULL    /* modify */
 117         }, {
 118                 SLAPD_MONITOR_WRITEW, SLAPD_MONITOR_WRITEW_NAME,
 119                 BER_BVNULL, BER_BVNULL, BER_BVNULL,
 120                 MONITOR_F_NONE,
 121                 NULL,   /* init */
 122                 monitor_subsys_writew_update,
 123                 NULL,   /* create */
 124                 NULL    /* modify */
 125         }, {
 126                 SLAPD_MONITOR_LOG, SLAPD_MONITOR_LOG_NAME,
 127                 BER_BVNULL, BER_BVNULL, BER_BVNULL,
 128                 MONITOR_F_NONE,
 129                 monitor_subsys_log_init,
 130                 NULL,   /* update */
 131                 NULL,   /* create */
 132                 monitor_subsys_log_modify
 133         }, {
 134                 SLAPD_MONITOR_OPS, SLAPD_MONITOR_OPS_NAME,
 135                 BER_BVNULL, BER_BVNULL, BER_BVNULL,
 136                 MONITOR_F_PERSISTENT_CH,
 137                 monitor_subsys_ops_init,
 138                 monitor_subsys_ops_update,
 139                 NULL,   /* create */
 140                 NULL,   /* modify */
 141         }, {
 142                 SLAPD_MONITOR_SENT, SLAPD_MONITOR_SENT_NAME,
 143                 BER_BVNULL, BER_BVNULL, BER_BVNULL,
 144                 MONITOR_F_PERSISTENT_CH,
 145                 monitor_subsys_sent_init,
 146                 monitor_subsys_sent_update,
 147                 NULL,   /* create */
 148                 NULL,   /* modify */
 149         }, {
 150                 SLAPD_MONITOR_TIME, SLAPD_MONITOR_TIME_NAME,
 151                 BER_BVNULL, BER_BVNULL, BER_BVNULL,
 152                 MONITOR_F_PERSISTENT_CH,
 153                 monitor_subsys_time_init,
 154                 monitor_subsys_time_update,
 155                 NULL,   /* create */
 156                 NULL,   /* modify */
 157         }, { -1, NULL }
 158 };
 159
 160 #ifdef SLAPD_MONITOR_DYNAMIC
 161
 162 int
 163 back_monitor_LTX_init_module( int argc, char *argv[] )
 164 {
 165         BackendInfo bi;
 166
 167         memset( &bi, '\0', sizeof(bi) );
 168         bi.bi_type = "monitor";
 169         bi.bi_init = monitor_back_initialize;
 170         backend_add( &bi );
 171         return 0;
 172 }
 173
 174 #endif /* SLAPD_MONITOR_DYNAMIC */
 175
 176 int
 177 monitor_back_initialize(
 178         BackendInfo     *bi
 179 )
 180 {
 181         static char *controls[] = {
 182                 LDAP_CONTROL_MANAGEDSAIT,
 183                 LDAP_CONTROL_VALUESRETURNFILTER,
 184                 NULL
 185         };
 186
 187         bi->bi_controls = controls;
 188
 189         bi->bi_init = 0;
 190         bi->bi_open = 0;
 191         bi->bi_config = monitor_back_config;
 192         bi->bi_close = 0;
 193         bi->bi_destroy = 0;
 194
 195         bi->bi_db_init = monitor_back_db_init;
 196         bi->bi_db_config = monitor_back_db_config;
 197         bi->bi_db_open = monitor_back_db_open;
 198         bi->bi_db_close = 0;
 199         bi->bi_db_destroy = monitor_back_db_destroy;
 200
 201         bi->bi_op_bind = monitor_back_bind;
 202         bi->bi_op_unbind = 0;
 203         bi->bi_op_search = monitor_back_search;
 204         bi->bi_op_compare = monitor_back_compare;
 205         bi->bi_op_modify = monitor_back_modify;
 206         bi->bi_op_modrdn = 0;
 207         bi->bi_op_add = 0;
 208         bi->bi_op_delete = 0;
 209         bi->bi_op_abandon = 0;
 210
 211         bi->bi_extended = 0;
 212
 213         bi->bi_entry_release_rw = 0;
 214         bi->bi_chk_referrals = 0;
 215         bi->bi_operational = monitor_back_operational;
 216
 217         /*
 218          * hooks for slap tools
 219          */
 220         bi->bi_tool_entry_open = 0;
 221         bi->bi_tool_entry_close = 0;
 222         bi->bi_tool_entry_first = 0;
 223         bi->bi_tool_entry_next = 0;
 224         bi->bi_tool_entry_get = 0;
 225         bi->bi_tool_entry_put = 0;
 226         bi->bi_tool_entry_reindex = 0;
 227         bi->bi_tool_sync = 0;
 228
 229         bi->bi_connection_init = 0;
 230         bi->bi_connection_destroy = 0;
 231
 232         return 0;
 233 }
 234
 235 int
 236 monitor_back_db_init(
 237         BackendDB       *be
 238 )
 239 {
 240         struct monitorinfo      *mi;
 241         Entry                   *e, *e_tmp;
 242         struct monitorentrypriv *mp;
 243         int                     i, rc;
 244         char                    buf[1024], *end_of_line;
 245         struct berval           dn, ndn;
 246         const char              *text;
 247         struct berval           bv[2];
 248
 249         /*
 250          * database monitor can be defined once only
 251          */
 252         if ( be_monitor ) {
 253 #ifdef NEW_LOGGING
 254                 LDAP_LOG( OPERATION, CRIT,
 255                         "only one monitor backend is allowed\n" , 0, 0, 0);
 256 #else
 257                 Debug( LDAP_DEBUG_ANY,
 258                         "only one monitor backend is allowed\n%s%s%s",
 259                         "", "", "" );
 260 #endif
 261                 return( -1 );
 262         }
 263         be_monitor = be;
 264
 265         /* indicate system schema supported */
 266         be->be_flags |= SLAP_BFLAG_MONITOR;
 267
 268         dn.bv_val = SLAPD_MONITOR_DN;
 269         dn.bv_len = sizeof( SLAPD_MONITOR_DN ) - 1;
 270
 271         rc = dnNormalize2( NULL, &dn, &ndn );
 272         if( rc != LDAP_SUCCESS ) {
 273 #ifdef NEW_LOGGING
 274                 LDAP_LOG( OPERATION, CRIT,
 275                         "monitor DN \"" SLAPD_MONITOR_DN "\" backend is allowed\n" , 0, 0, 0 );
 276 #else
 277                 Debug( LDAP_DEBUG_ANY,
 278                         "monitor DN \"" SLAPD_MONITOR_DN "\" backend is allowed\n",
 279                         0, 0, 0 );
 280 #endif
 281                 return -1;
 282         }
 283
 284         ber_dupbv( &bv[0], &dn );
 285         ber_bvarray_add( &be->be_suffix, &bv[0] );
 286         ber_bvarray_add( &be->be_nsuffix, &ndn );
 287
 288         mi = ( struct monitorinfo * )ch_calloc( sizeof( struct monitorinfo ), 1 );
 289         ldap_pvt_thread_mutex_init( &mi->mi_cache_mutex );
 290
 291         if ( slap_str2ad( "description", &monitor_ad_desc, &text ) ) {
 292 #ifdef NEW_LOGGING
 293                 LDAP_LOG( OPERATION, CRIT,
 294                         "monitor_back_db_init: %s\n", text, 0, 0 );
 295 #else
 296                 Debug( LDAP_DEBUG_ANY,
 297                         "monitor_subsys_backend_init: %s\n%s%s",
 298                         text, "", "" );
 299 #endif
 300                 return( -1 );
 301         }
 302
 303         /*
 304          * Create all the subsystem specific entries
 305          */
 306         e_tmp = NULL;
 307         for ( i = 0; monitor_subsys[ i ].mss_name != NULL; i++ ) {
 308                 int             len = strlen( monitor_subsys[ i ].mss_name );
 309                 struct berval   dn;
 310                 int             rc;
 311
 312                 dn.bv_len = len + sizeof( "cn=" ) - 1;
 313                 dn.bv_val = ch_calloc( sizeof( char ), dn.bv_len + 1 );
 314                 strcpy( dn.bv_val, "cn=" );
 315                 strcat( dn.bv_val, monitor_subsys[ i ].mss_name );
 316                 rc = dnPretty2( NULL, &dn, &monitor_subsys[ i ].mss_rdn );
 317                 free( dn.bv_val );
 318                 if ( rc != LDAP_SUCCESS ) {
 319 #ifdef NEW_LOGGING
 320                         LDAP_LOG( OPERATION, CRIT,
 321                                 "monitor RDN \"%s\" is invalid\n",
 322                                 dn.bv_val, 0, 0 );
 323 #else
 324                         Debug( LDAP_DEBUG_ANY,
 325                                 "monitor RDN \"%s\" is invalid\n",
 326                                 dn.bv_val, 0, 0 );
 327 #endif
 328                         return( -1 );
 329                 }
 330
 331                 dn.bv_len += sizeof( SLAPD_MONITOR_DN ); /* 1 for the , */
 332                 dn.bv_val = ch_malloc( dn.bv_len + 1 );
 333                 strcpy( dn.bv_val , monitor_subsys[ i ].mss_rdn.bv_val );
 334                 strcat( dn.bv_val, "," SLAPD_MONITOR_DN );
 335                 rc = dnPrettyNormal( NULL, &dn, &monitor_subsys[ i ].mss_dn,
 336                         &monitor_subsys[ i ].mss_ndn );
 337                 free( dn.bv_val );
 338                 if ( rc != LDAP_SUCCESS ) {
 339 #ifdef NEW_LOGGING
 340                         LDAP_LOG( OPERATION, CRIT,
 341                                 "monitor DN \"%s\" is invalid\n",
 342                                 dn.bv_val, 0, 0 );
 343 #else
 344                         Debug( LDAP_DEBUG_ANY,
 345                                 "monitor DN \"%s\" is invalid\n",
 346                                 dn.bv_val, 0, 0 );
 347 #endif
 348                         return( -1 );
 349                 }
 350
 351                 snprintf( buf, sizeof( buf ),
 352                                 "dn: %s\n"
 353                                 SLAPD_MONITOR_OBJECTCLASSES
 354                                 "cn: %s\n",
 355                                 monitor_subsys[ i ].mss_dn.bv_val,
 356                                 monitor_subsys[ i ].mss_name );
 357
 358                 e = str2entry( buf );
 359
 360                 if ( e == NULL) {
 361 #ifdef NEW_LOGGING
 362                         LDAP_LOG( OPERATION, CRIT,
 363                                 "unable to create '%s' entry\n",
 364                                 monitor_subsys[ i ].mss_dn.bv_val, 0, 0 );
 365 #else
 366                         Debug( LDAP_DEBUG_ANY,
 367                                 "unable to create '%s' entry\n",
 368                                 monitor_subsys[ i ].mss_dn.bv_val, 0, 0 );
 369 #endif
 370                         return( -1 );
 371                 }
 372
 373                 mp = ( struct monitorentrypriv * )ch_calloc( sizeof( struct monitorentrypriv ), 1 );
 374                 e->e_private = ( void * )mp;
 375                 mp->mp_info = &monitor_subsys[ i ];
 376                 mp->mp_children = NULL;
 377                 mp->mp_next = e_tmp;
 378                 mp->mp_flags = monitor_subsys[ i ].mss_flags;
 379
 380                 if ( monitor_cache_add( mi, e ) ) {
 381 #ifdef NEW_LOGGING
 382                         LDAP_LOG( OPERATION, CRIT,
 383                                 "unable to add entry '%s' to cache\n",
 384                                 monitor_subsys[ i ].mss_dn.bv_val, 0, 0 );
 385 #else
 386                         Debug( LDAP_DEBUG_ANY,
 387                                 "unable to add entry '%s' to cache\n",
 388                                 monitor_subsys[ i ].mss_dn.bv_val, 0, 0 );
 389 #endif
 390                         return -1;
 391                 }
 392
 393                 e_tmp = e;
 394         }
 395
 396         /*
 397          * creates the "cn=Monitor" entry
 398          */
 399         snprintf( buf, sizeof( buf ),
 400                         "dn: " SLAPD_MONITOR_DN "\n"
 401                         "objectClass: top\n"
 402                         "objectClass: monitor\n"
 403                         "objectClass: extensibleObject\n"
 404                         "structuralObjectClass: monitor\n"
 405                         "cn: Monitor" );
 406
 407         e = str2entry( buf );
 408         if ( e == NULL) {
 409 #ifdef NEW_LOGGING
 410                 LDAP_LOG( OPERATION, CRIT,
 411                         "unable to create '%s' entry\n",
 412                         SLAPD_MONITOR_DN, 0, 0 );
 413 #else
 414                 Debug( LDAP_DEBUG_ANY,
 415                         "unable to create '%s' entry\n%s%s",
 416                         SLAPD_MONITOR_DN, "", "" );
 417 #endif
 418                 return( -1 );
 419         }
 420         bv[1].bv_val = NULL;
 421         bv[0].bv_val = (char *) Versionstr;
 422         end_of_line = strchr( Versionstr, '\n' );
 423         if ( end_of_line ) {
 424                 bv[0].bv_len = end_of_line - Versionstr;
 425         } else {
 426                 bv[0].bv_len = strlen( Versionstr );
 427         }
 428         if ( attr_mergeit( e, monitor_ad_desc, bv ) ) {
 429 #ifdef NEW_LOGGING
 430                 LDAP_LOG( OPERATION, CRIT,
 431                         "unable to add description to '%s' entry\n",
 432                         SLAPD_MONITOR_DN, 0, 0 );
 433 #else
 434                 Debug( LDAP_DEBUG_ANY,
 435                         "unable to add description to '%s' entry\n%s%s",
 436                         SLAPD_MONITOR_DN, "", "" );
 437 #endif
 438                 return( -1 );
 439         }
 440
 441         mp = ( struct monitorentrypriv * )ch_calloc( sizeof( struct monitorentrypriv ), 1 );
 442         e->e_private = ( void * )mp;
 443
 444         mp->mp_info = NULL;
 445         mp->mp_children = e_tmp;
 446         mp->mp_next = NULL;
 447
 448         if ( monitor_cache_add( mi, e ) ) {
 449 #ifdef NEW_LOGGING
 450                 LDAP_LOG( OPERATION, CRIT,
 451                         "unable to add entry '%s' to cache\n",
 452                         SLAPD_MONITOR_DN, 0, 0 );
 453 #else
 454                 Debug( LDAP_DEBUG_ANY,
 455                         "unable to add entry '%s' to cache\n%s%s",
 456                         SLAPD_MONITOR_DN, "", "" );
 457 #endif
 458                 return -1;
 459         }
 460
 461         be->be_private = mi;
 462
 463         return 0;
 464 }
 465
 466 int
 467 monitor_back_db_open(
 468         BackendDB       *be
 469 )
 470 {
 471         struct monitorsubsys    *ms;
 472
 473         assert( be );
 474
 475         /*
 476          * opens the monitor backend
 477          */
 478         for ( ms = monitor_subsys; ms->mss_name != NULL; ms++ ) {
 479                 if ( ms->mss_init && ( *ms->mss_init )( be ) ) {
 480                         return( -1 );
 481                 }
 482         }
 483
 484         return( 0 );
 485 }
 486
 487 int
 488 monitor_back_config(
 489         BackendInfo     *bi,
 490         const char      *fname,
 491         int             lineno,
 492         int             argc,
 493         char            **argv
 494 )
 495 {
 496         /*
 497          * eventually, will hold backend specific configuration parameters
 498          */
 499         return 0;
 500 }
 501
 502 int
 503 monitor_back_db_config(
 504         Backend     *be,
 505         const char  *fname,
 506         int         lineno,
 507         int         argc,
 508         char        **argv
 509 )
 510 {
 511         /*
 512          * eventually, will hold database specific configuration parameters
 513          */
 514 #ifdef NEW_LOGGING
 515         LDAP_LOG( CONFIG, INFO,
 516                 "line %d of file '%s' will be ignored\n", lineno, fname, 0 );
 517 #else
 518         Debug( LDAP_DEBUG_CONFIG,
 519                 "line %d of file '%s' will be ignored\n%s", lineno, fname, "" );
 520 #endif
 521         return( 0 );
 522 }
 523
 524 int
 525 monitor_back_db_destroy(
 526         BackendDB       *be
 527 )
 528 {
 529         /*
 530          * FIXME: destroys all the data
 531          */
 532         return 0;
 533 }
 534