granicus.if.org Git - apache/blob - 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  * When a group is found, subgroups are stored in the group's cache entry.
 101  */
 102 typedef struct util_compare_subgroup_t {
 103     const char **subgroupDNs;
 104     int len;
 105 } util_compare_subgroup_t;
 106
 107 /*
 108  * We cache every successful search and bind operation, using the username
 109  * as the key. Each node in the cache contains the returned DN, plus the
 110  * password used to bind.
 111  */
 112 typedef struct util_search_node_t {
 113     const char *username;               /* Cache key */
 114     const char *dn;                     /* DN returned from search */
 115     const char *bindpw;                 /* The most recently used bind password;
 116                                            NULL if the bind failed */
 117     apr_time_t lastbind;                /* Time of last successful bind */
 118     const char **vals;                  /* Values of queried attributes */
 119     int        numvals;         /* Number of queried attributes */
 120 } util_search_node_t;
 121
 122 /*
 123  * We cache every successful compare operation, using the DN, attrib, and
 124  * value as the key.
 125  */
 126 typedef struct util_compare_node_t {
 127     const char *dn;                     /* DN, attrib and value combine to be the key */
 128     const char *attrib;
 129     const char *value;
 130     apr_time_t lastcompare;
 131     int result;
 132     int sgl_processed;      /* 0 if no sgl processing yet. 1 if sgl has been processed (even if SGL is NULL). Saves repeat work on leaves. */
 133     struct util_compare_subgroup_t *subgroupList;
 134 } util_compare_node_t;
 135
 136 /*
 137  * We cache every successful compare dn operation, using the dn in the require
 138  * statement and the dn fetched based on the client-provided username.
 139  */
 140 typedef struct util_dn_compare_node_t {
 141     const char *reqdn;          /* The DN in the require dn statement */
 142     const char *dn;                     /* The DN found in the search */
 143 } util_dn_compare_node_t;
 144
 145
 146 /*
 147  * Function prototypes for LDAP cache
 148  */
 149
 150 /* util_ldap_cache.c */
 151 unsigned long util_ldap_url_node_hash(void *n);
 152 int util_ldap_url_node_compare(void *a, void *b);
 153 void *util_ldap_url_node_copy(util_ald_cache_t *cache, void *c);
 154 void util_ldap_url_node_free(util_ald_cache_t *cache, void *n);
 155 void util_ldap_url_node_display(request_rec *r, util_ald_cache_t *cache, void *n);
 156
 157 unsigned long util_ldap_search_node_hash(void *n);
 158 int util_ldap_search_node_compare(void *a, void *b);
 159 void *util_ldap_search_node_copy(util_ald_cache_t *cache, void *c);
 160 void util_ldap_search_node_free(util_ald_cache_t *cache, void *n);
 161 void util_ldap_search_node_display(request_rec *r, util_ald_cache_t *cache, void *n);
 162
 163 unsigned long util_ldap_compare_node_hash(void *n);
 164 int util_ldap_compare_node_compare(void *a, void *b);
 165 void *util_ldap_compare_node_copy(util_ald_cache_t *cache, void *c);
 166 void util_ldap_compare_node_free(util_ald_cache_t *cache, void *n);
 167 void util_ldap_compare_node_display(request_rec *r, util_ald_cache_t *cache, void *n);
 168
 169 unsigned long util_ldap_dn_compare_node_hash(void *n);
 170 int util_ldap_dn_compare_node_compare(void *a, void *b);
 171 void *util_ldap_dn_compare_node_copy(util_ald_cache_t *cache, void *c);
 172 void util_ldap_dn_compare_node_free(util_ald_cache_t *cache, void *n);
 173 void util_ldap_dn_compare_node_display(request_rec *r, util_ald_cache_t *cache, void *n);
 174
 175
 176 /* util_ldap_cache_mgr.c */
 177
 178 /* Cache alloc and free function, dealing or not with shm */
 179 void util_ald_free(util_ald_cache_t *cache, const void *ptr);
 180 void *util_ald_alloc(util_ald_cache_t *cache, unsigned long size);
 181 const char *util_ald_strdup(util_ald_cache_t *cache, const char *s);
 182 util_compare_subgroup_t *util_ald_sgl_dup(util_ald_cache_t *cache, util_compare_subgroup_t *sgl);
 183 void util_ald_sgl_free(util_ald_cache_t *cache, util_compare_subgroup_t **sgl);
 184
 185 /* Cache managing function */
 186 unsigned long util_ald_hash_string(int nstr, ...);
 187 void util_ald_cache_purge(util_ald_cache_t *cache);
 188 util_url_node_t *util_ald_create_caches(util_ldap_state_t *s, const char *url);
 189 util_ald_cache_t *util_ald_create_cache(util_ldap_state_t *st,
 190                                 long cache_size,
 191                                 unsigned long (*hashfunc)(void *),
 192                                 int (*comparefunc)(void *, void *),
 193                                 void * (*copyfunc)(util_ald_cache_t *cache, void *),
 194                                 void (*freefunc)(util_ald_cache_t *cache, void *),
 195                                 void (*displayfunc)(request_rec *r, util_ald_cache_t *cache, void *));
 196
 197 void util_ald_destroy_cache(util_ald_cache_t *cache);
 198 void *util_ald_cache_fetch(util_ald_cache_t *cache, void *payload);
 199 void *util_ald_cache_insert(util_ald_cache_t *cache, void *payload);
 200 void util_ald_cache_remove(util_ald_cache_t *cache, void *payload);
 201 char *util_ald_cache_display_stats(request_rec *r, util_ald_cache_t *cache, char *name, char *id);
 202
 203 #endif /* APR_HAS_LDAP */
 204 #endif /* APU_LDAP_CACHE_H */