git.sur5r.net Git - openldap/blob - servers/slapd/back-meta/dncache.c

   1 /*
   2  * Copyright 1998-2002 The OpenLDAP Foundation, All Rights Reserved.
   3  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
   4  *
   5  * Copyright 2001, Pierangelo Masarati, All rights reserved. <ando@sys-net.it>
   6  *
   7  * This work has been developed to fulfill the requirements
   8  * of SysNet s.n.c. <http:www.sys-net.it> and it has been donated
   9  * to the OpenLDAP Foundation in the hope that it may be useful
  10  * to the Open Source community, but WITHOUT ANY WARRANTY.
  11  *
  12  * Permission is granted to anyone to use this software for any purpose
  13  * on any computer system, and to alter it and redistribute it, subject
  14  * to the following restrictions:
  15  *
  16  * 1. The author and SysNet s.n.c. are not responsible for the consequences
  17  *    of use of this software, no matter how awful, even if they arise from
  18  *    flaws in it.
  19  *
  20  * 2. The origin of this software must not be misrepresented, either by
  21  *    explicit claim or by omission.  Since few users ever read sources,
  22  *    credits should appear in the documentation.
  23  *
  24  * 3. Altered versions must be plainly marked as such, and must not be
  25  *    misrepresented as being the original software.  Since few users
  26  *    ever read sources, credits should appear in the documentation.
  27  *    SysNet s.n.c. cannot be responsible for the consequences of the
  28  *    alterations.
  29  *
  30  * 4. This notice may not be removed or altered.
  31  *
  32  *
  33  * This software is based on the backend back-ldap, implemented
  34  * by Howard Chu <hyc@highlandsun.com>, and modified by Mark Valence
  35  * <kurash@sassafras.com>, Pierangelo Masarati <ando@sys-net.it> and other
  36  * contributors. The contribution of the original software to the present
  37  * implementation is acknowledged in this copyright statement.
  38  *
  39  * A special acknowledgement goes to Howard for the overall architecture
  40  * (and for borrowing large pieces of code), and to Mark, who implemented
  41  * from scratch the attribute/objectclass mapping.
  42  *
  43  * The original copyright statement follows.
  44  *
  45  * Copyright 1999, Howard Chu, All rights reserved. <hyc@highlandsun.com>
  46  *
  47  * Permission is granted to anyone to use this software for any purpose
  48  * on any computer system, and to alter it and redistribute it, subject
  49  * to the following restrictions:
  50  *
  51  * 1. The author is not responsible for the consequences of use of this
  52  *    software, no matter how awful, even if they arise from flaws in it.
  53  *
  54  * 2. The origin of this software must not be misrepresented, either by
  55  *    explicit claim or by omission.  Since few users ever read sources,
  56  *    credits should appear in the documentation.
  57  *
  58  * 3. Altered versions must be plainly marked as such, and must not be
  59  *    misrepresented as being the original software.  Since few users
  60  *    ever read sources, credits should appear in the
  61  *    documentation.
  62  *
  63  * 4. This notice may not be removed or altered.
  64  *
  65  */
  66
  67 #include "portable.h"
  68
  69 #include <stdio.h>
  70
  71 #include "slap.h"
  72 #include "../back-ldap/back-ldap.h"
  73 #include "back-meta.h"
  74
  75 /*
  76  * The dncache, at present, maps an entry to the target that holds it.
  77  */
  78
  79 struct metadncacheentry {
  80         struct berval   dn;
  81         int             target;
  82
  83         time_t          lastupdated;
  84 };
  85
  86 /*
  87  * meta_dncache_cmp
  88  *
  89  * compares two struct metadncacheentry; used by avl stuff
  90  * FIXME: modify avl stuff to delete an entry based on cmp
  91  * (e.g. when ttl expired?)
  92  */
  93 int
  94 meta_dncache_cmp(
  95                 const void *c1,
  96                 const void *c2
  97 )
  98 {
  99         struct metadncacheentry *cc1 = ( struct metadncacheentry * )c1;
 100         struct metadncacheentry *cc2 = ( struct metadncacheentry * )c2;
 101
 102         int                     d = cc1->dn.bv_len - cc2->dn.bv_len;
 103
 104         /*
 105          * case sensitive, because the dn MUST be normalized
 106          */
 107         return d != 0 ? d : strcmp( cc1->dn.bv_val, cc2->dn.bv_val );
 108 }
 109
 110 /*
 111  * meta_dncache_dup
 112  *
 113  * returns -1 in case a duplicate struct metadncacheentry has been inserted;
 114  * used by avl stuff
 115  */
 116 int
 117 meta_dncache_dup(
 118                 void *c1,
 119                 void *c2
 120 )
 121 {
 122         struct metadncacheentry *cc1 = ( struct metadncacheentry * )c1;
 123         struct metadncacheentry *cc2 = ( struct metadncacheentry * )c2;
 124
 125         int                     d = cc1->dn.bv_len - cc2->dn.bv_len;
 126         int                     cmp;
 127
 128         /*
 129          * case sensitive, because the dn MUST be normalized
 130          */
 131         cmp = d != 0 ? d : strcmp( cc1->dn.bv_val, cc2->dn.bv_val );
 132
 133         return ( cmp == 0 ) ? -1 : 0;
 134 }
 135
 136 /*
 137  * meta_dncache_get_target
 138  *
 139  * returns the target a dn belongs to, or -1 in case the dn is not
 140  * in the cache
 141  */
 142 int
 143 meta_dncache_get_target(
 144                 struct metadncache      *cache,
 145                 struct berval           *ndn
 146 )
 147 {
 148         struct metadncacheentry tmp_entry, *entry;
 149         time_t curr_time;
 150         int target = -1;
 151
 152         assert( cache );
 153         assert( ndn );
 154
 155         tmp_entry.dn = *ndn;
 156         ldap_pvt_thread_mutex_lock( &cache->mutex );
 157         entry = ( struct metadncacheentry * )avl_find( cache->tree,
 158                         ( caddr_t )&tmp_entry, meta_dncache_cmp );
 159
 160         if ( entry != NULL ) {
 161
 162                 /*
 163                  * if cache->ttl < 0, cache never expires;
 164                  * if cache->ttl = 0 no cache is used; shouldn't get here
 165                  * else, cache is used with ttl
 166                  */
 167                 if ( cache->ttl < 0 ) {
 168                         target = entry->target;
 169                 } else {
 170
 171                         /*
 172                          * Need mutex?
 173                          */
 174                         curr_time = time( NULL );
 175
 176                         if ( entry->lastupdated+cache->ttl > curr_time ) {
 177                                 target = entry->target;
 178                         }
 179                 }
 180         }
 181         ldap_pvt_thread_mutex_unlock( &cache->mutex );
 182
 183         return target;
 184 }
 185
 186 /*
 187  * meta_dncache_update_entry
 188  *
 189  * updates target and lastupdated of a struct metadncacheentry if exists,
 190  * otherwise it gets created; returns -1 in case of error
 191  */
 192 int
 193 meta_dncache_update_entry(
 194                 struct metadncache      *cache,
 195                 struct berval           *ndn,
 196                 int                     target
 197 )
 198 {
 199         struct metadncacheentry *entry, tmp_entry;
 200         time_t curr_time = 0L;
 201         int err = 0;
 202
 203         assert( cache );
 204         assert( ndn );
 205
 206         /*
 207          * if cache->ttl < 0, cache never expires;
 208          * if cache->ttl = 0 no cache is used; shouldn't get here
 209          * else, cache is used with ttl
 210          */
 211         if ( cache->ttl > 0 ) {
 212
 213                 /*
 214                  * Need mutex?
 215                  */
 216                 curr_time = time( NULL );
 217         }
 218
 219         tmp_entry.dn = *ndn;
 220
 221         ldap_pvt_thread_mutex_lock( &cache->mutex );
 222         entry = ( struct metadncacheentry * )avl_find( cache->tree,
 223                         ( caddr_t )&tmp_entry, meta_dncache_cmp );
 224
 225         if ( entry != NULL ) {
 226                 entry->target = target;
 227                 entry->lastupdated = curr_time;
 228         } else {
 229                 entry = ch_calloc( sizeof( struct metadncacheentry ), 1 );
 230                 if ( entry == NULL ) {
 231                         ldap_pvt_thread_mutex_unlock( &cache->mutex );
 232                         return -1;
 233                 }
 234
 235                 ber_dupbv( &entry->dn, ndn );
 236                 if ( entry->dn.bv_val == NULL ) {
 237                         ldap_pvt_thread_mutex_unlock( &cache->mutex );
 238                         return -1;
 239                 }
 240                 entry->target = target;
 241                 entry->lastupdated = curr_time;
 242
 243                 err = avl_insert( &cache->tree, ( caddr_t )entry,
 244                                 meta_dncache_cmp, meta_dncache_dup );
 245         }
 246         ldap_pvt_thread_mutex_unlock( &cache->mutex );
 247
 248         return err;
 249 }
 250
 251 /*
 252  * meta_dncache_update_entry
 253  *
 254  * updates target and lastupdated of a struct metadncacheentry if exists,
 255  * otherwise it gets created; returns -1 in case of error
 256  */
 257 int
 258 meta_dncache_delete_entry(
 259                 struct metadncache      *cache,
 260                 struct berval           *ndn
 261 )
 262 {
 263         struct metadncacheentry *entry, tmp_entry;
 264
 265         assert( cache );
 266         assert( ndn );
 267
 268         tmp_entry.dn = *ndn;
 269
 270         ldap_pvt_thread_mutex_lock( &cache->mutex );
 271         entry = avl_delete( &cache->tree, ( caddr_t )&tmp_entry,
 272                         meta_dncache_cmp );
 273         ldap_pvt_thread_mutex_lock( &cache->mutex );
 274
 275         if ( entry != NULL ) {
 276                 meta_dncache_free( ( void * )entry );
 277         }
 278
 279         return 0;
 280 }
 281
 282 /*
 283  * meta_dncache_free
 284  *
 285  * frees an entry
 286  *
 287  */
 288 void
 289 meta_dncache_free(
 290                 void *e
 291 )
 292 {
 293         struct metadncacheentry *entry = ( struct metadncacheentry * )e;
 294
 295         free( entry->dn.bv_val );
 296 }
 297