pcap_openvas.h File Reference

Header file for module pcap. More...

#include <arpa/inet.h>
#include <pcap.h>
#include <sys/param.h>

Include dependency graph for pcap_openvas.h:

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

Go to the source code of this file.

Functions
int	v6_is_local_ip (struct in6_addr *)
int	islocalhost (struct in_addr *)
	Tests whether a packet sent to IP is LIKELY to route through the kernel localhost interface.
int	v6_islocalhost (struct in6_addr *)
	Tests whether a packet sent to IP is LIKELY to route through the kernel localhost interface.
int	get_datalink_size (int)
char *	routethrough (struct in_addr *, struct in_addr *)
	An awesome function to determine what interface a packet to a given destination should be routed through.
char *	v6_routethrough (struct in6_addr *, struct in6_addr *)
	An awesome function to determine what interface a packet to a given destination should be routed through.
int	v6_getsourceip (struct in6_addr *, struct in6_addr *)
char *	get_iface_from_ip (const char *)
	Given an IP address, determines which interface belongs to.
int	get_iface_index (struct in6_addr *, int *)
	Get the interface index depending on the target's IP.

Detailed Description

Header file for module pcap.

Definition in file pcap_openvas.h.

Function Documentation

get_datalink_size()

int get_datalink_size

(

int

datalink

)

Definition at line 298 of file pcap.c.

{
  int offset = -1;
  switch (datalink)
    {
    case DLT_EN10MB:
      offset = 14;
      break;
    case DLT_IEEE802:
      offset = 22;
      break;
    case DLT_NULL:
      offset = 4;
      break;
    case DLT_SLIP:
#if (FREEBSD || OPENBSD || NETBSD || BSDI || DARWIN)
      offset = 16;
#else
      offset = 24; /* Anyone use this??? */
#endif
      break;
    case DLT_PPP:
#if (FREEBSD || OPENBSD || NETBSD || BSDI || DARWIN)
      offset = 4;
#else
#ifdef SOLARIS
      offset = 8;
#else
      offset = 24; /* Anyone use this? */
#endif /* ifdef solaris */
#endif /* if freebsd || openbsd || netbsd || bsdi */
      break;
    case DLT_RAW:
      offset = 0;
      break;
    }
  return (offset);
}

Referenced by capture_next_frame(), capture_next_packet(), capture_next_v6_packet(), nasl_pcap_next(), nasl_send_capture(), and scan().

Here is the caller graph for this function:

get_iface_from_ip()

char * get_iface_from_ip

(

const char *

local_ip

)

Given an IP address, determines which interface belongs to.

Parameters

local_ip

IP address.

Returns

Iface name if found, Null otherwise.

Definition at line 1283 of file pcap.c.

{
  char errbuf[PCAP_ERRBUF_SIZE];
  pcap_if_t *alldevsp1 = NULL, *devs_aux = NULL;
  char *if_name = NULL;
 
  if (pcap_findalldevs (&alldevsp1, errbuf) == -1)
    g_debug ("Error for pcap_findalldevs(): %s", errbuf);
 
  devs_aux = alldevsp1;
  while (devs_aux)
    {
      pcap_addr_t *addr_aux = NULL;
 
      addr_aux = devs_aux->addresses;
      while (addr_aux)
        {
          char buffer[INET6_ADDRSTRLEN];
 
          if (((struct sockaddr *) addr_aux->addr)->sa_family == AF_INET)
            inet_ntop (AF_INET,
                       &(((struct sockaddr_in *) addr_aux->addr)->sin_addr),
                       buffer, INET_ADDRSTRLEN);
          else if (((struct sockaddr *) addr_aux->addr)->sa_family == AF_INET6)
            inet_ntop (AF_INET6,
                       &(((struct sockaddr_in6 *) addr_aux->addr)->sin6_addr),
                       buffer, INET6_ADDRSTRLEN);
 
          if (!g_strcmp0 (buffer, local_ip))
            {
              if_name = g_strdup (devs_aux->name);
              break;
            }
          addr_aux = addr_aux->next;
        }
 
      if (if_name)
        break;
      devs_aux = devs_aux->next;
    }
  pcap_freealldevs (alldevsp1);
  g_debug ("returning %s as device", if_name);
 
  return if_name;
}

