+/* $OpenLDAP$ */
/*
* Copyright 1998-1999 The OpenLDAP Foundation, All Rights Reserved.
* COPYING RESTRICTIONS APPLY, see COPYRIGHT file
#include "portable.h"
#include <stdio.h>
-#include <stdlib.h>
+
+#include <ac/stdlib.h>
#include <ac/errno.h>
#include <ac/socket.h>
#include <ac/unistd.h>
#include "ldap-int.h"
+#include "lber.h"
-#if defined( LDAP_API_FEATURE_X_OPENLDAP_V2_REFERRALS ) || defined( LDAP_API_FEATURE_X_OPENLDAP_V2_DNS )
static LDAPConn *find_connection LDAP_P(( LDAP *ld, LDAPServer *srv, int any ));
static void use_connection LDAP_P(( LDAP *ld, LDAPConn *lc ));
static void free_servers LDAP_P(( LDAPServer *srvlist ));
-#endif /* LDAP_API_FEATURE_X_OPENLDAP_V2_REFERRALS || LDAP_API_FEATURE_X_OPENLDAP_V2_DNS */
-
#ifdef LDAP_API_FEATURE_X_OPENLDAP_V2_DNS
-static LDAPServer *dn2servers LDAP_P(( LDAP *ld, char *dn ));
+static LDAPServer *dn2servers LDAP_P(( LDAP *ld, const char *dn ));
#endif /* LDAP_API_FEATURE_X_OPENLDAP_V2_DNS */
-#ifdef LDAP_API_FEATURE_X_OPENLDAP_V2_REFERRALS
-static BerElement *re_encode_request LDAP_P(( LDAP *ld, BerElement *origber,
- int msgid, char **dnp ));
-#endif /* LDAP_API_FEATURE_X_OPENLDAP_V2_REFERRALS */
+static BerElement *re_encode_request LDAP_P((
+ LDAP *ld,
+ BerElement *origber,
+ ber_int_t msgid,
+ char **dnp ));
BerElement *
{
BerElement *ber;
- if (( ber = ber_alloc_t( ld->ld_lberoptions )) == NULLBER ) {
+ if (( ber = ber_alloc_t( ld->ld_lberoptions )) == NULL ) {
ld->ld_errno = LDAP_NO_MEMORY;
#ifdef STR_TRANSLATION
} else {
}
-int
-ldap_send_initial_request( LDAP *ld, unsigned long msgtype, char *dn,
+ber_int_t
+ldap_send_initial_request(
+ LDAP *ld,
+ ber_tag_t msgtype,
+ const char *dn,
BerElement *ber )
{
-#if defined( LDAP_API_FEATURE_X_OPENLDAP_V2_REFERRALS ) || defined( LDAP_API_FEATURE_X_OPENLDAP_V2_DNS )
- LDAPServer *servers, *srv;
-#endif /* LDAP_API_FEATURE_X_OPENLDAP_V2_REFERRALS || LDAP_API_FEATURE_X_OPENLDAP_V2_DNS */
+ LDAPServer *servers;
Debug( LDAP_DEBUG_TRACE, "ldap_send_initial_request\n", 0, 0, 0 );
- if ( ! lber_pvt_sb_in_use(&ld->ld_sb ) ) {
+ if ( ! ber_pvt_sb_in_use(&ld->ld_sb ) ) {
/* not connected yet */
+ int rc = ldap_open_defconn( ld );
-#ifdef LDAP_API_FEATURE_X_OPENLDAP_V2_REFERRALS
- if (( srv = (LDAPServer *)calloc( 1, sizeof( LDAPServer ))) ==
- NULL || ( ld->ld_defhost != NULL && ( srv->lsrv_host =
- strdup( ld->ld_defhost )) == NULL ))
- {
- if (srv != NULL) free( srv );
- ld->ld_errno = LDAP_NO_MEMORY;
- return( -1 );
- }
-
- srv->lsrv_port = ld->ld_defport;
-
- if (( ld->ld_defconn = ldap_new_connection( ld, &srv, 1,1,0 ))
- == NULL )
- {
- if ( ld->ld_defhost != NULL ) free( srv->lsrv_host );
- free( (char *)srv );
- ld->ld_errno = LDAP_SERVER_DOWN;
- return( -1 );
- }
- ++ld->ld_defconn->lconn_refcnt; /* so it never gets closed/freed */
-
-#else /* LDAP_API_FEATURE_X_OPENLDAP_V2_REFERRALS */
- if ( open_ldap_connection( ld, &ld->ld_sb, ld->ld_defhost,
- ld->ld_defport, &ld->ld_host, 0 ) < 0 )
- {
- ldap_ld_free( ld, 0 );
- ld->ld_errno = LDAP_SERVER_DOWN;
+ if( rc < 0 ) {
+ ber_free( ber, 1 );
return( -1 );
}
-#endif /* LDAP_API_FEATURE_X_OPENLDAP_V2_REFERRALS */
Debug( LDAP_DEBUG_TRACE,
"ldap_delayed_open successful, ld_host is %s\n",
}
-#if !defined( LDAP_API_FEATURE_X_OPENLDAP_V2_REFERRALS ) && !defined( LDAP_API_FEATURE_X_OPENLDAP_V2_DNS )
-
- if ( ber_flush( &ld->ld_sb, ber, 1 ) != 0 ) {
- ld->ld_errno = LDAP_SERVER_DOWN;
- return( -1 );
- }
-
- ld->ld_errno = LDAP_SUCCESS;
- return( ld->ld_msgid );
-#else /* !LDAP_API_FEATURE_X_OPENLDAP_V2_REFERRALS && !LDAP_API_FEATURE_X_OPENLDAP_V2_DNS */
-
#ifdef LDAP_API_FEATURE_X_OPENLDAP_V2_DNS
- if (( LDAP_BOOL_GET(&ld->ld_options, LDAP_BOOL_DNS ) == LDAP_OPT_ON )
+ if ( LDAP_BOOL_GET(&ld->ld_options, LDAP_BOOL_DNS )
&& ldap_is_dns_dn( dn ) )
{
if (( servers = dn2servers( ld, dn )) == NULL ) {
}
}
#endif /* LDAP_DEBUG */
- } else {
+ } else
#endif /* LDAP_API_FEATURE_X_OPENLDAP_V2_DNS */
+ {
/*
* use of DNS is turned off or this is an X.500 DN...
* use our default connection
*/
servers = NULL;
-#ifdef LDAP_API_FEATURE_X_OPENLDAP_V2_DNS
}
-#endif /* LDAP_API_FEATURE_X_OPENLDAP_V2_DNS */
return( ldap_send_server_request( ld, ber, ld->ld_msgid, NULL, servers,
NULL, 0 ));
-#endif /* !LDAP_API_FEATURE_X_OPENLDAP_V2_REFERRALS && !LDAP_API_FEATURE_X_OPENLDAP_V2_DNS */
}
-#if defined( LDAP_API_FEATURE_X_OPENLDAP_V2_REFERRALS ) || defined( LDAP_API_FEATURE_X_OPENLDAP_V2_DNS )
int
-ldap_send_server_request( LDAP *ld, BerElement *ber, int msgid, LDAPRequest
- *parentreq, LDAPServer *srvlist, LDAPConn *lc, int bind )
+ldap_send_server_request(
+ LDAP *ld,
+ BerElement *ber,
+ ber_int_t msgid,
+ LDAPRequest *parentreq,
+ LDAPServer *srvlist,
+ LDAPConn *lc,
+ int bind )
{
LDAPRequest *lr;
int incparent;
}
use_connection( ld, lc );
- if (( lr = (LDAPRequest *)calloc( 1, sizeof( LDAPRequest ))) ==
+ if (( lr = (LDAPRequest *)LDAP_CALLOC( 1, sizeof( LDAPRequest ))) ==
NULL ) {
ld->ld_errno = LDAP_NO_MEMORY;
ldap_free_connection( ld, lc, 0, 0 );
* make a new LDAP server connection
* XXX open connection synchronously for now
*/
- if (( lc = (LDAPConn *)calloc( 1, sizeof( LDAPConn ))) == NULL ||
- ( !use_ldsb && ( (sb = lber_pvt_sb_alloc()) == NULL ))) {
+ if (( lc = (LDAPConn *)LDAP_CALLOC( 1, sizeof( LDAPConn ))) == NULL ||
+ ( !use_ldsb && ( (sb = ber_sockbuf_alloc()) == NULL ))) {
if ( lc != NULL ) {
- free( (char *)lc );
+ LDAP_FREE( (char *)lc );
}
ld->ld_errno = LDAP_NO_MEMORY;
return( NULL );
if ( srv == NULL ) {
if ( !use_ldsb ) {
- lber_pvt_sb_free( lc->lconn_sb );
+ ber_sockbuf_free( lc->lconn_sb );
}
- free( (char *)lc );
+ LDAP_FREE( (char *)lc );
ld->ld_errno = LDAP_SERVER_DOWN;
return( NULL );
}
use_connection( LDAP *ld, LDAPConn *lc )
{
++lc->lconn_refcnt;
- lc->lconn_lastused = time( 0 );
+ lc->lconn_lastused = time( NULL );
}
if ( lc->lconn_status == LDAP_CONNST_CONNECTED ) {
ldap_mark_select_clear( ld, lc->lconn_sb );
if ( unbind ) {
- ldap_send_unbind( ld, lc->lconn_sb );
+ ldap_send_unbind( ld, lc->lconn_sb, NULL, NULL );
}
- ldap_close_connection( lc->lconn_sb );
- lber_pvt_sb_destroy( lc->lconn_sb );
}
+
+ /* force closure */
+ ldap_close_connection( lc->lconn_sb );
+ ber_pvt_sb_destroy( lc->lconn_sb );
+
+ if( lc->lconn_ber != NULL ) {
+ ber_free( lc->lconn_ber, 1 );
+ }
+
prevlc = NULL;
for ( tmplc = ld->ld_conns; tmplc != NULL;
tmplc = tmplc->lconn_next ) {
}
free_servers( lc->lconn_server );
if ( lc->lconn_krbinstance != NULL ) {
- free( lc->lconn_krbinstance );
+ LDAP_FREE( lc->lconn_krbinstance );
}
if ( lc->lconn_sb != &ld->ld_sb ) {
- lber_pvt_sb_free( lc->lconn_sb );
+ ber_sockbuf_free( lc->lconn_sb );
}
- free( lc );
+ LDAP_FREE( lc );
Debug( LDAP_DEBUG_TRACE, "ldap_free_connection: actually freed\n",
0, 0, 0 );
} else {
- lc->lconn_lastused = time( 0 );
+ lc->lconn_lastused = time( NULL );
Debug( LDAP_DEBUG_TRACE, "ldap_free_connection: refcnt %d\n",
lc->lconn_refcnt, 0, 0 );
}
}
fprintf( stderr, "** Response Queue:\n" );
- if (( lm = ld->ld_responses ) == NULLMSG ) {
+ if (( lm = ld->ld_responses ) == NULL ) {
fprintf( stderr, " Empty\n" );
}
- for ( ; lm != NULLMSG; lm = lm->lm_next ) {
- fprintf( stderr, " * msgid %d, type %d\n",
- lm->lm_msgid, lm->lm_msgtype );
+ for ( ; lm != NULL; lm = lm->lm_next ) {
+ fprintf( stderr, " * msgid %d, type %lu\n",
+ lm->lm_msgid, (unsigned long) lm->lm_msgtype );
if (( l = lm->lm_chain ) != NULL ) {
fprintf( stderr, " chained responses:\n" );
- for ( ; l != NULLMSG; l = l->lm_chain ) {
+ for ( ; l != NULL; l = l->lm_chain ) {
fprintf( stderr,
- " * msgid %d, type %d\n",
- l->lm_msgid, l->lm_msgtype );
+ " * msgid %d, type %lu\n",
+ l->lm_msgid,
+ (unsigned long) l->lm_msgtype );
}
}
}
}
if ( lr->lr_res_error != NULL ) {
- free( lr->lr_res_error );
+ LDAP_FREE( lr->lr_res_error );
}
if ( lr->lr_res_matched != NULL ) {
- free( lr->lr_res_matched );
+ LDAP_FREE( lr->lr_res_matched );
}
- free( lr );
+ LDAP_FREE( lr );
}
while ( srvlist != NULL ) {
nextsrv = srvlist->lsrv_next;
if ( srvlist->lsrv_dn != NULL ) {
- free( srvlist->lsrv_dn );
+ LDAP_FREE( srvlist->lsrv_dn );
}
if ( srvlist->lsrv_host != NULL ) {
- free( srvlist->lsrv_host );
+ LDAP_FREE( srvlist->lsrv_host );
}
- free( srvlist );
+ LDAP_FREE( srvlist );
srvlist = nextsrv;
}
}
-#endif /* LDAP_API_FEATURE_X_OPENLDAP_V2_REFERRALS || LDAP_API_FEATURE_X_OPENLDAP_V2_DNS */
-#ifdef LDAP_API_FEATURE_X_OPENLDAP_V2_REFERRALS
/*
* XXX merging of errors in this routine needs to be improved
*/
#ifdef LDAP_API_FEATURE_X_OPENLDAP_V2_DNS
if ( ldapref ) {
#endif /* LDAP_API_FEATURE_X_OPENLDAP_V2_DNS */
- if (( srv = (LDAPServer *)calloc( 1,
+ if (( srv = (LDAPServer *)LDAP_CALLOC( 1,
sizeof( LDAPServer ))) == NULL ) {
ber_free( ber, 1 );
ld->ld_errno = LDAP_NO_MEMORY;
return( -1 );
}
- if (( srv->lsrv_host = strdup( tmpref )) == NULL ) {
- free( (char *)srv );
+ if (( srv->lsrv_host = LDAP_STRDUP( tmpref )) == NULL ) {
+ LDAP_FREE( (char *)srv );
ber_free( ber, 1 );
ld->ld_errno = LDAP_NO_MEMORY;
return( -1 );
*ports++ = '\0';
srv->lsrv_port = atoi( ports );
} else {
- srv->lsrv_port = openldap_ldap_global_options.ldo_defport;
+ srv->lsrv_port = ldap_int_global_options.ldo_defport;
}
#ifdef LDAP_API_FEATURE_X_OPENLDAP_V2_DNS
} else {
}
if ( !newdn && refdn != NULL ) {
- free( refdn );
+ LDAP_FREE( refdn );
}
}
- free( *errstrp );
+ LDAP_FREE( *errstrp );
*errstrp = unfollowed;
return(( rc == 0 ) ? count : rc );
if ( *referralsp == NULL ) {
first = 1;
- *referralsp = (char *)malloc( strlen( s ) + LDAP_REF_STR_LEN
+ *referralsp = (char *)LDAP_MALLOC( strlen( s ) + LDAP_REF_STR_LEN
+ 1 );
} else {
first = 0;
- *referralsp = (char *)realloc( *referralsp,
+ *referralsp = (char *)LDAP_REALLOC( *referralsp,
strlen( *referralsp ) + strlen( s ) + 2 );
}
static BerElement *
-re_encode_request( LDAP *ld, BerElement *origber, int msgid, char **dnp )
+re_encode_request( LDAP *ld, BerElement *origber, ber_int_t msgid, char **dnp )
{
/*
* XXX this routine knows way too much about how the lber library works!
*/
- unsigned long along, tag;
- long ver;
+ ber_int_t along;
+ ber_len_t len;
+ ber_tag_t tag;
+ ber_int_t ver;
int rc;
BerElement tmpber, *ber;
char *orig_dn;
Debug( LDAP_DEBUG_TRACE,
- "re_encode_request: new msgid %d, new dn <%s>\n",
- msgid, ( *dnp == NULL ) ? "NONE" : *dnp, 0 );
+ "re_encode_request: new msgid %ld, new dn <%s>\n",
+ (long) msgid, ( *dnp == NULL ) ? "NONE" : *dnp, 0 );
tmpber = *origber;
* all LDAP requests are sequences that start with a message id,
* followed by a sequence that is tagged with the operation code
*/
- if ( ber_scanf( &tmpber, "{i", &along ) != LDAP_TAG_MSGID ||
- ( tag = ber_skip_tag( &tmpber, &along )) == LBER_DEFAULT ) {
+ if ( ber_scanf( &tmpber, "{i", /*}*/ &along ) != LDAP_TAG_MSGID ||
+ ( tag = ber_skip_tag( &tmpber, &len )) == LBER_DEFAULT ) {
ld->ld_errno = LDAP_DECODING_ERROR;
return( NULL );
}
- if (( ber = ldap_alloc_ber_with_options( ld )) == NULLBER ) {
+ if (( ber = ldap_alloc_ber_with_options( ld )) == NULL ) {
return( NULL );
}
/* bind requests have a version number before the DN & other stuff */
- if ( tag == LDAP_REQ_BIND && ber_get_int( &tmpber, (long *)&ver ) ==
+ if ( tag == LDAP_REQ_BIND && ber_get_int( &tmpber, &ver ) ==
LBER_DEFAULT ) {
ld->ld_errno = LDAP_DECODING_ERROR;
ber_free( ber, 1 );
if ( *dnp == NULL ) {
*dnp = orig_dn;
} else {
- free( orig_dn );
+ LDAP_FREE( orig_dn );
}
if ( tag == LDAP_REQ_BIND ) {
- rc = ber_printf( ber, "{it{is", msgid, tag, ver, *dnp );
+ rc = ber_printf( ber, "{it{is" /*}}*/, msgid, tag, ver, *dnp );
} else {
- rc = ber_printf( ber, "{it{s", msgid, tag, *dnp );
+ rc = ber_printf( ber, "{it{s" /*}}*/, msgid, tag, *dnp );
}
if ( rc == -1 ) {
if ( ber_write( ber, tmpber.ber_ptr, ( tmpber.ber_end -
tmpber.ber_ptr ), 0 ) != ( tmpber.ber_end - tmpber.ber_ptr ) ||
- ber_printf( ber, "}}" ) == -1 ) {
+ ber_printf( ber, /*{{*/ "}}" ) == -1 ) {
ld->ld_errno = LDAP_ENCODING_ERROR;
ber_free( ber, 1 );
return( NULL );
if ( ldap_debug & LDAP_DEBUG_PACKETS ) {
Debug( LDAP_DEBUG_ANY, "re_encode_request new request is:\n",
0, 0, 0 );
- lber_log_dump( LDAP_DEBUG_BER, ldap_debug, ber, 0 );
+ ber_log_dump( LDAP_DEBUG_BER, ldap_debug, ber, 0 );
}
#endif /* LDAP_DEBUG */
LDAPRequest *
-ldap_find_request_by_msgid( LDAP *ld, int msgid )
+ldap_find_request_by_msgid( LDAP *ld, ber_int_t msgid )
{
LDAPRequest *lr;
return( lr );
}
-#endif /* LDAP_API_FEATURE_X_OPENLDAP_V2_REFERRALS */
#ifdef LDAP_API_FEATURE_X_OPENLDAP_V2_DNS
static LDAPServer *
-dn2servers( LDAP *ld, char *dn ) /* dn can also be a domain.... */
+dn2servers( LDAP *ld, const char *dn ) /* dn can also be a domain.... */
{
- char *p, *domain, *host, *server_dn, **dxs;
+ char *p, *host, *server_dn, **dxs;
+ const char *domain;
int i, port;
LDAPServer *srvlist, *prevsrv, *srv;
srvlist = NULL;
for ( i = 0; dxs[ i ] != NULL; ++i ) {
- port = openldap_ldap_global_options.ldo_defport;
+ port = ldap_int_global_options.ldo_defport;
server_dn = NULL;
if ( strchr( dxs[ i ], ':' ) == NULL ) {
host = dxs[ i ];
}
if ( host != NULL ) { /* found a server we can use */
- if (( srv = (LDAPServer *)calloc( 1,
+ if (( srv = (LDAPServer *)LDAP_CALLOC( 1,
sizeof( LDAPServer ))) == NULL ) {
free_servers( srvlist );
srvlist = NULL;
prevsrv = srv;
/* copy in info. */
- if (( srv->lsrv_host = strdup( host )) == NULL ||
+ if (( srv->lsrv_host = LDAP_STRDUP( host )) == NULL ||
( server_dn != NULL && ( srv->lsrv_dn =
- strdup( server_dn )) == NULL )) {
+ LDAP_STRDUP( server_dn )) == NULL )) {
free_servers( srvlist );
srvlist = NULL;
break; /* exit loop & return */