]> git.sur5r.net Git - openldap/blob - servers/slapd/back-meta/dncache.c
Fixup bdb_entry_release now that entry_decode uses two memory blocks
[openldap] / 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