external/bsd/openldap/dist/servers/slapd/back-ldap/distproc.c

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