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

version 1.146, 2007/01/04 14:01:22 version 1.159, 2008/01/07 23:20:04
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.145 2007/01/02 19:00:58 kurt Exp $ */  /* $OpenLDAP: pkg/ldap/libraries/libldap/result.c,v 1.158 2007/12/20 01:46:59 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-2007 The OpenLDAP Foundation.   * Copyright 1998-2008 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 244  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%02lu\n",                          "ldap_chkResponseList returns ld %p msgid %d, type 0x%02lx\n",
                         (void *)ld, lm->lm_msgid, (unsigned long)lm->lm_msgtype );                          (void *)ld, lm->lm_msgid, (unsigned long)lm->lm_msgtype );
         }          }
 #endif  #endif
Line 263  wait4msg( Line 263  wait4msg(
         int             rc;          int             rc;
         struct timeval  tv = { 0 },          struct timeval  tv = { 0 },
                         tv0 = { 0 },                          tv0 = { 0 },
                         *tvp;                          start_time_tv = { 0 },
         time_t          start_time = 0;                          *tvp = NULL;
         time_t          tmp_time;  
         LDAPConn        *lc;          LDAPConn        *lc;
   
         assert( ld != NULL );          assert( ld != NULL );
Line 275  wait4msg( Line 274  wait4msg(
         LDAP_PVT_THREAD_ASSERT_MUTEX_OWNER( &ld->ld_res_mutex );          LDAP_PVT_THREAD_ASSERT_MUTEX_OWNER( &ld->ld_res_mutex );
 #endif  #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 ) {
                 Debug( LDAP_DEBUG_TRACE, "wait4msg ld %p msgid %d (infinite timeout)\n",                  Debug( LDAP_DEBUG_TRACE, "wait4msg ld %p msgid %d (infinite timeout)\n",
Line 285  wait4msg( Line 289  wait4msg(
         }          }
 #endif /* LDAP_DEBUG */  #endif /* LDAP_DEBUG */
   
         if ( timeout == NULL ) {          if ( timeout != NULL ) {
                 tvp = NULL;  
         } else {  
                 tv0 = *timeout;                  tv0 = *timeout;
                 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 = LDAP_MSG_X_KEEP_LOOKING;          rc = LDAP_MSG_X_KEEP_LOOKING;
Line 315  wait4msg( Line 322  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 343  wait4msg( Line 350  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 ) {
                                 rc = ldap_int_select( ld, tvp );                                  rc = ldap_int_select( ld, tvp );
 #ifdef LDAP_DEBUG  #ifdef LDAP_DEBUG
                                 if ( rc == -1 ) {                                  if ( rc == -1 ) {
Line 418  wait4msg( Line 425  wait4msg(
                 }                  }
   
                 if ( rc == LDAP_MSG_X_KEEP_LOOKING && tvp != NULL ) {                  if ( rc == LDAP_MSG_X_KEEP_LOOKING && tvp != NULL ) {
                         tmp_time = time( NULL );                          struct timeval  curr_time_tv = { 0 },
                         tv0.tv_sec -= ( tmp_time - start_time );                                          delta_time_tv = { 0 };
                         if ( tv0.tv_sec <= 0 ) {  
                                 rc = 0; /* timed out */  #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;
                         }                          }
   
                           /* 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 secs to go\n",                          Debug( LDAP_DEBUG_TRACE, "wait4msg ld %p %ld s %ld us to go\n",
                                 (void *)ld, (long) tv.tv_sec, 0 );                                  (void *)ld, (long) tv.tv_sec, (long) tv.tv_usec );
                         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 520  nextresp3: Line 558  nextresp3:
                 if ( sock_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;
   #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;                  return -1;
   
         default:          default:
Line 854  nextresp2: Line 900  nextresp2:
                         {                          {
                                 id = lr->lr_msgid;                                  id = lr->lr_msgid;
                                 tag = lr->lr_res_msgtype;                                  tag = lr->lr_res_msgtype;
                                 Debug( LDAP_DEBUG_ANY, "request done: ld %p msgid %ld\n",                                  Debug( LDAP_DEBUG_TRACE, "request done: ld %p msgid %ld\n",
                                         (void *)ld, (long) 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>, "
Line 878  nextresp2: Line 924  nextresp2:
                                 lr = NULL;                                  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  #ifdef LDAP_R_COMPILE
                                 ldap_pvt_thread_mutex_lock( &ld->ld_req_mutex );                                  ldap_pvt_thread_mutex_lock( &ld->ld_req_mutex );
 #endif  #endif
Line 903  nextresp2: Line 953  nextresp2:
         }          }
   
         /* try to handle unsolicited responses as appropriate */          /* try to handle unsolicited responses as appropriate */
         if ( id == 0 && msgid != LDAP_RES_UNSOLICITED ) {          if ( id == 0 && msgid > LDAP_RES_UNSOLICITED ) {
                 int     is_nod = 0;                  int     is_nod = 0;
   
                 tag = ber_peek_tag( ber, &len );                  tag = ber_peek_tag( &tmpber, &len );
   
                 /* we have a res oid */                  /* we have a res oid */
                 if ( tag == LDAP_TAG_EXOP_RES_OID ) {                  if ( tag == LDAP_TAG_EXOP_RES_OID ) {
                         char    *resoid = NULL;                          static struct berval    bv_nod = BER_BVC( LDAP_NOTICE_OF_DISCONNECTION );
                           struct berval           resoid = BER_BVNULL;
   
                         if ( ber_scanf( ber, "a", &resoid ) == LBER_ERROR ) {                          if ( ber_scanf( &tmpber, "m", &resoid ) == 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;
                         }                          }
   
                         assert( resoid[ 0 ] != '\0' );                          assert( !BER_BVISEMPTY( &resoid ) );
   
                         is_nod = strcmp( resoid, LDAP_NOTICE_OF_DISCONNECTION ) == 0;                          is_nod = ber_bvcmp( &resoid, &bv_nod ) == 0;
                         LDAP_FREE( resoid );  
   
                         tag = ber_peek_tag( ber, &len );                          tag = ber_peek_tag( &tmpber, &len );
                 }                  }
   
                 /* we have a res value */  #if 0 /* don't need right now */
                   /* we have res data */
                 if ( tag == LDAP_TAG_EXOP_RES_VALUE ) {                  if ( tag == LDAP_TAG_EXOP_RES_VALUE ) {
                         /* don't need right now */                          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 */                  /* handle RFC 4511 "Notice of Disconnection" locally */
   
Line 949  nextresp2: Line 1009  nextresp2:
 #ifdef LDAP_R_COMPILE  #ifdef LDAP_R_COMPILE
                                 ldap_pvt_thread_mutex_unlock( &ld->ld_req_mutex );                                  ldap_pvt_thread_mutex_unlock( &ld->ld_req_mutex );
 #endif  #endif
                                 *lcp = NULL;                                  lc = *lcp = NULL;
                         }                          }
   
                         return LDAP_RES_EXTENDED;                          /* need to return -1, because otherwise
                            * a valid result is expected */
                           return -1;
                 }                  }
         }          }
   

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


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