nfs_ip_name.c

Go to the documentation of this file.

/*
 * vim:expandtab:shiftwidth=8:tabstop=8:
 *
 * Copyright CEA/DAM/DIF  (2008)
 * contributeur : Philippe DENIEL   philippe.deniel@cea.fr
 *                Thomas LEIBOVICI  thomas.leibovici@cea.fr
 *
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 3 of the License, or (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 * 
 * ---------------------------------------
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#ifdef _SOLARIS
#include "solaris_port.h"
#endif

#include "HashData.h"
#include "HashTable.h"
#include "log.h"
#include "nfs_core.h"
#include "nfs_exports.h"
#include "config_parsing.h"
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

/* Hashtable used to cache the hostname, accessed by their IP addess */
hash_table_t *ht_ip_name;
unsigned int expiration_time;

uint32_t ip_name_value_hash_func(hash_parameter_t * p_hparam,
                                          hash_buffer_t * buffclef)
{
  return hash_sockaddr((sockaddr_t *)buffclef->pdata, IGNORE_PORT) % p_hparam->index_size;
}

uint64_t ip_name_rbt_hash_func(hash_parameter_t * p_hparam,
                                        hash_buffer_t * buffclef)
{
  return hash_sockaddr((sockaddr_t *)buffclef->pdata, IGNORE_PORT);
}

int compare_ip_name(hash_buffer_t * buff1, hash_buffer_t * buff2)
{
  return (cmp_sockaddr((sockaddr_t *)(buff1->pdata), (sockaddr_t *)(buff2->pdata), IGNORE_PORT) != 0) ? 0 : 1;
}

int display_ip_name_key(hash_buffer_t * pbuff, char *str)
{
  sockaddr_t *addr = (sockaddr_t *)(pbuff->pdata);

  sprint_sockaddr(addr, str, HASHTABLE_DISPLAY_STRLEN);
  return strlen(str);
}

int display_ip_name_val(hash_buffer_t * pbuff, char *str)
{
  nfs_ip_name_t *nfs_ip_name = (pbuff->pdata);

  return snprintf(str, HASHTABLE_DISPLAY_STRLEN, "%s", nfs_ip_name->hostname);
}

int nfs_ip_name_add(sockaddr_t *ipaddr, char *hostname)
{
  hash_buffer_t buffkey;
  hash_buffer_t buffdata;
  nfs_ip_name_t *nfs_ip_name = NULL;
  sockaddr_t *pipaddr = NULL;
  struct timeval tv0, tv1, dur;
  int rc;
  char ipstring[SOCK_NAME_MAX];

  nfs_ip_name = gsh_malloc(sizeof(nfs_ip_name_t));

  if(nfs_ip_name == NULL)
    return IP_NAME_INSERT_MALLOC_ERROR;

  pipaddr = gsh_malloc(sizeof(sockaddr_t));
  if(pipaddr == NULL)
    {
      gsh_free(nfs_ip_name);
      return IP_NAME_INSERT_MALLOC_ERROR;
    }

  /* I have to keep an integer as key, I wil use the pointer buffkey->pdata for this, 
   * this also means that buffkey->len will be 0 */
  memcpy(pipaddr, ipaddr, sizeof(sockaddr_t));

  buffkey.pdata = (caddr_t) pipaddr;
  buffkey.len = sizeof(sockaddr_t);

  gettimeofday(&tv0, NULL) ;
  rc = getnameinfo((struct sockaddr *)pipaddr, sizeof(sockaddr_t),
                   nfs_ip_name->hostname, sizeof(nfs_ip_name->hostname),
                   NULL, 0, 0);
  gettimeofday(&tv1, NULL) ;
  timersub(&tv1, &tv0, &dur) ;


  sprint_sockaddr(pipaddr, ipstring, sizeof(ipstring));

  /* display warning if DNS resolution took more that 1.0s */
  if (dur.tv_sec >= 1)
  {
       LogEvent(COMPONENT_DISPATCH,
                "Warning: long DNS query for %s: %u.%06u sec", ipstring,
                (unsigned int)dur.tv_sec, (unsigned int)dur.tv_usec );
  }


  /* Ask for the name to be cached */
  if(rc != 0)
    {
       LogEvent(COMPONENT_DISPATCH,
                "Cannot resolve address %s, error %s",
                ipstring, gai_strerror(rc));

       gsh_free(nfs_ip_name);
       gsh_free(pipaddr);
       return IP_NAME_NETDB_ERROR;
    }

  LogDebug(COMPONENT_DISPATCH,
           "Inserting %s->%s to addr cache",
           ipstring, nfs_ip_name->hostname);

  /* I build the data with the request pointer that should be in state 'IN USE' */
  nfs_ip_name->timestamp = time(NULL);

  buffdata.pdata = (caddr_t) nfs_ip_name;
  buffdata.len = sizeof(nfs_ip_name_t);

  if(HashTable_Set(ht_ip_name, &buffkey, &buffdata) != HASHTABLE_SUCCESS)
    return IP_NAME_INSERT_MALLOC_ERROR;

  /* Copy the value for the caller */
  strncpy(hostname, nfs_ip_name->hostname, MAXHOSTNAMELEN);

  return IP_NAME_SUCCESS;
}                               /* nfs_ip_name_add */

