kb.c
上传用户:tjescc
上传日期:2021-02-23
资源大小:419k
文件大小:7k
源码类别:

Telnet服务器

开发平台:

Unix_Linux

  1. /* Nessuslib -- the Nessus Library
  2.  * Copyright (C) 1998 - 2003 Renaud Deraison
  3.  *
  4.  * This library is free software; you can redistribute it and/or
  5.  * modify it under the terms of the GNU Library General Public
  6.  * License as published by the Free Software Foundation; either
  7.  * version 2 of the License, or (at your option) any later version.
  8.  *
  9.  * This library is distributed in the hope that it will be useful,
  10.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12.  * Library General Public License for more details.
  13.  *
  14.  * You should have received a copy of the GNU Library General Public
  15.  * License along with this library; if not, write to the Free
  16.  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17.  *
  18.  * 
  19.  * Knowledge base management API
  20.  */ 
  21. #include <includes.h>
  22. #define HASH_MAX 65537 
  23. static unsigned int mkkey(char * name )
  24. {
  25.  char * p;
  26.  unsigned int h = 0;
  27.  if ( name == NULL )
  28. return 0;
  29.  for ( p = name ; *p != '' ; p ++ )
  30.   h = (h << 3) + (unsigned char)*p;
  31.  return h % HASH_MAX;
  32. }
  33. struct kb_item ** kb_new()
  34. {
  35.  return emalloc(HASH_MAX * sizeof(struct kb_item*));
  36. }
  37. /*
  38.  * READ the knowledge base
  39.  */
  40. struct kb_item * kb_item_get_single(struct kb_item ** kb, char * name, int type)
  41. {
  42.  unsigned int h = mkkey(name);
  43.  struct kb_item * ret;
  44.  
  45.  if ( kb == NULL || name == NULL ) return NULL;
  46.  
  47.  
  48.  ret = kb[h];
  49.  while ( ret != NULL )
  50.  {
  51.   if( (strcmp(ret->name, name) == 0) && (type == 0 || (ret->type == type)) ) return ret;
  52.   ret = ret->next;
  53.  }
  54.  
  55.  return ret;
  56. }
  57. char * kb_item_get_str(struct kb_item ** kb, char * name)
  58. {
  59.  struct kb_item * item = kb_item_get_single(kb, name, KB_TYPE_STR);
  60.  if(item == NULL) 
  61. return NULL;
  62.  else 
  63. return item->v.v_str;
  64. }
  65. int kb_item_get_int(struct kb_item ** kb, char * name)
  66. {
  67.  struct kb_item * item = kb_item_get_single(kb, name, KB_TYPE_INT);
  68.  if(item == NULL) 
  69. return -1;
  70.  else 
  71. return item->v.v_int;
  72. }
  73. struct kb_item * kb_item_get_all(struct kb_item ** kb, char * name)
  74. {
  75.  unsigned h = mkkey(name);
  76.  struct kb_item * k;
  77.  struct kb_item *ret = NULL;
  78.  
  79.  if ( kb == NULL || name ==  NULL) 
  80.     return NULL;
  81.     
  82.  k = kb[h];
  83.  while ( k != NULL )
  84.  {
  85.   if( strcmp(k->name, name) == 0 ) 
  86.         {
  87.         struct kb_item * p;
  88.         
  89.         p = emalloc(sizeof(struct kb_item));
  90.         memcpy(p, k, sizeof(struct kb_item));
  91.         p->next = ret;
  92.         ret = p;
  93.         }
  94.         k = k->next;
  95.  }
  96.  return ret;
  97. }
  98. struct kb_item * kb_item_get_pattern(struct kb_item ** kb, char * expr )
  99. {
  100.  int i;
  101.  struct kb_item * k;
  102.  struct kb_item * ret = NULL;
  103.  
  104.  if ( kb == NULL )
  105.     return NULL;
  106.  
  107.  for ( i = 0 ; i < HASH_MAX ; i ++ )
  108.  {
  109.   k = kb[i];
  110.   while ( k != NULL )
  111.   {
  112.    if( fnmatch(expr, k->name, 0) == 0)
  113.    {
  114.     struct kb_item * p;
  115.     p = emalloc(sizeof(struct kb_item));
  116.     memcpy(p, k, sizeof(struct kb_item));
  117.     p->next = ret;
  118.     ret = p;
  119.    }
  120.    k = k->next;
  121.    }
  122.   }
  123.   return ret;
  124. }
  125.  
  126. /* Free the result of kb_item_get_all() */
  127. void kb_item_get_all_free(struct kb_item * items)
  128. {
  129.  while ( items != NULL )
  130.  {
  131.   struct kb_item * next;
  132.   next = items->next;
  133.   memset(items, 0xd7, sizeof(struct kb_item));
  134.   efree(&items);
  135.   items = next;
  136.  }
  137. }
  138. /*
  139.  * WRITE to the knowledge base
  140.  */
  141.  
  142.  
  143.  
  144. static int kb_item_addset_str(struct kb_item ** kb, char * name, char * value, int replace)
  145. {
  146.  /* 
  147.   * Before we write anything to the KB, we need to make sure that the same
  148.   * (name,value) pair is not present already
  149.   */
  150.   int h = mkkey(name);
  151.   struct kb_item * item;
  152.   
  153.   if ( kb == NULL )
  154.     return -1;
  155.    
  156.   item = kb[h];
  157.   while ( item != NULL )
  158.   {
  159.    if ( strcmp(item->name, name) == 0 )
  160.    {
  161.    if(item->type == KB_TYPE_STR      && 
  162.       strcmp(item->v.v_str, value) == 0)
  163. return -1;
  164.     if ( replace != 0 )
  165.     {
  166.     if ( item->type == KB_TYPE_STR )
  167. efree(&item->v.v_str);
  168.    
  169.     item->type = KB_TYPE_STR;
  170.     item->v.v_str = estrdup(value);
  171.     return 0;
  172.     }
  173.    }
  174.    
  175.    item = item->next;
  176.   }
  177.  item = emalloc(sizeof(struct kb_item));
  178.  item->name = estrdup(name);
  179.  item->v.v_str = estrdup(value);
  180.  item->type = KB_TYPE_STR;
  181.  item->next = kb[h];
  182.  kb[h] = item;
  183.  return 0;
  184. }
  185. int kb_item_add_str(struct kb_item ** kb, char * name, char * value)
  186. {
  187.  return kb_item_addset_str(kb, name, value, 0); 
  188. }
  189. int kb_item_set_str(struct kb_item ** kb, char * name, char * value)
  190. {
  191.  return kb_item_addset_str(kb, name, value, 1); 
  192. }
  193. /* Replace an old value in the KB by a new one */
  194. static int kb_item_addset_int(struct kb_item ** kb, char * name, int value, int replace)
  195. {
  196.  /* 
  197.   * Before we write anything to the KB, we need to make sure that the same
  198.   * (name,value) pair is not present already
  199.   */
  200.   int h = mkkey(name);
  201.   struct kb_item * item;
  202.   
  203.   if ( kb == NULL )
  204.     return -1;
  205.     
  206.    
  207.   item  = kb[h];
  208.   while ( item != NULL )
  209.   {
  210.    if ( strcmp(item->name, name) == 0 )
  211.    {
  212.     if(item->type == KB_TYPE_INT      && 
  213.       item->v.v_int == value)
  214. return -1;
  215.     if ( replace != 0 )
  216.     {
  217.     if ( item->type == KB_TYPE_STR )
  218. efree(&item->v.v_str);
  219.    
  220.     item->type = KB_TYPE_INT;
  221.     item->v.v_int = value;
  222.     return 0;
  223.     }
  224.    }
  225.     
  226.    item = item->next;
  227.   }
  228.  item = emalloc(sizeof(struct kb_item));
  229.  item->name = estrdup(name);
  230.  item->v.v_int = value;
  231.  item->type = KB_TYPE_INT;
  232.  item->next = kb[h];
  233.  kb[h] = item;
  234.  return 0;
  235. }
  236. int kb_item_set_int(struct kb_item ** kb, char * name, int value)
  237. {
  238.  return kb_item_addset_int(kb, name, value, 1);
  239. }
  240.    
  241. int kb_item_add_int(struct kb_item ** kb, char * name, int value)
  242. {
  243.  return kb_item_addset_int(kb, name, value, 0);
  244. }
  245. void kb_item_rm_all(struct kb_item ** kb, char * name)
  246. {
  247.  int h = mkkey(name);
  248.  struct kb_item * k, * prev = NULL;
  249.  
  250.  if ( kb == NULL )
  251.     return;
  252.     
  253.  k = kb[h];
  254.  while ( k != NULL )
  255.  {
  256.   if(strcmp(k->name, name) == 0)
  257.   {
  258.    struct kb_item * next;
  259.    if(k->type == ARG_STRING)
  260.     efree(&k->v.v_str);
  261.    
  262.    efree(&k->name);
  263.    next = k->next; 
  264.    efree(&k);
  265.    if(prev != NULL) prev->next = next;
  266.    else kb[h] = next;
  267.    k = next; 
  268.   }
  269.   else {
  270.     prev = k;
  271.     k = k->next;
  272.     }
  273.  }
  274. }
  275. /*
  276.  * Backward compatibilty 
  277.  */
  278. struct arglist * plug_get_oldstyle_kb(struct arglist * desc )
  279. {
  280.  struct kb_item ** kb = arg_get_value(desc, "key");
  281.  struct arglist * ret;
  282.  struct kb_item * k;
  283.  int i;
  284.  if ( kb == NULL )
  285. return NULL;
  286.  ret = emalloc ( sizeof(struct arglist) );
  287.  for ( i = 0 ; i < HASH_MAX ; i ++ )
  288.  {
  289.   k = kb[i];
  290.   while ( k != NULL )
  291.   {
  292.   if ( k->type == KB_TYPE_INT )
  293. arg_add_value(ret, k->name, ARG_INT, -1, (void*)k->v.v_int);
  294.   else if ( k->type == KB_TYPE_STR )
  295. arg_add_value(ret, k->name, ARG_STRING, strlen(k->v.v_str), estrdup(k->v.v_str));
  296.    k = k->next;
  297.   }
  298.  }
  299.  return ret;
  300. }