/* Licensed to the Apache Software Foundation (ASF) under one or more

 * contributor license agreements.  See the NOTICE file distributed with

 * this work for additional information regarding copyright ownership.

 * The ASF licenses this file to You under the Apache License, Version 2.0

 * (the "License"); you may not use this file except in compliance with

 * the License.  You may obtain a copy of the License at

 *

 *     http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

#ifndef APU_LDAP_CACHE_H

#define APU_LDAP_CACHE_H

/**

 * @file  util_ldap_cache.h

 * @brief This switches LDAP support on or off.

 */

/* this whole thing disappears if LDAP is not enabled */

#if APR_HAS_LDAP

/*

 * LDAP Cache Manager

 */

#include "util_ldap.h"

typedef struct util_cache_node_t {

    void *payload;              /* Pointer to the payload */

    apr_time_t add_time;        /* Time node was added to cache */

    struct util_cache_node_t *next;

} util_cache_node_t;

typedef struct util_ald_cache util_ald_cache_t;

struct util_ald_cache {

    unsigned long size;                 /* Size of cache array */

    unsigned long maxentries;           /* Maximum number of cache entries */

    unsigned long numentries;           /* Current number of cache entries */

    unsigned long fullmark;             /* Used to keep track of when cache becomes 3/4 full */

    apr_time_t marktime;                /* Time that the cache became 3/4 full */

    unsigned long ttl;                  /* Time to live for items in cache */

    unsigned long (*hash)(void *);      /* Func to hash the payload */

    int (*compare)(void *, void *);     /* Func to compare two payloads */

    void * (*copy)(util_ald_cache_t *cache, void *); /* Func to alloc mem and copy payload to new mem */

    void (*free)(util_ald_cache_t *cache, void *); /* Func to free mem used by the payload */

    void (*display)(request_rec *r, util_ald_cache_t *cache, void *); /* Func to display the payload contents */

    util_cache_node_t **nodes;

    unsigned long numpurges;    /* No. of times the cache has been purged */

    double avg_purgetime;       /* Average time to purge the cache */

    apr_time_t last_purge;      /* Time of the last purge */

    unsigned long npurged;      /* Number of elements purged in last purge. This is not

                                   obvious: it won't be 3/4 the size of the cache if

                                   there were a lot of expired entries. */

    unsigned long fetches;      /* Number of fetches */

    unsigned long hits;         /* Number of cache hits */

    unsigned long inserts;      /* Number of inserts */

    unsigned long removes;      /* Number of removes */

#if APR_HAS_SHARED_MEMORY

    apr_shm_t *shm_addr;

    apr_rmm_t *rmm_addr;

#endif

};

#ifndef WIN32

#define ALD_MM_FILE_MODE ( S_IRUSR|S_IWUSR )

#else

#define ALD_MM_FILE_MODE ( _S_IREAD|_S_IWRITE )

#endif

/*

 * LDAP Cache

 */

/*

 * Maintain a cache of LDAP URLs that the server handles. Each node in

 * the cache contains the search cache for that URL, and a compare cache

 * for the URL. The compare cash is populated when doing require group

 * compares.

 */

typedef struct util_url_node_t {

    const char *url;

    util_ald_cache_t *search_cache;

    util_ald_cache_t *compare_cache;

    util_ald_cache_t *dn_compare_cache;

} util_url_node_t;

/*

 * When a group is found, subgroups are stored in the group's cache entry.

 */

typedef struct util_compare_subgroup_t {

    const char **subgroupDNs;

    int len;

} util_compare_subgroup_t;

/*

 * We cache every successful search and bind operation, using the username

 * as the key. Each node in the cache contains the returned DN, plus the

 * password used to bind.

 */

typedef struct util_search_node_t {

    const char *username;               /* Cache key */

    const char *dn;                     /* DN returned from search */

    const char *bindpw;                 /* The most recently used bind password;

                                           NULL if the bind failed */

    apr_time_t lastbind;                /* Time of last successful bind */

    const char **vals;                  /* Values of queried attributes */

    int        numvals;         /* Number of queried attributes */

} util_search_node_t;

/*

 * We cache every successful compare operation, using the DN, attrib, and

 * value as the key.

 */

typedef struct util_compare_node_t {

    const char *dn;                     /* DN, attrib and value combine to be the key */

    const char *attrib;

    const char *value;

    apr_time_t lastcompare;

    int result;

    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. */

    struct util_compare_subgroup_t *subgroupList;

} util_compare_node_t;

/*

 * We cache every successful compare dn operation, using the dn in the require

 * statement and the dn fetched based on the client-provided username.

 */

typedef struct util_dn_compare_node_t {

    const char *reqdn;          /* The DN in the require dn statement */

    const char *dn;                     /* The DN found in the search */

} util_dn_compare_node_t;

/*

 * Function prototypes for LDAP cache

 */

/* util_ldap_cache.c */

unsigned long util_ldap_url_node_hash(void *n);

int util_ldap_url_node_compare(void *a, void *b);

void *util_ldap_url_node_copy(util_ald_cache_t *cache, void *c);

void util_ldap_url_node_free(util_ald_cache_t *cache, void *n);

void util_ldap_url_node_display(request_rec *r, util_ald_cache_t *cache, void *n);

unsigned long util_ldap_search_node_hash(void *n);

int util_ldap_search_node_compare(void *a, void *b);

void *util_ldap_search_node_copy(util_ald_cache_t *cache, void *c);

void util_ldap_search_node_free(util_ald_cache_t *cache, void *n);

void util_ldap_search_node_display(request_rec *r, util_ald_cache_t *cache, void *n);

unsigned long util_ldap_compare_node_hash(void *n);

int util_ldap_compare_node_compare(void *a, void *b);

void *util_ldap_compare_node_copy(util_ald_cache_t *cache, void *c);

void util_ldap_compare_node_free(util_ald_cache_t *cache, void *n);

void util_ldap_compare_node_display(request_rec *r, util_ald_cache_t *cache, void *n);

unsigned long util_ldap_dn_compare_node_hash(void *n);

int util_ldap_dn_compare_node_compare(void *a, void *b);

void *util_ldap_dn_compare_node_copy(util_ald_cache_t *cache, void *c);

void util_ldap_dn_compare_node_free(util_ald_cache_t *cache, void *n);

void util_ldap_dn_compare_node_display(request_rec *r, util_ald_cache_t *cache, void *n);

/* util_ldap_cache_mgr.c */

/* Cache alloc and free function, dealing or not with shm */

void util_ald_free(util_ald_cache_t *cache, const void *ptr);

void *util_ald_alloc(util_ald_cache_t *cache, unsigned long size);

const char *util_ald_strdup(util_ald_cache_t *cache, const char *s);

util_compare_subgroup_t *util_ald_sgl_dup(util_ald_cache_t *cache, util_compare_subgroup_t *sgl);

void util_ald_sgl_free(util_ald_cache_t *cache, util_compare_subgroup_t **sgl);

/* Cache managing function */

unsigned long util_ald_hash_string(int nstr, ...);

void util_ald_cache_purge(util_ald_cache_t *cache);

util_url_node_t *util_ald_create_caches(util_ldap_state_t *s, const char *url);

util_ald_cache_t *util_ald_create_cache(util_ldap_state_t *st,

                                long cache_size,

                                long cache_ttl,

                                unsigned long (*hashfunc)(void *),

                                int (*comparefunc)(void *, void *),

                                void * (*copyfunc)(util_ald_cache_t *cache, void *),

                                void (*freefunc)(util_ald_cache_t *cache, void *),

                                void (*displayfunc)(request_rec *r, util_ald_cache_t *cache, void *));

void util_ald_destroy_cache(util_ald_cache_t *cache);

void *util_ald_cache_fetch(util_ald_cache_t *cache, void *payload);

void *util_ald_cache_insert(util_ald_cache_t *cache, void *payload);

void util_ald_cache_remove(util_ald_cache_t *cache, void *payload);

char *util_ald_cache_display_stats(request_rec *r, util_ald_cache_t *cache, char *name, char *id);

#endif /* APR_HAS_LDAP */

#endif /* APU_LDAP_CACHE_H */