Diff for /libraries/libldap/result.c between versions 1.99.2.23 and 1.122

version 1.99.2.23, 2007/03/13 08:53:15 version 1.122, 2006/01/03 22:12:09
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.22 2007/03/12 20:04:28 ando Exp $ */  /* $OpenLDAP: pkg/ldap/libraries/libldap/result.c,v 1.121 2005/12/13 14:53:11 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-2007 The OpenLDAP Foundation.   * Copyright 1998-2006 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 73  static int ldap_mark_abandoned LDAP_P(( Line 73  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, Sockbuf *sb, 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 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;          LDAPConn        *lc, *nextlc;
   
         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 = lc->lconn_next ) {                          for ( lc = ld->ld_conns; lc != NULL; lc = nextlc ) {
                                   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
                                         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->lconn_sb,
                                                   &lc, result );
 #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
Line 301  wait4msg( Line 303  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",
                                                 sock_errno(), 0, 0 );                                                  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)
                                                 || sock_errno() != EINTR )))                                                  || errno != EINTR )))
                                 {                                  {
                                         ld->ld_errno = (rc == -1 ? LDAP_SERVER_DOWN :                                          ld->ld_errno = (rc == -1 ? LDAP_SERVER_DOWN :
                                                 LDAP_TIMEOUT);                                                  LDAP_TIMEOUT);
Line 332  wait4msg( Line 334  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;                                          for ( lc = ld->ld_conns; rc == LDAP_MSG_X_KEEP_LOOKING && lc != NULL;
                                                 rc == LDAP_MSG_X_KEEP_LOOKING && lc != NULL; )                                                  lc = nextlc )
                                         {                                          {
                                                   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 ))
                                                 {                                                  {
 #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
                                                         rc = try_read1msg( ld, msgid, all, &lc, result );                                                          rc = try_read1msg( ld, msgid, all,
                                                                   lc->lconn_sb, &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 369  wait4msg( Line 360  wait4msg(
                 }                  }
   
                 if ( rc == LDAP_MSG_X_KEEP_LOOKING && tvp != NULL ) {                  if ( rc == LDAP_MSG_X_KEEP_LOOKING && tvp != NULL ) {
                         time_t  delta_time;  
   
                         tmp_time = time( NULL );                          tmp_time = time( NULL );
                         delta_time = tmp_time - start_time;                          tv0.tv_sec -= ( tmp_time - start_time );
                           if ( tv0.tv_sec <= 0 ) {
                         /* do not assume time_t is signed */  
                         if ( tv0.tv_sec <= delta_time ) {  
                                 rc = 0; /* timed out */                                  rc = 0; /* timed out */
                                 ld->ld_errno = LDAP_TIMEOUT;                                  ld->ld_errno = LDAP_TIMEOUT;
                                 break;                                  break;
                         }                          }
                         tv0.tv_sec -= delta_time;  
                         tv.tv_sec = tv0.tv_sec;                          tv.tv_sec = tv0.tv_sec;
   
                         Debug( LDAP_DEBUG_TRACE, "wait4msg ld %p %ld secs to go\n",                          Debug( LDAP_DEBUG_TRACE, "wait4msg ld %p %ld secs to go\n",
Line 398  try_read1msg( Line 384  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 )
 {  {
Line 450  retry: Line 437  retry:
         assert( LBER_VALID (ber) );          assert( LBER_VALID (ber) );
   
         /* get the next message */          /* get the next message */
         sock_errset(0);          errno = 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( lc->lconn_sb, &from, sizeof(struct sockaddr) );                  ber_int_sb_read(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
         tag = ber_get_next( lc->lconn_sb, &len, ber );          tag = ber_get_next( sb, &len, ber );
         if ( tag == LDAP_TAG_MESSAGE ) {          if ( tag == LDAP_TAG_MESSAGE ) {
                 /*                  /*
                  * We read a complete message.                   * We read a complete message.
Line 474  nextresp3: Line 461  nextresp3:
                                 "ber_get_next failed.\n", 0, 0, 0 );                                  "ber_get_next failed.\n", 0, 0, 0 );
 #endif               #endif             
 #ifdef EWOULDBLOCK                        #ifdef EWOULDBLOCK                      
                         if ( sock_errno() == EWOULDBLOCK ) return LDAP_MSG_X_KEEP_LOOKING;                          if (errno==EWOULDBLOCK) return LDAP_MSG_X_KEEP_LOOKING;
 #endif  #endif
 #ifdef EAGAIN  #ifdef EAGAIN
                         if ( sock_errno() == EAGAIN ) return LDAP_MSG_X_KEEP_LOOKING;                          if (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;
Line 499  nextresp3: Line 486  nextresp3:
                         (void *)ld, (long) id, 0);                          (void *)ld, (long) id, 0);
 retry_ber:  retry_ber:
                 ber_free( ber, 1 );                  ber_free( ber, 1 );
                 if ( ber_sockbuf_ctrl( lc->lconn_sb, LBER_SB_OPT_DATA_READY, NULL ) ) {                  if ( ber_sockbuf_ctrl( sb, LBER_SB_OPT_DATA_READY, NULL ) ) {
                         goto retry;                          goto retry;
                 }                  }
                 return( LDAP_MSG_X_KEEP_LOOKING );      /* continue looking */                  return( LDAP_MSG_X_KEEP_LOOKING );      /* continue looking */
Line 571  nextresp2: Line 558  nextresp2:
                                                                 lr->lr_msgid, 0, 0);                                                                  lr->lr_msgid, 0, 0);
                                                 }                                                  }
   
                                                 /* We successfully chased the reference */                                                  /* We sucessfully chased the reference */
                                                 v3ref = V3REF_SUCCESS;                                                  v3ref = V3REF_SUCCESS;
                                         }                                          }
                                 }                                  }
Line 617  nextresp2: Line 604  nextresp2:
                                         if( LDAP_BOOL_GET(&ld->ld_options, LDAP_BOOL_REFERRALS)                                          if( LDAP_BOOL_GET(&ld->ld_options, LDAP_BOOL_REFERRALS)
                                                          || (lr->lr_parent != NULL) )                                                           || (lr->lr_parent != NULL) )
                                         {                                          {
                                                   /* Assume referral not chased and return it to app */
                                                   v3ref = V3REF_TOAPP;
   
                                                 /* 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;
Line 632  nextresp2: Line 622  nextresp2:
                                                             0, &lr->lr_res_error, &hadref );                                                              0, &lr->lr_res_error, &hadref );
                                                         lr->lr_status = LDAP_REQST_COMPLETED;                                                          lr->lr_status = LDAP_REQST_COMPLETED;
                                                         Debug( LDAP_DEBUG_TRACE,                                                          Debug( LDAP_DEBUG_TRACE,
                                                                 "read1msg: referral %s chased, "                                                                  "read1msg: referral chased, mark request completed, ld %p msgid %d\n",
                                                                 "mark request completed, ld %p msgid %d\n",                                                                  (void *)ld, lr->lr_msgid, 0);
                                                                 hadref ? "" : "not",  
                                                                 (void *)ld, lr->lr_msgid);  
                                                         if( refer_cnt > 0) {                                                          if( refer_cnt > 0) {
                                                                 /* Referral successfully chased */                                                                  /* Referral successfully chased */
                                                                 v3ref = V3REF_SUCCESS;                                                                  v3ref = V3REF_SUCCESS;
                                                         } else {  
                                                                 refer_cnt = 0;  
                                                         }                                                          }
                                                 }                                                  }
                                         }                                          }
Line 662  nextresp2: Line 648  nextresp2:
          * go through the following code.  This code also chases V2 referrals           * go through the following code.  This code also chases V2 referrals
          * and checks if all referrals have been chased.           * and checks if all referrals have been chased.
          */           */
         if ( tag != LDAP_RES_SEARCH_ENTRY &&          if ( (tag != LDAP_RES_SEARCH_ENTRY) && (v3ref != V3REF_TOAPP) &&
                 tag != LDAP_RES_SEARCH_REFERENCE &&                  (tag != LDAP_RES_INTERMEDIATE ))
                 tag != LDAP_RES_INTERMEDIATE )  
         {          {
                 /* For a v3 search referral/reference, only come here if already chased it */                  /* For a v3 search referral/reference, only come here if already chased it */
                 if ( ld->ld_version >= LDAP_VERSION2 &&                  if ( ld->ld_version >= LDAP_VERSION2 &&
                         v3ref != V3REF_TOAPP &&  
                         ( lr->lr_parent != NULL ||                          ( lr->lr_parent != NULL ||
                         LDAP_BOOL_GET(&ld->ld_options, LDAP_BOOL_REFERRALS) ) )                          LDAP_BOOL_GET(&ld->ld_options, LDAP_BOOL_REFERRALS) ) )
                 {                  {
Line 843  lr->lr_res_matched ? lr->lr_res_matched Line 827  lr->lr_res_matched ? lr->lr_res_matched
 #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
                                 lc = *lcp = NULL;                                  *lcp = NULL;
                         }                          }
                 }                  }
         }          }
Line 904  lr->lr_res_matched ? lr->lr_res_matched Line 888  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( lc->lconn_sb, LBER_SB_OPT_DATA_READY, NULL ) ) ok = 1;                                  if (ber_sockbuf_ctrl(sb, LBER_SB_OPT_DATA_READY, NULL)) ok=1;
                         }                          }
                         /* set up response chain */                          /* set up response chain */
                         if ( tmp == NULL ) {                          if ( tmp == NULL ) {
Line 1004  exit: Line 988  exit:
                 ld->ld_errno = LDAP_SUCCESS;                  ld->ld_errno = LDAP_SUCCESS;
                 return( tag );                  return( tag );
         }          }
         if ( lc && ber_sockbuf_ctrl( lc->lconn_sb, LBER_SB_OPT_DATA_READY, NULL ) ) {          if ( ber_sockbuf_ctrl( sb, LBER_SB_OPT_DATA_READY, NULL ) ) {
                 goto retry;                  goto retry;
         }          }
         return( LDAP_MSG_X_KEEP_LOOKING );      /* continue looking */          return( LDAP_MSG_X_KEEP_LOOKING );      /* continue looking */

Removed from v.1.99.2.23  
changed lines
  Added in v.1.122


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