networking.h File Reference

GVM Networking related API. More...

#include "array.h"
#include <netdb.h>

Include dependency graph for networking.h:

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

Go to the source code of this file.

Data Structures
struct	range
	A port range. More...

Typedefs
typedef struct range	range_t

Enumerations
enum	port_protocol_t { PORT_PROTOCOL_TCP = 0 , PORT_PROTOCOL_UDP = 1 , PORT_PROTOCOL_OTHER = 2 }
	Possible port types. More...

Functions
int	gvm_source_iface_init (const char *)
	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, int, int)
	Binds a socket to use the global source address.
void	gvm_source_addr (void *)
	Gives the source IPv4 address.
void	gvm_source_addr6 (void *)
	Gives the source IPv6 address.
void	gvm_source_addr_as_addr6 (struct in6_addr *)
	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 *, struct in6_addr *)
	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 *, char *)
	Stringifies an IP address.
char *	addr6_as_str (const struct in6_addr *)
	Stringifies an IP address.
void	sockaddr_as_str (const struct sockaddr_storage *, char *)
	Convert an IP address to string format.
int	gvm_resolve (const char *, void *, int)
	Resolves a hostname to an IPv4 or IPv6 address.
GSList *	gvm_resolve_list (const char *)
	Returns a list of addresses that a hostname resolves to.
int	gvm_resolve_as_addr6 (const char *, struct in6_addr *)
	Resolves a hostname to an IPv4-mapped IPv6 or IPv6 address.
int	validate_port_range (const char *)
	Validate a port range string.
array_t *	port_range_ranges (const char *)
	Create a range array from a port_range string.
int	port_in_port_ranges (int, port_protocol_t, array_t *)
	Checks if a port num is in port ranges array.
int	ipv6_is_enabled (void)
	Checks if IPv6 support is enabled.
gchar *	gvm_routethrough (struct sockaddr_storage *, struct sockaddr_storage *)
	Get Interface which should be used for routing to destination addr.
char *	gvm_get_outgoing_iface (struct sockaddr_storage *)
	Get the outgoing interface name for a given destination addr.

Detailed Description

GVM Networking related API.

Definition in file networking.h.

Typedef Documentation

range_t

typedef struct range range_t

Definition at line 43 of file networking.h.

Enumeration Type Documentation

port_protocol_t

enum port_protocol_t

Possible port types.

Used in Manager database. If any symbol changes then a migrator must be added to update existing data.

Enumerator
PORT_PROTOCOL_TCP
PORT_PROTOCOL_UDP
PORT_PROTOCOL_OTHER

Definition at line 24 of file networking.h.

{
  PORT_PROTOCOL_TCP = 0,
  PORT_PROTOCOL_UDP = 1,
  PORT_PROTOCOL_OTHER = 2
} port_protocol_t;

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:

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:

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: