hosts.h File Reference

Protos and data structures for Hosts collections and single hosts objects. More...

#include <glib.h>
#include <netinet/in.h>

Include dependency graph for hosts.h:

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

Go to the source code of this file.

Data Structures
struct	gvm_host
	The structure for a single host object. More...
struct	gvm_vhost
	The structure for a single vhost object. More...
struct	gvm_hosts
	The structure for Hosts collection. More...

Macros
#define	FEATURE_HOSTS_ALLOWED_ONLY   1
	Flag that indecates that this version includes the function gvm_hosts_allowed_only().
#define	FEATURE_REVERSE_LOOKUP_EXCLUDED   1
	Flag that indecates that this version includes the functions gvm_reverse_lookup_only_excluded() and gvm_reverse_lookup_unify_excluded().

Typedefs
typedef struct gvm_host	gvm_host_t
typedef struct gvm_vhost	gvm_vhost_t
typedef struct gvm_hosts	gvm_hosts_t

Enumerations
enum	host_type {   HOST_TYPE_NAME = 0 , HOST_TYPE_IPV4 , HOST_TYPE_CIDR_BLOCK , HOST_TYPE_RANGE_SHORT ,   HOST_TYPE_RANGE_LONG , HOST_TYPE_IPV6 , HOST_TYPE_CIDR6_BLOCK , HOST_TYPE_RANGE6_LONG ,   HOST_TYPE_RANGE6_SHORT , HOST_TYPE_MAX }

Functions
gvm_hosts_t *	gvm_hosts_new (const gchar *)
	Creates a new gvm_hosts_t structure and the associated hosts objects from the provided hosts_str.
gvm_hosts_t *	gvm_hosts_new_with_max (const gchar *, unsigned int)
	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 *)
	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 *)
	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 *)
	Frees memory occupied by an gvm_hosts_t structure.
void	gvm_hosts_shuffle (gvm_hosts_t *)
	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 *)
	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.
void	gvm_hosts_add (gvm_hosts_t *, gvm_host_t *)
	Inserts a host object at the end of a hosts collection.
GSList *	gvm_hosts_resolve (gvm_hosts_t *)
	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_hosts_exclude (gvm_hosts_t *, const char *)
	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.
int	gvm_vhosts_exclude (gvm_host_t *, const char *)
	Exclude a list of vhosts from a host's vhosts list.
int	gvm_hosts_exclude_with_max (gvm_hosts_t *, const char *, unsigned int)
	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 *, const char *, const char *)
	Returns a list of hosts after a host authorization check.
char *	gvm_host_reverse_lookup (gvm_host_t *)
	Checks for a host object reverse dns lookup existence.
int	gvm_hosts_reverse_lookup_only (gvm_hosts_t *)
	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_unify (gvm_hosts_t *)
	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.
gvm_hosts_t *	gvm_hosts_reverse_lookup_only_excluded (gvm_hosts_t *)
	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 *)
	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 *)
	Gets the count of single hosts objects in a hosts collection.
unsigned int	gvm_hosts_removed (const gvm_hosts_t *)
	Gets the count of single values in hosts string that were removed (duplicates / excluded.).
unsigned int	gvm_hosts_duplicated (const gvm_hosts_t *)
	Gets the count of single values in hosts string that were duplicated and therefore removed from the list.
gvm_host_t *	gvm_host_from_str (const gchar *hosts_str)
	Creates a new gvm_host_t from a host string.
int	gvm_host_in_hosts (const gvm_host_t *, const struct in6_addr *, const gvm_hosts_t *)
	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.
gvm_host_t *	gvm_host_find_in_hosts (const gvm_host_t *, const struct in6_addr *, const gvm_hosts_t *)
	Find the gvm_host_t from a gvm_hosts_t structure.
gchar *	gvm_host_type_str (const gvm_host_t *)
	Gets a host's type in printable format.
enum host_type	gvm_host_type (const gvm_host_t *)
	Gets a host object's type.
gchar *	gvm_host_value_str (const gvm_host_t *)
	Gets a host's value in printable format.
int	gvm_host_resolve (const gvm_host_t *, void *, int)
	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 *, struct in6_addr *)
	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.
void	gvm_host_add_reverse_lookup (gvm_host_t *)
	Add a host's reverse-lookup name to the vhosts list.
void	gvm_host_free (gpointer)
	Frees the memory occupied by an gvm_host_t object.
gpointer	gvm_duplicate_vhost (gconstpointer, gpointer)
	Creates a deep copy of a gvm_vhost_t object.
