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

version 1.124.2.29, 2011/01/06 18:43:21 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$ */  /* $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-2011 The OpenLDAP Foundation.   * Copyright 1998-2010 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 66 Line 66
 #include "ldap_log.h"  #include "ldap_log.h"
 #include "lutil.h"  #include "lutil.h"
   
 static int ldap_abandoned LDAP_P(( LDAP *ld, ber_int_t msgid ));  static int ldap_abandoned LDAP_P(( LDAP *ld, ber_int_t msgid, int *idx ));
 static int ldap_mark_abandoned LDAP_P(( LDAP *ld, ber_int_t msgid ));  static int ldap_mark_abandoned LDAP_P(( LDAP *ld, ber_int_t msgid, int idx ));
 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,
Line 120  ldap_result( Line 120  ldap_result(
         return rc;          return rc;
 }  }
   
 /* protected by res_mutex */  
 static LDAPMessage *  static LDAPMessage *
 chkResponseList(  chkResponseList(
         LDAP *ld,          LDAP *ld,
Line 145  chkResponseList( Line 144  chkResponseList(
   
         lastlm = &ld->ld_responses;          lastlm = &ld->ld_responses;
         for ( lm = ld->ld_responses; lm != NULL; lm = nextlm ) {          for ( lm = ld->ld_responses; lm != NULL; lm = nextlm ) {
                   int     idx;
   
                 nextlm = lm->lm_next;                  nextlm = lm->lm_next;
                 ++cnt;                  ++cnt;
   
                 if ( ldap_abandoned( ld, lm->lm_msgid ) ) {                  if ( ldap_abandoned( ld, lm->lm_msgid, &idx ) ) {
                         Debug( LDAP_DEBUG_ANY,                          Debug( LDAP_DEBUG_ANY,
                                 "response list msg abandoned, "                                  "response list msg abandoned, "
                                 "msgid %d message type %s\n",                                  "msgid %d message type %s\n",
Line 163  chkResponseList( Line 164  chkResponseList(
                         default:                          default:
                                 /* there's no need to keep the id                                  /* there's no need to keep the id
                                  * in the abandoned list any longer */                                   * in the abandoned list any longer */
                                 ldap_mark_abandoned( ld, lm->lm_msgid );                                  ldap_mark_abandoned( ld, lm->lm_msgid, idx );
                                 break;                                  break;
                         }                          }
   
Line 230  chkResponseList( Line 231  chkResponseList(
         return lm;          return lm;
 }  }
   
 /* protected by res_mutex */  
 static int  static int
 wait4msg(  wait4msg(
         LDAP *ld,          LDAP *ld,
Line 284  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 );
                           LDAP_MUTEX_LOCK( &ld->ld_conn_mutex );
                         ldap_dump_connection( ld, ld->ld_conns, 1 );                          ldap_dump_connection( ld, ld->ld_conns, 1 );
                           LDAP_MUTEX_UNLOCK( &ld->ld_conn_mutex );
                         LDAP_MUTEX_LOCK( &ld->ld_req_mutex );                          LDAP_MUTEX_LOCK( &ld->ld_req_mutex );
                         ldap_dump_requests_and_responses( ld );                          ldap_dump_requests_and_responses( ld );
                         LDAP_MUTEX_UNLOCK( &ld->ld_req_mutex );                          LDAP_MUTEX_UNLOCK( &ld->ld_req_mutex );
Line 306  wait4msg( Line 308  wait4msg(
                                         break;                                          break;
                                 }                                  }
                         }                          }
                           LDAP_MUTEX_UNLOCK( &ld->ld_conn_mutex );
   
                         if ( !lc_ready ) {                          if ( !lc_ready ) {
                                 int err;                                  int err;
Line 325  wait4msg( Line 328  wait4msg(
                                 {                                  {
                                         ld->ld_errno = (rc == -1 ? LDAP_SERVER_DOWN :                                          ld->ld_errno = (rc == -1 ? LDAP_SERVER_DOWN :
                                                 LDAP_TIMEOUT);                                                  LDAP_TIMEOUT);
                                         LDAP_MUTEX_UNLOCK( &ld->ld_conn_mutex );  
                                         return( rc );                                          return( rc );
                                 }                                  }
   
Line 347  wait4msg( Line 349  wait4msg(
                                 {                                  {
                                         ldap_int_flush_request( ld, ld->ld_requests );                                          ldap_int_flush_request( ld, ld->ld_requests );
                                 }                                  }
                                   LDAP_MUTEX_UNLOCK( &ld->ld_req_mutex );
                                   LDAP_MUTEX_LOCK( &ld->ld_conn_mutex );
                                 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 356  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;
                                                   LDAP_MUTEX_UNLOCK( &ld->ld_conn_mutex );
                                                 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 ) {
                                                           LDAP_MUTEX_LOCK( &ld->ld_req_mutex );
                                                         ldap_free_connection( ld, lc, 0, 1 );                                                          ldap_free_connection( ld, lc, 0, 1 );
                                                           LDAP_MUTEX_UNLOCK( &ld->ld_req_mutex );
                                                 } else {                                                  } else {
                                                         --lc->lconn_refcnt;                                                          --lc->lconn_refcnt;
                                                 }                                                  }
                                                   LDAP_MUTEX_LOCK( &ld->ld_conn_mutex );
                                         } else {                                          } else {
                                                 lnext = lc->lconn_next;                                                  lnext = lc->lconn_next;
                                         }                                          }
                                 }                                  }
                                 LDAP_MUTEX_UNLOCK( &ld->ld_req_mutex );                                  LDAP_MUTEX_UNLOCK( &ld->ld_conn_mutex );
                         }                          }
                         LDAP_MUTEX_UNLOCK( &ld->ld_conn_mutex );  
                 }                  }
   
                 if ( rc == LDAP_MSG_X_KEEP_LOOKING && tvp != NULL ) {                  if ( rc == LDAP_MSG_X_KEEP_LOOKING && tvp != NULL ) {
Line 425  wait4msg( Line 432  wait4msg(
 }  }
   
   
 /* protected by res_mutex, conn_mutex and req_mutex */  
 static ber_tag_t  static ber_tag_t
 try_read1msg(  try_read1msg(
         LDAP *ld,          LDAP *ld,
Line 437  try_read1msg( Line 443  try_read1msg(
         BerElement      *ber;          BerElement      *ber;
         LDAPMessage     *newmsg, *l, *prev;          LDAPMessage     *newmsg, *l, *prev;
         ber_int_t       id;          ber_int_t       id;
           int             idx;
         ber_tag_t       tag;          ber_tag_t       tag;
         ber_len_t       len;          ber_len_t       len;
         int             foundit = 0;          int             foundit = 0;
Line 454  try_read1msg( Line 461  try_read1msg(
         assert( lc != NULL );          assert( lc != NULL );
                   
         LDAP_ASSERT_MUTEX_OWNER( &ld->ld_res_mutex );          LDAP_ASSERT_MUTEX_OWNER( &ld->ld_res_mutex );
         LDAP_ASSERT_MUTEX_OWNER( &ld->ld_conn_mutex );  
         LDAP_ASSERT_MUTEX_OWNER( &ld->ld_req_mutex );  
   
         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 498  nextresp3: Line 503  nextresp3:
                 Debug( LDAP_DEBUG_CONNS,                  Debug( LDAP_DEBUG_CONNS,
                         "ber_get_next failed.\n", 0, 0, 0 );                          "ber_get_next failed.\n", 0, 0, 0 );
 #endif               #endif             
   #ifdef EWOULDBLOCK                      
                 if ( err == EWOULDBLOCK ) return LDAP_MSG_X_KEEP_LOOKING;                  if ( err == EWOULDBLOCK ) return LDAP_MSG_X_KEEP_LOOKING;
   #endif
   #ifdef EAGAIN
                 if ( err == EAGAIN ) return LDAP_MSG_X_KEEP_LOOKING;                  if ( err == EAGAIN ) return LDAP_MSG_X_KEEP_LOOKING;
   #endif
                 ld->ld_errno = LDAP_SERVER_DOWN;                  ld->ld_errno = LDAP_SERVER_DOWN;
                 --lc->lconn_refcnt;                  --lc->lconn_refcnt;
                 lc->lconn_status = 0;                  lc->lconn_status = 0;
Line 526  nextresp3: Line 535  nextresp3:
                   
         /* if it's been abandoned, toss it */          /* if it's been abandoned, toss it */
         if ( id > 0 ) {          if ( id > 0 ) {
                 if ( ldap_abandoned( ld, id ) ) {                  if ( ldap_abandoned( ld, id, &idx ) ) {
                         /* the message type */                          /* the message type */
                         tag = ber_peek_tag( ber, &len );                          tag = ber_peek_tag( ber, &len );
                         switch ( tag ) {                          switch ( tag ) {
Line 539  nextresp3: Line 548  nextresp3:
                         default:                          default:
                                 /* there's no need to keep the id                                  /* there's no need to keep the id
                                  * in the abandoned list any longer */                                   * in the abandoned list any longer */
                                 ldap_mark_abandoned( ld, id );                                  ldap_mark_abandoned( ld, id, idx );
                                 break;                                  break;
                         }                          }
   
Line 821  nextresp2: Line 830  nextresp2:
                         Debug( LDAP_DEBUG_TRACE,                          Debug( LDAP_DEBUG_TRACE,
                                 "read1msg:  mark request completed, ld %p msgid %d\n",                                  "read1msg:  mark request completed, ld %p msgid %d\n",
                                 (void *)ld, lr->lr_msgid, 0);                                  (void *)ld, lr->lr_msgid, 0);
                         tmplr = lr;  
                         while ( lr->lr_parent != NULL ) {                          while ( lr->lr_parent != NULL ) {
                                 merge_error_info( ld, lr->lr_parent, lr );                                  merge_error_info( ld, lr->lr_parent, lr );
   
Line 830  nextresp2: Line 838  nextresp2:
                                         break;  /* not completely done yet */                                          break;  /* not completely done yet */
                                 }                                  }
                         }                          }
                         /* ITS#6744: Original lr was refcounted when we retrieved it,  
                          * must release it now that we're working with the parent  
                          */  
                         if ( tmplr->lr_parent ) {  
                                 ldap_return_request( ld, tmplr, 0 );  
                         }  
   
                         /* Check if all requests are finished, lr is now parent */                          /* Check if all requests are finished, lr is now parent */
                         tmplr = lr;                          tmplr = lr;
Line 880  nextresp2: Line 882  nextresp2:
                         }                          }
   
                         /*                          /*
                          * RFC 4511 unsolicited (id == 0) responses                           * RF 4511 unsolicited (id == 0) responses
                          * shouldn't necessarily end the connection                           * shouldn't necessarily end the connection
                          */                           */
                         if ( lc != NULL && id != 0 ) {                          if ( lc != NULL && id != 0 ) {
Line 1335  ldap_msgdelete( LDAP *ld, int msgid ) Line 1337  ldap_msgdelete( LDAP *ld, int msgid )
  *   *
  * return the location of the message id in the array of abandoned   * return the location of the message id in the array of abandoned
  * message ids, or -1   * message ids, or -1
    *
    * expects ld_res_mutex to be locked
  */   */
 static int  static int
 ldap_abandoned( LDAP *ld, ber_int_t msgid )  ldap_abandoned( LDAP *ld, ber_int_t msgid, int *idxp )
 {  {
         int     ret, idx;          LDAP_ASSERT_MUTEX_OWNER( &ld->ld_res_mutex );
   
           assert( idxp != NULL );
         assert( msgid >= 0 );          assert( msgid >= 0 );
   
         LDAP_MUTEX_LOCK( &ld->ld_abandon_mutex );          return ldap_int_bisect_find( ld->ld_abandoned, ld->ld_nabandoned, msgid, idxp );
         ret = ldap_int_bisect_find( ld->ld_abandoned, ld->ld_nabandoned, msgid, &idx );  
         LDAP_MUTEX_UNLOCK( &ld->ld_abandon_mutex );  
         return ret;  
 }  }
   
 /*  /*
  * ldap_mark_abandoned   * ldap_mark_abandoned
    *
    * expects ld_res_mutex to be locked
  */   */
 static int  static int
 ldap_mark_abandoned( LDAP *ld, ber_int_t msgid )  ldap_mark_abandoned( LDAP *ld, ber_int_t msgid, int idx )
 {  {
         int     ret, idx;          LDAP_ASSERT_MUTEX_OWNER( &ld->ld_res_mutex );
   
         assert( msgid >= 0 );          /* NOTE: those assertions are repeated in ldap_int_bisect_delete() */
         LDAP_MUTEX_LOCK( &ld->ld_abandon_mutex );          assert( idx >= 0 );
         ret = ldap_int_bisect_find( ld->ld_abandoned, ld->ld_nabandoned, msgid, &idx );          assert( (unsigned) idx < ld->ld_nabandoned );
         if (ret <= 0) {         /* error or already deleted by another thread */          assert( ld->ld_abandoned[ idx ] == msgid );
                 LDAP_MUTEX_UNLOCK( &ld->ld_abandon_mutex );  
                 return ret;          return ldap_int_bisect_delete( &ld->ld_abandoned, &ld->ld_nabandoned,
         }  
         /* still in abandoned array, so delete */  
         ret = ldap_int_bisect_delete( &ld->ld_abandoned, &ld->ld_nabandoned,  
                 msgid, idx );                  msgid, idx );
         LDAP_MUTEX_UNLOCK( &ld->ld_abandon_mutex );  
         return ret;  
 }  }

Removed from v.1.124.2.29  
changed lines
  Added in v.1.173


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