Referenced by get_iface_index(), and get_local_mac_address_from_ip().

Here is the caller graph for this function:

get_iface_index()

int get_iface_index	(	struct in6_addr *	ipaddr,
		int *	ifindex )

Get the interface index depending on the target's IP.

Parameters

[in]	ipaddr	The ip address of the target.
[out]	ifindex	the index of the selected iface

Returns

0 on success, otherwise -1.

Definition at line 1337 of file pcap.c.

{
  struct in6_addr src_addr;
  char *if_name, *ip_address;
 
  // We get the local address to use, with the remote address.
  memset (&src_addr, '\0', sizeof (struct in6_addr));
  v6_getsourceip (&src_addr, ipaddr);
  ip_address = addr6_as_str (&src_addr);
 
  // Once with the local ip address, we get the source iface name
  if_name = get_iface_from_ip (ip_address);
  g_free (ip_address);
  if (!if_name)
    {
      g_debug ("%s: Missing interface name", __func__);
      return -1;
    }
 
  *ifindex = if_nametoindex (if_name);
 
  return 0;
}

References get_iface_from_ip(), and v6_getsourceip().

Referenced by send_frame().

Here is the call graph for this function:

Here is the caller graph for this function:

islocalhost()

int islocalhost

(

struct in_addr *

addr

)

Tests whether a packet sent to IP is LIKELY to route through the kernel localhost interface.

Definition at line 271 of file pcap.c.

{
  char dev[128];
 
  if (addr == NULL)
    return -1;
 
  /* If it is 0.0.0.0 or starts with 127.0.0.1 then it is
     probably localhost */
  if ((addr->s_addr & htonl (0xFF000000)) == htonl (0x7F000000))
    return 1;
 
  if (!addr->s_addr)
    return 1;
 
  /* If it is the same addy as a local interface, then it is
     probably localhost */
 
  if (ipaddr2devname (dev, sizeof (dev), addr) != -1)
    return 1;
 
  /* OK, so to a first approximation, this addy is probably not
     localhost */
  return 0;
}

routethrough()

char * routethrough	(	struct in_addr *	dest,
		struct in_addr *	source )

An awesome function to determine what interface a packet to a given destination should be routed through.

It returns NULL if no appropriate interface is found, otherwise it returns the device name and fills in the source parameter. Some of the stuff is from Stevens' Unix Network Programming V2. He had an easier suggestion for doing this (in the book), but it isn't portable :(

Definition at line 1070 of file pcap.c.

{
  static int initialized = 0;
  int i;
  char buf[10240];
  struct interface_info *mydevs;
  static struct myroute
  {
    struct interface_info *dev;
    unsigned long mask;
    unsigned long dest;
    unsigned long metric;
  } myroutes[MAXROUTES];
  int numinterfaces = 0;
  char *p, *endptr;
  char iface[MAX_IFACE_NAME_LEN];
  static int numroutes = 0;
  FILE *routez;
  long best_match = -1;
 
  struct in_addr src;
 
  gvm_source_addr (&src);
  if (!dest)
    {
      g_message ("ipaddr2devname passed a NULL dest address");
      return NULL;
    }
 
  if (!initialized)
    {
      /* Dummy socket for ioctl */
      initialized = 1;
      mydevs = getinterfaces (&numinterfaces);
      if (!mydevs)
        return NULL;
 
      routez = fopen ("/proc/net/route", "r");
      if (routez)
        {
          /* OK, linux style /proc/net/route ... we can handle this ... */
          /* Now that we've got the interfaces, we g0 after the r0ut3Z */
          if (fgets (buf, sizeof (buf), routez)
              == NULL) /* Kill the first line */
            g_message ("%s: Could not read from /proc/net/route", __func__);
          else
            {
              while (fgets (buf, sizeof (buf), routez) != NULL)
                {
                  p = strtok (buf, " \t\n");
                  if (!p)
                    {
                      g_message ("Could not find interface in"
                                 " /proc/net/route line");
                      continue;
                    }
                  strncpy (iface, p, sizeof (iface) - 1);
                  iface[MAX_IFACE_NAME_LEN - 1] = '\0';
                  if ((p = strchr (iface, ':')))
                    {
                      *p = '\0'; /* To support IP aliasing */
                    }
                  p = strtok (NULL, " \t\n");
                  endptr = NULL;
                  myroutes[numroutes].dest = strtoul (p, &endptr, 16);
                  if (!endptr || *endptr)
                    {
                      g_message (
                                 "Failed to determine Destination from /proc/net/route");
                      continue;
                    }
                  for (i = 0; i < 5; i++)
                    {
                      p = strtok (NULL, " \t\n");
                      if (!p)
                        break;
                    }
                  if (!p)
                    {
                      g_message ("Failed to find field %d in"
                                 " /proc/net/route",
                                 i + 2);
                      continue;
                    }
                  endptr = NULL;
                  myroutes[numroutes].metric = strtol (p, &endptr, 10);
                  if (!endptr || *endptr)
                    {
                      g_message ("Failed to determine metric from /proc/net/route");
                      continue;
                    }
                  p = strtok (NULL, " \t\n");
                  endptr = NULL;
                  myroutes[numroutes].mask = strtoul (p, &endptr, 16);
                  if (!endptr || *endptr)
                    {
                      g_message ("Failed to determine mask"
                                 " from /proc/net/route");
                      continue;
                    }
 
                  g_debug ("#%d: for dev %s, The dest is %lX and the mask is %lX",
                           numroutes, iface, myroutes[numroutes].dest,
                           myroutes[numroutes].mask);
                  for (i = 0; i < numinterfaces; i++)
                    if (!strcmp (iface, mydevs[i].name))
                      {
                        myroutes[numroutes].dev = &mydevs[i];
                        break;
                      }
                  if (i == numinterfaces)
                    g_message (
                               "Failed to find interface %s mentioned in /proc/net/route",
                               iface);
                  numroutes++;
                  if (numroutes >= MAXROUTES)
                    {
                      g_message ("You seem to have WAY to many routes!");
                      break;
                    }
                }
            }
          fclose (routez);
        }
      else
        {
          g_message ("Could not read from /proc/net/route");
          return NULL;
        }
    }
  else
    mydevs = getinterfaces (&numinterfaces);
  /* WHEW, that takes care of initializing, now we have the easy job of
     finding which route matches */
  if (mydevs && islocalhost (dest))
    {
      if (source)
        source->s_addr = htonl (0x7F000001);
      /* Now we find the localhost interface name, assuming 127.0.0.1 is
         localhost (it damn well better be!)... */
      for (i = 0; i < numinterfaces; i++)
        {
          if (mydevs[i].addr.s_addr == htonl (0x7F000001))
            {
              return mydevs[i].name;
            }
        }
      return NULL;
    }
 
  for (i = 0; i < numroutes; i++)
    {
      /* Matching route found */
      if ((dest->s_addr & myroutes[i].mask) == myroutes[i].dest)
        {
          /* First time a match is found */
          if (-1 == best_match)
            {
              best_match = i;
            }
          else
            {
              /* Better match found */
              if (myroutes[i].mask > myroutes[best_match].mask)
                {
                  best_match = i;
                }
              /* Match with equal mask and smaller (better) metric found */
              else if ((myroutes[i].mask == myroutes[best_match].mask)
                       && (myroutes[i].metric < myroutes[best_match].metric))
                {
                  best_match = i;
                }
            }
        }
    }
 
  /* Set source */
  if (source)
    {
      /* Source address is given */
      if (src.s_addr != INADDR_ANY)
        source->s_addr = src.s_addr;
      /* Source address is INADDR_ANY and there is a good route */
      else if (best_match != -1)
        source->s_addr = myroutes[best_match].dev->addr.s_addr;
      /* No best route found and no default */
      else
        {
          /* Assigned first route in the table */
          if (myroutes[0].dev)
            {
              source->s_addr = myroutes[0].dev->addr.s_addr;
              best_match = 0;
            }
          /* or any */
          else
            source->s_addr = INADDR_ANY;
        }
    }
 
  if (best_match != -1)
    return myroutes[best_match].dev->name;
  return NULL;
}

References myroute::dest, myroute::dev, getinterfaces(), islocalhost(), myroute::mask, MAX_IFACE_NAME_LEN, MAXROUTES, myroute::metric, interface_info::name, and name.

Referenced by Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), init_capture_device(), nasl_pcap_next(), nasl_send_arp_request(), nasl_send_capture(), nasl_tcp_ping(), and openbpf().

