git.sur5r.net Git - openldap/blob - servers/slapd/back-ldap/distproc.c

   1 /* distproc.c - implement distributed procedures */
   2 /* $OpenLDAP$ */
   3 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
   4  *
   5  * Copyright 2005-2017 The OpenLDAP Foundation.
   6  * Portions Copyright 2003 Howard Chu.
   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 the 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  * Based on back-ldap and slapo-chain, developed by Howard Chu
  21  */
  22
  23 #include "portable.h"
  24
  25 #include <stdio.h>
  26
  27 #include <ac/string.h>
  28 #include <ac/socket.h>
  29
  30 #include "slap.h"
  31
  32 #ifdef SLAP_DISTPROC
  33
  34 #include "back-ldap.h"
  35
  36 #include "config.h"
  37
  38 /*
  39  * From <draft-sermersheim-ldap-distproc>
  40  *
  41
  42       ContinuationReference ::= SET {
  43          referralURI      [0] SET SIZE (1..MAX) OF URI,
  44          localReference   [2] LDAPDN,
  45          referenceType    [3] ReferenceType,
  46          remainingName    [4] RelativeLDAPDN OPTIONAL,
  47          searchScope      [5] SearchScope OPTIONAL,
  48          searchedSubtrees [6] SearchedSubtrees OPTIONAL,
  49          failedName       [7] LDAPDN OPTIONAL,
  50          ...  }
  51
  52       ReferenceType ::= ENUMERATED {
  53          superior               (0),
  54          subordinate            (1),
  55          cross                  (2),
  56          nonSpecificSubordinate (3),
  57          supplier               (4),
  58          master                 (5),
  59          immediateSuperior      (6),
  60          self                   (7),
  61          ...  }
  62
  63       SearchScope ::= ENUMERATED {
  64          baseObject         (0),
  65          singleLevel        (1),
  66          wholeSubtree       (2),
  67          subordinateSubtree (3),
  68          ...  }
  69
  70    SearchedSubtrees ::= SET OF RelativeLDAPDN
  71
  72    LDAPDN, RelativeLDAPDN, and LDAPString, are defined in [RFC2251].
  73
  74  */
  75
  76 typedef enum ReferenceType_t {
  77         LDAP_DP_RT_UNKNOWN                      = -1,
  78         LDAP_DP_RT_SUPERIOR                     = 0,
  79         LDAP_DP_RT_SUBORDINATE                  = 1,
  80         LDAP_DP_RT_CROSS                        = 2,
  81         LDAP_DP_RT_NONSPECIFICSUBORDINATE       = 3,
  82         LDAP_DP_RT_SUPPLIER                     = 4,
  83         LDAP_DP_RT_MASTER                       = 5,
  84         LDAP_DP_RT_IMMEDIATESUPERIOR            = 6,
  85         LDAP_DP_RT_SELF                         = 7,
  86         LDAP_DP_RT_LAST
  87 } ReferenceType_t;
  88
  89 typedef enum SearchScope_t {
  90         LDAP_DP_SS_UNKNOWN                      = -1,
  91         LDAP_DP_SS_BASEOBJECT                   = 0,
  92         LDAP_DP_SS_SINGLELEVEL                  = 1,
  93         LDAP_DP_SS_WHOLESUBTREE                 = 2,
  94         LDAP_DP_SS_SUBORDINATESUBTREE           = 3,
  95         LDAP_DP_SS_LAST
  96 } SearchScope_t;
  97
  98 typedef struct ContinuationReference_t {
  99         BerVarray               cr_referralURI;
 100         /* ?                    [1] ? */
 101         struct berval           cr_localReference;
 102         ReferenceType_t         cr_referenceType;
 103         struct berval           cr_remainingName;
 104         SearchScope_t           cr_searchScope;
 105         BerVarray               cr_searchedSubtrees;
 106         struct berval           cr_failedName;
 107 } ContinuationReference_t;
 108 #define CR_INIT         { NULL, BER_BVNULL, LDAP_DP_RT_UNKNOWN, BER_BVNULL, LDAP_DP_SS_UNKNOWN, NULL, BER_BVNULL }
 109
 110 #ifdef unused
 111 static struct berval    bv2rt[] = {
 112         BER_BVC( "superior" ),
 113         BER_BVC( "subordinate" ),
 114         BER_BVC( "cross" ),
 115         BER_BVC( "nonSpecificSubordinate" ),
 116         BER_BVC( "supplier" ),
 117         BER_BVC( "master" ),
 118         BER_BVC( "immediateSuperior" ),
 119         BER_BVC( "self" ),
 120         BER_BVNULL
 121 };
 122
 123 static struct berval    bv2ss[] = {
 124         BER_BVC( "baseObject" ),
 125         BER_BVC( "singleLevel" ),
 126         BER_BVC( "wholeSubtree" ),
 127         BER_BVC( "subordinateSubtree" ),
 128         BER_BVNULL
 129 };
 130
 131 static struct berval *
 132 ldap_distproc_rt2bv( ReferenceType_t rt )
 133 {
 134         return &bv2rt[ rt ];
 135 }
 136
 137 static const char *
 138 ldap_distproc_rt2str( ReferenceType_t rt )
 139 {
 140         return bv2rt[ rt ].bv_val;
 141 }
 142
 143 static ReferenceType_t
 144 ldap_distproc_bv2rt( struct berval *bv )
 145 {
 146         ReferenceType_t         rt;
 147
 148         for ( rt = 0; !BER_BVISNULL( &bv2rt[ rt ] ); rt++ ) {
 149                 if ( ber_bvstrcasecmp( bv, &bv2rt[ rt ] ) == 0 ) {
 150                         return rt;
 151                 }
 152         }
 153
 154         return LDAP_DP_RT_UNKNOWN;
 155 }
 156
 157 static ReferenceType_t
 158 ldap_distproc_str2rt( const char *s )
 159 {
 160         struct berval   bv;
 161
 162         ber_str2bv( s, 0, 0, &bv );
 163         return ldap_distproc_bv2rt( &bv );
 164 }
 165
 166 static struct berval *
 167 ldap_distproc_ss2bv( SearchScope_t ss )
 168 {
 169         return &bv2ss[ ss ];
 170 }
 171
 172 static const char *
 173 ldap_distproc_ss2str( SearchScope_t ss )
 174 {
 175         return bv2ss[ ss ].bv_val;
 176 }
 177
 178 static SearchScope_t
 179 ldap_distproc_bv2ss( struct berval *bv )
 180 {
 181         ReferenceType_t         ss;
 182
 183         for ( ss = 0; !BER_BVISNULL( &bv2ss[ ss ] ); ss++ ) {
 184                 if ( ber_bvstrcasecmp( bv, &bv2ss[ ss ] ) == 0 ) {
 185                         return ss;
 186                 }
 187         }
 188
 189         return LDAP_DP_SS_UNKNOWN;
 190 }
 191
 192 static SearchScope_t
 193 ldap_distproc_str2ss( const char *s )
 194 {
 195         struct berval   bv;
 196
 197         ber_str2bv( s, 0, 0, &bv );
 198         return ldap_distproc_bv2ss( &bv );
 199 }
 200 #endif /* unused */
 201
 202 /*
 203  * NOTE: this overlay assumes that the chainingBehavior control
 204  * is registered by the chain overlay; it may move here some time.
 205  * This overlay provides support for that control as well.
 206  */
 207
 208
 209 static int              sc_returnContRef;
 210 #define o_returnContRef                 o_ctrlflag[sc_returnContRef]
 211 #define get_returnContRef(op)           ((op)->o_returnContRef & SLAP_CONTROL_MASK)
 212
 213 static struct berval    slap_EXOP_CHAINEDREQUEST = BER_BVC( LDAP_EXOP_X_CHAINEDREQUEST );
 214 static struct berval    slap_FEATURE_CANCHAINOPS = BER_BVC( LDAP_FEATURE_X_CANCHAINOPS );
 215
 216 static BackendInfo      *lback;
 217
 218 typedef struct ldap_distproc_t {
 219         /* "common" configuration info (anything occurring before an "uri") */
 220         ldapinfo_t              *lc_common_li;
 221
 222         /* current configuration info */
 223         ldapinfo_t              *lc_cfg_li;
 224
 225         /* tree of configured[/generated?] "uri" info */
 226         ldap_avl_info_t         lc_lai;
 227
 228         unsigned                lc_flags;
 229 #define LDAP_DISTPROC_F_NONE            (0x00U)
 230 #define LDAP_DISTPROC_F_CHAINING        (0x01U)
 231 #define LDAP_DISTPROC_F_CACHE_URI       (0x10U)
 232
 233 #define LDAP_DISTPROC_CHAINING( lc )    ( ( (lc)->lc_flags & LDAP_DISTPROC_F_CHAINING ) == LDAP_DISTPROC_F_CHAINING )
 234 #define LDAP_DISTPROC_CACHE_URI( lc )   ( ( (lc)->lc_flags & LDAP_DISTPROC_F_CACHE_URI ) == LDAP_DISTPROC_F_CACHE_URI )
 235
 236 } ldap_distproc_t;
 237
 238 static int ldap_distproc_db_init_common( BackendDB      *be );
 239 static int ldap_distproc_db_init_one( BackendDB *be );
 240 #define ldap_distproc_db_open_one(be)           (lback)->bi_db_open( (be) )
 241 #define ldap_distproc_db_close_one(be)          (0)
 242 #define ldap_distproc_db_destroy_one(be, ca)    (lback)->bi_db_destroy( (be), (ca) )
 243
 244 static int
 245 ldap_distproc_uri_cmp( const void *c1, const void *c2 )
 246 {
 247         const ldapinfo_t        *li1 = (const ldapinfo_t *)c1;
 248         const ldapinfo_t        *li2 = (const ldapinfo_t *)c2;
 249
 250         assert( li1->li_bvuri != NULL );
 251         assert( !BER_BVISNULL( &li1->li_bvuri[ 0 ] ) );
 252         assert( BER_BVISNULL( &li1->li_bvuri[ 1 ] ) );
 253
 254         assert( li2->li_bvuri != NULL );
 255         assert( !BER_BVISNULL( &li2->li_bvuri[ 0 ] ) );
 256         assert( BER_BVISNULL( &li2->li_bvuri[ 1 ] ) );
 257
 258         /* If local DNs don't match, it is definitely not a match */
 259         return ber_bvcmp( &li1->li_bvuri[ 0 ], &li2->li_bvuri[ 0 ] );
 260 }
 261
 262 static int
 263 ldap_distproc_uri_dup( void *c1, void *c2 )
 264 {
 265         ldapinfo_t      *li1 = (ldapinfo_t *)c1;
 266         ldapinfo_t      *li2 = (ldapinfo_t *)c2;
 267
 268         assert( li1->li_bvuri != NULL );
 269         assert( !BER_BVISNULL( &li1->li_bvuri[ 0 ] ) );
 270         assert( BER_BVISNULL( &li1->li_bvuri[ 1 ] ) );
 271
 272         assert( li2->li_bvuri != NULL );
 273         assert( !BER_BVISNULL( &li2->li_bvuri[ 0 ] ) );
 274         assert( BER_BVISNULL( &li2->li_bvuri[ 1 ] ) );
 275
 276         /* Cannot have more than one shared session with same DN */
 277         if ( ber_bvcmp( &li1->li_bvuri[ 0 ], &li2->li_bvuri[ 0 ] ) == 0 ) {
 278                 return -1;
 279         }
 280
 281         return 0;
 282 }
 283
 284 static int
 285 ldap_distproc_operational( Operation *op, SlapReply *rs )
 286 {
 287         /* Trap entries generated by back-ldap.
 288          *
 289          * FIXME: we need a better way to recognize them; a cleaner
 290          * solution would be to be able to intercept the response
 291          * of be_operational(), so that we can divert only those
 292          * calls that fail because operational attributes were
 293          * requested for entries that do not belong to the underlying
 294          * database.  This fix is likely to intercept also entries
 295          * generated by back-perl and so. */
 296         if ( rs->sr_entry->e_private == NULL ) {
 297                 return LDAP_SUCCESS;
 298         }
 299
 300         return SLAP_CB_CONTINUE;
 301 }
 302
 303 static int
 304 ldap_distproc_response( Operation *op, SlapReply *rs )
 305 {
 306         return SLAP_CB_CONTINUE;
 307 }
 308
 309 /*
 310  * configuration...
 311  */
 312
 313 enum {
 314         /* NOTE: the chaining behavior control is registered
 315          * by the chain overlay; it may move here some time */
 316         DP_CHAINING = 1,
 317         DP_CACHE_URI,
 318
 319         DP_LAST
 320 };
 321
 322 static ConfigDriver distproc_cfgen;
 323 static ConfigCfAdd distproc_cfadd;
 324 static ConfigLDAPadd distproc_ldadd;
 325
 326 static ConfigTable distproc_cfg[] = {
 327         { "distproc-chaining", "args",
 328                 2, 4, 0, ARG_MAGIC|ARG_BERVAL|DP_CHAINING, distproc_cfgen,
 329                 /* NOTE: using the same attributeTypes defined
 330                  * for the "chain" overlay */
 331                 "( OLcfgOvAt:3.1 NAME 'olcChainingBehavior' "
 332                         "DESC 'Chaining behavior control parameters (draft-sermersheim-ldap-chaining)' "
 333                         "SYNTAX OMsDirectoryString SINGLE-VALUE )", NULL, NULL },
 334         { "distproc-cache-uri", "TRUE/FALSE",
 335                 2, 2, 0, ARG_MAGIC|ARG_ON_OFF|DP_CACHE_URI, distproc_cfgen,
 336                 "( OLcfgOvAt:3.2 NAME 'olcChainCacheURI' "
 337                         "DESC 'Enables caching of URIs not present in configuration' "
 338                         "SYNTAX OMsBoolean "
 339                         "SINGLE-VALUE )", NULL, NULL },
 340         { NULL, NULL, 0, 0, 0, ARG_IGNORED }
 341 };
 342
 343 static ConfigOCs distproc_ocs[] = {
 344         { "( OLcfgOvOc:7.1 "
 345                 "NAME 'olcDistProcConfig' "
 346                 "DESC 'Distributed procedures <draft-sermersheim-ldap-distproc> configuration' "
 347                 "SUP olcOverlayConfig "
 348                 "MAY ( "
 349                         "olcChainingBehavior $ "
 350                         "olcChainCacheURI "
 351                         ") )",
 352                 Cft_Overlay, distproc_cfg, NULL, distproc_cfadd },
 353         { "( OLcfgOvOc:7.2 "
 354                 "NAME 'olcDistProcDatabase' "
 355                 "DESC 'Distributed procedure remote server configuration' "
 356                 "AUXILIARY )",
 357                 Cft_Misc, distproc_cfg, distproc_ldadd },
 358         { NULL, 0, NULL }
 359 };
 360
 361 static int
 362 distproc_ldadd( CfEntryInfo *p, Entry *e, ConfigArgs *ca )
 363 {
 364         slap_overinst           *on;
 365         ldap_distproc_t         *lc;
 366
 367         ldapinfo_t              *li;
 368
 369         AttributeDescription    *ad = NULL;
 370         Attribute               *at;
 371         const char              *text;
 372
 373         int                     rc;
 374
 375         if ( p->ce_type != Cft_Overlay
 376                 || !p->ce_bi
 377                 || p->ce_bi->bi_cf_ocs != distproc_ocs )
 378         {
 379                 return LDAP_CONSTRAINT_VIOLATION;
 380         }
 381
 382         on = (slap_overinst *)p->ce_bi;
 383         lc = (ldap_distproc_t *)on->on_bi.bi_private;
 384
 385         assert( ca->be == NULL );
 386         ca->be = (BackendDB *)ch_calloc( 1, sizeof( BackendDB ) );
 387
 388         ca->be->bd_info = (BackendInfo *)on;
 389
 390         rc = slap_str2ad( "olcDbURI", &ad, &text );
 391         assert( rc == LDAP_SUCCESS );
 392
 393         at = attr_find( e->e_attrs, ad );
 394         if ( lc->lc_common_li == NULL && at != NULL ) {
 395                 /* FIXME: we should generate an empty default entry
 396                  * if none is supplied */
 397                 Debug( LDAP_DEBUG_ANY, "slapd-distproc: "
 398                         "first underlying database \"%s\" "
 399                         "cannot contain attribute \"%s\".\n",
 400                         e->e_name.bv_val, ad->ad_cname.bv_val, 0 );
 401                 rc = LDAP_CONSTRAINT_VIOLATION;
 402                 goto done;
 403
 404         } else if ( lc->lc_common_li != NULL && at == NULL ) {
 405                 /* FIXME: we should generate an empty default entry
 406                  * if none is supplied */
 407                 Debug( LDAP_DEBUG_ANY, "slapd-distproc: "
 408                         "subsequent underlying database \"%s\" "
 409                         "must contain attribute \"%s\".\n",
 410                         e->e_name.bv_val, ad->ad_cname.bv_val, 0 );
 411                 rc = LDAP_CONSTRAINT_VIOLATION;
 412                 goto done;
 413         }
 414
 415         if ( lc->lc_common_li == NULL ) {
 416                 rc = ldap_distproc_db_init_common( ca->be );
 417
 418         } else {
 419                 rc = ldap_distproc_db_init_one( ca->be );
 420         }
 421
 422         if ( rc != 0 ) {
 423                 Debug( LDAP_DEBUG_ANY, "slapd-distproc: "
 424                         "unable to init %sunderlying database \"%s\".\n",
 425                         lc->lc_common_li == NULL ? "common " : "", e->e_name.bv_val, 0 );
 426                 rc = LDAP_CONSTRAINT_VIOLATION;
 427                 goto done;
 428         }
 429
 430         li = ca->be->be_private;
 431
 432         if ( lc->lc_common_li == NULL ) {
 433                 lc->lc_common_li = li;
 434
 435         } else if ( avl_insert( &lc->lc_lai.lai_tree, (caddr_t)li,
 436                 ldap_distproc_uri_cmp, ldap_distproc_uri_dup ) )
 437         {
 438                 Debug( LDAP_DEBUG_ANY, "slapd-distproc: "
 439                         "database \"%s\" insert failed.\n",
 440                         e->e_name.bv_val, 0, 0 );
 441                 rc = LDAP_CONSTRAINT_VIOLATION;
 442                 goto done;
 443         }
 444
 445 done:;
 446         if ( rc != LDAP_SUCCESS ) {
 447                 (void)ldap_distproc_db_destroy_one( ca->be, NULL );
 448                 ch_free( ca->be );
 449                 ca->be = NULL;
 450         }
 451
 452         return rc;
 453 }
 454
 455 typedef struct ldap_distproc_cfadd_apply_t {
 456         Operation       *op;
 457         SlapReply       *rs;
 458         Entry           *p;
 459         ConfigArgs      *ca;
 460         int             count;
 461 } ldap_distproc_cfadd_apply_t;
 462
 463 static int
 464 ldap_distproc_cfadd_apply( void *datum, void *arg )
 465 {
 466         ldapinfo_t                      *li = (ldapinfo_t *)datum;
 467         ldap_distproc_cfadd_apply_t     *lca = (ldap_distproc_cfadd_apply_t *)arg;
 468
 469         struct berval                   bv;
 470
 471         /* FIXME: should not hardcode "olcDatabase" here */
 472         bv.bv_len = snprintf( lca->ca->cr_msg, sizeof( lca->ca->cr_msg ),
 473                 "olcDatabase={%d}%s", lca->count, lback->bi_type );
 474         bv.bv_val = lca->ca->cr_msg;
 475
 476         lca->ca->be->be_private = (void *)li;
 477         config_build_entry( lca->op, lca->rs, lca->p->e_private, lca->ca,
 478                 &bv, lback->bi_cf_ocs, &distproc_ocs[ 1 ] );
 479
 480         lca->count++;
 481
 482         return 0;
 483 }
 484
 485 static int
 486 distproc_cfadd( Operation *op, SlapReply *rs, Entry *p, ConfigArgs *ca )
 487 {
 488         CfEntryInfo     *pe = p->e_private;
 489         slap_overinst   *on = (slap_overinst *)pe->ce_bi;
 490         ldap_distproc_t *lc = (ldap_distproc_t *)on->on_bi.bi_private;
 491         void            *priv = (void *)ca->be->be_private;
 492
 493         if ( lback->bi_cf_ocs ) {
 494                 ldap_distproc_cfadd_apply_t     lca = { 0 };
 495
 496                 lca.op = op;
 497                 lca.rs = rs;
 498                 lca.p = p;
 499                 lca.ca = ca;
 500                 lca.count = 0;
 501
 502                 (void)ldap_distproc_cfadd_apply( (void *)lc->lc_common_li, (void *)&lca );
 503
 504                 (void)avl_apply( lc->lc_lai.lai_tree, ldap_distproc_cfadd_apply,
 505                         &lca, 1, AVL_INORDER );
 506
 507                 ca->be->be_private = priv;
 508         }
 509
 510         return 0;
 511 }
 512
 513 static int
 514 distproc_cfgen( ConfigArgs *c )
 515 {
 516         slap_overinst   *on = (slap_overinst *)c->bi;
 517         ldap_distproc_t *lc = (ldap_distproc_t *)on->on_bi.bi_private;
 518
 519         int             rc = 0;
 520
 521         if ( c->op == SLAP_CONFIG_EMIT ) {
 522                 switch( c->type ) {
 523                 case DP_CACHE_URI:
 524                         c->value_int = LDAP_DISTPROC_CACHE_URI( lc );
 525                         break;
 526
 527                 default:
 528                         assert( 0 );
 529                         rc = 1;
 530                 }
 531                 return rc;
 532
 533         } else if ( c->op == LDAP_MOD_DELETE ) {
 534                 switch( c->type ) {
 535                 case DP_CHAINING:
 536                         return 1;
 537
 538                 case DP_CACHE_URI:
 539                         lc->lc_flags &= ~LDAP_DISTPROC_F_CACHE_URI;
 540                         break;
 541
 542                 default:
 543                         return 1;
 544                 }
 545                 return rc;
 546         }
 547
 548         switch( c->type ) {
 549         case DP_CACHE_URI:
 550                 if ( c->value_int ) {
 551                         lc->lc_flags |= LDAP_DISTPROC_F_CACHE_URI;
 552                 } else {
 553                         lc->lc_flags &= ~LDAP_DISTPROC_F_CACHE_URI;
 554                 }
 555                 break;
 556
 557         default:
 558                 assert( 0 );
 559                 return 1;
 560         }
 561
 562         return rc;
 563 }
 564
 565 static int
 566 ldap_distproc_db_init(
 567         BackendDB *be,
 568         ConfigReply *cr )
 569 {
 570         slap_overinst   *on = (slap_overinst *)be->bd_info;
 571         ldap_distproc_t *lc = NULL;
 572
 573         if ( lback == NULL ) {
 574                 lback = backend_info( "ldap" );
 575
 576                 if ( lback == NULL ) {
 577                         return 1;
 578                 }
 579         }
 580
 581         lc = ch_malloc( sizeof( ldap_distproc_t ) );
 582         if ( lc == NULL ) {
 583                 return 1;
 584         }
 585         memset( lc, 0, sizeof( ldap_distproc_t ) );
 586         ldap_pvt_thread_mutex_init( &lc->lc_lai.lai_mutex );
 587
 588         on->on_bi.bi_private = (void *)lc;
 589
 590         return 0;
 591 }
 592
 593 static int
 594 ldap_distproc_db_config(
 595         BackendDB       *be,
 596         const char      *fname,
 597         int             lineno,
 598         int             argc,
 599         char            **argv )
 600 {
 601         slap_overinst   *on = (slap_overinst *)be->bd_info;
 602         ldap_distproc_t *lc = (ldap_distproc_t *)on->on_bi.bi_private;
 603
 604         int             rc = SLAP_CONF_UNKNOWN;
 605
 606         if ( lc->lc_common_li == NULL ) {
 607                 void    *be_private = be->be_private;
 608                 ldap_distproc_db_init_common( be );
 609                 lc->lc_common_li = lc->lc_cfg_li = (ldapinfo_t *)be->be_private;
 610                 be->be_private = be_private;
 611         }
 612
 613         /* Something for the distproc database? */
 614         if ( strncasecmp( argv[ 0 ], "distproc-", STRLENOF( "distproc-" ) ) == 0 ) {
 615                 char            *save_argv0 = argv[ 0 ];
 616                 BackendInfo     *bd_info = be->bd_info;
 617                 void            *be_private = be->be_private;
 618                 ConfigOCs       *be_cf_ocs = be->be_cf_ocs;
 619                 int             is_uri = 0;
 620
 621                 argv[ 0 ] += STRLENOF( "distproc-" );
 622
 623                 if ( strcasecmp( argv[ 0 ], "uri" ) == 0 ) {
 624                         rc = ldap_distproc_db_init_one( be );
 625                         if ( rc != 0 ) {
 626                                 Debug( LDAP_DEBUG_ANY, "%s: line %d: "
 627                                         "underlying slapd-ldap initialization failed.\n.",
 628                                         fname, lineno, 0 );
 629                                 return 1;
 630                         }
 631                         lc->lc_cfg_li = be->be_private;
 632                         is_uri = 1;
 633                 }
 634
 635                 /* TODO: add checks on what other slapd-ldap(5) args
 636                  * should be put in the template; this is not quite
 637                  * harmful, because attributes that shouldn't don't
 638                  * get actually used, but the user should at least
 639                  * be warned.
 640                  */
 641
 642                 be->bd_info = lback;
 643                 be->be_private = (void *)lc->lc_cfg_li;
 644                 be->be_cf_ocs = lback->bi_cf_ocs;
 645
 646                 rc = config_generic_wrapper( be, fname, lineno, argc, argv );
 647
 648                 argv[ 0 ] = save_argv0;
 649                 be->be_cf_ocs = be_cf_ocs;
 650                 be->be_private = be_private;
 651                 be->bd_info = bd_info;
 652
 653                 if ( is_uri ) {
 654 private_destroy:;
 655                         if ( rc != 0 ) {
 656                                 BackendDB               db = *be;
 657
 658                                 db.bd_info = lback;
 659                                 db.be_private = (void *)lc->lc_cfg_li;
 660                                 ldap_distproc_db_destroy_one( &db, NULL );
 661                                 lc->lc_cfg_li = NULL;
 662
 663                         } else {
 664                                 if ( lc->lc_cfg_li->li_bvuri == NULL
 665                                         || BER_BVISNULL( &lc->lc_cfg_li->li_bvuri[ 0 ] )
 666                                         || !BER_BVISNULL( &lc->lc_cfg_li->li_bvuri[ 1 ] ) )
 667                                 {
 668                                         Debug( LDAP_DEBUG_ANY, "%s: line %d: "
 669                                                 "no URI list allowed in slapo-distproc.\n",
 670                                                 fname, lineno, 0 );
 671                                         rc = 1;
 672                                         goto private_destroy;
 673                                 }
 674
 675                                 if ( avl_insert( &lc->lc_lai.lai_tree,
 676                                         (caddr_t)lc->lc_cfg_li,
 677                                         ldap_distproc_uri_cmp, ldap_distproc_uri_dup ) )
 678                                 {
 679                                         Debug( LDAP_DEBUG_ANY, "%s: line %d: "
 680                                                 "duplicate URI in slapo-distproc.\n",
 681                                                 fname, lineno, 0 );
 682                                         rc = 1;
 683                                         goto private_destroy;
 684                                 }
 685                         }
 686                 }
 687         }
 688
 689         return rc;
 690 }
 691
 692 enum db_which {
 693         db_open = 0,
 694         db_close,
 695         db_destroy,
 696
 697         db_last
 698 };
 699
 700 typedef struct ldap_distproc_db_apply_t {
 701         BackendDB       *be;
 702         BI_db_func      *func;
 703 } ldap_distproc_db_apply_t;
 704
 705 static int
 706 ldap_distproc_db_apply( void *datum, void *arg )
 707 {
 708         ldapinfo_t              *li = (ldapinfo_t *)datum;
 709         ldap_distproc_db_apply_t        *lca = (ldap_distproc_db_apply_t *)arg;
 710
 711         lca->be->be_private = (void *)li;
 712
 713         return lca->func( lca->be, NULL );
 714 }
 715
 716 static int
 717 ldap_distproc_db_func(
 718         BackendDB *be,
 719         enum db_which which
 720 )
 721 {
 722         slap_overinst   *on = (slap_overinst *)be->bd_info;
 723         ldap_distproc_t *lc = (ldap_distproc_t *)on->on_bi.bi_private;
 724
 725         int             rc = 0;
 726
 727         if ( lc ) {
 728                 BI_db_func      *func = (&lback->bi_db_open)[ which ];
 729
 730                 if ( func != NULL && lc->lc_common_li != NULL ) {
 731                         BackendDB               db = *be;
 732
 733                         db.bd_info = lback;
 734                         db.be_private = lc->lc_common_li;
 735
 736                         rc = func( &db, NULL );
 737
 738                         if ( rc != 0 ) {
 739                                 return rc;
 740                         }
 741
 742                         if ( lc->lc_lai.lai_tree != NULL ) {
 743                                 ldap_distproc_db_apply_t        lca;
 744
 745                                 lca.be = &db;
 746                                 lca.func = func;
 747
 748                                 rc = avl_apply( lc->lc_lai.lai_tree,
 749                                         ldap_distproc_db_apply, (void *)&lca,
 750                                         1, AVL_INORDER ) != AVL_NOMORE;
 751                         }
 752                 }
 753         }
 754
 755         return rc;
 756 }
 757
 758 static int
 759 ldap_distproc_db_open(
 760         BackendDB       *be,
 761         ConfigReply     *cr )
 762 {
 763         return ldap_distproc_db_func( be, db_open );
 764 }
 765
 766 static int
 767 ldap_distproc_db_close(
 768         BackendDB       *be,
 769         ConfigReply     *cr )
 770 {
 771         return ldap_distproc_db_func( be, db_close );
 772 }
 773
 774 static int
 775 ldap_distproc_db_destroy(
 776         BackendDB       *be,
 777         ConfigReply     *cr )
 778 {
 779         slap_overinst   *on = (slap_overinst *) be->bd_info;
 780         ldap_distproc_t *lc = (ldap_distproc_t *)on->on_bi.bi_private;
 781
 782         int             rc;
 783
 784         rc = ldap_distproc_db_func( be, db_destroy );
 785
 786         if ( lc ) {
 787                 avl_free( lc->lc_lai.lai_tree, NULL );
 788                 ldap_pvt_thread_mutex_destroy( &lc->lc_lai.lai_mutex );
 789                 ch_free( lc );
 790         }
 791
 792         return rc;
 793 }
 794
 795 /*
 796  * inits one instance of the slapd-ldap backend, and stores
 797  * the private info in be_private of the arg
 798  */
 799 static int
 800 ldap_distproc_db_init_common(
 801         BackendDB       *be )
 802 {
 803         BackendInfo     *bi = be->bd_info;
 804         int             t;
 805
 806         be->bd_info = lback;
 807         be->be_private = NULL;
 808         t = lback->bi_db_init( be, NULL );
 809         if ( t != 0 ) {
 810                 return t;
 811         }
 812         be->bd_info = bi;
 813
 814         return 0;
 815 }
 816
 817 /*
 818  * inits one instance of the slapd-ldap backend, stores
 819  * the private info in be_private of the arg and fills
 820  * selected fields with data from the template.
 821  *
 822  * NOTE: add checks about the other fields of the template,
 823  * which are ignored and SHOULD NOT be configured by the user.
 824  */
 825 static int
 826 ldap_distproc_db_init_one(
 827         BackendDB       *be )
 828 {
 829         slap_overinst   *on = (slap_overinst *)be->bd_info;
 830         ldap_distproc_t *lc = (ldap_distproc_t *)on->on_bi.bi_private;
 831
 832         BackendInfo     *bi = be->bd_info;
 833         ldapinfo_t      *li;
 834
 835         slap_op_t       t;
 836
 837         be->bd_info = lback;
 838         be->be_private = NULL;
 839         t = lback->bi_db_init( be, NULL );
 840         if ( t != 0 ) {
 841                 return t;
 842         }
 843         li = (ldapinfo_t *)be->be_private;
 844
 845         /* copy common data */
 846         li->li_nretries = lc->lc_common_li->li_nretries;
 847         li->li_flags = lc->lc_common_li->li_flags;
 848         li->li_version = lc->lc_common_li->li_version;
 849         for ( t = 0; t < SLAP_OP_LAST; t++ ) {
 850                 li->li_timeout[ t ] = lc->lc_common_li->li_timeout[ t ];
 851         }
 852         be->bd_info = bi;
 853
 854         return 0;
 855 }
 856
 857 typedef struct ldap_distproc_conn_apply_t {
 858         BackendDB       *be;
 859         Connection      *conn;
 860 } ldap_distproc_conn_apply_t;
 861
 862 static int
 863 ldap_distproc_conn_apply( void *datum, void *arg )
 864 {
 865         ldapinfo_t              *li = (ldapinfo_t *)datum;
 866         ldap_distproc_conn_apply_t      *lca = (ldap_distproc_conn_apply_t *)arg;
 867
 868         lca->be->be_private = (void *)li;
 869
 870         return lback->bi_connection_destroy( lca->be, lca->conn );
 871 }
 872
 873 static int
 874 ldap_distproc_connection_destroy(
 875         BackendDB *be,
 876         Connection *conn
 877 )
 878 {
 879         slap_overinst           *on = (slap_overinst *) be->bd_info;
 880         ldap_distproc_t         *lc = (ldap_distproc_t *)on->on_bi.bi_private;
 881         void                    *private = be->be_private;
 882         ldap_distproc_conn_apply_t      lca;
 883         int                     rc;
 884
 885         be->be_private = NULL;
 886         lca.be = be;
 887         lca.conn = conn;
 888         ldap_pvt_thread_mutex_lock( &lc->lc_lai.lai_mutex );
 889         rc = avl_apply( lc->lc_lai.lai_tree, ldap_distproc_conn_apply,
 890                 (void *)&lca, 1, AVL_INORDER ) != AVL_NOMORE;
 891         ldap_pvt_thread_mutex_unlock( &lc->lc_lai.lai_mutex );
 892         be->be_private = private;
 893
 894         return rc;
 895 }
 896
 897 static int
 898 ldap_distproc_parse_returnContRef_ctrl(
 899         Operation       *op,
 900         SlapReply       *rs,
 901         LDAPControl     *ctrl )
 902 {
 903         if ( get_returnContRef( op ) != SLAP_CONTROL_NONE ) {
 904                 rs->sr_text = "returnContinuationReference control specified multiple times";
 905                 return LDAP_PROTOCOL_ERROR;
 906         }
 907
 908         if ( op->o_pagedresults != SLAP_CONTROL_NONE ) {
 909                 rs->sr_text = "returnContinuationReference control specified with pagedResults control";
 910                 return LDAP_PROTOCOL_ERROR;
 911         }
 912
 913         if ( !BER_BVISEMPTY( &ctrl->ldctl_value ) ) {
 914                 rs->sr_text = "returnContinuationReference control: value must be NULL";
 915                 return LDAP_PROTOCOL_ERROR;
 916         }
 917
 918         op->o_returnContRef = ctrl->ldctl_iscritical ? SLAP_CONTROL_CRITICAL : SLAP_CONTROL_NONCRITICAL;
 919
 920         return LDAP_SUCCESS;
 921 }
 922
 923 static int
 924 ldap_exop_chained_request(
 925                 Operation       *op,
 926                 SlapReply       *rs )
 927 {
 928         Statslog( LDAP_DEBUG_STATS, "%s CHAINED REQUEST\n",
 929             op->o_log_prefix, 0, 0, 0, 0 );
 930
 931         rs->sr_err = backend_check_restrictions( op, rs,
 932                         (struct berval *)&slap_EXOP_CHAINEDREQUEST );
 933         if ( rs->sr_err != LDAP_SUCCESS ) {
 934                 return rs->sr_err;
 935         }
 936
 937         /* by now, just reject requests */
 938         rs->sr_text = "under development";
 939         return LDAP_UNWILLING_TO_PERFORM;
 940 }
 941
 942
 943 static slap_overinst distproc;
 944
 945 int
 946 distproc_initialize( void )
 947 {
 948         int     rc;
 949
 950         /* Make sure we don't exceed the bits reserved for userland */
 951         config_check_userland( DP_LAST );
 952
 953         rc = load_extop( (struct berval *)&slap_EXOP_CHAINEDREQUEST,
 954                 SLAP_EXOP_HIDE, ldap_exop_chained_request );
 955         if ( rc != LDAP_SUCCESS ) {
 956                 Debug( LDAP_DEBUG_ANY, "slapd-distproc: "
 957                         "unable to register chainedRequest exop: %d.\n",
 958                         rc, 0, 0 );
 959                 return rc;
 960         }
 961
 962         rc = supported_feature_load( &slap_FEATURE_CANCHAINOPS );
 963         if ( rc != LDAP_SUCCESS ) {
 964                 Debug( LDAP_DEBUG_ANY, "slapd-distproc: "
 965                         "unable to register canChainOperations supported feature: %d.\n",
 966                         rc, 0, 0 );
 967                 return rc;
 968         }
 969
 970         rc = register_supported_control( LDAP_CONTROL_X_RETURNCONTREF,
 971                         SLAP_CTRL_GLOBAL|SLAP_CTRL_ACCESS|SLAP_CTRL_HIDE, NULL,
 972                         ldap_distproc_parse_returnContRef_ctrl, &sc_returnContRef );
 973         if ( rc != LDAP_SUCCESS ) {
 974                 Debug( LDAP_DEBUG_ANY, "slapd-distproc: "
 975                         "unable to register returnContinuationReference control: %d.\n",
 976                         rc, 0, 0 );
 977                 return rc;
 978         }
 979
 980         distproc.on_bi.bi_type = "distproc";
 981         distproc.on_bi.bi_db_init = ldap_distproc_db_init;
 982         distproc.on_bi.bi_db_config = ldap_distproc_db_config;
 983         distproc.on_bi.bi_db_open = ldap_distproc_db_open;
 984         distproc.on_bi.bi_db_close = ldap_distproc_db_close;
 985         distproc.on_bi.bi_db_destroy = ldap_distproc_db_destroy;
 986
 987         /* ... otherwise the underlying backend's function would be called,
 988          * likely passing an invalid entry; on the contrary, the requested
 989          * operational attributes should have been returned while chasing
 990          * the referrals.  This all in all is a bit messy, because part
 991          * of the operational attributes are generated by the backend;
 992          * part by the frontend; back-ldap should receive all the available
 993          * ones from the remote server, but then, on its own, it strips those
 994          * it assumes will be (re)generated by the frontend (e.g.
 995          * subschemaSubentry, entryDN, ...) */
 996         distproc.on_bi.bi_operational = ldap_distproc_operational;
 997
 998         distproc.on_bi.bi_connection_destroy = ldap_distproc_connection_destroy;
 999
1000         distproc.on_response = ldap_distproc_response;
1001
1002         distproc.on_bi.bi_cf_ocs = distproc_ocs;
1003
1004         rc = config_register_schema( distproc_cfg, distproc_ocs );
1005         if ( rc ) {
1006                 return rc;
1007         }
1008
1009         return overlay_register( &distproc );
1010 }
1011
1012 #endif /* SLAP_DISTPROC */