← Back to branch summary

~ubuntu-branches/ubuntu/feisty/apache2/feisty

« back to all changes in this revision

Viewing changes to modules/ldap/util_ldap_cache.h

  • Committer: Bazaar Package Importer
  • Author(s): Andreas Barth
  • Date: 2006-12-09 21:05:45 UTC
  • mfrom: (0.6.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20061209210545-h70s0xaqc2v8vqr2
Tags: 2.2.3-3.2
http://bugs.debian.org/396265
* Non-maintainer upload.
* 043_ajp_connection_reuse: Patch from upstream Bugzilla, fixing a critical
  issue with regard to connection reuse in mod_proxy_ajp.
  Closes: #396265

Show diffs side-by-side

added added

removed removed

Lines of Context:
modules/ldap/util_ldap_cache.h
 
1
/* Licensed to the Apache Software Foundation (ASF) under one or more
 
2
 * contributor license agreements.  See the NOTICE file distributed with
 
3
 * this work for additional information regarding copyright ownership.
 
4
 * The ASF licenses this file to You under the Apache License, Version 2.0
 
5
 * (the "License"); you may not use this file except in compliance with
 
6
 * the License.  You may obtain a copy of the License at
 
7
 *
 
8
 *     http://www.apache.org/licenses/LICENSE-2.0
 
9
 *
 
10
 * Unless required by applicable law or agreed to in writing, software
 
11
 * distributed under the License is distributed on an "AS IS" BASIS,
 
12
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 
13
 * See the License for the specific language governing permissions and
 
14
 * limitations under the License.
 
15
 */
 
16
 
 
17
#ifndef APU_LDAP_CACHE_H
 
18
#define APU_LDAP_CACHE_H
 
19
 
 
20
/**
 
21
 * @file  util_ldap_cache.h
 
22
 * @brief This switches LDAP support on or off.
 
23
 */
 
24
 
 
25
/* this whole thing disappears if LDAP is not enabled */
 
26
#if APR_HAS_LDAP
 
27
 
 
28
 
 
29
/*
 
30
 * LDAP Cache Manager
 
31
 */
 
32
 
 
33
#include "util_ldap.h"
 
34
 
 
35
typedef struct util_cache_node_t {
 
36
    void *payload;              /* Pointer to the payload */
 
37
    apr_time_t add_time;        /* Time node was added to cache */
 
38
    struct util_cache_node_t *next;
 
39
} util_cache_node_t;
 
40
 
 
41
typedef struct util_ald_cache util_ald_cache_t;
 
42
 
 
43
struct util_ald_cache {
 
44
    unsigned long size;                 /* Size of cache array */
 
45
    unsigned long maxentries;           /* Maximum number of cache entries */
 
46
    unsigned long numentries;           /* Current number of cache entries */
 
47
    unsigned long fullmark;             /* Used to keep track of when cache becomes 3/4 full */
 
48
    apr_time_t marktime;                /* Time that the cache became 3/4 full */
 
49
    unsigned long (*hash)(void *);      /* Func to hash the payload */
 
50
    int (*compare)(void *, void *);     /* Func to compare two payloads */
 
51
    void * (*copy)(util_ald_cache_t *cache, void *); /* Func to alloc mem and copy payload to new mem */
 
52
    void (*free)(util_ald_cache_t *cache, void *); /* Func to free mem used by the payload */
 
53
    void (*display)(request_rec *r, util_ald_cache_t *cache, void *); /* Func to display the payload contents */
 
54
    util_cache_node_t **nodes;
 
55
 
 
56
    unsigned long numpurges;    /* No. of times the cache has been purged */
 
57
    double avg_purgetime;       /* Average time to purge the cache */
 
58
    apr_time_t last_purge;      /* Time of the last purge */
 
59
    unsigned long npurged;      /* Number of elements purged in last purge. This is not
 
60
                                   obvious: it won't be 3/4 the size of the cache if 
 
61
                                   there were a lot of expired entries. */
 
62
 
 
63
    unsigned long fetches;      /* Number of fetches */
 
64
    unsigned long hits;         /* Number of cache hits */
 
65
    unsigned long inserts;      /* Number of inserts */
 
66
    unsigned long removes;      /* Number of removes */
 
67
 
 
68
#if APR_HAS_SHARED_MEMORY
 
69
    apr_shm_t *shm_addr;
 
70
    apr_rmm_t *rmm_addr;
 
71
#endif
 
72
 
 
73
};
 
74
 
 
75
#ifndef WIN32
 
76
#define ALD_MM_FILE_MODE ( S_IRUSR|S_IWUSR )
 
77
#else
 
78
#define ALD_MM_FILE_MODE ( _S_IREAD|_S_IWRITE )
 
79
#endif
 
80
 
 
81
 
 
82
/*
 
83
 * LDAP Cache
 
84
 */
 
85
 
 
86
/*
 
87
 * Maintain a cache of LDAP URLs that the server handles. Each node in
 
88
 * the cache contains the search cache for that URL, and a compare cache
 
89
 * for the URL. The compare cash is populated when doing require group
 
90
 * compares.
 
91
 */
 
92
typedef struct util_url_node_t {
 
93
    const char *url;
 
94
    util_ald_cache_t *search_cache;
 
95
    util_ald_cache_t *compare_cache;
 
96
    util_ald_cache_t *dn_compare_cache;
 
97
} util_url_node_t;
 
98
 
 
99
/*
 
100
 * We cache every successful search and bind operation, using the username 
 
101
 * as the key. Each node in the cache contains the returned DN, plus the 
 
102
 * password used to bind.
 
103
 */
 
104
typedef struct util_search_node_t {
 
105
    const char *username;               /* Cache key */
 
106
    const char *dn;                     /* DN returned from search */
 
107
    const char *bindpw;                 /* The most recently used bind password; 
 
108
                                           NULL if the bind failed */
 
109
    apr_time_t lastbind;                /* Time of last successful bind */
 
110
    const char **vals;                  /* Values of queried attributes */
 
111
    int        numvals;         /* Number of queried attributes */
 
112
} util_search_node_t;
 
113
 
 
114
/*
 
115
 * We cache every successful compare operation, using the DN, attrib, and
 
116
 * value as the key. 
 
117
 */
 
118
typedef struct util_compare_node_t {
 
119
    const char *dn;                     /* DN, attrib and value combine to be the key */
 
120
    const char *attrib;                 
 
121
    const char *value;
 
122
    apr_time_t lastcompare;
 
123
    int result;
 
124
} util_compare_node_t;
 
125
 
 
126
/*
 
127
 * We cache every successful compare dn operation, using the dn in the require
 
128
 * statement and the dn fetched based on the client-provided username.
 
129
 */
 
130
typedef struct util_dn_compare_node_t {
 
131
    const char *reqdn;          /* The DN in the require dn statement */
 
132
    const char *dn;                     /* The DN found in the search */
 
133
} util_dn_compare_node_t;
 
134
 
 
135
 
 
136
/*
 
137
 * Function prototypes for LDAP cache
 
138
 */
 
139
 
 
140
/* util_ldap_cache.c */
 
141
unsigned long util_ldap_url_node_hash(void *n);
 
142
int util_ldap_url_node_compare(void *a, void *b);
 
143
void *util_ldap_url_node_copy(util_ald_cache_t *cache, void *c);
 
144
void util_ldap_url_node_free(util_ald_cache_t *cache, void *n);
 
145
void util_ldap_url_node_display(request_rec *r, util_ald_cache_t *cache, void *n);
 
146
 
 
147
unsigned long util_ldap_search_node_hash(void *n);
 
148
int util_ldap_search_node_compare(void *a, void *b);
 
149
void *util_ldap_search_node_copy(util_ald_cache_t *cache, void *c);
 
150
void util_ldap_search_node_free(util_ald_cache_t *cache, void *n);
 
151
void util_ldap_search_node_display(request_rec *r, util_ald_cache_t *cache, void *n);
 
152
 
 
153
unsigned long util_ldap_compare_node_hash(void *n);
 
154
int util_ldap_compare_node_compare(void *a, void *b);
 
155
void *util_ldap_compare_node_copy(util_ald_cache_t *cache, void *c);
 
156
void util_ldap_compare_node_free(util_ald_cache_t *cache, void *n);
 
157
void util_ldap_compare_node_display(request_rec *r, util_ald_cache_t *cache, void *n);
 
158
 
 
159
unsigned long util_ldap_dn_compare_node_hash(void *n);
 
160
int util_ldap_dn_compare_node_compare(void *a, void *b);
 
161
void *util_ldap_dn_compare_node_copy(util_ald_cache_t *cache, void *c);
 
162
void util_ldap_dn_compare_node_free(util_ald_cache_t *cache, void *n);
 
163
void util_ldap_dn_compare_node_display(request_rec *r, util_ald_cache_t *cache, void *n);
 
164
 
 
165
 
 
166
/* util_ldap_cache_mgr.c */
 
167
 
 
168
/* Cache alloc and free function, dealing or not with shm */
 
169
void util_ald_free(util_ald_cache_t *cache, const void *ptr);
 
170
void *util_ald_alloc(util_ald_cache_t *cache, unsigned long size);
 
171
const char *util_ald_strdup(util_ald_cache_t *cache, const char *s);
 
172
 
 
173
/* Cache managing function */
 
174
unsigned long util_ald_hash_string(int nstr, ...);
 
175
void util_ald_cache_purge(util_ald_cache_t *cache);
 
176
util_url_node_t *util_ald_create_caches(util_ldap_state_t *s, const char *url);
 
177
util_ald_cache_t *util_ald_create_cache(util_ldap_state_t *st,
 
178
                                long cache_size,
 
179
                                unsigned long (*hashfunc)(void *), 
 
180
                                int (*comparefunc)(void *, void *),
 
181
                                void * (*copyfunc)(util_ald_cache_t *cache, void *),
 
182
                                void (*freefunc)(util_ald_cache_t *cache, void *),
 
183
                                void (*displayfunc)(request_rec *r, util_ald_cache_t *cache, void *));
 
184
                                
 
185
void util_ald_destroy_cache(util_ald_cache_t *cache);
 
186
void *util_ald_cache_fetch(util_ald_cache_t *cache, void *payload);
 
187
void *util_ald_cache_insert(util_ald_cache_t *cache, void *payload);
 
188
void util_ald_cache_remove(util_ald_cache_t *cache, void *payload);
 
189
char *util_ald_cache_display_stats(request_rec *r, util_ald_cache_t *cache, char *name, char *id);
 
190
 
 
191
#endif /* APR_HAS_LDAP */
 
192
#endif /* APU_LDAP_CACHE_H */