kb.c File Reference

Knowledge base management API - Redis backend. More...

#include "kb.h"
#include <errno.h>
#include <glib.h>
#include <hiredis/hiredis.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

Include dependency graph for kb.c:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	kb_redis
	Subclass of struct kb, it contains the redis-specific fields, such as the redis context, current DB (namespace) id and the server socket path. More...

Macros
#define	_GNU_SOURCE
#define	G_LOG_DOMAIN   "libgvm util"
	GLib logging domain.
#define	memdup   g_memdup
#define	GLOBAL_DBINDEX_NAME   "GVM.__GlobalDBIndex"
	Name of the namespace usage bitmap in redis.
#define	redis_kb(__kb)

Functions
static int	redis_delete_all (struct kb_redis *kbr)
	Delete all the KB's content.
static int	redis_lnk_reset (kb_t kb)
	Reset connection to the KB. This is called after each fork() to make sure connections aren't shared between concurrent processes.
static int	redis_flush_all (kb_t kb, const char *except)
	Flush all the KB's content. Delete all namespaces.
static redisReply *	redis_cmd (struct kb_redis *kbr, const char *fmt,...)
	Execute a redis command and get a redis reply.
static int	try_database_index (struct kb_redis *kbr, int index)
	Attempt to atomically acquire ownership of a database.
static int	fetch_max_db_index (struct kb_redis *kbr)
	Set the number of databases have been configured into kbr struct.
static int	select_database (struct kb_redis *kbr)
	Select DB.
static int	redis_release_db (struct kb_redis *kbr)
	Release DB.
static char *	parse_port_of_addr (const char *addr, int tcp_indicator_len)
static redisContext *	connect_redis (const char *addr, int len)
static int	get_redis_ctx (struct kb_redis *kbr)
	Get redis context if it is already connected or do a a connection.
static int	redis_test_connection (struct kb_redis *kbr)
	Test redis connection.
static int	redis_delete (kb_t kb)
	Delete all entries and release ownership on the namespace.
static int	redis_get_kb_index (kb_t kb)
	Return the kb index.
static int	redis_memory_purge (kb_t kb)
	Attempt to purge dirty pages.
static int	redis_new (kb_t *kb, const char *kb_path)
	Initialize a new Knowledge Base object.
static kb_t	redis_direct_conn (const char *kb_path, const int kb_index)
	Connect to a Knowledge Base object with the given kb_index.
static kb_t	redis_find (const char *kb_path, const char *key)
	Find an existing Knowledge Base object with key.
void	kb_item_free (struct kb_item *item)
	Release a KB item (or a list).
static struct kb_item *	redis2kbitem_single (const char *name, const redisReply *elt, int force_int)
	Give a single KB item.
static struct kb_item *	redis2kbitem (const char *name, const redisReply *rep)
	Fetch a KB item or list from a redis Reply.
static struct kb_item *	redis_get_single (kb_t kb, const char *name, enum kb_item_type type)
	Get a single KB element.
static char *	redis_get_str (kb_t kb, const char *name)
	Get a single KB string item.
static int	redis_push_str (kb_t kb, const char *name, const char *value)
	Push a new entry under a given key.
static char *	redis_pop_str (kb_t kb, const char *name)
	Pops a single KB string item.
static int	redis_get_int (kb_t kb, const char *name)
	Get a single KB integer item.
static char *	redis_get_nvt (kb_t kb, const char *oid, enum kb_nvt_pos position)
	Get field of a NVT.
static nvti_t *	redis_get_nvt_all (kb_t kb, const char *oid)
	Get a full NVT.
static struct kb_item *	redis_get_all (kb_t kb, const char *name)
	Get all items stored under a given name.
static struct kb_item *	redis_get_pattern (kb_t kb, const char *pattern)
	Get all items stored under a given pattern.
static GSList *	redis_get_oids (kb_t kb)
	Get all NVT OIDs.
static size_t	redis_count (kb_t kb, const char *pattern)
	Count all items stored under a given pattern.
static int	redis_del_items (kb_t kb, const char *name)
	Delete all entries under a given name.
static int	redis_add_str_unique_volatile (kb_t kb, const char *name, const char *str, int expire, size_t len, int pos)
	Insert (append) a new unique and volatile entry under a given name.
static int	redis_add_str_unique (kb_t kb, const char *name, const char *str, size_t len, int pos)
	Insert (append) a new unique entry under a given name.
static int	redis_add_str (kb_t kb, const char *name, const char *str, size_t len)
	Insert (append) a new entry under a given name.
static int	redis_set_str (kb_t kb, const char *name, const char *val, size_t len)
	Set (replace) a new entry under a given name.
static int	redis_add_int_unique_volatile (kb_t kb, const char *name, int val, int expire)
	Insert (append) a new unique entry under a given name.
static int	redis_add_int_unique (kb_t kb, const char *name, int val)
	Insert (append) a new unique entry under a given name.
static int	redis_add_int (kb_t kb, const char *name, int val)
	Insert (append) a new entry under a given name.
static int	redis_set_int (kb_t kb, const char *name, int val)
	Set (replace) a new entry under a given name.
static int	redis_add_nvt (kb_t kb, const nvti_t *nvt, const char *filename)
	Insert a new nvt.
static int	redis_save (kb_t kb)
	Save all the elements from the KB.

Variables
static const struct kb_operations	KBRedisOperations
	Default KB operations.
const struct kb_operations *	KBDefaultOperations = &KBRedisOperations
	Default KB operations. No selection mechanism is provided yet since there's only one implementation (redis-based).

Detailed Description

Knowledge base management API - Redis backend.

Contains specialized structures and functions to use redis as a KB server.

Definition in file kb.c.

Macro Definition Documentation

_GNU_SOURCE

#define _GNU_SOURCE

Definition at line 11 of file kb.c.

G_LOG_DOMAIN

#define G_LOG_DOMAIN   "libgvm util"

GLib logging domain.

Definition at line 27 of file kb.c.

GLOBAL_DBINDEX_NAME

#define GLOBAL_DBINDEX_NAME   "GVM.__GlobalDBIndex"

Name of the namespace usage bitmap in redis.

Definition at line 45 of file kb.c.

Referenced by redis_find(), redis_flush_all(), redis_release_db(), and try_database_index().

memdup

#define memdup   g_memdup

Definition at line 32 of file kb.c.

Referenced by redis2kbitem_single().

redis_kb

#define redis_kb

(

__kb

)

Value:

((struct kb_redis *) (__kb))

Definition at line 62 of file kb.c.

Referenced by redis_add_int(), redis_add_int_unique(), redis_add_int_unique_volatile(), redis_add_nvt(), redis_add_str(), redis_add_str_unique(), redis_add_str_unique_volatile(), redis_count(), redis_del_items(), redis_delete(), redis_flush_all(), redis_get_all(), redis_get_nvt(), redis_get_nvt_all(), redis_get_oids(), redis_get_pattern(), redis_get_single(), redis_lnk_reset(), redis_memory_purge(), redis_pop_str(), redis_push_str(), redis_save(), redis_set_int(), and redis_set_str().

Function Documentation

connect_redis()

redisContext * connect_redis ( const char * addr, int len )

static

Definition at line 264 of file kb.c.

{
  const char *tcp_indicator = "tcp://";
  const int tcp_indicator_len = strlen (tcp_indicator);
  const int redis_default_port = 6379;
 
  int port, host_len;
  char *tmp, *host;
  redisContext *result;
  static int warn_flag = 0;
 
  if (len < tcp_indicator_len + 1)
    goto unix_connect;
  if (memcmp (addr, tcp_indicator, tcp_indicator_len) != 0)
    goto unix_connect;
  host_len = len - tcp_indicator_len;
  tmp = parse_port_of_addr (addr, tcp_indicator_len);
  if (tmp == NULL)
    port = redis_default_port;
  else
    {
      port = atoi (tmp);
      host_len -= strlen (tmp) + 1;
    }
  host = calloc (1, host_len);
  memmove (host, addr + tcp_indicator_len, host_len);
  result = redisConnect (host, port);
  if (warn_flag == 0)
    {
      g_warning ("A Redis TCP connection is being used. This feature is "
                 "experimental and insecure, since it is not an encrypted "
                 "channel. We discourage its usage in production environments");
      warn_flag = 1;
    }
  free (host);
  return result;
unix_connect:
  return redisConnectUnix (addr);
}

References parse_port_of_addr().

Referenced by get_redis_ctx(), redis_direct_conn(), redis_find(), and redis_flush_all().

Here is the call graph for this function:

Here is the caller graph for this function:

fetch_max_db_index()

