/*

 * validator/val_kcache.c - validator key shared cache with validated keys

 *

 * Copyright (c) 2007, NLnet Labs. All rights reserved.

 *

 * This software is open source.

 * 

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 

 * Redistributions of source code must retain the above copyright notice,

 * this list of conditions and the following disclaimer.

 * 

 * Redistributions in binary form must reproduce the above copyright notice,

 * this list of conditions and the following disclaimer in the documentation

 * and/or other materials provided with the distribution.

 * 

 * Neither the name of the NLNET LABS nor the names of its contributors may

 * be used to endorse or promote products derived from this software without

 * specific prior written permission.

 * 

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

 * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED

 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

/**

 * \file

 *

 * This file contains functions for dealing with the validator key cache.

 */

#include "config.h"

#include "validator/val_kcache.h"

#include "validator/val_kentry.h"

#include "util/log.h"

#include "util/config_file.h"

#include "util/data/dname.h"

#include "util/module.h"

struct key_cache* 

key_cache_create(struct config_file* cfg)

{

  struct key_cache* kcache = (struct key_cache*)calloc(1, 

    sizeof(*kcache));

  size_t numtables, start_size, maxmem;

  if(!kcache) {

    log_err("malloc failure");

    return NULL;

  }

  numtables = cfg->key_cache_slabs;

  start_size = HASH_DEFAULT_STARTARRAY;

  maxmem = cfg->key_cache_size;

  kcache->slab = slabhash_create(numtables, start_size, maxmem,

    &key_entry_sizefunc, &key_entry_compfunc,

    &key_entry_delkeyfunc, &key_entry_deldatafunc, NULL);

  if(!kcache->slab) {

    log_err("malloc failure");

    free(kcache);

    return NULL;

  }

  return kcache;

}

void 

key_cache_delete(struct key_cache* kcache)

{

  if(!kcache)

    return;

  slabhash_delete(kcache->slab);

  free(kcache);

}

void 

key_cache_insert(struct key_cache* kcache, struct key_entry_key* kkey,

  int copy_reason)

{

  struct key_entry_key* k = key_entry_copy(kkey, copy_reason);

  if(!k)

    return;

  key_entry_hash(k);

  slabhash_insert(kcache->slab, k->entry.hash, &k->entry, 

    k->entry.data, NULL);

}

/**

 * Lookup exactly in the key cache. Returns pointer to locked entry.

 * Caller must unlock it after use.

 * @param kcache: the key cache.

 * @param name: for what name to look; uncompressed wireformat

 * @param namelen: length of the name.

 * @param key_class: class of the key.

 * @param wr: set true to get a writelock.

 * @return key entry, locked, or NULL if not found. No TTL checking is

 *  performed.

 */

static struct key_entry_key*

key_cache_search(struct key_cache* kcache, uint8_t* name, size_t namelen, 

  uint16_t key_class, int wr)

{

  struct lruhash_entry* e;

  struct key_entry_key lookfor;

  lookfor.entry.key = &lookfor;

  lookfor.name = name;

  lookfor.namelen = namelen;

  lookfor.key_class = key_class;

  key_entry_hash(&lookfor);

  e = slabhash_lookup(kcache->slab, lookfor.entry.hash, &lookfor, wr);

  if(!e) 

    return NULL;

  return (struct key_entry_key*)e->key;

}

struct key_entry_key* 

key_cache_obtain(struct key_cache* kcache, uint8_t* name, size_t namelen, 

  uint16_t key_class, struct regional* region, time_t now)

{

  /* keep looking until we find a nonexpired entry */

  while(1) {

    struct key_entry_key* k = key_cache_search(kcache, name, 

      namelen, key_class, 0);

    if(k) {

      /* see if TTL is OK */

      struct key_entry_data* d = (struct key_entry_data*)

        k->entry.data;

      if(now <= d->ttl) {

        /* copy and return it */

        struct key_entry_key* retkey =

          key_entry_copy_toregion(k, region);

        lock_rw_unlock(&k->entry.lock);

        return retkey;

      }

      lock_rw_unlock(&k->entry.lock);

    }

    /* snip off first label to continue */

    if(dname_is_root(name))

      break;

    dname_remove_label(&name, &namelen);

  }

  return NULL;

}

size_t 

key_cache_get_mem(struct key_cache* kcache)

{

  return sizeof(*kcache) + slabhash_get_mem(kcache->slab);

}

void key_cache_remove(struct key_cache* kcache,

  uint8_t* name, size_t namelen, uint16_t key_class)

{

  struct key_entry_key lookfor;

  lookfor.entry.key = &lookfor;

  lookfor.name = name;

  lookfor.namelen = namelen;

  lookfor.key_class = key_class;

  key_entry_hash(&lookfor);

  slabhash_remove(kcache->slab, lookfor.entry.hash, &lookfor);

}