Diff for /servers/slapd/back-meta/dncache.c between versions 1.10 and 1.10.2.6

version 1.10, 2004/01/01 18:15:35 version 1.10.2.6, 2006/01/03 22:16:20
Line 1 Line 1
 /* $OpenLDAP: pkg/ldap/servers/slapd/back-meta/dncache.c,v 1.9 2003/12/08 16:41:41 kurt Exp $ */  /* $OpenLDAP: pkg/ldap/servers/slapd/back-meta/dncache.c,v 1.10.2.5 2005/12/20 19:08:13 kurt Exp $ */
 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.  /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
  *   *
  * Copyright 1999-2004 The OpenLDAP Foundation.   * Copyright 1999-2006 The OpenLDAP Foundation.
  * Portions Copyright 2001-2003 Pierangelo Masarati.   * Portions Copyright 2001-2003 Pierangelo Masarati.
  * Portions Copyright 1999-2003 Howard Chu.   * Portions Copyright 1999-2003 Howard Chu.
  * All rights reserved.   * All rights reserved.
Line 23 Line 23
 #include "portable.h"  #include "portable.h"
   
 #include <stdio.h>  #include <stdio.h>
   #include <ac/string.h>
   
 #include "slap.h"  #include "slap.h"
 #include "../back-ldap/back-ldap.h"  #include "../back-ldap/back-ldap.h"
