git.sur5r.net Git - openldap/blob - servers/slapd/backend.c

   1 /*
   2  * Copyright 1998-1999 The OpenLDAP Foundation, All Rights Reserved.
   3  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
   4  */
   5 /* backend.c - routines for dealing with back-end databases */
   6
   7
   8 #include "portable.h"
   9
  10 #include <stdio.h>
  11
  12 #include <ac/string.h>
  13 #include <ac/socket.h>
  14
  15 #include <sys/stat.h>
  16
  17 #include "slap.h"
  18 #include "lutil.h"
  19
  20 #include "ldap_defaults.h"
  21
  22 #ifdef SLAPD_LDAP
  23 #include "back-ldap/external.h"
  24 #endif
  25 #ifdef SLAPD_LDBM
  26 #include "back-ldbm/external.h"
  27 #endif
  28 #ifdef SLAPD_BDB2
  29 #include "back-bdb2/external.h"
  30 #endif
  31 #ifdef SLAPD_PASSWD
  32 #include "back-passwd/external.h"
  33 #endif
  34 #ifdef SLAPD_PERL
  35 #include "back-perl/external.h"
  36 #endif
  37 #ifdef SLAPD_SHELL
  38 #include "back-shell/external.h"
  39 #endif
  40 #ifdef SLAPD_TCL
  41 #include "back-tcl/external.h"
  42 #endif
  43
  44 static BackendInfo binfo[] = {
  45 #if defined(SLAPD_LDAP) && !defined(SLAPD_LDAP_DYNAMIC)
  46         {"ldap",        ldap_back_initialize},
  47 #endif
  48 #if defined(SLAPD_LDBM) && !defined(SLAPD_LDBM_DYNAMIC)
  49         {"ldbm",        ldbm_back_initialize},
  50 #endif
  51 #if defined(SLAPD_BDB2) && !defined(SLAPD_BDB2_DYNAMIC)
  52         {"bdb2",        bdb2_back_initialize},
  53 #endif
  54 #if defined(SLAPD_PASSWD) && !defined(SLAPD_PASSWD_DYNAMIC)
  55         {"passwd",      passwd_back_initialize},
  56 #endif
  57 #if defined(SLAPD_PERL) && !defined(SLAPD_PERL_DYNAMIC)
  58         {"perl",        perl_back_initialize},
  59 #endif
  60 #if defined(SLAPD_SHELL) && !defined(SLAPD_SHELL_DYNAMIC)
  61         {"shell",       shell_back_initialize},
  62 #endif
  63 #if defined(SLAPD_TCL) && !defined(SLAPD_LDAP_TCL)
  64         {"tcl",         tcl_back_initialize},
  65 #endif
  66         {NULL}
  67 };
  68
  69 int                     nBackendInfo = 0;
  70 BackendInfo     *backendInfo = NULL;
  71
  72 int                     nBackendDB = 0;
  73 BackendDB       *backendDB = NULL;
  74
  75 int backend_init(void)
  76 {
  77         int rc = -1;
  78
  79         if((nBackendInfo != 0) || (backendInfo != NULL)) {
  80                 /* already initialized */
  81                 Debug( LDAP_DEBUG_ANY,
  82                         "backend_init: already initialized.\n", 0, 0, 0 );
  83                 return -1;
  84         }
  85
  86         for( ;
  87                 binfo[nBackendInfo].bi_type !=  NULL;
  88                 nBackendInfo++ )
  89         {
  90                 rc = binfo[nBackendInfo].bi_init(
  91                         &binfo[nBackendInfo] );
  92
  93                 if(rc != 0) {
  94                         Debug( LDAP_DEBUG_ANY,
  95                                 "backend_init: initialized for type \"%s\"\n",
  96                                         binfo[nBackendInfo].bi_type, 0, 0 );
  97
  98                         /* destroy those we've already inited */
  99                         for( nBackendInfo--;
 100                                 nBackendInfo >= 0 ;
 101                                 nBackendInfo-- )
 102                         {
 103                                 if ( binfo[nBackendInfo].bi_destroy ) {
 104                                         binfo[nBackendInfo].bi_destroy(
 105                                                 &binfo[nBackendInfo] );
 106                                 }
 107                         }
 108                         return rc;
 109                 }
 110         }
 111
 112         if ( nBackendInfo > 0) {
 113                 backendInfo = binfo;
 114                 return 0;
 115         }
 116
 117 #ifdef SLAPD_MODULES
 118         return 0;
 119 #else
 120         Debug( LDAP_DEBUG_ANY,
 121                 "backend_init: failed\n",
 122                 0, 0, 0 );
 123
 124         return rc;
 125 #endif /* SLAPD_MODULES */
 126 }
 127
 128 int backend_add(BackendInfo *aBackendInfo)
 129 {
 130    int rc = 0;
 131
 132    if ((rc = aBackendInfo->bi_init(aBackendInfo)) != 0) {
 133       Debug( LDAP_DEBUG_ANY,
 134              "backend_add: initialization for type \"%s\" failed\n",
 135              aBackendInfo->bi_type, 0, 0 );
 136       return rc;
 137    }
 138
 139    /* now add the backend type to the Backend Info List */
 140    {
 141       BackendInfo *newBackendInfo = 0;
 142
 143       /* if backendInfo == binfo no deallocation of old backendInfo */
 144       if (backendInfo == binfo) {
 145          newBackendInfo = ch_calloc(nBackendInfo + 1, sizeof(BackendInfo));
 146          memcpy(newBackendInfo, backendInfo, sizeof(BackendInfo) *
 147                 nBackendInfo);
 148       } else {
 149          newBackendInfo = ch_realloc(backendInfo, sizeof(BackendInfo) *
 150                                      (nBackendInfo + 1));
 151       }
 152       memcpy(&newBackendInfo[nBackendInfo], aBackendInfo,
 153              sizeof(BackendInfo));
 154       backendInfo = newBackendInfo;
 155       nBackendInfo++;
 156
 157       return 0;
 158    }
 159 }
 160
 161 int backend_startup(int n)
 162 {
 163         int i;
 164         int rc = 0;
 165
 166         if( ! ( nBackendDB > 0 ) ) {
 167                 /* no databases */
 168                 Debug( LDAP_DEBUG_ANY,
 169                         "backend_startup: %d databases to startup.\n",
 170                         nBackendDB, 0, 0 );
 171                 return 1;
 172         }
 173
 174         if(n >= 0) {
 175                 /* startup a specific backend database */
 176                 Debug( LDAP_DEBUG_TRACE,
 177                         "backend_startup: starting database %d\n",
 178                         n, 0, 0 );
 179
 180                 /* make sure, n does not exceed the number of backend databases */
 181                 if ( n >= nbackends ) {
 182
 183                         Debug( LDAP_DEBUG_ANY,
 184                                 "backend_startup: database number %d exceeding maximum (%d)\n",
 185                                 n, nbackends, 0 );
 186                         return 1;
 187                 }
 188
 189                 if ( backendDB[n].bd_info->bi_open ) {
 190                         rc = backendDB[n].bd_info->bi_open(
 191                                 backendDB[n].bd_info );
 192                 }
 193
 194                 if(rc != 0) {
 195                         Debug( LDAP_DEBUG_ANY,
 196                                 "backend_startup: bi_open failed!\n",
 197                                 0, 0, 0 );
 198                         return rc;
 199                 }
 200
 201                 if ( backendDB[n].bd_info->bi_db_open ) {
 202                         rc = backendDB[n].bd_info->bi_db_open(
 203                                 &backendDB[n] );
 204                 }
 205
 206                 if(rc != 0) {
 207                         Debug( LDAP_DEBUG_ANY,
 208                                 "backend_startup: bi_db_open failed!\n",
 209                                 0, 0, 0 );
 210                         return rc;
 211                 }
 212
 213                 return rc;
 214         }
 215
 216         /* open each backend type */
 217         for( i = 0; i < nBackendInfo; i++ ) {
 218                 if( backendInfo[i].bi_nDB == 0) {
 219                         /* no database of this type, don't open */
 220                         continue;
 221                 }
 222
 223                 if( backendInfo[i].bi_open ) {
 224                         rc = backendInfo[i].bi_open(
 225                                 &backendInfo[i] );
 226                 }
 227
 228                 if(rc != 0) {
 229                         Debug( LDAP_DEBUG_ANY,
 230                                 "backend_startup: bi_open %d failed!\n",
 231                                 i, 0, 0 );
 232                         return rc;
 233                 }
 234         }
 235
 236         /* open each backend database */
 237         for( i = 0; i < nBackendDB; i++ ) {
 238                 if ( backendDB[i].bd_info->bi_db_open ) {
 239                         rc = backendDB[i].bd_info->bi_db_open(
 240                                 &backendDB[i] );
 241                 }
 242
 243                 if(rc != 0) {
 244                         Debug( LDAP_DEBUG_ANY,
 245                                 "backend_startup: bi_db_open %d failed!\n",
 246                                 i, 0, 0 );
 247                         return rc;
 248                 }
 249         }
 250
 251         return rc;
 252 }
 253
 254 int backend_shutdown(int n)
 255 {
 256         int i;
 257         int rc = 0;
 258
 259         if(n >= 0) {
 260                 /* shutdown a specific backend database */
 261
 262                 /* make sure, n does not exceed the number of backend databases */
 263                 if ( n >= nbackends ) {
 264
 265                         Debug( LDAP_DEBUG_ANY,
 266                                 "backend_startup: database number %d exceeding maximum (%d)\n",
 267                                 n, nbackends, 0 );
 268                         return 1;
 269                 }
 270
 271                 if ( backendDB[n].bd_info->bi_nDB == 0 ) {
 272                         /* no database of this type, we never opened it */
 273                         return 0;
 274                 }
 275
 276                 if ( backendDB[n].bd_info->bi_db_close ) {
 277                         backendDB[n].bd_info->bi_db_close(
 278                                 &backendDB[n] );
 279                 }
 280
 281                 if( backendDB[n].bd_info->bi_close ) {
 282                         backendDB[n].bd_info->bi_close(
 283                                 backendDB[n].bd_info );
 284                 }
 285
 286                 return 0;
 287         }
 288
 289         /* close each backend database */
 290         for( i = 0; i < nBackendDB; i++ ) {
 291                 BackendInfo  *bi;
 292
 293                 if ( backendDB[i].bd_info->bi_db_close ) {
 294                         backendDB[i].bd_info->bi_db_close(
 295                                 &backendDB[i] );
 296                 }
 297
 298                 if(rc != 0) {
 299                         Debug( LDAP_DEBUG_ANY,
 300                                 "backend_close: bi_close %s failed!\n",
 301                                 bi->bi_type, 0, 0 );
 302                 }
 303         }
 304
 305         /* close each backend type */
 306         for( i = 0; i < nBackendInfo; i++ ) {
 307                 if( backendInfo[i].bi_nDB == 0 ) {
 308                         /* no database of this type */
 309                         continue;
 310                 }
 311
 312                 if( backendInfo[i].bi_close ) {
 313                         backendInfo[i].bi_close(
 314                                 &backendInfo[i] );
 315                 }
 316         }
 317
 318         return 0;
 319 }
 320
 321 int backend_destroy(void)
 322 {
 323         int i;
 324
 325         /* destroy each backend database */
 326         for( i = 0; i < nBackendDB; i++ ) {
 327                 if ( backendDB[i].bd_info->bi_db_destroy ) {
 328                         backendDB[i].bd_info->bi_db_destroy(
 329                                 &backendDB[i] );
 330                 }
 331         }
 332
 333         /* destroy each backend type */
 334         for( i = 0; i < nBackendInfo; i++ ) {
 335                 if( backendInfo[i].bi_destroy ) {
 336                         backendInfo[i].bi_destroy(
 337                                 &backendInfo[i] );
 338                 }
 339         }
 340
 341 #ifdef SLAPD_MODULES
 342         if (backendInfo != binfo) {
 343            free(backendInfo);
 344         }
 345 #endif /* SLAPD_MODULES */
 346
 347         nBackendInfo = 0;
 348         backendInfo = NULL;
 349
 350         return 0;
 351 }
 352
 353 BackendInfo* backend_info(char *type)
 354 {
 355         int i;
 356
 357         /* search for the backend type */
 358         for( i = 0; i < nBackendInfo; i++ ) {
 359                 if( strcasecmp(backendInfo[i].bi_type, type) == 0 ) {
 360                         return &backendInfo[i];
 361                 }
 362         }
 363
 364         return NULL;
 365 }
 366
 367
 368 BackendDB *
 369 backend_db_init(
 370     char        *type
 371 )
 372 {
 373         Backend *be;
 374         BackendInfo *bi = backend_info(type);
 375         int     rc = 0;
 376
 377         if( bi == NULL ) {
 378                 fprintf( stderr, "Unrecognized database type (%s)\n", type );
 379                 return NULL;
 380         }
 381
 382         backendDB = (BackendDB *) ch_realloc(
 383                         (char *) backendDB,
 384                     (nBackendDB + 1) * sizeof(Backend) );
 385
 386         memset( &backendDB[nbackends], '\0', sizeof(Backend) );
 387
 388         be = &backends[nbackends++];
 389
 390         be->bd_info = bi;
 391         be->be_sizelimit = defsize;
 392         be->be_timelimit = deftime;
 393
 394         be->be_realm = global_realm != NULL
 395                 ? ch_strdup( global_realm ) : NULL;
 396
 397         if(bi->bi_db_init) {
 398                 rc = bi->bi_db_init( be );
 399         }
 400
 401         if(rc != 0) {
 402                 fprintf( stderr, "database init failed (%s)\n", type );
 403                 nbackends--;
 404                 return NULL;
 405         }
 406
 407         bi->bi_nDB++;
 408         return( be );
 409 }
 410
 411 void
 412 be_db_close( void )
 413 {
 414         int     i;
 415
 416         for ( i = 0; i < nbackends; i++ ) {
 417                 if ( backends[i].bd_info->bi_db_close ) {
 418                         (*backends[i].bd_info->bi_db_close)( &backends[i] );
 419                 }
 420         }
 421 }
 422
 423 Backend *
 424 select_backend( char * dn )
 425 {
 426         int     i, j, len, dnlen;
 427
 428         dnlen = strlen( dn );
 429         for ( i = 0; i < nbackends; i++ ) {
 430                 for ( j = 0; backends[i].be_nsuffix != NULL &&
 431                     backends[i].be_nsuffix[j] != NULL; j++ )
 432                 {
 433                         len = strlen( backends[i].be_nsuffix[j] );
 434
 435                         if ( len > dnlen ) {
 436                                 continue;
 437                         }
 438
 439                         if ( strcmp( backends[i].be_nsuffix[j],
 440                             dn + (dnlen - len) ) == 0 ) {
 441                                 return( &backends[i] );
 442                         }
 443                 }
 444         }
 445
 446 #ifdef LDAP_ALLOW_NULL_SEARCH_BASE
 447         /* Add greg@greg.rim.or.jp
 448          * It's quick hack for cheap client
 449          * Some browser offer a NULL base at ldap_search
 450          *
 451          * Should only be used as a last resort. -Kdz
 452          */
 453         if(dnlen == 0) {
 454                 Debug( LDAP_DEBUG_TRACE,
 455                         "select_backend: use default backend\n", 0, 0, 0 );
 456                 return( &backends[0] );
 457         }
 458 #endif /* LDAP_ALLOW_NULL_SEARCH_BASE */
 459
 460         return( NULL );
 461 }
 462
 463 int
 464 be_issuffix(
 465     Backend     *be,
 466     char        *suffix
 467 )
 468 {
 469         int     i;
 470
 471         for ( i = 0; be->be_nsuffix != NULL && be->be_nsuffix[i] != NULL; i++ ) {
 472                 if ( strcmp( be->be_nsuffix[i], suffix ) == 0 ) {
 473                         return( 1 );
 474                 }
 475         }
 476
 477         return( 0 );
 478 }
 479
 480 int
 481 be_isroot( Backend *be, char *ndn )
 482 {
 483         int rc;
 484
 485         if ( ndn == NULL || be->be_root_ndn == NULL ) {
 486                 return( 0 );
 487         }
 488
 489         rc = strcmp( be->be_root_ndn, ndn ) ? 0 : 1;
 490
 491         return(rc);
 492 }
 493
 494 char *
 495 be_root_dn( Backend *be )
 496 {
 497         if ( be->be_root_dn == NULL ) {
 498                 return( "" );
 499         }
 500
 501         return be->be_root_dn;
 502 }
 503
 504 int
 505 be_isroot_pw( Backend *be, char *ndn, struct berval *cred )
 506 {
 507         int result;
 508
 509         if ( ! be_isroot( be, ndn ) ) {
 510                 return( 0 );
 511         }
 512
 513 #ifdef SLAPD_CRYPT
 514         ldap_pvt_thread_mutex_lock( &crypt_mutex );
 515 #endif
 516
 517         result = lutil_passwd( cred->bv_val, be->be_root_pw, NULL );
 518
 519 #ifdef SLAPD_CRYPT
 520         ldap_pvt_thread_mutex_unlock( &crypt_mutex );
 521 #endif
 522
 523         return result == 0;
 524 }
 525
 526 int
 527 be_entry_release_rw( Backend *be, Entry *e, int rw )
 528 {
 529         if ( be->be_release ) {
 530                 /* free and release entry from backend */
 531                 return be->be_release( be, e, rw );
 532         } else {
 533                 /* free entry */
 534                 entry_free( e );
 535                 return 0;
 536         }
 537 }
 538
 539 int
 540 backend_unbind(
 541         Connection   *conn,
 542         Operation    *op
 543 )
 544 {
 545         int     i;
 546
 547         for ( i = 0; i < nbackends; i++ ) {
 548                 if ( backends[i].be_unbind ) {
 549                         (*backends[i].be_unbind)( &backends[i], conn, op );
 550                 }
 551         }
 552
 553         return 0;
 554 }
 555
 556 int
 557 backend_connection_init(
 558         Connection   *conn
 559 )
 560 {
 561         int     i;
 562
 563         for ( i = 0; i < nbackends; i++ ) {
 564                 if ( backends[i].be_connection_init ) {
 565                         (*backends[i].be_connection_init)( &backends[i], conn);
 566                 }
 567         }
 568
 569         return 0;
 570 }
 571
 572 int
 573 backend_connection_destroy(
 574         Connection   *conn
 575 )
 576 {
 577         int     i;
 578
 579         for ( i = 0; i < nbackends; i++ ) {
 580                 if ( backends[i].be_connection_destroy ) {
 581                         (*backends[i].be_connection_destroy)( &backends[i], conn);
 582                 }
 583         }
 584
 585         return 0;
 586 }
 587
 588 int
 589 backend_group(
 590         Backend *be,
 591         Entry   *target,
 592         char    *gr_ndn,
 593         char    *op_ndn,
 594         char    *objectclassValue,
 595         char    *groupattrName
 596 )
 597 {
 598         if (be->be_group)
 599                 return( be->be_group(be, target, gr_ndn, op_ndn,
 600                         objectclassValue, groupattrName) );
 601         else
 602                 return(1);
 603 }
 604
 605 #ifdef SLAPD_SCHEMA_DN
 606 Attribute *backend_subschemasubentry( Backend *be )
 607 {
 608         /* should be backend specific */
 609         static struct berval ss_val = {
 610                 sizeof(SLAPD_SCHEMA_DN)-1,
 611                 SLAPD_SCHEMA_DN };
 612         static struct berval *ss_vals[2] = { &ss_val, NULL };
 613         static Attribute ss_attr = {
 614                 "subschemasubentry",
 615                 ss_vals,
 616                 SYNTAX_DN | SYNTAX_CIS,
 617                 NULL
 618         };
 619
 620         return &ss_attr;
 621 }
 622 #endif