int fetch_max_db_index ( struct kb_redis * kbr )

static

Set the number of databases have been configured into kbr struct.

Parameters

[in]

kbr

Subclass of struct kb where to save the max db index founded.

Returns

0 on success, -1 on error.

Definition at line 109 of file kb.c.

{
  int rc = 0;
  redisContext *ctx = kbr->rctx;
  redisReply *rep = NULL;
 
  rep = redisCommand (ctx, "CONFIG GET databases");
  if (rep == NULL)
    {
      g_log (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
             "%s: redis command failed with '%s'", __func__, ctx->errstr);
      rc = -1;
      goto err_cleanup;
    }
 
  if (rep->type != REDIS_REPLY_ARRAY)
    {
      g_log (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
             "%s: cannot retrieve max DB number: %s", __func__, rep->str);
      rc = -1;
      goto err_cleanup;
    }
 
  if (rep->elements == 2)
    {
      kbr->max_db = (unsigned) atoi (rep->element[1]->str);
    }
  else
    {
      g_log (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
             "%s: unexpected reply length (%zd)", __func__, rep->elements);
      rc = -1;
      goto err_cleanup;
    }
 
  g_debug ("%s: maximum DB number: %u", __func__, kbr->max_db);
 
err_cleanup:
  if (rep != NULL)
    freeReplyObject (rep);
 
  return rc;
}

References G_LOG_DOMAIN, kb_redis::max_db, and kb_redis::rctx.

Referenced by redis_find(), and select_database().

Here is the caller graph for this function:

get_redis_ctx()

int get_redis_ctx ( struct kb_redis * kbr )

static

Get redis context if it is already connected or do a a connection.

Parameters

[in]

kbr

Subclass of struct kb where to fetch the context. or where it is saved in case of a new connection.

Returns

0 on success, -1 on connection error, -2 on unavailable DB slot.

Definition at line 314 of file kb.c.

{
  int rc;
 
  if (kbr->rctx != NULL)
    return 0;
 
  kbr->rctx = connect_redis (kbr->path, strlen (kbr->path));
  if (kbr->rctx == NULL || kbr->rctx->err)
    {
      g_log (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
             "%s: redis connection error to %s: %s", __func__, kbr->path,
             kbr->rctx ? kbr->rctx->errstr : strerror (ENOMEM));
      redisFree (kbr->rctx);
      kbr->rctx = NULL;
      return -1;
    }
 
  rc = select_database (kbr);
  if (rc)
    {
      g_log (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "No redis DB available");
      redisFree (kbr->rctx);
      kbr->rctx = NULL;
      return -2;
    }
 
  g_debug ("%s: connected to redis://%s/%d", __func__, kbr->path, kbr->db);
  return 0;
}

References connect_redis(), kb_redis::db, G_LOG_DOMAIN, kb_redis::path, kb_redis::rctx, and select_database().

Referenced by redis_add_int_unique(), redis_add_int_unique_volatile(), redis_add_str_unique(), redis_add_str_unique_volatile(), redis_cmd(), redis_get_pattern(), redis_new(), redis_set_int(), and redis_set_str().

Here is the call graph for this function:

Here is the caller graph for this function:

kb_item_free()

void kb_item_free

(

struct kb_item *

item

)

Release a KB item (or a list).

Parameters

[in]

item

Item or list to be release

Definition at line 642 of file kb.c.

{
  while (item != NULL)
    {
      struct kb_item *next;
 
      next = item->next;
      if (item->type == KB_TYPE_STR && item->v_str != NULL)
        g_free (item->v_str);
      g_free (item);
      item = next;
    }
}

References KB_TYPE_STR, kb_item::next, kb_item::type, and kb_item::v_str.

Referenced by nvticache_get_prefs(), redis_get_int(), and redis_get_str().

Here is the caller graph for this function:

parse_port_of_addr()

char * parse_port_of_addr ( const char * addr, int tcp_indicator_len )

inlinestatic

Definition at line 250 of file kb.c.

{
  char *tmp;
  int is_ip_v6;
  tmp = strrchr (addr + tcp_indicator_len, ':');
  if (tmp == NULL)
    return NULL;
  is_ip_v6 = addr[tcp_indicator_len] == '[';
  if (is_ip_v6 && (tmp - 1)[0] != ']')
    return NULL;
  return tmp + 1;
}

Referenced by connect_redis(), Ensure(), Ensure(), Ensure(), and main().

Here is the caller graph for this function:

redis2kbitem()

struct kb_item * redis2kbitem ( const char * name, const redisReply * rep )

static

Fetch a KB item or list from a redis Reply.

Parameters

[in]	name	Name of the item.
[in]	rep	A redisReply element where to fetch the item.

Returns

kb_item or list on success, NULL otherwise.

Definition at line 711 of file kb.c.

{
  struct kb_item *kbi;
 
  kbi = NULL;
 
  switch (rep->type)
    {
      unsigned int i;
 
    case REDIS_REPLY_STRING:
    case REDIS_REPLY_INTEGER:
      kbi = redis2kbitem_single (name, rep, 0);
      break;
 
    case REDIS_REPLY_ARRAY:
      for (i = 0; i < rep->elements; i++)
        {
          struct kb_item *tmpitem;
 
          tmpitem = redis2kbitem_single (name, rep->element[i], 0);
          if (tmpitem == NULL)
            break;
 
          if (kbi != NULL)
            {
              tmpitem->next = kbi;
              kbi = tmpitem;
            }
          else
            kbi = tmpitem;
        }
      break;
 
    case REDIS_REPLY_NIL:
    case REDIS_REPLY_STATUS:
    case REDIS_REPLY_ERROR:
    default:
      break;
    }
 
  return kbi;
}

References kb_item::name, kb_item::next, and redis2kbitem_single().

Referenced by redis_get_all(), and redis_get_pattern().

Here is the call graph for this function:

Here is the caller graph for this function:

redis2kbitem_single()

struct kb_item * redis2kbitem_single ( const char * name, const redisReply * elt, int force_int )

static

Give a single KB item.

Parameters

[in]	name	Name of the item.
[in]	elt	A redisReply element where to fetch the item.
[in]	force_int	To force string to integer conversion.

Returns

Single retrieve kb_item on success, NULL otherwise.

Definition at line 666 of file kb.c.

{
  struct kb_item *item;
  size_t namelen;
 
  if (elt->type != REDIS_REPLY_STRING && elt->type != REDIS_REPLY_INTEGER)
    return NULL;
 
  namelen = strlen (name) + 1;
 
  item = g_malloc0 (sizeof (struct kb_item) + namelen);
  if (elt->type == REDIS_REPLY_INTEGER)
    {
      item->type = KB_TYPE_INT;
      item->v_int = elt->integer;
    }
  else if (force_int)
    {
      item->type = KB_TYPE_INT;
      item->v_int = atoi (elt->str);
    }
  else
    {
      item->type = KB_TYPE_STR;
      item->v_str = memdup (elt->str, elt->len + 1);
      item->len = elt->len;
    }
 
  item->next = NULL;
  item->namelen = namelen;
  memset (item->name, 0, namelen);
  memcpy (item->name, name, namelen);
 
  return item;
}

References KB_TYPE_INT, KB_TYPE_STR, kb_item::len, memdup, kb_item::name, kb_item::namelen, kb_item::next, kb_item::type, kb_item::v_int, and kb_item::v_str.

Referenced by redis2kbitem(), and redis_get_single().

Here is the caller graph for this function:

redis_add_int()

int redis_add_int ( kb_t kb, const char * name, int val )

static

Insert (append) a new entry under a given name.

Parameters

[in]	kb	KB handle where to store the item.
[in]	name	Item name.
[in]	val	Item value.

Returns

0 on success, non-null on error.

Definition at line 1546 of file kb.c.

{
  redisReply *rep;
  int rc = 0;
 
  rep = redis_cmd (redis_kb (kb), "RPUSH %s %d", name, val);
  if (!rep || rep->type == REDIS_REPLY_ERROR)
    rc = -1;
  if (rep)
    freeReplyObject (rep);
 
  return rc;
}

References redis_cmd(), and redis_kb.

Here is the call graph for this function:

redis_add_int_unique()

int redis_add_int_unique ( kb_t kb, const char * name, int val )

static

Insert (append) a new unique entry under a given name.

Parameters

[in]	kb	KB handle where to store the item.
[in]	name	Item name.
[in]	val	Item value.

Returns

0 on success, non-null on error.

Definition at line 1505 of file kb.c.

{
  struct kb_redis *kbr;
  redisReply *rep;
  int rc = 0;
  redisContext *ctx;
 
  kbr = redis_kb (kb);
  if (get_redis_ctx (kbr) < 0)
    return -1;
  ctx = kbr->rctx;
  redisAppendCommand (ctx, "LREM %s 1 %d", name, val);
  redisAppendCommand (ctx, "RPUSH %s %d", name, val);
  redisGetReply (ctx, (void **) &rep);
  if (rep && rep->type == REDIS_REPLY_INTEGER && rep->integer == 1)
    g_debug ("Key '%s' already contained integer '%d'", name, val);
  freeReplyObject (rep);
  redisGetReply (ctx, (void **) &rep);
  if (rep == NULL || rep->type == REDIS_REPLY_ERROR)
    {
      rc = -1;
      goto out;
    }
 
out:
  if (rep != NULL)
    freeReplyObject (rep);
 
  return rc;
}

References get_redis_ctx(), kb_redis::rctx, and redis_kb.

Here is the call graph for this function:

redis_add_int_unique_volatile()

int redis_add_int_unique_volatile ( kb_t kb, const char * name, int val, int expire )

static

Insert (append) a new unique entry under a given name.

Parameters

[in]	kb	KB handle where to store the item.
[in]	name	Item name.
[in]	val	Item value.
[in]	expire	Item expire.

Returns

0 on success, non-null on error.

Definition at line 1452 of file kb.c.

{
  struct kb_redis *kbr;
  redisReply *rep;
  int rc = 0;
  redisContext *ctx;
 
  kbr = redis_kb (kb);
  if (get_redis_ctx (kbr) < 0)
    return -1;
  ctx = kbr->rctx;
  redisAppendCommand (ctx, "LREM %s 1 %d", name, val);
  redisAppendCommand (ctx, "RPUSH %s %d", name, val);
  redisAppendCommand (ctx, "EXPIRE %s %d", name, expire);
  /* Check LREM reply. */
  redisGetReply (ctx, (void **) &rep);
  if (rep && rep->type == REDIS_REPLY_INTEGER && rep->integer == 1)
    g_debug ("Key '%s' already contained integer '%d'", name, val);
  freeReplyObject (rep);
  /* Check PUSH reply. */
  redisGetReply (ctx, (void **) &rep);
  if (rep == NULL || rep->type == REDIS_REPLY_ERROR)
    {
      rc = -1;
      goto out;
    }
  /* Check EXPIRE reply. */
  redisGetReply (ctx, (void **) &rep);
  if (rep == NULL || rep->type == REDIS_REPLY_ERROR
      || (rep && rep->type == REDIS_REPLY_INTEGER && rep->integer != 1))
    {
      g_warning ("%s: Not able to set expire", __func__);
      rc = -1;
      goto out;
    }
 
out:
  if (rep != NULL)
    freeReplyObject (rep);
 
  return rc;
}

References get_redis_ctx(), kb_redis::rctx, and redis_kb.

Here is the call graph for this function:

redis_add_nvt()

int redis_add_nvt ( kb_t kb, const nvti_t * nvt, const char * filename )

static

Insert a new nvt.

Parameters

[in]	kb	KB handle where to store the nvt.
[in]	nvt	nvt to store.
[in]	filename	Path to nvt to store.

Returns

0 on success, non-null on error.

Definition at line 1607 of file kb.c.

{
  struct kb_redis *kbr;
  redisReply *rep = NULL;
  int rc = 0;
  unsigned int i;
  gchar *cves, *bids, *xrefs;
 
  if (!nvt || !filename)
    return -1;
 
  cves = nvti_refs (nvt, "cve", "", 0);
  bids = nvti_refs (nvt, "bid", "", 0);
  xrefs = nvti_refs (nvt, NULL, "cve,bid", 1);
 
  kbr = redis_kb (kb);
  rep = redis_cmd (
    kbr, "RPUSH nvt:%s %s %s %s %s %s %s %s %s %s %s %s %d %s %s",
    nvti_oid (nvt), filename,
    nvti_required_keys (nvt) ? nvti_required_keys (nvt) : "",
    nvti_mandatory_keys (nvt) ? nvti_mandatory_keys (nvt) : "",
    nvti_excluded_keys (nvt) ? nvti_excluded_keys (nvt) : "",
    nvti_required_udp_ports (nvt) ? nvti_required_udp_ports (nvt) : "",
    nvti_required_ports (nvt) ? nvti_required_ports (nvt) : "",
    nvti_dependencies (nvt) ? nvti_dependencies (nvt) : "",
    nvti_tag (nvt) ? nvti_tag (nvt) : "", cves ? cves : "", bids ? bids : "",
    xrefs ? xrefs : "", nvti_category (nvt), nvti_family (nvt),
    nvti_name (nvt));
  g_free (cves);
  g_free (bids);
  g_free (xrefs);
  if (rep == NULL || rep->type == REDIS_REPLY_ERROR)
    rc = -1;
  if (rep != NULL)
    freeReplyObject (rep);
 
  if (nvti_pref_len (nvt))
    redis_cmd (kbr, "DEL oid:%s:prefs", nvti_oid (nvt));
  for (i = 0; i < nvti_pref_len (nvt); i++)
    {
      const nvtpref_t *pref = nvti_pref (nvt, i);
 
      rep = redis_cmd (kbr, "RPUSH oid:%s:prefs %d|||%s|||%s|||%s",
                       nvti_oid (nvt), nvtpref_id (pref), nvtpref_name (pref),
                       nvtpref_type (pref), nvtpref_default (pref));
      if (!rep || rep->type == REDIS_REPLY_ERROR)
        rc = -1;
      if (rep)
        freeReplyObject (rep);
    }
  rep = redis_cmd (kbr, "RPUSH filename:%s %lu %s", filename, time (NULL),
                   nvti_oid (nvt));
  if (!rep || rep->type == REDIS_REPLY_ERROR)
    rc = -1;
  if (rep)
    freeReplyObject (rep);
  return rc;
}

References nvti_category(), nvti_dependencies(), nvti_excluded_keys(), nvti_family(), nvti_mandatory_keys(), nvti_name(), nvti_oid(), nvti_pref(), nvti_pref_len(), nvti_refs(), nvti_required_keys(), nvti_required_ports(), nvti_required_udp_ports(), nvti_tag(), nvtpref_default(), nvtpref_id(), nvtpref_name(), nvtpref_type(), redis_cmd(), and redis_kb.

Here is the call graph for this function:

redis_add_str()

int redis_add_str ( kb_t kb, const char * name, const char * str, size_t len )

static

Insert (append) a new entry under a given name.

Parameters

[in]	kb	KB handle where to store the item.
[in]	name	Item name.
[in]	str	Item value.
[in]	len	Value length. Used for blobs.

Returns

0 on success, non-null on error.

Definition at line 1381 of file kb.c.

{
  struct kb_redis *kbr;
  redisReply *rep;
  int rc = 0;
 
  kbr = redis_kb (kb);
  if (len == 0)
    rep = redis_cmd (kbr, "RPUSH %s %s", name, str);
  else
    rep = redis_cmd (kbr, "RPUSH %s %b", name, str, len);
  if (!rep || rep->type == REDIS_REPLY_ERROR)
    rc = -1;
 
  if (rep)
    freeReplyObject (rep);
  return rc;
}

References redis_cmd(), and redis_kb.

Here is the call graph for this function:

redis_add_str_unique()

int redis_add_str_unique ( kb_t kb, const char * name, const char * str, size_t len, int pos )

static

Insert (append) a new unique entry under a given name.

Parameters

[in]	kb	KB handle where to store the item.
[in]	name	Item name.
[in]	str	Item value.
[in]	len	Value length. Used for blobs.
[in]	pos	Which position the value is appended to. 0 for right, 1 for left position in the list.

Returns

0 on success, non-null on error.

Definition at line 1323 of file kb.c.

{
  struct kb_redis *kbr;
  redisReply *rep = NULL;
  int rc = 0;
  redisContext *ctx;
 
  kbr = redis_kb (kb);
  if (get_redis_ctx (kbr) < 0)
    return -1;
  ctx = kbr->rctx;
 
  /* Some VTs still rely on values being unique (ie. a value inserted multiple
   * times, will only be present once.)
   * Once these are fixed, the LREM becomes redundant and should be removed.
   */
  if (len == 0)
    {
      redisAppendCommand (ctx, "LREM %s 1 %s", name, str);
      redisAppendCommand (ctx, "%s %s %s", pos ? "LPUSH" : "RPUSH", name, str);
      redisGetReply (ctx, (void **) &rep);
      if (rep && rep->type == REDIS_REPLY_INTEGER && rep->integer == 1)
        g_debug ("Key '%s' already contained value '%s'", name, str);
      freeReplyObject (rep);
      redisGetReply (ctx, (void **) &rep);
    }
  else
    {
      redisAppendCommand (ctx, "LREM %s 1 %b", name, str, len);
      redisAppendCommand (ctx, "%s %s %b", pos ? "LPUSH" : "RPUSH", name, str,
                          len);
      redisGetReply (ctx, (void **) &rep);
      if (rep && rep->type == REDIS_REPLY_INTEGER && rep->integer == 1)
        g_debug ("Key '%s' already contained string '%s'", name, str);
      freeReplyObject (rep);
      redisGetReply (ctx, (void **) &rep);
    }
  if (rep == NULL || rep->type == REDIS_REPLY_ERROR)
    rc = -1;
 
  if (rep != NULL)
    freeReplyObject (rep);
 
  return rc;
}

References get_redis_ctx(), kb_redis::rctx, and redis_kb.

Here is the call graph for this function:

redis_add_str_unique_volatile()

int redis_add_str_unique_volatile ( kb_t kb, const char * name, const char * str, int expire, size_t len, int pos )

static

Insert (append) a new unique and volatile entry under a given name.

Parameters

[in]	kb	KB handle where to store the item.
[in]	name	Item name.
[in]	str	Item value.
[in]	expire	Item expire.
[in]	len	Value length. Used for blobs.
[in]	pos	Which position the value is appended to. 0 for right, 1 for left position in the list.

Returns

0 on success, -1 on error.

Definition at line 1230 of file kb.c.

{
  struct kb_redis *kbr;
  redisReply *rep = NULL;
  int rc = 0;
  redisContext *ctx;
 
  kbr = redis_kb (kb);
  if (get_redis_ctx (kbr) < 0)
    return -1;
  ctx = kbr->rctx;
 
  /* Some VTs still rely on values being unique (ie. a value inserted multiple
   * times, will only be present once.)
   * Once these are fixed, the LREM becomes redundant and should be removed.
   */
  if (len == 0)
    {
      redisAppendCommand (ctx, "LREM %s 1 %s", name, str);
      redisAppendCommand (ctx, "%s %s %s", pos ? "LPUSH" : "RPUSH", name, str);
      redisAppendCommand (ctx, "EXPIRE %s %d", name, expire);
      /* Check LREM reply. */
      redisGetReply (ctx, (void **) &rep);
      if (rep && rep->type == REDIS_REPLY_INTEGER && rep->integer == 1)
        g_debug ("Key '%s' already contained value '%s'", name, str);
      freeReplyObject (rep);
      /* Check PUSH reply. */
      redisGetReply (ctx, (void **) &rep);
      if (rep == NULL || rep->type == REDIS_REPLY_ERROR)
        {
          rc = -1;
          goto out;
        }
      /* Check EXPIRE reply. */
      redisGetReply (ctx, (void **) &rep);
      if (rep == NULL || rep->type == REDIS_REPLY_ERROR
          || (rep && rep->type == REDIS_REPLY_INTEGER && rep->integer != 1))
        {
          g_warning ("%s: Not able to set expire", __func__);
          rc = -1;
          goto out;
        }
    }
  else
    {
      redisAppendCommand (ctx, "LREM %s 1 %b", name, str, len);
      redisAppendCommand (ctx, "%s %s %b", pos ? "LPUSH" : "RPUSH", name, str,
                          len);
      redisAppendCommand (ctx, "EXPIRE %s %d", name, expire);
      /* Check LREM reply. */
      redisGetReply (ctx, (void **) &rep);
      if (rep && rep->type == REDIS_REPLY_INTEGER && rep->integer == 1)
        g_debug ("Key '%s' already contained string '%s'", name, str);
      freeReplyObject (rep);
      /* Check PUSH reply. */
      redisGetReply (ctx, (void **) &rep);
      if (rep == NULL || rep->type == REDIS_REPLY_ERROR)
        {
          rc = -1;
          goto out;
        }
      /* Check EXPIRE reply. */
      redisGetReply (ctx, (void **) &rep);
      if (rep == NULL || rep->type == REDIS_REPLY_ERROR
          || (rep && rep->type == REDIS_REPLY_INTEGER && rep->integer != 1))
        {
          g_warning ("%s: Not able to set expire", __func__);
          rc = -1;
          goto out;
        }
    }
 
out:
  if (rep != NULL)
    freeReplyObject (rep);
 
  return rc;
}

References get_redis_ctx(), kb_redis::rctx, and redis_kb.

Here is the call graph for this function:

redis_cmd()

redisReply * redis_cmd ( struct kb_redis * kbr, const char * fmt, ... )

static

Execute a redis command and get a redis reply.

Parameters

[in]	kbr	Subclass of struct kb to connect to.
[in]	fmt	Formatted variable argument list with the cmd to be executed.

Returns

Redis reply on success, NULL otherwise.

Definition at line 764 of file kb.c.

{
  redisReply *rep;
  va_list ap, aq;
  int retry = 0;
 
  va_start (ap, fmt);
  do
    {
      if (get_redis_ctx (kbr) < 0)
        {
          va_end (ap);
          return NULL;
        }
 
      va_copy (aq, ap);
      rep = redisvCommand (kbr->rctx, fmt, aq);
      va_end (aq);
 
      if (kbr->rctx->err)
        {
          if (rep != NULL)
            freeReplyObject (rep);
 
          redis_lnk_reset ((kb_t) kbr);
          retry = !retry;
        }
      else
        retry = 0;
    }
  while (retry);
 
  va_end (ap);
 
  return rep;
}

References get_redis_ctx(), kb_redis::rctx, and redis_lnk_reset().

Referenced by redis_add_int(), redis_add_nvt(), redis_add_str(), redis_count(), redis_del_items(), redis_delete_all(), redis_get_all(), redis_get_nvt(), redis_get_nvt_all(), redis_get_oids(), redis_get_pattern(), redis_get_single(), redis_memory_purge(), redis_pop_str(), redis_push_str(), redis_save(), and redis_test_connection().

Here is the call graph for this function:

Here is the caller graph for this function:

redis_count()

size_t redis_count ( kb_t kb, const char * pattern )

static

Count all items stored under a given pattern.

Parameters

[in]	kb	KB handle where to count the items.
[in]	pattern	'*' pattern of the elements to count.

Returns

Count of items.

Definition at line 1166 of file kb.c.

{
  struct kb_redis *kbr;
  redisReply *rep;
  size_t count;
 
  kbr = redis_kb (kb);
 
  rep = redis_cmd (kbr, "KEYS %s", pattern);
  if (rep == NULL)
    return 0;
 
  if (rep->type != REDIS_REPLY_ARRAY)
    {
      freeReplyObject (rep);
      return 0;
    }
 
  count = rep->elements;
  freeReplyObject (rep);
  return count;
}

References redis_cmd(), and redis_kb.

Here is the call graph for this function:

redis_del_items()

int redis_del_items ( kb_t kb, const char * name )

static

Delete all entries under a given name.

Parameters

[in]	kb	KB handle where to store the item.
[in]	name	Item name.

Returns

0 on success, non-null on error.

Definition at line 1198 of file kb.c.

{
  struct kb_redis *kbr;
  redisReply *rep;
  int rc = 0;
 
  kbr = redis_kb (kb);
 
  rep = redis_cmd (kbr, "DEL %s", name);
  if (rep == NULL || rep->type == REDIS_REPLY_ERROR)
    rc = -1;
 
  if (rep != NULL)
    freeReplyObject (rep);
 
  return rc;
}

References redis_cmd(), and redis_kb.

Here is the call graph for this function:

redis_delete()

int redis_delete ( kb_t kb )

static

Delete all entries and release ownership on the namespace.

Parameters

[in]

kb

KB handle to release.

Returns

0 on success, non-null on error.

Definition at line 394 of file kb.c.

{
  struct kb_redis *kbr;
 
  kbr = redis_kb (kb);
 
  redis_delete_all (kbr);
  redis_release_db (kbr);
 
  if (kbr->rctx != NULL)
    {
      g_free (kbr->path);
      redisFree (kbr->rctx);
      kbr->rctx = NULL;
    }
 
  g_free (kb);
  return 0;
}

References kb_redis::path, kb_redis::rctx, redis_delete_all(), redis_kb, and redis_release_db().

Referenced by redis_new().

Here is the call graph for this function:

Here is the caller graph for this function:

redis_delete_all()

int redis_delete_all ( struct kb_redis * kbr )

static

Delete all the KB's content.

Parameters

[in]

kbr

Subclass of struct kb.

Returns

0 on success, non-null on error.

Definition at line 1809 of file kb.c.

{
  int rc;
  redisReply *rep;
  struct sigaction new_action, original_action;
 
  /* Ignore SIGPIPE, in case of a lost connection. */
  new_action.sa_flags = 0;
  if (sigemptyset (&new_action.sa_mask))
    return -1;
  new_action.sa_handler = SIG_IGN;
  if (sigaction (SIGPIPE, &new_action, &original_action))
    return -1;
 
  if (kbr)
    g_debug ("%s: deleting all elements from KB #%u", __func__, kbr->db);
  rep = redis_cmd (kbr, "FLUSHDB");
  if (rep == NULL || rep->type != REDIS_REPLY_STATUS)
    {
      rc = -1;
      goto err_cleanup;
    }
 
  rc = 0;
 
err_cleanup:
  if (sigaction (SIGPIPE, &original_action, NULL))
    return -1;
  if (rep != NULL)
    freeReplyObject (rep);
 
  return rc;
}

References kb_redis::db, and redis_cmd().

Referenced by redis_delete(), redis_flush_all(), and redis_new().

Here is the call graph for this function:

Here is the caller graph for this function:

redis_direct_conn()

kb_t redis_direct_conn ( const char * kb_path, const int kb_index )

static

Connect to a Knowledge Base object with the given kb_index.

Parameters

[in]	kb_path	Path to KB.
[in]	kb_index	DB index

Returns

Knowledge Base object, NULL otherwise.

Definition at line 516 of file kb.c.

{
  struct kb_redis *kbr;
  redisReply *rep;
 
  if (kb_path == NULL)
    return NULL;
 
  kbr = g_malloc0 (sizeof (struct kb_redis));
  kbr->kb.kb_ops = &KBRedisOperations;
  kbr->path = g_strdup (kb_path);
 
  kbr->rctx = connect_redis (kbr->path, strlen (kbr->path));
  if (kbr->rctx == NULL || kbr->rctx->err)
    {
      g_log (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
             "%s: redis connection error to %s: %s", __func__, kbr->path,
             kbr->rctx ? kbr->rctx->errstr : strerror (ENOMEM));
      redisFree (kbr->rctx);
      g_free (kbr->path);
      g_free (kbr);
      return NULL;
    }
  kbr->db = kb_index;
  rep = redisCommand (kbr->rctx, "SELECT %d", kb_index);
  if (rep == NULL || rep->type != REDIS_REPLY_STATUS)
    {
      if (rep != NULL)
        freeReplyObject (rep);
      redisFree (kbr->rctx);
      kbr->rctx = NULL;
      g_free (kbr->path);
      g_free (kbr);
      return NULL;
    }
  freeReplyObject (rep);
  return (kb_t) kbr;
}

References connect_redis(), kb_redis::db, G_LOG_DOMAIN, kb_redis::kb, kb::kb_ops, KBRedisOperations, kb_redis::path, and kb_redis::rctx.

Here is the call graph for this function:

redis_find()

kb_t redis_find ( const char * kb_path, const char * key )

static

Find an existing Knowledge Base object with key.

Parameters

[in]	kb_path	Path to KB.
[in]	key	Marker key to search for in KB objects.

Returns

Knowledge Base object, NULL otherwise.

Definition at line 564 of file kb.c.

{
  struct kb_redis *kbr;
  unsigned int i = 1;
 
  if (kb_path == NULL)
    return NULL;
 
  kbr = g_malloc0 (sizeof (struct kb_redis));
  kbr->kb.kb_ops = &KBRedisOperations;
  kbr->path = g_strdup (kb_path);
 
  do
    {
      redisReply *rep;
 
      kbr->rctx = connect_redis (kbr->path, strlen (kbr->path));
      if (kbr->rctx == NULL || kbr->rctx->err)
        {
          g_log (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
                 "%s: redis connection error to %s: %s", __func__, kbr->path,
                 kbr->rctx ? kbr->rctx->errstr : strerror (ENOMEM));
          redisFree (kbr->rctx);
          g_free (kbr->path);
          g_free (kbr);
          return NULL;
        }
 
      if (kbr->max_db == 0)
        fetch_max_db_index (kbr);
 
      kbr->db = i;
      rep = redisCommand (kbr->rctx, "HEXISTS %s %d", GLOBAL_DBINDEX_NAME, i);
      if (rep == NULL || rep->type != REDIS_REPLY_INTEGER || rep->integer != 1)
        {
          if (rep != NULL)
            freeReplyObject (rep);
          i++;
          redisFree (kbr->rctx);
          kbr->rctx = NULL;
          continue;
        }
      freeReplyObject (rep);
      rep = redisCommand (kbr->rctx, "SELECT %u", i);
      if (rep == NULL || rep->type != REDIS_REPLY_STATUS)
        {
          redisFree (kbr->rctx);
          kbr->rctx = NULL;
        }
      else
        {
          freeReplyObject (rep);
          if (key)
            {
              char *tmp = kb_item_get_str (&kbr->kb, key);
              if (tmp)
                {
                  g_free (tmp);
                  return (kb_t) kbr;
                }
            }
          redisFree (kbr->rctx);
        }
      i++;
    }
  while (i < kbr->max_db);
 
  g_free (kbr->path);
  g_free (kbr);
  return NULL;
}

References connect_redis(), kb_redis::db, fetch_max_db_index(), G_LOG_DOMAIN, GLOBAL_DBINDEX_NAME, kb_redis::kb, kb_item_get_str(), kb::kb_ops, KBRedisOperations, kb_redis::max_db, kb_redis::path, and kb_redis::rctx.

Here is the call graph for this function:

redis_flush_all()

int redis_flush_all ( kb_t kb, const char * except )

static

Flush all the KB's content. Delete all namespaces.

Parameters

[in]	kb	KB handle.
[in]	except	Don't flush DB with except key.

Returns

0 on success, non-null on error.

Definition at line 1699 of file kb.c.

{
  unsigned int i = 1;
  struct kb_redis *kbr;
 
  kbr = redis_kb (kb);
  if (kbr->rctx)
    redisFree (kbr->rctx);
 
  g_debug ("%s: deleting all DBs at %s except %s", __func__, kbr->path, except);
  do
    {
      redisReply *rep;
 
      kbr->rctx = connect_redis (kbr->path, strlen (kbr->path));
      if (kbr->rctx == NULL || kbr->rctx->err)
        {
          g_log (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
                 "%s: redis connection error to %s: %s", __func__, kbr->path,
                 kbr->rctx ? kbr->rctx->errstr : strerror (ENOMEM));
          redisFree (kbr->rctx);
          kbr->rctx = NULL;
          return -1;
        }
 
      kbr->db = i;
      rep = redisCommand (kbr->rctx, "HEXISTS %s %d", GLOBAL_DBINDEX_NAME, i);
      if (rep == NULL || rep->type != REDIS_REPLY_INTEGER || rep->integer != 1)
        {
          freeReplyObject (rep);
          redisFree (kbr->rctx);
          i++;
          continue;
        }
      freeReplyObject (rep);
      rep = redisCommand (kbr->rctx, "SELECT %u", i);
      if (rep == NULL || rep->type != REDIS_REPLY_STATUS)
        {
          freeReplyObject (rep);
          redisFree (kbr->rctx);
          kbr->rctx = NULL;
        }
      else
        {
          freeReplyObject (rep);
          /* Don't remove DB if it has "except" key. */
          if (except)
            {
              char *tmp = kb_item_get_str (kb, except);
              if (tmp)
                {
                  g_free (tmp);
                  i++;
                  redisFree (kbr->rctx);
                  continue;
                }
            }
          redis_delete_all (kbr);
          redis_release_db (kbr);
          redisFree (kbr->rctx);
        }
      i++;
    }
  while (i < kbr->max_db);
 
  g_free (kbr->path);
  g_free (kb);
  return 0;
}

References connect_redis(), kb_redis::db, G_LOG_DOMAIN, GLOBAL_DBINDEX_NAME, kb_item_get_str(), kb_redis::max_db, kb_redis::path, kb_redis::rctx, redis_delete_all(), redis_kb, and redis_release_db().

Here is the call graph for this function:

redis_get_all()

struct kb_item * redis_get_all ( kb_t kb, const char * name )

static

Get all items stored under a given name.

Parameters

[in]	kb	KB handle where to fetch the items.
[in]	name	Name of the elements to retrieve.

Returns

Linked struct kb_item instances to be freed with kb_item_free() or NULL if no element was found or on error.

Definition at line 1038 of file kb.c.

