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:

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)   ((struct kb_redis *) (__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.

memdup

#define memdup   g_memdup

Definition at line 32 of file kb.c.

redis_kb

#define redis_kb

(

__kb

)

((struct kb_redis *) (__kb))

Definition at line 62 of file kb.c.

Function Documentation

connect_redis()

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

static

Definition at line 263 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;
  if ((tmp = parse_port_of_addr (addr, tcp_indicator_len)) == 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()

static 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()

static 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 312 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 639 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()

static 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;
  if ((tmp = rindex (addr + tcp_indicator_len, ':')) == 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().

Here is the caller graph for this function:

redis2kbitem()

static 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 708 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()

static 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 663 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()

static 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 1543 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()

static 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 1502 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()

static 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 1449 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()

static 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 1604 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()

static 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 1378 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()

static 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 1320 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()

static 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 1227 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()

static 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 761 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()

static 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 1163 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()

static 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 1195 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()

static 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 392 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 1806 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()

static 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 513 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()

static 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 561 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()

static 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 1696 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()

static 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 1035 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()

static 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 927 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()

static 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 420 of file kb.c.

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

redis_get_nvt()

static 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 953 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()

static 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 985 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()

static 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 1128 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()

static 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 1064 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()

static 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 809 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()

static 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 844 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()

static 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 1672 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()

static 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 442 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()

static 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 466 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);
 
  if ((rc = get_redis_ctx (kbr)) < 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()

static 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 900 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()

static 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 871 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()

static 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()

static 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 1774 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()

static 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 1567 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()

static 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 1408 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()

static 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 351 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()

static 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()

static 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 1877 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

static 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().