Diff for /libraries/libldap/result.c between versions 1.78 and 1.79

version 1.78, 2003/02/09 06:42:25 version 1.79, 2003/02/13 09:43:16
Line 1 Line 1
 /* $OpenLDAP: pkg/ldap/libraries/libldap/result.c,v 1.77 2003/02/08 20:53:07 kurt Exp $ */  /* $OpenLDAP: pkg/ldap/libraries/libldap/result.c,v 1.78 2003/02/09 06:42:25 kurt Exp $ */
 /*  /*
  * Copyright 1998-2003 The OpenLDAP Foundation, All Rights Reserved.   * Copyright 1998-2003 The OpenLDAP Foundation, All Rights Reserved.
  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file   * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
Line 141  chkResponseList( Line 141  chkResponseList(
             msgid, all, 0 );              msgid, all, 0 );
 #endif  #endif
         lastlm = NULL;          lastlm = NULL;
   #ifdef LDAP_R_COMPILE
           ldap_pvt_thread_mutex_lock( &ld->ld_res_mutex );
   #endif
         for ( lm = ld->ld_responses; lm != NULL; lm = nextlm ) {          for ( lm = ld->ld_responses; lm != NULL; lm = nextlm ) {
                 nextlm = lm->lm_next;                  nextlm = lm->lm_next;
   
Line 207  chkResponseList( Line 210  chkResponseList(
             }              }
             lm->lm_next = NULL;              lm->lm_next = NULL;
     }      }
   #ifdef LDAP_R_COMPILE
           ldap_pvt_thread_mutex_unlock( &ld->ld_res_mutex );
   #endif
   
 #ifdef LDAP_DEBUG  #ifdef LDAP_DEBUG
         if( lm == NULL) {          if( lm == NULL) {
Line 308  wait4msg( Line 314  wait4msg(
                 }                  }
   
                     if ( lc == NULL ) {                      if ( lc == NULL ) {
   #ifdef LDAP_R_COMPILE
                               ldap_pvt_thread_mutex_lock( &ld->ld_res_mutex );
   #endif
                             rc = ldap_int_select( ld, tvp );                              rc = ldap_int_select( ld, tvp );
   #ifdef LDAP_R_COMPILE
                               ldap_pvt_thread_mutex_unlock( &ld->ld_res_mutex );
   #endif
   
   
 #ifdef LDAP_DEBUG  #ifdef LDAP_DEBUG
Line 338  wait4msg( Line 350  wait4msg(
                                     rc = -2;    /* select interrupted: loop */                                      rc = -2;    /* select interrupted: loop */
                             } else {                              } else {
                                     rc = -2;                                      rc = -2;
   #ifdef LDAP_R_COMPILE
                                       ldap_pvt_thread_mutex_lock( &ld->ld_req_mutex );
   #endif
                                     if ( ld->ld_requests &&                                      if ( ld->ld_requests &&
                                                 ld->ld_requests->lr_status == LDAP_REQST_WRITING &&                                                  ld->ld_requests->lr_status == LDAP_REQST_WRITING &&
                                                 ldap_is_write_ready( ld,                                                  ldap_is_write_ready( ld,
                                                         ld->ld_requests->lr_conn->lconn_sb ) ) {                                                          ld->ld_requests->lr_conn->lconn_sb ) ) {
                                                 ldap_int_flush_request( ld, ld->ld_requests );                                                  ldap_int_flush_request( ld, ld->ld_requests );
                                         }                                          }
   #ifdef LDAP_R_COMPILE
                                       ldap_pvt_thread_mutex_unlock( &ld->ld_req_mutex );
   #endif
                                     for ( lc = ld->ld_conns; rc == -2 && lc != NULL;                                      for ( lc = ld->ld_conns; rc == -2 && lc != NULL;
                                         lc = nextlc ) {                                          lc = nextlc ) {
                                             nextlc = lc->lconn_next;                                              nextlc = lc->lconn_next;
Line 417  try_read1msg( Line 435  try_read1msg(
 #endif  #endif
   
 retry:  retry:
     if ( lc->lconn_ber == NULL ) {  #ifdef LDAP_R_COMPILE
           ldap_pvt_thread_mutex_lock( &ld->ld_res_mutex );
   #endif
           if ( lc->lconn_ber == NULL ) {
                 lc->lconn_ber = ldap_alloc_ber_with_options(ld);                  lc->lconn_ber = ldap_alloc_ber_with_options(ld);
   
                 if( lc->lconn_ber == NULL ) {                  if( lc->lconn_ber == NULL ) {
   #ifdef LDAP_R_COMPILE
                           ldap_pvt_thread_mutex_unlock( &ld->ld_res_mutex );
   #endif
                         return -1;                          return -1;
                 }                  }
     }          }
   
         ber = lc->lconn_ber;          ber = lc->lconn_ber;
         assert( LBER_VALID (ber) );          assert( LBER_VALID (ber) );
   
 retry2:  
         /* get the next message */          /* get the next message */
         errno = 0;          errno = 0;
 #ifdef LDAP_CONNECTIONLESS  #ifdef LDAP_CONNECTIONLESS
Line 437  retry2: Line 460  retry2:
                 ber_int_sb_read(sb, &from, sizeof(struct sockaddr));                  ber_int_sb_read(sb, &from, sizeof(struct sockaddr));
         }          }
 #endif  #endif
         if ( (tag = ber_get_next( sb, &len, ber ))          tag = ber_get_next( sb, &len, ber );
             != LDAP_TAG_MESSAGE ) {          if ( tag == LDAP_TAG_MESSAGE ) {
                   /*
                    * We read a complete message.
                    * The connection should no longer need this ber.
                    */
                   lc->lconn_ber = NULL;
           }
   #ifdef LDAP_R_COMPILE
           ldap_pvt_thread_mutex_unlock( &ld->ld_res_mutex );
   #endif
           if ( tag != LDAP_TAG_MESSAGE ) {
                 if ( tag == LBER_DEFAULT) {                  if ( tag == LBER_DEFAULT) {
 #ifdef LDAP_DEBUG                    #ifdef LDAP_DEBUG                  
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
Line 462  retry2: Line 495  retry2:
                 return -1;                  return -1;
         }          }
   
         /*  
      * We read a complete message.  
          * The connection should no longer need this ber.  
          */  
     lc->lconn_ber = NULL;  
   
         /* message id */          /* message id */
         if ( ber_get_int( ber, &id ) == LBER_ERROR ) {          if ( ber_get_int( ber, &id ) == LBER_ERROR ) {
                 ber_free( ber, 1 );                  ber_free( ber, 1 );
Line 483  retry2: Line 510  retry2:
                 Debug( LDAP_DEBUG_ANY, "abandoned\n", 0, 0, 0);                  Debug( LDAP_DEBUG_ANY, "abandoned\n", 0, 0, 0);
 #endif  #endif
 retry_ber:  retry_ber:
                   ber_free( ber, 1 );
                 if ( ber_sockbuf_ctrl( sb, LBER_SB_OPT_DATA_READY, NULL ) ) {                  if ( ber_sockbuf_ctrl( sb, LBER_SB_OPT_DATA_READY, NULL ) ) {
                         ber_free_buf( ber );                          goto retry;
                         ber_init2( ber, NULL, ld->ld_lberoptions );  
                         goto retry2;  
                 }                  }
                 ber_free( ber, 1 );  
                 return( -2 );   /* continue looking */                  return( -2 );   /* continue looking */
         }          }
   
Line 832  lr->lr_res_matched ? lr->lr_res_matched Line 857  lr->lr_res_matched ? lr->lr_res_matched
          * search response.           * search response.
          */           */
   
   #ifdef LDAP_R_COMPILE
           ldap_pvt_thread_mutex_lock( &ld->ld_res_mutex );
   #endif
         prev = NULL;          prev = NULL;
         for ( l = ld->ld_responses; l != NULL; l = l->lm_next ) {          for ( l = ld->ld_responses; l != NULL; l = l->lm_next ) {
                 if ( l->lm_msgid == new->lm_msgid )                  if ( l->lm_msgid == new->lm_msgid )
Line 843  lr->lr_res_matched ? lr->lr_res_matched Line 871  lr->lr_res_matched ? lr->lr_res_matched
         if ( l == NULL ) {          if ( l == NULL ) {
                 if ( foundit ) {                  if ( foundit ) {
                         *result = new;                          *result = new;
                         ld->ld_errno = LDAP_SUCCESS;                          goto leave;
                         return( tag );  
                 }                  }
   
                 new->lm_next = ld->ld_responses;                  new->lm_next = ld->ld_responses;
Line 877  lr->lr_res_matched ? lr->lr_res_matched Line 904  lr->lr_res_matched ? lr->lr_res_matched
                 else                  else
                         prev->lm_next = l->lm_next;                          prev->lm_next = l->lm_next;
                 *result = l;                  *result = l;
                 ld->ld_errno = LDAP_SUCCESS;  
                 return( tag );  
         }          }
   
 leave:  leave:
   #ifdef LDAP_R_COMPILE
           ldap_pvt_thread_mutex_unlock( &ld->ld_res_mutex );
   #endif
           if ( foundit ) {
                   ld->ld_errno = LDAP_SUCCESS;
                   return( tag );
           }
         if ( ber_sockbuf_ctrl( sb, LBER_SB_OPT_DATA_READY, NULL ) ) {          if ( ber_sockbuf_ctrl( sb, LBER_SB_OPT_DATA_READY, NULL ) ) {
                 goto retry;                  goto retry;
         }          }
Line 1056  int Line 1088  int
 ldap_msgdelete( LDAP *ld, int msgid )  ldap_msgdelete( LDAP *ld, int msgid )
 {  {
         LDAPMessage     *lm, *prev;          LDAPMessage     *lm, *prev;
           int rc = 0;
   
         assert( ld != NULL );          assert( ld != NULL );
   
Line 1066  ldap_msgdelete( LDAP *ld, int msgid ) Line 1099  ldap_msgdelete( LDAP *ld, int msgid )
 #endif  #endif
   
         prev = NULL;          prev = NULL;
   #ifdef LDAP_R_COMPILE
           ldap_pvt_thread_mutex_lock( &ld->ld_res_mutex );
   #endif
         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 )
                         break;                          break;
                 prev = lm;                  prev = lm;
         }          }
   
         if ( lm == NULL )          if ( lm == NULL ) {
                 return( -1 );                  rc = -1;
           } else {
         if ( prev == NULL )                  if ( prev == NULL )
                 ld->ld_responses = lm->lm_next;                          ld->ld_responses = lm->lm_next;
         else                  else
                 prev->lm_next = lm->lm_next;                          prev->lm_next = lm->lm_next;
           }
         if ( ldap_msgfree( lm ) == LDAP_RES_SEARCH_ENTRY )  #ifdef LDAP_R_COMPILE
                 return( -1 );          ldap_pvt_thread_mutex_unlock( &ld->ld_res_mutex );
   #endif
           if ( lm && ldap_msgfree( lm ) == LDAP_RES_SEARCH_ENTRY )
                   rc = -1;
   
         return( 0 );          return( rc );
 }  }
   
   

Removed from v.1.78  
changed lines
  Added in v.1.79


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