kb.h

Go to the documentation of this file.

/* OpenVAS Libraries
 *
 * Authors:
 * Henri Doreau <henri.doreau@gmail.com>
 *
 * Copyright:
 * Copyright (C) 2014 - Greenbone Networks GmbH.
 *
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Knowledge base management API - Redis backend.
 */
 
#ifndef OPENVAS_KB_H
#define OPENVAS_KB_H
 
#include <assert.h>
 
#include "../base/nvti.h" /* for nvti_t */
 
#define KB_PATH_DEFAULT "/tmp/redis.sock"
 
 
enum kb_item_type {
  KB_TYPE_UNSPEC,   
  KB_TYPE_INT,      
  KB_TYPE_STR,      
  /* -- */
  KB_TYPE_CNT,
};
 
enum kb_nvt_pos {
    NVT_FILENAME_POS,
    NVT_REQUIRED_KEYS_POS,
    NVT_MANDATORY_KEYS_POS,
    NVT_EXCLUDED_KEYS_POS,
    NVT_REQUIRED_UDP_PORTS_POS,
    NVT_REQUIRED_PORTS_POS,
    NVT_DEPENDENCIES_POS,
    NVT_TAGS_POS,
    NVT_CVES_POS,
    NVT_BIDS_POS,
    NVT_XREFS_POS,
    NVT_CATEGORY_POS,
    NVT_TIMEOUT_POS,
    NVT_FAMILY_POS,
    NVT_COPYRIGHT_POS,
    NVT_NAME_POS,
    NVT_VERSION_POS,
};
 
struct kb_item
{
  enum kb_item_type type;   
  union
  {
    char *v_str;
    int v_int;
  };                    
  struct kb_item *next; 
  size_t namelen;       
  char name[0];         
};
 
struct kb_operations;
 
struct kb
{
  const struct kb_operations *kb_ops;   
};
 
typedef struct kb *kb_t;
 
struct kb_operations
{
  /* ctor/dtor */
  int (*kb_new) (kb_t *, const char *);
  int (*kb_delete) (kb_t);
  kb_t (*kb_find) (const char *, const char *);
 
  /* Actual kb operations */
  struct kb_item *(*kb_get_single) (kb_t, const char *, enum kb_item_type);
  char *(*kb_get_str) (kb_t, const char *);
  int (*kb_get_int) (kb_t, const char *);
  char *(*kb_get_nvt) (kb_t, const char *, enum kb_nvt_pos);
  struct kb_item * (*kb_get_all) (kb_t, const char *);
  struct kb_item * (*kb_get_pattern) (kb_t, const char *);
  size_t (*kb_count) (kb_t, const char *);
  int (*kb_add_str) (kb_t, const char *, const char *);
  int (*kb_set_str) (kb_t, const char *, const char *);
  int (*kb_add_int) (kb_t, const char *, int);
  int (*kb_set_int) (kb_t, const char *, int);
  int (*kb_add_nvt) (kb_t, const nvti_t *, const char *);
  int (*kb_del_items) (kb_t, const char *);
 
  /* Utils */
  int (*kb_lnk_reset) (kb_t);
  int (*kb_flush) (kb_t, const char *);
};
 
extern const struct kb_operations *KBDefaultOperations;
 
void kb_item_free (struct kb_item *);
 
 
static inline int kb_new (kb_t *kb, const char *kb_path)
{
  assert (kb);
  assert (KBDefaultOperations);
  assert (KBDefaultOperations->kb_new);
 
  *kb = NULL;
 
  return KBDefaultOperations->kb_new (kb, kb_path);
}
 
static inline kb_t kb_find (const char *kb_path, const char *key)
{
  assert (KBDefaultOperations);
  assert (KBDefaultOperations->kb_find);
 
  return KBDefaultOperations->kb_find (kb_path, key);
}
 
static inline int
kb_nvt_add (kb_t kb, const nvti_t *nvt, const char *filename)
{
  assert (kb);
  assert (kb->kb_ops);
  assert (kb->kb_ops->kb_add_nvt);
 
  return kb->kb_ops->kb_add_nvt (kb, nvt, filename);
}
 
