Back to index

openldap  2.4.31
Functions
unbind.c File Reference
#include "portable.h"
#include <stdio.h>
#include <ac/stdlib.h>
#include <ac/socket.h>
#include <ac/string.h>
#include <ac/time.h>
#include "ldap-int.h"

Go to the source code of this file.

Functions

int ldap_unbind_ext (LDAP *ld, LDAPControl **sctrls, LDAPControl **cctrls)
int ldap_unbind_ext_s (LDAP *ld, LDAPControl **sctrls, LDAPControl **cctrls)
int ldap_unbind (LDAP *ld)
int ldap_ld_free (LDAP *ld, int close, LDAPControl **sctrls, LDAPControl **cctrls)
int ldap_destroy (LDAP *ld)
int ldap_unbind_s (LDAP *ld)
int ldap_send_unbind (LDAP *ld, Sockbuf *sb, LDAPControl **sctrls, LDAPControl **cctrls)

Function Documentation

int ldap_destroy ( LDAP *  ld)

Definition at line 242 of file unbind.c.

{
       return ( ldap_ld_free( ld, 1, NULL, NULL ) );
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ldap_ld_free ( LDAP *  ld,
int  close,
LDAPControl **  sctrls,
LDAPControl **  cctrls 
)

Definition at line 74 of file unbind.c.

{
       LDAPMessage   *lm, *next;
       int           err = LDAP_SUCCESS;

       LDAP_MUTEX_LOCK( &ld->ld_ldcmutex );
       /* Someone else is still using this ld. */
       if (ld->ld_ldcrefcnt > 1) { /* but not last thread */
              /* clean up self only */
              ld->ld_ldcrefcnt--;
              if ( ld->ld_error != NULL ) {
                     LDAP_FREE( ld->ld_error );
                     ld->ld_error = NULL;
              }

              if ( ld->ld_matched != NULL ) {
                     LDAP_FREE( ld->ld_matched );
                     ld->ld_matched = NULL;
              }
              if ( ld->ld_referrals != NULL) {
                     LDAP_VFREE(ld->ld_referrals);
                     ld->ld_referrals = NULL;
              }  
              LDAP_MUTEX_UNLOCK( &ld->ld_ldcmutex );
              LDAP_FREE( (char *) ld );
              return( err );
       }

       /* This ld is the last thread. */

       /* free LDAP structure and outstanding requests/responses */
       LDAP_MUTEX_LOCK( &ld->ld_req_mutex );
       while ( ld->ld_requests != NULL ) {
              ldap_free_request( ld, ld->ld_requests );
       }
       LDAP_MUTEX_UNLOCK( &ld->ld_req_mutex );
       LDAP_MUTEX_LOCK( &ld->ld_conn_mutex );

       /* free and unbind from all open connections */
       while ( ld->ld_conns != NULL ) {
              ldap_free_connection( ld, ld->ld_conns, 1, close );
       }
       LDAP_MUTEX_UNLOCK( &ld->ld_conn_mutex );
       LDAP_MUTEX_LOCK( &ld->ld_res_mutex );
       for ( lm = ld->ld_responses; lm != NULL; lm = next ) {
              next = lm->lm_next;
              ldap_msgfree( lm );
       }
    
       if ( ld->ld_abandoned != NULL ) {
              LDAP_FREE( ld->ld_abandoned );
              ld->ld_abandoned = NULL;
       }
       LDAP_MUTEX_UNLOCK( &ld->ld_res_mutex );
       LDAP_MUTEX_LOCK( &ld->ld_ldopts_mutex );

       /* final close callbacks */
       {
              ldaplist *ll, *next;

              for ( ll = ld->ld_options.ldo_conn_cbs; ll; ll = next ) {
                     ldap_conncb *cb = ll->ll_data;
                     next = ll->ll_next;
                     cb->lc_del( ld, NULL, cb );
                     LDAP_FREE( ll );
              }
       }

       if ( ld->ld_error != NULL ) {
              LDAP_FREE( ld->ld_error );
              ld->ld_error = NULL;
       }

       if ( ld->ld_matched != NULL ) {
              LDAP_FREE( ld->ld_matched );
              ld->ld_matched = NULL;
       }

       if ( ld->ld_referrals != NULL) {
              LDAP_VFREE(ld->ld_referrals);
              ld->ld_referrals = NULL;
       }  
    
       if ( ld->ld_selectinfo != NULL ) {
              ldap_free_select_info( ld->ld_selectinfo );
              ld->ld_selectinfo = NULL;
       }

       if ( ld->ld_options.ldo_defludp != NULL ) {
              ldap_free_urllist( ld->ld_options.ldo_defludp );
              ld->ld_options.ldo_defludp = NULL;
       }

#ifdef LDAP_CONNECTIONLESS
       if ( ld->ld_options.ldo_peer != NULL ) {
              LDAP_FREE( ld->ld_options.ldo_peer );
              ld->ld_options.ldo_peer = NULL;
       }

       if ( ld->ld_options.ldo_cldapdn != NULL ) {
              LDAP_FREE( ld->ld_options.ldo_cldapdn );
              ld->ld_options.ldo_cldapdn = NULL;
       }
#endif

#ifdef HAVE_CYRUS_SASL
       if ( ld->ld_options.ldo_def_sasl_mech != NULL ) {
              LDAP_FREE( ld->ld_options.ldo_def_sasl_mech );
              ld->ld_options.ldo_def_sasl_mech = NULL;
       }

       if ( ld->ld_options.ldo_def_sasl_realm != NULL ) {
              LDAP_FREE( ld->ld_options.ldo_def_sasl_realm );
              ld->ld_options.ldo_def_sasl_realm = NULL;
       }

       if ( ld->ld_options.ldo_def_sasl_authcid != NULL ) {
              LDAP_FREE( ld->ld_options.ldo_def_sasl_authcid );
              ld->ld_options.ldo_def_sasl_authcid = NULL;
       }

       if ( ld->ld_options.ldo_def_sasl_authzid != NULL ) {
              LDAP_FREE( ld->ld_options.ldo_def_sasl_authzid );
              ld->ld_options.ldo_def_sasl_authzid = NULL;
       }
#endif

#ifdef HAVE_TLS
       ldap_int_tls_destroy( &ld->ld_options );
#endif

       if ( ld->ld_options.ldo_sctrls != NULL ) {
              ldap_controls_free( ld->ld_options.ldo_sctrls );
              ld->ld_options.ldo_sctrls = NULL;
       }

       if ( ld->ld_options.ldo_cctrls != NULL ) {
              ldap_controls_free( ld->ld_options.ldo_cctrls );
              ld->ld_options.ldo_cctrls = NULL;
       }
       LDAP_MUTEX_UNLOCK( &ld->ld_ldopts_mutex );

       ber_sockbuf_free( ld->ld_sb );   
   
#ifdef LDAP_R_COMPILE
       ldap_pvt_thread_mutex_destroy( &ld->ld_msgid_mutex );
       ldap_pvt_thread_mutex_destroy( &ld->ld_conn_mutex );
       ldap_pvt_thread_mutex_destroy( &ld->ld_req_mutex );
       ldap_pvt_thread_mutex_destroy( &ld->ld_res_mutex );
       ldap_pvt_thread_mutex_destroy( &ld->ld_abandon_mutex );
       ldap_pvt_thread_mutex_destroy( &ld->ld_ldopts_mutex );
       ldap_pvt_thread_mutex_unlock( &ld->ld_ldcmutex );
       ldap_pvt_thread_mutex_destroy( &ld->ld_ldcmutex );
#endif
#ifndef NDEBUG
       LDAP_TRASH(ld);
#endif
       LDAP_FREE( (char *) ld->ldc );
       LDAP_FREE( (char *) ld );
   
       return( err );
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ldap_send_unbind ( LDAP *  ld,
Sockbuf *  sb,
LDAPControl **  sctrls,
LDAPControl **  cctrls 
)

Definition at line 256 of file unbind.c.

{
       BerElement    *ber;
       ber_int_t     id;

       Debug( LDAP_DEBUG_TRACE, "ldap_send_unbind\n", 0, 0, 0 );

#ifdef LDAP_CONNECTIONLESS
       if (LDAP_IS_UDP(ld))
              return LDAP_SUCCESS;
#endif
       /* create a message to send */
       if ( (ber = ldap_alloc_ber_with_options( ld )) == NULL ) {
              return( ld->ld_errno );
       }

       LDAP_NEXT_MSGID(ld, id);

       /* fill it in */
       if ( ber_printf( ber, "{itn" /*}*/, id,
           LDAP_REQ_UNBIND ) == -1 ) {
              ld->ld_errno = LDAP_ENCODING_ERROR;
              ber_free( ber, 1 );
              return( ld->ld_errno );
       }

       /* Put Server Controls */
       if( ldap_int_put_controls( ld, sctrls, ber ) != LDAP_SUCCESS ) {
              ber_free( ber, 1 );
              return ld->ld_errno;
       }

       if ( ber_printf( ber, /*{*/ "N}", LDAP_REQ_UNBIND ) == -1 ) {
              ld->ld_errno = LDAP_ENCODING_ERROR;
              ber_free( ber, 1 );
              return( ld->ld_errno );
       }

       ld->ld_errno = LDAP_SUCCESS;
       /* send the message */
       if ( ber_flush2( sb, ber, LBER_FLUSH_FREE_ALWAYS ) == -1 ) {
              ld->ld_errno = LDAP_SERVER_DOWN;
       }

       return( ld->ld_errno );
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ldap_unbind ( LDAP *  ld)

Definition at line 65 of file unbind.c.

{
       Debug( LDAP_DEBUG_TRACE, "ldap_unbind\n", 0, 0, 0 );

       return( ldap_unbind_ext( ld, NULL, NULL ) );
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ldap_unbind_ext ( LDAP *  ld,
LDAPControl **  sctrls,
LDAPControl **  cctrls 
)

Definition at line 38 of file unbind.c.

{
       int rc;

       assert( ld != NULL );
       assert( LDAP_VALID( ld ) );

       /* check client controls */
       rc = ldap_int_client_controls( ld, cctrls );
       if( rc != LDAP_SUCCESS ) return rc;

       return ldap_ld_free( ld, 1, sctrls, cctrls );
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ldap_unbind_ext_s ( LDAP *  ld,
LDAPControl **  sctrls,
LDAPControl **  cctrls 
)

Definition at line 56 of file unbind.c.

{
       return ldap_unbind_ext( ld, sctrls, cctrls );
}

Here is the call graph for this function:

int ldap_unbind_s ( LDAP *  ld)

Definition at line 248 of file unbind.c.

{
       return( ldap_unbind_ext( ld, NULL, NULL ) );
}

Here is the call graph for this function: