Greenbone Vulnerability Management Libraries  11.0.0
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...
 

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_tgvm_hosts_new (const gchar *)
 Creates a new gvm_hosts_t structure and the associated hosts objects from the provided hosts_str. More...
 
gvm_hosts_tgvm_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. More...
 
gvm_host_tgvm_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. More...
 
void gvm_hosts_free (gvm_hosts_t *)
 Frees memory occupied by an gvm_hosts_t structure. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
int gvm_vhosts_exclude (gvm_host_t *, const char *)
 Exclude a list of vhosts from a host's vhosts list. More...
 
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. More...
 
char * gvm_host_reverse_lookup (gvm_host_t *)
 Checks for a host object reverse dns lookup existence. More...
 
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. More...
 
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. More...
 
unsigned int gvm_hosts_count (const gvm_hosts_t *)
 Gets the count of single hosts objects in a hosts collection. More...
 
unsigned int gvm_hosts_removed (const gvm_hosts_t *)
 Gets the count of single values in hosts string that were removed (duplicates / excluded.) More...
 
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. More...
 
gchar * gvm_host_type_str (const gvm_host_t *)
 Gets a host's type in printable format. More...
 
enum host_type gvm_host_type (const gvm_host_t *)
 Gets a host object's type. More...
 
gchar * gvm_host_value_str (const gvm_host_t *)
 Gets a host's value in printable format. More...
 
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. More...
 
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. More...
 
void gvm_host_add_reverse_lookup (gvm_host_t *)
 Add a host's reverse-lookup name to the vhosts list. More...
 
gvm_vhost_tgvm_vhost_new (char *, char *)
 Creates a new gvm_vhost_t object. More...
 
int gvm_get_host_type (const gchar *)
 Determines the host type in a buffer. More...
 

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.

Typedef Documentation

◆ gvm_host_t

typedef struct gvm_host gvm_host_t

Definition at line 51 of file hosts.h.

◆ gvm_hosts_t

typedef struct gvm_hosts gvm_hosts_t

Definition at line 53 of file hosts.h.

◆ gvm_vhost_t

typedef struct gvm_vhost gvm_vhost_t

Definition at line 52 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 36 of file hosts.h.

37 {
38  HOST_TYPE_NAME = 0, /* Hostname eg. foo */
39  HOST_TYPE_IPV4, /* eg. 192.168.1.1 */
40  HOST_TYPE_CIDR_BLOCK, /* eg. 192.168.15.0/24 */
41  HOST_TYPE_RANGE_SHORT, /* eg. 192.168.15.10-20 */
42  HOST_TYPE_RANGE_LONG, /* eg. 192.168.15.10-192.168.18.3 */
43  HOST_TYPE_IPV6, /* eg. ::1 */
44  HOST_TYPE_CIDR6_BLOCK, /* eg. ::ffee/120 */
45  HOST_TYPE_RANGE6_LONG, /* eg. ::1:200:7-::1:205:500 */
46  HOST_TYPE_RANGE6_SHORT, /* eg. ::1-fe10 */
47  HOST_TYPE_MAX /* Boundary checking. */
48 };

Function Documentation

◆ gvm_get_host_type()

int gvm_get_host_type ( const gchar *  str_stripped)

Determines the host type in a buffer.

Parameters
[in]str_strippedBuffer 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 768 of file hosts.c.

769 {
770  /*
771  * We have a single element with no leading or trailing
772  * white spaces. This element could represent different host
773  * definitions: single IPs, host names, CIDR-expressed blocks,
774  * range-expressed networks, IPv6 addresses.
775  */
776 
777  /* Null or empty string. */
778  if (str_stripped == NULL || *str_stripped == '\0')
779  return -1;
780 
781  /* Check for regular single IPv4 address. */
782  if (is_ipv4_address (str_stripped))
783  return HOST_TYPE_IPV4;
784 
785  /* Check for regular single IPv6 address. */
786  if (is_ipv6_address (str_stripped))
787  return HOST_TYPE_IPV6;
788 
789  /* Check for regular IPv4 CIDR-expressed block like "192.168.12.0/24" */
790  if (is_cidr_block (str_stripped))
791  return HOST_TYPE_CIDR_BLOCK;
792 
793  /* Check for short range-expressed networks "192.168.12.5-40" */
794  if (is_short_range_network (str_stripped))
795  return HOST_TYPE_RANGE_SHORT;
796 
797  /* Check for long range-expressed networks "192.168.1.0-192.168.3.44" */
798  if (is_long_range_network (str_stripped))
799  return HOST_TYPE_RANGE_LONG;
800 
801  /* Check for regular IPv6 CIDR-expressed block like "2620:0:2d0:200::7/120" */
802  if (is_cidr6_block (str_stripped))
803  return HOST_TYPE_CIDR6_BLOCK;
804 
805  /* Check for short range-expressed networks "::1-ef12" */
806  if (is_short_range6_network (str_stripped))
807  return HOST_TYPE_RANGE6_SHORT;
808 
809  /* Check for long IPv6 range-expressed networks like "::1:20:7-::1:25:3" */
810  if (is_long_range6_network (str_stripped))
811  return HOST_TYPE_RANGE6_LONG;
812 
813  /* Check for hostname. */
814  if (is_hostname (str_stripped))
815  return HOST_TYPE_NAME;
816 
817  return -1;
818 }

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 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]hostThe host to which we add the vhost.

Definition at line 1630 of file hosts.c.

1631 {
1632  GSList *vhosts;
1633  gvm_vhost_t *vhost;
1634  char *value;
1635 
1636  if (!host || host->type == HOST_TYPE_NAME)
1637  return;
1638 
1639  value = gvm_host_reverse_lookup (host);
1640  if (!value)
1641  return;
1642  if (host_name_verify (host, value))
1643  {
1644  g_free (value);
1645  return;
1646  }
1647  /* Don't add vhost, if already in the list. */
1648  vhosts = host->vhosts;
1649  while (vhosts)
1650  {
1651  if (!strcasecmp (((gvm_vhost_t *) vhosts->data)->value, value))
1652  {
1653  g_free (value);
1654  return;
1655  }
1656  vhosts = vhosts->next;
1657  }
1658  vhost = gvm_vhost_new (value, g_strdup ("Reverse-DNS"));
1659  host->vhosts = g_slist_prepend (host->vhosts, vhost);
1660 }

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_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]hostThe host object whose value to get as IPv6.
[out]ip6Buffer to store the IPv6 address.
Returns
-1 if error, 0 otherwise.

Definition at line 1952 of file hosts.c.

1953 {
1954  if (host == NULL || ip6 == NULL)
1955  return -1;
1956 
1957  switch (gvm_host_type (host))
1958  {
1959  case HOST_TYPE_IPV6:
1960  memcpy (ip6, &host->addr6, sizeof (struct in6_addr));
1961  return 0;
1962 
1963  case HOST_TYPE_IPV4:
1964  ipv4_as_ipv6 (&host->addr, ip6);
1965  return 0;
1966 
1967  case HOST_TYPE_NAME:
1968  {
1969  struct in_addr ip4;
1970 
1971  /* Fail if IPv4 and IPv6 both don't resolve. */
1972  if (gvm_host_resolve (host, &ip4, AF_INET) == 0)
1973  ipv4_as_ipv6 (&ip4, ip6);
1974  else if (gvm_host_resolve (host, ip6, AF_INET6) == -1)
1975  return -1;
1976  return 0;
1977  }
1978 
1979  default:
1980  return -1;
1981  }
1982 }

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_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]hostThe host object.
[in]addrOptional pointer to ip address. Could be used so that host isn't resolved multiple times when type is HOST_TYPE_NAME.
[in]hostsHosts collection.
Returns
1 if host has equal in hosts, 0 otherwise.

Definition at line 1793 of file hosts.c.

1795 {
1796  char *host_str;
1797  size_t i;
1798 
1799  if (host == NULL || hosts == NULL)
1800  return 0;
1801 
1802  host_str = gvm_host_value_str (host);
1803 
1804  for (i = 0; i < hosts->count; i++)
1805  {
1806  gvm_host_t *current_host = hosts->hosts[i];
1807  char *tmp = gvm_host_value_str (current_host);
1808 
1809  if (strcasecmp (host_str, tmp) == 0)
1810  {
1811  g_free (host_str);
1812  g_free (tmp);
1813  return 1;
1814  }
1815  g_free (tmp);
1816 
1817  /* Hostnames in hosts list shouldn't be resolved. */
1818  if (addr && gvm_host_type (current_host) != HOST_TYPE_NAME)
1819  {
1820  struct in6_addr tmpaddr;
1821  gvm_host_get_addr6 (current_host, &tmpaddr);
1822 
1823  if (memcmp (addr->s6_addr, &tmpaddr.s6_addr, 16) == 0)
1824  {
1825  g_free (host_str);
1826  return 1;
1827  }
1828  }
1829  }
1830 
1831  g_free (host_str);
1832  return 0;
1833 }

References gvm_hosts::count, gvm_host_get_addr6(), gvm_host_type(), gvm_host_value_str(), HOST_TYPE_NAME, and gvm_hosts::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]hostThe host object whose name to resolve.
[out]dstBuffer to store resolved address. Size must be at least 4 bytes for AF_INET and 16 bytes for AF_INET6.
[in]familyEither AF_INET or AF_INET6.
Returns
-1 if error, 0 otherwise.

Definition at line 1931 of file hosts.c.

1932 {
1933  if (host == NULL || dst == NULL || host->type != HOST_TYPE_NAME)
1934  return -1;
1935 
1936  return gvm_resolve (host->name, dst, family);
1937 }

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]hostThe host to reverse-lookup.
Returns
Result of look-up, NULL otherwise.

Definition at line 1546 of file hosts.c.

1547 {
1548  int retry = 2;
1549  gchar hostname[NI_MAXHOST];
1550  void *addr;
1551  size_t addrlen;
1552  struct sockaddr_in sa;
1553  struct sockaddr_in6 sa6;
1554 
1555  if (!host)
1556  return NULL;
1557 
1558  if (host->type == HOST_TYPE_IPV4)
1559  {
1560  addr = &sa;
1561  addrlen = sizeof (sa);
1562  memset (addr, '\0', addrlen);
1563  sa.sin_addr = host->addr;
1564  sa.sin_family = AF_INET;
1565  }
1566  else if (host->type == HOST_TYPE_IPV6)
1567  {
1568  addr = &sa6;
1569  addrlen = sizeof (sa6);
1570  memset (&sa6, '\0', addrlen);
1571  memcpy (&sa6.sin6_addr, &host->addr6, 16);
1572  sa6.sin6_family = AF_INET6;
1573  }
1574  else
1575  return NULL;
1576 
1577  while (retry--)
1578  {
1579  int ret = getnameinfo (addr, addrlen, hostname, sizeof (hostname), NULL,
1580  0, NI_NAMEREQD);
1581  if (!ret)
1582  return g_ascii_strdown (hostname, -1);
1583  if (ret != EAI_AGAIN)
1584  break;
1585  }
1586  return NULL;
1587 }

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(), and gvm_hosts_reverse_lookup_unify().

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]hostThe host object.
Returns
Host type.

Definition at line 1843 of file hosts.c.

1844 {
1845  assert (host);
1846  return host->type;
1847 }

References gvm_host::type.

Referenced by gvm_host_get_addr6(), and gvm_host_in_hosts().

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]hostThe host object.
Returns
String representing host type. Statically allocated, thus, not to be freed.

Definition at line 1858 of file hosts.c.

1859 {
1860  if (host == NULL)
1861  return NULL;
1862 
1863  return host_type_str[host->type];
1864 }

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]hostThe host object.
Returns
String representing host value. To be freed with g_free().

Definition at line 1874 of file hosts.c.

1875 {
1876  if (host == NULL)
1877  return NULL;
1878 
1879  switch (host->type)
1880  {
1881  case HOST_TYPE_NAME:
1882  return g_strdup (host->name);
1883  break;
1884  case HOST_TYPE_IPV4:
1885  case HOST_TYPE_IPV6:
1886  /* Handle both cases using inet_ntop(). */
1887  {
1888  int family, size;
1889  gchar *str;
1890  const void *srcaddr;
1891 
1892  if (host->type == HOST_TYPE_IPV4)
1893  {
1894  family = AF_INET;
1895  size = INET_ADDRSTRLEN;
1896  srcaddr = &host->addr;
1897  }
1898  else
1899  {
1900  family = AF_INET6;
1901  size = INET6_ADDRSTRLEN;
1902  srcaddr = &host->addr6;
1903  }
1904 
1905  str = g_malloc0 (size);
1906  if (inet_ntop (family, srcaddr, str, size) == NULL)
1907  {
1908  perror ("inet_ntop");
1909  g_free (str);
1910  return NULL;
1911  }
1912  return str;
1913  }
1914  default:
1915  return g_strdup ("Erroneous host type: Should be Hostname/IPv4/IPv6.");
1916  }
1917 }

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 gvm_host_in_hosts(), gvm_hosts_deduplicate(), gvm_hosts_exclude_with_max(), and host_name_verify().

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]hostsThe hosts collection to count hosts of.
Returns
The number of single hosts.

Definition at line 1761 of file hosts.c.

1762 {
1763  return hosts ? hosts->count : 0;
1764 }

References gvm_hosts::count.

Referenced by gvm_hosts_exclude_with_max().

Here is the caller graph for this function:

◆ 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]hostsThe hosts collection from which to exclude.
[in]excluded_strString of hosts to exclude.
Returns
Number of excluded hosts, -1 if error.

Definition at line 1533 of file hosts.c.

1534 {
1535  return gvm_hosts_exclude_with_max (hosts, excluded_str, 0);
1536 }

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]hostsThe hosts collection from which to exclude.
[in]excluded_strString of hosts to exclude.
[in]max_hostsMax 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 1459 of file hosts.c.

1461 {
1465  gvm_hosts_t *excluded_hosts;
1466  GHashTable *name_table;
1467  size_t excluded = 0, i;
1468 
1469  if (hosts == NULL || excluded_str == NULL)
1470  return -1;
1471 
1472  excluded_hosts = gvm_hosts_new_with_max (excluded_str, max_hosts);
1473  if (excluded_hosts == NULL)
1474  return -1;
1475 
1476  if (gvm_hosts_count (excluded_hosts) == 0)
1477  {
1478  gvm_hosts_free (excluded_hosts);
1479  return 0;
1480  }
1481 
1482  /* Hash host values from excluded hosts list. */
1483  name_table = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
1484  for (i = 0; i < excluded_hosts->count; i++)
1485  {
1486  gchar *name;
1487 
1488  if ((name = gvm_host_value_str (excluded_hosts->hosts[i])))
1489  g_hash_table_insert (name_table, name, hosts);
1490  }
1491 
1492  /* Check for hosts values in hash table. */
1493  for (i = 0; i < hosts->count; i++)
1494  {
1495  gchar *name;
1496 
1497  if ((name = gvm_host_value_str (hosts->hosts[i])))
1498  {
1499  if (g_hash_table_lookup (name_table, name))
1500  {
1501  gvm_host_free (hosts->hosts[i]);
1502  hosts->hosts[i] = NULL;
1503  excluded++;
1504  g_free (name);
1505  continue;
1506  }
1507  g_free (name);
1508  }
1509  }
1510 
1511  /* Cleanup. */
1512  if (excluded)
1513  gvm_hosts_fill_gaps (hosts);
1514  hosts->count -= excluded;
1515  hosts->removed += excluded;
1516  hosts->current = 0;
1517  g_hash_table_destroy (name_table);
1518  gvm_hosts_free (excluded_hosts);
1519  return excluded;
1520 }

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]hostsThe hosts collection to free.

Definition at line 1255 of file hosts.c.

1256 {
1257  size_t i;
1258 
1259  if (hosts == NULL)
1260  return;
1261 
1262  if (hosts->orig_str)
1263  g_free (hosts->orig_str);
1264  for (i = 0; i < hosts->count; i++)
1265  gvm_host_free (hosts->hosts[i]);
1266  g_free (hosts->hosts);
1267  g_free (hosts);
1268 }

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

Referenced by gvm_hosts_exclude_with_max(), and gvm_hosts_new_with_max().

Here is the call graph for this function:
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_strThe 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 1226 of file hosts.c.

1227 {
1228  return gvm_hosts_new_with_max (hosts_str, 0);
1229 }

References gvm_hosts_new_with_max().

Here is the call 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_strThe hosts string. A copy will be created of this within the returned struct.
[in]max_hostsMax 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 1031 of file hosts.c.

1032 {
1033  gvm_hosts_t *hosts;
1034  gchar **host_element, **split;
1035  gchar *str;
1036 
1037  if (hosts_str == NULL)
1038  return NULL;
1039 
1040  /* Normalize separator: Transform newlines into commas. */
1041  hosts = gvm_hosts_init (hosts_str);
1042  str = hosts->orig_str;
1043  while (*str)
1044  {
1045  if (*str == '\n')
1046  *str = ',';
1047  str++;
1048  }
1049 
1050  /* Split comma-separated list into single host-specifications */
1051  split = g_strsplit (hosts->orig_str, ",", 0);
1052 
1053  /* first element of the split list */
1054  host_element = split;
1055  while (*host_element)
1056  {
1057  int host_type;
1058  gchar *stripped = g_strstrip (*host_element);
1059 
1060  if (stripped == NULL || *stripped == '\0')
1061  {
1062  host_element++;
1063  continue;
1064  }
1065 
1066  /* IPv4, hostname, IPv6, collection (short/long range, cidr block) etc,. ?
1067  */
1068  /* -1 if error. */
1069  host_type = gvm_get_host_type (stripped);
1070 
1071  switch (host_type)
1072  {
1073  case HOST_TYPE_NAME:
1074  case HOST_TYPE_IPV4:
1075  case HOST_TYPE_IPV6:
1076  {
1077  /* New host. */
1078  gvm_host_t *host = gvm_host_new ();
1079  host->type = host_type;
1080  if (host_type == HOST_TYPE_NAME)
1081  host->name = g_ascii_strdown (stripped, -1);
1082  else if (host_type == HOST_TYPE_IPV4)
1083  {
1084  if (inet_pton (AF_INET, stripped, &host->addr) != 1)
1085  break;
1086  }
1087  else if (host_type == HOST_TYPE_IPV6)
1088  {
1089  if (inet_pton (AF_INET6, stripped, &host->addr6) != 1)
1090  break;
1091  }
1092  gvm_hosts_add (hosts, host);
1093  break;
1094  }
1095  case HOST_TYPE_CIDR_BLOCK:
1096  case HOST_TYPE_RANGE_SHORT:
1097  case HOST_TYPE_RANGE_LONG:
1098  {
1099  struct in_addr first, last;
1100  uint32_t current;
1101  int (*ips_func) (const char *, struct in_addr *, struct in_addr *);
1102 
1104  ips_func = cidr_block_ips;
1105  else if (host_type == HOST_TYPE_RANGE_SHORT)
1106  ips_func = short_range_network_ips;
1107  else
1108  ips_func = long_range_network_ips;
1109 
1110  if (ips_func (stripped, &first, &last) == -1)
1111  break;
1112 
1113  /* Make sure that first actually comes before last */
1114  if (ntohl (first.s_addr) > ntohl (last.s_addr))
1115  break;
1116 
1117  /* Add addresses from first to last as single hosts. */
1118  current = first.s_addr;
1119  while (ntohl (current) <= ntohl (last.s_addr))
1120  {
1121  gvm_host_t *host;
1122  if (max_hosts > 0 && hosts->count > max_hosts)
1123  {
1124  g_strfreev (split);
1125  gvm_hosts_free (hosts);
1126  return NULL;
1127  }
1128  host = gvm_host_new ();
1129  host->type = HOST_TYPE_IPV4;
1130  host->addr.s_addr = current;
1131  gvm_hosts_add (hosts, host);
1132  /* Next IP address. */
1133  current = htonl (ntohl (current) + 1);
1134  }
1135  break;
1136  }
1137  case HOST_TYPE_CIDR6_BLOCK:
1138  case HOST_TYPE_RANGE6_LONG:
1140  {
1141  struct in6_addr first, last;
1142  unsigned char current[16];
1143  int (*ips_func) (const char *, struct in6_addr *,
1144  struct in6_addr *);
1145 
1147  ips_func = cidr6_block_ips;
1148  else if (host_type == HOST_TYPE_RANGE6_SHORT)
1149  ips_func = short_range6_network_ips;
1150  else
1151  ips_func = long_range6_network_ips;
1152 
1153  if (ips_func (stripped, &first, &last) == -1)
1154  break;
1155 
1156  /* Make sure the first comes before the last. */
1157  if (memcmp (&first.s6_addr, &last.s6_addr, 16) > 0)
1158  break;
1159 
1160  /* Add addresses from first to last as single hosts. */
1161  memcpy (current, &first.s6_addr, 16);
1162  while (memcmp (current, &last.s6_addr, 16) <= 0)
1163  {
1164  int i;
1165  gvm_host_t *host;
1166 
1167  if (max_hosts > 0 && hosts->count > max_hosts)
1168  {
1169  g_strfreev (split);
1170  gvm_hosts_free (hosts);
1171  return NULL;
1172  }
1173  host = gvm_host_new ();
1174  host->type = HOST_TYPE_IPV6;
1175  memcpy (host->addr6.s6_addr, current, 16);
1176  gvm_hosts_add (hosts, host);
1177  /* Next IPv6 address. */
1178  for (i = 15; i >= 0; --i)
1179  if (current[i] < 255)
1180  {
1181  current[i]++;
1182  break;
1183  }
1184  else
1185  current[i] = 0;
1186  }
1187  break;
1188  }
1189  case -1:
1190  default:
1191  /* Invalid host string. */
1192  g_strfreev (split);
1193  gvm_hosts_free (hosts);
1194  return NULL;
1195  }
1196  host_element++; /* move on to next element of split list */
1197  if (max_hosts > 0 && hosts->count > max_hosts)
1198  {
1199  g_strfreev (split);
1200  gvm_hosts_free (hosts);
1201  return NULL;
1202  }
1203  }
1204 
1205  /* No need to check for duplicates when a hosts string contains a
1206  * single (IP/Hostname/Range/Subnetwork) entry. */
1207  if (g_strv_length (split) > 1)
1208  gvm_hosts_deduplicate (hosts);
1209 
1210  g_strfreev (split);
1211  malloc_trim (0);
1212  return hosts;
1213 }

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 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]hostsgvm_hosts_t structure to get next host from.
Returns
Pointer to host. NULL if error or end of hosts.

Definition at line 1240 of file hosts.c.

1241 {
1242  if (!hosts || hosts->current == hosts->count)
1243  return NULL;
1244 
1245  return hosts->hosts[hosts->current++];
1246 }

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

◆ 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]hostsThe hosts collection.
Returns
The number of removed values.

Definition at line 1775 of file hosts.c.

1776 {
1777  return hosts ? hosts->removed : 0;
1778 }

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]hostsThe hosts collection from which to exclude.
Returns
List of unresolved hostnames.

Definition at line 1336 of file hosts.c.

1337 {
1338  size_t i, new_entries = 0, resolved = 0;
1339  GSList *unresolved = NULL;
1340 
1341  for (i = 0; i < hosts->count; i++)
1342  {
1343  GSList *list, *tmp;
1344  gvm_host_t *host = hosts->hosts[i];
1345 
1346  if (host->type != HOST_TYPE_NAME)
1347  continue;
1348 
1349  list = tmp = gvm_resolve_list (host->name);
1350  while (tmp)
1351  {
1352  /* Create a new host for each IP address. */
1353  gvm_host_t *new;
1354  struct in6_addr *ip6 = tmp->data;
1355  gvm_vhost_t *vhost;
1356 
1357  new = gvm_host_new ();
1358  if (ip6->s6_addr32[0] != 0 || ip6->s6_addr32[1] != 0
1359  || ip6->s6_addr32[2] != htonl (0xffff))
1360  {
1361  new->type = HOST_TYPE_IPV6;
1362  memcpy (&new->addr6, ip6, sizeof (new->addr6));
1363  }
1364  else
1365  {
1366  new->type = HOST_TYPE_IPV4;
1367  memcpy (&new->addr6, &ip6->s6_addr32[3], sizeof (new->addr));
1368  }
1369  vhost =
1370  gvm_vhost_new (g_strdup (host->name), g_strdup ("Forward-DNS"));
1371  new->vhosts = g_slist_prepend (new->vhosts, vhost);
1372  gvm_hosts_add (hosts, new);
1373  tmp = tmp->next;
1374  new_entries = 1;
1375  }
1376  /* Remove hostname from list, as it was either replaced by IPs, or
1377  * is unresolvable. */
1378  hosts->hosts[i] = NULL;
1379  resolved++;
1380  if (!list)
1381  unresolved = g_slist_prepend (unresolved, g_strdup (host->name));
1382  gvm_host_free (host);
1383  g_slist_free_full (list, g_free);
1384  }
1385  if (resolved)
1386  gvm_hosts_fill_gaps (hosts);
1387  hosts->count -= resolved;
1388  hosts->removed += resolved;
1389  if (new_entries)
1390  gvm_hosts_deduplicate (hosts);
1391  hosts->current = 0;
1392  return unresolved;
1393 }

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]hostsThe hosts collection to reverse.

Definition at line 1310 of file hosts.c.

1311 {
1312  size_t i, j;
1313  if (hosts == NULL)
1314  return;
1315 
1316  for (i = 0, j = hosts->count - 1; i < j; i++, j--)
1317  {
1318  gvm_host_t *tmp = hosts->hosts[i];
1319  hosts->hosts[i] = hosts->hosts[j];
1320  hosts->hosts[j] = tmp;
1321  }
1322  hosts->current = 0;
1323 }

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]hostsThe hosts collection to filter.
Returns
Number of hosts removed, -1 if error.

Definition at line 1672 of file hosts.c.

1673 {
1674  size_t i, count = 0;
1675 
1676  if (hosts == NULL)
1677  return -1;
1678 
1679  for (i = 0; i < hosts->count; i++)
1680  {
1681  gchar *name = gvm_host_reverse_lookup (hosts->hosts[i]);
1682 
1683  if (name == NULL)
1684  {
1685  gvm_host_free (hosts->hosts[i]);
1686  hosts->hosts[i] = NULL;
1687  count++;
1688  }
1689  else
1690  g_free (name);
1691  }
1692 
1693  if (count)
1694  gvm_hosts_fill_gaps (hosts);
1695  hosts->count -= count;
1696  hosts->removed += count;
1697  hosts->current = 0;
1698  return count;
1699 }

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

Here is the call 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]hostsThe hosts collection to filter.
Returns
Number of hosts removed, -1 if error.

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

Definition at line 1711 of file hosts.c.

1712 {
1716  size_t i, count = 0;
1717  GHashTable *name_table;
1718 
1719  if (hosts == NULL)
1720  return -1;
1721 
1722  name_table = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
1723  for (i = 0; i < hosts->count; i++)
1724  {
1725  gchar *name;
1726 
1727  if ((name = gvm_host_reverse_lookup (hosts->hosts[i])))
1728  {
1729  if (g_hash_table_lookup (name_table, name))
1730  {
1731  gvm_host_free (hosts->hosts[i]);
1732  hosts->hosts[i] = NULL;
1733  count++;
1734  g_free (name);
1735  }
1736  else
1737  {
1738  /* Insert in the hash table. Value not important. */
1739  g_hash_table_insert (name_table, name, hosts);
1740  }
1741  }
1742  }
1743 
1744  if (count)
1745  gvm_hosts_fill_gaps (hosts);
1746  g_hash_table_destroy (name_table);
1747  hosts->removed += count;
1748  hosts->count -= count;
1749  hosts->current = 0;
1750  return count;
1751 }

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

Here is the call 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]hostsThe hosts collection to shuffle.

Definition at line 1278 of file hosts.c.

1279 {
1280  size_t i = 0;
1281  GRand *rand;
1282 
1283  if (hosts == NULL)
1284  return;
1285 
1286  /* Shuffle the array. */
1287  rand = g_rand_new ();
1288  for (i = 0; i < hosts->count; i++)
1289  {
1290  void *tmp;
1291  int j = g_rand_int_range (rand, 0, hosts->count);
1292 
1293  tmp = hosts->hosts[i];
1294  hosts->hosts[i] = hosts->hosts[j];
1295  hosts->hosts[j] = tmp;
1296  }
1297 
1298  hosts->current = 0;
1299  g_rand_free (rand);
1300 }

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]valueVhost value.
[in]sourceSource of hostname.
Returns
Pointer to new vhost object.

Definition at line 829 of file hosts.c.

830 {
831  gvm_vhost_t *vhost;
832 
833  vhost = g_malloc0 (sizeof (gvm_vhost_t));
834  vhost->value = value;
835  vhost->source = source;
836 
837  return vhost;
838 }

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

Referenced by 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]hostThe host whose vhosts are to be excluded from.
[in]excluded_strString of hosts to exclude.
Returns
Number of excluded vhosts.

Definition at line 1404 of file hosts.c.

1405 {
1406  GSList *vhost;
1407  char **excluded;
1408  int ret = 0;
1409 
1410  if (!host || !excluded_str)
1411  return ret;
1412 
1413  vhost = host->vhosts;
1414  excluded = g_strsplit (excluded_str, ",", 0);
1415  if (!excluded || !*excluded)
1416  {
1417  g_strfreev (excluded);
1418  return ret;
1419  }
1420  while (vhost)
1421  {
1422  char **tmp = excluded;
1423  char *value = ((gvm_vhost_t *) vhost->data)->value;
1424 
1425  while (*tmp)
1426  {
1427  if (!strcasecmp (value, g_strstrip (*tmp)))
1428  {
1429  gvm_vhost_free (vhost->data);
1430  host->vhosts = vhost = g_slist_delete_link (host->vhosts, vhost);
1431  ret++;
1432  break;
1433  }
1434  tmp++;
1435  if (!*tmp)
1436  {
1437  vhost = vhost->next;
1438  break;
1439  }
1440  }
1441  }
1442  g_strfreev (excluded);
1443 
1444  return ret;
1445 }

References gvm_vhost_free(), and gvm_host::vhosts.

Here is the call graph for this function:
gvm_host_value_str
gchar * gvm_host_value_str(const gvm_host_t *host)
Gets a host's value in printable format.
Definition: hosts.c:1874
long_range6_network_ips
static int long_range6_network_ips(const char *str, struct in6_addr *first, struct in6_addr *last)
Gets the first and last IPv6 addresses from a long range-expressed network. eg. "::1:200:7-::1:205:50...
Definition: hosts.c:634
gvm_host::name
gchar * name
Definition: hosts.h:67
cidr6_block_ips
static int cidr6_block_ips(const char *str, struct in6_addr *first, struct in6_addr *last)
Gets the first and last usable IPv4 addresses from a CIDR-expressed block. eg. "192....
Definition: hosts.c:527
long_range_network_ips
static int long_range_network_ips(const char *str, struct in_addr *first, struct in_addr *last)
Gets the first and last IPv4 addresses from a long range-expressed network. eg. "192....
Definition: hosts.c:274
is_short_range_network
static int is_short_range_network(const char *str)
Checks if a buffer points to a valid short range-expressed network. "192.168.11.1-50" is valid,...
Definition: hosts.c:314
is_hostname
static int is_hostname(const char *str)
Checks if a buffer points to a valid hostname. Valid characters include: Alphanumerics,...
Definition: hosts.c:405
gvm_hosts::count
size_t count
Definition: hosts.h:96
gvm_hosts::removed
size_t removed
Definition: hosts.h:97
gvm_hosts_free
void gvm_hosts_free(gvm_hosts_t *hosts)
Frees memory occupied by an gvm_hosts_t structure.
Definition: hosts.c:1255
gvm_resolve_list
GSList * gvm_resolve_list(const char *name)
Returns a list of addresses that a hostname resolves to.
Definition: networking.c:338
is_long_range_network
static int is_long_range_network(const char *str)
Checks if a buffer points to a valid long range-expressed network. "192.168.12.1-192....
Definition: hosts.c:239
gvm_hosts_init
static gvm_hosts_t * gvm_hosts_init(const char *hosts_str)
Creates a hosts collection from a hosts string.
Definition: hosts.c:918
is_cidr6_block
static int is_cidr6_block(const char *str)
Checks if a buffer points to an IPv6 CIDR-expressed block. "2620:0:2d0:200::7/120" is valid,...
Definition: hosts.c:428
ipv4_as_ipv6
void ipv4_as_ipv6(const struct in_addr *ip4, struct in6_addr *ip6)
Maps an IPv4 address as an IPv6 address. eg. 192.168.10.20 would map to ::ffff:192....
Definition: networking.c:242
HOST_TYPE_IPV6
@ HOST_TYPE_IPV6
Definition: hosts.h:43
gvm_host_free
static void gvm_host_free(gpointer host)
Frees the memory occupied by an gvm_host_t object.
Definition: hosts.c:877
short_range6_network_ips
static int short_range6_network_ips(const char *str, struct in6_addr *first, struct in6_addr *last)
Gets the first and last IPv6 addresses from a short range-expressed network. eg. "\::ffee:1:1001-1005...
Definition: hosts.c:722
gvm_hosts_count
unsigned int gvm_hosts_count(const gvm_hosts_t *hosts)
Gets the count of single hosts objects in a hosts collection.
Definition: hosts.c:1761
is_long_range6_network
static int is_long_range6_network(const char *str)
Checks if a buffer points to a valid long IPv6 range-expressed network. "::fee5-::1:530" is valid.
Definition: hosts.c:599
HOST_TYPE_RANGE_SHORT
@ HOST_TYPE_RANGE_SHORT
Definition: hosts.h:41
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.
Definition: hosts.c:1031
gvm_host::type
enum host_type type
Definition: hosts.h:71
gvm_resolve
int gvm_resolve(const char *name, void *dst, int family)
Resolves a hostname to an IPv4 or IPv6 address.
Definition: networking.c:388
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 ad...
Definition: hosts.c:1952
gvm_vhost
The structure for a single vhost object.
Definition: hosts.h:78
HOST_TYPE_IPV4
@ HOST_TYPE_IPV4
Definition: hosts.h:39
gvm_hosts_add
static void gvm_hosts_add(gvm_hosts_t *hosts, gvm_host_t *host)
Inserts a host object at the end of a hosts collection.
Definition: hosts.c:898
gvm_hosts::hosts
gvm_host_t ** hosts
Definition: hosts.h:93
gvm_get_host_type
int gvm_get_host_type(const gchar *str_stripped)
Determines the host type in a buffer.
Definition: hosts.c:768
gvm_host
The structure for a single host object.
Definition: hosts.h:63
HOST_TYPE_CIDR6_BLOCK
@ HOST_TYPE_CIDR6_BLOCK
Definition: hosts.h:44
gvm_hosts::current
size_t current
Definition: hosts.h:95
cidr_block_ips
static int cidr_block_ips(const char *str, struct in_addr *first, struct in_addr *last)
Gets the first and last usable IPv4 addresses from a CIDR-expressed block. eg. "192....
Definition: hosts.c:208
gvm_vhost::value
char * value
Definition: hosts.h:80
HOST_TYPE_RANGE_LONG
@ HOST_TYPE_RANGE_LONG
Definition: hosts.h:42
gvm_host::addr
struct in_addr addr
Definition: hosts.h:68
HOST_TYPE_RANGE6_LONG
@ HOST_TYPE_RANGE6_LONG
Definition: hosts.h:45
gvm_host_type
enum host_type gvm_host_type(const gvm_host_t *host)
Gets a host object's type.
Definition: hosts.c:1843
is_cidr_block
static int is_cidr_block(const char *str)
Checks if a buffer points to an IPv4 CIDR-expressed block. "192.168.12.3/24" is valid,...
Definition: hosts.c:104
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 ...
Definition: hosts.c:1459
is_ipv4_address
static int is_ipv4_address(const char *str)
Checks if a buffer points to a valid IPv4 address. "192.168.11.1" is valid, "192.168....
Definition: hosts.c:72
gvm_host_new
static gvm_host_t * gvm_host_new()
Creates a new gvm_host_t object.
Definition: hosts.c:862
gvm_vhost::source
char * source
Definition: hosts.h:81
gvm_host_reverse_lookup
char * gvm_host_reverse_lookup(gvm_host_t *host)
Checks for a host object reverse dns lookup existence.
Definition: hosts.c:1546
HOST_TYPE_MAX
@ HOST_TYPE_MAX
Definition: hosts.h:47
is_short_range6_network
static int is_short_range6_network(const char *str)
Checks if a buffer points to a valid short IPv6 range-expressed network. "::200:ff:1-fee5" is valid.
Definition: hosts.c:674
gvm_vhost_free
static void gvm_vhost_free(gpointer vhost)
Frees the memory occupied by an gvm_vhost_t object.
Definition: hosts.c:846
gvm_hosts::orig_str
gchar * orig_str
Definition: hosts.h:92
host_name_verify
static int host_name_verify(gvm_host_t *host, const char *value)
Verifies that hostname value resolves to a host's IP.
Definition: hosts.c:1598
host_type
host_type
Definition: hosts.h:36
host_type_str
gchar * host_type_str[HOST_TYPE_MAX]
Definition: hosts.c:53
gvm_host::addr6
struct in6_addr addr6
Definition: hosts.h:69
gvm_vhost_new
gvm_vhost_t * gvm_vhost_new(char *value, char *source)
Creates a new gvm_vhost_t object.
Definition: hosts.c:829
HOST_TYPE_CIDR_BLOCK
@ HOST_TYPE_CIDR_BLOCK
Definition: hosts.h:40
gvm_hosts_fill_gaps
static void gvm_hosts_fill_gaps(gvm_hosts_t *hosts)
Fill the gaps in the array of a hosts collection, which are caused by the removal of host entries.
Definition: hosts.c:936
short_range_network_ips
static int short_range_network_ips(const char *str, struct in_addr *first, struct in_addr *last)
Gets the first and last IPv4 addresses from a short range-expressed network. "192....
Definition: hosts.c:359
HOST_TYPE_RANGE6_SHORT
@ HOST_TYPE_RANGE6_SHORT
Definition: hosts.h:46
gvm_hosts_deduplicate
static void gvm_hosts_deduplicate(gvm_hosts_t *hosts)
Removes duplicate hosts values from an gvm_hosts_t structure. Also resets the iterator current positi...
Definition: hosts.c:974
is_ipv6_address
static int is_ipv6_address(const char *str)
Checks if a buffer points to a valid IPv6 address. "0:0:0:0:0:0:0:1", "::1" and "::FFFF:192....
Definition: hosts.c:88
HOST_TYPE_NAME
@ HOST_TYPE_NAME
Definition: hosts.h:38
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_NAM...
Definition: hosts.c:1931
gvm_host::vhosts
GSList * vhosts
Definition: hosts.h:72
gvm_hosts
The structure for Hosts collection.
Definition: hosts.h:90