Diff for /libraries/libldap/result.c between versions 1.99.2.15 and 1.99.2.18

version 1.99.2.15, 2006/04/03 19:49:54 version 1.99.2.18, 2006/11/07 04:06:22
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.99.2.14 2006/01/03 22:16:09 kurt Exp $ */  /* $OpenLDAP: pkg/ldap/libraries/libldap/result.c,v 1.99.2.17 2006/08/18 15:14:38 ando 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-2006 The OpenLDAP Foundation.   * Copyright 1998-2006 The OpenLDAP Foundation.
Line 233  wait4msg( Line 233  wait4msg(
                         *tvp;                          *tvp;
         time_t          start_time = 0;          time_t          start_time = 0;
         time_t          tmp_time;          time_t          tmp_time;
         LDAPConn        *lc, *nextlc;          LDAPConn        *lc;
   
         assert( ld != NULL );          assert( ld != NULL );
         assert( result != NULL );          assert( result != NULL );
Line 277  wait4msg( Line 277  wait4msg(
 #ifdef LDAP_R_COMPILE  #ifdef LDAP_R_COMPILE
                         ldap_pvt_thread_mutex_lock( &ld->ld_conn_mutex );                          ldap_pvt_thread_mutex_lock( &ld->ld_conn_mutex );
 #endif  #endif
                         for ( lc = ld->ld_conns; lc != NULL; lc = nextlc ) {                          for ( lc = ld->ld_conns; lc != NULL; lc = lc->lconn_next ) {
                                 nextlc = 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  #ifdef LDAP_R_COMPILE
Line 302  wait4msg( Line 301  wait4msg(
                                 if ( rc == -1 ) {                                  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",
                                                 errno, 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)
                                                 || errno != 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 333  wait4msg( Line 332  wait4msg(
                                         ldap_pvt_thread_mutex_unlock( &ld->ld_req_mutex );                                          ldap_pvt_thread_mutex_unlock( &ld->ld_req_mutex );
                                         ldap_pvt_thread_mutex_lock( &ld->ld_conn_mutex );                                          ldap_pvt_thread_mutex_lock( &ld->ld_conn_mutex );
 #endif  #endif
                                         for ( lc = ld->ld_conns; rc == LDAP_MSG_X_KEEP_LOOKING && lc != NULL;                                          for ( lc = ld->ld_conns;
                                                 lc = nextlc )                                                  rc == LDAP_MSG_X_KEEP_LOOKING && lc != NULL; )
                                         {                                          {
                                                 nextlc = lc->lconn_next;  
                                                 if ( lc->lconn_status == LDAP_CONNST_CONNECTED &&                                                  if ( lc->lconn_status == LDAP_CONNST_CONNECTED &&
                                                         ldap_is_read_ready( ld, lc->lconn_sb ))                                                          ldap_is_read_ready( ld, lc->lconn_sb ))
                                                 {                                                  {
Line 344  wait4msg( Line 342  wait4msg(
                                                         ldap_pvt_thread_mutex_unlock( &ld->ld_conn_mutex );                                                          ldap_pvt_thread_mutex_unlock( &ld->ld_conn_mutex );
 #endif  #endif
                                                         rc = try_read1msg( ld, msgid, all, &lc, result );                                                          rc = try_read1msg( ld, msgid, all, &lc, result );
                                                                 if ( lc == NULL ) lc = nextlc;  
 #ifdef LDAP_R_COMPILE  #ifdef LDAP_R_COMPILE
                                                         ldap_pvt_thread_mutex_lock( &ld->ld_conn_mutex );                                                          ldap_pvt_thread_mutex_lock( &ld->ld_conn_mutex );
 #endif  #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;
   
                                                                   /* don't get to next conn! */
                                                                   break;
                                                           }
                                                 }                                                  }
   
                                                   /* next conn */
                                                   lc = 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 );
Line 434  retry: Line 445  retry:
         assert( LBER_VALID (ber) );          assert( LBER_VALID (ber) );
   
         /* 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;
Line 458  nextresp3: Line 469  nextresp3:
                                 "ber_get_next failed.\n", 0, 0, 0 );                                  "ber_get_next failed.\n", 0, 0, 0 );
 #endif               #endif             
 #ifdef EWOULDBLOCK                        #ifdef EWOULDBLOCK                      
                         if (errno==EWOULDBLOCK) return LDAP_MSG_X_KEEP_LOOKING;                          if ( sock_errno() == EWOULDBLOCK ) return LDAP_MSG_X_KEEP_LOOKING;
 #endif  #endif
 #ifdef EAGAIN  #ifdef EAGAIN
                         if (errno == 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;
                         return -1;                          return -1;

Removed from v.1.99.2.15  
changed lines
  Added in v.1.99.2.18


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