{
  struct kb_redis *kbr;
  struct kb_item *kbi;
  redisReply *rep;
 
  kbr = redis_kb (kb);
 
  rep = redis_cmd (kbr, "LRANGE %s 0 -1", name);
  if (rep == NULL)
    return NULL;
 
  kbi = redis2kbitem (name, rep);
 
  freeReplyObject (rep);
 
  return kbi;
}

References kb_item::name, redis2kbitem(), redis_cmd(), and redis_kb.

Here is the call graph for this function:

redis_get_int()

int redis_get_int ( kb_t kb, const char * name )

static

Get a single KB integer item.

Parameters

[in]	kb	KB handle where to fetch the item.
[in]	name	Name of the element to retrieve.

Returns

An integer.

Definition at line 930 of file kb.c.

{
  struct kb_item *kbi;
 
  kbi = redis_get_single (kb, name, KB_TYPE_INT);
  if (kbi != NULL)
    {
      int res;
 
      res = kbi->v_int;
      kb_item_free (kbi);
      return res;
    }
  return -1;
}

References kb_item_free(), KB_TYPE_INT, kb_item::name, redis_get_single(), and kb_item::v_int.

Here is the call graph for this function:

redis_get_kb_index()

int redis_get_kb_index ( kb_t kb )

static

Return the kb index.

Parameters

[in]

kb

KB handle.

Returns

kb_index on success, null on error.

Definition at line 422 of file kb.c.

{
  int i;
  i = ((struct kb_redis *) kb)->db;
  if (i > 0)
    return i;
  return -1;
}

References kb_redis::db.

redis_get_nvt()

char * redis_get_nvt ( kb_t kb, const char * oid, enum kb_nvt_pos position )

static

Get field of a NVT.

Parameters

[in]	kb	KB handle where to store the nvt.
[in]	oid	OID of NVT to get from.
[in]	position	Position of field to get.

Returns

Value of field, NULL otherwise.

Definition at line 956 of file kb.c.

{
  struct kb_redis *kbr;
  redisReply *rep;
  char *res = NULL;
 
  kbr = redis_kb (kb);
  if (position >= NVT_TIMESTAMP_POS)
    rep = redis_cmd (kbr, "LINDEX filename:%s %d", oid,
                     position - NVT_TIMESTAMP_POS);
  else
    rep = redis_cmd (kbr, "LINDEX nvt:%s %d", oid, position);
  if (!rep)
    return NULL;
  if (rep->type == REDIS_REPLY_INTEGER)
    res = g_strdup_printf ("%lld", rep->integer);
  else if (rep->type == REDIS_REPLY_STRING)
    res = g_strdup (rep->str);
  freeReplyObject (rep);
 
  return res;
}

References NVT_TIMESTAMP_POS, redis_cmd(), and redis_kb.

Here is the call graph for this function:

redis_get_nvt_all()

nvti_t * redis_get_nvt_all ( kb_t kb, const char * oid )

static

Get a full NVT.

Parameters

[in]	kb	KB handle where to store the nvt.
[in]	oid	OID of NVT to get.

Returns

nvti_t of NVT, NULL otherwise.

Definition at line 988 of file kb.c.

{
  struct kb_redis *kbr;
  redisReply *rep;
 
  kbr = redis_kb (kb);
  rep =
    redis_cmd (kbr, "LRANGE nvt:%s %d %d", oid, NVT_FILENAME_POS, NVT_NAME_POS);
  if (!rep)
    return NULL;
  if (rep->type != REDIS_REPLY_ARRAY || rep->elements != NVT_NAME_POS + 1)
    {
      freeReplyObject (rep);
      return NULL;
    }
  else
    {
      nvti_t *nvti = nvti_new ();
 
      nvti_set_oid (nvti, oid);
      nvti_set_required_keys (nvti, rep->element[NVT_REQUIRED_KEYS_POS]->str);
      nvti_set_mandatory_keys (nvti, rep->element[NVT_MANDATORY_KEYS_POS]->str);
      nvti_set_excluded_keys (nvti, rep->element[NVT_EXCLUDED_KEYS_POS]->str);
      nvti_set_required_udp_ports (
        nvti, rep->element[NVT_REQUIRED_UDP_PORTS_POS]->str);
      nvti_set_required_ports (nvti, rep->element[NVT_REQUIRED_PORTS_POS]->str);
      nvti_set_dependencies (nvti, rep->element[NVT_DEPENDENCIES_POS]->str);
      nvti_set_tag (nvti, rep->element[NVT_TAGS_POS]->str);
      nvti_add_refs (nvti, "cve", rep->element[NVT_CVES_POS]->str, "");
      nvti_add_refs (nvti, "bid", rep->element[NVT_BIDS_POS]->str, "");
      nvti_add_refs (nvti, NULL, rep->element[NVT_XREFS_POS]->str, "");
      nvti_set_category (nvti, atoi (rep->element[NVT_CATEGORY_POS]->str));
      nvti_set_family (nvti, rep->element[NVT_FAMILY_POS]->str);
      nvti_set_name (nvti, rep->element[NVT_NAME_POS]->str);
 
      freeReplyObject (rep);
      return nvti;
    }
}

References NVT_BIDS_POS, NVT_CATEGORY_POS, NVT_CVES_POS, NVT_DEPENDENCIES_POS, NVT_EXCLUDED_KEYS_POS, NVT_FAMILY_POS, NVT_FILENAME_POS, NVT_MANDATORY_KEYS_POS, NVT_NAME_POS, NVT_REQUIRED_KEYS_POS, NVT_REQUIRED_PORTS_POS, NVT_REQUIRED_UDP_PORTS_POS, NVT_TAGS_POS, NVT_XREFS_POS, nvti_add_refs(), nvti_new(), nvti_set_category(), nvti_set_dependencies(), nvti_set_excluded_keys(), nvti_set_family(), nvti_set_mandatory_keys(), nvti_set_name(), nvti_set_oid(), nvti_set_required_keys(), nvti_set_required_ports(), nvti_set_required_udp_ports(), nvti_set_tag(), redis_cmd(), and redis_kb.

Here is the call graph for this function:

redis_get_oids()

GSList * redis_get_oids ( kb_t kb )

static

Get all NVT OIDs.

Parameters

[in]

kb

KB handle where to fetch the items.

Returns

Linked list of all OIDs or NULL.

Definition at line 1131 of file kb.c.

{
  struct kb_redis *kbr;
  redisReply *rep;
  GSList *list = NULL;
  size_t i;
 
  kbr = redis_kb (kb);
  rep = redis_cmd (kbr, "KEYS nvt:*");
  if (!rep)
    return NULL;
 
  if (rep->type != REDIS_REPLY_ARRAY)
    {
      freeReplyObject (rep);
      return NULL;
    }
 
  /* Fetch OID values from key names nvt:OID. */
  for (i = 0; i < rep->elements; i++)
    list = g_slist_prepend (list, g_strdup (rep->element[i]->str + 4));
  freeReplyObject (rep);
 
  return list;
}

References redis_cmd(), and redis_kb.

Here is the call graph for this function:

redis_get_pattern()

struct kb_item * redis_get_pattern ( kb_t kb, const char * pattern )

static

Get all items stored under a given pattern.

Parameters

[in]	kb	KB handle where to fetch the items.
[in]	pattern	'*' pattern of the elements to retrieve.

Returns

Linked struct kb_item instances to be freed with kb_item_free() or NULL if no element was found or on error.

Definition at line 1067 of file kb.c.

{
  struct kb_redis *kbr;
  struct kb_item *kbi = NULL;
  redisReply *rep;
  unsigned int i;
 
  kbr = redis_kb (kb);
  rep = redis_cmd (kbr, "KEYS %s", pattern);
  if (!rep)
    return NULL;
  if (rep->type != REDIS_REPLY_ARRAY)
    {
      freeReplyObject (rep);
      return NULL;
    }
 
  if (get_redis_ctx (kbr) < 0)
    return NULL;
  for (i = 0; i < rep->elements; i++)
    redisAppendCommand (kbr->rctx, "LRANGE %s 0 -1", rep->element[i]->str);
 
  for (i = 0; i < rep->elements; i++)
    {
      struct kb_item *tmp;
      redisReply *rep_range;
 
      redisGetReply (kbr->rctx, (void **) &rep_range);
      if (!rep)
        continue;
      tmp = redis2kbitem (rep->element[i]->str, rep_range);
      if (!tmp)
        {
          freeReplyObject (rep_range);
          continue;
        }
 
      if (kbi)
        {
          struct kb_item *tmp2;
 
          tmp2 = tmp;
          while (tmp->next)
            tmp = tmp->next;
          tmp->next = kbi;
          kbi = tmp2;
        }
      else
        kbi = tmp;
      freeReplyObject (rep_range);
    }
 
  freeReplyObject (rep);
  return kbi;
}

