Diff for /libraries/libldap/result.c between versions 1.124.2.21 and 1.151

version 1.124.2.21, 2010/04/13 20:22:59 version 1.151, 2007/02/05 19:32:44
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.124.2.20 2009/11/18 17:04:31 quanah Exp $ */  /* $OpenLDAP: pkg/ldap/libraries/libldap/result.c,v 1.150 2007/02/05 09:10:24 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-2010 The OpenLDAP Foundation.   * Copyright 1998-2007 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 71  static int ldap_mark_abandoned LDAP_P(( Line 71  static int ldap_mark_abandoned LDAP_P((
 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 117  ldap_result( Line 118  ldap_result(
         ldap_pvt_thread_mutex_lock( &ld->ld_res_mutex );          ldap_pvt_thread_mutex_lock( &ld->ld_res_mutex );
 #endif  #endif
   
         rc = wait4msg( ld, msgid, all, timeout, result );  #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  #ifdef LDAP_R_COMPILE
         ldap_pvt_thread_mutex_unlock( &ld->ld_res_mutex );          ldap_pvt_thread_mutex_unlock( &ld->ld_res_mutex );
Line 231  chkResponseList( Line 244  chkResponseList(
                         "ldap_chkResponseList returns ld %p NULL\n", (void *)ld, 0, 0);                          "ldap_chkResponseList returns ld %p NULL\n", (void *)ld, 0, 0);
         } else {          } else {
                 Debug( LDAP_DEBUG_TRACE,                  Debug( LDAP_DEBUG_TRACE,
                         "ldap_chkResponseList returns ld %p msgid %d, type 0x%02lx\n",                          "ldap_chkResponseList returns ld %p msgid %d, type 0x%02lu\n",
                         (void *)ld, lm->lm_msgid, (unsigned long)lm->lm_msgtype );                          (void *)ld, lm->lm_msgid, (unsigned long)lm->lm_msgtype );
         }          }
 #endif  #endif
Line 250  wait4msg( Line 263  wait4msg(
         int             rc;          int             rc;
         struct timeval  tv = { 0 },          struct timeval  tv = { 0 },
                         tv0 = { 0 },                          tv0 = { 0 },
                         start_time_tv = { 0 },                          *tvp;
                         *tvp = NULL;          time_t          start_time = 0;
           time_t          tmp_time;
         LDAPConn        *lc;          LDAPConn        *lc;
   
         assert( ld != NULL );          assert( ld != NULL );
Line 276  wait4msg( Line 290  wait4msg(
         }          }
 #endif /* LDAP_DEBUG */  #endif /* LDAP_DEBUG */
   
         if ( timeout != NULL && timeout->tv_sec != -1 ) {          if ( timeout == NULL ) {
                   tvp = NULL;
           } else {
                 tv0 = *timeout;                  tv0 = *timeout;
                 tv = *timeout;                  tv = *timeout;
                 tvp = &tv;                  tvp = &tv;
 #ifdef HAVE_GETTIMEOFDAY                  start_time = time( NULL );
                 gettimeofday( &start_time_tv, NULL );  
 #else /* ! HAVE_GETTIMEOFDAY */  
                 time( &start_time_tv.tv_sec );  
                 start_time_tv.tv_usec = 0;  
 #endif /* ! HAVE_GETTIMEOFDAY */  
         }          }
                                           
         rc = LDAP_MSG_X_KEEP_LOOKING;          rc = LDAP_MSG_X_KEEP_LOOKING;
Line 309  wait4msg( Line 320  wait4msg(
                 }                  }
 #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 {                  } else {
Line 322  wait4msg( Line 333  wait4msg(
                                 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;
                                 }                                  }
Line 330  wait4msg( Line 348  wait4msg(
                         ldap_pvt_thread_mutex_unlock( &ld->ld_conn_mutex );                          ldap_pvt_thread_mutex_unlock( &ld->ld_conn_mutex );
 #endif  #endif
   
                         if ( !lc_ready ) {                          if ( !lc_ready ) {
                                 int err;  
                                 rc = ldap_int_select( ld, tvp );                                  rc = ldap_int_select( ld, tvp );
                                 if ( rc == -1 ) {  
                                         err = sock_errno();  
 #ifdef LDAP_DEBUG  #ifdef LDAP_DEBUG
                                   if ( rc == -1 ) {
                                         Debug( LDAP_DEBUG_TRACE,                                          Debug( LDAP_DEBUG_TRACE,
                                                 "ldap_int_select returned -1: errno %d\n",                                                  "ldap_int_select returned -1: errno %d\n",
                                                 err, 0, 0 );                                                  sock_errno(), 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)
                                                 || err != EINTR ) ) )                                                  || sock_errno() != EINTR ) ) )
                                 {                                  {
                                         ld->ld_errno = (rc == -1 ? LDAP_SERVER_DOWN :                                          ld->ld_errno = (rc == -1 ? LDAP_SERVER_DOWN :
                                                 LDAP_TIMEOUT);                                                  LDAP_TIMEOUT);
Line 355  wait4msg( Line 371  wait4msg(
                                         rc = LDAP_MSG_X_KEEP_LOOKING;   /* select interrupted: loop */                                          rc = LDAP_MSG_X_KEEP_LOOKING;   /* select interrupted: loop */
   
                                 } else {                                  } else {
                                         lc_ready = 1;                                          rc = LDAP_MSG_X_KEEP_LOOKING;
                                 }  
                         }  
                         if ( lc_ready ) {  
                                 LDAPConn *lnext;  
                                 rc = LDAP_MSG_X_KEEP_LOOKING;  
 #ifdef LDAP_R_COMPILE  
                                 ldap_pvt_thread_mutex_lock( &ld->ld_req_mutex );  
 #endif  
                                 if ( ld->ld_requests &&  
                                         ld->ld_requests->lr_status == LDAP_REQST_WRITING &&  
                                         ldap_is_write_ready( ld,  
                                                 ld->ld_requests->lr_conn->lconn_sb ) )  
                                 {  
                                         ldap_int_flush_request( ld, ld->ld_requests );  
                                 }  
 #ifdef LDAP_R_COMPILE  #ifdef LDAP_R_COMPILE
                                 ldap_pvt_thread_mutex_unlock( &ld->ld_req_mutex );                                          ldap_pvt_thread_mutex_lock( &ld->ld_req_mutex );
                                 ldap_pvt_thread_mutex_lock( &ld->ld_conn_mutex );  
 #endif  #endif
                                 for ( lc = ld->ld_conns;                                          if ( ld->ld_requests &&
                                         rc == LDAP_MSG_X_KEEP_LOOKING && lc != NULL;                                                  ld->ld_requests->lr_status == LDAP_REQST_WRITING &&
                                         lc = lnext )                                                  ldap_is_write_ready( ld,
                                 {                                                          ld->ld_requests->lr_conn->lconn_sb ) )
                                         if ( lc->lconn_status == LDAP_CONNST_CONNECTED &&  
                                                 ldap_is_read_ready( ld, lc->lconn_sb ) )  
                                         {                                          {
                                                 /* Don't let it get freed out from under us */                                                  ldap_int_flush_request( ld, ld->ld_requests );
                                                 ++lc->lconn_refcnt;                                          }
 #ifdef LDAP_R_COMPILE  #ifdef LDAP_R_COMPILE
                                                 ldap_pvt_thread_mutex_unlock( &ld->ld_conn_mutex );                                          ldap_pvt_thread_mutex_unlock( &ld->ld_req_mutex );
                                           ldap_pvt_thread_mutex_lock( &ld->ld_conn_mutex );
 #endif  #endif
                                                 rc = try_read1msg( ld, msgid, all, lc, result );                                          for ( lc = ld->ld_conns;
                                                 lnext = lc->lconn_next;                                                  rc == LDAP_MSG_X_KEEP_LOOKING && lc != NULL; )
                                           {
                                                   if ( lc->lconn_status == LDAP_CONNST_CONNECTED &&
                                                           ldap_is_read_ready( ld, lc->lconn_sb ) )
                                                   {
   #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
                                                           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;
   
                                                 /* Only take locks if we're really freeing */                                                                  /* don't get to next conn! */
                                                 if ( lc->lconn_refcnt <= 1 ) {                                                                  break;
 #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  
                                                 } else {  
                                                         --lc->lconn_refcnt;  
                                                 }                                                  }
 #ifdef LDAP_R_COMPILE  
                                                 ldap_pvt_thread_mutex_lock( &ld->ld_conn_mutex );                                                  /* next conn */
 #endif                                                  lc = lc->lconn_next;
                                         } else {  
                                                 lnext = lc->lconn_next;  
                                         }                                          }
                                 }  
 #ifdef LDAP_R_COMPILE  #ifdef LDAP_R_COMPILE
                                 ldap_pvt_thread_mutex_unlock( &ld->ld_conn_mutex );                                          ldap_pvt_thread_mutex_unlock( &ld->ld_conn_mutex );
 #endif  #endif
                                   }
                         }                          }
                 }                  }
   
                 if ( rc == LDAP_MSG_X_KEEP_LOOKING && tvp != NULL ) {                  if ( rc == LDAP_MSG_X_KEEP_LOOKING && tvp != NULL ) {
                         struct timeval  curr_time_tv = { 0 },                          tmp_time = time( NULL );
                                         delta_time_tv = { 0 };                          tv0.tv_sec -= ( tmp_time - start_time );
                           if ( tv0.tv_sec <= 0 ) {
 #ifdef HAVE_GETTIMEOFDAY                                  rc = 0; /* timed out */
                         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;
                         }                          }
   
                         /* tv0 -= delta_time */  
                         tv0.tv_sec -= delta_time_tv.tv_sec;  
                         tv0.tv_usec -= delta_time_tv.tv_usec;  
                         if ( tv0.tv_usec < 0 ) {  
                                 tv0.tv_sec--;  
                                 tv0.tv_usec += 1000000;  
                         }  
   
                         tv.tv_sec = tv0.tv_sec;                          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",                          Debug( LDAP_DEBUG_TRACE, "wait4msg ld %p %ld secs to go\n",
                                 (void *)ld, (long) tv.tv_sec, (long) tv.tv_usec );                                  (void *)ld, (long) tv.tv_sec, 0 );
                           start_time = tmp_time;
                         start_time_tv.tv_sec = curr_time_tv.tv_sec;  
                         start_time_tv.tv_usec = curr_time_tv.tv_usec;  
                 }                  }
         }          }
   
Line 471  try_read1msg( Line 447  try_read1msg(
         LDAP *ld,          LDAP *ld,
         ber_int_t msgid,          ber_int_t msgid,
         int all,          int all,
         LDAPConn *lc,          LDAPConn **lcp,
         LDAPMessage **result )          LDAPMessage **result )
 {  {
         BerElement      *ber;          BerElement      *ber;
Line 482  try_read1msg( Line 458  try_read1msg(
         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, err;          int             rc, refer_cnt, hadref, simple_request;
         ber_int_t       lderr;          ber_int_t       lderr;
   
 #ifdef LDAP_CONNECTIONLESS  #ifdef LDAP_CONNECTIONLESS
Line 492  try_read1msg( Line 469  try_read1msg(
 #endif  #endif
   
         assert( ld != NULL );          assert( ld != NULL );
         assert( lc != NULL );          assert( lcp != NULL );
           assert( *lcp != NULL );
                   
 #ifdef LDAP_R_COMPILE  #ifdef LDAP_R_COMPILE
         LDAP_PVT_THREAD_ASSERT_MUTEX_OWNER( &ld->ld_res_mutex );          LDAP_PVT_THREAD_ASSERT_MUTEX_OWNER( &ld->ld_res_mutex );
Line 501  try_read1msg( Line 479  try_read1msg(
         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 534  nextresp3: Line 514  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                        #ifdef EWOULDBLOCK                      
                 if ( err == EWOULDBLOCK ) return LDAP_MSG_X_KEEP_LOOKING;                  if ( sock_errno() == EWOULDBLOCK ) return LDAP_MSG_X_KEEP_LOOKING;
 #endif  #endif
 #ifdef EAGAIN  #ifdef EAGAIN
                 if ( err == EAGAIN ) return LDAP_MSG_X_KEEP_LOOKING;                  if ( sock_errno() == EAGAIN ) return LDAP_MSG_X_KEEP_LOOKING;
 #endif  #endif
                 ld->ld_errno = LDAP_SERVER_DOWN;                  ld->ld_errno = LDAP_SERVER_DOWN;
                 --lc->lconn_refcnt;  
                 lc->lconn_status = 0;  
                 return -1;                  return -1;
   
         default:          default:
Line 564  nextresp3: Line 541  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, &idx ) ) {
Line 589  nextresp3: Line 561  nextresp3:
                         }                          }
   
                         Debug( LDAP_DEBUG_ANY,                          Debug( LDAP_DEBUG_ANY,
                                 "abandoned/discarded ld %p msgid %d message type %s\n",                                  "abandoned/discarded ld %p msgid %ld message type %s\n",
                                 (void *)ld, id, ldap_int_msgtype2str( tag ) );                                  (void *)ld, (long)id, ldap_int_msgtype2str( tag ) );
   
 retry_ber:  retry_ber:
                         ber_free( ber, 1 );                          ber_free( ber, 1 );
Line 616  retry_ber: Line 588  retry_ber:
                         }                          }
   
                         Debug( LDAP_DEBUG_ANY,                          Debug( LDAP_DEBUG_ANY,
                                 "no request for response on ld %p msgid %d message type %s (tossing)\n",                                  "no request for response on ld %p msgid %ld message type %s (tossing)\n",
                                 (void *)ld, id, msg );                                  (void *)ld, (long)id, msg );
   
                         goto retry_ber;                          goto retry_ber;
                 }                  }
Line 627  retry_ber: Line 599  retry_ber:
                         ber_scanf(ber, "x{");                          ber_scanf(ber, "x{");
                 }                  }
 nextresp2:  nextresp2:
                 ;  
 #endif  #endif
         }          }
   
Line 640  nextresp2: Line 611  nextresp2:
         }          }
   
         Debug( LDAP_DEBUG_TRACE,          Debug( LDAP_DEBUG_TRACE,
                 "read1msg: ld %p msgid %d message type %s\n",                  "read1msg: ld %p msgid %ld message type %s\n",
                 (void *)ld, id, ldap_int_msgtype2str( tag ) );                  (void *)ld, (long)lr->lr_msgid, ldap_int_msgtype2str( tag ) );
   
         if ( id == 0 ) {          if ( id == 0 ) {
                 /* unsolicited notification message (RFC 4511) */                  /* unsolicited notification message (RFC 4511) */
Line 845  nextresp2: Line 816  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 892  nextresp2: Line 859  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 %d\n",                                  Debug( LDAP_DEBUG_ANY, "request done: ld %p msgid %ld\n",
                                         (void *)ld, id, 0 );                                          (void *)ld, (long) 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 921  nextresp2: Line 888  nextresp2:
                          * shouldn't necessarily end the connection                           * shouldn't necessarily end the connection
                          */                           */
                         if ( lc != NULL && id != 0 ) {                          if ( lc != NULL && id != 0 ) {
                                 --lc->lconn_refcnt;  #ifdef LDAP_R_COMPILE
                                 lc = NULL;                                  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;
                         }                          }
                 }                  }
         }          }
Line 988  nextresp2: Line 961  nextresp2:
   
                         /* get rid of the connection... */                          /* get rid of the connection... */
                         if ( lc != NULL ) {                          if ( lc != NULL ) {
                                 --lc->lconn_refcnt;  #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                          /* need to return -1, because otherwise
Line 1097  nextresp2: Line 1077  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 1136  nextresp2: Line 1115  nextresp2:
                 goto exit;                  goto exit;
         }          }
   
         Debug( LDAP_DEBUG_TRACE, "adding response ld %p msgid %d type %ld:\n",          Debug( LDAP_DEBUG_TRACE, "adding response ld %p msgid %ld type %ld:\n",
                 (void *)ld, newmsg->lm_msgid, (long) newmsg->lm_msgtype );                  (void *)ld, (long) 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 1387  ldap_abandoned( LDAP *ld, ber_int_t msgi Line 1366  ldap_abandoned( LDAP *ld, ber_int_t msgi
   
         assert( idxp != NULL );          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 );          return ldap_int_bisect_find( ld->ld_abandoned, ld->ld_nabandoned, msgid, idxp );
 }  }
Line 1405  ldap_mark_abandoned( LDAP *ld, ber_int_t Line 1385  ldap_mark_abandoned( LDAP *ld, ber_int_t
   
         /* NOTE: those assertions are repeated in ldap_int_bisect_delete() */          /* NOTE: those assertions are repeated in ldap_int_bisect_delete() */
         assert( idx >= 0 );          assert( idx >= 0 );
         assert( (unsigned) idx < ld->ld_nabandoned );          assert( idx < ld->ld_nabandoned );
         assert( ld->ld_abandoned[ idx ] == msgid );          assert( ld->ld_abandoned[ idx ] == msgid );
   
         return ldap_int_bisect_delete( &ld->ld_abandoned, &ld->ld_nabandoned,          return ldap_int_bisect_delete( &ld->ld_abandoned, &ld->ld_nabandoned,

Removed from v.1.124.2.21  
changed lines
  Added in v.1.151


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