int nfs_ip_name_get(sockaddr_t *ipaddr, char *hostname)
{
  hash_buffer_t buffkey;
  hash_buffer_t buffval;
  nfs_ip_name_t *nfs_ip_name;
  char ipstring[SOCK_NAME_MAX];

  sprint_sockaddr(ipaddr, ipstring, sizeof(ipstring));

  buffkey.pdata = (caddr_t) ipaddr;
  buffkey.len = sizeof(sockaddr_t);

  if(HashTable_Get(ht_ip_name, &buffkey, &buffval) == HASHTABLE_SUCCESS)
    {
      nfs_ip_name = (nfs_ip_name_t *) buffval.pdata;
      strncpy(hostname, nfs_ip_name->hostname, MAXHOSTNAMELEN);

      LogFullDebug(COMPONENT_DISPATCH,
                   "Cache get hit for %s->%s",
                   ipstring, nfs_ip_name->hostname);

      return IP_NAME_SUCCESS;
    }

  LogFullDebug(COMPONENT_DISPATCH,
               "Cache get miss for %s",
               ipstring);

  return IP_NAME_NOT_FOUND;
}                               /* nfs_ip_name_get */

int nfs_ip_name_remove(sockaddr_t *ipaddr)
{
  hash_buffer_t buffkey, old_value;
  nfs_ip_name_t *nfs_ip_name = NULL;
  char ipstring[SOCK_NAME_MAX];

  sprint_sockaddr(ipaddr, ipstring, sizeof(ipstring));

  buffkey.pdata = (caddr_t) ipaddr;
  buffkey.len = sizeof(sockaddr_t);

  if(HashTable_Del(ht_ip_name, &buffkey, NULL, &old_value) == HASHTABLE_SUCCESS)
    {
      nfs_ip_name = (nfs_ip_name_t *) old_value.pdata;

      LogFullDebug(COMPONENT_DISPATCH,
                   "Cache remove hit for %s->%s",
                   ipstring, nfs_ip_name->hostname);

      gsh_free(nfs_ip_name);
      return IP_NAME_SUCCESS;
    }

  LogFullDebug(COMPONENT_DISPATCH,
               "Cache remove miss for %s",
               ipstring);

  return IP_NAME_NOT_FOUND;
}                               /* nfs_ip_name_remove */

int nfs_Init_ip_name(nfs_ip_name_parameter_t param)
{
  if((ht_ip_name = HashTable_Init(&param.hash_param)) == NULL)
    {
      LogCrit(COMPONENT_INIT, "NFS IP_NAME: Cannot init IP/name cache");
      return -1;
    }

  /* Set the expiration time */
  expiration_time = param.expiration_time;

  return IP_NAME_SUCCESS;
}                               /* nfs_Init_ip_name */

int nfs_ip_name_populate(char *path)
{
  config_file_t config_file;
  config_item_t block;
  int var_max;
  int var_index;
  int err;
  char *key_name;
  char *key_value;
  char label[MAXNAMLEN];
  sockaddr_t ipaddr;
  nfs_ip_name_t *nfs_ip_name;
  sockaddr_t *pipaddr;
  hash_buffer_t buffkey;
  hash_buffer_t buffdata;

  config_file = config_ParseFile(path);

  if(!config_file)
    {
      LogCrit(COMPONENT_CONFIG, "Can't open file %s", path);

      return IP_NAME_NOT_FOUND;
    }

  /* Get the config BLOCK */
  if((block = config_FindItemByName(config_file, CONF_LABEL_IP_NAME_HOSTS)) == NULL)
    {
      LogCrit(COMPONENT_CONFIG,
              "Can't get label %s in file %s",
              CONF_LABEL_IP_NAME_HOSTS, path);
      return IP_NAME_NOT_FOUND;
    }
  else if(config_ItemType(block) != CONFIG_ITEM_BLOCK)
    {
      /* Expected to be a block */
      return IP_NAME_NOT_FOUND;
    }

  var_max = config_GetNbItems(block);

  for(var_index = 0; var_index < var_max; var_index++)
    {
      config_item_t item;

      item = config_GetItemByIndex(block, var_index);

      /* Get key's name */
      if((err = config_GetKeyValue(item, &key_name, &key_value)) != 0)
        {
          LogCrit(COMPONENT_CONFIG,
                  "Error reading key[%d] from section \"%s\" of configuration file.",
                  var_index, label);
          return IP_NAME_NOT_FOUND;
        }

      err = ipstring_to_sockaddr(key_value, &ipaddr);
      if(err != 0)
        {
          LogCrit(COMPONENT_CONFIG,
                  "Error converting %s to an ipaddress %s",
                  key_value, gai_strerror(err));
          return IP_NAME_NOT_FOUND;
        }

      /* Entry to be cached */
      nfs_ip_name = gsh_malloc(sizeof(nfs_ip_name_t));
      if(nfs_ip_name == NULL)
        return IP_NAME_INSERT_MALLOC_ERROR;

      pipaddr = gsh_malloc(sizeof(sockaddr_t));
      if(pipaddr == NULL)
        {
          gsh_free(nfs_ip_name);
          return IP_NAME_INSERT_MALLOC_ERROR;
        }

      strncpy(nfs_ip_name->hostname, key_name, MAXHOSTNAMELEN);
      nfs_ip_name->timestamp = time(NULL);
      memcpy(pipaddr, &ipaddr, sizeof(sockaddr_t));

      buffdata.pdata = (caddr_t) nfs_ip_name;
      buffdata.len = sizeof(nfs_ip_name_t);

      buffkey.pdata = (caddr_t) pipaddr;
      buffkey.len = sizeof(sockaddr_t);

      if(HashTable_Set(ht_ip_name, &buffkey, &buffdata) != HASHTABLE_SUCCESS)
        {
          gsh_free(nfs_ip_name);
          gsh_free(pipaddr);
          return IP_NAME_INSERT_MALLOC_ERROR;
        }
    }

  if(isFullDebug(COMPONENT_CONFIG))
    HashTable_Log(COMPONENT_CONFIG, ht_ip_name);

  return IP_NAME_SUCCESS;
}                               /* nfs_ip_name_populate */

void nfs_ip_name_get_stats(hash_stat_t * phstat)
{
  HashTable_GetStats(ht_ip_name, phstat);
}                               /* nfs_ip_name_get_stats */