hosts.c File Reference

Implementation of an API to handle Hosts objects. More...

#include "hosts.h"
#include "networking.h"
#include <arpa/inet.h>
#include <assert.h>
#include <ctype.h>
#include <malloc.h>
#include <netdb.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <unistd.h>

Include dependency graph for hosts.c:

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

Go to the source code of this file.

Macros
#define	G_LOG_DOMAIN   "libgvm base"
	GLib log domain.

Functions
static int	is_ipv4_address (const char *str)
	Checks if a buffer points to a valid IPv4 address. "192.168.11.1" is valid, "192.168.1.300" and "192.168.1.1e" are not.
static int	is_ipv6_address (const char *str)
	Checks if a buffer points to a valid IPv6 address. "0:0:0:0:0:0:0:1", "::1" and "::FFFF:192.168.13.55" are valid "::1g" is not.
static int	is_cidr_block (const char *str)
	Checks if a buffer points to an IPv4 CIDR-expressed block. "192.168.12.3/24" is valid, "192.168.1.3/31" is not.
static int	cidr_get_block (const char *str, unsigned int *block)
	Gets the network block value from a CIDR-expressed block string. For "192.168.1.1/24" it is 24.
static int	cidr_get_ip (const char *str, struct in_addr *addr)
	Gets the IPv4 value from a CIDR-expressed block. eg. For "192.168.1.10/24" it is "192.168.1.10".
static int	cidr_block_ips (const char *str, struct in_addr *first, struct in_addr *last)
	Gets the first and last usable IPv4 addresses from a CIDR-expressed block. eg. "192.168.1.0/24" would give 192.168.1.1 as first and 192.168.1.254 as last.
static int	is_long_range_network (const char *str)
	Checks if a buffer points to a valid long range-expressed network. "192.168.12.1-192.168.13.50" is valid.
static int	long_range_network_ips (const char *str, struct in_addr *first, struct in_addr *last)
	Gets the first and last IPv4 addresses from a long range-expressed network. eg. "192.168.1.1-192.168.2.40" would give 192.168.1.1 as first and 192.168.2.40 as last.
static int	is_short_range_network (const char *str)
	Checks if a buffer points to a valid short range-expressed network. "192.168.11.1-50" is valid, "192.168.1.1-50e" and "192.168.1.1-300" are not.
static int	short_range_network_ips (const char *str, struct in_addr *first, struct in_addr *last)
	Gets the first and last IPv4 addresses from a short range-expressed network. "192.168.1.1-40" would give 192.168.1.1 as first and 192.168.1.40 as last.
static int	is_hostname (const char *str)
	Checks if a buffer points to a valid hostname.
static int	is_cidr6_block (const char *str)
	Checks if a buffer points to an IPv6 CIDR-expressed block. "2620:0:2d0:200::7/120" is valid, "2620:0:2d0:200::7/129" is not.
static int	cidr6_get_block (const char *str, unsigned int *block)
	Gets the network block value from a CIDR-expressed block string. For "192.168.1.1/24" it is 24.
static int	cidr6_get_ip (const char *str, struct in6_addr *addr6)
	Gets the IPv4 value from a CIDR-expressed block. eg. For "192.168.1.10/24" it is "192.168.1.10".
static int	cidr6_block_ips (const char *str, struct in6_addr *first, struct in6_addr *last)
	Gets the first and last usable IPv4 addresses from a CIDR-expressed block. eg. "192.168.1.0/24 would give 192.168.1.1 as first and 192.168.1.254 as last. Thus, it skips the network and broadcast addresses.
static int	is_long_range6_network (const char *str)
	Checks if a buffer points to a valid long IPv6 range-expressed network. "::fee5-::1:530" is valid.
static int	long_range6_network_ips (const char *str, struct in6_addr *first, struct in6_addr *last)
	Gets the first and last IPv6 addresses from a long range-expressed network. eg. "::1:200:7-::1:205:500" would give ::1:200:7 as first and ::1:205:500 as last.
static int	is_short_range6_network (const char *str)
	Checks if a buffer points to a valid short IPv6 range-expressed network. "::200:ff:1-fee5" is valid.
static int	short_range6_network_ips (const char *str, struct in6_addr *first, struct in6_addr *last)
	Gets the first and last IPv6 addresses from a short range-expressed network. eg. "\::ffee:1:1001-1005" would give ::ffee:1:1001 as first and ::ffee:1:1005 as last.
int	gvm_get_host_type (const gchar *str_stripped)
	Determines the host type in a buffer.
gvm_vhost_t *	gvm_vhost_new (char *value, char *source)
	Creates a new gvm_vhost_t object.
static void	gvm_vhost_free (gpointer vhost)
	Frees the memory occupied by an gvm_vhost_t object.
gpointer	gvm_duplicate_vhost (gconstpointer vhost, gpointer data)
	Creates a deep copy of a gvm_vhost_t object.
static gvm_host_t *	gvm_host_new ()
	Creates a new gvm_host_t object.
void	gvm_host_free (gpointer host)
	Frees the memory occupied by an gvm_host_t object.
void	gvm_hosts_add (gvm_hosts_t *hosts, gvm_host_t *host)
	Inserts a host object at the end of a hosts collection.
static gvm_hosts_t *	gvm_hosts_init (const char *hosts_str)
	Creates a hosts collection from a hosts string.
static void	gvm_hosts_fill_gaps (gvm_hosts_t *hosts)
	Fill the gaps in the array of a hosts collection, which are caused by the removal of host entries.
static void	gvm_hosts_deduplicate (gvm_hosts_t *hosts)
	Removes duplicate hosts values from an gvm_hosts_t structure. Also resets the iterator current position.
gvm_hosts_t *	gvm_hosts_new_with_max (const gchar *hosts_str, unsigned int max_hosts)
	Creates a new gvm_hosts_t structure and the associated hosts objects from the provided hosts_str.
gvm_hosts_t *	gvm_hosts_new (const gchar *hosts_str)
	Creates a new gvm_hosts_t structure and the associated hosts objects from the provided hosts_str.
gvm_host_t *	gvm_hosts_next (gvm_hosts_t *hosts)
	Gets the next gvm_host_t from a gvm_hosts_t structure. The state of iteration is kept internally within the gvm_hosts structure.
void	gvm_hosts_move_current_host_to_end (gvm_hosts_t *hosts)
	Move the current gvm_host_t from a gvm_hosts_t structure to the end of the hosts list.
void	gvm_hosts_free (gvm_hosts_t *hosts)
	Frees memory occupied by an gvm_hosts_t structure.
void	gvm_hosts_shuffle (gvm_hosts_t *hosts)
	Randomizes the order of the hosts objects in the collection. Not to be used while iterating over the single hosts as it resets the iterator.
void	gvm_hosts_reverse (gvm_hosts_t *hosts)
	Reverses the order of the hosts objects in the collection. Not to be used while iterating over the single hosts as it resets the iterator.
GSList *	gvm_hosts_resolve (gvm_hosts_t *hosts)
	Resolves host objects of type name in a hosts collection, replacing hostnames with IPv4 values. Not to be used while iterating over the single hosts as it resets the iterator.
int	gvm_vhosts_exclude (gvm_host_t *host, const char *excluded_str)
	Exclude a list of vhosts from a host's vhosts list.
int	gvm_hosts_exclude_with_max (gvm_hosts_t *hosts, const char *excluded_str, unsigned int max_hosts)
	Excludes a set of hosts provided as a string from a hosts collection. Not to be used while iterating over the single hosts as it resets the iterator.
GSList *	gvm_hosts_allowed_only (gvm_hosts_t *hosts, const char *deny_hosts_str, const char *allow_hosts_str)
	Returns a list of hosts after a host authorization check.
int	gvm_hosts_exclude (gvm_hosts_t *hosts, const char *excluded_str)
	Excludes a set of hosts provided as a string from a hosts collection. Not to be used while iterating over the single hosts as it resets the iterator.
gvm_host_t *	gvm_host_from_str (const gchar *host_str)
	Creates a new gvm_host_t from a host string.
char *	gvm_host_reverse_lookup (gvm_host_t *host)
	Checks for a host object reverse dns lookup existence.
static int	host_name_verify (gvm_host_t *host, const char *value)
	Verifies that hostname value resolves to a host's IP.
void	gvm_host_add_reverse_lookup (gvm_host_t *host)
	Add a host's reverse-lookup name to the vhosts list.
gvm_hosts_t *	gvm_hosts_reverse_lookup_only_excluded (gvm_hosts_t *hosts)
	Removes hosts that don't reverse-lookup from the hosts collection. Not to be used while iterating over the single hosts as it resets the iterator.
int	gvm_hosts_reverse_lookup_only (gvm_hosts_t *hosts)
	Removes hosts that don't reverse-lookup from the hosts collection. Not to be used while iterating over the single hosts as it resets the iterator.
gvm_hosts_t *	gvm_hosts_reverse_lookup_unify_excluded (gvm_hosts_t *hosts)
	Removes hosts duplicates that reverse-lookup to the same value. Not to be used while iterating over the single hosts as it resets the iterator.
int	gvm_hosts_reverse_lookup_unify (gvm_hosts_t *hosts)
	Removes hosts duplicates that reverse-lookup to the same value. Not to be used while iterating over the single hosts as it resets the iterator.
unsigned int	gvm_hosts_count (const gvm_hosts_t *hosts)
	Gets the count of single hosts objects in a hosts collection.
unsigned int	gvm_hosts_removed (const gvm_hosts_t *hosts)
	Gets the count of single values in hosts string that were removed (duplicates / excluded.).
unsigned int	gvm_hosts_duplicated (const gvm_hosts_t *hosts)
	Gets the count of single values in hosts string that were duplicated and therefore removed from the list.
gvm_host_t *	gvm_host_find_in_hosts (const gvm_host_t *host, const struct in6_addr *addr, const gvm_hosts_t *hosts)
	Find the gvm_host_t from a gvm_hosts_t structure.
gvm_host_t *	gvm_duplicate_host (gvm_host_t *host)
	Creates a deep copy of a host. gvm_host_free has to be called on it.
int	gvm_host_in_hosts (const gvm_host_t *host, const struct in6_addr *addr, const gvm_hosts_t *hosts)
	Returns whether a host has an equal host in a hosts collection. eg. 192.168.10.1 has an equal in list created from "192.168.10.1-5, 192.168.10.10-20" string while 192.168.10.7 doesn't.
enum host_type	gvm_host_type (const gvm_host_t *host)
	Gets a host object's type.
gchar *	gvm_host_type_str (const gvm_host_t *host)
	Gets a host's type in printable format.
gchar *	gvm_host_value_str (const gvm_host_t *host)
	Gets a host's value in printable format.
int	gvm_host_resolve (const gvm_host_t *host, void *dst, int family)
	Resolves a host object's name to an IPv4 or IPv6 address. Host object should be of type HOST_TYPE_NAME.
int	gvm_host_get_addr6 (const gvm_host_t *host, struct in6_addr *ip6)
	Gives a host object's value as an IPv6 address. If the host type is hostname, it resolves the IPv4 address then gives an IPv4-mapped IPv6 address (eg. ::ffff:192.168.1.1 .) If the host type is IPv4, it gives an IPv4-mapped IPv6 address. If the host's type is IPv6, it gives the value directly.

Variables
gchar *	host_type_str [HOST_TYPE_MAX]

Detailed Description

Implementation of an API to handle Hosts objects.

This file contains all methods to handle Hosts collections (gvm_hosts_t) and single hosts objects (gvm_host_t.)

The module consequently uses glib datatypes.

Definition in file hosts.c.

Macro Definition Documentation

G_LOG_DOMAIN

#define G_LOG_DOMAIN   "libgvm base"

GLib log domain.

Definition at line 36 of file hosts.c.

Function Documentation

cidr6_block_ips()

int cidr6_block_ips ( const char * str, struct in6_addr * first, struct in6_addr * last )

static

Gets the first and last usable IPv4 addresses from a CIDR-expressed block. eg. "192.168.1.0/24 would give 192.168.1.1 as first and 192.168.1.254 as last. Thus, it skips the network and broadcast addresses.

Parameters

[in]	str	Buffer containing CIDR-expressed block.
[out]	first	First IPv4 address in block.
[out]	last	Last IPv4 address in block.

Returns

-1 if error, 0 else.

Definition at line 572 of file hosts.c.

{
  unsigned int block;
  int i, j;
 
  if (str == NULL || first == NULL || last == NULL)
    return -1;
 
  /* Get IP and block values. */
  if (cidr6_get_block (str, &block) == -1)
    return -1;
  if (cidr6_get_ip (str, first) == -1)
    return -1;
  memcpy (&last->s6_addr, &first->s6_addr, 16);
 
  /* /128 => Specified address is the first and last one. */
  if (block == 128)
    return 0;
 
  /* First IP: And with mask and increment to skip network address. */
  j = 15;
  for (i = (128 - block) / 8; i > 0; i--)
    {
      first->s6_addr[j] = 0;
      j--;
    }
  first->s6_addr[j] &= 0xff ^ ((1 << ((128 - block) % 8)) - 1);
 
  /* Last IP: Broadcast address - 1. */
  j = 15;
  for (i = (128 - block) / 8; i > 0; i--)
    {
      last->s6_addr[j] = 0xff;
      j--;
    }
  last->s6_addr[j] |= (1 << ((128 - block) % 8)) - 1;
 
  /* /127 => Only two addresses. Don't skip network / broadcast addresses.*/
  if (block == 127)
    return 0;
 
  /* Increment first IP. */
  for (i = 15; i >= 0; --i)
    if (first->s6_addr[i] < 255)
      {
        first->s6_addr[i]++;
        break;
      }
    else
      first->s6_addr[i] = 0;
  /* Decrement last IP. */
  for (i = 15; i >= 0; --i)
    if (last->s6_addr[i] > 0)
      {
        last->s6_addr[i]--;
        break;
      }
    else
      last->s6_addr[i] = 0xff;
 
  return 0;
}

References cidr6_get_block(), and cidr6_get_ip().

Referenced by gvm_hosts_new_with_max().

Here is the call graph for this function:

Here is the caller graph for this function:

cidr6_get_block()

int cidr6_get_block ( const char * str, unsigned int * block )

static

Gets the network block value from a CIDR-expressed block string. For "192.168.1.1/24" it is 24.

Parameters

[in]	str	Buffer containing CIDR-expressed block.
[out]	block	Variable to store block value.

Returns

-1 if error, 0 otherwise.

Definition at line 516 of file hosts.c.

{
  if (str == NULL || block == NULL)
    return -1;
 
  if (sscanf (str, "%*[0-9a-fA-F.:]/%3u", block) != 1)
    return -1;
 
  return 0;
}

Referenced by cidr6_block_ips().

Here is the caller graph for this function:

cidr6_get_ip()

int cidr6_get_ip ( const char * str, struct in6_addr * addr6 )

static

Gets the IPv4 value from a CIDR-expressed block. eg. For "192.168.1.10/24" it is "192.168.1.10".

Parameters

[in]	str	String containing CIDR-expressed block.
[out]	addr6	Variable to store the IPv4 address value.

Returns

-1 if error, 0 otherwise.

Definition at line 537 of file hosts.c.

{
  gchar *addr6_str, *tmp;
 
  if (str == NULL || addr6 == NULL)
    return -1;
 
  addr6_str = g_strdup (str);
  tmp = strchr (addr6_str, '/');
  if (tmp == NULL)
    {
      g_free (addr6_str);
      return -1;
    }
  *tmp = '\0';
 
  if (inet_pton (AF_INET6, addr6_str, addr6) != 1)
    return -1;
 
  g_free (addr6_str);
  return 0;
}

Referenced by cidr6_block_ips().

Here is the caller graph for this function:

cidr_block_ips()

int cidr_block_ips ( const char * str, struct in_addr * first, struct in_addr * last )

static

Gets the first and last usable IPv4 addresses from a CIDR-expressed block. eg. "192.168.1.0/24" would give 192.168.1.1 as first and 192.168.1.254 as last.

Both network and broadcast addresses are skipped:

• They are never used as a host address. Not being included is the expected behaviour from users.
• When needed, short/long ranges (eg. 192.168.1.0-255) are available.

Parameters

[in]	str	Buffer containing CIDR-expressed block.
[out]	first	First IPv4 address in block.
[out]	last	Last IPv4 address in block.

Returns

-1 if error, 0 else.

Definition at line 198 of file hosts.c.

{
  unsigned int block;
 
  if (str == NULL || first == NULL || last == NULL)
    return -1;
 
  /* Get IP and block values. */
  if (cidr_get_block (str, &block) == -1)
    return -1;
  if (cidr_get_ip (str, first) == -1)
    return -1;
 
  /* First IP: And with mask and increment. */
  first->s_addr &= htonl (0xffffffff ^ ((1 << (32 - block)) - 1));
  first->s_addr = htonl (ntohl (first->s_addr) + 1);
 
  /* Last IP: First IP + Number of usable hosts - 1. */
  last->s_addr = htonl (ntohl (first->s_addr) + (1 << (32 - block)) - 3);
  return 0;
}

References cidr_get_block(), and cidr_get_ip().

Referenced by gvm_hosts_new_with_max().

Here is the call graph for this function:

Here is the caller graph for this function:

cidr_get_block()

int cidr_get_block ( const char * str, unsigned int * block )

static

Gets the network block value from a CIDR-expressed block string. For "192.168.1.1/24" it is 24.

Parameters

[in]	str	Buffer containing CIDR-expressed block.
[out]	block	Variable to store block value.

Returns

-1 if error, 0 otherwise.

Definition at line 137 of file hosts.c.

{
  if (str == NULL || block == NULL)
    return -1;
 
  if (sscanf (str, "%*[0-9.]/%2u", block) != 1)
    return -1;
 
  return 0;
}

Referenced by cidr_block_ips().

Here is the caller graph for this function:

cidr_get_ip()

int cidr_get_ip ( const char * str, struct in_addr * addr )

static

Gets the IPv4 value from a CIDR-expressed block. eg. For "192.168.1.10/24" it is "192.168.1.10".

Parameters

[in]	str	String containing CIDR-expressed block.
[out]	addr	Variable to store the IPv4 address value.

Returns

-1 if error, 0 otherwise.

Definition at line 158 of file hosts.c.

{
  gchar *addr_str, *tmp;
 
  if (str == NULL || addr == NULL)
    return -1;
 
  addr_str = g_strdup (str);
  tmp = strchr (addr_str, '/');
  if (tmp == NULL)
    {
      g_free (addr_str);
      return -1;
    }
  *tmp = '\0';
 
  if (inet_pton (AF_INET, addr_str, addr) != 1)
    return -1;
 
  g_free (addr_str);
  return 0;
}

Referenced by cidr_block_ips().

Here is the caller graph for this function:

gvm_duplicate_host()

gvm_host_t * gvm_duplicate_host

(

gvm_host_t *

host

)

Creates a deep copy of a host. gvm_host_free has to be called on it.

Parameters

host	source host

Returns

gvm_host_t* copy of host

Definition at line 2198 of file hosts.c.

{
  gvm_host_t *ret = NULL;
 
  if (host == NULL)
    return NULL;
 
  ret = gvm_host_new ();
 
  ret->type = host->type;
  switch (host->type)
    {
    case HOST_TYPE_NAME:
      ret->name = g_strdup (host->name);
      break;
    case HOST_TYPE_IPV4:
      ret->addr.s_addr = host->addr.s_addr;
      break;
    case HOST_TYPE_IPV6:
      ret->addr6.__in6_u = host->addr6.__in6_u;
      break;
    default:
      g_free (ret);
      return NULL;
    }
  ret->vhosts = g_slist_copy_deep (host->vhosts, gvm_duplicate_vhost, NULL);
 
  return ret;
}

References gvm_host::addr, gvm_host::addr6, gvm_duplicate_vhost(), gvm_host_new(), HOST_TYPE_IPV4, HOST_TYPE_IPV6, HOST_TYPE_NAME, gvm_host::name, gvm_host::type, and gvm_host::vhosts.

Referenced by gvm_hosts_reverse_lookup_only_excluded(), and gvm_hosts_reverse_lookup_unify_excluded().

Here is the call graph for this function:

Here is the caller graph for this function:

gvm_duplicate_vhost()

gpointer gvm_duplicate_vhost	(	gconstpointer	vhost,
		gpointer	data )

Creates a deep copy of a gvm_vhost_t object.

Parameters

vhost	source vhost
data	dummy for g_slist_copy_deep

Returns

gpointer copy of vhost

Definition at line 909 of file hosts.c.

{
  (void) (data);
  gvm_vhost_t *ret = NULL;
 
  if (!vhost)
    return NULL;
 
  ret = gvm_vhost_new (g_strdup (((gvm_vhost_t *) vhost)->value),
                       g_strdup (((gvm_vhost_t *) vhost)->source));
 
  return ret;
}

References gvm_vhost_new().

Referenced by gvm_duplicate_host().

Here is the call graph for this function:

Here is the caller graph for this function:

gvm_get_host_type()

int gvm_get_host_type

(

const gchar *

str_stripped

)

Determines the host type in a buffer.

Parameters

[in]

str_stripped

Buffer that contains host definition, could a be hostname, single IPv4 or IPv6, CIDR-expressed block etc,.

Returns

Host_TYPE_*, -1 if error.

Definition at line 813 of file hosts.c.

{
  /*
   * We have a single element with no leading or trailing
   * white spaces. This element could represent different host
   * definitions: single IPs, host names, CIDR-expressed blocks,
   * range-expressed networks, IPv6 addresses.
   */
 
  /* Null or empty string. */
  if (str_stripped == NULL || *str_stripped == '\0')
    return -1;
 
  /* Check for regular single IPv4 address. */
  if (is_ipv4_address (str_stripped))
    return HOST_TYPE_IPV4;
 
  /* Check for regular single IPv6 address. */
  if (is_ipv6_address (str_stripped))
    return HOST_TYPE_IPV6;
 
  /* Check for regular IPv4 CIDR-expressed block like "192.168.12.0/24" */
  if (is_cidr_block (str_stripped))
    return HOST_TYPE_CIDR_BLOCK;
 
  /* Check for short range-expressed networks "192.168.12.5-40" */
  if (is_short_range_network (str_stripped))
    return HOST_TYPE_RANGE_SHORT;
 
  /* Check for long range-expressed networks "192.168.1.0-192.168.3.44" */
  if (is_long_range_network (str_stripped))
    return HOST_TYPE_RANGE_LONG;
 
  /* Check for regular IPv6 CIDR-expressed block like "2620:0:2d0:200::7/120" */
  if (is_cidr6_block (str_stripped))
    return HOST_TYPE_CIDR6_BLOCK;
 
  /* Check for short range-expressed networks "::1-ef12" */
  if (is_short_range6_network (str_stripped))
    return HOST_TYPE_RANGE6_SHORT;
 
  /* Check for long IPv6 range-expressed networks like "::1:20:7-::1:25:3" */
  if (is_long_range6_network (str_stripped))
    return HOST_TYPE_RANGE6_LONG;
 
  /* Check for hostname. */
  if (is_hostname (str_stripped))
    return HOST_TYPE_NAME;
 
  return -1;
}

References HOST_TYPE_CIDR6_BLOCK, HOST_TYPE_CIDR_BLOCK, HOST_TYPE_IPV4, HOST_TYPE_IPV6, HOST_TYPE_NAME, HOST_TYPE_RANGE6_LONG, HOST_TYPE_RANGE6_SHORT, HOST_TYPE_RANGE_LONG, HOST_TYPE_RANGE_SHORT, is_cidr6_block(), is_cidr_block(), is_hostname(), is_ipv4_address(), is_ipv6_address(), is_long_range6_network(), is_long_range_network(), is_short_range6_network(), and is_short_range_network().

Referenced by Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), gvm_host_from_str(), gvm_hosts_new_with_max(), gvm_server_open_verify(), and osp_send_command().

Here is the call graph for this function:

Here is the caller graph for this function:

gvm_host_add_reverse_lookup()

void gvm_host_add_reverse_lookup

(

gvm_host_t *

host

)

Add a host's reverse-lookup name to the vhosts list.

Parameters

[in]

host

The host to which we add the vhost.

Definition at line 1920 of file hosts.c.

{
  GSList *vhosts;
  gvm_vhost_t *vhost;
  char *value;
 
  if (!host || host->type == HOST_TYPE_NAME)
    return;
 
  value = gvm_host_reverse_lookup (host);
  if (!value)
    return;
  if (host_name_verify (host, value))
    {
      g_free (value);
      return;
    }
  /* Don't add vhost, if already in the list. */
  vhosts = host->vhosts;
  while (vhosts)
    {
      if (!strcasecmp (((gvm_vhost_t *) vhosts->data)->value, value))
        {
          g_free (value);
          return;
        }
      vhosts = vhosts->next;
    }
  vhost = gvm_vhost_new (value, g_strdup ("Reverse-DNS"));
  host->vhosts = g_slist_prepend (host->vhosts, vhost);
}

References gvm_host_reverse_lookup(), gvm_vhost_new(), host_name_verify(), HOST_TYPE_NAME, gvm_host::type, and gvm_host::vhosts.

Here is the call graph for this function:

gvm_host_find_in_hosts()

gvm_host_t * gvm_host_find_in_hosts	(	const gvm_host_t *	host,
		const struct in6_addr *	addr,
		const gvm_hosts_t *	hosts )

Find the gvm_host_t from a gvm_hosts_t structure.

Parameters

[in]	host	The host object.
[in]	addr	Optional pointer to ip address. Could be used so that host isn't resolved multiple times when type is HOST_TYPE_NAME.
[in]	hosts	Hosts collection.

Returns

Pointer to host if found. NULL if error or host not found

Definition at line 2149 of file hosts.c.

{
  char *host_str;
  size_t i;
 
  if (host == NULL || hosts == NULL)
    return NULL;
 
  host_str = gvm_host_value_str (host);
 
  for (i = 0; i < hosts->count; i++)
    {
      gvm_host_t *current_host = hosts->hosts[i];
      char *tmp = gvm_host_value_str (current_host);
 
      if (strcasecmp (host_str, tmp) == 0)
        {
          g_free (host_str);
          g_free (tmp);
          return current_host;
        }
      g_free (tmp);
 
      /* Hostnames in hosts list shouldn't be resolved. */
      if (addr && gvm_host_type (current_host) != HOST_TYPE_NAME)
        {
          struct in6_addr tmpaddr;
          gvm_host_get_addr6 (current_host, &tmpaddr);
 
          if (memcmp (addr->s6_addr, &tmpaddr.s6_addr, 16) == 0)
            {
              g_free (host_str);
              return current_host;
            }
        }
    }
 
  g_free (host_str);
  return NULL;
}

References gvm_hosts::count, gvm_host_get_addr6(), gvm_host_type(), gvm_host_value_str(), HOST_TYPE_NAME, and gvm_hosts::hosts.

Referenced by gvm_host_in_hosts().

Here is the call graph for this function:

Here is the caller graph for this function:

gvm_host_free()

void gvm_host_free

(

gpointer

host

)

Frees the memory occupied by an gvm_host_t object.

Parameters

[in]

host

Host to free.

Definition at line 944 of file hosts.c.

{
  gvm_host_t *h = host;
  if (h == NULL)
    return;
 
  /* If host of type hostname, free the name buffer, first. */
  if (h->type == HOST_TYPE_NAME)
    g_free (h->name);
 
  g_slist_free_full (h->vhosts, gvm_vhost_free);
  g_free (h);
}

References gvm_vhost_free(), HOST_TYPE_NAME, gvm_host::name, gvm_host::type, and gvm_host::vhosts.

Referenced by gvm_hosts_allowed_only(), gvm_hosts_deduplicate(), gvm_hosts_exclude_with_max(), gvm_hosts_free(), gvm_hosts_resolve(), gvm_hosts_reverse_lookup_only_excluded(), and gvm_hosts_reverse_lookup_unify_excluded().

Here is the call graph for this function:

Here is the caller graph for this function:

gvm_host_from_str()

gvm_host_t * gvm_host_from_str

(

const gchar *

host_str

)

Creates a new gvm_host_t from a host string.

Parameters

[in]

host_str

The host string can consist of a hostname, IPv4 address or IPv6 address.

Returns

NULL if error. Otherwise, a single host structure that should be put into a gvm_hosts_t structure for freeing with gvm_hosts_free or freed directly via gvm_host_free.

Definition at line 1786 of file hosts.c.

{
  int host_type;
 
  if (host_str == NULL)
    return NULL;
 
  /* IPv4, hostname, IPv6 */
  /* -1 if error. */
  host_type = gvm_get_host_type (host_str);
 
  switch (host_type)
    {
    case HOST_TYPE_NAME:
    case HOST_TYPE_IPV4:
    case HOST_TYPE_IPV6:
      {
        /* New host. */
        gvm_host_t *host = gvm_host_new ();
        host->type = host_type;
        if (host_type == HOST_TYPE_NAME)
          host->name = g_ascii_strdown (host_str, -1);
        else if (host_type == HOST_TYPE_IPV4)
          {
            if (inet_pton (AF_INET, host_str, &host->addr) != 1)
              break;
          }
        else if (host_type == HOST_TYPE_IPV6)
          {
            if (inet_pton (AF_INET6, host_str, &host->addr6) != 1)
              break;
          }
        return host;
      }
    case -1:
    default:
      return NULL;
    }
  return NULL;
}

References gvm_host::addr, gvm_host::addr6, gvm_get_host_type(), gvm_host_new(), HOST_TYPE_IPV4, HOST_TYPE_IPV6, HOST_TYPE_NAME, gvm_host::name, and gvm_host::type.

Here is the call graph for this function:

gvm_host_get_addr6()

int gvm_host_get_addr6	(	const gvm_host_t *	host,
		struct in6_addr *	ip6 )

Gives a host object's value as an IPv6 address. If the host type is hostname, it resolves the IPv4 address then gives an IPv4-mapped IPv6 address (eg. ::ffff:192.168.1.1 .) If the host type is IPv4, it gives an IPv4-mapped IPv6 address. If the host's type is IPv6, it gives the value directly.

Parameters

[in]	host	The host object whose value to get as IPv6.
[out]	ip6	Buffer to store the IPv6 address.

Returns

-1 if error, 0 otherwise.

Definition at line 2367 of file hosts.c.

{
  if (host == NULL || ip6 == NULL)
    return -1;
 
  switch (gvm_host_type (host))
    {
    case HOST_TYPE_IPV6:
      memcpy (ip6, &host->addr6, sizeof (struct in6_addr));
      return 0;
 
    case HOST_TYPE_IPV4:
      ipv4_as_ipv6 (&host->addr, ip6);
      return 0;
 
    case HOST_TYPE_NAME:
      {
        struct in_addr ip4;
 
        /* Fail if IPv4 and IPv6 both don't resolve. */
        if (gvm_host_resolve (host, &ip4, AF_INET) == 0)
          ipv4_as_ipv6 (&ip4, ip6);
        else if (gvm_host_resolve (host, ip6, AF_INET6) == -1)
          return -1;
        return 0;
      }
 
    default:
      return -1;
    }
}

References gvm_host::addr, gvm_host::addr6, gvm_host_resolve(), gvm_host_type(), HOST_TYPE_IPV4, HOST_TYPE_IPV6, HOST_TYPE_NAME, and ipv4_as_ipv6().

Referenced by gvm_host_find_in_hosts().

Here is the call graph for this function:

Here is the caller graph for this function:

gvm_host_in_hosts()

int gvm_host_in_hosts	(	const gvm_host_t *	host,
		const struct in6_addr *	addr,
		const gvm_hosts_t *	hosts )

Returns whether a host has an equal host in a hosts collection. eg. 192.168.10.1 has an equal in list created from "192.168.10.1-5, 192.168.10.10-20" string while 192.168.10.7 doesn't.

Parameters

[in]	host	The host object.
[in]	addr	Optional pointer to ip address. Could be used so that host isn't resolved multiple times when type is HOST_TYPE_NAME.
[in]	hosts	Hosts collection.

Returns

1 if host has equal in hosts, 0 otherwise.

Definition at line 2241 of file hosts.c.

{
  if (gvm_host_find_in_hosts (host, addr, hosts))
    return 1;
 
  return 0;
}

References gvm_host_find_in_hosts().

Here is the call graph for this function:

gvm_host_new()

gvm_host_t * gvm_host_new ( )

static

Creates a new gvm_host_t object.

Returns

Pointer to new host object, NULL if creation fails.

Definition at line 929 of file hosts.c.

{
  gvm_host_t *host;
 
  host = g_malloc0 (sizeof (gvm_host_t));
 
  return host;
}

Referenced by gvm_duplicate_host(), gvm_host_from_str(), gvm_hosts_new_with_max(), and gvm_hosts_resolve().

Here is the caller graph for this function:

gvm_host_resolve()

int gvm_host_resolve	(	const gvm_host_t *	host,
		void *	dst,
		int	family )

Resolves a host object's name to an IPv4 or IPv6 address. Host object should be of type HOST_TYPE_NAME.

Parameters

[in]	host	The host object whose name to resolve.
[out]	dst	Buffer to store resolved address. Size must be at least 4 bytes for AF_INET and 16 bytes for AF_INET6.
[in]	family	Either AF_INET or AF_INET6.

Returns

-1 if error, 0 otherwise.

Definition at line 2346 of file hosts.c.

{
  if (host == NULL || dst == NULL || host->type != HOST_TYPE_NAME)
    return -1;
 
  return gvm_resolve (host->name, dst, family);
}

References gvm_resolve(), HOST_TYPE_NAME, gvm_host::name, and gvm_host::type.

Referenced by gvm_host_get_addr6().

Here is the call graph for this function:

Here is the caller graph for this function:

gvm_host_reverse_lookup()

char * gvm_host_reverse_lookup

(

gvm_host_t *

host

)

Checks for a host object reverse dns lookup existence.

Parameters

[in]

host

The host to reverse-lookup.

Returns

Result of look-up, NULL otherwise.

Definition at line 1835 of file hosts.c.

{
  int retry = 10;
  gchar hostname[NI_MAXHOST];
  void *addr;
  size_t addrlen;
  struct sockaddr_in sa;
  struct sockaddr_in6 sa6;
 
  if (!host)
    return NULL;
 
  if (host->type == HOST_TYPE_IPV4)
    {
      addr = &sa;
      addrlen = sizeof (sa);
      memset (addr, '\0', addrlen);
      sa.sin_addr = host->addr;
      sa.sin_family = AF_INET;
    }
  else if (host->type == HOST_TYPE_IPV6)
    {
      addr = &sa6;
      addrlen = sizeof (sa6);
      memset (&sa6, '\0', addrlen);
      memcpy (&sa6.sin6_addr, &host->addr6, 16);
      sa6.sin6_family = AF_INET6;
    }
  else
    return NULL;
 
  while (retry--)
    {
      int ret = getnameinfo (addr, addrlen, hostname, sizeof (hostname), NULL,
                             0, NI_NAMEREQD);
      if (!ret)
        return g_ascii_strdown (hostname, -1);
      if (ret != EAI_AGAIN)
        break;
      usleep (10000); // 10ms
    }
  return NULL;
}

References gvm_host::addr, gvm_host::addr6, HOST_TYPE_IPV4, HOST_TYPE_IPV6, and gvm_host::type.

Referenced by gvm_host_add_reverse_lookup(), gvm_hosts_reverse_lookup_only_excluded(), and gvm_hosts_reverse_lookup_unify_excluded().

Here is the caller graph for this function:

gvm_host_type()

enum host_type gvm_host_type

(

const gvm_host_t *

host

)

Gets a host object's type.

Parameters

[in]

host

The host object.

Returns

Host type.

Definition at line 2258 of file hosts.c.

{
  assert (host);
  return host->type;
}

References gvm_host::type.

Referenced by gvm_host_find_in_hosts(), and gvm_host_get_addr6().

Here is the caller graph for this function:

gvm_host_type_str()

gchar * gvm_host_type_str

(

const gvm_host_t *

host

)

Gets a host's type in printable format.

Parameters

[in]

host

The host object.

Returns

String representing host type. Statically allocated, thus, not to be freed.

Definition at line 2273 of file hosts.c.

{
  if (host == NULL)
    return NULL;
 
  return host_type_str[host->type];
}

References host_type_str, and gvm_host::type.

gvm_host_value_str()

gchar * gvm_host_value_str

(

const gvm_host_t *

host

)

Gets a host's value in printable format.

Parameters

[in]

host

The host object.

Returns

String representing host value. To be freed with g_free().

Definition at line 2289 of file hosts.c.

{
  if (host == NULL)
    return NULL;
 
  switch (host->type)
    {
    case HOST_TYPE_NAME:
      return g_strdup (host->name);
      break;
    case HOST_TYPE_IPV4:
    case HOST_TYPE_IPV6:
      /* Handle both cases using inet_ntop(). */
      {
        int family, size;
        gchar *str;
        const void *srcaddr;
 
        if (host->type == HOST_TYPE_IPV4)
          {
            family = AF_INET;
            size = INET_ADDRSTRLEN;
            srcaddr = &host->addr;
          }
        else
          {
            family = AF_INET6;
            size = INET6_ADDRSTRLEN;
            srcaddr = &host->addr6;
          }
 
        str = g_malloc0 (size);
        if (inet_ntop (family, srcaddr, str, size) == NULL)
          {
            perror ("inet_ntop");
            g_free (str);
            return NULL;
          }
        return str;
      }
    default:
      return g_strdup ("Erroneous host type: Should be Hostname/IPv4/IPv6.");
    }
}

References gvm_host::addr, gvm_host::addr6, HOST_TYPE_IPV4, HOST_TYPE_IPV6, HOST_TYPE_NAME, gvm_host::name, and gvm_host::type.

Referenced by Ensure(), gvm_host_find_in_hosts(), gvm_hosts_allowed_only(), gvm_hosts_deduplicate(), gvm_hosts_exclude_with_max(), host_name_verify(), and host_value_eq().

Here is the caller graph for this function:

gvm_hosts_add()

void gvm_hosts_add	(	gvm_hosts_t *	hosts,
		gvm_host_t *	host )

Inserts a host object at the end of a hosts collection.

Parameters

[in]	hosts	Hosts in which to insert the host.
[in]	host	Host to insert.

Definition at line 965 of file hosts.c.

{
  if (hosts->count == hosts->max_size)
    {
      hosts->max_size *= 4;
      hosts->hosts =
        g_realloc_n (hosts->hosts, hosts->max_size, sizeof (*hosts->hosts));
      memset (hosts->hosts + hosts->count, '\0',
              (hosts->max_size - hosts->count) * sizeof (gvm_host_t *));
    }
  hosts->hosts[hosts->count] = host;
  hosts->count++;
}

References gvm_hosts::count, gvm_hosts::hosts, and gvm_hosts::max_size.

Referenced by gvm_hosts_new_with_max(), gvm_hosts_resolve(), gvm_hosts_reverse_lookup_only_excluded(), and gvm_hosts_reverse_lookup_unify_excluded().

Here is the caller graph for this function:

gvm_hosts_allowed_only()

GSList * gvm_hosts_allowed_only	(	gvm_hosts_t *	hosts,
		const char *	deny_hosts_str,
		const char *	allow_hosts_str )

Returns a list of hosts after a host authorization check.

Parameters

[in,out]	hosts	The hosts collection from which to exclude.
[in]	deny_hosts_str	String of denied hosts. This hosts will be removed from the hosts list
[in]	allow_hosts_str	String of allow hosts. This hosts will be kept in the hosts list

Returns

List of non-authorized hosts if any, otherwise Null. The returned list must be free()'d by the caller functions.

Uses a hash table in order to exclude hosts in O(N+M) time.

Definition at line 1657 of file hosts.c.

{
  gvm_hosts_t *allowed_hosts, *denied_hosts;
  GHashTable *name_allow_table = NULL, *name_deny_table = NULL;
  GSList *removed = NULL;
  size_t excluded = 0, i;
 
  if (hosts == NULL || (deny_hosts_str == NULL && allow_hosts_str == NULL))
    return NULL;
 
  // Prepare list of denied and allowed hosts
  denied_hosts = gvm_hosts_new_with_max (deny_hosts_str, 0);
  allowed_hosts = gvm_hosts_new_with_max (allow_hosts_str, 0);
  if (denied_hosts == NULL && allowed_hosts == NULL)
    return NULL;
 
  if (gvm_hosts_count (denied_hosts) == 0)
    gvm_hosts_free (denied_hosts);
  else
    {
      /* Hash host values from denied hosts list. */
      name_deny_table =
        g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
      for (i = 0; i < denied_hosts->count; i++)
        {
          gchar *name;
 
          name = gvm_host_value_str (denied_hosts->hosts[i]);
          if (name)
            g_hash_table_insert (name_deny_table, name, hosts);
        }
    }
  if (gvm_hosts_count (allowed_hosts) == 0)
    gvm_hosts_free (allowed_hosts);
  else
    {
      /* Hash host values from allowed hosts list. */
      name_allow_table =
        g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
      for (i = 0; i < allowed_hosts->count; i++)
        {
          gchar *name;
 
          name = gvm_host_value_str (allowed_hosts->hosts[i]);
          if (name)
            g_hash_table_insert (name_allow_table, name, hosts);
        }
    }
 
  /* Check for authorized hosts in hash table and create a list of removed
   * hosts. */
  for (i = 0; i < hosts->count; i++)
    {
      gchar *name;
 
      name = gvm_host_value_str (hosts->hosts[i]);
      if (name)
        {
          if (denied_hosts != NULL
              && g_hash_table_lookup (name_deny_table, name))
            {
              gvm_host_free (hosts->hosts[i]);
              hosts->hosts[i] = NULL;
              excluded++;
              removed = g_slist_prepend (removed, name);
              continue;
            }
          else if (allowed_hosts != NULL
                   && !g_hash_table_lookup (name_allow_table, name))
            {
              gvm_host_free (hosts->hosts[i]);
              hosts->hosts[i] = NULL;
              excluded++;
              removed = g_slist_prepend (removed, name);
              continue;
            }
          g_free (name);
        }
    }
 
  /* Cleanup. */
  if (excluded)
    gvm_hosts_fill_gaps (hosts);
 
  hosts->count -= excluded;
  hosts->removed += excluded;
  hosts->current = 0;
  if (name_allow_table != NULL)
    g_hash_table_destroy (name_allow_table);
  if (name_deny_table != NULL)
    g_hash_table_destroy (name_deny_table);
  if (allowed_hosts != NULL)
    gvm_hosts_free (allowed_hosts);
  if (denied_hosts != NULL)
    gvm_hosts_free (denied_hosts);
  return removed;
}

References gvm_hosts::count, gvm_hosts::current, gvm_host_free(), gvm_host_value_str(), gvm_hosts_count(), gvm_hosts_fill_gaps(), gvm_hosts_free(), gvm_hosts_new_with_max(), gvm_hosts::hosts, and gvm_hosts::removed.

Referenced by Ensure(), and main().

Here is the call graph for this function:

Here is the caller graph for this function:

gvm_hosts_count()

unsigned int gvm_hosts_count

(

const gvm_hosts_t *

hosts

)

Gets the count of single hosts objects in a hosts collection.

Parameters

[in]

hosts

The hosts collection to count hosts of.

Returns

The number of single hosts.

Definition at line 2105 of file hosts.c.

{
  return hosts ? hosts->count : 0;
}

References gvm_hosts::count.

Referenced by Ensure(), Ensure(), gvm_hosts_allowed_only(), and gvm_hosts_exclude_with_max().

Here is the caller graph for this function:

gvm_hosts_deduplicate()

void gvm_hosts_deduplicate ( gvm_hosts_t * hosts )

static

Removes duplicate hosts values from an gvm_hosts_t structure. Also resets the iterator current position.

Parameters

[in]

hosts

hosts collection from which to remove duplicates.

Uses a hash table in order to deduplicate the hosts list in O(N) time.

Definition at line 1043 of file hosts.c.

{
  GHashTable *name_table;
  size_t i, duplicates = 0;
 
  if (hosts == NULL)
    return;
  name_table = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
 
  for (i = 0; i < hosts->count; i++)
    {
      gchar *name;
 
      name = gvm_host_value_str (hosts->hosts[i]);
      if (name)
        {
          gvm_host_t *host, *removed = hosts->hosts[i];
 
          host = g_hash_table_lookup (name_table, name);
          if (host)
            {
              /* Remove duplicate host. Add its vhosts to the original host. */
              host->vhosts = g_slist_concat (host->vhosts, removed->vhosts);
              removed->vhosts = NULL;
              gvm_host_free (removed);
              hosts->hosts[i] = NULL;
              duplicates++;
              g_free (name);
            }
          else
            g_hash_table_insert (name_table, name, hosts->hosts[i]);
        }
    }
 
  if (duplicates)
    gvm_hosts_fill_gaps (hosts);
  g_hash_table_destroy (name_table);
  hosts->count -= duplicates;
  hosts->duplicated += duplicates;
  hosts->current = 0;
#ifdef __GLIBC__
  malloc_trim (0);
#endif
}

References gvm_hosts::count, gvm_hosts::current, gvm_hosts::duplicated, gvm_host_free(), gvm_host_value_str(), gvm_hosts_fill_gaps(), gvm_hosts::hosts, and gvm_host::vhosts.

Referenced by gvm_hosts_new_with_max(), and gvm_hosts_resolve().

Here is the call graph for this function:

Here is the caller graph for this function:

gvm_hosts_duplicated()

unsigned int gvm_hosts_duplicated

(

const gvm_hosts_t *

hosts

)

Gets the count of single values in hosts string that were duplicated and therefore removed from the list.

Parameters

[in]

hosts

The hosts collection.

Returns

The number of duplicated values.

Definition at line 2133 of file hosts.c.

{
  return hosts ? hosts->duplicated : 0;
}

References gvm_hosts::duplicated.

gvm_hosts_exclude()

int gvm_hosts_exclude	(	gvm_hosts_t *	hosts,
		const char *	excluded_str )

Excludes a set of hosts provided as a string from a hosts collection. Not to be used while iterating over the single hosts as it resets the iterator.

Parameters

[in]	hosts	The hosts collection from which to exclude.
[in]	excluded_str	String of hosts to exclude.

Returns

Number of excluded hosts, -1 if error.

Definition at line 1770 of file hosts.c.

{
  return gvm_hosts_exclude_with_max (hosts, excluded_str, 0);
}

References gvm_hosts_exclude_with_max().

Here is the call graph for this function:

gvm_hosts_exclude_with_max()

int gvm_hosts_exclude_with_max	(	gvm_hosts_t *	hosts,
		const char *	excluded_str,
		unsigned int	max_hosts )

Excludes a set of hosts provided as a string from a hosts collection. Not to be used while iterating over the single hosts as it resets the iterator.

Parameters

[in,out]	hosts	The hosts collection from which to exclude.
[in]	excluded_str	String of hosts to exclude.
[in]	max_hosts	Max number of hosts in hosts_str. 0 means unlimited.

Returns

Number of excluded hosts, -1 if error.

Uses a hash table in order to exclude hosts in O(N+M) time.

Definition at line 1579 of file hosts.c.

{
  gvm_hosts_t *excluded_hosts;
  GHashTable *name_table;
  size_t excluded = 0, i;
 
  if (hosts == NULL || excluded_str == NULL)
    return -1;
 
  excluded_hosts = gvm_hosts_new_with_max (excluded_str, max_hosts);
  if (excluded_hosts == NULL)
    return -1;
 
  if (gvm_hosts_count (excluded_hosts) == 0)
    {
      gvm_hosts_free (excluded_hosts);
      return 0;
    }
 
  /* Hash host values from excluded hosts list. */
  name_table = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
  for (i = 0; i < excluded_hosts->count; i++)
    {
      gchar *name;
 
      name = gvm_host_value_str (excluded_hosts->hosts[i]);
      if (name)
        g_hash_table_insert (name_table, name, hosts);
    }
 
  /* Check for hosts values in hash table. */
  for (i = 0; i < hosts->count; i++)
    {
      gchar *name;
 
      name = gvm_host_value_str (hosts->hosts[i]);
      if (name)
        {
          if (g_hash_table_lookup (name_table, name))
            {
              gvm_host_free (hosts->hosts[i]);
              hosts->hosts[i] = NULL;
              excluded++;
              g_free (name);
              continue;
            }
          g_free (name);
        }
    }
 
  /* Cleanup. */
  if (excluded)
    gvm_hosts_fill_gaps (hosts);
  hosts->count -= excluded;
  hosts->removed += excluded;
  hosts->current = 0;
  g_hash_table_destroy (name_table);
  gvm_hosts_free (excluded_hosts);
  return excluded;
}

References gvm_hosts::count, gvm_hosts::current, gvm_host_free(), gvm_host_value_str(), gvm_hosts_count(), gvm_hosts_fill_gaps(), gvm_hosts_free(), gvm_hosts_new_with_max(), gvm_hosts::hosts, and gvm_hosts::removed.

Referenced by gvm_hosts_exclude().

Here is the call graph for this function:

Here is the caller graph for this function:

gvm_hosts_fill_gaps()

void gvm_hosts_fill_gaps ( gvm_hosts_t * hosts )

static

Fill the gaps in the array of a hosts collection, which are caused by the removal of host entries.

Parameters

[in]

hosts

Hosts collection to fill gaps in.

Definition at line 1005 of file hosts.c.

{
  size_t i;
  if (!hosts)
    return;
 
  for (i = 0; i < hosts->max_size; i++)
    {
      if (!hosts->hosts[i])
        {
          size_t j;
 
          /* Fill the gap with the closest host entry, in order to keep the
           * sequential ordering. */
          for (j = i + 1; j < hosts->max_size; j++)
            {
              if (hosts->hosts[j])
                {
                  hosts->hosts[i] = hosts->hosts[j];
                  hosts->hosts[j] = NULL;
                  break;
                }
            }
          /* No more entries left, ie. the empty space between count and
           * max_size. */
          if (!hosts->hosts[i])
            return;
        }
    }
}

References gvm_hosts::hosts, and gvm_hosts::max_size.

Referenced by gvm_hosts_allowed_only(), gvm_hosts_deduplicate(), gvm_hosts_exclude_with_max(), gvm_hosts_resolve(), gvm_hosts_reverse_lookup_only_excluded(), and gvm_hosts_reverse_lookup_unify_excluded().

Here is the caller graph for this function:

gvm_hosts_free()

void gvm_hosts_free

(

gvm_hosts_t *

hosts

)

Frees memory occupied by an gvm_hosts_t structure.

Parameters

[in]

hosts

The hosts collection to free.

Definition at line 1375 of file hosts.c.

{
  size_t i;
 
  if (hosts == NULL)
    return;
 
  g_free (hosts->orig_str);
  for (i = 0; i < hosts->count; i++)
    gvm_host_free (hosts->hosts[i]);
  g_free (hosts->hosts);
  g_free (hosts);
  hosts = NULL;
}

References gvm_hosts::count, gvm_host_free(), gvm_hosts::hosts, and gvm_hosts::orig_str.

Referenced by Ensure(), Ensure(), Ensure(), Ensure(), gvm_hosts_allowed_only(), gvm_hosts_exclude_with_max(), gvm_hosts_new_with_max(), gvm_hosts_reverse_lookup_only(), and gvm_hosts_reverse_lookup_unify().

Here is the call graph for this function:

Here is the caller graph for this function:

gvm_hosts_init()

gvm_hosts_t * gvm_hosts_init ( const char * hosts_str )

static

Creates a hosts collection from a hosts string.

Parameters

[in]

hosts_str

String of hosts.

Returns

Hosts collection.

Definition at line 987 of file hosts.c.

{
  gvm_hosts_t *hosts;
 
  hosts = g_malloc0 (sizeof (gvm_hosts_t));
  hosts->max_size = 1024;
  hosts->hosts = g_malloc0_n (hosts->max_size, sizeof (gvm_host_t *));
  hosts->orig_str = g_strdup (hosts_str);
  return hosts;
}

References gvm_hosts::hosts, gvm_hosts::max_size, and gvm_hosts::orig_str.

Referenced by gvm_hosts_new_with_max().

Here is the caller graph for this function:

gvm_hosts_move_current_host_to_end()

void gvm_hosts_move_current_host_to_end

(

gvm_hosts_t *

hosts

)

Move the current gvm_host_t from a gvm_hosts_t structure to the end of the hosts list.

Parameters

[in,out]

hosts

gvm_hosts_t structure which hosts must be rearange. The hosts->current index points to the last used host and gvm_hosts_next() must be called to get the next host in the list.

Definition at line 1332 of file hosts.c.

{
  void *host_tmp;
  size_t i;
 
  if (!hosts)
    return;
 
  // Keep in mind that gvm_hosts_next will return the current host and then
  // increment hosts->current.
 
  if (hosts->current == hosts->count)
    {
      // We're on the last host, just make the previous host current.
      // TODO what happens when current is 0?
      hosts->current -= 1;
      return;
    }
 
  // Make the previous host current. This makes sure that gvm_hosts_next will
  // return the host that has replaced the current host.
  // TODO what happens when current is 0?
  hosts->current -= 1;
  // Get the host to be moved.
  host_tmp = hosts->hosts[hosts->current];
 
  // Shift all the others down. Start from current + 1 because we're assigning
  // into the previous slot (i - 1). It's safe to do this because we already
  // checked if current == count above.
  for (i = hosts->current + 1; i < hosts->count; i++)
    hosts->hosts[i - 1] = hosts->hosts[i];
 
  // Put the moved host on the end.
  hosts->hosts[hosts->count - 1] = host_tmp;
}

References gvm_hosts::count, gvm_hosts::current, and gvm_hosts::hosts.

Referenced by Ensure().

Here is the caller graph for this function:

gvm_hosts_new()

gvm_hosts_t * gvm_hosts_new

(

const gchar *

hosts_str

)

Creates a new gvm_hosts_t structure and the associated hosts objects from the provided hosts_str.

Parameters

[in]

hosts_str

The hosts string. A copy will be created of this within the returned struct.

Returns

NULL if error, otherwise, a hosts structure that should be released using gvm_hosts_free.

Definition at line 1300 of file hosts.c.

{
  return gvm_hosts_new_with_max (hosts_str, 0);
}

References gvm_hosts_new_with_max().

Referenced by Ensure(), Ensure(), Ensure(), gvm_hosts_reverse_lookup_only_excluded(), and gvm_hosts_reverse_lookup_unify_excluded().

Here is the call graph for this function:

Here is the caller graph for this function:

gvm_hosts_new_with_max()

gvm_hosts_t * gvm_hosts_new_with_max	(	const gchar *	hosts_str,
		unsigned int	max_hosts )

Creates a new gvm_hosts_t structure and the associated hosts objects from the provided hosts_str.

Parameters

[in]	hosts_str	The hosts string. A copy will be created of this within the returned struct.
[in]	max_hosts	Max number of hosts in hosts_str. 0 means unlimited.

Returns

NULL if error or hosts_str contains more than max hosts. Otherwise, a hosts structure that should be released using gvm_hosts_free.

Definition at line 1103 of file hosts.c.

{
  gvm_hosts_t *hosts;
  gchar **host_element, **split;
  gchar *str;
 
  if (hosts_str == NULL)
    return NULL;
 
  /* Normalize separator: Transform newlines into commas. */
  hosts = gvm_hosts_init (hosts_str);
  str = hosts->orig_str;
  while (*str)
    {
      if (*str == '\n')
        *str = ',';
      str++;
    }
 
  /* Split comma-separated list into single host-specifications */
  split = g_strsplit (hosts->orig_str, ",", 0);
 
  /* first element of the split list */
  host_element = split;
  while (*host_element)
    {
      int host_type;
      gchar *stripped = g_strstrip (*host_element);
 
      if (stripped == NULL || *stripped == '\0')
        {
          host_element++;
          continue;
        }
 
      /* IPv4, hostname, IPv6, collection (short/long range, cidr block) etc,. ?
       */
      /* -1 if error. */
      host_type = gvm_get_host_type (stripped);
 
      switch (host_type)
        {
        case HOST_TYPE_NAME:
        case HOST_TYPE_IPV4:
        case HOST_TYPE_IPV6:
          {
            /* New host. */
            gvm_host_t *host = gvm_host_new ();
            host->type = host_type;
            if (host_type == HOST_TYPE_NAME)
              host->name = g_ascii_strdown (stripped, -1);
            else if (host_type == HOST_TYPE_IPV4)
              {
                if (inet_pton (AF_INET, stripped, &host->addr) != 1)
                  break;
              }
            else if (host_type == HOST_TYPE_IPV6)
              {
                if (inet_pton (AF_INET6, stripped, &host->addr6) != 1)
                  break;
              }
            gvm_hosts_add (hosts, host);
            break;
          }
        case HOST_TYPE_CIDR_BLOCK:
        case HOST_TYPE_RANGE_SHORT:
        case HOST_TYPE_RANGE_LONG:
          {
            struct in_addr first, last;
            uint32_t current;
            int (*ips_func) (const char *, struct in_addr *, struct in_addr *);
 
            if (host_type == HOST_TYPE_CIDR_BLOCK)
              ips_func = cidr_block_ips;
            else if (host_type == HOST_TYPE_RANGE_SHORT)
              ips_func = short_range_network_ips;
            else
              ips_func = long_range_network_ips;
 
            if (ips_func (stripped, &first, &last) == -1)
              break;
 
            /* Make sure that first actually comes before last */
            if (ntohl (first.s_addr) > ntohl (last.s_addr))
              break;
 
            /* Add addresses from first to last as single hosts. */
            current = first.s_addr;
            while (ntohl (current) <= ntohl (last.s_addr))
              {
                gvm_host_t *host;
                if (max_hosts > 0 && hosts->count > max_hosts)
                  {
                    g_strfreev (split);
                    gvm_hosts_free (hosts);
                    return NULL;
                  }
                host = gvm_host_new ();
                host->type = HOST_TYPE_IPV4;
                host->addr.s_addr = current;
                gvm_hosts_add (hosts, host);
                /* Next IP address. */
                current = htonl (ntohl (current) + 1);
              }
            break;
          }
        case HOST_TYPE_CIDR6_BLOCK:
        case HOST_TYPE_RANGE6_LONG:
        case HOST_TYPE_RANGE6_SHORT:
          {
            struct in6_addr first, last;
            unsigned char current[16];
            int (*ips_func) (const char *, struct in6_addr *,
                             struct in6_addr *);
 
            if (host_type == HOST_TYPE_CIDR6_BLOCK)
              ips_func = cidr6_block_ips;
            else if (host_type == HOST_TYPE_RANGE6_SHORT)
              ips_func = short_range6_network_ips;
            else
              ips_func = long_range6_network_ips;
 
            if (ips_func (stripped, &first, &last) == -1)
              break;
 
            /* Make sure the first comes before the last. */
            if (memcmp (&first.s6_addr, &last.s6_addr, 16) > 0)
              break;
 
            /* Add addresses from first to last as single hosts. */
            memcpy (current, &first.s6_addr, 16);
            while (memcmp (current, &last.s6_addr, 16) <= 0)
              {
                int i;
                gvm_host_t *host;
 
                if (max_hosts > 0 && hosts->count > max_hosts)
                  {
                    g_strfreev (split);
                    gvm_hosts_free (hosts);
                    return NULL;
                  }
                host = gvm_host_new ();
                host->type = HOST_TYPE_IPV6;
                memcpy (host->addr6.s6_addr, current, 16);
                gvm_hosts_add (hosts, host);
                /* Next IPv6 address. */
                for (i = 15; i >= 0; --i)
                  if (current[i] < 255)
                    {
                      current[i]++;
                      break;
                    }
                  else
                    current[i] = 0;
              }
            break;
          }
        case -1:
        default:
          /* Invalid host string. */
          g_strfreev (split);
          gvm_hosts_free (hosts);
          return NULL;
        }
      host_element++; /* move on to next element of split list */
      if (max_hosts > 0 && hosts->count > max_hosts)
        {
          g_strfreev (split);
          gvm_hosts_free (hosts);
          return NULL;
        }
    }
 
  /* No need to check for duplicates when a hosts string contains a
   * single (IP/Hostname/Range/Subnetwork) entry. */
  if (g_strv_length (split) > 1)
    gvm_hosts_deduplicate (hosts);
 
  g_strfreev (split);
#ifdef __GLIBC__
  malloc_trim (0);
#endif
  return hosts;
}

References gvm_host::addr, gvm_host::addr6, cidr6_block_ips(), cidr_block_ips(), gvm_hosts::count, gvm_get_host_type(), gvm_host_new(), gvm_hosts_add(), gvm_hosts_deduplicate(), gvm_hosts_free(), gvm_hosts_init(), HOST_TYPE_CIDR6_BLOCK, HOST_TYPE_CIDR_BLOCK, HOST_TYPE_IPV4, HOST_TYPE_IPV6, HOST_TYPE_NAME, HOST_TYPE_RANGE6_LONG, HOST_TYPE_RANGE6_SHORT, HOST_TYPE_RANGE_LONG, HOST_TYPE_RANGE_SHORT, long_range6_network_ips(), long_range_network_ips(), gvm_host::name, gvm_hosts::orig_str, short_range6_network_ips(), short_range_network_ips(), and gvm_host::type.

Referenced by Ensure(), Ensure(), gvm_hosts_allowed_only(), gvm_hosts_exclude_with_max(), and gvm_hosts_new().

Here is the call graph for this function:

Here is the caller graph for this function:

gvm_hosts_next()

gvm_host_t * gvm_hosts_next

(

gvm_hosts_t *

hosts

)

Gets the next gvm_host_t from a gvm_hosts_t structure. The state of iteration is kept internally within the gvm_hosts structure.

Parameters

[in]

hosts

gvm_hosts_t structure to get next host from.

Returns

Pointer to host. NULL if error or end of hosts.

Definition at line 1314 of file hosts.c.

{
  if (!hosts || hosts->current == hosts->count)
    return NULL;
 
  return hosts->hosts[hosts->current++];
}

References gvm_hosts::count, gvm_hosts::current, and gvm_hosts::hosts.

Referenced by Ensure(), and Ensure().

Here is the caller graph for this function:

gvm_hosts_removed()

unsigned int gvm_hosts_removed

(

const gvm_hosts_t *

hosts

)

Gets the count of single values in hosts string that were removed (duplicates / excluded.).

Parameters

[in]

hosts

The hosts collection.

Returns

The number of removed values.

Definition at line 2119 of file hosts.c.

{
  return hosts ? hosts->removed : 0;
}

References gvm_hosts::removed.

gvm_hosts_resolve()

GSList * gvm_hosts_resolve

(

gvm_hosts_t *

hosts

)

Resolves host objects of type name in a hosts collection, replacing hostnames with IPv4 values. Not to be used while iterating over the single hosts as it resets the iterator.

Parameters

[in]

hosts

The hosts collection from which to exclude.

Returns

List of unresolved hostnames.

Definition at line 1456 of file hosts.c.

{
  size_t i, new_entries = 0, resolved = 0;
  GSList *unresolved = NULL;
 
  for (i = 0; i < hosts->count; i++)
    {
      GSList *list, *tmp;
      gvm_host_t *host = hosts->hosts[i];
 
      if (host->type != HOST_TYPE_NAME)
        continue;
 
      list = tmp = gvm_resolve_list (host->name);
      while (tmp)
        {
          /* Create a new host for each IP address. */
          gvm_host_t *new;
          struct in6_addr *ip6 = tmp->data;
          gvm_vhost_t *vhost;
 
          new = gvm_host_new ();
          if (ip6->s6_addr32[0] != 0 || ip6->s6_addr32[1] != 0
              || ip6->s6_addr32[2] != htonl (0xffff))
            {
              new->type = HOST_TYPE_IPV6;
              memcpy (&new->addr6, ip6, sizeof (new->addr6));
            }
          else
            {
              new->type = HOST_TYPE_IPV4;
              memcpy (&new->addr6, &ip6->s6_addr32[3], sizeof (new->addr));
            }
          vhost =
            gvm_vhost_new (g_strdup (host->name), g_strdup ("Forward-DNS"));
          new->vhosts = g_slist_prepend (new->vhosts, vhost);
          gvm_hosts_add (hosts, new);
          tmp = tmp->next;
          new_entries = 1;
        }
      /* Remove hostname from list, as it was either replaced by IPs, or
       * is unresolvable. */
      hosts->hosts[i] = NULL;
      resolved++;
      if (!list)
        unresolved = g_slist_prepend (unresolved, g_strdup (host->name));
      gvm_host_free (host);
      g_slist_free_full (list, g_free);
    }
  if (resolved)
    gvm_hosts_fill_gaps (hosts);
  hosts->count -= resolved;
  hosts->removed += resolved;
  if (new_entries)
    gvm_hosts_deduplicate (hosts);
  hosts->current = 0;
  return unresolved;
}

References gvm_hosts::count, gvm_hosts::current, gvm_host_free(), gvm_host_new(), gvm_hosts_add(), gvm_hosts_deduplicate(), gvm_hosts_fill_gaps(), gvm_resolve_list(), gvm_vhost_new(), HOST_TYPE_IPV4, HOST_TYPE_IPV6, HOST_TYPE_NAME, gvm_hosts::hosts, gvm_host::name, gvm_hosts::removed, and gvm_host::type.

Here is the call graph for this function:

gvm_hosts_reverse()

void gvm_hosts_reverse

(

gvm_hosts_t *

hosts

)

Reverses the order of the hosts objects in the collection. Not to be used while iterating over the single hosts as it resets the iterator.

Parameters

[in]

hosts

The hosts collection to reverse.

Definition at line 1430 of file hosts.c.

{
  size_t i, j;
  if (hosts == NULL)
    return;
 
  for (i = 0, j = hosts->count - 1; i < j; i++, j--)
    {
      gvm_host_t *tmp = hosts->hosts[i];
      hosts->hosts[i] = hosts->hosts[j];
      hosts->hosts[j] = tmp;
    }
  hosts->current = 0;
}

References gvm_hosts::count, gvm_hosts::current, and gvm_hosts::hosts.

gvm_hosts_reverse_lookup_only()

int gvm_hosts_reverse_lookup_only

(

gvm_hosts_t *

hosts

)

Removes hosts that don't reverse-lookup from the hosts collection. Not to be used while iterating over the single hosts as it resets the iterator.

Parameters

[in]

hosts

The hosts collection to filter.

Returns

Number of hosts removed, -1 if error.

Definition at line 2003 of file hosts.c.

{
  gvm_hosts_t *excluded;
  int count = 0;
 
  if (hosts == NULL)
    return -1;
 
  excluded = gvm_hosts_reverse_lookup_only_excluded (hosts);
  count = excluded->count;
  gvm_hosts_free (excluded);
 
  return count;
}

References gvm_hosts::count, gvm_hosts_free(), and gvm_hosts_reverse_lookup_only_excluded().

Here is the call graph for this function:

gvm_hosts_reverse_lookup_only_excluded()

gvm_hosts_t * gvm_hosts_reverse_lookup_only_excluded

(

gvm_hosts_t *

hosts

)

Removes hosts that don't reverse-lookup from the hosts collection. Not to be used while iterating over the single hosts as it resets the iterator.

Parameters

[in]

hosts

The hosts collection to filter.

Returns

list of hosts removed, Null on error.

Definition at line 1962 of file hosts.c.

{
  size_t i, count = 0;
  gvm_hosts_t *excluded = gvm_hosts_new ("");
 
  if (hosts == NULL)
    return NULL;
 
  for (i = 0; i < hosts->count; i++)
    {
      gchar *name = gvm_host_reverse_lookup (hosts->hosts[i]);
 
      if (name == NULL)
        {
          gvm_hosts_add (excluded, gvm_duplicate_host (hosts->hosts[i]));
          gvm_host_free (hosts->hosts[i]);
          hosts->hosts[i] = NULL;
          count++;
        }
      else
        g_free (name);
    }
 
  if (count)
    gvm_hosts_fill_gaps (hosts);
  hosts->count -= count;
  hosts->removed += count;
  hosts->current = 0;
  return excluded;
}

References gvm_hosts::count, gvm_hosts::current, gvm_duplicate_host(), gvm_host_free(), gvm_host_reverse_lookup(), gvm_hosts_add(), gvm_hosts_fill_gaps(), gvm_hosts_new(), gvm_hosts::hosts, and gvm_hosts::removed.

Referenced by gvm_hosts_reverse_lookup_only().

Here is the call graph for this function:

Here is the caller graph for this function:

gvm_hosts_reverse_lookup_unify()

int gvm_hosts_reverse_lookup_unify

(

gvm_hosts_t *

hosts

)

Removes hosts duplicates that reverse-lookup to the same value. Not to be used while iterating over the single hosts as it resets the iterator.

Parameters

[in]

hosts

The hosts collection to filter.

Returns

Number of hosts removed, -1 if error.

Definition at line 2084 of file hosts.c.

{
  gvm_hosts_t *excluded = NULL;
  int count = 0;
  if (hosts == NULL)
    return -1;
 
  excluded = gvm_hosts_reverse_lookup_unify_excluded (hosts);
  count = excluded->count;
  gvm_hosts_free (excluded);
 
  return count;
}

References gvm_hosts::count, gvm_hosts_free(), and gvm_hosts_reverse_lookup_unify_excluded().

Here is the call graph for this function:

gvm_hosts_reverse_lookup_unify_excluded()

gvm_hosts_t * gvm_hosts_reverse_lookup_unify_excluded

(

gvm_hosts_t *

hosts

)

Removes hosts duplicates that reverse-lookup to the same value. Not to be used while iterating over the single hosts as it resets the iterator.

Parameters

[in]

hosts

The hosts collection to filter.

Returns

List of hosts removed, Null if error.

Uses a hash table in order to unify the hosts list in O(N) time.

Definition at line 2028 of file hosts.c.

{
  size_t i, count = 0;
  GHashTable *name_table;
  gvm_hosts_t *excluded = NULL;
 
  if (hosts == NULL)
    return NULL;
 
  excluded = gvm_hosts_new ("");
  name_table = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
  for (i = 0; i < hosts->count; i++)
    {
      gchar *name;
 
      name = gvm_host_reverse_lookup (hosts->hosts[i]);
      if (name)
        {
          if (g_hash_table_lookup (name_table, name))
            {
              gvm_hosts_add (excluded, gvm_duplicate_host (hosts->hosts[i]));
              gvm_host_free (hosts->hosts[i]);
              hosts->hosts[i] = NULL;
              count++;
              g_free (name);
            }
          else
            {
              /* Insert in the hash table. Value not important. */
              g_hash_table_insert (name_table, name, hosts);
            }
        }
    }
 
  if (count)
    gvm_hosts_fill_gaps (hosts);
  g_hash_table_destroy (name_table);
  hosts->removed += count;
  hosts->count -= count;
  hosts->current = 0;
  return excluded;
}

References gvm_hosts::count, gvm_hosts::current, gvm_duplicate_host(), gvm_host_free(), gvm_host_reverse_lookup(), gvm_hosts_add(), gvm_hosts_fill_gaps(), gvm_hosts_new(), gvm_hosts::hosts, and gvm_hosts::removed.

Referenced by gvm_hosts_reverse_lookup_unify().

Here is the call graph for this function:

Here is the caller graph for this function:

gvm_hosts_shuffle()

void gvm_hosts_shuffle

(

gvm_hosts_t *

hosts

)

Randomizes the order of the hosts objects in the collection. Not to be used while iterating over the single hosts as it resets the iterator.

Parameters

[in]

hosts

The hosts collection to shuffle.

Definition at line 1398 of file hosts.c.

{
  size_t i = 0;
  GRand *rand;
 
  if (hosts == NULL)
    return;
 
  /* Shuffle the array. */
  rand = g_rand_new ();
  for (i = 0; i < hosts->count; i++)
    {
      void *tmp;
      int j = g_rand_int_range (rand, 0, hosts->count);
 
      tmp = hosts->hosts[i];
      hosts->hosts[i] = hosts->hosts[j];
      hosts->hosts[j] = tmp;
    }
 
  hosts->current = 0;
  g_rand_free (rand);
}

References gvm_hosts::count, gvm_hosts::current, and gvm_hosts::hosts.

gvm_vhost_free()

void gvm_vhost_free ( gpointer vhost )

static

Frees the memory occupied by an gvm_vhost_t object.

Parameters

[in]

vhost

Vhost to free.

Definition at line 891 of file hosts.c.

{
  if (vhost)
    {
      g_free (((gvm_vhost_t *) vhost)->value);
      g_free (((gvm_vhost_t *) vhost)->source);
    }
  g_free (vhost);
}

Referenced by gvm_host_free(), and gvm_vhosts_exclude().

Here is the caller graph for this function:

gvm_vhost_new()

gvm_vhost_t * gvm_vhost_new	(	char *	value,
		char *	source )

Creates a new gvm_vhost_t object.

Parameters

[in]	value	Vhost value.
[in]	source	Source of hostname.

Returns

Pointer to new vhost object.

Definition at line 874 of file hosts.c.

{
  gvm_vhost_t *vhost;
 
  vhost = g_malloc0 (sizeof (gvm_vhost_t));
  vhost->value = value;
  vhost->source = source;
 
  return vhost;
}

References gvm_vhost::source, and gvm_vhost::value.

Referenced by gvm_duplicate_vhost(), gvm_host_add_reverse_lookup(), and gvm_hosts_resolve().

Here is the caller graph for this function:

gvm_vhosts_exclude()

int gvm_vhosts_exclude	(	gvm_host_t *	host,
		const char *	excluded_str )

Exclude a list of vhosts from a host's vhosts list.

Parameters

[in]	host	The host whose vhosts are to be excluded from.
[in]	excluded_str	String of hosts to exclude.

Returns

Number of excluded vhosts.

Definition at line 1524 of file hosts.c.

{
  GSList *vhost;
  char **excluded;
  int ret = 0;
 
  if (!host || !excluded_str)
    return ret;
 
  vhost = host->vhosts;
  excluded = g_strsplit (excluded_str, ",", 0);
  if (!excluded || !*excluded)
    {
      g_strfreev (excluded);
      return ret;
    }
  while (vhost)
    {
      char **tmp = excluded;
      char *value = ((gvm_vhost_t *) vhost->data)->value;
 
      while (*tmp)
        {
          if (!strcasecmp (value, g_strstrip (*tmp)))
            {
              gvm_vhost_free (vhost->data);
              host->vhosts = vhost = g_slist_delete_link (host->vhosts, vhost);
              ret++;
              break;
            }
          tmp++;
          if (!*tmp)
            {
              vhost = vhost->next;
              break;
            }
        }
    }
  g_strfreev (excluded);
 
  return ret;
}

References gvm_vhost_free(), and gvm_host::vhosts.

Here is the call graph for this function:

host_name_verify()

int host_name_verify ( gvm_host_t * host, const char * value )

static

Verifies that hostname value resolves to a host's IP.

Parameters

[in]	host	The host whose IP is to be checked against.
[in]	value	Hostname value to verify.

Returns

0 if hostname resolves to host's IP, -1 otherwise.

Definition at line 1888 of file hosts.c.

{
  GSList *list, *tmp;
  char *host_str;
  int ret = -1;
 
  assert (host);
  assert (value);
  host_str = gvm_host_value_str (host);
  list = tmp = gvm_resolve_list (value);
  while (tmp)
    {
      char buffer[INET6_ADDRSTRLEN];
      addr6_to_str (tmp->data, buffer);
      if (!strcasecmp (host_str, buffer))
        {
          ret = 0;
          break;
        }
      tmp = tmp->next;
    }
  g_free (host_str);
  g_slist_free_full (list, g_free);
  return ret;
}

References addr6_to_str(), gvm_host_value_str(), and gvm_resolve_list().

Referenced by gvm_host_add_reverse_lookup().

Here is the call graph for this function:

Here is the caller graph for this function:

is_cidr6_block()

int is_cidr6_block ( const char * str )

static

Checks if a buffer points to an IPv6 CIDR-expressed block. "2620:0:2d0:200::7/120" is valid, "2620:0:2d0:200::7/129" is not.

Parameters

[in]

str

Buffer to check in.

Returns

1 if valid IPv6 CIDR-expressed block, 0 otherwise.

Definition at line 470 of file hosts.c.

{
  long block;
  char *addr6_str, *block_str, *p;
 
  addr6_str = g_strdup (str);
  block_str = strchr (addr6_str, '/');
  if (block_str == NULL)
    {
      g_free (addr6_str);
      return 0;
    }
 
  /* Separate the address from the block value. */
  *block_str = '\0';
  block_str++;
 
  if (!is_ipv6_address (addr6_str) || !isdigit (*block_str))
    {
      g_free (addr6_str);
      return 0;
    }
 
  p = NULL;
  block = strtol (block_str, &p, 10);
 
  if (*p || block <= 0 || block > 128)
    {
      g_free (addr6_str);
      return 0;
    }
 
  g_free (addr6_str);
  return 1;
}

References is_ipv6_address().

Referenced by gvm_get_host_type().

Here is the call graph for this function:

Here is the caller graph for this function:

is_cidr_block()

int is_cidr_block ( const char * str )

static

Checks if a buffer points to an IPv4 CIDR-expressed block. "192.168.12.3/24" is valid, "192.168.1.3/31" is not.

Parameters

[in]

str

Buffer to check in.

Returns

1 if valid CIDR-expressed block, 0 otherwise.

Definition at line 91 of file hosts.c.

{
  long block;
  char *addr_str, *block_str, *p;
 
  addr_str = g_strdup (str);
  block_str = strchr (addr_str, '/');
  if (block_str == NULL)
    {
      g_free (addr_str);
      return 0;
    }
 
  /* Separate the address from the block value. */
  *block_str = '\0';
  block_str++;
 
  if (!is_ipv4_address (addr_str) || !isdigit (*block_str))
    {
      g_free (addr_str);
      return 0;
    }
 
  p = NULL;
  block = strtol (block_str, &p, 10);
 
  if (*p || block <= 0 || block > 30)
    {
      g_free (addr_str);
      return 0;
    }
 
  g_free (addr_str);
  return 1;
}

References is_ipv4_address().

Referenced by gvm_get_host_type().

Here is the call graph for this function:

Here is the caller graph for this function:

is_hostname()

int is_hostname ( const char * str )

static

Checks if a buffer points to a valid hostname.

Parameters

[in]

str

String to check.

Returns

1 if valid hostname, 0 otherwise.

Definition at line 396 of file hosts.c.

{
  gchar *copy, **point, **split;
 
  /* From
   * https://stackoverflow.com/questions/2532053/validate-a-hostname-string. */
 
  /* Remove one dot from the end. */
 
  copy = g_strdup (str);
  if (copy[strlen (copy) - 1] == '.')
    copy[strlen (copy) - 1] = '\0';
 
  /* Check length. */
 
  if (strlen (copy) == 0 || strlen (copy) > 253)
    {
      g_free (copy);
      return 0;
    }
 
  /* Split on dots. */
 
  point = split = g_strsplit (copy, ".", 0);
  g_free (copy);
 
  /* Last part (TLD) may not be an integer. */
 
  if (*point)
    {
      gchar *last;
 
      while (*(point + 1))
        point++;
      last = *point;
      if (strlen (last))
        {
          while (*last && isdigit (*last))
            last++;
          if (*last == '\0')
            {
              g_strfreev (split);
              return 0;
            }
        }
    }
 
  /* Check each part. */
 
  point = split;
  while (*point)
    if (g_regex_match_simple ("^(?!-)[a-z0-9_-]{1,63}(?<!-)$", *point,
                              G_REGEX_CASELESS, 0)
        == 0)
      {
        g_strfreev (split);
        return 0;
      }
    else
      point++;
 
  g_strfreev (split);
  return 1;
}

Referenced by gvm_get_host_type().

Here is the caller graph for this function:

is_ipv4_address()

int is_ipv4_address ( const char * str )

static

Checks if a buffer points to a valid IPv4 address. "192.168.11.1" is valid, "192.168.1.300" and "192.168.1.1e" are not.

Parameters

[in]

str

Buffer to check in.

Returns

1 if valid IPv4 address, 0 otherwise.

Definition at line 59 of file hosts.c.

{
  struct sockaddr_in sa;
 
  return inet_pton (AF_INET, str, &(sa.sin_addr)) == 1;
}

Referenced by gvm_get_host_type(), is_cidr_block(), is_long_range_network(), and is_short_range_network().

Here is the caller graph for this function:

is_ipv6_address()

int is_ipv6_address ( const char * str )

static

Checks if a buffer points to a valid IPv6 address. "0:0:0:0:0:0:0:1", "::1" and "::FFFF:192.168.13.55" are valid "::1g" is not.

Parameters

[in]

str

Buffer to check in.

Returns

1 if valid IPv6 address, 0 otherwise.

Definition at line 75 of file hosts.c.

{
  struct sockaddr_in6 sa6;
 
  return inet_pton (AF_INET6, str, &(sa6.sin6_addr)) == 1;
}

Referenced by gvm_get_host_type(), is_cidr6_block(), is_long_range6_network(), and is_short_range6_network().

Here is the caller graph for this function:

is_long_range6_network()

int is_long_range6_network ( const char * str )

static

Checks if a buffer points to a valid long IPv6 range-expressed network. "::fee5-::1:530" is valid.

Parameters

[in]

str

Buffer to check in.

Returns

1 if valid long range-expressed network, 0 otherwise.

Definition at line 644 of file hosts.c.

{
  char *first_str, *second_str;
  int ret;
 
  first_str = g_strdup (str);
  second_str = strchr (first_str, '-');
  if (second_str == NULL)
    {
      g_free (first_str);
      return 0;
    }
 
  /* Separate the addresses. */
  *second_str = '\0';
  second_str++;
 
  ret = is_ipv6_address (first_str) && is_ipv6_address (second_str);
  g_free (first_str);
 
  return ret;
}

References is_ipv6_address().

Referenced by gvm_get_host_type().

Here is the call graph for this function:

Here is the caller graph for this function:

is_long_range_network()

int is_long_range_network ( const char * str )

static

Checks if a buffer points to a valid long range-expressed network. "192.168.12.1-192.168.13.50" is valid.

Parameters

[in]

str

Buffer to check in.

Returns

1 if valid long range-expressed network, 0 otherwise.

Definition at line 229 of file hosts.c.

{
  char *first_str, *second_str;
  int ret;
 
  first_str = g_strdup (str);
  second_str = strchr (first_str, '-');
  if (second_str == NULL)
    {
      g_free (first_str);
      return 0;
    }
 
  /* Separate the addresses. */
  *second_str = '\0';
  second_str++;
 
  ret = is_ipv4_address (first_str) && is_ipv4_address (second_str);
  g_free (first_str);
 
  return ret;
}

References is_ipv4_address().

Referenced by gvm_get_host_type().

Here is the call graph for this function:

Here is the caller graph for this function:

is_short_range6_network()

int is_short_range6_network ( const char * str )

static

Checks if a buffer points to a valid short IPv6 range-expressed network. "::200:ff:1-fee5" is valid.

Parameters

str	String to check in.

Returns

1 if str points to a valid short-range IPv6 network, 0 otherwise.

Definition at line 719 of file hosts.c.

{
  char *ip_str, *end_str, *p;
 
  ip_str = g_strdup (str);
  end_str = strchr (ip_str, '-');
  if (end_str == NULL)
    {
      g_free (ip_str);
      return 0;
    }
 
  /* Separate the addresses. */
  *end_str = '\0';
  end_str++;
 
  if (!is_ipv6_address (ip_str) || *end_str == '\0')
    {
      g_free (ip_str);
      return 0;
    }
 
  p = end_str;
  /* Check that the 2nd part is at most 4 hexadecimal characters. */
  while (isxdigit (*p) && p++)
    ;
  if (*p || p - end_str > 4)
    {
      g_free (ip_str);
      return 0;
    }
 
  g_free (ip_str);
  return 1;
}

References is_ipv6_address().

Referenced by gvm_get_host_type().

Here is the call graph for this function:

Here is the caller graph for this function:

is_short_range_network()

int is_short_range_network ( const char * str )

static

Checks if a buffer points to a valid short range-expressed network. "192.168.11.1-50" is valid, "192.168.1.1-50e" and "192.168.1.1-300" are not.

Parameters

str	String to check in.

Returns

1 if str points to a valid short range-network, 0 otherwise.

Definition at line 304 of file hosts.c.

{
  long end;
  char *ip_str, *end_str, *p;
 
  ip_str = g_strdup (str);
  end_str = strchr (ip_str, '-');
  if (end_str == NULL)
    {
      g_free (ip_str);
      return 0;
    }
 
  /* Separate the addresses. */
  *end_str = '\0';
  end_str++;
 
  if (!is_ipv4_address (ip_str) || !isdigit (*end_str))
    {
      g_free (ip_str);
      return 0;
    }
 
  p = NULL;
  end = strtol (end_str, &p, 10);
 
  if (*p || end < 0 || end > 255)
    {
      g_free (ip_str);
      return 0;
    }
 
  g_free (ip_str);
  return 1;
}

References is_ipv4_address().

Referenced by gvm_get_host_type().

Here is the call graph for this function:

Here is the caller graph for this function:

long_range6_network_ips()

int long_range6_network_ips ( const char * str, struct in6_addr * first, struct in6_addr * last )

static

Gets the first and last IPv6 addresses from a long range-expressed network. eg. "::1:200:7-::1:205:500" would give ::1:200:7 as first and ::1:205:500 as last.

Parameters

[in]	str	String containing long IPv6 range-expressed network.
[out]	first	First IPv6 address in range.
[out]	last	Last IPv6 address in range.

Returns

-1 if error, 0 else.

Definition at line 679 of file hosts.c.

{
  char *first_str, *last_str;
 
  if (str == NULL || first == NULL || last == NULL)
    return -1;
 
  first_str = g_strdup (str);
  last_str = strchr (first_str, '-');
  if (last_str == NULL)
    {
      g_free (first_str);
      return -1;
    }
 
  /* Separate the two IPs. */
  *last_str = '\0';
  last_str++;
 
  if (inet_pton (AF_INET6, first_str, first) != 1
      || inet_pton (AF_INET6, last_str, last) != 1)
    {
      g_free (first_str);
      return -1;
    }
 
  g_free (first_str);
  return 0;
}

Referenced by gvm_hosts_new_with_max().

Here is the caller graph for this function:

long_range_network_ips()

int long_range_network_ips ( const char * str, struct in_addr * first, struct in_addr * last )

static

Gets the first and last IPv4 addresses from a long range-expressed network. eg. "192.168.1.1-192.168.2.40" would give 192.168.1.1 as first and 192.168.2.40 as last.

Parameters

[in]	str	String containing long range-expressed network.
[out]	first	First IP address in block.
[out]	last	Last IP address in block.

Returns

-1 if error, 0 else.

Definition at line 264 of file hosts.c.

{
  char *first_str, *last_str;
 
  if (str == NULL || first == NULL || last == NULL)
    return -1;
 
  first_str = g_strdup (str);
  last_str = strchr (first_str, '-');
  if (last_str == NULL)
    {
      g_free (first_str);
      return -1;
    }
 
  /* Separate the two IPs. */
  *last_str = '\0';
  last_str++;
 
  if (inet_pton (AF_INET, first_str, first) != 1
      || inet_pton (AF_INET, last_str, last) != 1)
    {
      g_free (first_str);
      return -1;
    }
 
  g_free (first_str);
  return 0;
}

Referenced by gvm_hosts_new_with_max().

Here is the caller graph for this function:

short_range6_network_ips()

int short_range6_network_ips ( const char * str, struct in6_addr * first, struct in6_addr * last )

static

Gets the first and last IPv6 addresses from a short range-expressed network. eg. "\::ffee:1:1001-1005" would give ::ffee:1:1001 as first and ::ffee:1:1005 as last.

Parameters

[in]	str	String containing short IPv6 range-expressed network.
[out]	first	First IPv6 address in range.
[out]	last	Last IPv6 address in range.

Returns

-1 if error, 0 else.

Definition at line 767 of file hosts.c.

{
  char *first_str, *last_str;
  long int end;
 
  if (str == NULL || first == NULL || last == NULL)
    return -1;
 
  first_str = g_strdup (str);
  last_str = strchr (first_str, '-');
  if (last_str == NULL)
    {
      g_free (first_str);
      return -1;
    }
 
  /* Separate the first IP. */
  *last_str = '\0';
  last_str++;
 
  if (inet_pton (AF_INET6, first_str, first) != 1)
    {
      g_free (first_str);
      return -1;
    }
 
  /* Calculate the last IP. */
  memcpy (last, first, sizeof (*last));
  end = strtol (last_str, NULL, 16);
  memcpy (&last->s6_addr[15], &end, 1);
  memcpy (&last->s6_addr[14], ((char *) &end) + 1, 1);
 
  g_free (first_str);
  return 0;
}

Referenced by gvm_hosts_new_with_max().

Here is the caller graph for this function:

short_range_network_ips()

int short_range_network_ips ( const char * str, struct in_addr * first, struct in_addr * last )

static

Gets the first and last IPv4 addresses from a short range-expressed network. "192.168.1.1-40" would give 192.168.1.1 as first and 192.168.1.40 as last.

Parameters

[in]	str	String containing short range-expressed network.
[out]	first	First IP address in block.
[out]	last	Last IP address in block.

Returns

-1 if error, 0 else.

Definition at line 352 of file hosts.c.

{
  char *first_str, *last_str;
  int end;
 
  if (str == NULL || first == NULL || last == NULL)
    return -1;
 
  first_str = g_strdup (str);
  last_str = strchr (first_str, '-');
  if (last_str == NULL)
    {
      g_free (first_str);
      return -1;
    }
 
  /* Separate the two IPs. */
  *last_str = '\0';
  last_str++;
  end = atoi (last_str);
 
  /* Get the first IP */
  if (inet_pton (AF_INET, first_str, first) != 1)
    {
      g_free (first_str);
      return -1;
    }
 
  /* Get the last IP */
  last->s_addr = htonl ((ntohl (first->s_addr) & 0xffffff00) + end);
 
  g_free (first_str);
  return 0;
}

Referenced by gvm_hosts_new_with_max().

Here is the caller graph for this function:

Variable Documentation

host_type_str

gchar* host_type_str[HOST_TYPE_MAX]

Initial value:

                  = {
[HOST_TYPE_NAME] = "Hostname",
[HOST_TYPE_IPV4] = "IPv4",
[HOST_TYPE_IPV6] = "IPv6",
[HOST_TYPE_CIDR_BLOCK] = "IPv4 CIDR block",
[HOST_TYPE_RANGE_SHORT] = "IPv4 short range",
[HOST_TYPE_RANGE_LONG] = "IPv4 long range"}

Definition at line 40 of file hosts.c.

                                    {
  [HOST_TYPE_NAME] = "Hostname",
  [HOST_TYPE_IPV4] = "IPv4",
  [HOST_TYPE_IPV6] = "IPv6",
  [HOST_TYPE_CIDR_BLOCK] = "IPv4 CIDR block",
  [HOST_TYPE_RANGE_SHORT] = "IPv4 short range",
  [HOST_TYPE_RANGE_LONG] = "IPv4 long range"};

Referenced by gvm_host_type_str().