tlsmgrmem.c

[詳解]

/*++
/* NAME
/*  tlsmgrmem 3
/* SUMMARY
/*  Memory-based TLS manager interface for tlsfinger(1).
/* SYNOPSIS
/*  #ifdef  USE_TLS
/*  #include <tlsmgrmem.h>
/*
/*  void    tlsmgrmem_disable()
/*
/*  void    tlsmgrmem_status(enable, count, hits)
/*  int *enable;
/*  int *count;
/*  int *hits;
/*
/*  void    tlsmgrmem_flush()
/*  #endif
/* DESCRIPTION
/*  tlsmgrmem_disable() disables the in-memory TLS session cache.
/*
/*  tlsmgrmem_status() reports whether the cache is enabled, the
/*  number of entries in the cache, and the number of cache hits.
/*  If any of the return pointers are null, that item is not reported.
/*
/*  tlsmgrmem_flush() flushes any cached data and frees the cache.
/* LICENSE
/* .ad
/* .fi
/*  The Secure Mailer license must be distributed with this software.
/* AUTHOR(S)
/*  Wietse Venema
/*  IBM T.J. Watson Research
/*  P.O. Box 704
/*  Yorktown Heights, NY 10598, USA
/*
/*  Viktor Dukhovni
/*--*/

#include <sys_defs.h>

#ifdef USE_TLS
#include <htable.h>
#include <vstring.h>
#include <tls_mgr.h>

#include "tlsmgrmem.h"

static HTABLE *tls_cache;
static int cache_enabled = 1;
static int cache_count;
static int cache_hits;
typedef void (*free_func) (void *);
static free_func free_value = (free_func) vstring_free;

void    tlsmgrmem_disable(void)
{
    cache_enabled = 0;
}

void    tlsmgrmem_flush(void)
{
    if (!tls_cache)
    return;
    htable_free(tls_cache, free_value);
}

void    tlsmgrmem_status(int *enabled, int *count, int *hits)
{
    if (enabled)
    *enabled = cache_enabled;
    if (count)
    *count = cache_count;
    if (hits)
    *hits = cache_hits;
}

/* tls_mgr_* - Local cache and stubs that do not talk to the TLS manager */

int     tls_mgr_seed(VSTRING *buf, int len)
{
    return (TLS_MGR_STAT_OK);
}

int     tls_mgr_policy(const char *unused_type, int *cachable, int *timeout)
{
    if (cache_enabled && tls_cache == 0)
    tls_cache = htable_create(1);
    *cachable = cache_enabled;
    *timeout = TLS_SESSION_LIFEMIN;
    return (TLS_MGR_STAT_OK);
}

int     tls_mgr_lookup(const char *unused_type, const char *key, VSTRING *buf)
{
    VSTRING *s;

    if (tls_cache == 0)
    return TLS_MGR_STAT_ERR;

    if ((s = (VSTRING *) htable_find(tls_cache, key)) == 0)
    return TLS_MGR_STAT_ERR;

    vstring_memcpy(buf, vstring_str(s), VSTRING_LEN(s));

    ++cache_hits;
    return (TLS_MGR_STAT_OK);
}

int     tls_mgr_update(const char *unused_type, const char *key,
                       const char *buf, ssize_t len)
{
    HTABLE_INFO *ent;
    VSTRING *s;

    if (tls_cache == 0)
    return TLS_MGR_STAT_ERR;

    if ((ent = htable_locate(tls_cache, key)) == 0) {
    s = vstring_alloc(len);
    ent = htable_enter(tls_cache, key, (void *) s);
    } else {
    s = (VSTRING *) ent->value;
    }
    vstring_memcpy(s, buf, len);

    ++cache_count;
    return (TLS_MGR_STAT_OK);
}

int     tls_mgr_delete(const char *unused_type, const char *key)
{
    if (tls_cache == 0)
    return TLS_MGR_STAT_ERR;

    if (htable_locate(tls_cache, key)) {
    htable_delete(tls_cache, key, free_value);
    --cache_count;
    }
    return (TLS_MGR_STAT_OK);
}

#endif