Diff for /libraries/libldap/result.c between versions 1.64.2.13 and 1.124.2.11

version 1.64.2.13, 2004/03/26 22:34:27 version 1.124.2.11, 2008/05/28 16:20:07
Line 1 Line 1
 /* $OpenLDAP: pkg/ldap/libraries/libldap/result.c,v 1.64.2.12 2003/02/28 17:07:14 kurt Exp $ */  /* result.c - wait for an ldap result */
 /*  /* $OpenLDAP: pkg/ldap/libraries/libldap/result.c,v 1.124.2.10 2008/02/11 23:26:41 kurt Exp $ */
  * Copyright 1998-2003 The OpenLDAP Foundation, All Rights Reserved.  /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file   *
    * Copyright 1998-2008 The OpenLDAP Foundation.
    * All rights reserved.
    *
    * Redistribution and use in source and binary forms, with or without
    * modification, are permitted only as authorized by the OpenLDAP
    * Public License.
    *
    * A copy of this license is available in the file LICENSE in the
    * top-level directory of the distribution or, alternatively, at
    * <http://www.OpenLDAP.org/license.html>.
  */   */
 /*  Portions  /* Portions Copyright (c) 1990 Regents of the University of Michigan.
  *  Copyright (c) 1990 Regents of the University of Michigan.   * All rights reserved.
  *  All rights reserved.  
  */   */
 /*---  /* This notice applies to changes, created by or for Novell, Inc.,
  * This notice applies to changes, created by or for Novell, Inc.,  
  * to preexisting works for which notices appear elsewhere in this file.   * to preexisting works for which notices appear elsewhere in this file.
  *   *
  * Copyright (C) 1999, 2000 Novell, Inc. All Rights Reserved.   * Copyright (C) 1999, 2000 Novell, Inc. All Rights Reserved.
Line 24 Line 32
  *---   *---
  * Modification to OpenLDAP source by Novell, Inc.   * Modification to OpenLDAP source by Novell, Inc.
  * April 2000 sfs Add code to process V3 referrals and search results   * April 2000 sfs Add code to process V3 referrals and search results
  *   *---
  *  result.c - wait for an ldap result   * Note: A verbatim copy of version 2.0.1 of the OpenLDAP Public License 
  */  
 /* Note: A verbatim copy of version 2.0.1 of the OpenLDAP Public License   
  * can be found in the file "build/LICENSE-2.0.1" in this distribution   * can be found in the file "build/LICENSE-2.0.1" in this distribution
  * of OpenLDAP Software.   * of OpenLDAP Software.
  */   */
   
 /*  /*
  * LDAPv3 (RFC2251)   * LDAPv3 (RFC 4511)
  *      LDAPResult ::= SEQUENCE {   *      LDAPResult ::= SEQUENCE {
  *              resultCode              ENUMERATED { ... },   *              resultCode                      ENUMERATED { ... },
  *              matchedDN               LDAPDN,   *              matchedDN                       LDAPDN,
  *              errorMessage    LDAPString,   *              diagnosticMessage               LDAPString,
  *              referral                Referral OPTIONAL   *              referral                        [3] Referral OPTIONAL
  *      }   *      }
  *      Referral ::= SEQUENCE OF LDAPURL        (one or more)   *      Referral ::= SEQUENCE OF LDAPURL        (one or more)
  *      LDAPURL ::= LDAPString                          (limited to URL chars)   *      LDAPURL ::= LDAPString                  (limited to URL chars)
  */   */
   
 #include "portable.h"  #include "portable.h"
Line 58 Line 64
   
 #include "ldap-int.h"  #include "ldap-int.h"
 #include "ldap_log.h"  #include "ldap_log.h"
   #include "lutil.h"
   
 static int ldap_abandoned LDAP_P(( LDAP *ld, ber_int_t msgid ));  static int ldap_abandoned LDAP_P(( LDAP *ld, ber_int_t msgid, int *idx ));
 static int ldap_mark_abandoned LDAP_P(( LDAP *ld, ber_int_t msgid ));  static int ldap_mark_abandoned LDAP_P(( LDAP *ld, ber_int_t msgid, int idx ));
 static int wait4msg LDAP_P(( LDAP *ld, ber_int_t msgid, int all, struct timeval *timeout,  static int wait4msg LDAP_P(( LDAP *ld, ber_int_t msgid, int all, struct timeval *timeout,
         LDAPMessage **result ));          LDAPMessage **result ));
 static ber_tag_t try_read1msg LDAP_P(( LDAP *ld, ber_int_t msgid,  static ber_tag_t try_read1msg LDAP_P(( LDAP *ld, ber_int_t msgid,
         int all, Sockbuf *sb, LDAPConn **lc, LDAPMessage **result ));          int all, LDAPConn **lc, LDAPMessage **result ));
 static ber_tag_t build_result_ber LDAP_P(( LDAP *ld, BerElement **bp, LDAPRequest *lr ));  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 ));  static void merge_error_info LDAP_P(( LDAP *ld, LDAPRequest *parentr, LDAPRequest *lr ));
 static LDAPMessage * chkResponseList LDAP_P(( LDAP *ld, int msgid, int all));  static LDAPMessage * chkResponseList LDAP_P(( LDAP *ld, int msgid, int all));
   
   #define LDAP_MSG_X_KEEP_LOOKING         (-2)
   
   
 /*  /*
  * ldap_result - wait for an ldap result response to a message from the   * ldap_result - wait for an ldap result response to a message from the
Line 83  static LDAPMessage * chkResponseList LDA Line 92  static LDAPMessage * chkResponseList LDA
  * search references, followed by an ldap result).  An extension to   * search references, followed by an ldap result).  An extension to
  * LDAPv3 allows partial extended responses to be returned in response   * LDAPv3 allows partial extended responses to be returned in response
  * to any request.  The type of the first message received is returned.   * to any request.  The type of the first message received is returned.
  * When waiting, any messages that have been abandoned are discarded.   * When waiting, any messages that have been abandoned/discarded are 
    * discarded.
  *   *
  * Example:   * Example:
  *      ldap_result( s, msgid, all, timeout, result )   *      ldap_result( s, msgid, all, timeout, result )
Line 96  ldap_result( Line 106  ldap_result(
         struct timeval *timeout,          struct timeval *timeout,
         LDAPMessage **result )          LDAPMessage **result )
 {  {
         LDAPMessage     *lm;          LDAPMessage     *lm = NULL;
           int             rc;
   
         assert( ld != NULL );          assert( ld != NULL );
         assert( result != NULL );          assert( result != NULL );
   
 #ifdef NEW_LOGGING          Debug( LDAP_DEBUG_TRACE, "ldap_result ld %p msgid %d\n", (void *)ld, msgid, 0 );
         LDAP_LOG ( OPERATION, ARGS, "ldap_result msgid %d\n", msgid, 0, 0 );  
 #else  #ifdef LDAP_R_COMPILE
         Debug( LDAP_DEBUG_TRACE, "ldap_result msgid %d\n", msgid, 0, 0 );          ldap_pvt_thread_mutex_lock( &ld->ld_res_mutex );
 #endif  #endif
   
     lm = chkResponseList(ld, msgid, all);  #if 0
           /* this is already done inside wait4msg(), right?... */
           lm = chkResponseList( ld, msgid, all );
   #endif
   
         if ( lm == NULL ) {          if ( lm == NULL ) {
                 return( wait4msg( ld, msgid, all, timeout, result ) );                  rc = wait4msg( ld, msgid, all, timeout, result );
   
           } else {
                   *result = lm;
                   ld->ld_errno = LDAP_SUCCESS;
                   rc = lm->lm_msgtype;
         }          }
   
         *result = lm;  #ifdef LDAP_R_COMPILE
         ld->ld_errno = LDAP_SUCCESS;          ldap_pvt_thread_mutex_unlock( &ld->ld_res_mutex );
         return( lm->lm_msgtype );  #endif
   
           return rc;
 }  }
   
 static LDAPMessage *  static LDAPMessage *
