[BACK]Return to result.c CVS log [TXT] [DIR] Up to [OpenLDAP] / libraries / libldap

Diff for /libraries/libldap/result.c between versions 1.172 and 1.173

version 1.172, 2010/06/02 01:30:19 version 1.173, 2010/10/13 06:43:16
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.171 2010/04/13 20:17:56 kurt Exp $ */  /* $OpenLDAP: pkg/ldap/libraries/libldap/result.c,v 1.172 2010/06/02 01:30:19 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-2010 The OpenLDAP Foundation.
Line 113  ldap_result( Line 113  ldap_result(
   
         Debug( LDAP_DEBUG_TRACE, "ldap_result ld %p msgid %d\n", (void *)ld, msgid, 0 );          Debug( LDAP_DEBUG_TRACE, "ldap_result ld %p msgid %d\n", (void *)ld, msgid, 0 );
   
 #ifdef LDAP_R_COMPILE          LDAP_MUTEX_LOCK( &ld->ld_res_mutex );
         ldap_pvt_thread_mutex_lock( &ld->ld_res_mutex );  
 #endif  
   
         rc = wait4msg( ld, msgid, all, timeout, result );          rc = wait4msg( ld, msgid, all, timeout, result );
           LDAP_MUTEX_UNLOCK( &ld->ld_res_mutex );
 #ifdef LDAP_R_COMPILE  
         ldap_pvt_thread_mutex_unlock( &ld->ld_res_mutex );  
 #endif  
   
         return rc;          return rc;
 }  }
Line 142  chkResponseList( Line 136  chkResponseList(
          * wait until it arrives or timeout occurs.           * wait until it arrives or timeout occurs.
          */           */
   
 #ifdef LDAP_R_COMPILE          LDAP_ASSERT_MUTEX_OWNER( &ld->ld_res_mutex );
         LDAP_PVT_THREAD_ASSERT_MUTEX_OWNER( &ld->ld_res_mutex );  
 #endif  
   
         Debug( LDAP_DEBUG_TRACE,          Debug( LDAP_DEBUG_TRACE,
                 "ldap_chkResponseList ld %p msgid %d all %d\n",                  "ldap_chkResponseList ld %p msgid %d all %d\n",
Line 257  wait4msg( Line 249  wait4msg(
         assert( ld != NULL );          assert( ld != NULL );
         assert( result != NULL );          assert( result != NULL );
   
 #ifdef LDAP_R_COMPILE          LDAP_ASSERT_MUTEX_OWNER( &ld->ld_res_mutex );
         LDAP_PVT_THREAD_ASSERT_MUTEX_OWNER( &ld->ld_res_mutex );  
 #endif  
   
         if ( timeout == NULL && ld->ld_options.ldo_tm_api.tv_sec >= 0 ) {          if ( timeout == NULL && ld->ld_options.ldo_tm_api.tv_sec >= 0 ) {
                 tv = ld->ld_options.ldo_tm_api;                  tv = ld->ld_options.ldo_tm_api;
Line 294  wait4msg( Line 284  wait4msg(
                 if ( ldap_debug & LDAP_DEBUG_TRACE ) {                  if ( ldap_debug & LDAP_DEBUG_TRACE ) {
                         Debug( LDAP_DEBUG_TRACE, "wait4msg continue ld %p msgid %d all %d\n",                          Debug( LDAP_DEBUG_TRACE, "wait4msg continue ld %p msgid %d all %d\n",
                                 (void *)ld, msgid, all );                                  (void *)ld, msgid, all );
 #ifdef LDAP_R_COMPILE                          LDAP_MUTEX_LOCK( &ld->ld_conn_mutex );
                         ldap_pvt_thread_mutex_lock( &ld->ld_conn_mutex );  
 #endif  
                         ldap_dump_connection( ld, ld->ld_conns, 1 );                          ldap_dump_connection( ld, ld->ld_conns, 1 );
 #ifdef LDAP_R_COMPILE                          LDAP_MUTEX_UNLOCK( &ld->ld_conn_mutex );
                         ldap_pvt_thread_mutex_unlock( &ld->ld_conn_mutex );                          LDAP_MUTEX_LOCK( &ld->ld_req_mutex );
                         ldap_pvt_thread_mutex_lock( &ld->ld_req_mutex );  
 #endif  
                         ldap_dump_requests_and_responses( ld );                          ldap_dump_requests_and_responses( ld );
 #ifdef LDAP_R_COMPILE                          LDAP_MUTEX_UNLOCK( &ld->ld_req_mutex );
                         ldap_pvt_thread_mutex_unlock( &ld->ld_req_mutex );  
 #endif  
                 }                  }
 #endif /* LDAP_DEBUG */  #endif /* LDAP_DEBUG */
   
Line 315  wait4msg( Line 299  wait4msg(
                 } else {                  } else {
                         int lc_ready = 0;                          int lc_ready = 0;
   
 #ifdef LDAP_R_COMPILE                          LDAP_MUTEX_LOCK( &ld->ld_conn_mutex );
                         ldap_pvt_thread_mutex_lock( &ld->ld_conn_mutex );  
 #endif  
                         for ( lc = ld->ld_conns; lc != NULL; lc = lc->lconn_next ) {                          for ( lc = ld->ld_conns; lc != NULL; lc = 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 ) )
Line 326  wait4msg( Line 308  wait4msg(
                                         break;                                          break;
                                 }                                  }
                         }                          }
 #ifdef LDAP_R_COMPILE                          LDAP_MUTEX_UNLOCK( &ld->ld_conn_mutex );
                         ldap_pvt_thread_mutex_unlock( &ld->ld_conn_mutex );  
 #endif  
   
                         if ( !lc_ready ) {                          if ( !lc_ready ) {
                                 int err;                                  int err;
Line 361  wait4msg( Line 341  wait4msg(
                         if ( lc_ready ) {                          if ( lc_ready ) {
                                 LDAPConn *lnext;                                  LDAPConn *lnext;
                                 rc = LDAP_MSG_X_KEEP_LOOKING;                                  rc = LDAP_MSG_X_KEEP_LOOKING;
 #ifdef LDAP_R_COMPILE                                  LDAP_MUTEX_LOCK( &ld->ld_req_mutex );
                                 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,
Line 371  wait4msg( Line 349  wait4msg(
                                 {                                  {
                                         ldap_int_flush_request( ld, ld->ld_requests );                                          ldap_int_flush_request( ld, ld->ld_requests );
                                 }                                  }
 #ifdef LDAP_R_COMPILE                                  LDAP_MUTEX_UNLOCK( &ld->ld_req_mutex );
                                 ldap_pvt_thread_mutex_unlock( &ld->ld_req_mutex );                                  LDAP_MUTEX_LOCK( &ld->ld_conn_mutex );
                                 ldap_pvt_thread_mutex_lock( &ld->ld_conn_mutex );  
 #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 = lnext )                                          lc = lnext )
Line 384  wait4msg( Line 360  wait4msg(
                                         {                                          {
                                                 /* Don't let it get freed out from under us */                                                  /* Don't let it get freed out from under us */
                                                 ++lc->lconn_refcnt;                                                  ++lc->lconn_refcnt;
 #ifdef LDAP_R_COMPILE                                                  LDAP_MUTEX_UNLOCK( &ld->ld_conn_mutex );
                                                 ldap_pvt_thread_mutex_unlock( &ld->ld_conn_mutex );  
 #endif  
                                                 rc = try_read1msg( ld, msgid, all, lc, result );                                                  rc = try_read1msg( ld, msgid, all, lc, result );
                                                 lnext = lc->lconn_next;                                                  lnext = lc->lconn_next;
   
                                                 /* Only take locks if we're really freeing */                                                  /* Only take locks if we're really freeing */
                                                 if ( lc->lconn_refcnt <= 1 ) {                                                  if ( lc->lconn_refcnt <= 1 ) {
 #ifdef LDAP_R_COMPILE                                                          LDAP_MUTEX_LOCK( &ld->ld_req_mutex );
                                                         ldap_pvt_thread_mutex_lock( &ld->ld_req_mutex );  
 #endif  
                                                         ldap_free_connection( ld, lc, 0, 1 );                                                          ldap_free_connection( ld, lc, 0, 1 );
 #ifdef LDAP_R_COMPILE                                                          LDAP_MUTEX_UNLOCK( &ld->ld_req_mutex );
                                                         ldap_pvt_thread_mutex_unlock( &ld->ld_req_mutex );  
 #endif  
                                                 } else {                                                  } else {
                                                         --lc->lconn_refcnt;                                                          --lc->lconn_refcnt;
                                                 }                                                  }
 #ifdef LDAP_R_COMPILE                                                  LDAP_MUTEX_LOCK( &ld->ld_conn_mutex );
                                                 ldap_pvt_thread_mutex_lock( &ld->ld_conn_mutex );  
 #endif  
                                         } else {                                          } else {
                                                 lnext = lc->lconn_next;                                                  lnext = lc->lconn_next;
                                         }                                          }
                                 }                                  }
 #ifdef LDAP_R_COMPILE                                  LDAP_MUTEX_UNLOCK( &ld->ld_conn_mutex );
                                 ldap_pvt_thread_mutex_unlock( &ld->ld_conn_mutex );  
 #endif  
                         }                          }
                 }                  }
   
Line 494  try_read1msg( Line 460  try_read1msg(
         assert( ld != NULL );          assert( ld != NULL );
         assert( lc != NULL );          assert( lc != NULL );
                   
 #ifdef LDAP_R_COMPILE          LDAP_ASSERT_MUTEX_OWNER( &ld->ld_res_mutex );
         LDAP_PVT_THREAD_ASSERT_MUTEX_OWNER( &ld->ld_res_mutex );  
 #endif  
   
         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 );
Line 1331  ldap_msgdelete( LDAP *ld, int msgid ) Line 1295  ldap_msgdelete( LDAP *ld, int msgid )
         Debug( LDAP_DEBUG_TRACE, "ldap_msgdelete ld=%p msgid=%d\n",          Debug( LDAP_DEBUG_TRACE, "ldap_msgdelete ld=%p msgid=%d\n",
                 (void *)ld, msgid, 0 );                  (void *)ld, msgid, 0 );
   
 #ifdef LDAP_R_COMPILE          LDAP_MUTEX_LOCK( &ld->ld_res_mutex );
         ldap_pvt_thread_mutex_lock( &ld->ld_res_mutex );  
 #endif  
         prev = NULL;          prev = NULL;
         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 ) {
Line 1352  ldap_msgdelete( LDAP *ld, int msgid ) Line 1314  ldap_msgdelete( LDAP *ld, int msgid )
                         prev->lm_next = lm->lm_next;                          prev->lm_next = lm->lm_next;
                 }                  }
         }          }
 #ifdef LDAP_R_COMPILE          LDAP_MUTEX_UNLOCK( &ld->ld_res_mutex );
         ldap_pvt_thread_mutex_unlock( &ld->ld_res_mutex );  
 #endif  
         if ( lm ) {          if ( lm ) {
                 switch ( ldap_msgfree( lm ) ) {                  switch ( ldap_msgfree( lm ) ) {
                 case LDAP_RES_SEARCH_ENTRY:                  case LDAP_RES_SEARCH_ENTRY:
Line 1383  ldap_msgdelete( LDAP *ld, int msgid ) Line 1343  ldap_msgdelete( LDAP *ld, int msgid )
 static int  static int
 ldap_abandoned( LDAP *ld, ber_int_t msgid, int *idxp )  ldap_abandoned( LDAP *ld, ber_int_t msgid, int *idxp )
 {  {
 #ifdef LDAP_R_COMPILE          LDAP_ASSERT_MUTEX_OWNER( &ld->ld_res_mutex );
         LDAP_PVT_THREAD_ASSERT_MUTEX_OWNER( &ld->ld_res_mutex );  
 #endif  
   
         assert( idxp != NULL );          assert( idxp != NULL );
         assert( msgid >= 0 );          assert( msgid >= 0 );
Line 1401  ldap_abandoned( LDAP *ld, ber_int_t msgi Line 1359  ldap_abandoned( LDAP *ld, ber_int_t msgi
 static int  static int
 ldap_mark_abandoned( LDAP *ld, ber_int_t msgid, int idx )  ldap_mark_abandoned( LDAP *ld, ber_int_t msgid, int idx )
 {  {
 #ifdef LDAP_R_COMPILE          LDAP_ASSERT_MUTEX_OWNER( &ld->ld_res_mutex );
         LDAP_PVT_THREAD_ASSERT_MUTEX_OWNER( &ld->ld_res_mutex );  
 #endif  
   
         /* 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 );
Removed from v.1.172  
changed lines
  Added in v.1.173

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