Line 32 Line 33
  * The dncache, at present, maps an entry to the target that holds it.   * The dncache, at present, maps an entry to the target that holds it.
  */   */
   
 struct metadncacheentry {  typedef struct metadncacheentry_t {
         struct berval   dn;          struct berval   dn;
         int             target;          int             target;
   
         time_t          lastupdated;          time_t          lastupdated;
 };  } metadncacheentry_t;
   
 /*  /*
  * meta_dncache_cmp   * meta_dncache_cmp
Line 48  struct metadncacheentry { Line 49  struct metadncacheentry {
  */   */
 int  int
 meta_dncache_cmp(  meta_dncache_cmp(
                 const void *c1,          const void      *c1,
                 const void *c2          const void      *c2 )
 )  
 {  {
         struct metadncacheentry *cc1 = ( struct metadncacheentry * )c1;          metadncacheentry_t      *cc1 = ( metadncacheentry_t * )c1;
         struct metadncacheentry *cc2 = ( struct metadncacheentry * )c2;          metadncacheentry_t      *cc2 = ( metadncacheentry_t * )c2;
   
         /*          /*
          * case sensitive, because the dn MUST be normalized           * case sensitive, because the dn MUST be normalized
Line 69  meta_dncache_cmp( Line 69  meta_dncache_cmp(
  */   */
 int  int
 meta_dncache_dup(  meta_dncache_dup(
                 void *c1,          void            *c1,
                 void *c2          void            *c2 )
 )  
 {  {
         struct metadncacheentry *cc1 = ( struct metadncacheentry * )c1;          metadncacheentry_t      *cc1 = ( metadncacheentry_t * )c1;
         struct metadncacheentry *cc2 = ( struct metadncacheentry * )c2;          metadncacheentry_t      *cc2 = ( metadncacheentry_t * )c2;
                   
         /*          /*
          * case sensitive, because the dn MUST be normalized           * case sensitive, because the dn MUST be normalized
Line 90  meta_dncache_dup( Line 89  meta_dncache_dup(
  */   */
 int  int
 meta_dncache_get_target(  meta_dncache_get_target(
                 struct metadncache      *cache,          metadncache_t   *cache,
                 struct berval           *ndn          struct berval   *ndn )
 )  {
 {          metadncacheentry_t      tmp_entry,
         struct metadncacheentry tmp_entry, *entry;                                  *entry;
         time_t curr_time;          int                     target = META_TARGET_NONE;
         int target = -1;  
   
         assert( cache );          assert( cache != NULL );
         assert( ndn );          assert( ndn != NULL );
   
         tmp_entry.dn = *ndn;          tmp_entry.dn = *ndn;
         ldap_pvt_thread_mutex_lock( &cache->mutex );          ldap_pvt_thread_mutex_lock( &cache->mutex );
         entry = ( struct metadncacheentry * )avl_find( cache->tree,          entry = ( metadncacheentry_t * )avl_find( cache->tree,
                         ( caddr_t )&tmp_entry, meta_dncache_cmp );                          ( caddr_t )&tmp_entry, meta_dncache_cmp );
   
         if ( entry != NULL ) {          if ( entry != NULL ) {
Line 115  meta_dncache_get_target( Line 113  meta_dncache_get_target(
                  */                   */
                 if ( cache->ttl < 0 ) {                   if ( cache->ttl < 0 ) { 
                         target = entry->target;                          target = entry->target;
                 } else {  
   
                         /*  
                          * Need mutex?  
                          */       
                         curr_time = time( NULL );  
   
                         if ( entry->lastupdated+cache->ttl > curr_time ) {                  } else {
                           if ( entry->lastupdated+cache->ttl > slap_get_time() ) {
                                 target = entry->target;                                  target = entry->target;
                         }                          }
                 }                  }
Line 140  meta_dncache_get_target( Line 133  meta_dncache_get_target(
  */   */
 int  int
 meta_dncache_update_entry(  meta_dncache_update_entry(
                 struct metadncache      *cache,          metadncache_t   *cache,
                 struct berval           *ndn,          struct berval   *ndn,
                 int                     target          int             target )
 )  {
 {          metadncacheentry_t      *entry,
         struct metadncacheentry *entry, tmp_entry;                                  tmp_entry;
         time_t curr_time = 0L;          time_t                  curr_time = 0L;
         int err = 0;          int                     err = 0;
   
         assert( cache );          assert( cache != NULL );
         assert( ndn );          assert( ndn != NULL );
   
         /*          /*
          * if cache->ttl < 0, cache never expires;           * if cache->ttl < 0, cache never expires;
Line 158  meta_dncache_update_entry( Line 151  meta_dncache_update_entry(
          * else, cache is used with ttl           * else, cache is used with ttl
          */           */
         if ( cache->ttl > 0 ) {          if ( cache->ttl > 0 ) {
                   curr_time = slap_get_time();
                 /*  
                  * Need mutex?  
                  */  
                 curr_time = time( NULL );  
         }          }
   
         tmp_entry.dn = *ndn;          tmp_entry.dn = *ndn;
   
         ldap_pvt_thread_mutex_lock( &cache->mutex );          ldap_pvt_thread_mutex_lock( &cache->mutex );
         entry = ( struct metadncacheentry * )avl_find( cache->tree,          entry = ( metadncacheentry_t * )avl_find( cache->tree,
                         ( caddr_t )&tmp_entry, meta_dncache_cmp );                          ( caddr_t )&tmp_entry, meta_dncache_cmp );
   
         if ( entry != NULL ) {          if ( entry != NULL ) {
                 entry->target = target;                  entry->target = target;
                 entry->lastupdated = curr_time;                  entry->lastupdated = curr_time;
   
         } else {          } else {
                 entry = ch_calloc( sizeof( struct metadncacheentry ), 1 );                  entry = ch_malloc( sizeof( metadncacheentry_t ) + ndn->bv_len + 1 );
                 if ( entry == NULL ) {                  if ( entry == NULL ) {
                         ldap_pvt_thread_mutex_unlock( &cache->mutex );                          err = -1;
                         return -1;                          goto error_return;
                 }                  }
   
                 ber_dupbv( &entry->dn, ndn );                  entry->dn.bv_len = ndn->bv_len;
                 if ( entry->dn.bv_val == NULL ) {                  entry->dn.bv_val = (char *)&entry[ 1 ];
                         ldap_pvt_thread_mutex_unlock( &cache->mutex );                  AC_MEMCPY( entry->dn.bv_val, ndn->bv_val, ndn->bv_len );
                         return -1;                  entry->dn.bv_val[ ndn->bv_len ] = '\0';
                 }  
                 entry->target = target;                  entry->target = target;
                 entry->lastupdated = curr_time;                  entry->lastupdated = curr_time;
   
                 err = avl_insert( &cache->tree, ( caddr_t )entry,                  err = avl_insert( &cache->tree, ( caddr_t )entry,
                                 meta_dncache_cmp, meta_dncache_dup );                                  meta_dncache_cmp, meta_dncache_dup );
         }          }
   
   error_return:;
         ldap_pvt_thread_mutex_unlock( &cache->mutex );          ldap_pvt_thread_mutex_unlock( &cache->mutex );
   
         return err;          return err;
Line 205  meta_dncache_update_entry( Line 197  meta_dncache_update_entry(
  */   */
 int  int
 meta_dncache_delete_entry(  meta_dncache_delete_entry(
                 struct metadncache      *cache,          metadncache_t   *cache,
                 struct berval           *ndn          struct berval   *ndn )
 )  
 {  {
         struct metadncacheentry *entry, tmp_entry;          metadncacheentry_t      *entry,
                                   tmp_entry;
   
         assert( cache );          assert( cache != NULL );
         assert( ndn );          assert( ndn != NULL );
   
         tmp_entry.dn = *ndn;          tmp_entry.dn = *ndn;
   
Line 236  meta_dncache_delete_entry( Line 228  meta_dncache_delete_entry(
  */   */
 void  void
 meta_dncache_free(  meta_dncache_free(
                 void *e          void            *e )
 )  
 {  {
         struct metadncacheentry *entry = ( struct metadncacheentry * )e;          free( e );
   
         free( entry->dn.bv_val );  
 }  }
   

Removed from v.1.10  
changed lines
  Added in v.1.10.2.6


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