Line 124  chkResponseList( Line 145  chkResponseList(
         int msgid,          int msgid,
         int all)          int all)
 {  {
         LDAPMessage     *lm, *lastlm, *nextlm;          LDAPMessage     *lm, **lastlm, *nextlm;
     /*          int             cnt = 0;
   
           /*
          * Look through the list of responses we have received on           * Look through the list of responses we have received on
          * this association and see if the response we're interested in           * this association and see if the response we're interested in
          * is there.  If it is, return it.  If not, call wait4msg() to           * is there.  If it is, return it.  If not, call wait4msg() to
          * wait until it arrives or timeout occurs.           * wait until it arrives or timeout occurs.
          */           */
   
 #ifdef NEW_LOGGING  #ifdef LDAP_R_COMPILE
         LDAP_LOG ( OPERATION, ARGS, "ldap_chkResponseList for msgid=%d, all=%d\n",           LDAP_PVT_THREAD_ASSERT_MUTEX_OWNER( &ld->ld_res_mutex );
                 msgid, all, 0 );  
 #else  
         Debug( LDAP_DEBUG_TRACE,  
                 "ldap_chkResponseList for msgid=%d, all=%d\n",  
             msgid, all, 0 );  
 #endif  #endif
         lastlm = NULL;  
           Debug( LDAP_DEBUG_TRACE,
                   "ldap_chkResponseList ld %p msgid %d all %d\n",
                   (void *)ld, msgid, all );
   
           lastlm = &ld->ld_responses;
         for ( lm = ld->ld_responses; lm != NULL; lm = nextlm ) {          for ( lm = ld->ld_responses; lm != NULL; lm = nextlm ) {
                   int     idx;
   
                 nextlm = lm->lm_next;                  nextlm = lm->lm_next;
                   ++cnt;
   
                 if ( ldap_abandoned( ld, lm->lm_msgid ) ) {                  if ( ldap_abandoned( ld, lm->lm_msgid, &idx ) ) {
 #ifdef NEW_LOGGING                          Debug( LDAP_DEBUG_ANY,
                         LDAP_LOG ( OPERATION, DETAIL1,                                   "response list msg abandoned, "
                                 "ldap_chkResponseList msg abandoned, msgid %d\n", msgid, 0, 0 );                                  "msgid %d message type %s\n",
 #else                                  lm->lm_msgid, ldap_int_msgtype2str( lm->lm_msgtype ), 0 );
                         Debug( LDAP_DEBUG_TRACE,  
                                 "ldap_chkResponseList msg abandoned, msgid %d\n",                          switch ( lm->lm_msgtype ) {
                             msgid, 0, 0 );                          case LDAP_RES_SEARCH_ENTRY:
 #endif                          case LDAP_RES_SEARCH_REFERENCE:
                         ldap_mark_abandoned( ld, lm->lm_msgid );                          case LDAP_RES_INTERMEDIATE:
                                   break;
   
                         if ( lastlm == NULL ) {                          default:
                                 /* Remove first entry in list */                                  /* there's no need to keep the id
                                 ld->ld_responses = lm->lm_next;                                   * in the abandoned list any longer */
                         } else {                                  ldap_mark_abandoned( ld, lm->lm_msgid, idx );
                                 lastlm->lm_next = nextlm;                                  break;
                         }                          }
   
                           /* Remove this entry from list */
                           *lastlm = nextlm;
   
                         ldap_msgfree( lm );                          ldap_msgfree( lm );
   
                         continue;                          continue;
Line 170  chkResponseList( Line 200  chkResponseList(
                 if ( msgid == LDAP_RES_ANY || lm->lm_msgid == msgid ) {                  if ( msgid == LDAP_RES_ANY || lm->lm_msgid == msgid ) {
                         LDAPMessage     *tmp;                          LDAPMessage     *tmp;
   
                         if ( all == LDAP_MSG_ONE || msgid == LDAP_RES_UNSOLICITED ) {                          if ( all == LDAP_MSG_ONE ||
                                   all == LDAP_MSG_RECEIVED ||
                                   msgid == LDAP_RES_UNSOLICITED )
                           {
                                 break;                                  break;
                         }                          }
   
                         for ( tmp = lm; tmp != NULL; tmp = tmp->lm_chain ) {                          tmp = lm->lm_chain_tail;
                                 if ( tmp->lm_msgtype != LDAP_RES_SEARCH_ENTRY                          if ( tmp->lm_msgtype == LDAP_RES_SEARCH_ENTRY ||
                                     && tmp->lm_msgtype != LDAP_RES_SEARCH_REFERENCE                                  tmp->lm_msgtype == LDAP_RES_SEARCH_REFERENCE ||
                                         && tmp->lm_msgtype != LDAP_RES_EXTENDED_PARTIAL )                                  tmp->lm_msgtype == LDAP_RES_INTERMEDIATE )
                                 {                          {
                                         break;                                  tmp = NULL;
                                 }  
                         }                          }
   
                         if ( tmp == NULL ) {                          if ( tmp == NULL ) {
Line 189  chkResponseList( Line 221  chkResponseList(
   
                         break;                          break;
                 }                  }
                 lastlm = lm;                  lastlm = &lm->lm_next;
         }          }
   
     if ( lm != NULL ) {          if ( lm != NULL ) {
                 /* Found an entry, remove it from the list */                  /* Found an entry, remove it from the list */
             if ( lastlm == NULL ) {                  if ( all == LDAP_MSG_ONE && lm->lm_chain != NULL ) {
                     ld->ld_responses = (all == LDAP_MSG_ONE && lm->lm_chain != NULL                          *lastlm = lm->lm_chain;
                         ? lm->lm_chain : lm->lm_next);                          lm->lm_chain->lm_next = lm->lm_next;
             } else {                          lm->lm_chain->lm_chain_tail = ( lm->lm_chain_tail != lm ) ? lm->lm_chain_tail : lm->lm_chain;
                     lastlm->lm_next = (all == LDAP_MSG_ONE && lm->lm_chain != NULL                          lm->lm_chain = NULL;
                         ? lm->lm_chain : lm->lm_next);                          lm->lm_chain_tail = NULL;
             }                  } else {
             if ( all == LDAP_MSG_ONE && lm->lm_chain != NULL ) {                          *lastlm = lm->lm_next;
                     lm->lm_chain->lm_next = lm->lm_next;                  }
                     lm->lm_chain = NULL;                  lm->lm_next = NULL;
             }          }
             lm->lm_next = NULL;  
     }  
   
 #ifdef LDAP_DEBUG  #ifdef LDAP_DEBUG
         if( lm == NULL) {          if ( lm == NULL) {
 #ifdef NEW_LOGGING  
                 LDAP_LOG ( OPERATION, RESULTS, "ldap_chkResponseList returns NULL\n",  
                         0, 0, 0 );  
 #else  
                 Debug( LDAP_DEBUG_TRACE,                  Debug( LDAP_DEBUG_TRACE,
                         "ldap_chkResponseList returns NULL\n", 0, 0, 0);                          "ldap_chkResponseList returns ld %p NULL\n", (void *)ld, 0, 0);
 #endif  
         } else {          } else {
 #ifdef NEW_LOGGING  
                 LDAP_LOG ( OPERATION, RESULTS,   
                         "ldap_chkResponseList returns msgid %d, type 0x%02lu\n",  
                         lm->lm_msgid, (unsigned long) lm->lm_msgtype, 0 );  
 #else  
                 Debug( LDAP_DEBUG_TRACE,                  Debug( LDAP_DEBUG_TRACE,
                         "ldap_chkResponseList returns msgid %d, type 0x%02lu\n",                          "ldap_chkResponseList returns ld %p msgid %d, type 0x%02lx\n",
                         lm->lm_msgid, (unsigned long) lm->lm_msgtype, 0);                          (void *)ld, lm->lm_msgid, (unsigned long)lm->lm_msgtype );
 #endif  
         }          }
 #endif  #endif
     return lm;  
           return lm;
 }  }
   
 static int  static int
Line 241  wait4msg( Line 261  wait4msg(
         LDAPMessage **result )          LDAPMessage **result )
 {  {
         int             rc;          int             rc;
         struct timeval  tv, *tvp;          struct timeval  tv = { 0 },
         time_t          start_time = 0;                          tv0 = { 0 },
         time_t          tmp_time;                          start_time_tv = { 0 },
         LDAPConn        *lc, *nextlc;                          *tvp = NULL;
           LDAPConn        *lc;
   
         assert( ld != NULL );          assert( ld != NULL );
         assert( result != NULL );          assert( result != NULL );
   
   #ifdef LDAP_R_COMPILE
           LDAP_PVT_THREAD_ASSERT_MUTEX_OWNER( &ld->ld_res_mutex );
   #endif
   
           if ( timeout == NULL && ld->ld_options.ldo_tm_api.tv_sec >= 0 ) {
                   tv = ld->ld_options.ldo_tm_api;
                   timeout = &tv;
           }
   
 #ifdef LDAP_DEBUG  #ifdef LDAP_DEBUG
         if ( timeout == NULL ) {          if ( timeout == NULL ) {
 #ifdef NEW_LOGGING                  Debug( LDAP_DEBUG_TRACE, "wait4msg ld %p msgid %d (infinite timeout)\n",
                 LDAP_LOG ( OPERATION, ARGS,                           (void *)ld, msgid, 0 );
                         "wait4msg (infinite timeout), msgid %d\n", msgid, 0, 0 );  
 #else  
                 Debug( LDAP_DEBUG_TRACE, "wait4msg (infinite timeout), msgid %d\n",  
                     msgid, 0, 0 );  
 #endif  
         } else {          } else {
 #ifdef NEW_LOGGING                  Debug( LDAP_DEBUG_TRACE, "wait4msg ld %p msgid %d (timeout %ld usec)\n",
                 LDAP_LOG ( OPERATION, ARGS,                           (void *)ld, msgid, (long)timeout->tv_sec * 1000000 + timeout->tv_usec );
                         "wait4msg (timeout %ld sec, %ld usec), msgid %d\n",   
                         (long) timeout->tv_sec, (long) timeout->tv_usec, msgid );  
 #else  
                 Debug( LDAP_DEBUG_TRACE, "wait4msg (timeout %ld sec, %ld usec), msgid %d\n",  
                        (long) timeout->tv_sec, (long) timeout->tv_usec, msgid );  
 #endif  
         }          }
 #endif /* LDAP_DEBUG */  #endif /* LDAP_DEBUG */
   
         if ( timeout == NULL ) {          if ( timeout != NULL ) {
                 tvp = NULL;                  tv0 = *timeout;
         } else {  
                 tv = *timeout;                  tv = *timeout;
                 tvp = &tv;                  tvp = &tv;
                 start_time = time( NULL );  #ifdef HAVE_GETTIMEOFDAY
                   gettimeofday( &start_time_tv, NULL );
   #else /* ! HAVE_GETTIMEOFDAY */
                   time( &start_time_tv.tv_sec );
                   start_time_tv.tv_usec = 0;
   #endif /* ! HAVE_GETTIMEOFDAY */
         }          }
                                           
         rc = -2;          rc = LDAP_MSG_X_KEEP_LOOKING;
         while ( rc == -2 ) {          while ( rc == LDAP_MSG_X_KEEP_LOOKING ) {
 #ifdef LDAP_DEBUG  #ifdef LDAP_DEBUG
 #ifdef NEW_LOGGING  
                 LDAP_LOG ( OPERATION, ARGS,   
                         "wait4msg continue, msgid %d, all %d\n", msgid, all, 0 );  
 #else  
                 Debug( LDAP_DEBUG_TRACE, "wait4msg continue, msgid %d, all %d\n",  
                     msgid, all, 0 );  
 #endif  
                 if ( ldap_debug & LDAP_DEBUG_TRACE ) {                  if ( ldap_debug & LDAP_DEBUG_TRACE ) {
                           Debug( LDAP_DEBUG_TRACE, "wait4msg continue ld %p msgid %d all %d\n",
                                   (void *)ld, msgid, all );
   #ifdef LDAP_R_COMPILE
                           ldap_pvt_thread_mutex_lock( &ld->ld_conn_mutex );
   #endif
                         ldap_dump_connection( ld, ld->ld_conns, 1 );                          ldap_dump_connection( ld, ld->ld_conns, 1 );
   #ifdef LDAP_R_COMPILE
                           ldap_pvt_thread_mutex_unlock( &ld->ld_conn_mutex );
                           ldap_pvt_thread_mutex_lock( &ld->ld_req_mutex );
   #endif
                         ldap_dump_requests_and_responses( ld );                          ldap_dump_requests_and_responses( ld );
   #ifdef LDAP_R_COMPILE
                           ldap_pvt_thread_mutex_unlock( &ld->ld_req_mutex );
   #endif
                 }                  }
 #endif /* LDAP_DEBUG */  #endif /* LDAP_DEBUG */
   
         if( (*result = chkResponseList(ld, msgid, all)) != NULL ) {                  if ( ( *result = chkResponseList( ld, msgid, all ) ) != NULL ) {
             rc = (*result)->lm_msgtype;                          rc = (*result)->lm_msgtype;
         } else {  
   
                         for ( lc = ld->ld_conns; lc != NULL; lc = nextlc ) {                  } else {
                                 nextlc = lc->lconn_next;                          int lc_ready = 0;
   
   #ifdef LDAP_R_COMPILE
                           ldap_pvt_thread_mutex_lock( &ld->ld_conn_mutex );
   #endif
                           for ( lc = ld->ld_conns; lc != NULL; lc = lc->lconn_next ) {
                                 if ( ber_sockbuf_ctrl( lc->lconn_sb,                                  if ( ber_sockbuf_ctrl( lc->lconn_sb,
                                                 LBER_SB_OPT_DATA_READY, NULL ) ) {                                          LBER_SB_OPT_DATA_READY, NULL ) )
                                         rc = try_read1msg( ld, msgid, all, lc->lconn_sb,                                  {
                                                 &lc, result );  #ifdef LDAP_R_COMPILE
                                     break;                                          ldap_pvt_thread_mutex_unlock( &ld->ld_conn_mutex );
   #endif
                                           rc = try_read1msg( ld, msgid, all, &lc, result );
   #ifdef LDAP_R_COMPILE
                                           ldap_pvt_thread_mutex_lock( &ld->ld_conn_mutex );
   #endif
                                           lc_ready = 1;
                                           break;
                                 }                                  }
                 }                          }
   #ifdef LDAP_R_COMPILE
                           ldap_pvt_thread_mutex_unlock( &ld->ld_conn_mutex );
   #endif
   
                     if ( lc == NULL ) {                          if ( !lc_ready ) {
                             rc = ldap_int_select( ld, tvp );                                  rc = ldap_int_select( ld, tvp );
   #ifdef LDAP_DEBUG
                                   if ( rc == -1 ) {
                                           Debug( LDAP_DEBUG_TRACE,
                                                   "ldap_int_select returned -1: errno %d\n",
                                                   sock_errno(), 0, 0 );
                                   }
   #endif
   
                                   if ( rc == 0 || ( rc == -1 && (
                                           !LDAP_BOOL_GET(&ld->ld_options, LDAP_BOOL_RESTART)
                                                   || sock_errno() != EINTR ) ) )
                                   {
                                           ld->ld_errno = (rc == -1 ? LDAP_SERVER_DOWN :
                                                   LDAP_TIMEOUT);
                                           return( rc );
                                   }
   
 #ifdef LDAP_DEBUG                                  if ( rc == -1 ) {
                             if ( rc == -1 ) {                                          rc = LDAP_MSG_X_KEEP_LOOKING;   /* select interrupted: loop */
 #ifdef NEW_LOGGING  
                                         LDAP_LOG ( OPERATION, ARGS,                                   } else {
                                                 "wait4msg: ldap_int_select returned -1: errno %d\n",                                           rc = LDAP_MSG_X_KEEP_LOOKING;
                                                 errno, 0, 0 );  #ifdef LDAP_R_COMPILE
 #else                                          ldap_pvt_thread_mutex_lock( &ld->ld_req_mutex );
                                 Debug( LDAP_DEBUG_TRACE,  #endif
                                         "ldap_int_select returned -1: errno %d\n",                                          if ( ld->ld_requests &&
                                         errno, 0, 0 );  
 #endif  
                             }  
 #endif  
   
                             if ( rc == 0 || ( rc == -1 && (  
                                     !LDAP_BOOL_GET(&ld->ld_options, LDAP_BOOL_RESTART)  
                                     || errno != EINTR )))  
                             {  
                                     ld->ld_errno = (rc == -1 ? LDAP_SERVER_DOWN :  
                                         LDAP_TIMEOUT);  
                                     return( rc );  
                             }  
   
                             if ( rc == -1 ) {  
                                     rc = -2;    /* select interrupted: loop */  
                             } else {  
                                     rc = -2;  
                                     if ( ld->ld_requests &&  
                                                 ld->ld_requests->lr_status == LDAP_REQST_WRITING &&                                                  ld->ld_requests->lr_status == LDAP_REQST_WRITING &&
                                                 ldap_is_write_ready( ld,                                                  ldap_is_write_ready( ld,
                                                         ld->ld_requests->lr_conn->lconn_sb ) ) {                                                          ld->ld_requests->lr_conn->lconn_sb ) )
                                           {
                                                 ldap_int_flush_request( ld, ld->ld_requests );                                                  ldap_int_flush_request( ld, ld->ld_requests );
                                         }                                          }
                                     for ( lc = ld->ld_conns; rc == -2 && lc != NULL;  #ifdef LDAP_R_COMPILE
                                         lc = nextlc ) {                                          ldap_pvt_thread_mutex_unlock( &ld->ld_req_mutex );
                                             nextlc = lc->lconn_next;                                          ldap_pvt_thread_mutex_lock( &ld->ld_conn_mutex );
                                             if ( lc->lconn_status ==  #endif
                                                 LDAP_CONNST_CONNECTED &&                                          for ( lc = ld->ld_conns;
                                                 ldap_is_read_ready( ld,                                                  rc == LDAP_MSG_X_KEEP_LOOKING && lc != NULL; )
                                                 lc->lconn_sb )) {                                          {
                                                     rc = try_read1msg( ld, msgid, all,                                                  if ( lc->lconn_status == LDAP_CONNST_CONNECTED &&
                                                         lc->lconn_sb, &lc, result );                                                          ldap_is_read_ready( ld, lc->lconn_sb ) )
                                                         if ( lc == NULL ) lc = nextlc;                                                  {
                                             }  #ifdef LDAP_R_COMPILE
                                     }                                                          ldap_pvt_thread_mutex_unlock( &ld->ld_conn_mutex );
                             }  #endif
                     }                                                          rc = try_read1msg( ld, msgid, all, &lc, result );
                 }  #ifdef LDAP_R_COMPILE
                                                           ldap_pvt_thread_mutex_lock( &ld->ld_conn_mutex );
                 if ( rc == -2 && tvp != NULL ) {  #endif
                         tmp_time = time( NULL );                                                          if ( lc == NULL ) {
                         if (( tv.tv_sec -=  ( tmp_time - start_time )) <= 0 ) {                                                                  /* if lc gets free()'d,
                                 rc = 0; /* timed out */                                                                   * there's no guarantee
                                                                    * lc->lconn_next is still
                                                                    * sane; better restart
                                                                    * (ITS#4405) */
                                                                   lc = ld->ld_conns;
   
                                                                   /* don't get to next conn! */
                                                                   break;
                                                           }
                                                   }
   
                                                   /* next conn */
                                                   lc = lc->lconn_next;
                                           }
   #ifdef LDAP_R_COMPILE
                                           ldap_pvt_thread_mutex_unlock( &ld->ld_conn_mutex );
   #endif
                                   }
                           }
                   }
   
                   if ( rc == LDAP_MSG_X_KEEP_LOOKING && tvp != NULL ) {
                           struct timeval  curr_time_tv = { 0 },
                                           delta_time_tv = { 0 };
   
   #ifdef HAVE_GETTIMEOFDAY
                           gettimeofday( &curr_time_tv, NULL );
   #else /* ! HAVE_GETTIMEOFDAY */
                           time( &curr_time_tv.tv_sec );
                           curr_time_tv.tv_usec = 0;
   #endif /* ! HAVE_GETTIMEOFDAY */
   
                           /* delta_time = tmp_time - start_time */
                           delta_time_tv.tv_sec = curr_time_tv.tv_sec - start_time_tv.tv_sec;
                           delta_time_tv.tv_usec = curr_time_tv.tv_usec - start_time_tv.tv_usec;
                           if ( delta_time_tv.tv_usec < 0 ) {
                                   delta_time_tv.tv_sec--;
                                   delta_time_tv.tv_usec += 1000000;
                           }
   
                           /* tv0 < delta_time ? */
                           if ( ( tv0.tv_sec < delta_time_tv.tv_sec ) ||
                                ( ( tv0.tv_sec == delta_time_tv.tv_sec ) && ( tv0.tv_usec < delta_time_tv.tv_usec ) ) )
                           {
                                   rc = 0; /* timed out */
                                 ld->ld_errno = LDAP_TIMEOUT;                                  ld->ld_errno = LDAP_TIMEOUT;
                                 break;                                  break;
                         }                          }
   
 #ifdef NEW_LOGGING                          /* tv0 -= delta_time */
                         LDAP_LOG ( OPERATION, DETAIL1,                           tv0.tv_sec -= delta_time_tv.tv_sec;
                                 "wait4msg: %ld secs to go\n", (long) tv.tv_sec, 0, 0 );                          tv0.tv_usec -= delta_time_tv.tv_usec;
 #else                          if ( tv0.tv_usec < 0 ) {
                         Debug( LDAP_DEBUG_TRACE, "wait4msg:  %ld secs to go\n",                                  tv0.tv_sec--;
                                (long) tv.tv_sec, 0, 0 );                                  tv0.tv_usec += 1000000;
 #endif                          }
                         start_time = tmp_time;  
                           tv.tv_sec = tv0.tv_sec;
                           tv.tv_usec = tv0.tv_usec;
   
                           Debug( LDAP_DEBUG_TRACE, "wait4msg ld %p %ld s %ld us to go\n",
                                   (void *)ld, (long) tv.tv_sec, (long) tv.tv_usec );
   
                           start_time_tv.tv_sec = curr_time_tv.tv_sec;
                           start_time_tv.tv_usec = curr_time_tv.tv_usec;
                 }                  }
         }          }
   
Line 389  try_read1msg( Line 480  try_read1msg(
         LDAP *ld,          LDAP *ld,
         ber_int_t msgid,          ber_int_t msgid,
         int all,          int all,
         Sockbuf *sb,  
         LDAPConn **lcp,          LDAPConn **lcp,
         LDAPMessage **result )          LDAPMessage **result )
 {  {
         BerElement      *ber;          BerElement      *ber;
         LDAPMessage     *new, *l, *prev, *tmp;          LDAPMessage     *newmsg, *l, *prev;
         ber_int_t       id;          ber_int_t       id;
           int             idx;
         ber_tag_t       tag;          ber_tag_t       tag;
         ber_len_t       len;          ber_len_t       len;
         int             foundit = 0;          int             foundit = 0;
         LDAPRequest     *lr, *tmplr;          LDAPRequest     *lr, *tmplr, dummy_lr = { 0 };
         LDAPConn        *lc;          LDAPConn        *lc;
         BerElement      tmpber;          BerElement      tmpber;
         int             rc, refer_cnt, hadref, simple_request;          int             rc, refer_cnt, hadref, simple_request;
         ber_int_t       lderr;          ber_int_t       lderr;
   
 #ifdef LDAP_CONNECTIONLESS  #ifdef LDAP_CONNECTIONLESS
         int             firstmsg = 1, moremsgs = 0, isv2 = 0;          LDAPMessage     *tmp = NULL, *chain_head = NULL;
           int             moremsgs = 0, isv2 = 0;
 #endif  #endif
         /*  
          * v3ref = flag for V3 referral / search reference  
          * 0 = not a ref, 1 = sucessfully chased ref, -1 = pass ref to application  
          */  
         int     v3ref;  
   
         assert( ld != NULL );          assert( ld != NULL );
         assert( lcp != NULL );          assert( lcp != NULL );
         assert( *lcp != NULL );          assert( *lcp != NULL );
                   
 #ifdef NEW_LOGGING  #ifdef LDAP_R_COMPILE
         LDAP_LOG ( OPERATION, ARGS, "read1msg: msgid %d, all %d\n", msgid, all, 0 );          LDAP_PVT_THREAD_ASSERT_MUTEX_OWNER( &ld->ld_res_mutex );
 #else  
         Debug( LDAP_DEBUG_TRACE, "read1msg: msgid %d, all %d\n", msgid, all, 0 );  
 #endif  #endif
   
           Debug( LDAP_DEBUG_TRACE, "read1msg: ld %p msgid %d all %d\n",
                   (void *)ld, msgid, all );
   
         lc = *lcp;          lc = *lcp;
   
 retry:  retry:
     if ( lc->lconn_ber == NULL ) {          if ( lc->lconn_ber == NULL ) {
                 lc->lconn_ber = ldap_alloc_ber_with_options(ld);                  lc->lconn_ber = ldap_alloc_ber_with_options( ld );
   
                 if( lc->lconn_ber == NULL ) {                  if ( lc->lconn_ber == NULL ) {
                         return -1;                          return -1;
                 }                  }
     }          }
   
         ber = lc->lconn_ber;          ber = lc->lconn_ber;
         assert( LBER_VALID (ber) );          assert( LBER_VALID (ber) );
   
 retry2:  
         /* get the next message */          /* get the next message */
         errno = 0;          sock_errset(0);
 #ifdef LDAP_CONNECTIONLESS  #ifdef LDAP_CONNECTIONLESS
         if ( LDAP_IS_UDP(ld) ) {          if ( LDAP_IS_UDP(ld) ) {
                 struct sockaddr from;                  struct sockaddr from;
                 ber_int_sb_read(sb, &from, sizeof(struct sockaddr));                  ber_int_sb_read( lc->lconn_sb, &from, sizeof(struct sockaddr) );
                 if (ld->ld_options.ldo_version == LDAP_VERSION2) isv2=1;                  if ( ld->ld_options.ldo_version == LDAP_VERSION2 ) isv2 = 1;
         }          }
 nextresp3:  nextresp3:
 #endif  #endif
         if ( (tag = ber_get_next( sb, &len, ber ))          tag = ber_get_next( lc->lconn_sb, &len, ber );
             != LDAP_TAG_MESSAGE ) {          switch ( tag ) {
                 if ( tag == LBER_DEFAULT) {          case LDAP_TAG_MESSAGE:
                   /*
                    * We read a complete message.
                    * The connection should no longer need this ber.
                    */
                   lc->lconn_ber = NULL;
                   break;
   
           case LBER_DEFAULT:
 #ifdef LDAP_DEBUG                    #ifdef LDAP_DEBUG                  
 #ifdef NEW_LOGGING                  Debug( LDAP_DEBUG_CONNS,
                         LDAP_LOG ( OPERATION, DETAIL1,                           "ber_get_next failed.\n", 0, 0, 0 );
                                 "read1msg: ber_get_next failed\n", 0, 0, 0 );  
 #else  
                         Debug( LDAP_DEBUG_CONNS,  
                               "ber_get_next failed.\n", 0, 0, 0 );  
 #endif               
 #endif               #endif             
 #ifdef EWOULDBLOCK                        #ifdef EWOULDBLOCK                      
                         if (errno==EWOULDBLOCK) return -2;                  if ( sock_errno() == EWOULDBLOCK ) return LDAP_MSG_X_KEEP_LOOKING;
 #endif  #endif
 #ifdef EAGAIN  #ifdef EAGAIN
                         if (errno == EAGAIN) return -2;                  if ( sock_errno() == EAGAIN ) return LDAP_MSG_X_KEEP_LOOKING;
 #endif  #endif
                         ld->ld_errno = LDAP_SERVER_DOWN;                  ld->ld_errno = LDAP_SERVER_DOWN;
                         return -1;  #ifdef LDAP_R_COMPILE
                 }                  ldap_pvt_thread_mutex_lock( &ld->ld_req_mutex );
   #endif
                   ldap_free_connection( ld, lc, 1, 0 );
   #ifdef LDAP_R_COMPILE
                   ldap_pvt_thread_mutex_unlock( &ld->ld_req_mutex );
   #endif
                   lc = *lcp = NULL;
                   return -1;
   
           default:
                 ld->ld_errno = LDAP_LOCAL_ERROR;                  ld->ld_errno = LDAP_LOCAL_ERROR;
                 return -1;                  return -1;
         }          }
   
         /*  
      * We read a complete message.  
          * The connection should no longer need this ber.  
          */  
     lc->lconn_ber = NULL;  
   
         /* message id */          /* message id */
         if ( ber_get_int( ber, &id ) == LBER_ERROR ) {          if ( ber_get_int( ber, &id ) == LBER_ERROR ) {
                 ber_free( ber, 1 );                  ber_free( ber, 1 );
Line 486  nextresp3: Line 580  nextresp3:
                 return( -1 );                  return( -1 );
         }          }
   
           /* id == 0 iff unsolicited notification message (RFC 4511) */
   
           /* id < 0 is invalid, just toss it. FIXME: should we disconnect? */
           if ( id < 0 ) {
                   goto retry_ber;
           }
           
         /* if it's been abandoned, toss it */          /* if it's been abandoned, toss it */
         if ( ldap_abandoned( ld, id ) ) {          if ( id > 0 ) {
 #ifdef NEW_LOGGING                  if ( ldap_abandoned( ld, id, &idx ) ) {
                 LDAP_LOG ( OPERATION, DETAIL1, "read1msg: abandoned\n", 0, 0, 0 );                          /* the message type */
 #else                          tag = ber_peek_tag( ber, &len );
                 Debug( LDAP_DEBUG_ANY, "abandoned\n", 0, 0, 0);                          switch ( tag ) {
 #endif                          case LDAP_RES_SEARCH_ENTRY:
                           case LDAP_RES_SEARCH_REFERENCE:
                           case LDAP_RES_INTERMEDIATE:
                           case LBER_ERROR:
                                   break;
   
                           default:
                                   /* there's no need to keep the id
                                    * in the abandoned list any longer */
                                   ldap_mark_abandoned( ld, id, idx );
                                   break;
                           }
   
                           Debug( LDAP_DEBUG_ANY,
                                   "abandoned/discarded ld %p msgid %d message type %s\n",
                                   (void *)ld, id, ldap_int_msgtype2str( tag ) );
   
 retry_ber:  retry_ber:
                 if ( ber_sockbuf_ctrl( sb, LBER_SB_OPT_DATA_READY, NULL ) ) {                          ber_free( ber, 1 );
                         ber_free_buf( ber );                          if ( ber_sockbuf_ctrl( lc->lconn_sb, LBER_SB_OPT_DATA_READY, NULL ) ) {
                         ber_init2( ber, NULL, ld->ld_lberoptions );                                  goto retry;
                         goto retry2;                          }
                           return( LDAP_MSG_X_KEEP_LOOKING );      /* continue looking */
                   }
   
                   lr = ldap_find_request_by_msgid( ld, id );
                   if ( lr == NULL ) {
                           const char      *msg = "unknown";
   
                           /* the message type */
                           tag = ber_peek_tag( ber, &len );
                           switch ( tag ) {
                           case LBER_ERROR:
                                   break;
   
                           default:
                                   msg = ldap_int_msgtype2str( tag );
                                   break;
                           }
   
                           Debug( LDAP_DEBUG_ANY,
                                   "no request for response on ld %p msgid %d message type %s (tossing)\n",
                                   (void *)ld, id, msg );
   
                           goto retry_ber;
                 }                  }
                 ber_free( ber, 1 );  
                 return( -2 );   /* continue looking */  
         }  
   
         if (( lr = ldap_find_request_by_msgid( ld, id )) == NULL ) {  
 #ifdef NEW_LOGGING  
                 LDAP_LOG ( OPERATION, DETAIL1,   
                         "read1msg: no request for response with msgid %ld (tossing)\n",  
                         (long) id, 0, 0 );  
 #else  
                 Debug( LDAP_DEBUG_ANY,  
                     "no request for response with msgid %ld (tossing)\n",  
                     (long) id, 0, 0 );  
 #endif  
                 goto retry_ber;  
         }  
 #ifdef LDAP_CONNECTIONLESS  #ifdef LDAP_CONNECTIONLESS
         if (LDAP_IS_UDP(ld) && isv2) {                  if ( LDAP_IS_UDP(ld) && isv2 ) {
                 ber_scanf(ber, "x{");                          ber_scanf(ber, "x{");
         }                  }
 nextresp2:  nextresp2:
 #endif  #endif
           }
   
         /* the message type */          /* the message type */
         if ( (tag = ber_peek_tag( ber, &len )) == LBER_ERROR ) {          tag = ber_peek_tag( ber, &len );
           if ( tag == LBER_ERROR ) {
                 ld->ld_errno = LDAP_DECODING_ERROR;                  ld->ld_errno = LDAP_DECODING_ERROR;
                 ber_free( ber, 1 );                  ber_free( ber, 1 );
                 return( -1 );                  return( -1 );
         }          }
   
 #ifdef NEW_LOGGING  
         LDAP_LOG ( OPERATION, DETAIL1,   
                 "read1msg: ldap_read: message type %s msgid %ld, original id %ld\n",  
             ldap_int_msgtype2str( tag ),  
                 (long) lr->lr_msgid, (long) lr->lr_origid );  
 #else  
         Debug( LDAP_DEBUG_TRACE,          Debug( LDAP_DEBUG_TRACE,
                 "ldap_read: message type %s msgid %ld, original id %ld\n",                  "read1msg: ld %p msgid %d message type %s\n",
             ldap_int_msgtype2str( tag ),                  (void *)ld, id, ldap_int_msgtype2str( tag ) );
                 (long) lr->lr_msgid, (long) lr->lr_origid );  
           if ( id == 0 ) {
                   /* unsolicited notification message (RFC 4511) */
                   if ( tag != LDAP_RES_EXTENDED ) {
                           /* toss it */
                           goto retry_ber;
   
                           /* strictly speaking, it's an error; from RFC 4511:
   
   4.4.  Unsolicited Notification
   
      An unsolicited notification is an LDAPMessage sent from the server to
      the client that is not in response to any LDAPMessage received by the
      server.  It is used to signal an extraordinary condition in the
      server or in the LDAP session between the client and the server.  The
      notification is of an advisory nature, and the server will not expect
      any response to be returned from the client.
   
      The unsolicited notification is structured as an LDAPMessage in which
      the messageID is zero and protocolOp is set to the extendedResp
      choice using the ExtendedResponse type (See Section 4.12).  The
      responseName field of the ExtendedResponse always contains an LDAPOID
      that is unique for this notification.
   
                            * however, since unsolicited responses
                            * are of advisory nature, better
                            * toss it, right now
                            */
   
   #if 0
                           ld->ld_errno = LDAP_DECODING_ERROR;
                           ber_free( ber, 1 );
                           return( -1 );
 #endif  #endif
                   }
   
                   lr = &dummy_lr;
           }
   
         id = lr->lr_origid;          id = lr->lr_origid;
         refer_cnt = 0;          refer_cnt = 0;
         hadref = simple_request = 0;          hadref = simple_request = 0;
         rc = -2;        /* default is to keep looking (no response found) */          rc = LDAP_MSG_X_KEEP_LOOKING;   /* default is to keep looking (no response found) */
         lr->lr_res_msgtype = tag;          lr->lr_res_msgtype = tag;
   
         /*          /*
          * This code figures out if we are going to chase a           * Check for V3 search reference
          * referral / search reference, or pass it back to the application  
          */           */
         v3ref = 0;      /* Assume not a V3 search reference or referral */          if ( tag == LDAP_RES_SEARCH_REFERENCE ) {
         if( (tag != LDAP_RES_SEARCH_ENTRY) && (ld->ld_version > LDAP_VERSION2) ) {                  if ( ld->ld_version > LDAP_VERSION2 ) {
                 BerElement      tmpber = *ber;  /* struct copy */  
                 char **refs = NULL;  
   
                 if( tag == LDAP_RES_SEARCH_REFERENCE) {  
                         /* This is a V3 search reference */                          /* This is a V3 search reference */
                         /* Assume we do not chase the reference, but pass it to application */                          if ( LDAP_BOOL_GET(&ld->ld_options, LDAP_BOOL_REFERRALS) ||
                         v3ref = -1;                                          lr->lr_parent != NULL )
                         if( LDAP_BOOL_GET(&ld->ld_options, LDAP_BOOL_REFERRALS) ||  
                                         (lr->lr_parent != NULL) )  
                         {                          {
                                   char **refs = NULL;
                                   tmpber = *ber;
   
                                 /* Get the referral list */                                  /* Get the referral list */
                                 if ( ber_scanf( &tmpber, "{v}", &refs ) == LBER_ERROR ) {                                  if ( ber_scanf( &tmpber, "{v}", &refs ) == LBER_ERROR ) {
                                         rc = LDAP_DECODING_ERROR;                                          rc = LDAP_DECODING_ERROR;
   
                                 } else {                                  } else {
                                         /* Note: refs arrary is freed by ldap_chase_v3referrals */                                          /* Note: refs array is freed by ldap_chase_v3referrals */
                                         refer_cnt = ldap_chase_v3referrals( ld, lr, refs,                                          refer_cnt = ldap_chase_v3referrals( ld, lr, refs,
                                             1, &lr->lr_res_error, &hadref );                                                  1, &lr->lr_res_error, &hadref );
                                         if ( refer_cnt > 0 ) {  /* sucessfully chased reference */                                          if ( refer_cnt > 0 ) {
                                                   /* successfully chased reference */
                                                 /* If haven't got end search, set chasing referrals */                                                  /* If haven't got end search, set chasing referrals */
                                                 if( lr->lr_status != LDAP_REQST_COMPLETED) {                                                  if ( lr->lr_status != LDAP_REQST_COMPLETED ) {
                                                         lr->lr_status = LDAP_REQST_CHASINGREFS;                                                          lr->lr_status = LDAP_REQST_CHASINGREFS;
 #ifdef NEW_LOGGING  
                                                         LDAP_LOG ( OPERATION, DETAIL1,   
                                                                 "read1msg: search ref chased,"  
                                                                 "mark request chasing refs, id =        %d\n",  
                                                                 lr->lr_msgid, 0, 0 );  
 #else  
                                                         Debug( LDAP_DEBUG_TRACE,                                                          Debug( LDAP_DEBUG_TRACE,
                                                             "read1msg:  search ref chased, mark request chasing refs, id = %d\n",                                                                  "read1msg:  search ref chased, "
                                                             lr->lr_msgid, 0, 0);                                                                  "mark request chasing refs, "
 #endif                                                                  "id = %d\n",
                                                                   lr->lr_msgid, 0, 0 );
                                                 }                                                  }
                                                 v3ref = 1;      /* We sucessfully chased the reference */  
                                         }                                          }
                                 }                                  }
                         }                          }
                 } else {                  }
                         /* Check for V3 referral */  
                         ber_len_t len;          } else if ( tag != LDAP_RES_SEARCH_ENTRY && tag != LDAP_RES_INTERMEDIATE ) {
                         if ( ber_scanf( &tmpber, "{iaa",/*}*/ &lderr,                  /* All results that just return a status, i.e. don't return data
                                     &lr->lr_res_matched, &lr->lr_res_error )                   * go through the following code.  This code also chases V2 referrals
                                     != LBER_ERROR ) {                   * and checks if all referrals have been chased.
                    */
                   char            *lr_res_error = NULL;
   
                   tmpber = *ber;  /* struct copy */
                   if ( ber_scanf( &tmpber, "{eAA", &lderr,
                                   &lr->lr_res_matched, &lr_res_error )
                                   != LBER_ERROR )
                   {
                           if ( lr_res_error != NULL ) {
                                   if ( lr->lr_res_error != NULL ) {
                                           (void)ldap_append_referral( ld, &lr->lr_res_error, lr_res_error );
                                           LDAP_FREE( (char *)lr_res_error );
   
                                   } else {
                                           lr->lr_res_error = lr_res_error;
                                   }
                                   lr_res_error = NULL;
                           }
   
                           /* Do we need to check for referrals? */
                           if ( LDAP_BOOL_GET(&ld->ld_options, LDAP_BOOL_REFERRALS) ||
                                           lr->lr_parent != NULL )
                           {
                                   char            **refs = NULL;
                                   ber_len_t       len;
   
                                 /* Check if V3 referral */                                  /* Check if V3 referral */
                                 if( ber_peek_tag( &tmpber, &len) == LDAP_TAG_REFERRAL ) {                                  if ( ber_peek_tag( &tmpber, &len ) == LDAP_TAG_REFERRAL ) {
                                         /* We have a V3 referral, assume we cannot chase it */                                          if ( ld->ld_version > LDAP_VERSION2 ) {
                                         v3ref = -1;  
                                         if( LDAP_BOOL_GET(&ld->ld_options, LDAP_BOOL_REFERRALS)  
                                                          || (lr->lr_parent != NULL) )  
                                         {  
                                                 v3ref = -1;  /* Assume referral not chased and return it to app */  
                                                 /* Get the referral list */                                                  /* Get the referral list */
                                                 if( ber_scanf( &tmpber, "{v}", &refs) == LBER_ERROR) {                                                  if ( ber_scanf( &tmpber, "{v}", &refs) == LBER_ERROR) {
                                                         rc = LDAP_DECODING_ERROR;                                                          rc = LDAP_DECODING_ERROR;
                                                         lr->lr_status = LDAP_REQST_COMPLETED;                                                          lr->lr_status = LDAP_REQST_COMPLETED;
 #ifdef NEW_LOGGING  
                                                         LDAP_LOG ( OPERATION, DETAIL1,   
                                                                 "read1msg: referral decode error,"  
                                                                 "mark request completed, id =   %d\n",  
                                                                 lr->lr_msgid, 0, 0 );  
 #else  
                                                         Debug( LDAP_DEBUG_TRACE,                                                          Debug( LDAP_DEBUG_TRACE,
                                                             "read1msg: referral decode error, mark request completed, id = %d\n",                                                                  "read1msg: referral decode error, "
                                                                     lr->lr_msgid, 0, 0);                                                                  "mark request completed, ld %p msgid %d\n",
 #endif                                                                  (void *)ld, lr->lr_msgid, 0 );
   
                                                 } else {                                                  } else {
                                                         /* Chase the referral                                                           /* Chase the referral 
                                                          * Note: refs arrary is freed by ldap_chase_v3referrals                                                           * refs array is freed by ldap_chase_v3referrals
                                                          */                                                           */
                                                         refer_cnt = ldap_chase_v3referrals( ld, lr, refs,                                                          refer_cnt = ldap_chase_v3referrals( ld, lr, refs,
                                                             0, &lr->lr_res_error, &hadref );                                                                  0, &lr->lr_res_error, &hadref );
                                                         lr->lr_status = LDAP_REQST_COMPLETED;                                                          lr->lr_status = LDAP_REQST_COMPLETED;
 #ifdef NEW_LOGGING  
                                                         LDAP_LOG ( OPERATION, DETAIL1,   
                                                                 "read1msg: referral chased,"  
                                                                 "mark request completed, id =   %d\n",  
                                                                 lr->lr_msgid, 0, 0 );  
 #else  
                                                         Debug( LDAP_DEBUG_TRACE,                                                          Debug( LDAP_DEBUG_TRACE,
                                                             "read1msg:  referral chased, mark request completed, id = %d\n",                                                                  "read1msg: referral %s chased, "
                                                             lr->lr_msgid, 0, 0);                                                                  "mark request completed, ld %p msgid %d\n",
 #endif                                                                  refer_cnt > 0 ? "" : "not",
                                                         if( refer_cnt > 0) {                                                                  (void *)ld, lr->lr_msgid);
                                                                 v3ref = 1;  /* Referral successfully chased */                                                          if ( refer_cnt < 0 ) {
                                                                   refer_cnt = 0;
                                                         }                                                          }
                                                 }                                                  }
                                         }                                          }
                                 }                                  } else {
                                           switch ( lderr ) {
                                           case LDAP_SUCCESS:
                                           case LDAP_COMPARE_TRUE:
                                           case LDAP_COMPARE_FALSE:
                                                   break;
   
                                           default:
                                                   if ( lr->lr_res_error == NULL ) {
                                                           break;
                                                   }
   
                                 if( lr->lr_res_matched != NULL ) {                                                  /* pedantic, should never happen */
                                         LDAP_FREE( lr->lr_res_matched );                                                  if ( lr->lr_res_error[ 0 ] == '\0' ) {
                                         lr->lr_res_matched = NULL;                                                          LDAP_FREE( lr->lr_res_error );
                                 }                                                          lr->lr_res_error = NULL;
                                 if( lr->lr_res_error != NULL ) {                                                          break;  
                                         LDAP_FREE( lr->lr_res_error );                                                  }
                                         lr->lr_res_error = NULL;  
                                                   /* V2 referrals are in error string */
                                                   refer_cnt = ldap_chase_referrals( ld, lr,
                                                           &lr->lr_res_error, -1, &hadref );
                                                   lr->lr_status = LDAP_REQST_COMPLETED;
                                                   Debug( LDAP_DEBUG_TRACE,
                                                           "read1msg:  V2 referral chased, "
                                                           "mark request completed, id = %d\n",
                                                           lr->lr_msgid, 0, 0 );
                                                   break;
                                           }
                                 }                                  }
                         }                          }
                 }  
         }  
   
         /* All results that just return a status, i.e. don't return data                          /* save errno, message, and matched string */
          * go through the following code.  This code also chases V2 referrals                          if ( !hadref || lr->lr_res_error == NULL ) {
          * and checks if all referrals have been chased.                                  lr->lr_res_errno =
          */                                          lderr == LDAP_PARTIAL_RESULTS
         if ( (tag != LDAP_RES_SEARCH_ENTRY) && (v3ref > -1)                                          ? LDAP_SUCCESS : lderr;
 #ifdef LDAP_RES_INTERMEDIATE_RESP  
                 && (tag != LDAP_RES_INTERMEDIATE_RESP )  
 #endif  
         ) {  
                 /* For a v3 search referral/reference, only come here if already chased it */  
                 if ( ld->ld_version >= LDAP_VERSION2 &&  
                         ( lr->lr_parent != NULL ||  
                         LDAP_BOOL_GET(&ld->ld_options, LDAP_BOOL_REFERRALS) ) )  
                 {  
                         tmpber = *ber;  /* struct copy */  
                         if ( v3ref == 1 ) {  
                                 /* V3 search reference or V3 referral  
                                  * sucessfully chased. If this message  
                                  * is a search result, then it has no more  
                                  * outstanding referrals.  
                                  */  
                                 if ( tag == LDAP_RES_SEARCH_RESULT )  
                                         refer_cnt = 0;  
                         } else if ( ber_scanf( &tmpber, "{iaa}", &lderr,  
                             &lr->lr_res_matched, &lr->lr_res_error )  
                             != LBER_ERROR ) {  
                                 if ( lderr != LDAP_SUCCESS ) {  
                                         /* referrals are in error string */  
                                         refer_cnt = ldap_chase_referrals( ld, lr,  
                                                 &lr->lr_res_error, -1, &hadref );  
                                         lr->lr_status = LDAP_REQST_COMPLETED;  
 #ifdef NEW_LOGGING  
                                         LDAP_LOG ( OPERATION, DETAIL1,   
                                                 "read1msg: V2 referral chased,"  
                                                 "mark request completed, id =   %d\n",  
                                                 lr->lr_msgid, 0, 0 );  
 #else  
                                         Debug( LDAP_DEBUG_TRACE,  
                                             "read1msg:  V2 referral chased, mark request completed, id = %d\n", lr->lr_msgid, 0, 0);  
 #endif  
                                 }  
   
                                 /* save errno, message, and matched string */                          } else if ( ld->ld_errno != LDAP_SUCCESS ) {
                                 if ( !hadref || lr->lr_res_error == NULL ) {                                  lr->lr_res_errno = ld->ld_errno;
                                         lr->lr_res_errno = ( lderr ==  
                                         LDAP_PARTIAL_RESULTS ) ? LDAP_SUCCESS                          } else {
                                         : lderr;                                  lr->lr_res_errno = LDAP_PARTIAL_RESULTS;
                                 } else if ( ld->ld_errno != LDAP_SUCCESS ) {  
                                         lr->lr_res_errno = ld->ld_errno;  
                                 } else {  
                                         lr->lr_res_errno = LDAP_PARTIAL_RESULTS;  
                                 }  
 #ifdef NEW_LOGGING  
 LDAP_LOG ( OPERATION, DETAIL1,   
         "read1msg: new result: 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 : "" );  
 #else  
 Debug( LDAP_DEBUG_TRACE,  
     "new result:  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 : "" );  
 #endif  
                         }                          }
                 }                  }
   
 #ifdef NEW_LOGGING                  /* in any case, don't leave any lr_res_error 'round */
                 LDAP_LOG ( OPERATION, DETAIL1, "read1msg: %d new referrals\n",                   if ( lr_res_error ) {
                         refer_cnt, 0, 0 );                          LDAP_FREE( lr_res_error );
 #else                  }
   
                 Debug( LDAP_DEBUG_TRACE,                  Debug( LDAP_DEBUG_TRACE,
                     "read1msg:  %d new referrals\n", refer_cnt, 0, 0 );                          "read1msg: ld %p %d new referrals\n",
 #endif                          (void *)ld, refer_cnt, 0 );
   
                 if ( refer_cnt != 0 ) { /* chasing referrals */                  if ( refer_cnt != 0 ) { /* chasing referrals */
                         ber_free( ber, 1 );                          ber_free( ber, 1 );
                         ber = NULL;                          ber = NULL;
                         if ( refer_cnt < 0 ) {                          if ( refer_cnt < 0 ) {
                                   ldap_return_request( ld, lr, 0 );
                                 return( -1 );   /* fatal error */                                  return( -1 );   /* fatal error */
                         }                          }
                         lr->lr_res_errno = LDAP_SUCCESS; /* sucessfully chased referral */                          lr->lr_res_errno = LDAP_SUCCESS; /* sucessfully chased referral */
   
                 } else {                  } else {
                         if ( lr->lr_outrefcnt <= 0 && lr->lr_parent == NULL ) {                          if ( lr->lr_outrefcnt <= 0 && lr->lr_parent == NULL ) {
                                 /* request without any referrals */                                  /* request without any referrals */
                                 simple_request = ( hadref ? 0 : 1 );                                  simple_request = ( hadref ? 0 : 1 );
   
                         } else {                          } else {
                                 /* request with referrals or child request */                                  /* request with referrals or child request */
                                 ber_free( ber, 1 );                                  ber_free( ber, 1 );
Line 744  Debug( LDAP_DEBUG_TRACE, Line 875  Debug( LDAP_DEBUG_TRACE,
                         }                          }
   
                         lr->lr_status = LDAP_REQST_COMPLETED; /* declare this request done */                          lr->lr_status = LDAP_REQST_COMPLETED; /* declare this request done */
 #ifdef NEW_LOGGING  
                         LDAP_LOG ( OPERATION, DETAIL1,   
                                 "read1msg: mark request completed, id = %d\n",   
                                 lr->lr_msgid, 0, 0 );  
 #else  
                         Debug( LDAP_DEBUG_TRACE,                          Debug( LDAP_DEBUG_TRACE,
                             "read1msg:  mark request completed, id = %d\n", lr->lr_msgid, 0, 0);                                  "read1msg:  mark request completed, ld %p msgid %d\n",
 #endif                                  (void *)ld, lr->lr_msgid, 0);
                         while ( lr->lr_parent != NULL ) {                          while ( lr->lr_parent != NULL ) {
                                 merge_error_info( ld, lr->lr_parent, lr );                                  merge_error_info( ld, lr->lr_parent, lr );
   
Line 763  Debug( LDAP_DEBUG_TRACE, Line 889  Debug( LDAP_DEBUG_TRACE,
   
                         /* Check if all requests are finished, lr is now parent */                          /* Check if all requests are finished, lr is now parent */
                         tmplr = lr;                          tmplr = lr;
                         if (tmplr->lr_status == LDAP_REQST_COMPLETED) {                          if ( tmplr->lr_status == LDAP_REQST_COMPLETED ) {
                                 for(tmplr=lr->lr_child; tmplr != NULL; tmplr=tmplr->lr_refnext) {                                  for ( tmplr = lr->lr_child;
                                 if( tmplr->lr_status != LDAP_REQST_COMPLETED) {                                          tmplr != NULL;
                                         break;                                          tmplr = tmplr->lr_refnext )
                                         }                                  {
                                           if ( tmplr->lr_status != LDAP_REQST_COMPLETED ) break;
                                 }                                  }
                         }                          }
   
                         /* This is the parent request if the request has referrals */                          /* This is the parent request if the request has referrals */
                         if ( lr->lr_outrefcnt <= 0 && lr->lr_parent == NULL && tmplr == NULL ) {                          if ( lr->lr_outrefcnt <= 0 &&
                                   lr->lr_parent == NULL &&
                                   tmplr == NULL )
                           {
                                 id = lr->lr_msgid;                                  id = lr->lr_msgid;
                                 tag = lr->lr_res_msgtype;                                  tag = lr->lr_res_msgtype;
 #ifdef NEW_LOGGING                                  Debug( LDAP_DEBUG_TRACE, "request done: ld %p msgid %d\n",
                         LDAP_LOG ( OPERATION, DETAIL1,                                           (void *)ld, id, 0 );
                                 "read1msg: request %ld done\n", (long) id, 0, 0 );                                  Debug( LDAP_DEBUG_TRACE,
                         LDAP_LOG ( OPERATION, DETAIL1,                                           "res_errno: %d, res_error: <%s>, "
                                 "read1msg: res_errno: %d,res_error: <%s>, res_matched: <%s>\n",                                          "res_matched: <%s>\n",
                                 lr->lr_res_errno, lr->lr_res_error ? lr->lr_res_error : "",                                          lr->lr_res_errno,
                                 lr->lr_res_matched ? lr->lr_res_matched : "" );                                          lr->lr_res_error ? lr->lr_res_error : "",
 #else                                          lr->lr_res_matched ? lr->lr_res_matched : "" );
                                 Debug( LDAP_DEBUG_ANY, "request %ld done\n",  
                                     (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 : "" );  
 #endif  
                                 if ( !simple_request ) {                                  if ( !simple_request ) {
                                         ber_free( ber, 1 );                                          ber_free( ber, 1 );
                                         ber = NULL;                                          ber = NULL;
                                         if ( build_result_ber( ld, &ber, lr )                                          if ( build_result_ber( ld, &ber, lr )
                                             == LBER_ERROR ) {                                              == LBER_ERROR )
                                           {
                                                 rc = -1; /* fatal error */                                                  rc = -1; /* fatal error */
                                         }                                          }
                                 }                                  }
   
                                 ldap_free_request( ld, lr );                                  if ( lr != &dummy_lr ) {
                                           ldap_return_request( ld, lr, 1 );
                                   }
                                   lr = NULL;
                         }                          }
   
                         if ( lc != NULL ) {                          /*
                            * RF 4511 unsolicited (id == 0) responses
                            * shouldn't necessarily end the connection
                            */
                           if ( lc != NULL && id != 0 ) {
   #ifdef LDAP_R_COMPILE
                                   ldap_pvt_thread_mutex_lock( &ld->ld_req_mutex );
   #endif
                                 ldap_free_connection( ld, lc, 0, 1 );                                  ldap_free_connection( ld, lc, 0, 1 );
                                 *lcp = NULL;  #ifdef LDAP_R_COMPILE
                                   ldap_pvt_thread_mutex_unlock( &ld->ld_req_mutex );
   #endif
                                   lc = *lcp = NULL;
                         }                          }
                 }                  }
         }          }
   
           if ( lr != NULL ) {
                   if ( lr != &dummy_lr ) {
                           ldap_return_request( ld, lr, 0 );
                   }
                   lr = NULL;
           }
   
         if ( ber == NULL ) {          if ( ber == NULL ) {
                 return( rc );                  return( rc );
         }          }
   
           /* try to handle unsolicited responses as appropriate */
           if ( id == 0 && msgid > LDAP_RES_UNSOLICITED ) {
                   int     is_nod = 0;
   
                   tag = ber_peek_tag( &tmpber, &len );
   
                   /* we have a res oid */
                   if ( tag == LDAP_TAG_EXOP_RES_OID ) {
                           static struct berval    bv_nod = BER_BVC( LDAP_NOTICE_OF_DISCONNECTION );
                           struct berval           resoid = BER_BVNULL;
   
                           if ( ber_scanf( &tmpber, "m", &resoid ) == LBER_ERROR ) {
                                   ld->ld_errno = LDAP_DECODING_ERROR;
                                   ber_free( ber, 1 );
                                   return -1;
                           }
   
                           assert( !BER_BVISEMPTY( &resoid ) );
   
                           is_nod = ber_bvcmp( &resoid, &bv_nod ) == 0;
   
                           tag = ber_peek_tag( &tmpber, &len );
                   }
   
   #if 0 /* don't need right now */
                   /* we have res data */
                   if ( tag == LDAP_TAG_EXOP_RES_VALUE ) {
                           struct berval resdata;
   
                           if ( ber_scanf( &tmpber, "m", &resdata ) == LBER_ERROR ) {
                                   ld->ld_errno = LDAP_DECODING_ERROR;
                                   ber_free( ber, 0 );
                                   return ld->ld_errno;
                           }
   
                           /* use it... */
                   }
   #endif
   
                   /* handle RFC 4511 "Notice of Disconnection" locally */
   
                   if ( is_nod ) {
                           if ( tag == LDAP_TAG_EXOP_RES_VALUE ) {
                                   ld->ld_errno = LDAP_DECODING_ERROR;
                                   ber_free( ber, 1 );
                                   return -1;
                           }
   
                           /* get rid of the connection... */
                           if ( lc != NULL ) {
   #ifdef LDAP_R_COMPILE
                                   ldap_pvt_thread_mutex_lock( &ld->ld_req_mutex );
   #endif
                                   ldap_free_connection( ld, lc, 0, 1 );
   #ifdef LDAP_R_COMPILE
                                   ldap_pvt_thread_mutex_unlock( &ld->ld_req_mutex );
   #endif
                                   lc = *lcp = NULL;
                           }
   
                           /* need to return -1, because otherwise
                            * a valid result is expected */
                           return -1;
                   }
           }
   
         /* make a new ldap message */          /* make a new ldap message */
         if ( (new = (LDAPMessage *) LDAP_CALLOC( 1, sizeof(LDAPMessage) ))          newmsg = (LDAPMessage *) LDAP_CALLOC( 1, sizeof(LDAPMessage) );
             == NULL ) {          if ( newmsg == NULL ) {
                 ld->ld_errno = LDAP_NO_MEMORY;                  ld->ld_errno = LDAP_NO_MEMORY;
                 return( -1 );                  return( -1 );
         }          }
         new->lm_msgid = (int)id;          newmsg->lm_msgid = (int)id;
         new->lm_msgtype = tag;          newmsg->lm_msgtype = tag;
         new->lm_ber = ber;          newmsg->lm_ber = ber;
           newmsg->lm_chain_tail = newmsg;
   
 #ifdef LDAP_CONNECTIONLESS  #ifdef LDAP_CONNECTIONLESS
         /* CLDAP replies all fit in a single datagram. In LDAPv2 RFC1798          /* CLDAP replies all fit in a single datagram. In LDAPv2 RFC1798
Line 845  lr->lr_res_matched ? lr->lr_res_matched Line 1056  lr->lr_res_matched ? lr->lr_res_matched
                                  */                                   */
                                 ber = ber_dup( ber );                                  ber = ber_dup( ber );
                                 ber_scanf( ber, "x" );                                  ber_scanf( ber, "x" );
                                 if (ber_peek_tag(ber, &len) != LBER_DEFAULT) {                                  if ( ber_peek_tag( ber, &len ) != LBER_DEFAULT ) {
                                         /* There's more - dup the ber buffer so they can all be                                          /* There's more - dup the ber buffer so they can all be
                                          * individually freed by ldap_msgfree.                                           * individually freed by ldap_msgfree.
                                          */                                           */
                                         struct berval bv;                                          struct berval bv;
                                         ber_get_option(ber, LBER_OPT_BER_REMAINING_BYTES, &len);                                          ber_get_option( ber, LBER_OPT_BER_REMAINING_BYTES, &len );
                                         bv.bv_val = LDAP_MALLOC(len);                                          bv.bv_val = LDAP_MALLOC( len );
                                         if (bv.bv_val) {                                          if ( bv.bv_val ) {
                                                 ok=1;                                                  ok = 1;
                                                 ber_read(ber, bv.bv_val, len);                                                  ber_read( ber, bv.bv_val, len );
                                                 bv.bv_len = len;                                                  bv.bv_len = len;
                                                 ber_init2(ber, &bv, ld->ld_lberoptions );                                                  ber_init2( ber, &bv, ld->ld_lberoptions );
                                         }                                          }
                                 }                                  }
                         } else {                          } else {
Line 864  lr->lr_res_matched ? lr->lr_res_matched Line 1075  lr->lr_res_matched ? lr->lr_res_matched
                                  * datagram, if the sockbuf is readable we still have data                                   * datagram, if the sockbuf is readable we still have data
                                  * to parse.                                   * to parse.
                                  */                                   */
                                 ber = ldap_alloc_ber_with_options(ld);                                  ber = ldap_alloc_ber_with_options( ld );
                                 if (ber_sockbuf_ctrl(sb, LBER_SB_OPT_DATA_READY, NULL)) ok=1;                                  if ( ber_sockbuf_ctrl( lc->lconn_sb, LBER_SB_OPT_DATA_READY, NULL ) ) ok = 1;
                         }                          }
                         /* set up response chain */                          /* set up response chain */
                         if ( firstmsg ) {                          if ( tmp == NULL ) {
                                 firstmsg = 0;                                  newmsg->lm_next = ld->ld_responses;
                                 new->lm_next = ld->ld_responses;                                  ld->ld_responses = newmsg;
                                 ld->ld_responses = new;                                  chain_head = newmsg;
                         } else {                          } else {
                                 tmp->lm_chain = new;                                  tmp->lm_chain = newmsg;
                         }                          }
                         tmp = new;                          chain_head->lm_chain_tail = newmsg;
                           tmp = newmsg;
                         /* "ok" means there's more to parse */                          /* "ok" means there's more to parse */
                         if (ok) {                          if ( ok ) {
                                 if (isv2) goto nextresp2;                                  if ( isv2 ) {
                                 else goto nextresp3;                                          goto nextresp2;
   
                                   } else {
                                           goto nextresp3;
                                   }
                         } else {                          } else {
                                 /* got to end of datagram without a SearchResult. Free                                  /* got to end of datagram without a SearchResult. Free
                                  * our dup'd ber, but leave any buffer alone. For v2 case,                                   * our dup'd ber, but leave any buffer alone. For v2 case,
                                  * the previous response is still using this buffer. For v3,                                   * the previous response is still using this buffer. For v3,
                                  * the new ber has no buffer to free yet.                                   * the new ber has no buffer to free yet.
                                  */                                   */
                                 ber_free(ber, 0);                                  ber_free( ber, 0 );
                                 return -1;                                  return -1;
                         }                          }
                 } else if ( moremsgs ) {                  } else if ( moremsgs ) {
Line 894  lr->lr_res_matched ? lr->lr_res_matched Line 1110  lr->lr_res_matched ? lr->lr_res_matched
                  * stick the result onto the end of the chain, and then pull the                   * stick the result onto the end of the chain, and then pull the
                  * first response off the head of the chain.                   * first response off the head of the chain.
                  */                   */
                         tmp->lm_chain = new;                          tmp->lm_chain = newmsg;
                           chain_head->lm_chain_tail = newmsg;
                         *result = chkResponseList( ld, msgid, all );                          *result = chkResponseList( ld, msgid, all );
                         ld->ld_errno = LDAP_SUCCESS;                          ld->ld_errno = LDAP_SUCCESS;
                         return( (*result)->lm_msgtype );                          return( (*result)->lm_msgtype );
                 }                  }
         }          }
 #endif  #endif /* LDAP_CONNECTIONLESS */
   
         /* is this the one we're looking for? */          /* is this the one we're looking for? */
         if ( msgid == LDAP_RES_ANY || id == msgid ) {          if ( msgid == LDAP_RES_ANY || id == msgid ) {
                 if ( all == LDAP_MSG_ONE                  if ( all == LDAP_MSG_ONE
                     || (new->lm_msgtype != LDAP_RES_SEARCH_RESULT                          || ( newmsg->lm_msgtype != LDAP_RES_SEARCH_RESULT
                     && new->lm_msgtype != LDAP_RES_SEARCH_ENTRY                                  && newmsg->lm_msgtype != LDAP_RES_SEARCH_ENTRY
                     && new->lm_msgtype != LDAP_RES_SEARCH_REFERENCE) ) {                                  && newmsg->lm_msgtype != LDAP_RES_SEARCH_REFERENCE ) )
                         *result = new;                  {
                           *result = newmsg;
                         ld->ld_errno = LDAP_SUCCESS;                          ld->ld_errno = LDAP_SUCCESS;
                         return( tag );                          return( tag );
                 } else if ( new->lm_msgtype == LDAP_RES_SEARCH_RESULT) {  
                   } else if ( newmsg->lm_msgtype == LDAP_RES_SEARCH_RESULT) {
                         foundit = 1;    /* return the chain later */                          foundit = 1;    /* return the chain later */
                 }                  }
         }          }
Line 924  lr->lr_res_matched ? lr->lr_res_matched Line 1143  lr->lr_res_matched ? lr->lr_res_matched
   
         prev = NULL;          prev = NULL;
         for ( l = ld->ld_responses; l != NULL; l = l->lm_next ) {          for ( l = ld->ld_responses; l != NULL; l = l->lm_next ) {
                 if ( l->lm_msgid == new->lm_msgid )                  if ( l->lm_msgid == newmsg->lm_msgid ) {
                         break;                          break;
                   }
                 prev = l;                  prev = l;
         }          }
   
         /* not part of an existing search response */          /* not part of an existing search response */
         if ( l == NULL ) {          if ( l == NULL ) {
                 if ( foundit ) {                  if ( foundit ) {
                         *result = new;                          *result = newmsg;
                         ld->ld_errno = LDAP_SUCCESS;                          goto exit;
                         return( tag );  
                 }                  }
   
                 new->lm_next = ld->ld_responses;                  newmsg->lm_next = ld->ld_responses;
                 ld->ld_responses = new;                  ld->ld_responses = newmsg;
                 goto exit;                  goto exit;
         }          }
   
 #ifdef NEW_LOGGING          Debug( LDAP_DEBUG_TRACE, "adding response ld %p msgid %d type %ld:\n",
         LDAP_LOG ( OPERATION, DETAIL1,                   (void *)ld, newmsg->lm_msgid, (long) newmsg->lm_msgtype );
                 "read1msg: adding response id %ld type %ld\n",  
                 (long) new->lm_msgid, (long) new->lm_msgtype, 0 );  
 #else  
         Debug( LDAP_DEBUG_TRACE, "adding response id %ld type %ld:\n",  
             (long) new->lm_msgid, (long) new->lm_msgtype, 0 );  
 #endif  
   
         /* part of a search response - add to end of list of entries */          /* part of a search response - add to end of list of entries */
         for ( tmp = l; (tmp->lm_chain != NULL) &&          l->lm_chain_tail->lm_chain = newmsg;
                 ((tmp->lm_chain->lm_msgtype == LDAP_RES_SEARCH_ENTRY) ||          l->lm_chain_tail = newmsg;
                  (tmp->lm_chain->lm_msgtype == LDAP_RES_SEARCH_REFERENCE) ||  
                          (tmp->lm_chain->lm_msgtype == LDAP_RES_EXTENDED_PARTIAL ));  
             tmp = tmp->lm_chain )  
                 ;       /* NULL */  
         tmp->lm_chain = new;  
   
         /* return the whole chain if that's what we were looking for */          /* return the whole chain if that's what we were looking for */
         if ( foundit ) {          if ( foundit ) {
                 if ( prev == NULL )                  if ( prev == NULL ) {
                         ld->ld_responses = l->lm_next;                          ld->ld_responses = l->lm_next;
                 else                  } else {
                         prev->lm_next = l->lm_next;                          prev->lm_next = l->lm_next;
                   }
                 *result = l;                  *result = l;
                 ld->ld_errno = LDAP_SUCCESS;  
                 return( tag );  
         }          }
   
 exit:  exit:
         if ( ber_sockbuf_ctrl( sb, LBER_SB_OPT_DATA_READY, NULL ) ) {          if ( foundit ) {
                   ld->ld_errno = LDAP_SUCCESS;
                   return( tag );
           }
           if ( lc && ber_sockbuf_ctrl( lc->lconn_sb, LBER_SB_OPT_DATA_READY, NULL ) ) {
                 goto retry;                  goto retry;
         }          }
         return( -2 );   /* continue looking */          return( LDAP_MSG_X_KEEP_LOOKING );      /* continue looking */
 }  }
   
   
Line 996  build_result_ber( LDAP *ld, BerElement * Line 1207  build_result_ber( LDAP *ld, BerElement *
         }          }
   
         if ( ber_printf( ber, "{it{ess}}", lr->lr_msgid,          if ( ber_printf( ber, "{it{ess}}", lr->lr_msgid,
             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_matched ? lr->lr_res_matched : "",
             lr->lr_res_error ? lr->lr_res_error : "" ) == -1 ) {                  lr->lr_res_error ? lr->lr_res_error : "" ) == -1 )
           {
                 ld->ld_errno = LDAP_ENCODING_ERROR;                  ld->ld_errno = LDAP_ENCODING_ERROR;
                 ber_free(ber, 1);                  ber_free( ber, 1 );
                 return( LBER_ERROR );                  return( LBER_ERROR );
         }          }
   
Line 1009  build_result_ber( LDAP *ld, BerElement * Line 1220  build_result_ber( LDAP *ld, BerElement *
   
         if ( ber_skip_tag( ber, &len ) == LBER_ERROR ) {          if ( ber_skip_tag( ber, &len ) == LBER_ERROR ) {
                 ld->ld_errno = LDAP_DECODING_ERROR;                  ld->ld_errno = LDAP_DECODING_ERROR;
                 ber_free(ber, 1);                  ber_free( ber, 1 );
                 return( LBER_ERROR );                  return( LBER_ERROR );
         }          }
   
         if ( ber_get_int( ber, &along ) == LBER_ERROR ) {          if ( ber_get_enum( ber, &along ) == LBER_ERROR ) {
                 ld->ld_errno = LDAP_DECODING_ERROR;                  ld->ld_errno = LDAP_DECODING_ERROR;
                 ber_free(ber, 1);                  ber_free( ber, 1 );
                 return( LBER_ERROR );                  return( LBER_ERROR );
         }          }
   
Line 1023  build_result_ber( LDAP *ld, BerElement * Line 1234  build_result_ber( LDAP *ld, BerElement *
   
         if ( tag == LBER_ERROR ) {          if ( tag == LBER_ERROR ) {
                 ld->ld_errno = LDAP_DECODING_ERROR;                  ld->ld_errno = LDAP_DECODING_ERROR;
                 ber_free(ber, 1);                  ber_free( ber, 1 );
                 return( LBER_ERROR );                  return( LBER_ERROR );
         }          }
   
Line 1032  build_result_ber( LDAP *ld, BerElement * Line 1243  build_result_ber( LDAP *ld, BerElement *
 }  }
   
   
 static void  
 merge_error_info( LDAP *ld, LDAPRequest *parentr, LDAPRequest *lr )  
 {  
 /*  /*
  * Merge error information in "lr" with "parentr" error code and string.   * Merge error information in "lr" with "parentr" error code and string.
  */   */
   static void
   merge_error_info( LDAP *ld, LDAPRequest *parentr, LDAPRequest *lr )
   {
         if ( lr->lr_res_errno == LDAP_PARTIAL_RESULTS ) {          if ( lr->lr_res_errno == LDAP_PARTIAL_RESULTS ) {
                 parentr->lr_res_errno = lr->lr_res_errno;                  parentr->lr_res_errno = lr->lr_res_errno;
                 if ( lr->lr_res_error != NULL ) {                  if ( lr->lr_res_error != NULL ) {
                         (void)ldap_append_referral( ld, &parentr->lr_res_error,                          (void)ldap_append_referral( ld, &parentr->lr_res_error,
                             lr->lr_res_error );                                  lr->lr_res_error );
                 }                  }
   
         } else if ( lr->lr_res_errno != LDAP_SUCCESS &&          } else if ( lr->lr_res_errno != LDAP_SUCCESS &&
             parentr->lr_res_errno == LDAP_SUCCESS ) {                  parentr->lr_res_errno == LDAP_SUCCESS )
           {
                 parentr->lr_res_errno = lr->lr_res_errno;                  parentr->lr_res_errno = lr->lr_res_errno;
                 if ( parentr->lr_res_error != NULL ) {                  if ( parentr->lr_res_error != NULL ) {
                         LDAP_FREE( parentr->lr_res_error );                          LDAP_FREE( parentr->lr_res_error );
                 }                  }
                 parentr->lr_res_error = lr->lr_res_error;                  parentr->lr_res_error = lr->lr_res_error;
                 lr->lr_res_error = NULL;                  lr->lr_res_error = NULL;
                 if ( LDAP_NAME_ERROR( lr->lr_res_errno )) {                  if ( LDAP_NAME_ERROR( lr->lr_res_errno ) ) {
                         if ( parentr->lr_res_matched != NULL ) {                          if ( parentr->lr_res_matched != NULL ) {
                                 LDAP_FREE( parentr->lr_res_matched );                                  LDAP_FREE( parentr->lr_res_matched );
                         }                          }
Line 1061  merge_error_info( LDAP *ld, LDAPRequest Line 1274  merge_error_info( LDAP *ld, LDAPRequest
                 }                  }
         }          }
   
 #ifdef NEW_LOGGING  
         LDAP_LOG( OPERATION, DETAIL1, "merged parent (id %d) error info:  ",  
             parentr->lr_msgid, 0, 0 );  
         LDAP_LOG( OPERATION, DETAIL1, "result errno %d, error <%s>, matched <%s>\n",  
             parentr->lr_res_errno, parentr->lr_res_error ?  
             parentr->lr_res_error : "", parentr->lr_res_matched ?  
             parentr->lr_res_matched : "" );  
 #else  
         Debug( LDAP_DEBUG_TRACE, "merged parent (id %d) error info:  ",          Debug( LDAP_DEBUG_TRACE, "merged parent (id %d) error info:  ",
             parentr->lr_msgid, 0, 0 );                  parentr->lr_msgid, 0, 0 );
         Debug( LDAP_DEBUG_TRACE, "result errno %d, error <%s>, matched <%s>\n",          Debug( LDAP_DEBUG_TRACE, "result errno %d, error <%s>, matched <%s>\n",
             parentr->lr_res_errno, parentr->lr_res_error ?                  parentr->lr_res_errno,
             parentr->lr_res_error : "", parentr->lr_res_matched ?                  parentr->lr_res_error ?  parentr->lr_res_error : "",
             parentr->lr_res_matched : "" );                  parentr->lr_res_matched ?  parentr->lr_res_matched : "" );
 #endif  
 }  }
   
   
Line 1084  int Line 1288  int
 ldap_msgtype( LDAPMessage *lm )  ldap_msgtype( LDAPMessage *lm )
 {  {
         assert( lm != NULL );          assert( lm != NULL );
         return ( lm != NULL ) ? lm->lm_msgtype : -1;          return ( lm != NULL ) ? (int)lm->lm_msgtype : -1;
 }  }
   
   
Line 1097  ldap_msgid( LDAPMessage *lm ) Line 1301  ldap_msgid( LDAPMessage *lm )
 }  }
   
   
 char * ldap_int_msgtype2str( ber_tag_t tag )  const char *
   ldap_int_msgtype2str( ber_tag_t tag )
 {  {
         switch( tag ) {          switch( tag ) {
         case LDAP_RES_ADD: return "add";          case LDAP_RES_ADD: return "add";
Line 1105  char * ldap_int_msgtype2str( ber_tag_t t Line 1310  char * ldap_int_msgtype2str( ber_tag_t t
         case LDAP_RES_COMPARE: return "compare";          case LDAP_RES_COMPARE: return "compare";
         case LDAP_RES_DELETE: return "delete";          case LDAP_RES_DELETE: return "delete";
         case LDAP_RES_EXTENDED: return "extended-result";          case LDAP_RES_EXTENDED: return "extended-result";
         case LDAP_RES_EXTENDED_PARTIAL: return "extended-partial";          case LDAP_RES_INTERMEDIATE: return "intermediate";
         case LDAP_RES_MODIFY: return "modify";          case LDAP_RES_MODIFY: return "modify";
         case LDAP_RES_RENAME: return "rename";          case LDAP_RES_RENAME: return "rename";
         case LDAP_RES_SEARCH_ENTRY: return "search-entry";          case LDAP_RES_SEARCH_ENTRY: return "search-entry";
Line 1121  ldap_msgfree( LDAPMessage *lm ) Line 1326  ldap_msgfree( LDAPMessage *lm )
         LDAPMessage     *next;          LDAPMessage     *next;
         int             type = 0;          int             type = 0;
   
 #ifdef NEW_LOGGING  
         LDAP_LOG ( OPERATION, ENTRY, "ldap_msgfree\n", 0, 0, 0 );  
 #else  
         Debug( LDAP_DEBUG_TRACE, "ldap_msgfree\n", 0, 0, 0 );          Debug( LDAP_DEBUG_TRACE, "ldap_msgfree\n", 0, 0, 0 );
 #endif  
   
         for ( ; lm != NULL; lm = next ) {          for ( ; lm != NULL; lm = next ) {
                 next = lm->lm_chain;                  next = lm->lm_chain;
Line 1134  ldap_msgfree( LDAPMessage *lm ) Line 1335  ldap_msgfree( LDAPMessage *lm )
                 LDAP_FREE( (char *) lm );                  LDAP_FREE( (char *) lm );
         }          }
   
         return( type );          return type;
 }  }
   
 /*  /*
Line 1146  int Line 1347  int
 ldap_msgdelete( LDAP *ld, int msgid )  ldap_msgdelete( LDAP *ld, int msgid )
 {  {
         LDAPMessage     *lm, *prev;          LDAPMessage     *lm, *prev;
           int             rc = 0;
   
         assert( ld != NULL );          assert( ld != NULL );
   
 #ifdef NEW_LOGGING          Debug( LDAP_DEBUG_TRACE, "ldap_msgdelete ld=%p msgid=%d\n",
         LDAP_LOG ( OPERATION, ENTRY, "ldap_msgdelete\n", 0, 0, 0 );                  (void *)ld, msgid, 0 );
 #else  
         Debug( LDAP_DEBUG_TRACE, "ldap_msgdelete\n", 0, 0, 0 );  
 #endif  
   
   #ifdef LDAP_R_COMPILE
           ldap_pvt_thread_mutex_lock( &ld->ld_res_mutex );
   #endif
         prev = NULL;          prev = NULL;
         for ( lm = ld->ld_responses; lm != NULL; lm = lm->lm_next ) {          for ( lm = ld->ld_responses; lm != NULL; lm = lm->lm_next ) {
                 if ( lm->lm_msgid == msgid )                  if ( lm->lm_msgid == msgid ) {
                         break;                          break;
                   }
                 prev = lm;                  prev = lm;
         }          }
   
         if ( lm == NULL )          if ( lm == NULL ) {
                 return( -1 );                  rc = -1;
   
         if ( prev == NULL )          } else {
                 ld->ld_responses = lm->lm_next;                  if ( prev == NULL ) {
         else                          ld->ld_responses = lm->lm_next;
                 prev->lm_next = lm->lm_next;                  } else {
                           prev->lm_next = lm->lm_next;
                   }
           }
   #ifdef LDAP_R_COMPILE
           ldap_pvt_thread_mutex_unlock( &ld->ld_res_mutex );
   #endif
           if ( lm ) {
                   switch ( ldap_msgfree( lm ) ) {
                   case LDAP_RES_SEARCH_ENTRY:
                   case LDAP_RES_SEARCH_REFERENCE:
                   case LDAP_RES_INTERMEDIATE:
                           rc = -1;
                           break;
   
         if ( ldap_msgfree( lm ) == LDAP_RES_SEARCH_ENTRY )                  default:
                 return( -1 );                          break;
                   }
           }
   
         return( 0 );          return rc;
 }  }
   
   
 /*  /*
  * return 1 if message msgid is waiting to be abandoned, 0 otherwise   * ldap_abandoned
    *
    * return the location of the message id in the array of abandoned
    * message ids, or -1
    *
    * expects ld_res_mutex to be locked
  */   */
 static int  static int
 ldap_abandoned( LDAP *ld, ber_int_t msgid )  ldap_abandoned( LDAP *ld, ber_int_t msgid, int *idxp )
 {  {
         int     i;  #ifdef LDAP_R_COMPILE
           LDAP_PVT_THREAD_ASSERT_MUTEX_OWNER( &ld->ld_res_mutex );
         if ( ld->ld_abandoned == NULL )  #endif
                 return( 0 );  
   
         for ( i = 0; ld->ld_abandoned[i] != -1; i++ )          assert( idxp != NULL );
                 if ( ld->ld_abandoned[i] == msgid )          assert( msgid >= 0 );
                         return( 1 );          assert( ld->ld_nabandoned >= 0 );
   
         return( 0 );          return ldap_int_bisect_find( ld->ld_abandoned, ld->ld_nabandoned, msgid, idxp );
 }  }
   
   /*
    * ldap_mark_abandoned
    *
    * expects ld_res_mutex to be locked
    */
 static int  static int
 ldap_mark_abandoned( LDAP *ld, ber_int_t msgid )  ldap_mark_abandoned( LDAP *ld, ber_int_t msgid, int idx )
 {  {
         int     i;  #ifdef LDAP_R_COMPILE
           LDAP_PVT_THREAD_ASSERT_MUTEX_OWNER( &ld->ld_res_mutex );
         if ( ld->ld_abandoned == NULL )  #endif
                 return( -1 );  
   
         for ( i = 0; ld->ld_abandoned[i] != -1; i++ )  
                 if ( ld->ld_abandoned[i] == msgid )  
                         break;  
   
         if ( ld->ld_abandoned[i] == -1 )  
                 return( -1 );  
   
         for ( ; ld->ld_abandoned[i] != -1; i++ ) {          /* NOTE: those assertions are repeated in ldap_int_bisect_delete() */
                 ld->ld_abandoned[i] = ld->ld_abandoned[i + 1];          assert( idx >= 0 );
         }          assert( idx < ld->ld_nabandoned );
           assert( ld->ld_abandoned[ idx ] == msgid );
   
         return( 0 );          return ldap_int_bisect_delete( &ld->ld_abandoned, &ld->ld_nabandoned,
                   msgid, idx );
 }  }

Removed from v.1.64.2.13  
changed lines
  Added in v.1.124.2.11


______________
© Copyright 1998-2020, OpenLDAP Foundation, info@OpenLDAP.org