References get_redis_ctx(), kb_item::next, kb_redis::rctx, redis2kbitem(), redis_cmd(), and redis_kb.

Here is the call graph for this function:

redis_get_single()

struct kb_item * redis_get_single ( kb_t kb, const char * name, enum kb_item_type type )

static

Get a single KB element.

Parameters

[in]	kb	KB handle where to fetch the item.
[in]	name	Name of the element to retrieve.
[in]	type	Desired element type.

Returns

A struct kb_item to be freed with kb_item_free() or NULL if no element was found or on error.

Definition at line 812 of file kb.c.

{
  struct kb_item *kbi;
  struct kb_redis *kbr;
  redisReply *rep;
 
  kbr = redis_kb (kb);
  kbi = NULL;
 
  rep = redis_cmd (kbr, "LINDEX %s -1", name);
  if (rep == NULL || rep->type != REDIS_REPLY_STRING)
    {
      kbi = NULL;
      goto out;
    }
 
  kbi = redis2kbitem_single (name, rep, type == KB_TYPE_INT);
 
out:
  if (rep != NULL)
    freeReplyObject (rep);
 
  return kbi;
}

References KB_TYPE_INT, redis2kbitem_single(), redis_cmd(), and redis_kb.

Referenced by redis_get_int(), and redis_get_str().

Here is the call graph for this function:

Here is the caller graph for this function:

redis_get_str()

char * redis_get_str ( kb_t kb, const char * name )

static

Get a single KB string item.

Parameters

[in]	kb	KB handle where to fetch the item.
[in]	name	Name of the element to retrieve.

Returns

A struct kb_item to be freed with kb_item_free() or NULL if no element was found or on error.

Definition at line 847 of file kb.c.

{
  struct kb_item *kbi;
 
  kbi = redis_get_single (kb, name, KB_TYPE_STR);
  if (kbi != NULL)
    {
      char *res;
 
      res = kbi->v_str;
      kbi->v_str = NULL;
      kb_item_free (kbi);
      return res;
    }
  return NULL;
}

References kb_item_free(), KB_TYPE_STR, kb_item::name, redis_get_single(), and kb_item::v_str.

Here is the call graph for this function:

redis_lnk_reset()

int redis_lnk_reset ( kb_t kb )

static

Reset connection to the KB. This is called after each fork() to make sure connections aren't shared between concurrent processes.

Parameters

[in]

kb

KB handle.

Returns

0 on success, non-null on error.

Definition at line 1675 of file kb.c.

{
  struct kb_redis *kbr;
 
  kbr = redis_kb (kb);
 
  if (kbr->rctx != NULL)
    {
      redisFree (kbr->rctx);
      kbr->rctx = NULL;
    }
 
  return 0;
}

References kb_redis::rctx, and redis_kb.

Referenced by redis_cmd().

Here is the caller graph for this function:

redis_memory_purge()

int redis_memory_purge ( kb_t kb )

static

Attempt to purge dirty pages.

Attempt to purge dirty pages so these can be reclaimed by the allocator. This command only works when using jemalloc as an allocator, and evaluates to a benign NOOP for all others. Command is applied to complete redis instance and not only single db.

Parameters

[in]

kb

KB handle where to run the command.

Returns

0 on success, non-null on error.

Definition at line 444 of file kb.c.

{
  redisReply *rep;
  int rc = 0;
 
  rep = redis_cmd (redis_kb (kb), "MEMORY PURGE");
  if (!rep || rep->type == REDIS_REPLY_ERROR)
    rc = -1;
  if (rep)
    freeReplyObject (rep);
 
  return rc;
}

References redis_cmd(), and redis_kb.

Referenced by redis_new().

Here is the call graph for this function:

Here is the caller graph for this function:

redis_new()

int redis_new ( kb_t * kb, const char * kb_path )

static

Initialize a new Knowledge Base object.

Parameters

[in]	kb	Reference to a kb_t to initialize.
[in]	kb_path	Path to KB.

Returns

0 on success, -1 on connection error, -2 when no DB is available, -3 when given kb_path was NULL.

Definition at line 468 of file kb.c.

{
  struct kb_redis *kbr;
  int rc = 0;
 
  if (kb_path == NULL)
    return -3;
 
  kbr = g_malloc0 (sizeof (struct kb_redis));
  kbr->kb.kb_ops = &KBRedisOperations;
  kbr->path = g_strdup (kb_path);
 
  rc = get_redis_ctx (kbr);
  if (rc < 0)
    {
      redis_delete ((kb_t) kbr);
      return rc;
    }
  if (redis_test_connection (kbr))
    {
      g_log (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
             "%s: cannot access redis at '%s'", __func__, kb_path);
      redis_delete ((kb_t) kbr);
      kbr = NULL;
      rc = -1;
    }
 
  /* Ensure that the new kb is clean */
  redis_delete_all (kbr);
 
  *kb = (kb_t) kbr;
 
  /* Try to make unused memory available for the OS again. */
  if (redis_memory_purge (*kb))
    g_warning ("%s: Memory purge was not successful", __func__);
 
  return rc;
}

References G_LOG_DOMAIN, get_redis_ctx(), kb_redis::kb, kb::kb_ops, KBRedisOperations, kb_redis::path, redis_delete(), redis_delete_all(), redis_memory_purge(), and redis_test_connection().

Here is the call graph for this function:

redis_pop_str()

char * redis_pop_str ( kb_t kb, const char * name )

static

Pops a single KB string item.

Parameters

[in]	kb	KB handle where to fetch the item.
[in]	name	Name of the key from where to retrieve.

Returns

A string to be freed or NULL if list is empty or on error.

Definition at line 903 of file kb.c.

{
  struct kb_redis *kbr;
  redisReply *rep;
  char *value = NULL;
 
  kbr = redis_kb (kb);
  rep = redis_cmd (kbr, "RPOP %s", name);
  if (!rep)
    return NULL;
 
  if (rep->type == REDIS_REPLY_STRING)
    value = g_strdup (rep->str);
  freeReplyObject (rep);
 
  return value;
}

References redis_cmd(), and redis_kb.

Here is the call graph for this function:

redis_push_str()

int redis_push_str ( kb_t kb, const char * name, const char * value )

static

Push a new entry under a given key.

Parameters

[in]	kb	KB handle where to store the item.
[in]	name	Key to push to.
[in]	value	Value to push.

Returns

0 on success, non-null on error.

Definition at line 874 of file kb.c.

{
  struct kb_redis *kbr;
  redisReply *rep = NULL;
  int rc = 0;
 
  if (!value)
    return -1;
 
  kbr = redis_kb (kb);
  rep = redis_cmd (kbr, "LPUSH %s %s", name, value);
  if (!rep || rep->type == REDIS_REPLY_ERROR)
    rc = -1;
 
  if (rep)
    freeReplyObject (rep);
 
  return rc;
}

References redis_cmd(), and redis_kb.

Here is the call graph for this function:

redis_release_db()

int redis_release_db ( struct kb_redis * kbr )

static

Release DB.

Parameters

[in]

kbr

Subclass of struct kb.

Returns

0 on success, -1 on error.

Definition at line 216 of file kb.c.

{
  int rc;
  redisContext *ctx = kbr->rctx;
  redisReply *rep;
 
  if (ctx == NULL)
    return -EINVAL;
 
  rep = redisCommand (ctx, "SELECT 0"); /* Management database*/
  if (rep == NULL || rep->type != REDIS_REPLY_STATUS)
    {
      rc = -1;
      goto err_cleanup;
    }
  freeReplyObject (rep);
 
  rep = redisCommand (ctx, "HDEL %s %d", GLOBAL_DBINDEX_NAME, kbr->db);
  if (rep == NULL || rep->type != REDIS_REPLY_INTEGER)
    {
      rc = -1;
      goto err_cleanup;
    }
 
  rc = 0;
 
err_cleanup:
  if (rep != NULL)
    freeReplyObject (rep);
 
  return rc;
}

References kb_redis::db, GLOBAL_DBINDEX_NAME, and kb_redis::rctx.

Referenced by redis_delete(), and redis_flush_all().

Here is the caller graph for this function:

redis_save()

int redis_save ( kb_t kb )

static

Save all the elements from the KB.

Parameters

[in]

kb

KB handle.

Returns

0 on success, -1 on error.

Definition at line 1777 of file kb.c.

{
  int rc;
  redisReply *rep;
  struct kb_redis *kbr;
 
  kbr = redis_kb (kb);
  g_debug ("%s: saving all elements from KB #%u", __func__, kbr->db);
  rep = redis_cmd (kbr, "SAVE");
  if (rep == NULL || rep->type != REDIS_REPLY_STATUS)
    {
      rc = -1;
      goto err_cleanup;
    }
 
  rc = 0;
 
err_cleanup:
  if (rep != NULL)
    freeReplyObject (rep);
 
  return rc;
}

References kb_redis::db, redis_cmd(), and redis_kb.

Here is the call graph for this function:

redis_set_int()

int redis_set_int ( kb_t kb, const char * name, int val )

static

Set (replace) a new entry under a given name.

Parameters

[in]	kb	KB handle where to store the item.
[in]	name	Item name.
[in]	val	Item value.

Returns

0 on success, non-null on error.

Definition at line 1570 of file kb.c.

{
  struct kb_redis *kbr;
  redisReply *rep = NULL;
  redisContext *ctx;
  int rc = 0, i = 4;
 
  kbr = redis_kb (kb);
  if (get_redis_ctx (redis_kb (kb)) < 0)
    return -1;
  ctx = kbr->rctx;
  redisAppendCommand (ctx, "MULTI");
  redisAppendCommand (ctx, "DEL %s", name);
  redisAppendCommand (ctx, "RPUSH %s %d", name, val);
  redisAppendCommand (ctx, "EXEC");
  while (i--)
    {
      redisGetReply (ctx, (void **) &rep);
      if (!rep || rep->type == REDIS_REPLY_ERROR)
        rc = -1;
      if (rep)
        freeReplyObject (rep);
    }
 
  return rc;
}

References get_redis_ctx(), kb_redis::rctx, and redis_kb.

Here is the call graph for this function:

redis_set_str()

int redis_set_str ( kb_t kb, const char * name, const char * val, size_t len )

static

Set (replace) a new entry under a given name.

Parameters

[in]	kb	KB handle where to store the item.
[in]	name	Item name.
[in]	val	Item value.
[in]	len	Value length. Used for blobs.

Returns

0 on success, non-null on error.

Definition at line 1411 of file kb.c.

{
  struct kb_redis *kbr;
  redisReply *rep = NULL;
  redisContext *ctx;
  int rc = 0, i = 4;
 
  kbr = redis_kb (kb);
  if (get_redis_ctx (kbr) < 0)
    return -1;
  ctx = kbr->rctx;
  redisAppendCommand (ctx, "MULTI");
  redisAppendCommand (ctx, "DEL %s", name);
  if (len == 0)
    redisAppendCommand (ctx, "RPUSH %s %s", name, val);
  else
    redisAppendCommand (ctx, "RPUSH %s %b", name, val, len);
  redisAppendCommand (ctx, "EXEC");
  while (i--)
    {
      redisGetReply (ctx, (void **) &rep);
      if (!rep || rep->type == REDIS_REPLY_ERROR)
        rc = -1;
      if (rep)
        freeReplyObject (rep);
    }
 
  return rc;
}

References get_redis_ctx(), kb_redis::rctx, and redis_kb.

Here is the call graph for this function:

redis_test_connection()

int redis_test_connection ( struct kb_redis * kbr )

static

Test redis connection.

Parameters

[in]

kbr

Subclass of struct kb to test.

Returns

0 on success, negative integer on error.

Definition at line 353 of file kb.c.

{
  int rc = 0;
  redisReply *rep;
 
  rep = redis_cmd (kbr, "PING");
  if (rep == NULL)
    {
      /* not 100% relevant but hiredis doesn't provide us with proper error
       * codes. */
      rc = -ECONNREFUSED;
      goto out;
    }
 
  if (rep->type != REDIS_REPLY_STATUS)
    {
      rc = -EINVAL;
      goto out;
    }
 
  if (g_ascii_strcasecmp (rep->str, "PONG"))
    {
      rc = -EPROTO;
      goto out;
    }
 
out:
  if (rep != NULL)
    freeReplyObject (rep);
 
  return rc;
}

References redis_cmd().

Referenced by redis_new().

Here is the call graph for this function:

Here is the caller graph for this function:

select_database()

int select_database ( struct kb_redis * kbr )

static

Select DB.

WARNING: do not call redis_cmd in here, since our context is not fully acquired yet!

Parameters

[in]

kbr

Subclass of struct kb where to save the db index.

Returns

0 on success, -1 on error.

Definition at line 164 of file kb.c.

{
  int rc;
  redisContext *ctx = kbr->rctx;
  redisReply *rep = NULL;
 
  if (kbr->db == 0)
    {
      unsigned i;
 
      if (kbr->max_db == 0)
        fetch_max_db_index (kbr);
 
      for (i = 1; i < kbr->max_db; i++)
        {
          rc = try_database_index (kbr, i);
          if (rc == 0)
            break;
        }
    }
 
  /* No DB available, give up. */
  if (kbr->db == 0)
    {
      rc = -1;
      goto err_cleanup;
    }
 
  rep = redisCommand (ctx, "SELECT %u", kbr->db);
  if (rep == NULL || rep->type != REDIS_REPLY_STATUS)
    {
      rc = -1;
      goto err_cleanup;
    }
 
  rc = 0;
 
err_cleanup:
  if (rep != NULL)
    freeReplyObject (rep);
 
  return rc;
}

References kb_redis::db, fetch_max_db_index(), kb_redis::max_db, kb_redis::rctx, and try_database_index().

Referenced by get_redis_ctx().

Here is the call graph for this function:

Here is the caller graph for this function:

try_database_index()

int try_database_index ( struct kb_redis * kbr, int index )

static

Attempt to atomically acquire ownership of a database.

Returns

0 on success, negative integer otherwise.

Definition at line 78 of file kb.c.

{
  redisContext *ctx = kbr->rctx;
  redisReply *rep;
  int rc = 0;
 
  rep = redisCommand (ctx, "HSETNX %s %d 1", GLOBAL_DBINDEX_NAME, index);
  if (rep == NULL)
    return -ENOMEM;
 
  if (rep->type != REDIS_REPLY_INTEGER)
    rc = -EPROTO;
  else if (rep->integer == 0)
    rc = -EALREADY;
  else
    kbr->db = index;
 
  freeReplyObject (rep);
 
  return rc;
}

References kb_redis::db, GLOBAL_DBINDEX_NAME, and kb_redis::rctx.

Referenced by select_database().

Here is the caller graph for this function:

Variable Documentation

KBDefaultOperations

const struct kb_operations* KBDefaultOperations = &KBRedisOperations

Default KB operations. No selection mechanism is provided yet since there's only one implementation (redis-based).

Definition at line 1880 of file kb.c.

Referenced by kb_add_int_unique_volatile(), kb_add_str_unique_volatile(), kb_direct_conn(), kb_find(), and kb_new().

KBRedisOperations

const struct kb_operations KBRedisOperations

static

Initial value:

= {
  .kb_new = redis_new,
  .kb_find = redis_find,
  .kb_delete = redis_delete,
  .kb_get_single = redis_get_single,
  .kb_get_str = redis_get_str,
  .kb_get_int = redis_get_int,
  .kb_get_nvt = redis_get_nvt,
  .kb_get_nvt_all = redis_get_nvt_all,
  .kb_get_nvt_oids = redis_get_oids,
  .kb_push_str = redis_push_str,
  .kb_pop_str = redis_pop_str,
  .kb_get_all = redis_get_all,
  .kb_get_pattern = redis_get_pattern,
  .kb_count = redis_count,
  .kb_add_str = redis_add_str,
  .kb_add_str_unique = redis_add_str_unique,
  .kb_add_str_unique_volatile = redis_add_str_unique_volatile,
  .kb_set_str = redis_set_str,
  .kb_add_int = redis_add_int,
  .kb_add_int_unique = redis_add_int_unique,
  .kb_add_int_unique_volatile = redis_add_int_unique_volatile,
  .kb_set_int = redis_set_int,
  .kb_add_nvt = redis_add_nvt,
  .kb_del_items = redis_del_items,
  .kb_lnk_reset = redis_lnk_reset,
  .kb_save = redis_save,
  .kb_flush = redis_flush_all,
  .kb_direct_conn = redis_direct_conn,
  .kb_get_kb_index = redis_get_kb_index}

Default KB operations.

No selection mechanism is provided yet since there's only one implementation (redis-based).

Definition at line 47 of file kb.c.

Referenced by redis_direct_conn(), redis_find(), and redis_new().