Diff for /libraries/libldap/result.c between versions 1.159 and 1.178

version 1.159, 2008/01/07 23:20:04 version 1.178, 2010/12/11 03:51:21
Line 1 Line 1
 /* result.c - wait for an ldap result */  /* result.c - wait for an ldap result */
 /* $OpenLDAP: pkg/ldap/libraries/libldap/result.c,v 1.158 2007/12/20 01:46:59 hyc Exp $ */  /* $OpenLDAP: pkg/ldap/libraries/libldap/result.c,v 1.177 2010/12/11 03:35:01 hyc Exp $ */
 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.  /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
  *   *
  * Copyright 1998-2008 The OpenLDAP Foundation.   * Copyright 1998-2010 The OpenLDAP Foundation.
  * All rights reserved.   * All rights reserved.
  *   *
  * Redistribution and use in source and binary forms, with or without   * Redistribution and use in source and binary forms, with or without
Line 66 Line 66
 #include "ldap_log.h"  #include "ldap_log.h"
 #include "lutil.h"  #include "lutil.h"
   
 static int ldap_abandoned LDAP_P(( LDAP *ld, ber_int_t msgid, int *idx ));  static int ldap_abandoned LDAP_P(( LDAP *ld, ber_int_t msgid ));
 static int ldap_mark_abandoned LDAP_P(( LDAP *ld, ber_int_t msgid, int idx ));  static int ldap_mark_abandoned LDAP_P(( LDAP *ld, ber_int_t msgid ));
 static int wait4msg LDAP_P(( LDAP *ld, ber_int_t msgid, int all, struct timeval *timeout,  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, 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));
