Diff for /servers/slapd/back-ldap/chain.c between versions 1.12.2.4 and 1.12.2.5

version 1.12.2.4, 2005/02/02 17:32:44 version 1.12.2.5, 2005/03/14 22:25:00
Line 1 Line 1
 /* chain.c - chain LDAP operations */  /* chain.c - chain LDAP operations */
 /* $OpenLDAP: pkg/ldap/servers/slapd/back-ldap/chain.c,v 1.12.2.3 2005/01/28 17:29:49 kurt Exp $ */  /* $OpenLDAP: pkg/ldap/servers/slapd/back-ldap/chain.c,v 1.12.2.4 2005/02/02 17:32:44 kurt Exp $ */
 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.  /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
  *   *
  * Copyright 2003-2005 The OpenLDAP Foundation.   * Copyright 2003-2005 The OpenLDAP Foundation.
Line 30 Line 30
 #include "back-ldap.h"  #include "back-ldap.h"
   
 #ifdef LDAP_CONTROL_X_CHAINING_BEHAVIOR  #ifdef LDAP_CONTROL_X_CHAINING_BEHAVIOR
   #define SLAP_CHAINING_DEFAULT                           LDAP_CHAINING_PREFERRED
 #define SLAP_CH_RESOLVE_SHIFT                           SLAP_CONTROL_SHIFT  #define SLAP_CH_RESOLVE_SHIFT                           SLAP_CONTROL_SHIFT
 #define SLAP_CH_RESOLVE_MASK                            (0x3 << SLAP_CH_RESOLVE_SHIFT)  #define SLAP_CH_RESOLVE_MASK                            (0x3 << SLAP_CH_RESOLVE_SHIFT)
 #define SLAP_CH_RESOLVE_CHAINING_PREFERRED              (LDAP_CHAINING_PREFERRED << SLAP_CH_RESOLVE_SHIFT)  #define SLAP_CH_RESOLVE_CHAINING_PREFERRED              (LDAP_CHAINING_PREFERRED << SLAP_CH_RESOLVE_SHIFT)
 #define SLAP_CH_RESOLVE_CHAINING_REQUIRED               (LDAP_CHAINING_REQUIRED << SLAP_CH_RESOLVE_SHIFT)  #define SLAP_CH_RESOLVE_CHAINING_REQUIRED               (LDAP_CHAINING_REQUIRED << SLAP_CH_RESOLVE_SHIFT)
 #define SLAP_CH_RESOLVE_REFERRALS_PREFERRED             (LDAP_REFERRALS_PREFERRED << SLAP_CH_RESOLVE_SHIFT)  #define SLAP_CH_RESOLVE_REFERRALS_PREFERRED             (LDAP_REFERRALS_PREFERRED << SLAP_CH_RESOLVE_SHIFT)
 #define SLAP_CH_RESOLVE_REFERRALS_REQUIRED              (LDAP_REFERRALS_REQUIRED << SLAP_CH_RESOLVE_SHIFT)  #define SLAP_CH_RESOLVE_REFERRALS_REQUIRED              (LDAP_REFERRALS_REQUIRED << SLAP_CH_RESOLVE_SHIFT)
 #define SLAP_CH_RESOLVE_DEFAULT                         SLAP_CH_RESOLVE_CHAINING_PREFERRED  #define SLAP_CH_RESOLVE_DEFAULT                         (SLAP_CHAINING_DEFAULT << SLAP_CH_RESOLVE_SHIFT)
 #define SLAP_CH_CONTINUATION_SHIFT                      (SLAP_CH_RESOLVE_SHIFT + 2)  #define SLAP_CH_CONTINUATION_SHIFT                      (SLAP_CH_RESOLVE_SHIFT + 2)
 #define SLAP_CH_CONTINUATION_MASK                       (0x3 << SLAP_CH_CONTINUATION_SHIFT)  #define SLAP_CH_CONTINUATION_MASK                       (0x3 << SLAP_CH_CONTINUATION_SHIFT)
 #define SLAP_CH_CONTINUATION_CHAINING_PREFERRED         (LDAP_CHAINING_PREFERRED << SLAP_CH_CONTINUATION_SHIFT)  #define SLAP_CH_CONTINUATION_CHAINING_PREFERRED         (LDAP_CHAINING_PREFERRED << SLAP_CH_CONTINUATION_SHIFT)
 #define SLAP_CH_CONTINUATION_CHAINING_REQUIRED          (LDAP_CHAINING_REQUIRED << SLAP_CH_CONTINUATION_SHIFT)  #define SLAP_CH_CONTINUATION_CHAINING_REQUIRED          (LDAP_CHAINING_REQUIRED << SLAP_CH_CONTINUATION_SHIFT)
 #define SLAP_CH_CONTINUATION_REFERRALS_PREFERRED        (LDAP_REFERRALS_PREFERRED << SLAP_CH_CONTINUATION_SHIFT)  #define SLAP_CH_CONTINUATION_REFERRALS_PREFERRED        (LDAP_REFERRALS_PREFERRED << SLAP_CH_CONTINUATION_SHIFT)
 #define SLAP_CH_CONTINUATION_REFERRALS_REQUIRED         (LDAP_REFERRALS_REQUIRED << SLAP_CH_CONTINUATION_SHIFT)  #define SLAP_CH_CONTINUATION_REFERRALS_REQUIRED         (LDAP_REFERRALS_REQUIRED << SLAP_CH_CONTINUATION_SHIFT)
 #define SLAP_CH_CONTINUATION_DEFAULT                    SLAP_CH_CONTINUATION_CHAINING_PREFERRED  #define SLAP_CH_CONTINUATION_DEFAULT                    (SLAP_CHAINING_DEFAULT << SLAP_CH_CONTINUATION_SHIFT)
   
 #define o_chaining                      o_ctrlflag[sc_chainingBehavior]  #define o_chaining                      o_ctrlflag[sc_chainingBehavior]
 #define get_chaining(op)                ((op)->o_chaining & SLAP_CONTROL_MASK)  #define get_chaining(op)                ((op)->o_chaining & SLAP_CONTROL_MASK)
 #define get_chainingBehavior(op)        ((op)->o_chaining & (SLAP_CH_RESOLVE_MASK|SLAP_CH_CONTINUATION_MASK))  #define get_chainingBehavior(op)        ((op)->o_chaining & (SLAP_CH_RESOLVE_MASK|SLAP_CH_CONTINUATION_MASK))
 #define get_resolveBehavior(op)         ((op)->o_chaining & SLAP_CH_RESOLVE_MASK)  #define get_resolveBehavior(op)         ((op)->o_chaining & SLAP_CH_RESOLVE_MASK)
 #define get_continuationBehavior(op)    ((op)->o_chaining & SLAP_CH_CONTINUATION_MASK)  #define get_continuationBehavior(op)    ((op)->o_chaining & SLAP_CH_CONTINUATION_MASK)
   
   static int              sc_chainingBehavior;
 #endif /*  LDAP_CONTROL_X_CHAINING_BEHAVIOR */  #endif /*  LDAP_CONTROL_X_CHAINING_BEHAVIOR */
   
 #define LDAP_CH_NONE                    ((void *)(0))  #define LDAP_CH_NONE                    ((void *)(0))
 #define LDAP_CH_RES                     ((void *)(1))  #define LDAP_CH_RES                     ((void *)(1))
 #define LDAP_CH_ERR                     ((void *)(2))  #define LDAP_CH_ERR                     ((void *)(2))
   
 static int              sc_chainingBehavior;  
 static BackendInfo      *lback;  static BackendInfo      *lback;
   
   typedef struct ldap_chain_t {
           struct ldapinfo         *lc_li;
           unsigned                lc_flags;
   #define LDAP_CHAIN_F_NONE               0x00U
   #define LDAP_CHAIN_F_CHAINING           0x01U
   
   #ifdef LDAP_CONTROL_X_CHAINING_BEHAVIOR
           LDAPControl             lc_chaining_ctrl;
           char                    lc_chaining_ctrlflag;
   #endif /* LDAP_CONTROL_X_CHAINING_BEHAVIOR */
   } ldap_chain_t;
   
   #ifdef LDAP_CONTROL_X_CHAINING_BEHAVIOR
   static int
   chaining_control_add(
                   ldap_chain_t    *lc,
                   Operation       *op, 
                   LDAPControl     ***oldctrlsp )
   {
           LDAPControl     **ctrls = NULL;
           int             c = 0;
   
           *oldctrlsp = op->o_ctrls;
   
           /* default chaining control not defined */
           if ( !( lc->lc_flags & LDAP_CHAIN_F_CHAINING ) ) {
                   return 0;
           }
   
           /* already present */
           if ( get_chaining( op ) > SLAP_CONTROL_IGNORED ) {
                   return 0;
           }
   
           /* FIXME: check other incompatibilities */
   
           /* add to other controls */
           if ( op->o_ctrls ) {
                   for ( c = 0; op->o_ctrls[ c ]; c++ )
                           /* count them */ ;
           }
   
           ctrls = ch_calloc( sizeof( LDAPControl *), c + 2 );
           ctrls[ 0 ] = &lc->lc_chaining_ctrl;
           if ( op->o_ctrls ) {
                   for ( c = 0; op->o_ctrls[ c ]; c++ ) {
                           ctrls[ c + 1 ] = op->o_ctrls[ c ];
                   }
           }
           ctrls[ c + 1 ] = NULL;
   
           op->o_ctrls = ctrls;
   
           op->o_chaining = lc->lc_chaining_ctrlflag;
   
           return 0;
   }
   
   static int
   chaining_control_remove(
                   Operation       *op, 
                   LDAPControl     ***oldctrlsp )
   {
           LDAPControl     **oldctrls = *oldctrlsp;
   
           /* we assume that the first control is the chaining control
            * added by the chain overlay, so it's the only one we explicitly 
            * free */
           if ( op->o_ctrls != oldctrls ) {
                   assert( op->o_ctrls );
                   assert( op->o_ctrls[ 0 ] );
   
                   free( op->o_ctrls );
   
                   op->o_chaining = 0;
                   op->o_ctrls = oldctrls;
           } 
   
           *oldctrlsp = NULL;
   
           return 0;
   }
   #endif /* LDAP_CONTROL_X_CHAINING_BEHAVIOR */
   
 static int  static int
 ldap_chain_operational( Operation *op, SlapReply *rs )  ldap_chain_operational( Operation *op, SlapReply *rs )
 {  {
Line 170  ldap_chain_op( Line 256  ldap_chain_op(
         BerVarray       ref )          BerVarray       ref )
 {  {
         slap_overinst   *on = (slap_overinst *) op->o_bd->bd_info;          slap_overinst   *on = (slap_overinst *) op->o_bd->bd_info;
         struct ldapinfo li, *lip = (struct ldapinfo *)on->on_bi.bi_private;          ldap_chain_t    *lc = (ldap_chain_t *)on->on_bi.bi_private;
           struct ldapinfo li, *lip = lc->lc_li;
   
         /* NOTE: returned if ref is empty... */          /* NOTE: returned if ref is empty... */
         int             rc = LDAP_OTHER;          int             rc = LDAP_OTHER;
   
   #ifdef LDAP_CONTROL_X_CHAINING_BEHAVIOR
           LDAPControl     **ctrls = NULL;
           
           (void)chaining_control_add( lc, op, &ctrls );
   #endif /* LDAP_CONTROL_X_CHAINING_BEHAVIOR */
   
         if ( lip->url != NULL ) {          if ( lip->url != NULL ) {
                 op->o_bd->be_private = on->on_bi.bi_private;                  op->o_bd->be_private = lip;
                 return ( *op_f )( op, rs );                  rc = ( *op_f )( op, rs );
                   goto done;
         }          }
   
         li = *lip;          li = *lip;
Line 245  Document: draft-ietf-ldapbis-protocol-27 Line 339  Document: draft-ietf-ldapbis-protocol-27
                 }                  }
         }          }
   
   done:;
   #ifdef LDAP_CONTROL_X_CHAINING_BEHAVIOR
           (void)chaining_control_remove( op, &ctrls );
   #endif /* LDAP_CONTROL_X_CHAINING_BEHAVIOR */
   
         return rc;          return rc;
 }  }
   
Line 260  ldap_chain_response( Operation *op, Slap Line 359  ldap_chain_response( Operation *op, Slap
         BerVarray       ref;          BerVarray       ref;
         struct berval   ndn = op->o_ndn;          struct berval   ndn = op->o_ndn;
   
         struct ldapinfo li, *lip = (struct ldapinfo *)on->on_bi.bi_private;          ldap_chain_t    *lc = (ldap_chain_t *)on->on_bi.bi_private;
           struct ldapinfo li, *lip = lc->lc_li;
   
 #ifdef LDAP_CONTROL_X_CHAINING_BEHAVIOR  #ifdef LDAP_CONTROL_X_CHAINING_BEHAVIOR
         int             sr_err = rs->sr_err;          int             sr_err = rs->sr_err;
Line 394  ldap_chain_response( Operation *op, Slap Line 494  ldap_chain_response( Operation *op, Slap
                                         odn = op->o_req_dn,                                          odn = op->o_req_dn,
                                         ondn = op->o_req_ndn;                                          ondn = op->o_req_ndn;
   
   #ifdef LDAP_CONTROL_X_CHAINING_BEHAVIOR
                           LDAPControl     **ctrls = NULL;
           
                           (void)chaining_control_add( lc, op, &ctrls );
   #endif /* LDAP_CONTROL_X_CHAINING_BEHAVIOR */
   
                         rs->sr_type = REP_SEARCH;                          rs->sr_type = REP_SEARCH;
   
                         sc2.sc_response = ldap_chain_cb_search_response;                          sc2.sc_response = ldap_chain_cb_search_response;
Line 466  ldap_chain_response( Operation *op, Slap Line 572  ldap_chain_response( Operation *op, Slap
                                 rc = rs->sr_err;                                  rc = rs->sr_err;
                         }                          }
   
   #ifdef LDAP_CONTROL_X_CHAINING_BEHAVIOR
                           (void)chaining_control_remove( op, &ctrls );
   #endif /* LDAP_CONTROL_X_CHAINING_BEHAVIOR */
   
                         op->o_req_dn = odn;                          op->o_req_dn = odn;
                         op->o_req_ndn = ondn;                          op->o_req_ndn = ondn;
                         rs->sr_type = REP_SEARCHREF;                          rs->sr_type = REP_SEARCHREF;
Line 536  dont_chain:; Line 646  dont_chain:;
         return rc;          return rc;
 }  }
   
   #ifdef LDAP_CONTROL_X_CHAINING_BEHAVIOR
   static int
   ldap_chain_parse_ctrl(
           Operation       *op,
           SlapReply       *rs,
           LDAPControl     *ctrl );
   
   static int
   str2chain( const char *s )
   {
           if ( strcasecmp( s, "chainingPreferred" ) == 0 ) {
                   return LDAP_CHAINING_PREFERRED;
                   
           } else if ( strcasecmp( s, "chainingRequired" ) == 0 ) {
                   return LDAP_CHAINING_REQUIRED;
   
           } else if ( strcasecmp( s, "referralsPreferred" ) == 0 ) {
                   return LDAP_REFERRALS_PREFERRED;
                   
           } else if ( strcasecmp( s, "referralsRequired" ) == 0 ) {
                   return LDAP_REFERRALS_REQUIRED;
           }
   
           return -1;
   }
   #endif /* LDAP_CONTROL_X_CHAINING_BEHAVIOR */
   
 static int  static int
 ldap_chain_db_config(  ldap_chain_db_config(
         BackendDB       *be,          BackendDB       *be,
Line 546  ldap_chain_db_config( Line 683  ldap_chain_db_config(
 )  )
 {  {
         slap_overinst   *on = (slap_overinst *) be->bd_info;          slap_overinst   *on = (slap_overinst *) be->bd_info;
           ldap_chain_t    *lc = (ldap_chain_t *)on->on_bi.bi_private;
         void            *private = be->be_private;          void            *private = be->be_private;
         char            *argv0 = NULL;          char            *argv0 = NULL;
         int             rc;          int             rc;
   
         be->be_private = on->on_bi.bi_private;  
         if ( strncasecmp( argv[ 0 ], "chain-", STRLENOF( "chain-" ) ) == 0 ) {          if ( strncasecmp( argv[ 0 ], "chain-", STRLENOF( "chain-" ) ) == 0 ) {
                 argv0 = argv[ 0 ];                  argv0 = argv[ 0 ];
                 argv[ 0 ] = &argv[ 0 ][ STRLENOF( "chain-" ) ];                  argv[ 0 ] = &argv[ 0 ][ STRLENOF( "chain-" ) ];
   
   #ifdef LDAP_CONTROL_X_CHAINING_BEHAVIOR
                   if ( strcasecmp( argv[ 0 ], "chaining" ) == 0 ) {
                           char                    **tmpargv = argv;
                           BerElementBuffer        berbuf;
                           BerElement              *ber = (BerElement *)&berbuf;
                           int                     resolve = -1,
                                                   continuation = -1,
                                                   iscritical = 0;
                           Operation               op = { 0 };
                           SlapReply               rs = { 0 };
   
                           lc->lc_chaining_ctrlflag = 0;
   
                           for ( argc--, tmpargv++; argc > 0; argc--, tmpargv++ ) {
                                   if ( strncasecmp( tmpargv[ 0 ], "resolve=", STRLENOF( "resolve=" ) ) == 0 ) {
                                           resolve = str2chain( tmpargv[ 0 ] + STRLENOF( "resolve=" ) );
                                           if ( resolve == -1 ) {
                                                   fprintf( stderr, "%s line %d: "
                                                           "illegal <resolve> value %s "
                                                           "in \"chain-chaining>\"\n",
                                                           fname, lineno, tmpargv[ 0 ] );
                                                   return 1;
                                           }
   
                                   } else if ( strncasecmp( tmpargv[ 0 ], "continuation=", STRLENOF( "continuation=" ) ) == 0 ) {
                                           continuation = str2chain( tmpargv[ 0 ] + STRLENOF( "continuation=" ) );
                                           if ( continuation == -1 ) {
                                                   fprintf( stderr, "%s line %d: "
                                                           "illegal <continuation> value %s "
                                                           "in \"chain-chaining\"\n",
                                                           fname, lineno, tmpargv[ 0 ] );
                                                   return 1;
                                           }
   
                                   } else if ( strcasecmp( tmpargv[ 0 ], "critical" ) == 0 ) {
                                           iscritical = 1;
   
                                   } else {
                                           fprintf( stderr, "%s line %d: "
                                                   "unknown option in \"chain-chaining\"\n",
                                                   fname, lineno );
                                           return 1;
                                   }
                           }
   
                           if ( resolve != -1 || continuation != -1 ) {
                                   int     err;
   
                                   if ( resolve == -1 ) {
                                           /* default */
                                           resolve = SLAP_CHAINING_DEFAULT;
                                   }
   
                                   ber_init2( ber, NULL, LBER_USE_DER );
   
                                   err = ber_printf( ber, "{e" /* } */, resolve );
                                   if ( err == -1 ) {
                                           ber_free( ber, 1 );
                                           fprintf( stderr, "%s line %d: "
                                                   "chaining behavior control encoding error!\n",
                                                   fname, lineno );
                                           return 1;
                                   }
   
                                   if ( continuation > -1 ) {
                                           err = ber_printf( ber, "e", continuation );
                                           if ( err == -1 ) {
                                                   ber_free( ber, 1 );
                                                   fprintf( stderr, "%s line %d: "
                                                           "chaining behavior control encoding error!\n",
                                                           fname, lineno );
                                                   return 1;
                                           }
                                   }
   
                                   err = ber_printf( ber, /* { */ "N}" );
                                   if ( err == -1 ) {
                                           ber_free( ber, 1 );
                                           fprintf( stderr, "%s line %d: "
                                                   "chaining behavior control encoding error!\n",
                                                   fname, lineno );
                                           return 1;
                                   }
   
                                   if ( ber_flatten2( ber, &lc->lc_chaining_ctrl.ldctl_value, 0 ) == -1 ) {
                                           exit( EXIT_FAILURE );
                                   }
   
                           } else {
                                   BER_BVZERO( &lc->lc_chaining_ctrl.ldctl_value );
                           }
   
                           lc->lc_chaining_ctrl.ldctl_oid = LDAP_CONTROL_X_CHAINING_BEHAVIOR;
                           lc->lc_chaining_ctrl.ldctl_iscritical = iscritical;
   
                           if ( ldap_chain_parse_ctrl( &op, &rs, &lc->lc_chaining_ctrl ) != LDAP_SUCCESS )
                           {
                                   fprintf( stderr, "%s line %d: "
                                           "unable to parse chaining control%s%s\n",
                                           fname, lineno,
                                           rs.sr_text ? ": " : "",
                                           rs.sr_text ? rs.sr_text : "" );
                                   return 1;
                           }
   
                           lc->lc_chaining_ctrlflag = op.o_chaining;
   
                           lc->lc_flags |= LDAP_CHAIN_F_CHAINING;
   
                           rc = 0;
                           goto done;
                   }
   #endif /* LDAP_CONTROL_X_CHAINING_BEHAVIOR */
         }          }
   
   
           be->be_private = lc->lc_li;
         rc = lback->bi_db_config( be, fname, lineno, argc, argv );          rc = lback->bi_db_config( be, fname, lineno, argc, argv );
           be->be_private = private;
   
   done:;
         if ( argv0 ) {          if ( argv0 ) {
                 argv[ 0 ] = argv0;                  argv[ 0 ] = argv0;
         }          }
           
         be->be_private = private;  
         return rc;          return rc;
 }  }
   
Line 570  ldap_chain_db_init( Line 826  ldap_chain_db_init(
 )  )
 {  {
         slap_overinst   *on = (slap_overinst *)be->bd_info;          slap_overinst   *on = (slap_overinst *)be->bd_info;
           ldap_chain_t    *lc = NULL;
         int             rc;          int             rc;
         BackendDB       bd = *be;          BackendDB       bd = *be;
   
Line 581  ldap_chain_db_init( Line 838  ldap_chain_db_init(
                 }                  }
         }          }
   
           lc = ch_malloc( sizeof( ldap_chain_t ) );
           memset( lc, 0, sizeof( ldap_chain_t ) );
   
         bd.be_private = NULL;          bd.be_private = NULL;
         rc = lback->bi_db_init( &bd );          rc = lback->bi_db_init( &bd );
         on->on_bi.bi_private = bd.be_private;          lc->lc_li = (struct ldapinfo *)bd.be_private;
           on->on_bi.bi_private = (void *)lc;
   
         return rc;          return rc;
 }  }
   
 #ifdef LDAP_CONTROL_X_CHAINING_BEHAVIOR  
 static int  static int
 ldap_chain_db_open(  ldap_chain_db_open(
         BackendDB *be          BackendDB *be
 )  )
 {  {
         return overlay_register_control( be, LDAP_CONTROL_X_CHAINING_BEHAVIOR );          int     rc = 0;
 }  
   #ifdef LDAP_CONTROL_X_CHAINING_BEHAVIOR
           rc = overlay_register_control( be, LDAP_CONTROL_X_CHAINING_BEHAVIOR );
 #endif /* LDAP_CONTROL_X_CHAINING_BEHAVIOR */  #endif /* LDAP_CONTROL_X_CHAINING_BEHAVIOR */
   
           return rc;
   }
   
 static int  static int
 ldap_chain_db_destroy(  ldap_chain_db_destroy(
         BackendDB *be          BackendDB *be
 )  )
 {  {
         slap_overinst *on = (slap_overinst *) be->bd_info;          slap_overinst   *on = (slap_overinst *) be->bd_info;
         void *private = be->be_private;          ldap_chain_t    *lc = (ldap_chain_t *)on->on_bi.bi_private;
         int rc;          void            *private = be->be_private;
           int             rc;
   
         be->be_private = on->on_bi.bi_private;          be->be_private = (void *)lc->lc_li;
         rc = lback->bi_db_destroy( be );          rc = lback->bi_db_destroy( be );
         on->on_bi.bi_private = be->be_private;          lc->lc_li = be->be_private;
           ch_free( lc );
           on->on_bi.bi_private = NULL;
         be->be_private = private;          be->be_private = private;
         return rc;          return rc;
 }  }
Line 620  ldap_chain_connection_destroy( Line 888  ldap_chain_connection_destroy(
         Connection *conn          Connection *conn
 )  )
 {  {
         slap_overinst *on = (slap_overinst *) be->bd_info;          slap_overinst   *on = (slap_overinst *) be->bd_info;
         void *private = be->be_private;          ldap_chain_t    *lc = (ldap_chain_t *)on->on_bi.bi_private;
         int rc;          void            *private = be->be_private;
           int             rc;
   
         be->be_private = on->on_bi.bi_private;          be->be_private = (void *)lc->lc_li;
         rc = lback->bi_connection_destroy( be, conn );          rc = lback->bi_connection_destroy( be, conn );
         on->on_bi.bi_private = be->be_private;  
         be->be_private = private;          be->be_private = private;
   
         return rc;          return rc;
 }  }
   
Line 778  chain_init( void ) Line 1047  chain_init( void )
   
         ldapchain.on_bi.bi_type = "chain";          ldapchain.on_bi.bi_type = "chain";
         ldapchain.on_bi.bi_db_init = ldap_chain_db_init;          ldapchain.on_bi.bi_db_init = ldap_chain_db_init;
 #ifdef LDAP_CONTROL_X_CHAINING_BEHAVIOR  
         ldapchain.on_bi.bi_db_open = ldap_chain_db_open;          ldapchain.on_bi.bi_db_open = ldap_chain_db_open;
 #endif /* LDAP_CONTROL_X_CHAINING_BEHAVIOR */  
         ldapchain.on_bi.bi_db_config = ldap_chain_db_config;          ldapchain.on_bi.bi_db_config = ldap_chain_db_config;
         ldapchain.on_bi.bi_db_destroy = ldap_chain_db_destroy;          ldapchain.on_bi.bi_db_destroy = ldap_chain_db_destroy;
   

Removed from v.1.12.2.4  
changed lines
  Added in v.1.12.2.5


______________
© Copyright 1998-2020, OpenLDAP Foundation, info@OpenLDAP.org