+/* $OpenLDAP$ */
/*
* Copyright 1998-1999 The OpenLDAP Foundation, All Rights Reserved.
* COPYING RESTRICTIONS APPLY, see COPYRIGHT file
#ifdef LDAP_CONNECTIONLESS
#include <stdio.h>
-#include <stdlib.h>
+
+#include <ac/stdlib.h>
#include <ac/errno.h>
#include <ac/socket.h>
LDAP *ld, struct sockaddr *sap ));
static int cldap_result LDAP_P((
LDAP *ld, int msgid, LDAPMessage **res,
- struct cldap_retinfo *crip, char *base ));
+ struct cldap_retinfo *crip, const char *base ));
static int cldap_parsemsg LDAP_P((
LDAP *ld, int msgid, BerElement *ber,
- LDAPMessage **res, char *base ));
+ LDAPMessage **res, const char *base ));
/*
* cldap_open - initialize and connect to an ldap server. A magic cookie to
*/
LDAP *
-cldap_open( char *host, int port )
+cldap_open( LDAP_CONST char *host, int port )
{
int s;
unsigned long address;
int local_h_errno;
char *ha_buf=NULL;
-#define DO_RETURN(x) if (ha_buf) free(ha_buf); return (x);
+#define DO_RETURN(x) if (ha_buf) LDAP_FREE(ha_buf); return (x);
Debug( LDAP_DEBUG_TRACE, "ldap_open\n", 0, 0, 0 );
ld->ld_cldapaddrs = NULL;
if (ber_pvt_sb_set_io( &(ld->ld_sb), &ber_pvt_sb_io_udp, NULL )<0) {
- ldap_ld_free(ld, 1 );
+ ldap_ld_free(ld, 1, NULL, NULL );
return NULL;
}
- ld->ld_version = LDAP_VERSION;
+ ld->ld_version = LDAP_VERSION2;
sock.sin_family = AF_INET;
sock.sin_port = htons( port );
* 'host' may be a space-separated list.
*/
if ( host != NULL ) {
+ char *host_dup = LDAP_STRDUP( host );
+ host = host_dup;
for ( ; host != NULL; host = p ) {
if (( p = strchr( host, ' ' )) != NULL ) {
for (*p++ = '\0'; *p == ' '; p++) {
(char *)hp->h_addr_list[ i ],
sizeof(sock.sin_addr.s_addr));
if ( add_addr( ld, (struct sockaddr *)&sock ) < 0 ) {
- ldap_ld_free( ld, 1 );
+ ldap_ld_free( ld, 1, NULL, NULL );
+ LDAP_FREE( host_dup );
DO_RETURN( NULL );
}
}
} else {
sock.sin_addr.s_addr = address;
if ( add_addr( ld, (struct sockaddr *)&sock ) < 0 ) {
- ldap_ld_free( ld, 1 );
+ ldap_ld_free( ld, 1, NULL, NULL );
+ LDAP_FREE( host_dup );
DO_RETURN( NULL );
}
}
if ( ld->ld_host == NULL ) {
- ld->ld_host = strdup( host );
+ ld->ld_host = LDAP_STRDUP( host );
}
}
+ LDAP_FREE( host_dup );
} else {
- address = INADDR_LOOPBACK;
- sock.sin_addr.s_addr = htonl( address );
+ sock.sin_addr.s_addr = htonl( INADDR_LOOPBACK );
if ( add_addr( ld, (struct sockaddr *)&sock ) < 0 ) {
- ldap_ld_free( ld, 1 );
+ ldap_ld_free( ld, 1, NULL, NULL );
DO_RETURN( NULL );
}
}
if ( ld->ld_cldapaddrs == NULL
-#ifdef LDAP_API_FEATURE_X_OPENLDAP_V2_REFERRALS
|| ( ld->ld_defconn = ldap_new_connection( ld, NULL, 1,0,0 )) == NULL
-#endif /* LDAP_API_FEATURE_X_OPENLDAP_V2_REFERRALS */
) {
- ldap_ld_free( ld, 0 );
+ ldap_ld_free( ld, 0, NULL, NULL );
DO_RETURN( NULL );
}
void
cldap_close( LDAP *ld )
{
- ldap_ld_free( ld, 0 );
+ ldap_ld_free( ld, 0, NULL, NULL );
}
int
-cldap_search_s( LDAP *ld, char *base, int scope, char *filter, char **attrs,
- int attrsonly, LDAPMessage **res, char *logdn )
+cldap_search_s( LDAP *ld,
+ LDAP_CONST char *base,
+ int scope,
+ LDAP_CONST char *filter,
+ char **attrs,
+ int attrsonly,
+ LDAPMessage **res,
+ char *logdn )
{
int ret, msgid;
struct cldap_retinfo cri;
- *res = NULLMSG;
+ *res = NULL;
(void) memset( &cri, 0, sizeof( cri ));
{
struct sockaddr *newsap, **addrs;
- if (( newsap = (struct sockaddr *)malloc( sizeof( struct sockaddr )))
+ if (( newsap = (struct sockaddr *)LDAP_MALLOC( sizeof( struct sockaddr )))
== NULL ) {
ld->ld_errno = LDAP_NO_MEMORY;
return( -1 );
}
- if ( ld->ld_cldapnaddr == 0 ) {
- addrs = (struct sockaddr **)malloc( sizeof(struct sockaddr *));
- } else {
- addrs = (struct sockaddr **)realloc( ld->ld_cldapaddrs,
+ addrs = (struct sockaddr **)LDAP_REALLOC( ld->ld_cldapaddrs,
( ld->ld_cldapnaddr + 1 ) * sizeof(struct sockaddr *));
- }
if ( addrs == NULL ) {
- free( newsap );
+ LDAP_FREE( newsap );
ld->ld_errno = LDAP_NO_MEMORY;
return( -1 );
}
static int
cldap_result( LDAP *ld, int msgid, LDAPMessage **res,
- struct cldap_retinfo *crip, char *base )
+ struct cldap_retinfo *crip, const char *base )
{
Sockbuf *sb = &ld->ld_sb;
BerElement ber;
char *logdn;
- int ret, id, fromaddr, i;
+ int ret, fromaddr, i;
+ ber_int_t id;
struct timeval tv;
fromaddr = -1;
logdn = NULL;
if ( ber_scanf( &ber, "ia", &id, &logdn ) == LBER_ERROR ) {
- free( ber.ber_buf ); /* gack! */
+ LDAP_FREE( ber.ber_buf ); /* gack! */
ret = LDAP_DECODING_ERROR;
Debug( LDAP_DEBUG_TRACE,
"cldap_result: ber_scanf returned LBER_ERROR (%d)\n",
ret, 0, 0 );
} else if ( id != msgid ) {
- free( ber.ber_buf ); /* gack! */
+ LDAP_FREE( ber.ber_buf ); /* gack! */
Debug( LDAP_DEBUG_TRACE,
"cldap_result: looking for msgid %d; got %d\n",
msgid, id, 0 );
}
}
ret = cldap_parsemsg( ld, msgid, &ber, res, base );
- free( ber.ber_buf ); /* gack! */
+ LDAP_FREE( ber.ber_buf ); /* gack! */
Debug( LDAP_DEBUG_TRACE,
"cldap_result got result (%d)\n", ret, 0, 0 );
}
if ( logdn != NULL ) {
- free( logdn );
+ LDAP_FREE( logdn );
}
}
static int
cldap_parsemsg( LDAP *ld, int msgid, BerElement *ber,
- LDAPMessage **res, char *base )
+ LDAPMessage **res, const char *base )
{
- unsigned long tag, len;
- int baselen, slen, rc;
+ ber_tag_t tag;
+ ber_len_t len;
+ int baselen, slen;
+ ber_tag_t rc;
char *dn, *p, *cookie;
LDAPMessage *chain, *prev, *ldm;
struct berval *bv;
rc = LDAP_DECODING_ERROR; /* pessimistic */
- ldm = chain = prev = NULLMSG;
+ ldm = chain = prev = NULL;
baselen = ( base == NULL ) ? 0 : strlen( base );
bv = NULL;
for ( tag = ber_first_element( ber, &len, &cookie );
tag != LBER_DEFAULT && rc != LDAP_SUCCESS;
tag = ber_next_element( ber, &len, cookie )) {
- if (( ldm = (LDAPMessage *)calloc( 1, sizeof(LDAPMessage)))
+ if (( ldm = (LDAPMessage *)LDAP_CALLOC( 1, sizeof(LDAPMessage)))
== NULL || ( ldm->lm_ber = ldap_alloc_ber_with_options( ld ))
- == NULLBER ) {
+ == NULL ) {
rc = LDAP_NO_MEMORY;
break; /* return w/error*/
}
break; /* return w/error */
}
- if ( ber_printf( ldm->lm_ber, "to", tag, bv->bv_val,
- bv->bv_len ) == -1 ) {
+ if ( ber_printf( ldm->lm_ber, "tO", tag, bv ) == -1 ) {
break; /* return w/error */
}
ber_bvfree( bv );
rc = LDAP_SUCCESS;
} else if ( tag == LDAP_RES_SEARCH_ENTRY ) {
- if ( ber_scanf( ber, "{aO", &dn, &bv ) == LBER_ERROR ) {
+ if ( ber_scanf( ber, "{aO" /*}*/, &dn, &bv ) == LBER_ERROR ) {
break; /* return w/error */
}
Debug( LDAP_DEBUG_TRACE, "cldap_parsemsg entry %s\n", dn, 0, 0 );
/*
* substitute original searchbase for trailing '*'
*/
- if (( p = (char *)malloc( slen + baselen )) == NULL ) {
+ if (( p = (char *)LDAP_MALLOC( slen + baselen )) == NULL ) {
rc = LDAP_NO_MEMORY;
- free( dn );
+ LDAP_FREE( dn );
break; /* return w/error */
}
strcpy( p, dn );
strcpy( p + slen - 1, base );
- free( dn );
+ LDAP_FREE( dn );
dn = p;
}
bv->bv_len ) == -1 ) {
break; /* return w/error */
}
- free( dn );
+ LDAP_FREE( dn );
ber_bvfree( bv );
bv = NULL;
} else {
Debug( LDAP_DEBUG_TRACE, "cldap_parsemsg got unknown tag %lu\n",
tag, 0, 0 );
- rc = LDAP_PROTOCOL_ERROR;
+ rc = LDAP_DECODING_ERROR;
break; /* return w/error */
}
#ifdef LDAP_DEBUG
if ( ldap_debug & LDAP_DEBUG_PACKETS ) {
- fprintf( stderr, "cldap_parsemsg add message id %d type %d:\n",
- ldm->lm_msgid, ldm->lm_msgtype );
+ fprintf( stderr, "cldap_parsemsg add message id %ld type %ld:\n",
+ (long) ldm->lm_msgid, (long) ldm->lm_msgtype );
ber_log_dump( LDAP_DEBUG_BER, ldap_debug, ldm->lm_ber, 1 );
}
#endif /* LDAP_DEBUG */
/* dispose of any leftovers */
if ( ldm != NULL ) {
- if ( ldm->lm_ber != NULLBER ) {
+ if ( ldm->lm_ber != NULL ) {
ber_free( ldm->lm_ber, 1 );
}
- free( ldm );
+ LDAP_FREE( ldm );
}
if ( bv != NULL ) {
ber_bvfree( bv );
/* return chain, calling result2error if we got anything at all */
*res = chain;
- return(( *res == NULLMSG ) ? rc : ldap_result2error( ld, *res, 0 ));
+ return(( *res == NULL ) ? rc : ldap_result2error( ld, *res, 0 ));
}
#endif /* LDAP_CONNECTIONLESS */
projects / openldap / blobdiff