Line 106  ldap_result( Line 106  ldap_result(
         struct timeval *timeout,          struct timeval *timeout,
         LDAPMessage **result )          LDAPMessage **result )
 {  {
         LDAPMessage     *lm = NULL;  
         int             rc;          int             rc;
   
         assert( ld != NULL );          assert( ld != NULL );
Line 114  ldap_result( Line 113  ldap_result(
   
         Debug( LDAP_DEBUG_TRACE, "ldap_result ld %p msgid %d\n", (void *)ld, msgid, 0 );          Debug( LDAP_DEBUG_TRACE, "ldap_result ld %p msgid %d\n", (void *)ld, msgid, 0 );
   
 #ifdef LDAP_R_COMPILE          LDAP_MUTEX_LOCK( &ld->ld_res_mutex );
         ldap_pvt_thread_mutex_lock( &ld->ld_res_mutex );          rc = wait4msg( ld, msgid, all, timeout, result );
 #endif          LDAP_MUTEX_UNLOCK( &ld->ld_res_mutex );
   
 #if 0  
         /* this is already done inside wait4msg(), right?... */  
         lm = chkResponseList( ld, msgid, all );  
 #endif  
   
         if ( lm == NULL ) {  
                 rc = wait4msg( ld, msgid, all, timeout, result );  
   
         } else {  
                 *result = lm;  
                 ld->ld_errno = LDAP_SUCCESS;  
                 rc = lm->lm_msgtype;  
         }  
   
 #ifdef LDAP_R_COMPILE  
         ldap_pvt_thread_mutex_unlock( &ld->ld_res_mutex );  
 #endif  
   
         return rc;          return rc;
 }  }
   
   /* protected by res_mutex */
 static LDAPMessage *  static LDAPMessage *
 chkResponseList(  chkResponseList(
         LDAP *ld,          LDAP *ld,
Line 155  chkResponseList( Line 137  chkResponseList(
          * wait until it arrives or timeout occurs.           * wait until it arrives or timeout occurs.
          */           */
   
 #ifdef LDAP_R_COMPILE          LDAP_ASSERT_MUTEX_OWNER( &ld->ld_res_mutex );
         LDAP_PVT_THREAD_ASSERT_MUTEX_OWNER( &ld->ld_res_mutex );  
 #endif  
   
         Debug( LDAP_DEBUG_TRACE,          Debug( LDAP_DEBUG_TRACE,
                 "ldap_chkResponseList ld %p msgid %d all %d\n",                  "ldap_chkResponseList ld %p msgid %d all %d\n",
Line 165  chkResponseList( Line 145  chkResponseList(
   
         lastlm = &ld->ld_responses;          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;                  ++cnt;
   
                 if ( ldap_abandoned( ld, lm->lm_msgid, &idx ) ) {                  if ( ldap_abandoned( ld, lm->lm_msgid ) ) {
                         Debug( LDAP_DEBUG_ANY,                          Debug( LDAP_DEBUG_ANY,
                                 "response list msg abandoned, "                                  "response list msg abandoned, "
                                 "msgid %d message type %s\n",                                  "msgid %d message type %s\n",
Line 185  chkResponseList( Line 163  chkResponseList(
                         default:                          default:
                                 /* there's no need to keep the id                                  /* there's no need to keep the id
                                  * in the abandoned list any longer */                                   * in the abandoned list any longer */
                                 ldap_mark_abandoned( ld, lm->lm_msgid, idx );                                  ldap_mark_abandoned( ld, lm->lm_msgid );
                                 break;                                  break;
                         }                          }
   
Line 252  chkResponseList( Line 230  chkResponseList(
         return lm;          return lm;
 }  }
   
   /* protected by res_mutex */
 static int  static int
 wait4msg(  wait4msg(
         LDAP *ld,          LDAP *ld,
Line 270  wait4msg( Line 249  wait4msg(
         assert( ld != NULL );          assert( ld != NULL );
         assert( result != NULL );          assert( result != NULL );
   
 #ifdef LDAP_R_COMPILE          LDAP_ASSERT_MUTEX_OWNER( &ld->ld_res_mutex );
         LDAP_PVT_THREAD_ASSERT_MUTEX_OWNER( &ld->ld_res_mutex );  
 #endif  
   
         if ( timeout == NULL && ld->ld_options.ldo_tm_api.tv_sec >= 0 ) {          if ( timeout == NULL && ld->ld_options.ldo_tm_api.tv_sec >= 0 ) {
                 tv = ld->ld_options.ldo_tm_api;                  tv = ld->ld_options.ldo_tm_api;
Line 289  wait4msg( Line 266  wait4msg(
         }          }
 #endif /* LDAP_DEBUG */  #endif /* LDAP_DEBUG */
   
         if ( timeout != NULL ) {          if ( timeout != NULL && timeout->tv_sec != -1 ) {
                 tv0 = *timeout;                  tv0 = *timeout;
                 tv = *timeout;                  tv = *timeout;
                 tvp = &tv;                  tvp = &tv;
Line 307  wait4msg( Line 284  wait4msg(
                 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",                          Debug( LDAP_DEBUG_TRACE, "wait4msg continue ld %p msgid %d all %d\n",
                                 (void *)ld, msgid, all );                                  (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_MUTEX_LOCK( &ld->ld_req_mutex );
                         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_MUTEX_UNLOCK( &ld->ld_req_mutex );
                         ldap_pvt_thread_mutex_unlock( &ld->ld_req_mutex );  
 #endif  
                 }                  }
 #endif /* LDAP_DEBUG */  #endif /* LDAP_DEBUG */
   
Line 328  wait4msg( Line 297  wait4msg(
                 } else {                  } else {
                         int lc_ready = 0;                          int lc_ready = 0;
   
 #ifdef LDAP_R_COMPILE                          LDAP_MUTEX_LOCK( &ld->ld_conn_mutex );
                         ldap_pvt_thread_mutex_lock( &ld->ld_conn_mutex );  
 #endif  
                         for ( lc = ld->ld_conns; lc != NULL; lc = lc->lconn_next ) {                          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 ) )
                                 {                                  {
 #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 );  
 #endif  
                                         lc_ready = 1;                                          lc_ready = 1;
                                         break;                                          break;
                                 }                                  }
                         }                          }
 #ifdef LDAP_R_COMPILE  
                         ldap_pvt_thread_mutex_unlock( &ld->ld_conn_mutex );  
 #endif  
   
                         if ( !lc_ready ) {                          if ( !lc_ready ) {
                                   int err;
                                 rc = ldap_int_select( ld, tvp );                                  rc = ldap_int_select( ld, tvp );
 #ifdef LDAP_DEBUG  
                                 if ( rc == -1 ) {                                  if ( rc == -1 ) {
                                           err = sock_errno();
   #ifdef LDAP_DEBUG
                                         Debug( LDAP_DEBUG_TRACE,                                          Debug( LDAP_DEBUG_TRACE,
                                                 "ldap_int_select returned -1: errno %d\n",                                                  "ldap_int_select returned -1: errno %d\n",
                                                 sock_errno(), 0, 0 );                                                  err, 0, 0 );
                                 }  
 #endif  #endif
                                   }
   
                                 if ( rc == 0 || ( rc == -1 && (                                  if ( rc == 0 || ( rc == -1 && (
                                         !LDAP_BOOL_GET(&ld->ld_options, LDAP_BOOL_RESTART)                                          !LDAP_BOOL_GET(&ld->ld_options, LDAP_BOOL_RESTART)
                                                 || sock_errno() != EINTR ) ) )                                                  || err != EINTR ) ) )
                                 {                                  {
                                         ld->ld_errno = (rc == -1 ? LDAP_SERVER_DOWN :                                          ld->ld_errno = (rc == -1 ? LDAP_SERVER_DOWN :
                                                 LDAP_TIMEOUT);                                                  LDAP_TIMEOUT);
                                           LDAP_MUTEX_UNLOCK( &ld->ld_conn_mutex );
                                         return( rc );                                          return( rc );
                                 }                                  }
   
Line 373  wait4msg( Line 333  wait4msg(
                                         rc = LDAP_MSG_X_KEEP_LOOKING;   /* select interrupted: loop */                                          rc = LDAP_MSG_X_KEEP_LOOKING;   /* select interrupted: loop */
   
                                 } else {                                  } else {
                                         rc = LDAP_MSG_X_KEEP_LOOKING;                                          lc_ready = 1;
 #ifdef LDAP_R_COMPILE                                  }
                                         ldap_pvt_thread_mutex_lock( &ld->ld_req_mutex );                          }
 #endif                          if ( lc_ready ) {
                                         if ( ld->ld_requests &&                                  LDAPConn *lnext;
                                                 ld->ld_requests->lr_status == LDAP_REQST_WRITING &&                                  rc = LDAP_MSG_X_KEEP_LOOKING;
                                                 ldap_is_write_ready( ld,                                  LDAP_MUTEX_LOCK( &ld->ld_req_mutex );
                                                         ld->ld_requests->lr_conn->lconn_sb ) )                                  if ( ld->ld_requests &&
                                         {                                          ld->ld_requests->lr_status == LDAP_REQST_WRITING &&
                                                 ldap_int_flush_request( ld, ld->ld_requests );                                          ldap_is_write_ready( ld,
                                         }                                                  ld->ld_requests->lr_conn->lconn_sb ) )
 #ifdef LDAP_R_COMPILE                                  {
                                         ldap_pvt_thread_mutex_unlock( &ld->ld_req_mutex );                                          ldap_int_flush_request( ld, ld->ld_requests );
                                         ldap_pvt_thread_mutex_lock( &ld->ld_conn_mutex );                                  }
 #endif                                  for ( lc = ld->ld_conns;
                                         for ( lc = ld->ld_conns;                                          rc == LDAP_MSG_X_KEEP_LOOKING && lc != NULL;
                                                 rc == LDAP_MSG_X_KEEP_LOOKING && lc != NULL; )                                          lc = lnext )
                                   {
                                           if ( lc->lconn_status == LDAP_CONNST_CONNECTED &&
                                                   ldap_is_read_ready( ld, lc->lconn_sb ) )
                                         {                                          {
                                                 if ( lc->lconn_status == LDAP_CONNST_CONNECTED &&                                                  /* Don't let it get freed out from under us */
                                                         ldap_is_read_ready( ld, lc->lconn_sb ) )                                                  ++lc->lconn_refcnt;
                                                 {                                                  rc = try_read1msg( ld, msgid, all, lc, result );
 #ifdef LDAP_R_COMPILE                                                  lnext = lc->lconn_next;
                                                         ldap_pvt_thread_mutex_unlock( &ld->ld_conn_mutex );  
 #endif                                                  /* Only take locks if we're really freeing */
                                                         rc = try_read1msg( ld, msgid, all, &lc, result );                                                  if ( lc->lconn_refcnt <= 1 ) {
 #ifdef LDAP_R_COMPILE                                                          ldap_free_connection( ld, lc, 0, 1 );
                                                         ldap_pvt_thread_mutex_lock( &ld->ld_conn_mutex );                                                  } else {
 #endif                                                          --lc->lconn_refcnt;
                                                         if ( lc == NULL ) {  
                                                                 /* if lc gets free()'d,  
                                                                  * 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;  
                                                         }  
                                                 }                                                  }
                                           } else {
                                                 /* next conn */                                                  lnext = lc->lconn_next;
                                                 lc = lc->lconn_next;  
                                         }                                          }
 #ifdef LDAP_R_COMPILE  
                                         ldap_pvt_thread_mutex_unlock( &ld->ld_conn_mutex );  
 #endif  
                                 }                                  }
                                   LDAP_MUTEX_UNLOCK( &ld->ld_req_mutex );
                         }                          }
                           LDAP_MUTEX_UNLOCK( &ld->ld_conn_mutex );
                 }                  }
   
                 if ( rc == LDAP_MSG_X_KEEP_LOOKING && tvp != NULL ) {                  if ( rc == LDAP_MSG_X_KEEP_LOOKING && tvp != NULL ) {
Line 475  wait4msg( Line 425  wait4msg(
 }  }
   
   
   /* protected by res_mutex, conn_mutex and req_mutex */
 static ber_tag_t  static ber_tag_t
 try_read1msg(  try_read1msg(
         LDAP *ld,          LDAP *ld,
         ber_int_t msgid,          ber_int_t msgid,
         int all,          int all,
         LDAPConn **lcp,          LDAPConn *lc,
         LDAPMessage **result )          LDAPMessage **result )
 {  {
         BerElement      *ber;          BerElement      *ber;
         LDAPMessage     *newmsg, *l, *prev;          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, dummy_lr = { 0 };          LDAPRequest     *lr, *tmplr, dummy_lr = { 0 };
         LDAPConn        *lc;  
         BerElement      tmpber;          BerElement      tmpber;
         int             rc, refer_cnt, hadref, simple_request;          int             rc, refer_cnt, hadref, simple_request, err;
         ber_int_t       lderr;          ber_int_t       lderr;
   
 #ifdef LDAP_CONNECTIONLESS  #ifdef LDAP_CONNECTIONLESS
Line 502  try_read1msg( Line 451  try_read1msg(
 #endif  #endif
   
         assert( ld != NULL );          assert( ld != NULL );
         assert( lcp != NULL );          assert( lc != NULL );
         assert( *lcp != NULL );  
                   
 #ifdef LDAP_R_COMPILE          LDAP_ASSERT_MUTEX_OWNER( &ld->ld_res_mutex );
         LDAP_PVT_THREAD_ASSERT_MUTEX_OWNER( &ld->ld_res_mutex );          LDAP_ASSERT_MUTEX_OWNER( &ld->ld_conn_mutex );
 #endif          LDAP_ASSERT_MUTEX_OWNER( &ld->ld_req_mutex );
   
         Debug( LDAP_DEBUG_TRACE, "read1msg: ld %p msgid %d all %d\n",          Debug( LDAP_DEBUG_TRACE, "read1msg: ld %p msgid %d all %d\n",
                 (void *)ld, msgid, all );                  (void *)ld, msgid, all );
   
         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 );
Line 547  nextresp3: Line 493  nextresp3:
                 break;                  break;
   
         case LBER_DEFAULT:          case LBER_DEFAULT:
                   err = sock_errno();
 #ifdef LDAP_DEBUG                    #ifdef LDAP_DEBUG                  
                 Debug( LDAP_DEBUG_CONNS,                  Debug( LDAP_DEBUG_CONNS,
                         "ber_get_next failed.\n", 0, 0, 0 );                          "ber_get_next failed.\n", 0, 0, 0 );
 #endif               #endif             
 #ifdef EWOULDBLOCK                                        if ( err == EWOULDBLOCK ) return LDAP_MSG_X_KEEP_LOOKING;
                 if ( sock_errno() == EWOULDBLOCK ) return LDAP_MSG_X_KEEP_LOOKING;                  if ( err == EAGAIN ) return LDAP_MSG_X_KEEP_LOOKING;
 #endif  
 #ifdef EAGAIN  
                 if ( sock_errno() == EAGAIN ) return LDAP_MSG_X_KEEP_LOOKING;  
 #endif  
                 ld->ld_errno = LDAP_SERVER_DOWN;                  ld->ld_errno = LDAP_SERVER_DOWN;
 #ifdef LDAP_R_COMPILE                  --lc->lconn_refcnt;
                 ldap_pvt_thread_mutex_lock( &ld->ld_req_mutex );                  lc->lconn_status = 0;
 #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;                  return -1;
   
         default:          default:
Line 582  nextresp3: Line 519  nextresp3:
   
         /* id == 0 iff unsolicited notification message (RFC 4511) */          /* 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 ( id > 0 ) {          if ( id > 0 ) {
                 if ( ldap_abandoned( ld, id, &idx ) ) {                  if ( ldap_abandoned( ld, id ) ) {
                         /* the message type */                          /* the message type */
                         tag = ber_peek_tag( ber, &len );                          tag = ber_peek_tag( ber, &len );
                         switch ( tag ) {                          switch ( tag ) {
Line 597  nextresp3: Line 539  nextresp3:
                         default:                          default:
                                 /* there's no need to keep the id                                  /* there's no need to keep the id
                                  * in the abandoned list any longer */                                   * in the abandoned list any longer */
                                 ldap_mark_abandoned( ld, id, idx );                                  ldap_mark_abandoned( ld, id );
                                 break;                                  break;
                         }                          }
   
                         Debug( LDAP_DEBUG_ANY,                          Debug( LDAP_DEBUG_ANY,
                                 "abandoned/discarded ld %p msgid %ld message type %s\n",                                  "abandoned/discarded ld %p msgid %d message type %s\n",
                                 (void *)ld, (long)id, ldap_int_msgtype2str( tag ) );                                  (void *)ld, id, ldap_int_msgtype2str( tag ) );
   
 retry_ber:  retry_ber:
                         ber_free( ber, 1 );                          ber_free( ber, 1 );
Line 629  retry_ber: Line 571  retry_ber:
                         }                          }
   
                         Debug( LDAP_DEBUG_ANY,                          Debug( LDAP_DEBUG_ANY,
                                 "no request for response on ld %p msgid %ld message type %s (tossing)\n",                                  "no request for response on ld %p msgid %d message type %s (tossing)\n",
                                 (void *)ld, (long)id, msg );                                  (void *)ld, id, msg );
   
                         goto retry_ber;                          goto retry_ber;
                 }                  }
Line 640  retry_ber: Line 582  retry_ber:
                         ber_scanf(ber, "x{");                          ber_scanf(ber, "x{");
                 }                  }
 nextresp2:  nextresp2:
                   ;
 #endif  #endif
         }          }
   
Line 652  nextresp2: Line 595  nextresp2:
         }          }
   
         Debug( LDAP_DEBUG_TRACE,          Debug( LDAP_DEBUG_TRACE,
                 "read1msg: ld %p msgid %ld message type %s\n",                  "read1msg: ld %p msgid %d message type %s\n",
                 (void *)ld, (long)lr->lr_msgid, ldap_int_msgtype2str( tag ) );                  (void *)ld, id, ldap_int_msgtype2str( tag ) );
   
         if ( id == 0 ) {          if ( id == 0 ) {
                 /* unsolicited notification message (RFC 4511) */                  /* unsolicited notification message (RFC 4511) */
Line 759  nextresp2: Line 702  nextresp2:
                         }                          }
   
                         /* Do we need to check for referrals? */                          /* Do we need to check for referrals? */
                         if ( LDAP_BOOL_GET(&ld->ld_options, LDAP_BOOL_REFERRALS) ||                          if ( tag != LDAP_RES_BIND &&
                                         lr->lr_parent != NULL )                                  ( LDAP_BOOL_GET(&ld->ld_options, LDAP_BOOL_REFERRALS) ||
                                           lr->lr_parent != NULL ))
                         {                          {
                                 char            **refs = NULL;                                  char            **refs = NULL;
                                 ber_len_t       len;                                  ber_len_t       len;
Line 857  nextresp2: Line 801  nextresp2:
                                 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 */
                           if ( lr->lr_res_matched ) {
                                   LDAP_FREE( lr->lr_res_matched );
                                   lr->lr_res_matched = NULL;
                           }
   
                 } else {                  } else {
                         if ( lr->lr_outrefcnt <= 0 && lr->lr_parent == NULL ) {                          if ( lr->lr_outrefcnt <= 0 && lr->lr_parent == NULL ) {
Line 873  nextresp2: Line 821  nextresp2:
                         Debug( LDAP_DEBUG_TRACE,                          Debug( LDAP_DEBUG_TRACE,
                                 "read1msg:  mark request completed, ld %p msgid %d\n",                                  "read1msg:  mark request completed, ld %p msgid %d\n",
                                 (void *)ld, lr->lr_msgid, 0);                                  (void *)ld, lr->lr_msgid, 0);
                           tmplr = lr;
                         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 881  nextresp2: Line 830  nextresp2:
                                         break;  /* not completely done yet */                                          break;  /* not completely done yet */
                                 }                                  }
                         }                          }
                           /* ITS#6744: Original lr was refcounted when we retrieved it,
                            * must release it now that we're working with the parent
                            */
                           if ( tmplr->lr_parent ) {
                                   ldap_return_request( ld, tmplr, 0 );
                           }
   
                         /* Check if all requests are finished, lr is now parent */                          /* Check if all requests are finished, lr is now parent */
                         tmplr = lr;                          tmplr = lr;
Line 900  nextresp2: Line 855  nextresp2:
                         {                          {
                                 id = lr->lr_msgid;                                  id = lr->lr_msgid;
                                 tag = lr->lr_res_msgtype;                                  tag = lr->lr_res_msgtype;
                                 Debug( LDAP_DEBUG_TRACE, "request done: ld %p msgid %ld\n",                                  Debug( LDAP_DEBUG_TRACE, "request done: ld %p msgid %d\n",
                                         (void *)ld, (long) id, 0 );                                          (void *)ld, id, 0 );
                                 Debug( LDAP_DEBUG_TRACE,                                  Debug( LDAP_DEBUG_TRACE,
                                         "res_errno: %d, res_error: <%s>, "                                          "res_errno: %d, res_error: <%s>, "
                                         "res_matched: <%s>\n",                                          "res_matched: <%s>\n",
Line 925  nextresp2: Line 880  nextresp2:
                         }                          }
   
                         /*                          /*
                          * RF 4511 unsolicited (id == 0) responses                           * RFC 4511 unsolicited (id == 0) responses
                          * shouldn't necessarily end the connection                           * shouldn't necessarily end the connection
                          */                           */
                         if ( lc != NULL && id != 0 ) {                          if ( lc != NULL && id != 0 ) {
 #ifdef LDAP_R_COMPILE                                  --lc->lconn_refcnt;
                                 ldap_pvt_thread_mutex_lock( &ld->ld_req_mutex );                                  lc = NULL;
 #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;  
                         }                          }
                 }                  }
         }          }
Line 1002  nextresp2: Line 951  nextresp2:
   
                         /* get rid of the connection... */                          /* get rid of the connection... */
                         if ( lc != NULL ) {                          if ( lc != NULL ) {
 #ifdef LDAP_R_COMPILE                                  --lc->lconn_refcnt;
                                 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                          /* need to return -1, because otherwise
                          * a valid result is expected */                           * a valid result is expected */
                           ld->ld_errno = lderr;
                         return -1;                          return -1;
                 }                  }
         }          }
Line 1118  nextresp2: Line 1061  nextresp2:
         if ( msgid == LDAP_RES_ANY || id == msgid ) {          if ( msgid == LDAP_RES_ANY || id == msgid ) {
                 if ( all == LDAP_MSG_ONE                  if ( all == LDAP_MSG_ONE
                         || ( newmsg->lm_msgtype != LDAP_RES_SEARCH_RESULT                          || ( newmsg->lm_msgtype != LDAP_RES_SEARCH_RESULT
                                 && newmsg->lm_msgtype != LDAP_RES_SEARCH_ENTRY                                  && newmsg->lm_msgtype != LDAP_RES_SEARCH_ENTRY
                                   && newmsg->lm_msgtype != LDAP_RES_INTERMEDIATE
                                 && newmsg->lm_msgtype != LDAP_RES_SEARCH_REFERENCE ) )                                  && newmsg->lm_msgtype != LDAP_RES_SEARCH_REFERENCE ) )
                 {                  {
                         *result = newmsg;                          *result = newmsg;
Line 1156  nextresp2: Line 1100  nextresp2:
                 goto exit;                  goto exit;
         }          }
   
         Debug( LDAP_DEBUG_TRACE, "adding response ld %p msgid %ld type %ld:\n",          Debug( LDAP_DEBUG_TRACE, "adding response ld %p msgid %d type %ld:\n",
                 (void *)ld, (long) newmsg->lm_msgid, (long) newmsg->lm_msgtype );                  (void *)ld, newmsg->lm_msgid, (long) newmsg->lm_msgtype );
   
         /* part of a search response - add to end of list of entries */          /* part of a search response - add to end of list of entries */
         l->lm_chain_tail->lm_chain = newmsg;          l->lm_chain_tail->lm_chain = newmsg;
Line 1349  ldap_msgdelete( LDAP *ld, int msgid ) Line 1293  ldap_msgdelete( LDAP *ld, int msgid )
         Debug( LDAP_DEBUG_TRACE, "ldap_msgdelete ld=%p msgid=%d\n",          Debug( LDAP_DEBUG_TRACE, "ldap_msgdelete ld=%p msgid=%d\n",
                 (void *)ld, msgid, 0 );                  (void *)ld, msgid, 0 );
   
 #ifdef LDAP_R_COMPILE          LDAP_MUTEX_LOCK( &ld->ld_res_mutex );
         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 ) {
Line 1370  ldap_msgdelete( LDAP *ld, int msgid ) Line 1312  ldap_msgdelete( LDAP *ld, int msgid )
                         prev->lm_next = lm->lm_next;                          prev->lm_next = lm->lm_next;
                 }                  }
         }          }
 #ifdef LDAP_R_COMPILE          LDAP_MUTEX_UNLOCK( &ld->ld_res_mutex );
         ldap_pvt_thread_mutex_unlock( &ld->ld_res_mutex );  
 #endif  
         if ( lm ) {          if ( lm ) {
                 switch ( ldap_msgfree( lm ) ) {                  switch ( ldap_msgfree( lm ) ) {
                 case LDAP_RES_SEARCH_ENTRY:                  case LDAP_RES_SEARCH_ENTRY:
Line 1395  ldap_msgdelete( LDAP *ld, int msgid ) Line 1335  ldap_msgdelete( LDAP *ld, int msgid )
  *   *
  * return the location of the message id in the array of abandoned   * return the location of the message id in the array of abandoned
  * message ids, or -1   * message ids, or -1
  *  
  * expects ld_res_mutex to be locked  
  */   */
 static int  static int
 ldap_abandoned( LDAP *ld, ber_int_t msgid, int *idxp )  ldap_abandoned( LDAP *ld, ber_int_t msgid )
 {  {
 #ifdef LDAP_R_COMPILE          int     ret, idx;
         LDAP_PVT_THREAD_ASSERT_MUTEX_OWNER( &ld->ld_res_mutex );  
 #endif  
   
         assert( idxp != NULL );  
         assert( msgid >= 0 );          assert( msgid >= 0 );
         assert( ld->ld_nabandoned >= 0 );  
   
         return ldap_int_bisect_find( ld->ld_abandoned, ld->ld_nabandoned, msgid, idxp );          LDAP_MUTEX_LOCK( &ld->ld_abandon_mutex );
           ret = ldap_int_bisect_find( ld->ld_abandoned, ld->ld_nabandoned, msgid, &idx );
           LDAP_MUTEX_UNLOCK( &ld->ld_abandon_mutex );
           return ret;
 }  }
   
 /*  /*
  * ldap_mark_abandoned   * ldap_mark_abandoned
  *  
  * expects ld_res_mutex to be locked  
  */   */
 static int  static int
 ldap_mark_abandoned( LDAP *ld, ber_int_t msgid, int idx )  ldap_mark_abandoned( LDAP *ld, ber_int_t msgid )
 {  {
 #ifdef LDAP_R_COMPILE          int     ret, idx;
         LDAP_PVT_THREAD_ASSERT_MUTEX_OWNER( &ld->ld_res_mutex );  
 #endif  
   
         /* NOTE: those assertions are repeated in ldap_int_bisect_delete() */  
         assert( idx >= 0 );  
         assert( idx < ld->ld_nabandoned );  
         assert( ld->ld_abandoned[ idx ] == msgid );  
   
         return ldap_int_bisect_delete( &ld->ld_abandoned, &ld->ld_nabandoned,          assert( msgid >= 0 );
           LDAP_MUTEX_LOCK( &ld->ld_abandon_mutex );
           ret = ldap_int_bisect_find( ld->ld_abandoned, ld->ld_nabandoned, msgid, &idx );
           if (ret <= 0) {         /* error or already deleted by another thread */
                   LDAP_MUTEX_UNLOCK( &ld->ld_abandon_mutex );
                   return ret;
           }
           /* still in abandoned array, so delete */
           ret = ldap_int_bisect_delete( &ld->ld_abandoned, &ld->ld_nabandoned,
                 msgid, idx );                  msgid, idx );
           LDAP_MUTEX_UNLOCK( &ld->ld_abandon_mutex );
           return ret;
 }  }

Removed from v.1.159  
changed lines
  Added in v.1.178


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