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

   1 /* log.c - deal with log subsystem */
   2 /*
   3  * Copyright 1998-2002 The OpenLDAP Foundation, All Rights Reserved.
   4  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
   5  */
   6 /*
   7  * Copyright 2001, Pierangelo Masarati, All rights reserved. <ando@sys-net.it>
   8  *
   9  * This work has beed deveolped for the OpenLDAP Foundation
  10  * in the hope that it may be useful to the Open Source community,
  11  * but WITHOUT ANY WARRANTY.
  12  *
  13  * Permission is granted to anyone to use this software for any purpose
  14  * on any computer system, and to alter it and redistribute it, subject
  15  * to the following restrictions:
  16  *
  17  * 1. The author and SysNet s.n.c. are not responsible for the consequences
  18  *    of use of this software, no matter how awful, even if they arise from
  19  *    flaws in it.
  20  *
  21  * 2. The origin of this software must not be misrepresented, either by
  22  *    explicit claim or by omission.  Since few users ever read sources,
  23  *    credits should appear in the documentation.
  24  *
  25  * 3. Altered versions must be plainly marked as such, and must not be
  26  *    misrepresented as being the original software.  Since few users
  27  *    ever read sources, credits should appear in the documentation.
  28  *    SysNet s.n.c. cannot be responsible for the consequences of the
  29  *    alterations.
  30  *
  31  * 4. This notice may not be removed or altered.
  32  */
  33
  34 #include "portable.h"
  35
  36 #include <stdio.h>
  37
  38 #include <ac/string.h>
  39
  40 #include "slap.h"
  41 #include "lutil.h"
  42 #include "ldif.h"
  43 #include "back-monitor.h"
  44
  45 /*
  46  * log mutex
  47  */
  48 ldap_pvt_thread_mutex_t         monitor_log_mutex;
  49
  50 static struct {
  51         int i;
  52         const char *s;
  53 } int_2_level[] = {
  54         { LDAP_DEBUG_TRACE,     "Trace" },
  55         { LDAP_DEBUG_PACKETS,   "Packets" },
  56         { LDAP_DEBUG_ARGS,      "Args" },
  57         { LDAP_DEBUG_CONNS,     "Conns" },
  58         { LDAP_DEBUG_BER,       "BER" },
  59         { LDAP_DEBUG_FILTER,    "Filter" },
  60         { LDAP_DEBUG_CONFIG,    "Config" },     /* useless */
  61         { LDAP_DEBUG_ACL,       "ACL" },
  62         { LDAP_DEBUG_STATS,     "Stats" },
  63         { LDAP_DEBUG_STATS2,    "Stats2" },
  64         { LDAP_DEBUG_SHELL,     "Shell" },
  65         { LDAP_DEBUG_PARSE,     "Parse" },
  66         { LDAP_DEBUG_CACHE,     "Cache" },
  67         { LDAP_DEBUG_INDEX,     "Index" },
  68         { 0,                    NULL }
  69 };
  70
  71 static int loglevel2int( const char *str );
  72 static const char * int2loglevel( int n );
  73
  74 static int add_values( Entry *e, Modification *mod, int *newlevel );
  75 static int delete_values( Entry *e, Modification *mod, int *newlevel );
  76 static int replace_values( Entry *e, Modification *mod, int *newlevel );
  77
  78 /*
  79  * initializes log subentry
  80  */
  81 int
  82 monitor_subsys_log_init(
  83         BackendDB       *be
  84 )
  85 {
  86         struct monitorinfo      *mi;
  87         Entry                   *e;
  88         int                     i;
  89         struct berval           bv[2];
  90
  91         ldap_pvt_thread_mutex_init( &monitor_log_mutex );
  92
  93         mi = ( struct monitorinfo * )be->be_private;
  94
  95         if ( monitor_cache_get( mi, &monitor_subsys[SLAPD_MONITOR_LOG].mss_ndn,
  96                                 &e ) ) {
  97 #ifdef NEW_LOGGING
  98                 LDAP_LOG(( "operation", LDAP_LEVEL_CRIT,
  99                         "monitor_subsys_log_init: "
 100                         "unable to get entry '%s'\n",
 101                         monitor_subsys[SLAPD_MONITOR_LOG].mss_ndn.bv_val ));
 102 #else
 103                 Debug( LDAP_DEBUG_ANY,
 104                         "monitor_subsys_log_init: "
 105                         "unable to get entry '%s'\n%s%s",
 106                         monitor_subsys[SLAPD_MONITOR_LOG].mss_ndn.bv_val,
 107                         "", "" );
 108 #endif
 109                 return( -1 );
 110         }
 111
 112         bv[1].bv_val = NULL;
 113
 114         /* initialize the debug level */
 115         for ( i = 0; int_2_level[ i ].i != 0; i++ ) {
 116                 if ( int_2_level[ i ].i & ldap_syslog ) {
 117                         bv[0].bv_val = ( char * )int_2_level[ i ].s;
 118                         bv[0].bv_len = strlen( bv[0].bv_val );
 119
 120                         attr_merge( e, monitor_ad_desc, bv );
 121                 }
 122         }
 123
 124         monitor_cache_release( mi, e );
 125
 126         return( 0 );
 127 }
 128
 129 int
 130 monitor_subsys_log_modify(
 131         struct monitorinfo      *mi,
 132         Entry                   *e,
 133         Modifications           *modlist
 134 )
 135 {
 136         int             rc = LDAP_OTHER;
 137         int             newlevel = ldap_syslog;
 138         Attribute       *save_attrs;
 139         Modifications   *ml;
 140
 141         ldap_pvt_thread_mutex_lock( &monitor_log_mutex );
 142
 143         save_attrs = e->e_attrs;
 144         e->e_attrs = attrs_dup( e->e_attrs );
 145
 146         for ( ml = modlist; ml != NULL; ml = ml->sml_next ) {
 147                 Modification    *mod = &ml->sml_mod;
 148
 149                 /*
 150                  * accept all operational attributes
 151                  */
 152                 if ( is_at_operational( mod->sm_desc->ad_type ) ) {
 153                         ( void ) attr_delete( &e->e_attrs, mod->sm_desc );
 154                         rc = attr_merge( e, mod->sm_desc, mod->sm_bvalues );
 155                         if ( rc != 0 ) {
 156                                 rc = LDAP_OTHER;
 157                                 break;
 158                         }
 159                         continue;
 160
 161                 /*
 162                  * only the monitor description attribute can be modified
 163                  */
 164                 } else if ( mod->sm_desc != monitor_ad_desc ) {
 165                         rc = LDAP_UNWILLING_TO_PERFORM;
 166                         break;
 167                 }
 168
 169                 switch ( mod->sm_op ) {
 170                 case LDAP_MOD_ADD:
 171                         rc = add_values( e, mod, &newlevel );
 172                         break;
 173
 174                 case LDAP_MOD_DELETE:
 175                         rc = delete_values( e, mod, &newlevel );
 176                         break;
 177
 178                 case LDAP_MOD_REPLACE:
 179                         rc = replace_values( e, mod, &newlevel );
 180                         break;
 181
 182                 default:
 183                         rc = LDAP_OPERATIONS_ERROR;
 184                         break;
 185                 }
 186
 187                 if ( rc != LDAP_SUCCESS ) {
 188                         break;
 189                 }
 190         }
 191
 192         /* set the new debug level */
 193         if ( rc == LDAP_SUCCESS ) {
 194                 const char *text;
 195                 static char textbuf[1024];
 196
 197 #if 0   /* need op */
 198                 /* check for abandon */
 199                 ldap_pvt_thread_mutex_lock( &op->o_abandonmutex );
 200                 if ( op->o_abandon ) {
 201                         ldap_pvt_thread_mutex_unlock( &op->o_abandonmutex );
 202                         rc = SLAPD_ABANDON;
 203
 204                         goto cleanup;
 205                 }
 206                 ldap_pvt_thread_mutex_unlock( &op->o_abandonmutex );
 207 #endif
 208
 209                 /* check that the entry still obeys the schema */
 210                 rc = entry_schema_check( be_monitor, e, save_attrs,
 211                                 &text, textbuf, sizeof( textbuf ) );
 212                 if ( rc != LDAP_SUCCESS ) {
 213                         goto cleanup;
 214                 }
 215
 216                 /*
 217                  * Do we need to protect this with a mutex?
 218                  */
 219                 ldap_syslog = newlevel;
 220
 221 #if 0   /* debug rather than log */
 222                 slap_debug = newlevel;
 223                 lutil_set_debug_level( "slapd", slap_debug );
 224                 ber_set_option(NULL, LBER_OPT_DEBUG_LEVEL, &slap_debug);
 225                 ldap_set_option(NULL, LDAP_OPT_DEBUG_LEVEL, &slap_debug);
 226                 ldif_debug = slap_debug;
 227 #endif
 228         }
 229
 230 cleanup:;
 231         if ( rc == LDAP_SUCCESS ) {
 232                 attrs_free( save_attrs );
 233
 234         } else {
 235                 attrs_free( e->e_attrs );
 236                 e->e_attrs = save_attrs;
 237         }
 238
 239         ldap_pvt_thread_mutex_unlock( &monitor_log_mutex );
 240
 241         return( rc );
 242 }
 243
 244 static int
 245 loglevel2int( const char *str )
 246 {
 247         int             i;
 248
 249         for ( i = 0; int_2_level[ i ].i != 0; i++ ) {
 250                 if ( strcasecmp( str, int_2_level[ i ].s ) == 0 ) {
 251                         return int_2_level[ i ].i;
 252                 }
 253         }
 254
 255         return 0;
 256 }
 257
 258 static const char *
 259 int2loglevel( int n )
 260 {
 261         int             i;
 262
 263         for ( i = 0; int_2_level[ i ].i != 0; i++ ) {
 264                 if ( int_2_level[ i ].i == n ) {
 265                         return int_2_level[ i ].s;
 266                 }
 267         }
 268
 269         return NULL;
 270 }
 271
 272 static int
 273 check_constraints( Modification *mod, int *newlevel )
 274 {
 275         int             i;
 276
 277         for ( i = 0; mod->sm_bvalues && mod->sm_bvalues[i].bv_val != NULL; i++ ) {
 278                 int l;
 279                 const char *s;
 280                 ber_len_t len;
 281
 282                 l = loglevel2int( mod->sm_bvalues[i].bv_val );
 283                 if ( !l ) {
 284                         return LDAP_CONSTRAINT_VIOLATION;
 285                 }
 286
 287                 s = int2loglevel( l );
 288                 len = strlen( s );
 289                 assert( len == mod->sm_bvalues[i].bv_len );
 290
 291                 AC_MEMCPY( mod->sm_bvalues[i].bv_val, s, len );
 292
 293                 *newlevel |= l;
 294         }
 295
 296         return LDAP_SUCCESS;
 297 }
 298
 299 static int
 300 add_values( Entry *e, Modification *mod, int *newlevel )
 301 {
 302         Attribute       *a;
 303         int             i, rc;
 304         MatchingRule    *mr = mod->sm_desc->ad_type->sat_equality;
 305
 306         rc = check_constraints( mod, newlevel );
 307         if ( rc != LDAP_SUCCESS ) {
 308                 return rc;
 309         }
 310
 311         a = attr_find( e->e_attrs, mod->sm_desc );
 312
 313         if ( a != NULL ) {
 314
 315                 /* "description" SHOULD have appropriate rules ... */
 316                 if ( mr == NULL || !mr->smr_match ) {
 317                         return LDAP_INAPPROPRIATE_MATCHING;
 318                 }
 319
 320                 for ( i = 0; mod->sm_bvalues[i].bv_val != NULL; i++ ) {
 321                         int rc;
 322                         int j;
 323                         const char *text = NULL;
 324                         struct berval asserted;
 325
 326                         rc = value_normalize( mod->sm_desc,
 327                                         SLAP_MR_EQUALITY,
 328                                         &mod->sm_bvalues[i],
 329                                         &asserted,
 330                                         &text );
 331
 332                         if ( rc != LDAP_SUCCESS ) {
 333                                 return rc;
 334                         }
 335
 336                         for ( j = 0; a->a_vals[j].bv_val != NULL; j++ ) {
 337                                 int match;
 338                                 int rc = value_match( &match, mod->sm_desc, mr,
 339                                                 SLAP_MR_VALUE_SYNTAX_MATCH,
 340                                                 &a->a_vals[j], &asserted, &text );
 341
 342                                 if ( rc == LDAP_SUCCESS && match == 0 ) {
 343                                         free( asserted.bv_val );
 344                                         return LDAP_TYPE_OR_VALUE_EXISTS;
 345                                 }
 346                         }
 347
 348                         free( asserted.bv_val );
 349                 }
 350         }
 351
 352         /* no - add them */
 353         if ( attr_merge( e, mod->sm_desc, mod->sm_bvalues ) != 0 ) {
 354                 /* this should return result of attr_merge */
 355                 return LDAP_OTHER;
 356         }
 357
 358         return LDAP_SUCCESS;
 359 }
 360
 361 static int
 362 delete_values( Entry *e, Modification *mod, int *newlevel )
 363 {
 364         int             i, j, k, found, rc, nl = 0;
 365         Attribute       *a;
 366         MatchingRule    *mr = mod->sm_desc->ad_type->sat_equality;
 367
 368         rc = check_constraints( mod, &nl );
 369         if ( rc != LDAP_SUCCESS ) {
 370                 return rc;
 371         }
 372
 373         *newlevel &= ~nl;
 374
 375         /* delete the entire attribute */
 376         if ( mod->sm_bvalues == NULL ) {
 377                 int rc = attr_delete( &e->e_attrs, mod->sm_desc );
 378
 379                 if ( rc ) {
 380                         rc = LDAP_NO_SUCH_ATTRIBUTE;
 381                 } else {
 382                         *newlevel = 0;
 383                         rc = LDAP_SUCCESS;
 384                 }
 385                 return rc;
 386         }
 387
 388         if ( mr == NULL || !mr->smr_match ) {
 389                 /* disallow specific attributes from being deleted if
 390                  * no equality rule */
 391                 return LDAP_INAPPROPRIATE_MATCHING;
 392         }
 393
 394         /* delete specific values - find the attribute first */
 395         if ( (a = attr_find( e->e_attrs, mod->sm_desc )) == NULL ) {
 396                 return( LDAP_NO_SUCH_ATTRIBUTE );
 397         }
 398
 399         /* find each value to delete */
 400         for ( i = 0; mod->sm_bvalues[i].bv_val != NULL; i++ ) {
 401                 int rc;
 402                 const char *text = NULL;
 403
 404                 struct berval asserted;
 405
 406                 rc = value_normalize( mod->sm_desc,
 407                                 SLAP_MR_EQUALITY,
 408                                 &mod->sm_bvalues[i],
 409                                 &asserted,
 410                                 &text );
 411
 412                 if( rc != LDAP_SUCCESS ) return rc;
 413
 414                 found = 0;
 415                 for ( j = 0; a->a_vals[j].bv_val != NULL; j++ ) {
 416                         int match;
 417                         int rc = value_match( &match, mod->sm_desc, mr,
 418                                         SLAP_MR_VALUE_SYNTAX_MATCH,
 419                                         &a->a_vals[j], &asserted, &text );
 420
 421                         if( rc == LDAP_SUCCESS && match != 0 ) {
 422                                 continue;
 423                         }
 424
 425                         /* found a matching value */
 426                         found = 1;
 427
 428                         /* delete it */
 429                         free( a->a_vals[j].bv_val );
 430                         for ( k = j + 1; a->a_vals[k].bv_val != NULL; k++ ) {
 431                                 a->a_vals[k - 1] = a->a_vals[k];
 432                         }
 433                         a->a_vals[k - 1].bv_val = NULL;
 434
 435                         break;
 436                 }
 437
 438                 free( asserted.bv_val );
 439
 440                 /* looked through them all w/o finding it */
 441                 if ( ! found ) {
 442                         return LDAP_NO_SUCH_ATTRIBUTE;
 443                 }
 444         }
 445
 446         /* if no values remain, delete the entire attribute */
 447         if ( a->a_vals[0].bv_val == NULL ) {
 448                 /* should already be zero */
 449                 *newlevel = 0;
 450
 451                 if ( attr_delete( &e->e_attrs, mod->sm_desc ) ) {
 452                         return LDAP_NO_SUCH_ATTRIBUTE;
 453                 }
 454         }
 455
 456         return LDAP_SUCCESS;
 457 }
 458
 459 static int
 460 replace_values( Entry *e, Modification *mod, int *newlevel )
 461 {
 462         int rc;
 463
 464         *newlevel = 0;
 465         rc = check_constraints( mod, newlevel );
 466         if ( rc != LDAP_SUCCESS ) {
 467                 return rc;
 468         }
 469
 470         rc = attr_delete( &e->e_attrs, mod->sm_desc );
 471
 472         if ( rc != LDAP_SUCCESS && rc != LDAP_NO_SUCH_ATTRIBUTE ) {
 473                 return rc;
 474         }
 475
 476         if ( mod->sm_bvalues != NULL &&
 477                 attr_merge( e, mod->sm_desc, mod->sm_bvalues ) != 0 ) {
 478                 return LDAP_OTHER;
 479         }
 480
 481         return LDAP_SUCCESS;
 482 }
 483