Here is the call graph for this function:

Here is the caller graph for this function:

v6_getsourceip()

int v6_getsourceip	(	struct in6_addr *	src,
		struct in6_addr *	dst )

Definition at line 487 of file pcap.c.

{
  int sd;
  struct sockaddr_in sock;
  unsigned int socklen;
  unsigned short p1;
 
  p1 = (unsigned short) rand ();
  if (p1 < 5000)
    p1 += 5000;
 
  if (IN6_IS_ADDR_V4MAPPED (dst))
    {
      char name[INET6_ADDRSTRLEN];
 
      if ((sd = socket (AF_INET, SOCK_DGRAM, 0)) == -1)
        {
          perror ("Socket troubles");
          return 0;
        }
      bzero (&sock, sizeof (struct sockaddr_in));
      sock.sin_family = AF_INET;
      sock.sin_addr.s_addr = dst->s6_addr32[3];
      sock.sin_port = htons (p1);
      if (connect (sd, (struct sockaddr *) &sock, sizeof (struct sockaddr_in))
          == -1)
        {
          close (sd);
          return 0;
        }
      bzero (&sock, sizeof (struct sockaddr_in));
      socklen = sizeof (struct sockaddr_in);
      if (getsockname (sd, (struct sockaddr *) &sock, &socklen) == -1)
        {
          perror ("getsockname");
          close (sd);
          return 0;
        }
 
      src->s6_addr32[0] = 0;
      src->s6_addr32[1] = 0;
      src->s6_addr32[2] = htonl (0xffff);
      src->s6_addr32[3] = sock.sin_addr.s_addr;
      g_debug ("source address is %s",
               inet_ntop (AF_INET6, src, name, sizeof (name)));
      close (sd);
    }
  else
    {
      struct sockaddr_in6 sock6;
      char name[INET6_ADDRSTRLEN];
 
      if ((sd = socket (AF_INET6, SOCK_DGRAM, 0)) == -1)
        {
          perror ("Socket troubles");
          return 0;
        }
      bzero (&sock6, sizeof (sock6));
      sock6.sin6_family = AF_INET6;
      sock6.sin6_addr.s6_addr32[0] = dst->s6_addr32[0];
      sock6.sin6_addr.s6_addr32[1] = dst->s6_addr32[1];
      sock6.sin6_addr.s6_addr32[2] = dst->s6_addr32[2];
      sock6.sin6_addr.s6_addr32[3] = dst->s6_addr32[3];
      sock6.sin6_port = htons (p1);
      if (connect (sd, (struct sockaddr *) &sock6, sizeof (struct sockaddr_in6))
          == -1)
        {
          close (sd);
          return 0;
        }
      bzero (&sock6, sizeof (struct sockaddr_in6));
      socklen = sizeof (struct sockaddr_in6);
      if (getsockname (sd, (struct sockaddr *) &sock6, &socklen) == -1)
        {
          perror ("getsockname");
          close (sd);
          return 0;
        }
 
      src->s6_addr32[0] = sock6.sin6_addr.s6_addr32[0];
      src->s6_addr32[1] = sock6.sin6_addr.s6_addr32[1];
      src->s6_addr32[2] = sock6.sin6_addr.s6_addr32[2];
      src->s6_addr32[3] = sock6.sin6_addr.s6_addr32[3];
      memcpy (src, &sock6.sin6_addr, sizeof (struct in6_addr));
      g_debug ("source addrss is %s",
               inet_ntop (AF_INET6, src, name, sizeof (name)));
      close (sd);
    }
  return 1; /* Calling function responsible for checking validity */
}

References name.

Referenced by get_iface_index(), nasl_this_host(), and v6_routethrough().

Here is the caller graph for this function:

v6_is_local_ip()

int v6_is_local_ip

(

struct in6_addr *

addr

)

Definition at line 115 of file pcap.c.

{
  int i, j, ifaces, numroutes = 0;
  struct interface_info *ifs;
  static struct myroute myroutes[MAXROUTES];
  struct in6_addr network, mask;
 
  if ((ifs = v6_getinterfaces (&ifaces)) == NULL)
    return -1;
 
  if (IN6_IS_ADDR_V4MAPPED (addr))
    {
      for (i = 0; i < ifaces; i++)
        {
          int if_net = ifs[i].mask.s6_addr32[3] & ifs[i].addr6.s6_addr32[3];
          int addr_net = addr->s6_addr32[3] & ifs[i].mask.s6_addr32[3];
          g_debug ("iface %s", ifs[i].name);
          DEBUG_IPV4 (if_net)
          DEBUG_IPV4 (addr_net)
          DEBUG_IPV4 (ifs[i].mask.s6_addr32[3])
 
          if (if_net == addr_net && addr_net)
            return 1;
        }
    }
  else
    {
      if (IN6_IS_ADDR_LINKLOCAL (addr))
        return 1;
      if (IN6_IS_ADDR_LOOPBACK (addr))
        return 1;
      if (getipv6routes (myroutes, &numroutes) == 0)
        {
          for (i = 0; i < numroutes; i++)
            {
              char addr1[INET6_ADDRSTRLEN];
              char addr2[INET6_ADDRSTRLEN];
 
              if (ipv6_prefix_to_mask (myroutes[i].mask, &mask) == -1)
                return -1;
              for (j = 0; j < (int) sizeof (struct in6_addr); j++)
                network.s6_addr[j] = addr->s6_addr[j] & mask.s6_addr[j];
 
              g_debug ("comparing addresses %s and %s",
                       inet_ntop (AF_INET6, &network, addr1, sizeof (addr1)),
                       inet_ntop (AF_INET6, &myroutes[i].dest6, addr2,
                                  sizeof (addr2)));
              if (IN6_ARE_ADDR_EQUAL (&network, &myroutes[i].dest6))
                {
                  return 1;
                }
            }
        }
    }
  return 0;
}

References interface_info::addr6, DEBUG_IPV4, getipv6routes(), ipv6_prefix_to_mask(), interface_info::mask, MAXROUTES, name, and v6_getinterfaces().

Referenced by nasl_islocalnet().

Here is the call graph for this function:

Here is the caller graph for this function:

v6_islocalhost()

int v6_islocalhost

(

struct in6_addr *

addr

)

Tests whether a packet sent to IP is LIKELY to route through the kernel localhost interface.

Definition at line 234 of file pcap.c.

{
  char dev[128];
 
  if (addr == NULL)
    return -1;
 
  if (IN6_IS_ADDR_V4MAPPED (addr))
    {
      /* If it is 0.0.0.0 or starts with 127.0.0.1 then it is
         probably localhost */
      if ((addr->s6_addr32[3] & htonl (0xFF000000)) == htonl (0x7F000000))
        return 1;
 
      if (!addr->s6_addr32[3])
        return 1;
    }
 
  if (IN6_IS_ADDR_LOOPBACK (addr))
    return 1;
 
  /* If it is the same addy as a local interface, then it is
     probably localhost */
 
  if (v6_ipaddr2devname (dev, sizeof (dev), addr) != -1)
    return 1;
 
  /* OK, so to a first approximation, this addy is probably not
     localhost */
  return 0;
}

References interface_info::addr, and v6_ipaddr2devname().

Referenced by Ensure(), init_v6_capture_device(), nasl_islocalhost(), nasl_send_v6packet(), nasl_tcp_v6_ping(), nasl_this_host(), openvas_routethrough(), and v6_routethrough().

Here is the call graph for this function:

Here is the caller graph for this function:

v6_routethrough()

char * v6_routethrough	(	struct in6_addr *	dest,
		struct in6_addr *	source )

An awesome function to determine what interface a packet to a given destination should be routed through.

It returns NULL if no appropriate interface is found, otherwise it returns the device name and fills in the source parameter. Some of the stuff is from Stevens' Unix Network Programming V2. He had an easier suggestion for doing this (in the book), but it isn't portable :(

Definition at line 851 of file pcap.c.

{
  static int initialized = 0;
  int i;
  struct in6_addr addy;
  static enum {
    procroutetechnique,
    connectsockettechnique,
    guesstechnique
  } technique = procroutetechnique;
  struct interface_info *mydevs;
  static struct myroute myroutes[MAXROUTES];
  int numinterfaces = 0;
  static int numroutes = 0;
  struct in6_addr mask;
  struct in6_addr network = {0};
  struct in6_addr src;
  long best_match = -1;
 
  if (!dest)
    {
      g_message ("ipaddr2devname passed a NULL dest address");
      return NULL;
    }
 
  if (IN6_IS_ADDR_V4MAPPED (dest))
    gvm_source_addr_as_addr6 (&src);
  else
    gvm_source_addr6 (&src);
 
  if (!initialized)
    {
      /* Dummy socket for ioctl */
      initialized = 1;
      mydevs = v6_getinterfaces (&numinterfaces);
      if (IN6_IS_ADDR_V4MAPPED (dest))
        {
          if (getipv4routes (myroutes, &numroutes) < 0)
            technique = connectsockettechnique;
        }
      else
        {
          if (getipv6routes (myroutes, &numroutes) < 0)
            technique = connectsockettechnique;
        }
    }
  else
    {
      mydevs = v6_getinterfaces (&numinterfaces);
    }
  /* WHEW, that takes care of initializing, now we have the easy job of
     finding which route matches */
  if (v6_islocalhost (dest))
    {
      if (source)
        {
          if (IN6_IS_ADDR_V4MAPPED (source))
            {
              source->s6_addr32[0] = 0;
              source->s6_addr32[1] = 0;
              source->s6_addr32[2] = htonl (0xffff);
              source->s6_addr32[3] = htonl (0x7F000001);
            }
          else
            {
              source->s6_addr32[0] = 0;
              source->s6_addr32[1] = 0;
              source->s6_addr32[2] = 0;
              source->s6_addr32[3] = htonl (1);
            }
        }
      /* Now we find the localhost interface name, assuming 127.0.0.1
         or ::1 is localhost (it damn well better be!)... */
      for (i = 0; i < numinterfaces; i++)
        {
          if (IN6_IS_ADDR_V4MAPPED (&mydevs[i].addr6))
            {
              if (mydevs[i].addr6.s6_addr32[3] == htonl (0x7F000001))
                return mydevs[i].name;
            }
          else
            {
              if (IN6_ARE_ADDR_EQUAL (&in6addr_any, &mydevs[i].addr6))
                return mydevs[i].name;
            }
        }
      return NULL;
    }
 
  if (technique == procroutetechnique)
    {
      char addr1[INET6_ADDRSTRLEN];
      char addr2[INET6_ADDRSTRLEN];
      for (i = 0; i < numroutes; i++)
        {
          if (ipv6_prefix_to_mask (myroutes[i].mask, &mask) == -1)
            {
              g_warning ("error creating IPv6 mask from prefix: %ld",
                         myroutes[i].mask);
              return NULL;
            }
          for (int j = 0; j < (int) sizeof (struct in6_addr); j++)
            network.s6_addr[j] = dest->s6_addr[j] & mask.s6_addr[j];
 
          g_debug (
            "comparing addresses %s and %s",
            inet_ntop (AF_INET6, &network, addr1, sizeof (addr1)),
            inet_ntop (AF_INET6, &myroutes[i].dest6, addr2, sizeof (addr2)));
          /* matching route found */
          if (IN6_ARE_ADDR_EQUAL (&network, &myroutes[i].dest6))
            {
              /* First time a match is found */
              if (-1 == best_match)
                {
                  best_match = i;
                }
              else
                {
                  /* Better match found */
                  if (myroutes[i].mask > myroutes[best_match].mask)
                    {
                      best_match = i;
                    }
                  /* Match with equal mask and smaller (better) metric found */
                  else if ((myroutes[i].mask == myroutes[best_match].mask)
                           && (myroutes[i].metric
                               < myroutes[best_match].metric))
                    {
                      best_match = i;
                    }
                }
            }
        }
      if (source)
        {
          if (!IN6_ARE_ADDR_EQUAL (&src, &in6addr_any))
            memcpy (source, &src, sizeof (struct in6_addr));
          else
            {
              if (myroutes[best_match].dev != NULL)
                {
                  memcpy (source, &myroutes[best_match].dev->addr6,
                          sizeof (struct in6_addr));
                }
            }
        }
      g_debug (
        "%s: Best matching route with dst '%s' metric '%ld' and interface '%s'",
        __func__,
        inet_ntop (AF_INET6, &myroutes[best_match].dest6, addr1,
                   sizeof (addr1)),
        myroutes[best_match].mask, myroutes[best_match].dev->name);
      if (best_match != -1)
        return myroutes[best_match].dev->name;
 
      technique = connectsockettechnique;
    }
  if (technique == connectsockettechnique)
    {
      if (!v6_getsourceip (&addy, dest))
        return NULL;
      if (IN6_ARE_ADDR_EQUAL (&addy, &network))
        {
          struct hostent *myhostent = NULL;
          char myname[MAXHOSTNAMELEN + 1];
 
          myhostent = gethostbyname (myname);
          if (gethostname (myname, MAXHOSTNAMELEN) || !myhostent)
            g_message ("Cannot get hostname!");
          else if (myhostent->h_addrtype == AF_INET)
            {
              addy.s6_addr32[0] = 0;
              addy.s6_addr32[1] = 0;
              addy.s6_addr32[2] = htonl (0xffff);
              memcpy (&addy.s6_addr32[0], myhostent->h_addr_list[0],
                      sizeof (struct in6_addr));
            }
          else
            memcpy (&addy, myhostent->h_addr_list[0], sizeof (struct in6_addr));
        }
 
      /* Now we insure this claimed address is a real interface ... */
      for (i = 0; i < numinterfaces; i++)
        {
          char addr1[INET6_ADDRSTRLEN];
          char addr2[INET6_ADDRSTRLEN];
 
          g_debug (
            "comparing addresses %s and %s",
            inet_ntop (AF_INET6, &mydevs[i].addr6, addr1, sizeof (addr1)),
            inet_ntop (AF_INET6, &addy, addr2, sizeof (addr2)));
          if (IN6_ARE_ADDR_EQUAL (&mydevs[i].addr6, &addy))
            {
              if (source)
                {
                  memcpy (source, &addy, sizeof (struct in6_addr));
                }
              return mydevs[i].name;
            }
        }
      return NULL;
    }
  else
    g_message ("%s: Provided technique is neither proc route nor"
               " connect socket",
               __func__);
  return NULL;
}

References myroute::dev, getipv4routes(), getipv6routes(), ipv6_prefix_to_mask(), MAXROUTES, interface_info::name, v6_getinterfaces(), v6_getsourceip(), and v6_islocalhost().

Referenced by get_mtu(), init_v6_capture_device(), nasl_pcap_next(), nasl_send_capture(), nasl_tcp_v6_ping(), and v6_openbpf().

Here is the call graph for this function:

Here is the caller graph for this function: