kb.h

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2014-2023 Greenbone AG
 *
 * SPDX-License-Identifier: GPL-2.0-or-later
 */
 
#ifndef _GVM_KB_H
#define _GVM_KB_H
 
#include "../base/nvti.h" /* for nvti_t */
 
#include <assert.h>
#include <stddef.h>    /* for NULL */
#include <sys/types.h> /* for size_t */
 
#ifdef REDIS_SOCKET_PATH
#define KB_PATH_DEFAULT REDIS_SOCKET_PATH
#else
#define KB_PATH_DEFAULT "/run/redis/redis.sock"
#endif
 
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_FAMILY_POS,
  NVT_NAME_POS,
  NVT_TIMESTAMP_POS,
  NVT_OID_POS,
};
 
struct kb_item
{
  enum kb_item_type type; 
  union 
  {
    char *v_str; 
    int v_int;   
  };             
  size_t len;           
  struct kb_item *next; 
  size_t namelen; 
  char name[];    
};
 
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 *);     
  kb_t (*kb_direct_conn) (const char *, const int); 
  /* 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);
  nvti_t *(*kb_get_nvt_all) (kb_t, const char *);
  GSList *(*kb_get_nvt_oids) (kb_t);
  int (*kb_push_str) (kb_t, const char *, const char *);
  char *(*kb_pop_str) (kb_t, const char *);
  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 *, size_t);
  int (*kb_add_str_unique) (kb_t, const char *, const char *, size_t, int);
  int (*kb_add_str_unique_volatile) (kb_t, const char *, const char *, int,
                                     size_t, int);
  int (*kb_set_str) (kb_t, const char *, const char *, size_t);
  int (*kb_add_int) (kb_t, const char *, int);
  int (*kb_add_int_unique) (kb_t, const char *, int);
  int (*kb_add_int_unique_volatile) (kb_t, const char *, int, 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_save) (kb_t);                
  int (*kb_lnk_reset) (kb_t);           
  int (*kb_flush) (kb_t, const char *); 
  int (*kb_get_kb_index) (kb_t);        
};
 
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_direct_conn (const char *kb_path, const int kb_index)
{
  assert (KBDefaultOperations);
  assert (KBDefaultOperations->kb_direct_conn);
 
  return KBDefaultOperations->kb_direct_conn (kb_path, kb_index);
}
 
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_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 int
kb_item_push_str (kb_t kb, const char *name, const char *value)
{
  assert (kb);
  assert (kb->kb_ops);
  assert (kb->kb_ops->kb_push_str);
 
  return kb->kb_ops->kb_push_str (kb, name, value);
}
 
static inline char *
kb_item_pop_str (kb_t kb, const char *name)
{
  assert (kb);
  assert (kb->kb_ops);
  assert (kb->kb_ops->kb_pop_str);
 
  return kb->kb_ops->kb_pop_str (kb, name);
}
 
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, size_t len)
{
  assert (kb);
  assert (kb->kb_ops);
  assert (kb->kb_ops->kb_add_str);
 
  return kb->kb_ops->kb_add_str (kb, name, str, len);
}
 
static inline int
kb_item_add_str_unique (kb_t kb, const char *name, const char *str, size_t len,
                        int pos)
{
  assert (kb);
  assert (kb->kb_ops);
  assert (kb->kb_ops->kb_add_str_unique);
 
  return kb->kb_ops->kb_add_str_unique (kb, name, str, len, pos);
}
 
static inline int
kb_add_str_unique_volatile (kb_t kb, const char *name, const char *str,
                            int expire, size_t len, int pos)
{
  assert (kb);
  assert (KBDefaultOperations);
  assert (KBDefaultOperations->kb_add_str_unique_volatile);
 
  return KBDefaultOperations->kb_add_str_unique_volatile (kb, name, str, expire,
                                                          len, pos);
}
 
static inline int
kb_item_set_str (kb_t kb, const char *name, const char *str, size_t len)
{
  assert (kb);
  assert (kb->kb_ops);
  assert (kb->kb_ops->kb_set_str);
 
  return kb->kb_ops->kb_set_str (kb, name, str, len);
}
 
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_add_int_unique (kb_t kb, const char *name, int val)
{
  assert (kb);
  assert (kb->kb_ops);
  assert (kb->kb_ops->kb_add_int_unique);
 
  return kb->kb_ops->kb_add_int_unique (kb, name, val);
}
 
static inline int
kb_add_int_unique_volatile (kb_t kb, const char *name, int val, int expire)
{
  assert (kb);
  assert (KBDefaultOperations);
  assert (KBDefaultOperations->kb_add_int_unique_volatile);
 
  return KBDefaultOperations->kb_add_int_unique_volatile (kb, name, val,
                                                          expire);
}
 
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_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_get_nvt);
 
  return kb->kb_ops->kb_get_nvt (kb, oid, position);
}
 
static inline nvti_t *
kb_nvt_get_all (kb_t kb, const char *oid)
{
  assert (kb);
  assert (kb->kb_ops);
  assert (kb->kb_ops->kb_get_nvt_all);
 
  return kb->kb_ops->kb_get_nvt_all (kb, oid);
}
 
static inline GSList *
kb_nvt_get_oids (kb_t kb)
{
  assert (kb);
  assert (kb->kb_ops);
  assert (kb->kb_ops->kb_get_nvt_oids);
 
  return kb->kb_ops->kb_get_nvt_oids (kb);
}
 
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_save (kb_t kb)
{
  int rc = 0;
 
  assert (kb);
  assert (kb->kb_ops);
 
  if (kb->kb_ops->kb_save != NULL)
    rc = kb->kb_ops->kb_save (kb);
 
  return rc;
}
 
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;
}
 
static inline int
kb_get_kb_index (kb_t kb)
{
  assert (kb);
  assert (kb->kb_ops);
  assert (kb->kb_ops->kb_get_kb_index);
 
  return kb->kb_ops->kb_get_kb_index (kb);
}
 
#endif