static inline char *
kb_nvt_get (kb_t kb, const char *oid, enum kb_nvt_pos position)
{
  assert (kb);
  assert (kb->kb_ops);
  assert (kb->kb_ops->kb_add_nvt);
 
  return kb->kb_ops->kb_get_nvt (kb, oid, position);
}
 
static inline int kb_delete (kb_t kb)
{
  assert (kb);
  assert (kb->kb_ops);
  assert (kb->kb_ops->kb_delete);
 
  return kb->kb_ops->kb_delete (kb);
}
 
static inline struct kb_item *
kb_item_get_single (kb_t kb, const char *name, enum kb_item_type type)
{
  assert (kb);
  assert (kb->kb_ops);
  assert (kb->kb_ops->kb_get_single);
 
  return kb->kb_ops->kb_get_single (kb, name, type);
}
 
static inline char *
kb_item_get_str (kb_t kb, const char *name)
{
  assert (kb);
  assert (kb->kb_ops);
  assert (kb->kb_ops->kb_get_str);
 
  return kb->kb_ops->kb_get_str (kb, name);
}
 
static inline int
kb_item_get_int (kb_t kb, const char *name)
{
  assert (kb);
  assert (kb->kb_ops);
  assert (kb->kb_ops->kb_get_int);
 
  return kb->kb_ops->kb_get_int (kb, name);
}
 
static inline struct kb_item *
kb_item_get_all (kb_t kb, const char *name)
{
  assert (kb);
  assert (kb->kb_ops);
  assert (kb->kb_ops->kb_get_all);
 
  return kb->kb_ops->kb_get_all (kb, name);
}
 
static inline struct kb_item *
kb_item_get_pattern (kb_t kb, const char *pattern)
{
  assert (kb);
  assert (kb->kb_ops);
  assert (kb->kb_ops->kb_get_pattern);
 
  return kb->kb_ops->kb_get_pattern (kb, pattern);
}
 
static inline size_t
kb_item_count (kb_t kb, const char *pattern)
{
  assert (kb);
  assert (kb->kb_ops);
  assert (kb->kb_ops->kb_count);
 
  return kb->kb_ops->kb_count (kb, pattern);
}
 
static inline int
kb_item_add_str (kb_t kb, const char *name, const char *str)
{
  assert (kb);
  assert (kb->kb_ops);
  assert (kb->kb_ops->kb_add_str);
 
  return kb->kb_ops->kb_add_str (kb, name, str);
}
 
static inline int
kb_item_set_str (kb_t kb, const char *name, const char *str)
{
  assert (kb);
  assert (kb->kb_ops);
  assert (kb->kb_ops->kb_set_str);
 
  return kb->kb_ops->kb_set_str (kb, name, str);
}
 
static inline int
kb_item_add_int (kb_t kb, const char *name, int val)
{
  assert (kb);
  assert (kb->kb_ops);
  assert (kb->kb_ops->kb_add_int);
 
  return kb->kb_ops->kb_add_int (kb, name, val);
}
 
static inline int
kb_item_set_int (kb_t kb, const char *name, int val)
{
  assert (kb);
  assert (kb->kb_ops);
  assert (kb->kb_ops->kb_set_int);
 
  return kb->kb_ops->kb_set_int (kb, name, val);
}
 
static inline int
kb_del_items (kb_t kb, const char *name)
{
  assert (kb);
  assert (kb->kb_ops);
  assert (kb->kb_ops->kb_del_items);
 
  return kb->kb_ops->kb_del_items (kb, name);
}
 
static inline int kb_lnk_reset (kb_t kb)
{
  int rc = 0;
 
  assert (kb);
  assert (kb->kb_ops);
 
  if (kb->kb_ops->kb_lnk_reset != NULL)
    rc = kb->kb_ops->kb_lnk_reset (kb);
 
  return rc;
}
 
static inline int kb_flush (kb_t kb, const char *except)
{
  int rc = 0;
 
  assert (kb);
  assert (kb->kb_ops);
 
  if (kb->kb_ops->kb_flush != NULL)
    rc = kb->kb_ops->kb_flush (kb, except);
 
  return rc;
}
 
#endif