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

   1 /*
   2  * Copyright 1998-2001 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         tmp_entry.dn = ndn;
 153         ldap_pvt_thread_mutex_lock( &cache->mutex );
 154         entry = ( struct metadncacheentry * )avl_find( cache->tree,
 155                         ( caddr_t )&tmp_entry, meta_dncache_cmp );
 156
 157         if ( entry != NULL ) {
 158
 159                 /*
 160                  * if cache->ttl < 0, cache never expires;
 161                  * if cache->ttl = 0 no cache is used; shouldn't get here
 162                  * else, cache is used with ttl
 163                  */
 164                 if ( cache->ttl < 0 ) {
 165                         target = entry->target;
 166                 } else {
 167
 168                         /*
 169                          * Need mutex?
 170                          */
 171                         curr_time = time( NULL );
 172
 173                         if ( entry->lastupdated+cache->ttl > curr_time ) {
 174                                 target = entry->target;
 175                         }
 176                 }
 177         }
 178         ldap_pvt_thread_mutex_unlock( &cache->mutex );
 179
 180         return target;
 181 }
 182
 183 /*
 184  * meta_dncache_update_entry
 185  *
 186  * updates target and lastupdated of a struct metadncacheentry if exists,
 187  * otherwise it gets created; returns -1 in case of error
 188  */
 189 int
 190 meta_dncache_update_entry(
 191                 struct metadncache      *cache,
 192                 struct berval           *ndn,
 193                 int                     target
 194 )
 195 {
 196         struct metadncacheentry *entry, tmp_entry;
 197         time_t curr_time = 0L;
 198         int err = 0;
 199
 200         /*
 201          * if cache->ttl < 0, cache never expires;
 202          * if cache->ttl = 0 no cache is used; shouldn't get here
 203          * else, cache is used with ttl
 204          */
 205         if ( cache->ttl > 0 ) {
 206
 207                 /*
 208                  * Need mutex?
 209                  */
 210                 curr_time = time( NULL );
 211         }
 212
 213         tmp_entry.dn = ndn;
 214
 215         ldap_pvt_thread_mutex_lock( &cache->mutex );
 216         entry = ( struct metadncacheentry * )avl_find( cache->tree,
 217                         ( caddr_t )&tmp_entry, meta_dncache_cmp );
 218
 219         if ( entry != NULL ) {
 220                 entry->target = target;
 221                 entry->lastupdated = curr_time;
 222         } else {
 223                 entry = ch_calloc( sizeof( struct metadncacheentry ), 1 );
 224                 if ( entry == NULL ) {
 225                         ldap_pvt_thread_mutex_unlock( &cache->mutex );
 226                         return -1;
 227                 }
 228
 229                 entry->dn = ber_bvdup( ndn );
 230                 if ( entry->dn == NULL ) {
 231                         ldap_pvt_thread_mutex_unlock( &cache->mutex );
 232                         return -1;
 233                 }
 234                 entry->target = target;
 235                 entry->lastupdated = curr_time;
 236
 237                 err = avl_insert( &cache->tree, ( caddr_t )entry,
 238                                 meta_dncache_cmp, meta_dncache_dup );
 239         }
 240         ldap_pvt_thread_mutex_unlock( &cache->mutex );
 241
 242         return err;
 243 }
 244
 245 /*
 246  * meta_dncache_update_entry
 247  *
 248  * updates target and lastupdated of a struct metadncacheentry if exists,
 249  * otherwise it gets created; returns -1 in case of error
 250  */
 251 int
 252 meta_dncache_delete_entry(
 253                 struct metadncache      *cache,
 254                 struct berval           *ndn
 255 )
 256 {
 257         struct metadncacheentry *entry, tmp_entry;
 258
 259         tmp_entry.dn = ndn;
 260
 261         ldap_pvt_thread_mutex_lock( &cache->mutex );
 262         entry = avl_delete( &cache->tree, ( caddr_t )&tmp_entry,
 263                         meta_dncache_cmp );
 264         ldap_pvt_thread_mutex_lock( &cache->mutex );
 265
 266         if ( entry != NULL ) {
 267                 meta_dncache_free( ( void * )entry );
 268         }
 269
 270         return 0;
 271 }
 272
 273 /*
 274  * meta_dncache_free
 275  *
 276  * frees an entry
 277  *
 278  */
 279 void
 280 meta_dncache_free(
 281                 void *e
 282 )
 283 {
 284         struct metadncacheentry *entry = ( struct metadncacheentry * )e;
 285
 286         ber_bvfree( entry->dn );
 287 }
 288