+/* $OpenLDAP$ */
/*
+ * Copyright 1998-1999 The OpenLDAP Foundation, All Rights Reserved.
+ * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
+ */
+/* Portions
* Copyright (c) 1995 Regents of the University of Michigan.
* All rights reserved.
*
#include "portable.h"
-#ifndef lint
-static char copyright[] = "@(#) Copyright (c) 1995 Regents of the University of Michigan.\nAll rights reserved.\n";
-#endif
-
#include <stdio.h>
-#include <stdlib.h>
+
+#include <ac/stdlib.h>
#include <ac/errno.h>
#include <ac/socket.h>
#include <ac/time.h>
#include <ac/unistd.h>
-#include "lber.h"
-#include "ldap.h"
#include "ldap-int.h"
+#include "lber.h"
-#if defined( LDAP_REFERRALS ) || defined( LDAP_DNS )
-static LDAPConn *find_connection LDAP_P(( LDAP *ld, LDAPServer *srv, int any ));
+static LDAPConn *find_connection LDAP_P(( LDAP *ld, LDAPURLDesc *srv, int any ));
static void use_connection LDAP_P(( LDAP *ld, LDAPConn *lc ));
-static void free_servers LDAP_P(( LDAPServer *srvlist ));
-#endif /* LDAP_REFERRALS || LDAP_DNS */
-
-#ifdef LDAP_DNS
-static LDAPServer *dn2servers LDAP_P(( LDAP *ld, char *dn ));
-#endif /* LDAP_DNS */
+#ifdef LDAP_API_FEATURE_X_OPENLDAP_V2_DNS
+static LDAPURLDesc *dn2servers LDAP_P(( LDAP *ld, const char *dn ));
+#endif /* LDAP_API_FEATURE_X_OPENLDAP_V2_DNS */
-#ifdef LDAP_REFERRALS
-static BerElement *re_encode_request LDAP_P(( LDAP *ld, BerElement *origber,
- int msgid, char **dnp ));
-#endif /* LDAP_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_REFERRALS ) || defined( LDAP_DNS )
- LDAPServer *servers;
-#endif /* LDAP_REFERRALS || LDAP_DNS */
+ LDAPURLDesc *servers;
+ int rc;
Debug( LDAP_DEBUG_TRACE, "ldap_send_initial_request\n", 0, 0, 0 );
-#if !defined( LDAP_REFERRALS ) && !defined( LDAP_DNS )
- if ( ber_flush( &ld->ld_sb, ber, 1 ) != 0 ) {
- ld->ld_errno = LDAP_SERVER_DOWN;
- return( -1 );
- }
+ if ( ! ber_pvt_sb_in_use(&ld->ld_sb ) ) {
+ /* not connected yet */
+ int rc = ldap_open_defconn( ld );
- ld->ld_errno = LDAP_SUCCESS;
- return( ld->ld_msgid );
-#else /* !LDAP_REFERRALS && !LDAP_DNS */
+ if( rc < 0 ) {
+ ber_free( ber, 1 );
+ return( -1 );
+ }
+
+ Debug( LDAP_DEBUG_TRACE,
+ "ldap_delayed_open successful, ld_host is %s\n",
+ ( ld->ld_host == NULL ) ? "(null)" : ld->ld_host, 0, 0 );
+ }
-#ifdef LDAP_DNS
- if (( ld->ld_options & LDAP_OPT_DNS ) != 0 && ldap_is_dns_dn( dn )) {
+#ifdef LDAP_API_FEATURE_X_OPENLDAP_V2_DNS
+ if ( LDAP_BOOL_GET(&ld->ld_options, LDAP_BOOL_DNS )
+ && ldap_is_dns_dn( dn ) )
+ {
if (( servers = dn2servers( ld, dn )) == NULL ) {
ber_free( ber, 1 );
return( -1 );
#ifdef LDAP_DEBUG
if ( ldap_debug & LDAP_DEBUG_TRACE ) {
- LDAPServer *srv;
+ LDAPURLDesc *srv;
- for ( srv = servers; srv != NULL;
- srv = srv->lsrv_next ) {
+ for ( srv = servers;
+ srv != NULL;
+ srv = srv->lud_next )
+ {
fprintf( stderr,
"LDAP server %s: dn %s, port %d\n",
- srv->lsrv_host, ( srv->lsrv_dn == NULL ) ?
- "(default)" : srv->lsrv_dn,
- srv->lsrv_port );
+ srv->lud_host, ( srv->lud_dn == NULL ) ?
+ "(default)" : srv->lud_dn,
+ srv->lud_port );
}
}
#endif /* LDAP_DEBUG */
- } else {
-#endif /* LDAP_DNS */
+ } 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_DNS
}
-#endif /* LDAP_DNS */
- return( ldap_send_server_request( ld, ber, ld->ld_msgid, NULL, servers,
- NULL, 0 ));
-#endif /* !LDAP_REFERRALS && !LDAP_DNS */
+ rc = ldap_send_server_request( ld, ber, ld->ld_msgid, NULL,
+ servers, NULL, 0 );
+ if (servers)
+ ldap_free_urllist(servers);
+ return(rc);
}
-#if defined( LDAP_REFERRALS ) || defined( LDAP_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,
+ LDAPURLDesc *srvlist,
+ LDAPConn *lc,
+ int bind )
{
LDAPRequest *lr;
int incparent;
incparent = 1;
++parentreq->lr_outrefcnt;
}
- lc = ldap_new_connection( ld, &srvlist, 0, 1, bind );
+ lc = ldap_new_connection( ld, srvlist, 0, 1, bind );
}
- free_servers( srvlist );
}
}
}
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 );
if ( ber_flush( lc->lconn_sb, ber, 0 ) != 0 ) {
#ifdef notyet
- extern int errno;
-
if ( errno == EWOULDBLOCK ) {
/* need to continue write later */
lr->lr_status = LDAP_REQST_WRITING;
return( msgid );
}
-
LDAPConn *
-ldap_new_connection( LDAP *ld, LDAPServer **srvlistp, int use_ldsb,
+ldap_new_connection( LDAP *ld, LDAPURLDesc *srvlist, int use_ldsb,
int connect, int bind )
{
LDAPConn *lc;
- LDAPServer *prevsrv, *srv;
+ LDAPURLDesc *srv;
Sockbuf *sb;
/*
* make a new LDAP server connection
* XXX open connection synchronously for now
*/
- if (( lc = (LDAPConn *)calloc( 1, sizeof( LDAPConn ))) == NULL ||
- ( !use_ldsb && ( sb = (Sockbuf *)calloc( 1, sizeof( Sockbuf )))
- == 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 );
lc->lconn_sb = ( use_ldsb ) ? &ld->ld_sb : sb;
if ( connect ) {
- prevsrv = NULL;
-
- for ( srv = *srvlistp; srv != NULL; srv = srv->lsrv_next ) {
+ for ( srv = srvlist; srv != NULL; srv = srv->lud_next ) {
if ( open_ldap_connection( ld, lc->lconn_sb,
- srv->lsrv_host, srv->lsrv_port,
- &lc->lconn_krbinstance, 0 ) != -1 ) {
+ srv, &lc->lconn_krbinstance, 0 ) != -1 )
+ {
break;
}
- prevsrv = srv;
}
if ( srv == NULL ) {
- if ( !use_ldsb ) {
- free( (char *)lc->lconn_sb );
- }
- free( (char *)lc );
+ if ( !use_ldsb ) {
+ ber_sockbuf_free( lc->lconn_sb );
+ }
+ LDAP_FREE( (char *)lc );
ld->ld_errno = LDAP_SERVER_DOWN;
return( NULL );
}
- if ( prevsrv == NULL ) {
- *srvlistp = srv->lsrv_next;
- } else {
- prevsrv->lsrv_next = srv->lsrv_next;
- }
- lc->lconn_server = srv;
+ lc->lconn_server = ldap_url_dup(srv);
}
lc->lconn_status = LDAP_CONNST_CONNECTED;
freepasswd = err = 0;
- if ( ld->ld_rebindproc == NULL ) {
+ if ( ld->ld_rebindproc == 0 ) {
binddn = passwd = "";
authmethod = LDAP_AUTH_SIMPLE;
} else {
static LDAPConn *
-find_connection( LDAP *ld, LDAPServer *srv, int any )
+find_connection( LDAP *ld, LDAPURLDesc *srv, int any )
/*
* return an existing connection (if any) to the server srv
* if "any" is non-zero, check for any server in the "srv" chain
*/
{
LDAPConn *lc;
- LDAPServer *ls;
+ LDAPURLDesc *ls;
for ( lc = ld->ld_conns; lc != NULL; lc = lc->lconn_next ) {
- for ( ls = srv; ls != NULL; ls = ls->lsrv_next ) {
- if ( lc->lconn_server->lsrv_host != NULL &&
- ls->lsrv_host != NULL && strcasecmp(
- ls->lsrv_host, lc->lconn_server->lsrv_host ) == 0
- && ls->lsrv_port == lc->lconn_server->lsrv_port ) {
+ for ( ls = srv; ls != NULL; ls = ls->lud_next ) {
+ if ( lc->lconn_server->lud_host != NULL &&
+ ls->lud_host != NULL && strcasecmp(
+ ls->lud_host, lc->lconn_server->lud_host ) == 0
+ && ls->lud_port == lc->lconn_server->lud_port ) {
return( lc );
}
if ( !any ) {
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_close_connection( lc->lconn_sb );
- if ( lc->lconn_sb->sb_ber.ber_buf != NULL ) {
- free( lc->lconn_sb->sb_ber.ber_buf );
+ ldap_send_unbind( ld, lc->lconn_sb, NULL, NULL );
}
}
+
+ /* 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 ) {
}
prevlc = tmplc;
}
- free_servers( lc->lconn_server );
+ ldap_free_urllist( lc->lconn_server );
if ( lc->lconn_krbinstance != NULL ) {
- free( lc->lconn_krbinstance );
+ LDAP_FREE( lc->lconn_krbinstance );
}
if ( lc->lconn_sb != &ld->ld_sb ) {
- free( (char *)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 );
}
ldap_dump_connection( LDAP *ld, LDAPConn *lconns, int all )
{
LDAPConn *lc;
+ char timebuf[32];
fprintf( stderr, "** Connection%s:\n", all ? "s" : "" );
for ( lc = lconns; lc != NULL; lc = lc->lconn_next ) {
if ( lc->lconn_server != NULL ) {
fprintf( stderr, "* host: %s port: %d%s\n",
- ( lc->lconn_server->lsrv_host == NULL ) ? "(null)"
- : lc->lconn_server->lsrv_host,
- lc->lconn_server->lsrv_port, ( lc->lconn_sb ==
+ ( lc->lconn_server->lud_host == NULL ) ? "(null)"
+ : lc->lconn_server->lud_host,
+ lc->lconn_server->lud_port, ( lc->lconn_sb ==
&ld->ld_sb ) ? " (default)" : "" );
}
fprintf( stderr, " refcnt: %d status: %s\n", lc->lconn_refcnt,
"NeedSocket" : ( lc->lconn_status ==
LDAP_CONNST_CONNECTING ) ? "Connecting" : "Connected" );
fprintf( stderr, " last used: %s\n",
- ctime( &lc->lconn_lastused ));
+ ldap_pvt_ctime( &lc->lconn_lastused, timebuf ));
if ( !all ) {
break;
}
}
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 );
}
-static void
-free_servers( LDAPServer *srvlist )
-{
- LDAPServer *nextsrv;
-
- while ( srvlist != NULL ) {
- nextsrv = srvlist->lsrv_next;
- if ( srvlist->lsrv_dn != NULL ) {
- free( srvlist->lsrv_dn );
- }
- if ( srvlist->lsrv_host != NULL ) {
- free( srvlist->lsrv_host );
- }
- free( srvlist );
- srvlist = nextsrv;
- }
-}
-#endif /* LDAP_REFERRALS || LDAP_DNS */
-
-
-#ifdef LDAP_REFERRALS
/*
* XXX merging of errors in this routine needs to be improved
*/
ldap_chase_referrals( LDAP *ld, LDAPRequest *lr, char **errstrp, int *hadrefp )
{
int rc, count, len, newdn;
-#ifdef LDAP_DNS
+#ifdef LDAP_API_FEATURE_X_OPENLDAP_V2_DNS
int ldapref;
-#endif /* LDAP_DNS */
+#endif /* LDAP_API_FEATURE_X_OPENLDAP_V2_DNS */
char *p, *ports, *ref, *tmpref, *refdn, *unfollowed;
LDAPRequest *origreq;
- LDAPServer *srv;
+ LDAPURLDesc *srv;
BerElement *ber;
Debug( LDAP_DEBUG_TRACE, "ldap_chase_referrals\n", 0, 0, 0 );
/* parse out & follow referrals */
for ( ref = p; rc == 0 && ref != NULL; ref = p ) {
-#ifdef LDAP_DNS
+#ifdef LDAP_API_FEATURE_X_OPENLDAP_V2_DNS
ldapref = 0;
-#endif /* LDAP_DNS */
+#endif /* LDAP_API_FEATURE_X_OPENLDAP_V2_DNS */
if (( p = strchr( ref, '\n' )) != NULL ) {
*p++ = '\0';
LDAP_LDAP_REF_STR, LDAP_LDAP_REF_STR_LEN ) == 0 ) {
Debug( LDAP_DEBUG_TRACE,
"chasing LDAP referral: <%s>\n", ref, 0, 0 );
-#ifdef LDAP_DNS
+#ifdef LDAP_API_FEATURE_X_OPENLDAP_V2_DNS
ldapref = 1;
-#endif /* LDAP_DNS */
+#endif /* LDAP_API_FEATURE_X_OPENLDAP_V2_DNS */
tmpref = ref + LDAP_LDAP_REF_STR_LEN;
-#ifdef LDAP_DNS
+#ifdef LDAP_API_FEATURE_X_OPENLDAP_V2_DNS
} else if ( len > LDAP_DX_REF_STR_LEN && strncasecmp( ref,
LDAP_DX_REF_STR, LDAP_DX_REF_STR_LEN ) == 0 ) {
Debug( LDAP_DEBUG_TRACE,
"chasing DX referral: <%s>\n", ref, 0, 0 );
tmpref = ref + LDAP_DX_REF_STR_LEN;
-#endif /* LDAP_DNS */
+#endif /* LDAP_API_FEATURE_X_OPENLDAP_V2_DNS */
} else {
Debug( LDAP_DEBUG_TRACE,
"ignoring unknown referral <%s>\n", ref, 0, 0 );
continue;
}
+ /* NOTE! This code treats "ldap://host/" differently
+ * from "ldap://host". The behavior is wrong, but is
+ * left here intentionally to maintain compatibility
+ * with OpenLDAP 1.x and UMich 3.3 clients.
+ */
*hadrefp = 1;
if (( refdn = strchr( tmpref, '/' )) != NULL ) {
*refdn++ = '\0';
return( -1 );
}
-#ifdef LDAP_DNS
+#ifdef LDAP_API_FEATURE_X_OPENLDAP_V2_DNS
if ( ldapref ) {
-#endif /* LDAP_DNS */
- if (( srv = (LDAPServer *)calloc( 1,
- sizeof( LDAPServer ))) == NULL ) {
+#endif /* LDAP_API_FEATURE_X_OPENLDAP_V2_DNS */
+ if (( srv = (LDAPURLDesc *)LDAP_CALLOC( 1,
+ sizeof( LDAPURLDesc ))) == 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->lud_host = LDAP_STRDUP( tmpref )) == NULL ) {
+ LDAP_FREE( (char *)srv );
ber_free( ber, 1 );
ld->ld_errno = LDAP_NO_MEMORY;
return( -1 );
}
- if (( ports = strchr( srv->lsrv_host, ':' )) != NULL ) {
+ if (( ports = strchr( srv->lud_host, ':' )) != NULL ) {
*ports++ = '\0';
- srv->lsrv_port = atoi( ports );
+ srv->lud_port = atoi( ports );
} else {
- srv->lsrv_port = LDAP_PORT;
+ srv->lud_port = ldap_int_global_options.ldo_defport;
}
-#ifdef LDAP_DNS
+#ifdef LDAP_API_FEATURE_X_OPENLDAP_V2_DNS
} else {
srv = dn2servers( ld, tmpref );
}
-#endif /* LDAP_DNS */
+#endif /* LDAP_API_FEATURE_X_OPENLDAP_V2_DNS */
if ( srv != NULL && ldap_send_server_request( ld, ber, ld->ld_msgid,
lr, srv, NULL, 1 ) >= 0 ) {
rc = ldap_append_referral( ld, &unfollowed, ref );
}
+ if (srv != NULL)
+ ldap_free_urllist(srv);
+
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 );
- ber_dump( 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_REFERRALS */
-#ifdef LDAP_DNS
-static LDAPServer *
-dn2servers( LDAP *ld, char *dn ) /* dn can also be a domain.... */
+#ifdef LDAP_API_FEATURE_X_OPENLDAP_V2_DNS
+static LDAPURLDesc *
+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;
+ LDAPURLDesc *srvlist, *prevsrv, *srv;
if (( domain = strrchr( dn, '@' )) != NULL ) {
++domain;
}
srvlist = NULL;
-
for ( i = 0; dxs[ i ] != NULL; ++i ) {
- port = LDAP_PORT;
- server_dn = NULL;
- if ( strchr( dxs[ i ], ':' ) == NULL ) {
- host = dxs[ i ];
- } else if ( strlen( dxs[ i ] ) >= 7 &&
- strncmp( dxs[ i ], "ldap://", 7 ) == 0 ) {
- host = dxs[ i ] + 7;
- if (( p = strchr( host, ':' )) == NULL ) {
- p = host;
- } else {
- *p++ = '\0';
- port = atoi( p );
- }
- if (( p = strchr( p, '/' )) != NULL ) {
- server_dn = ++p;
- if ( *server_dn == '\0' ) {
- server_dn = NULL;
- }
- }
- } else {
- host = NULL;
- }
-
- if ( host != NULL ) { /* found a server we can use */
- if (( srv = (LDAPServer *)calloc( 1,
- sizeof( LDAPServer ))) == NULL ) {
- free_servers( srvlist );
- srvlist = NULL;
- break; /* exit loop & return */
- }
-
+ if (ldap_url_parselist(&srv, dxs[i]) == LDAP_SUCCESS
+ || ldap_url_parsehosts(&srv, dxs[i]) == LDAP_SUCCESS)
+ {
/* add to end of list of servers */
if ( srvlist == NULL ) {
srvlist = srv;
} else {
- prevsrv->lsrv_next = srv;
+ prevsrv->lud_next = srv;
}
prevsrv = srv;
-
- /* copy in info. */
- if (( srv->lsrv_host = strdup( host )) == NULL ||
- ( server_dn != NULL && ( srv->lsrv_dn =
- strdup( server_dn )) == NULL )) {
- free_servers( srvlist );
- srvlist = NULL;
- break; /* exit loop & return */
- }
- srv->lsrv_port = port;
}
}
return( srvlist );
}
-#endif /* LDAP_DNS */
+#endif /* LDAP_API_FEATURE_X_OPENLDAP_V2_DNS */
projects / openldap / blobdiff