plugs_req.c File Reference

Performs various checks for requirements set in a given plugin. More...

#include "plugs_req.h"
#include "pluginscheduler.h"
#include <gvm/base/prefs.h>
#include <gvm/util/nvticache.h>
#include <regex.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

Include dependency graph for plugs_req.c:

Go to the source code of this file.

Functions
int	kb_get_port_state_proto (kb_t, int, char *)
static int	get_closed_ports (kb_t kb, char *ports_list, char *proto)
	Returns whether a port in a port list is closed or not. More...
static int	kb_missing_keyname_of_namelist (kb_t kb, char *keys, char **keyname)
	Returns the name of the first key which is not present in the kb. More...
static int	kb_present_keyname_of_namelist (kb_t kb, char *keys, char **keyname)
	Returns the name of the first key which is present in the kb. More...
static int	check_mandatory_keys (kb_t kb, char *keys)
	Checks mandatory keys presence and value in the KB. More...
int	mandatory_requirements_met (kb_t kb, nvti_t *nvti)
	Check whether mandatory requirements for plugin are met. More...
char *	requirements_plugin (kb_t kb, nvti_t *nvti)
	Determine if the plugin requirements are met. More...

Detailed Description

Performs various checks for requirements set in a given plugin.

Definition in file plugs_req.c.

Function Documentation

check_mandatory_keys()

static int check_mandatory_keys ( kb_t  kb, char *  keys  )

static

Checks mandatory keys presence and value in the KB.

Parameters

[in]	kb	KB handle where to search for the keys.
[in]	keys	Comma separated list of mandatory keys.

Returns

1 if a key is missing or not matching its value, 0 otherwise.

Definition at line 160 of file plugs_req.c.

{
  int i;
  char **keynames;
 
  if (!kb || !keys || !*keys)
    return 0;
  keynames = g_strsplit (keys, ", ", 0);
  if (!keynames)
    return 0;
  for (i = 0; keynames[i] != NULL; i++)
    {
      struct kb_item *kbi;
      char *re_str = NULL, *pos;
 
      /* Split, if key requires RE matching. */
      if ((pos = strstr (keynames[i], "=")))
        {
          re_str = pos + 1;
          *pos = '\0';
        }
 
      kbi = kb_item_get_single (kb, keynames[i], KB_TYPE_UNSPEC);
      if (!kbi)
        {
          g_strfreev (keynames);
          return 1;
        }
 
      if (re_str)
        {
          regex_t re;
 
          /* Check if RE matches. */
          if (kbi->type != KB_TYPE_STR || !kbi->v_str)
            {
              g_strfreev (keynames);
              kb_item_free (kbi);
              return 1;
            }
          if (regcomp (&re, re_str, REG_EXTENDED | REG_NOSUB | REG_ICASE))
            {
              g_warning ("Couldn't compile regex %s", re_str);
              g_strfreev (keynames);
              kb_item_free (kbi);
              return 1;
            }
          if (regexec (&re, kbi->v_str, 0, NULL, 0) == REG_NOMATCH)
            {
              g_strfreev (keynames);
              kb_item_free (kbi);
              regfree (&re);
              return 1;
            }
          regfree (&re);
        }
      kb_item_free (kbi);
    }
 
  g_strfreev (keynames);
  return 0;
}

Referenced by mandatory_requirements_met().

Here is the caller graph for this function:

get_closed_ports()

static int get_closed_ports ( kb_t  kb, char *  ports_list, char *  proto  )

static

Returns whether a port in a port list is closed or not.

Returns

Whether a port in a port list is closed or not.

Definition at line 39 of file plugs_req.c.

{
  int i;
  char **ports;
 
  if (!ports_list)
    return -1;
  ports = g_strsplit (ports_list, ", ", 0);
  for (i = 0; ports[i] != NULL; i++)
    {
      int iport = atoi (ports[i]);
      if (iport > 0 && kb_get_port_state_proto (kb, iport, proto) != 0)
        {
          g_strfreev (ports);
          return iport;
        }
      else
        {
          if (kb_item_get_int (kb, ports[i]) > 0)
            {
              g_strfreev (ports);
              return 1; /* should be the actual value indeed ! */
            }
        }
    }
  g_strfreev (ports);
  return 0; /* found nothing */
}

References kb_get_port_state_proto().

Referenced by requirements_plugin().

Here is the call graph for this function:

Here is the caller graph for this function:

kb_get_port_state_proto()

int kb_get_port_state_proto	(	kb_t	kb,
		int	portnum,
		char *	proto
	)

Parameters

proto

Protocol (udp/tcp). If NULL, "tcp" will be used.

Definition at line 100 of file plugutils.c.

{
  char port_s[255], *kbstr;
  const char *prange = prefs_get ("port_range");
  port_protocol_t port_type;
  array_t *port_ranges;
 
  if (!proto)
    proto = "tcp";
  if (!strcmp (proto, "udp"))
    {
      port_type = PORT_PROTOCOL_UDP;
      kbstr = "Host/udp_scanned";
    }
  else
    {
      port_type = PORT_PROTOCOL_TCP;
      kbstr = "Host/scanned";
    }
 
  /* Check that we actually scanned the port */
  if (kb_item_get_int (kb, kbstr) <= 0)
    return unscanned_ports_as_closed (port_type);
 
  port_ranges = port_range_ranges (prange);
  if (!port_in_port_ranges (portnum, port_type, port_ranges))
    {
      array_free (port_ranges);
      return unscanned_ports_as_closed (port_type);
    }
  array_free (port_ranges);
 
  /* Ok, we scanned it. What is its state ? */
  snprintf (port_s, sizeof (port_s), "Ports/%s/%d", proto, portnum);
  return kb_item_get_int (kb, port_s) > 0;
}

Referenced by get_closed_ports().

Here is the caller graph for this function:

kb_missing_keyname_of_namelist()

static int kb_missing_keyname_of_namelist ( kb_t  kb, char *  keys, char **  keyname  )

static

Returns the name of the first key which is not present in the kb.

Parameters

[in]	kb	KB handle where to search for the keys.
[in]	keys	Comma separated list of keys.
[out]	keyname	Key that was missing. Free with g_free().

Returns

1 if a key is missing in KB, 0 otherwise.

Definition at line 83 of file plugs_req.c.

{
  int i;
  char **keynames;
  if (!kb || !keys || !*keys)
    return 0;
 
  keynames = g_strsplit (keys, ", ", 0);
  if (!keynames)
    return 0;
  for (i = 0; keynames[i] != NULL; i++)
    {
      struct kb_item *kbi =
        kb_item_get_single (kb, keynames[i], KB_TYPE_UNSPEC);
 
      if (kbi == NULL)
        {
          if (keyname)
            *keyname = g_strdup (keynames[i]);
          g_strfreev (keynames);
          return 1;
        }
 
      kb_item_free (kbi);
    }
 
  g_strfreev (keynames);
  return 0; /* All of the keys are present in the kb */
}

Referenced by requirements_plugin().

Here is the caller graph for this function:

kb_present_keyname_of_namelist()

static int kb_present_keyname_of_namelist ( kb_t  kb, char *  keys, char **  keyname  )

static

Returns the name of the first key which is present in the kb.

Parameters

[in]	kb	KB handle where to search for the keys.
[in]	keys	Comma separated list of keys.
[out]	keyname	Key that was found. Free with g_free().

Returns

1 if a key is present in KB, 0 otherwise.

Definition at line 122 of file plugs_req.c.

{
  int i;
  char **keynames;
 
  if (!kb || !keys || !*keys)
    return 0;
 
  keynames = g_strsplit (keys, ", ", 0);
  if (!keynames)
    return 0;
  for (i = 0; keynames[i] != NULL; i++)
    {
      struct kb_item *kbi =
        kb_item_get_single (kb, keynames[i], KB_TYPE_UNSPEC);
 
      if (kbi != NULL)
        {
          if (keyname)
            *keyname = g_strdup (keynames[i]);
          kb_item_free (kbi);
          g_strfreev (keynames);
          return 1;
        }
    }
 
  g_strfreev (keynames);
  return 0;
}

Referenced by requirements_plugin().

Here is the caller graph for this function:

mandatory_requirements_met()

int mandatory_requirements_met	(	kb_t	kb,
		nvti_t *	nvti
	)

Check whether mandatory requirements for plugin are met.

Parameters

kb	The knowledge base with all keys.
plugin	The scheduler plugin.

Returns

1 if all mandatory requirements for the plugin are met. 0 if it is not the case.

Definition at line 234 of file plugs_req.c.

{
  int ret;
 
  ret = check_mandatory_keys (kb, nvti_mandatory_keys (nvti));
 
  if (ret)
    return 0;
  return 1;
}

References check_mandatory_keys().

Referenced by launch_plugin().

Here is the call graph for this function:

Here is the caller graph for this function:

requirements_plugin()

char* requirements_plugin	(	kb_t	kb,
		nvti_t *	nvti
	)

Determine if the plugin requirements are met.

Returns

Returns NULL is everything is ok, else an error message.

Definition at line 251 of file plugs_req.c.

{
  static char error[64];
  char *errkey = NULL, *keys, *tcp, *udp;
  const char *opti = prefs_get ("optimization_level");
 
  /*
   * Check whether the good ports are open
   */
  error[sizeof (error) - 1] = '\0';
  tcp = nvti_required_ports (nvti);
  if (tcp && *tcp && (get_closed_ports (kb, tcp, "tcp")) == 0)
    {
      strncpy (error, "none of the required tcp ports are open",
               sizeof (error) - 1);
      return error;
    }
 
  udp = nvti_required_udp_ports (nvti);
  if (udp && *udp && (get_closed_ports (kb, udp, "udp")) == 0)
    {
      strncpy (error, "none of the required udp ports are open",
               sizeof (error) - 1);
      return error;
    }
 
  if (opti != NULL && (strcmp (opti, "open_ports") == 0 || atoi (opti) == 1))
    return NULL;
 
  /*
   * Check whether a key we wanted is missing
   */
  keys = nvti_required_keys (nvti);
  if (kb_missing_keyname_of_namelist (kb, keys, &errkey))
    {
      snprintf (error, sizeof (error), "because the key %s is missing", errkey);
      g_free (errkey);
      return error;
    }
 
  if (opti != NULL && (strcmp (opti, "required_keys") == 0 || atoi (opti) == 2))
    return NULL;
 
  /*
   * Check whether a key we do not want is present
   */
  keys = nvti_excluded_keys (nvti);
  if (kb_present_keyname_of_namelist (kb, keys, &errkey))
    {
      snprintf (error, sizeof (error), "because the key %s is present", errkey);
      g_free (errkey);
      return error;
    }
  return NULL;
}

References get_closed_ports(), kb_missing_keyname_of_namelist(), and kb_present_keyname_of_namelist().

Referenced by launch_plugin().

Here is the call graph for this function:

Here is the caller graph for this function: