networking.c File Reference

Implementation of GVM Networking related API. More...

#include "networking.h"
#include <arpa/inet.h>
#include <assert.h>
#include <ctype.h>
#include <errno.h>
#include <glib/gstdio.h>
#include <ifaddrs.h>
#include <net/if.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <unistd.h>

Include dependency graph for networking.c:

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

Go to the source code of this file.

Data Structures
struct	route_entry

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

Typedefs
typedef struct route_entry	route_entry_t

Functions
int	gvm_source_iface_init (const char *iface)
	Initializes the source network interface name and related information.
int	gvm_source_iface_is_set (void)
	Check if global_source global_source_iface is set.
int	gvm_source_set_socket (int socket, int port, int family)
	Binds a socket to use the global source address.
void	gvm_source_addr (void *addr)
	Gives the source IPv4 address.
void	gvm_source_addr6 (void *addr6)
	Gives the source IPv6 address.
void	gvm_source_addr_as_addr6 (struct in6_addr *addr6)
	Gives the source IPv4 mapped as an IPv6 address. eg. 192.168.20.10 would map to ::ffff:192.168.20.10.
char *	gvm_source_addr_str (void)
	Gives the source IPv4 address in string format.
char *	gvm_source_addr6_str (void)
	Gives the source IPv6 address in string format.
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.168.10.20.
void	addr6_to_str (const struct in6_addr *addr6, char *str)
	Stringifies an IP address.
char *	addr6_as_str (const struct in6_addr *addr6)
	Stringifies an IP address.
void	sockaddr_as_str (const struct sockaddr_storage *addr, char *str)
	Convert an IP address to string format.
GSList *	gvm_resolve_list (const char *name)
	Returns a list of addresses that a hostname resolves to.
int	gvm_resolve (const char *name, void *dst, int family)
	Resolves a hostname to an IPv4 or IPv6 address.
int	gvm_resolve_as_addr6 (const char *name, struct in6_addr *ip6)
	Resolves a hostname to an IPv4-mapped IPv6 or IPv6 address.
int	validate_port_range (const char *port_range)
	Validate a port range string.
array_t *	port_range_ranges (const char *port_range)
	Create a range array from a port_range string.
int	port_in_port_ranges (int pnum, port_protocol_t ptype, array_t *pranges)
	Checks if a port num is in port ranges array.
int	ipv6_is_enabled (void)
	Checks if IPv6 support is enabled.
static gboolean	ip_islocalhost (struct sockaddr_storage *storage)
	Determine if IP is localhost.
static GSList *	get_routes (void)
	Get the entries of /proc/net/route as list of route_entry structs.
static void	free_routes (GSList *routes)
	Free the list of routes.
gchar *	gvm_routethrough (struct sockaddr_storage *storage_dest, struct sockaddr_storage *storage_source)
	Get Interface which should be used for routing to destination addr.
static int	get_connected_udp_sock (struct sockaddr_storage *target_addr)
	Get a connected UDP socket.
static int	get_sock_addr (int sockfd, struct sockaddr_storage *sock_addr)
	Get address from socket.
static char *	get_ifname_from_ifaddr (struct sockaddr_storage *target_addr)
	Get iface name of iface matching the given interface address.
char *	gvm_get_outgoing_iface (struct sockaddr_storage *target_addr)
	Get the outgoing interface name for a given destination addr.

Variables
char	global_source_iface [IFNAMSIZ] = {'\0'}
struct in_addr	global_source_addr = {.s_addr = 0}
struct in6_addr	global_source_addr6 = {.s6_addr32 = {0, 0, 0, 0}}

Detailed Description

Implementation of GVM Networking related API.

Definition in file networking.c.

Macro Definition Documentation

G_LOG_DOMAIN

#define G_LOG_DOMAIN   "libgvm base"

GLib log domain.

Definition at line 35 of file networking.c.

memdup

#define memdup   g_memdup

Definition at line 40 of file networking.c.

Referenced by gvm_resolve_list().

Typedef Documentation

route_entry_t

typedef struct route_entry route_entry_t

Definition at line 862 of file networking.c.

Function Documentation

addr6_as_str()

char * addr6_as_str

(

const struct in6_addr *

addr6

)

Stringifies an IP address.

Parameters

[in]

addr6

IP address.

Returns

IP as string. NULL otherwise.

Definition at line 279 of file networking.c.

{
  char *str;
 
  if (!addr6)
    return NULL;
 
  str = g_malloc0 (INET6_ADDRSTRLEN);
  addr6_to_str (addr6, str);
  return str;
}

References addr6_to_str().

Here is the call graph for this function:

addr6_to_str()

void addr6_to_str	(	const struct in6_addr *	addr6,
		char *	str )

Stringifies an IP address.

Parameters

[in]	addr6	IP address.
[out]	str	Buffer to output IP.

Definition at line 261 of file networking.c.

{
  if (!addr6)
    return;
  if (IN6_IS_ADDR_V4MAPPED (addr6))
    inet_ntop (AF_INET, &addr6->s6_addr32[3], str, INET6_ADDRSTRLEN);
  else
    inet_ntop (AF_INET6, addr6, str, INET6_ADDRSTRLEN);
}

Referenced by addr6_as_str(), and host_name_verify().

Here is the caller graph for this function:

free_routes()

void free_routes ( GSList * routes )

static

Free the list of routes.

Parameters

GSList

of route_entry structs, or NULL.

Definition at line 987 of file networking.c.

{
  if (routes)
    {
      GSList *routes_p;
 
      for (routes_p = routes; routes_p; routes_p = routes_p->next)
        {
          if (((route_entry_t *) (routes_p->data))->interface)
            g_free (((route_entry_t *) (routes_p->data))->interface);
          g_free (routes_p->data);
        }
      g_slist_free (routes);
    }
}

Referenced by Ensure(), and gvm_routethrough().

Here is the caller graph for this function:

get_connected_udp_sock()

int get_connected_udp_sock ( struct sockaddr_storage * target_addr )

static

Get a connected UDP socket.

Parameters

target_addr

Holds addr for connect call

Returns

Socket number or -1 on error.

Definition at line 1140 of file networking.c.

{
  int family = target_addr->ss_family;
  int sockfd = -1;
  if (family == AF_INET)
    {
      sockfd = socket (AF_INET, SOCK_DGRAM, 0);
      if (sockfd < 0)
        {
          g_warning ("Socket error: %s", strerror (errno));
          return -1;
        }
 
      ((struct sockaddr_in *) target_addr)->sin_port = htons (9877);
      if (connect (sockfd, (struct sockaddr *) target_addr,
                   sizeof (struct sockaddr_in))
          < 0)
        {
          g_warning ("Connect error: %s", strerror (errno));
          close (sockfd);
          return -1;
        }
    }
  else if (family == AF_INET6)
    {
      sockfd = socket (AF_INET6, SOCK_DGRAM, 0);
      if (sockfd < 0)
        {
          g_warning ("Socket error: %s", strerror (errno));
          return -1;
        }
      ((struct sockaddr_in6 *) target_addr)->sin6_port = htons (9877);
      if (connect (sockfd, (struct sockaddr *) target_addr,
                   sizeof (struct sockaddr_in6))
          < 0)
        {
          g_warning ("Connect error: %s", strerror (errno));
          close (sockfd);
          return -1;
        }
    }
  return sockfd;
}

Referenced by gvm_get_outgoing_iface().

Here is the caller graph for this function:

get_ifname_from_ifaddr()

char * get_ifname_from_ifaddr ( struct sockaddr_storage * target_addr )

static

Get iface name of iface matching the given interface address.

Parameters

[in]

target_addr

Address of interface.

Returns

Interface name of matching interface which to be freed by the caller. Null if no interface found or error.

Definition at line 1229 of file networking.c.

{
  struct ifaddrs *ifaddr, *ifa;
  int family = target_addr->ss_family;
  char *interface_out = NULL;
 
  if (getifaddrs (&ifaddr) == -1)
    {
      g_warning ("%s: getifaddr failed: %s", __func__, strerror (errno));
      return NULL;
    }
  if (family == AF_INET)
    {
      struct sockaddr_in *sin;
      for (ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next)
        {
          if (!(ifa->ifa_flags & IFF_UP))
            continue;
          if (ifa->ifa_addr == NULL)
            continue;
          if (ifa->ifa_addr->sa_family == AF_INET)
            {
              sin = (struct sockaddr_in *) (ifa->ifa_addr);
              if (((struct sockaddr_in *) target_addr)->sin_addr.s_addr
                  == sin->sin_addr.s_addr)
                interface_out = g_strdup (ifa->ifa_name);
            }
        }
    }
  else if (family == AF_INET6)
    {
      struct sockaddr_in6 *sin6;
      for (ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next)
        {
          if (!(ifa->ifa_flags & IFF_UP))
            continue;
          if (ifa->ifa_addr == NULL)
            continue;
          if (ifa->ifa_addr->sa_family == AF_INET6)
            {
              sin6 = (struct sockaddr_in6 *) (ifa->ifa_addr);
              if (IN6_ARE_ADDR_EQUAL (
                    &(sin6->sin6_addr),
                    &((struct sockaddr_in6 *) target_addr)->sin6_addr))
                interface_out = g_strdup (ifa->ifa_name);
            }
        }
    }
  freeifaddrs (ifaddr);
  return interface_out;
}

Referenced by gvm_get_outgoing_iface().

Here is the caller graph for this function:

get_routes()

GSList * get_routes ( void )

static

Get the entries of /proc/net/route as list of route_entry structs.

Returns

GSList of route_entry structs. NULL if no routes found or Error.

Definition at line 878 of file networking.c.

{
  GSList *routes;
  GError *err;
  GIOChannel *file_channel;
  gchar *line;
  gchar **items_in_line;
  int status;
  route_entry_t *entry;
 
  err = NULL;
  routes = NULL;
  line = NULL;
 
  /* Open "/proc/net/route". */
  file_channel = g_io_channel_new_file ("/proc/net/route", "r", &err);
  if (file_channel == NULL)
    {
      g_warning ("%s: %s. ", __func__,
                 err ? err->message : "Error opening /proc/net/ipv6_route");
      err = NULL;
      return NULL;
    }
 
  /* Skip first first line of file. */
  status = g_io_channel_read_line (file_channel, &line, NULL, NULL, &err);
  if (status != G_IO_STATUS_NORMAL || !line || err)
    {
      g_warning ("%s: %s", __func__,
                 err ? err->message
                     : "g_io_channel_read_line() status != G_IO_STATUS_NORMAL");
      err = NULL;
    }
  g_free (line);
 
  /* Until EOF or err we go through lines of file and extract Iface, Mask and
   * Destination and put it into the to be returned list of routes.*/
  while (1)
    {
      gchar *interface, *char_p;
      unsigned long mask, dest;
      int count;
 
      /* Get new line. */
      line = NULL;
      status = g_io_channel_read_line (file_channel, &line, NULL, NULL, &err);
      if ((status != G_IO_STATUS_NORMAL) || !line || err)
        {
          if (status == G_IO_STATUS_AGAIN)
            g_warning ("%s: /proc/net/route unavailable.", __func__);
          if (err || status == G_IO_STATUS_ERROR)
            g_warning (
              "%s: %s", __func__,
              err ? err->message
                  : "g_io_channel_read_line() status == G_IO_STATUS_ERROR");
          err = NULL;
          g_free (line);
          break;
        }
 
      /* Get items in line. */
      items_in_line = g_strsplit (line, "\t", -1);
      /* Check for missing entries in line of "/proc/net/route". */
      for (count = 0; items_in_line[count]; count++)
        ;
      if (11 != count)
        {
          g_strfreev (items_in_line);
          g_free (line);
          continue;
        }
 
      interface = g_strndup (items_in_line[0], 64);
      /* Cut interface str after ":" if IP aliasing is used. */
      char_p = strchr (interface, ':');
      if (char_p)
        {
          *char_p = '\0';
        }
      dest = strtoul (items_in_line[1], NULL, 16);
      mask = strtoul (items_in_line[7], NULL, 16);
 
      /* Fill GSList entry. */
      entry = g_malloc0 (sizeof (route_entry_t));
      entry->interface = interface;
      entry->dest = dest;
      entry->mask = mask;
      routes = g_slist_append (routes, entry);
 
      g_strfreev (items_in_line);
      g_free (line);
    }
 
  status = g_io_channel_shutdown (file_channel, TRUE, &err);
  g_io_channel_unref (file_channel);
  if ((G_IO_STATUS_NORMAL != status) || err)
    g_warning ("%s: %s", __func__,
               err ? err->message
                   : "g_io_channel_shutdown() was not successful");
 
  return routes;
}

References route_entry::dest, route_entry::interface, and route_entry::mask.

Referenced by Ensure(), gvm_routethough(), and gvm_routethrough().

Here is the caller graph for this function:

get_sock_addr()

int get_sock_addr ( int sockfd, struct sockaddr_storage * sock_addr )

static

Get address from socket.

Parameters

[in]	sockfd	Socket from which to get the address.
[out]	sock_addr	Location to write address into.

Returns

0 on success, -1 on error.

Definition at line 1193 of file networking.c.

{
  socklen_t len;
  int family = sock_addr->ss_family;
  if (family == AF_INET)
    {
      len = sizeof (struct sockaddr_in);
      if (getsockname (sockfd, (struct sockaddr *) sock_addr, &len) < 0)
        {
          g_warning ("getsockname error: %s", strerror (errno));
          close (sockfd);
          return -1;
        }
    }
  else if (family == AF_INET6)
    {
      len = sizeof (struct sockaddr_in6);
      if (getsockname (sockfd, (struct sockaddr *) sock_addr, &len) < 0)
        {
          g_warning ("getsockname error:%s", strerror (errno));
          close (sockfd);
          return -1;
        }
    }
  return 0;
}

Referenced by gvm_get_outgoing_iface().

Here is the caller graph for this function:

gvm_get_outgoing_iface()

char * gvm_get_outgoing_iface

(

struct sockaddr_storage *

target_addr

)

Get the outgoing interface name for a given destination addr.

A UDP socket is connected and its address retrieved. The address is the address of the interface of the outgoing interface. Its is determined by the kernel. We then search the list of interfaces for this address to determine the interface name. This method has the downside that if two interfaces with same addr are UP, a wrong interface might be returned because we can only retrieve the interface addr which was chosen by the kernel and nothing else (like e.g. interface number).

Parameters

[in]

target_addr

Destination address.

Returns

Name of outgoing interface which has to be freed by caller. NULL if no interface found or Error.

Definition at line 1298 of file networking.c.

{
  int family, sockfd;
  struct sockaddr_storage out_iface_addr;
  char *out_iface_str;
 
  out_iface_str = NULL;
  family = target_addr->ss_family;
 
  if (!target_addr)
    return NULL;
 
  // get a connected udp socket
  sockfd = get_connected_udp_sock (target_addr);
  if (sockfd < 0)
    return NULL;
  // get socked address which is the addr of the interface we want to get
  out_iface_addr.ss_family = family;
  if (get_sock_addr (sockfd, &out_iface_addr) < 0)
    return NULL;
  // get interface name form interface address
  out_iface_str = get_ifname_from_ifaddr (&out_iface_addr);
  return out_iface_str;
}

References get_connected_udp_sock(), get_ifname_from_ifaddr(), and get_sock_addr().

Here is the call graph for this function:

gvm_resolve()

int gvm_resolve	(	const char *	name,
		void *	dst,
		int	family )

Resolves a hostname to an IPv4 or IPv6 address.

Parameters

[in]	name	Hostname 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 389 of file networking.c.

{
  struct addrinfo hints, *info, *p;
 
  if (name == NULL || dst == NULL
      || (family != AF_INET && family != AF_INET6 && family != AF_UNSPEC))
    return -1;
 
  bzero (&hints, sizeof (hints));
  hints.ai_family = family;
  hints.ai_socktype = SOCK_STREAM;
  hints.ai_protocol = 0;
  if ((getaddrinfo (name, NULL, &hints, &info)) != 0)
    return -1;
 
  p = info;
  while (p)
    {
      if (p->ai_family == family || family == AF_UNSPEC)
        {
          if (p->ai_family == AF_INET && family == AF_UNSPEC)
            {
              struct sockaddr_in *addrin = (struct sockaddr_in *) p->ai_addr;
              ipv4_as_ipv6 (&(addrin->sin_addr), dst);
            }
          else if (p->ai_family == AF_INET)
            {
              struct sockaddr_in *addrin = (struct sockaddr_in *) p->ai_addr;
              memcpy (dst, &(addrin->sin_addr), sizeof (struct in_addr));
            }
          else if (p->ai_family == AF_INET6)
            {
              struct sockaddr_in6 *addrin = (struct sockaddr_in6 *) p->ai_addr;
              memcpy (dst, &(addrin->sin6_addr), sizeof (struct in6_addr));
            }
          break;
        }
 
      p = p->ai_next;
    }
 
  freeaddrinfo (info);
  return 0;
}

References ipv4_as_ipv6().

Referenced by gvm_host_resolve(), and gvm_resolve_as_addr6().

Here is the call graph for this function:

Here is the caller graph for this function:

gvm_resolve_as_addr6()

int gvm_resolve_as_addr6	(	const char *	name,
		struct in6_addr *	ip6 )

Resolves a hostname to an IPv4-mapped IPv6 or IPv6 address.

Parameters

[in]	name	Hostname to resolve.
[out]	ip6	Buffer to store resolved address.

Returns

-1 if error, 0 otherwise.

Definition at line 443 of file networking.c.

{
  return gvm_resolve (name, ip6, AF_UNSPEC);
}

References gvm_resolve().

Here is the call graph for this function:

gvm_resolve_list()

GSList * gvm_resolve_list

(

const char *

name

)

Returns a list of addresses that a hostname resolves to.

Parameters

[in]

name

Hostname to resolve.

Returns

List of addresses, NULL otherwise.

Definition at line 339 of file networking.c.

{
  struct addrinfo hints, *info, *p;
  GSList *list = NULL;
 
  if (name == NULL)
    return NULL;
 
  bzero (&hints, sizeof (hints));
  hints.ai_family = AF_UNSPEC;
  hints.ai_socktype = SOCK_STREAM;
  hints.ai_protocol = 0;
  if ((getaddrinfo (name, NULL, &hints, &info)) != 0)
    return NULL;
 
  p = info;
  while (p)
    {
      struct in6_addr dst;
 
      if (p->ai_family == AF_INET)
        {
          struct sockaddr_in *addrin = (struct sockaddr_in *) p->ai_addr;
          ipv4_as_ipv6 (&(addrin->sin_addr), &dst);
          list = g_slist_prepend (list, memdup (&dst, sizeof (dst)));
        }
      else if (p->ai_family == AF_INET6)
        {
          struct sockaddr_in6 *addrin = (struct sockaddr_in6 *) p->ai_addr;
          memcpy (&dst, &(addrin->sin6_addr), sizeof (struct in6_addr));
          list = g_slist_prepend (list, memdup (&dst, sizeof (dst)));
        }
      p = p->ai_next;
    }
 
  freeaddrinfo (info);
  return list;
}

References ipv4_as_ipv6(), and memdup.

Referenced by gvm_hosts_resolve(), and host_name_verify().

Here is the call graph for this function:

Here is the caller graph for this function:

gvm_routethrough()

gchar * gvm_routethrough	(	struct sockaddr_storage *	storage_dest,
		struct sockaddr_storage *	storage_source )

Get Interface which should be used for routing to destination addr.

This function should be used sparingly as it parses /proc/net/route for every call.

Parameters

[in]	storage_dest	Destination address.
[out]	storage_source	Source address. Is set to either address of the interface we use or global source address if set. Only gets filled if storage_source != NULL.

Returns

Interface name of interface used for routing to destination address. NULL if no interface found or Error.

Definition at line 1018 of file networking.c.

{
  struct ifaddrs *ifaddr, *ifa;
  gchar *interface_out;
 
  interface_out = NULL;
 
  if (!storage_dest)
    return NULL;
 
  if (getifaddrs (&ifaddr) == -1)
    {
      g_debug ("%s: getifaddr failed: %s", __func__, strerror (errno));
      return NULL;
    }
 
  /* IPv4. */
  if (storage_dest->ss_family == AF_INET)
    {
      GSList *routes;
 
      routes = get_routes ();
 
      /* Set storage_source to localhost if storage_source was supplied and
       * return name of loopback interface. */
      if (ip_islocalhost (storage_dest))
        {
          // TODO: check for (storage_source->ss_family == AF_INET)
          if (storage_source)
            {
              struct sockaddr_in *sin_p = (struct sockaddr_in *) storage_source;
              sin_p->sin_addr.s_addr = htonl (0x7F000001);
            }
 
          for (ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next)
            {
              if (ifa->ifa_addr && (ifa->ifa_addr->sa_family == AF_INET)
                  && (ifa->ifa_flags & (IFF_LOOPBACK)))
                {
                  interface_out = g_strdup (ifa->ifa_name);
                  break;
                }
            }
        }
      else
        {
          struct sockaddr_in *sin_dest_p, *sin_src_p;
          struct in_addr global_src;
          unsigned long best_match;
          GSList *routes_p;
 
          /* Check if global_source_addr in use. */
          gvm_source_addr (&global_src);
 
          sin_dest_p = (struct sockaddr_in *) storage_dest;
          sin_src_p = (struct sockaddr_in *) storage_source;
          /* Check routes for matching address. Get interface name and set
           * storage_source*/
          for (best_match = 0, routes_p = routes; routes_p;
               routes_p = routes_p->next)
            {
              if (((sin_dest_p->sin_addr.s_addr
                    & ((route_entry_t *) (routes_p->data))->mask)
                   == ((route_entry_t *) (routes_p->data))->dest)
                  && (((route_entry_t *) (routes_p->data))->mask >= best_match))
                {
                  /* Interface of matching route.*/
                  g_free (interface_out);
                  interface_out =
                    g_strdup (((route_entry_t *) (routes_p->data))->interface);
                  best_match = ((route_entry_t *) (routes_p->data))->mask;
 
                  if (!storage_source)
                    continue;
 
                  /* Set storage_source to global source if global source
                   * present.*/
                  if (global_src.s_addr != INADDR_ANY)
                    sin_src_p->sin_addr.s_addr = global_src.s_addr;
                  /* Set storage_source to addr of matching interface if no
                   * global source present.*/
                  else
                    {
                      for (ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next)
                        {
                          if (ifa->ifa_addr
                              && (ifa->ifa_addr->sa_family == AF_INET)
                              && (g_strcmp0 (interface_out, ifa->ifa_name)
                                  == 0))
                            {
                              sin_src_p->sin_addr.s_addr =
                                ((struct sockaddr_in *) (ifa->ifa_addr))
                                  ->sin_addr.s_addr;
                              break;
                            }
                        }
                    }
                }
            }
        }
      free_routes (routes);
    }
  else if (storage_dest->ss_family == AF_INET6)
    {
      g_warning ("%s: IPv6 not yet implemented for this function. Will be "
                 "implemented soon. Thanks for your patience.",
                 __func__);
    }
 
  freeifaddrs (ifaddr);
  return interface_out != NULL ? interface_out : NULL;
}

References free_routes(), get_routes(), gvm_source_addr(), and ip_islocalhost().

Referenced by Ensure().

Here is the call graph for this function:

Here is the caller graph for this function:

gvm_source_addr()

void gvm_source_addr

(

void *

addr

)

Gives the source IPv4 address.

Parameters

[out]

addr

Buffer of at least 4 bytes.

Definition at line 174 of file networking.c.

{
  if (addr)
    memcpy (addr, &global_source_addr.s_addr, 4);
}

References global_source_addr.

Referenced by Ensure(), gvm_routethrough(), gvm_source_set_socket(), and main().

Here is the caller graph for this function:

gvm_source_addr6()

void gvm_source_addr6

(

void *

addr6

)

Gives the source IPv6 address.

Parameters

[out]

addr6

Buffer of at least 16 bytes.

Definition at line 186 of file networking.c.

{
  if (addr6)
    memcpy (addr6, &global_source_addr6.s6_addr, 16);
}

References global_source_addr6.

Referenced by gvm_source_set_socket().

Here is the caller graph for this function:

gvm_source_addr6_str()

char * gvm_source_addr6_str

(

void

)

Gives the source IPv6 address in string format.

Returns

Source IPv6 string. Free with g_free().

Definition at line 225 of file networking.c.

{
  char *str = g_malloc0 (INET6_ADDRSTRLEN);
 
  inet_ntop (AF_INET6, &global_source_addr6, str, INET6_ADDRSTRLEN);
  return str;
}

References global_source_addr6.

gvm_source_addr_as_addr6()

void gvm_source_addr_as_addr6

(

struct in6_addr *

addr6

)

Gives the source IPv4 mapped as an IPv6 address. eg. 192.168.20.10 would map to ::ffff:192.168.20.10.

Parameters

[out]

addr6

Buffer of at least 16 bytes.

Definition at line 199 of file networking.c.

{
  if (addr6)
    ipv4_as_ipv6 (&global_source_addr, addr6);
}

References global_source_addr, and ipv4_as_ipv6().

Here is the call graph for this function:

gvm_source_addr_str()

char * gvm_source_addr_str

(

void

)

Gives the source IPv4 address in string format.

Returns

Source IPv4 string. Free with g_free().

Definition at line 211 of file networking.c.

{
  char *str = g_malloc0 (INET_ADDRSTRLEN);
 
  inet_ntop (AF_INET, &global_source_addr.s_addr, str, INET_ADDRSTRLEN);
  return str;
}

References global_source_addr.

gvm_source_iface_init()

int gvm_source_iface_init

(

const char *

iface

)

Initializes the source network interface name and related information.

Parameters

[in]

iface

Name of network interface to use as source interface.

Returns

0 if success. If error, return 1 and reset source values to default.

Definition at line 64 of file networking.c.

{
  struct ifaddrs *ifaddr, *ifa;
  int ret = 1;
 
  bzero (global_source_iface, sizeof (global_source_iface));
  global_source_addr.s_addr = INADDR_ANY;
  global_source_addr6 = in6addr_any;
 
  if (iface == NULL)
    return ret;
 
  if (strlen (iface) >= sizeof (global_source_iface))
    return ret;
 
  if (getifaddrs (&ifaddr) == -1)
    return ret;
 
  /* Search for the adequate interface/family. */
  for (ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next)
    {
      if (ifa->ifa_addr && strcmp (iface, ifa->ifa_name) == 0)
        {
          if (ifa->ifa_addr->sa_family == AF_INET)
            {
              struct in_addr *addr =
                &((struct sockaddr_in *) ifa->ifa_addr)->sin_addr;
 
              memcpy (&global_source_addr, addr, sizeof (global_source_addr));
              ret = 0;
            }
          else if (ifa->ifa_addr->sa_family == AF_INET6)
            {
              struct sockaddr_in6 *addr;
 
              addr = (struct sockaddr_in6 *) ifa->ifa_addr;
              memcpy (&global_source_addr6.s6_addr, &addr->sin6_addr,
                      sizeof (struct in6_addr));
              ret = 0;
            }
        }
    }
 
  /* At least one address for the interface was found. */
  if (ret == 0)
    memcpy (global_source_iface, iface, strlen (iface));
 
  freeifaddrs (ifaddr);
  return ret;
}

References global_source_addr, global_source_addr6, and global_source_iface.

Referenced by Ensure().

Here is the caller graph for this function:

gvm_source_iface_is_set()

int gvm_source_iface_is_set

(

void

)

Check if global_source global_source_iface is set.

Returns

1 if set, 0 otherwise.

Definition at line 121 of file networking.c.

{
  return *global_source_iface != '\0';
}

References global_source_iface.

gvm_source_set_socket()

int gvm_source_set_socket	(	int	socket,
		int	port,
		int	family )

Binds a socket to use the global source address.

Parameters

[in]	socket	Socket to set source address for.
[in]	port	Network port for socket.
[in]	family	Family of socket. AF_INET or AF_INET6.

Returns

0 if success, -1 if error.

Definition at line 136 of file networking.c.

{
  if (family == AF_INET)
    {
      struct sockaddr_in addr;
 
      bzero (&addr, sizeof (addr));
      gvm_source_addr (&addr.sin_addr);
      addr.sin_port = htons (port);
      addr.sin_family = AF_INET;
 
      if (bind (socket, (struct sockaddr *) &addr, sizeof (addr)) < 0)
        return -1;
    }
  else if (family == AF_INET6)
    {
      struct sockaddr_in6 addr6;
 
      bzero (&addr6, sizeof (addr6));
      gvm_source_addr6 (&addr6.sin6_addr);
      addr6.sin6_port = htons (port);
      addr6.sin6_family = AF_INET6;
 
      if (bind (socket, (struct sockaddr *) &addr6, sizeof (addr6)) < 0)
        return -1;
    }
  else
    return -1;
 
  return 0;
}

References gvm_source_addr(), and gvm_source_addr6().

Here is the call graph for this function:

ip_islocalhost()

gboolean ip_islocalhost ( struct sockaddr_storage * storage )

static

Determine if IP is localhost.

Returns

True if IP is localhost, else false.

Definition at line 775 of file networking.c.

{
  struct in_addr addr;
  struct in_addr *addr_p;
  struct in6_addr addr6 = IN6ADDR_ANY_INIT;
  struct in6_addr *addr6_p;
  struct sockaddr_in *sin_p;
  struct sockaddr_in6 *sin6_p;
  struct ifaddrs *ifaddr, *ifa;
  int family;
 
  family = storage->ss_family;
  addr6_p = &addr6;
  addr_p = &addr;
  addr.s_addr = 0;
 
  if (family == AF_INET)
    {
      sin_p = (struct sockaddr_in *) storage;
      addr = sin_p->sin_addr;
 
      if (addr_p == NULL)
        return FALSE;
      /* addr is 0.0.0.0 */
      if ((addr_p)->s_addr == 0)
        return TRUE;
      /* addr starts with 127.0.0.1 */
      if (((addr_p)->s_addr & htonl (0xFF000000)) == htonl (0x7F000000))
        return TRUE;
    }
  if (family == AF_INET6)
    {
      sin6_p = (struct sockaddr_in6 *) storage;
      addr6 = sin6_p->sin6_addr;
 
      if (IN6_IS_ADDR_V4MAPPED (&addr6))
        {
          /* addr is 0.0.0.0 */
          if (addr6_p->s6_addr32[3] == 0)
            return 1;
 
          /* addr starts with 127.0.0.1 */
          if ((addr6_p->s6_addr32[3] & htonl (0xFF000000))
              == htonl (0x7F000000))
            return 1;
        }
      if (IN6_IS_ADDR_LOOPBACK (addr6_p))
        return 1;
    }
 
  if (getifaddrs (&ifaddr) == -1)
    {
      g_debug ("%s: getifaddr failed: %s", __func__, strerror (errno));
      return FALSE;
    }
  else
    {
      struct sockaddr_in *sin;
      struct sockaddr_in6 *sin6;
 
      for (ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next)
        {
          if (ifa->ifa_addr == NULL)
            continue;
          if (ifa->ifa_addr->sa_family == AF_INET)
            {
              sin = (struct sockaddr_in *) (ifa->ifa_addr);
              /* Check if same address as local interface. */
              if (addr_p->s_addr == sin->sin_addr.s_addr)
                return TRUE;
            }
          if (ifa->ifa_addr->sa_family == AF_INET6)
            {
              sin6 = (struct sockaddr_in6 *) (ifa->ifa_addr);
 
              /* Check if same address as local interface. */
              if (family == AF_INET6
                  && IN6_ARE_ADDR_EQUAL (&(sin6->sin6_addr), addr6_p))
                return TRUE;
            }
        }
      freeifaddrs (ifaddr);
    }
 
  return FALSE;
}

Referenced by Ensure(), gvm_routethough(), and gvm_routethrough().

Here is the caller graph for this function:

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.168.10.20.

Parameters

[in]	ip4	IPv4 address to map.
[out]	ip6	Buffer to store the IPv6 address.

Definition at line 243 of file networking.c.

{
  if (ip4 == NULL || ip6 == NULL)
    return;
 
  ip6->s6_addr32[0] = 0;
  ip6->s6_addr32[1] = 0;
  ip6->s6_addr32[2] = htonl (0xffff);
  memcpy (&ip6->s6_addr32[3], ip4, sizeof (struct in_addr));
}

Referenced by gvm_host_get_addr6(), gvm_resolve(), gvm_resolve_list(), and gvm_source_addr_as_addr6().

Here is the caller graph for this function:

ipv6_is_enabled()

int ipv6_is_enabled

(

void

)

Checks if IPv6 support is enabled.

Returns

1 if IPv6 is enabled, 0 if disabled.

Definition at line 752 of file networking.c.

{
  int sock = socket (PF_INET6, SOCK_STREAM, 0);
 
  if (sock < 0)
    {
      if (errno == EAFNOSUPPORT)
        return 0;
    }
  else
    close (sock);
 
  return 1;
}

port_in_port_ranges()

int port_in_port_ranges	(	int	pnum,
		port_protocol_t	ptype,
		array_t *	pranges )

Checks if a port num is in port ranges array.

Parameters

[in]	pnum	Port number.
[in]	ptype	Port type.
[in]	pranges	Array of port ranges.

Returns

1 if port in port ranges, 0 otherwise.

Definition at line 728 of file networking.c.

{
  unsigned int i;
 
  if (pranges == NULL || pnum < 0 || pnum > 65536)
    return 0;
 
  for (i = 0; i < pranges->len; i++)
    {
      range_t *range = (range_t *) g_ptr_array_index (pranges, i);
      if (range->type != ptype)
        continue;
      if (range->start <= pnum && pnum <= range->end)
        return 1;
    }
  return 0;
}

References range::start, and range::type.

Referenced by Ensure(), and main().

Here is the caller graph for this function:

port_range_ranges()

array_t * port_range_ranges

(

const char *

port_range

)

Create a range array from a port_range string.

Parameters

[in]

port_range

Valid port_range string.

Returns

Range array or NULL if port_range invalid or NULL.

Definition at line 601 of file networking.c.

{
  gchar **split, **point, *range_start, *current;
  array_t *ranges;
  int tcp, err;
 
  if (!port_range)
    return NULL;
 
  /* port_range needs to be a valid port_range string. */
  err = validate_port_range (port_range);
  if (err)
    return NULL;
 
  ranges = make_array ();
 
  while (*port_range && isblank (*port_range))
    port_range++;
 
  /* Accepts T: and U: before any of the ranges.  This toggles the remaining
   * ranges, as in nmap.  Treats a leading naked range as TCP, whereas nmap
   * treats it as TCP and UDP. */
 
  /* Treat newlines like commas. */
  range_start = current = g_strdup (port_range);
  while (*current)
    {
      if (*current == '\n')
        *current = ',';
      current++;
    }
 
  tcp = 1;
  split = g_strsplit (range_start, ",", 0);
  g_free (range_start);
  point = split;
 
  while (*point)
    {
      gchar *hyphen, *element;
      range_t *range;
      int element_strlen;
 
      element = g_strstrip (*point);
      element_strlen = strlen (element);
 
      if (element_strlen >= 2)
        {
          if (element[0] == 'T')
            {
              element++;
              while (*element && isblank (*element))
                element++;
              if (*element == ':')
                {
                  element++;
                  tcp = 1;
                }
            }
          else if (element[0] == 'U')
            {
              element++;
              while (*element && isblank (*element))
                element++;
              if (*element == ':')
                {
                  element++;
                  tcp = 0;
                }
            }
          /* Else tcp stays as it is. */
        }
 
      /* Skip any space that followed the type specifier. */
      while (*element && isblank (*element))
        element++;
 
      hyphen = strchr (element, '-');
      if (hyphen)
        {
          *hyphen = '\0';
          hyphen++;
          while (*hyphen && isblank (*hyphen))
            hyphen++;
          assert (*hyphen); /* Validation checks this. */
 
          /* A range. */
 
          range = (range_t *) g_malloc0 (sizeof (range_t));
 
          range->start = atoi (element);
          range->end = atoi (hyphen);
          range->type = tcp ? PORT_PROTOCOL_TCP : PORT_PROTOCOL_UDP;
          range->exclude = 0;
 
          array_add (ranges, range);
        }
      else if (*element)
        {
          /* A single port. */
 
          range = (range_t *) g_malloc0 (sizeof (range_t));
 
          range->start = atoi (element);
          range->end = range->start;
          range->type = tcp ? PORT_PROTOCOL_TCP : PORT_PROTOCOL_UDP;
          range->exclude = 0;
 
          array_add (ranges, range);
        }
      /* Else skip over empty range. */
      point += 1;
    }
  g_strfreev (split);
  return ranges;
}

References array_add(), range::end, range::exclude, make_array(), PORT_PROTOCOL_TCP, PORT_PROTOCOL_UDP, range::start, range::type, and validate_port_range().

Referenced by Ensure(), Ensure(), and main().

Here is the call graph for this function:

Here is the caller graph for this function:

sockaddr_as_str()

void sockaddr_as_str	(	const struct sockaddr_storage *	addr,
		char *	str )

Convert an IP address to string format.

Parameters

[in]	addr	Address to convert.
[out]	str	Buffer of INET6_ADDRSTRLEN size.

Definition at line 298 of file networking.c.

{
  if (!addr || !str)
    return;
 
  if (addr->ss_family == AF_INET)
    {
      struct sockaddr_in *saddr = (struct sockaddr_in *) addr;
      inet_ntop (AF_INET, &saddr->sin_addr, str, INET6_ADDRSTRLEN);
    }
  else if (addr->ss_family == AF_INET6)
    {
      struct sockaddr_in6 *s6addr = (struct sockaddr_in6 *) addr;
      if (IN6_IS_ADDR_V4MAPPED (&s6addr->sin6_addr))
        inet_ntop (AF_INET, &s6addr->sin6_addr.s6_addr[12], str,
                   INET6_ADDRSTRLEN);
      else
        inet_ntop (AF_INET6, &s6addr->sin6_addr, str, INET6_ADDRSTRLEN);
    }
  else if (addr->ss_family == AF_UNIX)
    {
      g_snprintf (str, INET6_ADDRSTRLEN, "unix_socket");
    }
  else if (addr->ss_family == AF_UNSPEC)
    {
      g_snprintf (str, INET6_ADDRSTRLEN, "unknown_socket");
    }
  else
    {
      g_snprintf (str, INET6_ADDRSTRLEN, "type_%d_socket", addr->ss_family);
    }
}

validate_port_range()

int validate_port_range

(

const char *

port_range

)

Validate a port range string.

Accepts ranges in form of "103,U:200-1024,3000-4000,T:3-4,U:7".

Parameters

[in]

port_range

A port range.

Returns

0 success, 1 failed.

Definition at line 460 of file networking.c.

{
  gchar **split, **point, *range, *range_start;
 
  if (!port_range)
    return 1;
 
  while (*port_range && isblank (*port_range))
    port_range++;
  if (*port_range == '\0')
    return 1;
 
  /* Treat newlines like commas. */
  range = range_start = g_strdup (port_range);
  while (*range)
    {
      if (*range == '\n')
        *range = ',';
      range++;
    }
 
  split = g_strsplit (range_start, ",", 0);
  g_free (range_start);
  point = split;
 
  while (*point)
    {
      gchar *hyphen, *element;
 
      /* Strip off any outer whitespace. */
 
      element = g_strstrip (*point);
 
      /* Strip off any leading type specifier and following whitespace. */
 
      if ((strlen (element) >= 2)
          && ((element[0] == 'T') || (element[0] == 'U')))
        {
          element++;
          while (*element && isblank (*element))
            element++;
          if (*element == ':')
            element++;
        }
 
      /* Look for a hyphen. */
 
      hyphen = strchr (element, '-');
      if (hyphen)
        {
          long int number1, number2;
          const char *first;
          char *end;
 
          hyphen++;
 
          /* Check the first number. */
 
          first = element;
          while (*first && isblank (*first))
            first++;
          if (*first == '-')
            goto fail;
 
          errno = 0;
          number1 = strtol (first, &end, 10);
          while (*end && isblank (*end))
            end++;
          if (errno || (*end != '-'))
            goto fail;
          if (number1 == 0)
            goto fail;
          if (number1 > 65535)
            goto fail;
 
          /* Check the second number. */
 
          while (*hyphen && isblank (*hyphen))
            hyphen++;
          if (*hyphen == '\0')
            goto fail;
 
          errno = 0;
          number2 = strtol (hyphen, &end, 10);
          while (*end && isblank (*end))
            end++;
          if (errno || *end)
            goto fail;
          if (number2 == 0)
            goto fail;
          if (number2 > 65535)
            goto fail;
 
          if (number1 > number2)
            goto fail;
        }
      else
        {
          long int number;
          const char *only;
          char *end;
 
          /* Check the single number. */
 
          only = element;
          while (*only && isblank (*only))
            only++;
          /* Empty ranges are OK. */
          if (*only)
            {
              errno = 0;
              number = strtol (only, &end, 10);
              while (*end && isblank (*end))
                end++;
              if (errno || *end)
                goto fail;
              if (number == 0)
                goto fail;
              if (number > 65535)
                goto fail;
            }
        }
      point += 1;
    }
 
  g_strfreev (split);
  return 0;
 
fail:
  g_strfreev (split);
  return 1;
}

Referenced by Ensure(), Ensure(), Ensure(), main(), and port_range_ranges().

Here is the caller graph for this function:

Variable Documentation

global_source_addr

struct in_addr global_source_addr = {.s_addr = 0}

Definition at line 49 of file networking.c.

{.s_addr = 0};

Referenced by gvm_source_addr(), gvm_source_addr_as_addr6(), gvm_source_addr_str(), and gvm_source_iface_init().

global_source_addr6

struct in6_addr global_source_addr6 = {.s6_addr32 = {0, 0, 0, 0}}

Definition at line 52 of file networking.c.

{.s6_addr32 = {0, 0, 0, 0}};

Referenced by gvm_source_addr6(), gvm_source_addr6_str(), and gvm_source_iface_init().

global_source_iface

char global_source_iface[IFNAMSIZ] = {'\0'}

Definition at line 46 of file networking.c.

{'\0'};

Referenced by gvm_source_iface_init(), and gvm_source_iface_is_set().