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         char *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         /*
 103          * case sensitive, because the dn MUST be normalized
 104          */
 105         return strcmp( cc1->dn, cc2->dn );
 106 }
 107
 108 /*
 109  * meta_dncache_dup
 110  *
 111  * returns -1 in case a duplicate struct metadncacheentry has been inserted;
 112  * used by avl stuff
 113  */
 114 int
 115 meta_dncache_dup(
 116                 void *c1,
 117                 void *c2
 118 )
 119 {
 120         struct metadncacheentry *cc1 = ( struct metadncacheentry * )c1;
 121         struct metadncacheentry *cc2 = ( struct metadncacheentry * )c2;
 122
 123         /*
 124          * case sensitive, because the dn MUST be normalized
 125          */
 126         return ( strcmp( cc1->dn, cc2->dn ) == 0 ) ? -1 : 0;
 127 }
 128
 129 /*
 130  * meta_dncache_get_target
 131  *
 132  * returns the target a dn belongs to, or -1 in case the dn is not
 133  * in the cache
 134  */
 135 int
 136 meta_dncache_get_target(
 137                 struct metadncache      *cache,
 138                 const char              *ndn
 139 )
 140 {
 141         struct metadncacheentry tmp_entry, *entry;
 142         time_t curr_time;
 143         int target = -1;
 144
 145         tmp_entry.dn = ( char * )ndn;
 146         ldap_pvt_thread_mutex_lock( &cache->mutex );
 147         entry = ( struct metadncacheentry * )avl_find( cache->tree,
 148                         ( caddr_t )&tmp_entry, meta_dncache_cmp );
 149
 150         if ( entry != NULL ) {
 151
 152                 /*
 153                  * if cache->ttl < 0, cache never expires;
 154                  * if cache->ttl = 0 no cache is used; shouldn't get here
 155                  * else, cache is used with ttl
 156                  */
 157                 if ( cache->ttl < 0 ) {
 158                         target = entry->target;
 159                 } else {
 160
 161                         /*
 162                          * Need mutex?
 163                          */
 164                         curr_time = time( NULL );
 165
 166                         if ( entry->lastupdated+cache->ttl > curr_time ) {
 167                                 target = entry->target;
 168                         }
 169                 }
 170         }
 171         ldap_pvt_thread_mutex_unlock( &cache->mutex );
 172
 173         return target;
 174 }
 175
 176 /*
 177  * meta_dncache_update_entry
 178  *
 179  * updates target and lastupdated of a struct metadncacheentry if exists,
 180  * otherwise it gets created; returns -1 in case of error
 181  */
 182 int
 183 meta_dncache_update_entry(
 184                 struct metadncache      *cache,
 185                 const char              *ndn,
 186                 int                     target
 187 )
 188 {
 189         struct metadncacheentry *entry, tmp_entry;
 190         time_t curr_time = 0L;
 191         int err = 0;
 192
 193         /*
 194          * if cache->ttl < 0, cache never expires;
 195          * if cache->ttl = 0 no cache is used; shouldn't get here
 196          * else, cache is used with ttl
 197          */
 198         if ( cache->ttl > 0 ) {
 199
 200                 /*
 201                  * Need mutex?
 202                  */
 203                 curr_time = time( NULL );
 204         }
 205
 206         tmp_entry.dn = ( char * )ndn;
 207
 208         ldap_pvt_thread_mutex_lock( &cache->mutex );
 209         entry = ( struct metadncacheentry * )avl_find( cache->tree,
 210                         ( caddr_t )&tmp_entry, meta_dncache_cmp );
 211
 212         if ( entry != NULL ) {
 213                 entry->target = target;
 214                 entry->lastupdated = curr_time;
 215         } else {
 216                 entry = ch_calloc( sizeof( struct metadncacheentry ), 1 );
 217                 if ( entry == NULL ) {
 218                         ldap_pvt_thread_mutex_unlock( &cache->mutex );
 219                         return -1;
 220                 }
 221
 222                 entry->dn = ch_strdup( ndn );
 223                 if ( entry->dn == NULL ) {
 224                         ldap_pvt_thread_mutex_unlock( &cache->mutex );
 225                         return -1;
 226                 }
 227                 entry->target = target;
 228                 entry->lastupdated = curr_time;
 229
 230                 err = avl_insert( &cache->tree, ( caddr_t )entry,
 231                                 meta_dncache_cmp, meta_dncache_dup );
 232         }
 233         ldap_pvt_thread_mutex_unlock( &cache->mutex );
 234
 235         return err;
 236 }
 237
 238 /*
 239  * meta_dncache_update_entry
 240  *
 241  * updates target and lastupdated of a struct metadncacheentry if exists,
 242  * otherwise it gets created; returns -1 in case of error
 243  */
 244 int
 245 meta_dncache_delete_entry(
 246                 struct metadncache      *cache,
 247                 const char              *ndn
 248 )
 249 {
 250         struct metadncacheentry *entry, tmp_entry;
 251
 252         tmp_entry.dn = ( char * )ndn;
 253
 254         ldap_pvt_thread_mutex_lock( &cache->mutex );
 255         entry = avl_delete( &cache->tree, ( caddr_t )&tmp_entry,
 256                         meta_dncache_cmp );
 257         ldap_pvt_thread_mutex_lock( &cache->mutex );
 258
 259         if ( entry != NULL ) {
 260                 meta_dncache_free( ( void * )entry );
 261         }
 262
 263         return 0;
 264 }
 265
 266 /*
 267  * meta_dncache_free
 268  *
 269  * frees an entry
 270  *
 271  */
 272 void
 273 meta_dncache_free(
 274                 void *e
 275 )
 276 {
 277         struct metadncacheentry *entry = ( struct metadncacheentry * )e;
 278
 279         free( entry->dn );
 280 }
 281