gvm_host_t *	gvm_duplicate_host (gvm_host_t *)
	Creates a deep copy of a host. gvm_host_free has to be called on it.
gvm_vhost_t *	gvm_vhost_new (char *, char *)
	Creates a new gvm_vhost_t object.
int	gvm_get_host_type (const gchar *)
	Determines the host type in a buffer.
int	gvm_is_cidr6_block (const char *)
	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.
int	gvm_cidr6_get_block (const char *, unsigned int *)
	Gets the network block value from a CIDR-expressed block string. For "192.168.1.1/24" it is 24.
int	gvm_cidr6_get_ip (const char *, struct in6_addr *)
	Gets the IPv4 value from a CIDR-expressed block. eg. For "192.168.1.10/24" it is "192.168.1.10".
int	gvm_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.

Detailed Description

Protos and data structures for Hosts collections and single hosts objects.

This file contains the protos for hosts.c

Definition in file hosts.h.

Macro Definition Documentation

FEATURE_HOSTS_ALLOWED_ONLY

#define FEATURE_HOSTS_ALLOWED_ONLY   1

Flag that indecates that this version includes the function gvm_hosts_allowed_only().

Definition at line 20 of file hosts.h.

FEATURE_REVERSE_LOOKUP_EXCLUDED

#define FEATURE_REVERSE_LOOKUP_EXCLUDED   1

Flag that indecates that this version includes the functions gvm_reverse_lookup_only_excluded() and gvm_reverse_lookup_unify_excluded().

Definition at line 26 of file hosts.h.

Typedef Documentation

gvm_host_t

typedef struct gvm_host gvm_host_t

Definition at line 48 of file hosts.h.

gvm_hosts_t

typedef struct gvm_hosts gvm_hosts_t

Definition at line 50 of file hosts.h.

gvm_vhost_t

typedef struct gvm_vhost gvm_vhost_t

Definition at line 49 of file hosts.h.

Enumeration Type Documentation

host_type

enum host_type

Enumerator
HOST_TYPE_NAME
HOST_TYPE_IPV4
HOST_TYPE_CIDR_BLOCK
HOST_TYPE_RANGE_SHORT
HOST_TYPE_RANGE_LONG
HOST_TYPE_IPV6
HOST_TYPE_CIDR6_BLOCK
HOST_TYPE_RANGE6_LONG
HOST_TYPE_RANGE6_SHORT
HOST_TYPE_MAX

Definition at line 33 of file hosts.h.

{
  HOST_TYPE_NAME = 0,     /* Hostname eg. foo */
  HOST_TYPE_IPV4,         /* eg. 192.168.1.1 */
  HOST_TYPE_CIDR_BLOCK,   /* eg. 192.168.15.0/24 */
  HOST_TYPE_RANGE_SHORT,  /* eg. 192.168.15.10-20 */
  HOST_TYPE_RANGE_LONG,   /* eg. 192.168.15.10-192.168.18.3 */
  HOST_TYPE_IPV6,         /* eg. ::1 */
  HOST_TYPE_CIDR6_BLOCK,  /* eg. ::ffee/120 */
  HOST_TYPE_RANGE6_LONG,  /* eg. ::1:200:7-::1:205:500 */
  HOST_TYPE_RANGE6_SHORT, /* eg. ::1-fe10 */
  HOST_TYPE_MAX           /* Boundary checking. */
};

Function Documentation

gvm_cidr6_block_ips()

int gvm_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.

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 (gvm_cidr6_get_block (str, &block) == -1)
    return -1;
  if (gvm_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 gvm_cidr6_get_block(), and gvm_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:

gvm_cidr6_get_block()

int gvm_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.

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

Here is the caller graph for this function:

gvm_cidr6_get_ip()

int gvm_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".

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 gvm_cidr6_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 2199 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 910 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 814 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 (gvm_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 gvm_is_cidr6_block(), 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_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 1921 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 2150 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 945 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 1787 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 2368 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 2242 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_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 2347 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 1836 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 2259 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 2274 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 2290 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 966 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 1658 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 2106 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_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 2134 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 1771 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 1580 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_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 1376 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_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 1333 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 1301 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 1104 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 = gvm_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, cidr_block_ips(), gvm_hosts::count, gvm_cidr6_block_ips(), 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 1315 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 2120 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 1457 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 1431 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 2004 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 1963 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 2085 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 2029 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 1399 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_is_cidr6_block()

int gvm_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.

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:

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 875 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 1525 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: