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.

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_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 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 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 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 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 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 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 1375 of file hosts.c.

{
  size_t i;
 
  if (hosts == NULL)
    return;
 
  if (hosts->orig_str)
    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 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 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_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 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: