X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=libraries%2Flibldap%2Fresult.c;h=36df94b712776a5ce60ca65591aeacc7633bde71;hb=8045b54124f0365b3d34d9d3220256f052f2b76b;hp=90e9e69b65dcaad0190d143e221280e85123ab19;hpb=d44ac9835a746d1fbcf5e150a3218df114640372;p=openldap

diff --git a/libraries/libldap/result.c b/libraries/libldap/result.c
index 90e9e69b65..36df94b712 100644
--- a/libraries/libldap/result.c
+++ b/libraries/libldap/result.c
@@ -1,5 +1,6 @@
+/* $OpenLDAP$ */
 /*
- * Copyright 1998-1999 The OpenLDAP Foundation, All Rights Reserved.
+ * Copyright 1998-2000 The OpenLDAP Foundation, All Rights Reserved.
  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
  */
 /*  Portions
@@ -9,10 +10,23 @@
  *  result.c - wait for an ldap result
  */
 
+/*
+ * LDAPv3 (RFC2251)
+ *	LDAPResult ::= SEQUENCE {
+ *		resultCode		ENUMERATED { ... },
+ *		matchedDN		LDAPDN,
+ *		errorMessage	LDAPString,
+ *		referral		Referral OPTIONAL
+ *	}
+ *	Referral ::= SEQUENCE OF LDAPURL	(one or more)
+ *	LDAPURL ::= LDAPString				(limited to URL chars)
+ */
+
 #include "portable.h"
 
 #include <stdio.h>
-#include <stdlib.h>
+
+#include <ac/stdlib.h>
 
 #include <ac/errno.h>
 #include <ac/socket.h>
@@ -23,13 +37,13 @@
 #include "ldap-int.h"
 
 
-static int ldap_abandoned LDAP_P(( LDAP *ld, int msgid ));
-static int ldap_mark_abandoned LDAP_P(( LDAP *ld, int msgid ));
-static int wait4msg LDAP_P(( LDAP *ld, int msgid, int all, struct timeval *timeout,
-	LDAPMessage **result ));
-static int try_read1msg LDAP_P(( LDAP *ld, int msgid, int all, Sockbuf *sb, LDAPConn *lc,
+static int ldap_abandoned LDAP_P(( LDAP *ld, ber_int_t msgid ));
+static int ldap_mark_abandoned LDAP_P(( LDAP *ld, ber_int_t msgid ));
+static int wait4msg LDAP_P(( LDAP *ld, ber_int_t msgid, int all, struct timeval *timeout,
 	LDAPMessage **result ));
-static unsigned long build_result_ber LDAP_P(( LDAP *ld, BerElement *ber, LDAPRequest *lr ));
+static ber_tag_t try_read1msg LDAP_P(( LDAP *ld, ber_int_t msgid,
+	int all, Sockbuf *sb, LDAPConn *lc, LDAPMessage **result ));
+static ber_tag_t build_result_ber LDAP_P(( LDAP *ld, BerElement **bp, LDAPRequest *lr ));
 static void merge_error_info LDAP_P(( LDAP *ld, LDAPRequest *parentr, LDAPRequest *lr ));
 
 
@@ -48,7 +62,11 @@ static void merge_error_info LDAP_P(( LDAP *ld, LDAPRequest *parentr, LDAPReques
  *	ldap_result( s, msgid, all, timeout, result )
  */
 int
-ldap_result( LDAP *ld, int msgid, int all, struct timeval *timeout,
+ldap_result(
+	LDAP *ld,
+	int msgid,
+	int all,
+	struct timeval *timeout,
 	LDAPMessage **result )
 {
 	LDAPMessage	*lm, *lastlm, *nextlm;
@@ -74,15 +92,15 @@ ldap_result( LDAP *ld, int msgid, int all, struct timeval *timeout,
 	 * wait until it arrives or timeout occurs.
 	 */
 
-	*result = NULLMSG;
-	lastlm = NULLMSG;
-	for ( lm = ld->ld_responses; lm != NULLMSG; lm = nextlm ) {
+	*result = NULL;
+	lastlm = NULL;
+	for ( lm = ld->ld_responses; lm != NULL; lm = nextlm ) {
 		nextlm = lm->lm_next;
 
 		if ( ldap_abandoned( ld, lm->lm_msgid ) ) {
 			ldap_mark_abandoned( ld, lm->lm_msgid );
 
-			if ( lastlm == NULLMSG ) {
+			if ( lastlm == NULL ) {
 				ld->ld_responses = lm->lm_next;
 			} else {
 				lastlm->lm_next = nextlm;
@@ -102,34 +120,36 @@ ldap_result( LDAP *ld, int msgid, int all, struct timeval *timeout,
 			    && lm->lm_msgtype != LDAP_RES_SEARCH_ENTRY) )
 				break;
 
-			for ( tmp = lm; tmp != NULLMSG; tmp = tmp->lm_chain ) {
+			for ( tmp = lm; tmp != NULL; tmp = tmp->lm_chain ) {
 				if ( tmp->lm_msgtype == LDAP_RES_SEARCH_RESULT )
 					break;
 			}
 
-			if ( tmp == NULLMSG ) {
-				return( wait4msg( ld, msgid, all, timeout,
-				    result ) );
+			if ( tmp == NULL ) {
+				lm = NULL;
 			}
 
 			break;
 		}
 		lastlm = lm;
 	}
-	if ( lm == NULLMSG ) {
+	if ( lm == NULL ) {
 		return( wait4msg( ld, msgid, all, timeout, result ) );
 	}
 
-	if ( lastlm == NULLMSG ) {
-		ld->ld_responses = (all == 0 && lm->lm_chain != NULLMSG
+	if ( lastlm == NULL ) {
+		ld->ld_responses = (all == 0 && lm->lm_chain != NULL
 		    ? lm->lm_chain : lm->lm_next);
 	} else {
-		lastlm->lm_next = (all == 0 && lm->lm_chain != NULLMSG
+		lastlm->lm_next = (all == 0 && lm->lm_chain != NULL
 		    ? lm->lm_chain : lm->lm_next);
 	}
-	if ( all == 0 )
-		lm->lm_chain = NULLMSG;
-	lm->lm_next = NULLMSG;
+	if ( all == 0 && lm->lm_chain != NULL )
+	{
+		lm->lm_chain->lm_next = lm->lm_next;
+		lm->lm_chain = NULL;
+	}
+	lm->lm_next = NULL;
 
 	*result = lm;
 	ld->ld_errno = LDAP_SUCCESS;
@@ -137,7 +157,11 @@ ldap_result( LDAP *ld, int msgid, int all, struct timeval *timeout,
 }
 
 static int
-wait4msg( LDAP *ld, int msgid, int all, struct timeval *timeout,
+wait4msg(
+	LDAP *ld,
+	ber_int_t msgid,
+	int all,
+	struct timeval *timeout,
 	LDAPMessage **result )
 {
 	int		rc;
@@ -196,8 +220,7 @@ wait4msg( LDAP *ld, int msgid, int all, struct timeval *timeout,
 #endif
 
 			if ( rc == 0 || ( rc == -1 && (
-				( LDAP_BOOL_GET(&ld->ld_options, LDAP_BOOL_RESTART)
-					== LDAP_OPT_OFF )
+				!LDAP_BOOL_GET(&ld->ld_options, LDAP_BOOL_RESTART)
 				|| errno != EINTR )))
 			{
 				ld->ld_errno = (rc == -1 ? LDAP_SERVER_DOWN :
@@ -241,31 +264,41 @@ wait4msg( LDAP *ld, int msgid, int all, struct timeval *timeout,
 }
 
 
-static int
-try_read1msg( LDAP *ld, int msgid, int all, Sockbuf *sb,
-    LDAPConn *lc, LDAPMessage **result )
+static ber_tag_t
+try_read1msg(
+	LDAP *ld,
+	ber_int_t msgid,
+	int all,
+	Sockbuf *sb,
+    LDAPConn *lc,
+	LDAPMessage **result )
 {
 	BerElement	*ber;
 	LDAPMessage	*new, *l, *prev, *tmp;
-	long		id;
-	unsigned long	tag, len;
+	ber_int_t	id;
+	ber_tag_t	tag;
+	ber_len_t	len;
 	int		foundit = 0;
 	LDAPRequest	*lr;
 	BerElement	tmpber;
 	int		rc, refer_cnt, hadref, simple_request;
-	unsigned long	lderr;
+	ber_int_t	lderr;
 
 	assert( ld != NULL );
 	assert( lc != NULL );
 	
-	ber = &lc->lconn_ber;
-
 	Debug( LDAP_DEBUG_TRACE, "read1msg\n", 0, 0, 0 );
 
-#if 0
-	ber_init_w_nullc( &ber, 0 );
-	ldap_set_ber_options( ld, &ber );
-#endif
+    if ( lc->lconn_ber == NULL ) {
+		lc->lconn_ber = ldap_alloc_ber_with_options(ld);
+
+		if( lc->lconn_ber == NULL ) {
+			return -1;
+		}
+    }
+
+	ber = lc->lconn_ber;
+	assert( BER_VALID (ber) );
 
 	/* get the next message */
 	errno = 0;
@@ -289,37 +322,46 @@ try_read1msg( LDAP *ld, int msgid, int all, Sockbuf *sb,
 		return -1;
 	}
 
+	/*
+     * We read a complete message.
+	 * The connection should no longer need this ber.
+	 */
+    lc->lconn_ber = NULL;
+
 	/* message id */
 	if ( ber_get_int( ber, &id ) == LBER_ERROR ) {
+		ber_free( ber, 1 );
 		ld->ld_errno = LDAP_DECODING_ERROR;
 		return( -1 );
 	}
 
 	/* if it's been abandoned, toss it */
-	if ( ldap_abandoned( ld, (int)id ) ) {
-		ber_clear( ber, 1 );	/* gack! */
+	if ( ldap_abandoned( ld, id ) ) {
+		ber_free( ber, 1 );
 		return( -2 );	/* continue looking */
 	}
 
 	if (( lr = ldap_find_request_by_msgid( ld, id )) == NULL ) {
 		Debug( LDAP_DEBUG_ANY,
 		    "no request for response with msgid %ld (tossing)\n",
-		    id, 0, 0 );
-		ber_clear( ber, 1 );	/* gack! */
+		    (long) id, 0, 0 );
+		ber_free( ber, 1 );
 		return( -2 );	/* continue looking */
 	}
-	Debug( LDAP_DEBUG_TRACE, "ldap_read: %s msgid %ld, original id %d\n",
-	    ( tag == LDAP_RES_SEARCH_ENTRY ) ? "entry" : 
-		( tag == LDAP_RES_SEARCH_REFERENCE ) ? "reference" : "result",
-		id, lr->lr_origid );
-	id = lr->lr_origid;
 
 	/* the message type */
 	if ( (tag = ber_peek_tag( ber, &len )) == LBER_ERROR ) {
 		ld->ld_errno = LDAP_DECODING_ERROR;
+		ber_free( ber, 1 );
 		return( -1 );
 	}
 
+	Debug( LDAP_DEBUG_TRACE, "ldap_read: %s msgid %ld, original id %ld\n",
+	    ( tag == LDAP_RES_SEARCH_ENTRY ) ? "entry" : 
+		( tag == LDAP_RES_SEARCH_REFERENCE ) ? "reference" : "result",
+		(long) id, (long) lr->lr_origid );
+
+	id = lr->lr_origid;
 	refer_cnt = 0;
 	hadref = simple_request = 0;
 	rc = -2;	/* default is to keep looking (no response found) */
@@ -328,8 +370,7 @@ try_read1msg( LDAP *ld, int msgid, int all, Sockbuf *sb,
 	if ( tag != LDAP_RES_SEARCH_ENTRY ) {
 		if ( ld->ld_version >= LDAP_VERSION2 &&
 			( lr->lr_parent != NULL ||
-			( LDAP_BOOL_GET(&ld->ld_options, LDAP_BOOL_REFERRALS)
-				!= LDAP_OPT_OFF ) ) )
+			LDAP_BOOL_GET(&ld->ld_options, LDAP_BOOL_REFERRALS) ) )
 		{
 			tmpber = *ber;	/* struct copy */
 			if ( ber_scanf( &tmpber, "{iaa}", &lderr,
@@ -362,7 +403,8 @@ Debug( LDAP_DEBUG_TRACE,
 		    "read1msg:  %d new referrals\n", refer_cnt, 0, 0 );
 
 		if ( refer_cnt != 0 ) {	/* chasing referrals */
-			ber_clear( ber, 1 );	/* gack! */
+			ber_free( ber, 1 );
+			ber = NULL;
 			if ( refer_cnt < 0 ) {
 				return( -1 );	/* fatal error */
 			}
@@ -373,7 +415,8 @@ Debug( LDAP_DEBUG_TRACE,
 				simple_request = ( hadref ? 0 : 1 );
 			} else {
 				/* request with referrals or child request */
-				ber_clear( ber, 1 );	/* gack! */
+				ber_free( ber, 1 );
+				ber = NULL;
 			}
 
 			while ( lr->lr_parent != NULL ) {
@@ -389,16 +432,16 @@ Debug( LDAP_DEBUG_TRACE,
 				id = lr->lr_msgid;
 				tag = lr->lr_res_msgtype;
 				Debug( LDAP_DEBUG_ANY, "request %ld done\n",
-				    id, 0, 0 );
+				    (long) id, 0, 0 );
 Debug( LDAP_DEBUG_TRACE,
 "res_errno: %d, res_error: <%s>, res_matched: <%s>\n",
 lr->lr_res_errno, lr->lr_res_error ? lr->lr_res_error : "",
 lr->lr_res_matched ? lr->lr_res_matched : "" );
 				if ( !simple_request ) {
-					ber_clear( ber, 1 ); /* gack! */
-					if ( build_result_ber( ld, ber, lr )
+					ber_free( ber, 1 );
+					ber = NULL;
+					if ( build_result_ber( ld, &ber, lr )
 					    == LBER_ERROR ) {
-						ld->ld_errno = LDAP_NO_MEMORY;
 						rc = -1; /* fatal error */
 					}
 				}
@@ -412,20 +455,19 @@ lr->lr_res_matched ? lr->lr_res_matched : "" );
 		}
 	}
 
-	if ( ber->ber_buf == NULL ) {
+	if ( ber == NULL ) {
 		return( rc );
 	}
 
 	/* make a new ldap message */
-	if ( (new = (LDAPMessage *) calloc( 1, sizeof(LDAPMessage) ))
+	if ( (new = (LDAPMessage *) LDAP_CALLOC( 1, sizeof(LDAPMessage) ))
 	    == NULL ) {
 		ld->ld_errno = LDAP_NO_MEMORY;
 		return( -1 );
 	}
 	new->lm_msgid = (int)id;
 	new->lm_msgtype = tag;
-	new->lm_ber = ber_dup( ber );
-	ber_clear( ber, 0 ); /* don't kill buffer */
+	new->lm_ber = ber;
 
 #ifndef LDAP_NOCACHE
 		if ( ld->ld_cache != NULL ) {
@@ -452,15 +494,15 @@ lr->lr_res_matched ? lr->lr_res_matched : "" );
 	 * search response.
 	 */
 
-	prev = NULLMSG;
-	for ( l = ld->ld_responses; l != NULLMSG; l = l->lm_next ) {
+	prev = NULL;
+	for ( l = ld->ld_responses; l != NULL; l = l->lm_next ) {
 		if ( l->lm_msgid == new->lm_msgid )
 			break;
 		prev = l;
 	}
 
 	/* not part of an existing search response */
-	if ( l == NULLMSG ) {
+	if ( l == NULL ) {
 		if ( foundit ) {
 			*result = new;
 			ld->ld_errno = LDAP_SUCCESS;
@@ -472,11 +514,11 @@ lr->lr_res_matched ? lr->lr_res_matched : "" );
 		return( -2 );	/* continue looking */
 	}
 
-	Debug( LDAP_DEBUG_TRACE, "adding response id %d type %d:\n",
-	    new->lm_msgid, new->lm_msgtype, 0 );
+	Debug( LDAP_DEBUG_TRACE, "adding response id %ld type %ld:\n",
+	    (long) new->lm_msgid, (long) new->lm_msgtype, 0 );
 
 	/* part of a search response - add to end of list of entries */
-	for ( tmp = l; tmp->lm_chain != NULLMSG &&
+	for ( tmp = l; tmp->lm_chain != NULL &&
 	    tmp->lm_chain->lm_msgtype == LDAP_RES_SEARCH_ENTRY;
 	    tmp = tmp->lm_chain )
 		;	/* NULL */
@@ -484,7 +526,7 @@ lr->lr_res_matched ? lr->lr_res_matched : "" );
 
 	/* return the whole chain if that's what we were looking for */
 	if ( foundit ) {
-		if ( prev == NULLMSG )
+		if ( prev == NULL )
 			ld->ld_responses = l->lm_next;
 		else
 			prev->lm_next = l->lm_next;
@@ -508,31 +550,56 @@ lr->lr_res_matched ? lr->lr_res_matched : "" );
 }
 
 
-static unsigned long
-build_result_ber( LDAP *ld, BerElement *ber, LDAPRequest *lr )
+static ber_tag_t
+build_result_ber( LDAP *ld, BerElement **bp, LDAPRequest *lr )
 {
-	unsigned long	len;
-	long		along;
+	ber_len_t	len;
+	ber_int_t	tag;
+	ber_int_t	along;
+	BerElement *ber;
+
+	*bp = NULL;
+	ber = ldap_alloc_ber_with_options( ld );
+
+	if( ber == NULL ) {
+		ld->ld_errno = LDAP_NO_MEMORY;
+		return LBER_ERROR;
+	}
 
-	ber_init_w_nullc( ber, 0 );
-	ldap_set_ber_options( ld, ber );
 	if ( ber_printf( ber, "{it{ess}}", lr->lr_msgid,
-	    (unsigned long) lr->lr_res_msgtype, lr->lr_res_errno,
+	    lr->lr_res_msgtype, lr->lr_res_errno,
 	    lr->lr_res_matched ? lr->lr_res_matched : "",
 	    lr->lr_res_error ? lr->lr_res_error : "" ) == -1 ) {
+
+		ld->ld_errno = LDAP_ENCODING_ERROR;
+		ber_free(ber, 1);
 		return( LBER_ERROR );
 	}
 
 	ber_reset( ber, 1 );
+
 	if ( ber_skip_tag( ber, &len ) == LBER_ERROR ) {
+		ld->ld_errno = LDAP_DECODING_ERROR;
+		ber_free(ber, 1);
 		return( LBER_ERROR );
 	}
 
 	if ( ber_get_int( ber, &along ) == LBER_ERROR ) {
+		ld->ld_errno = LDAP_DECODING_ERROR;
+		ber_free(ber, 1);
+		return( LBER_ERROR );
+	}
+
+	tag = ber_peek_tag( ber, &len );
+
+	if ( tag == LBER_ERROR ) {
+		ld->ld_errno = LDAP_DECODING_ERROR;
+		ber_free(ber, 1);
 		return( LBER_ERROR );
 	}
 
-	return( ber_peek_tag( ber, &len ));
+	*bp = ber;
+	return tag;
 }
 
 
@@ -552,13 +619,13 @@ merge_error_info( LDAP *ld, LDAPRequest *parentr, LDAPRequest *lr )
 	    parentr->lr_res_errno == LDAP_SUCCESS ) {
 		parentr->lr_res_errno = lr->lr_res_errno;
 		if ( parentr->lr_res_error != NULL ) {
-			free( parentr->lr_res_error );
+			LDAP_FREE( parentr->lr_res_error );
 		}
 		parentr->lr_res_error = lr->lr_res_error;
 		lr->lr_res_error = NULL;
 		if ( LDAP_NAME_ERROR( lr->lr_res_errno )) {
 			if ( parentr->lr_res_matched != NULL ) {
-				free( parentr->lr_res_matched );
+				LDAP_FREE( parentr->lr_res_matched );
 			}
 			parentr->lr_res_matched = lr->lr_res_matched;
 			lr->lr_res_matched = NULL;
@@ -579,7 +646,7 @@ int
 ldap_msgtype( LDAPMessage *lm )
 {
 	assert( lm != NULL );
-	return ( lm == NULL ) ? lm->lm_msgtype : -1;
+	return ( lm != NULL ) ? lm->lm_msgtype : -1;
 }
 
 
@@ -588,7 +655,7 @@ ldap_msgid( LDAPMessage *lm )
 {
 	assert( lm != NULL );
 
-	return ( lm == NULL ) ? lm->lm_msgid : -1;
+	return ( lm != NULL ) ? lm->lm_msgid : -1;
 }
 
 
@@ -602,11 +669,11 @@ ldap_msgfree( LDAPMessage *lm )
 
 	Debug( LDAP_DEBUG_TRACE, "ldap_msgfree\n", 0, 0, 0 );
 
-	for ( ; lm != NULLMSG; lm = next ) {
+	for ( ; lm != NULL; lm = next ) {
 		next = lm->lm_chain;
 		type = lm->lm_msgtype;
 		ber_free( lm->lm_ber, 1 );
-		free( (char *) lm );
+		LDAP_FREE( (char *) lm );
 	}
 
 	return( type );
@@ -626,17 +693,17 @@ ldap_msgdelete( LDAP *ld, int msgid )
 
 	Debug( LDAP_DEBUG_TRACE, "ldap_msgdelete\n", 0, 0, 0 );
 
-	prev = NULLMSG;
-	for ( lm = ld->ld_responses; lm != NULLMSG; lm = lm->lm_next ) {
+	prev = NULL;
+	for ( lm = ld->ld_responses; lm != NULL; lm = lm->lm_next ) {
 		if ( lm->lm_msgid == msgid )
 			break;
 		prev = lm;
 	}
 
-	if ( lm == NULLMSG )
+	if ( lm == NULL )
 		return( -1 );
 
-	if ( prev == NULLMSG )
+	if ( prev == NULL )
 		ld->ld_responses = lm->lm_next;
 	else
 		prev->lm_next = lm->lm_next;
@@ -652,7 +719,7 @@ ldap_msgdelete( LDAP *ld, int msgid )
  * return 1 if message msgid is waiting to be abandoned, 0 otherwise
  */
 static int
-ldap_abandoned( LDAP *ld, int msgid )
+ldap_abandoned( LDAP *ld, ber_int_t msgid )
 {
 	int	i;
 
@@ -668,7 +735,7 @@ ldap_abandoned( LDAP *ld, int msgid )
 
 
 static int
-ldap_mark_abandoned( LDAP *ld, int msgid )
+ldap_mark_abandoned( LDAP *ld, ber_int_t msgid )
 {
 	int	i;
 
@@ -694,11 +761,19 @@ ldap_mark_abandoned( LDAP *ld, int msgid )
 int
 cldap_getmsg( LDAP *ld, struct timeval *timeout, BerElement *ber )
 {
-	int		rc;
-	unsigned long	tag, len;
+	int	rc;
+	ber_tag_t	tag;
+	ber_len_t	len;
 
 	if ( ! ber_pvt_sb_data_ready(&ld->ld_sb) ) {
-		rc = ldap_select1( ld, timeout );
+		/* restored from ldap_select1() in result.c version 1.24 */
+		fd_set	readfds;
+		if ( ldap_int_tblsize == 0 )
+			ldap_int_ip_init();
+		FD_ZERO( &readfds );
+		FD_SET( ber_pvt_sb_get_desc(&ld->ld_sb), &readfds );
+		rc = select( ldap_int_tblsize, &readfds, 0, 0, timeout );
+
 		if ( rc == -1 || rc == 0 ) {
 			ld->ld_errno = (rc == -1 ? LDAP_SERVER_DOWN :
 			    LDAP_TIMEOUT);
@@ -714,6 +789,6 @@ cldap_getmsg( LDAP *ld, struct timeval *timeout, BerElement *ber )
 		return( -1 );
 	}
 
-	return( tag );
+	return( 0 );
 }
 #endif /* LDAP_CONNECTIONLESS */