gnunet-helper-vpn.c File Reference

the helper for the VPN service. More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_common.h"
#include "gnunet_protocols.h"

Include dependency graph for gnunet-helper-vpn.c:

Go to the source code of this file.

Data Structures
struct	in6_ifreq
	This is in linux/include/net/ipv6.h, but not always exported... More...

Macros
#define	DEBUG   GNUNET_NO
	Need 'struct GNUNET_MessageHeader'. More...
#define	MAX_SIZE   65536
	Maximum size of a GNUnet message (GNUNET_MAX_MESSAGE_SIZE) More...

Functions
static int	init_tun (char *dev)
	Creates a tun-interface called dev;. More...
static void	set_address6 (const char *dev, const char *address, unsigned long prefix_len)
	Sets the IPv6-Address given in address on the interface dev. More...
static void	set_address4 (const char *dev, const char *address, const char *mask)
	Sets the IPv4-Address given in address on the interface dev. More...
static void	run (int fd_tun)
	Start forwarding to and from the tunnel. More...
int	main (int argc, char **argv)
	Open VPN tunnel interface. More...

Detailed Description

the helper for the VPN service.

Opens a virtual network-interface, sends data received on the if to stdout, sends data received on stdin to the interface

Author

Philipp Tölke

Christian Grothoff

The following list of people have reviewed this code and considered it safe since the last modification (if you reviewed it, please have your name added to the list):

• Philipp Tölke

Definition in file gnunet-helper-vpn.c.

Macro Definition Documentation

DEBUG

#define DEBUG   GNUNET_NO

Need 'struct GNUNET_MessageHeader'.

Need VPN message types. Should we print (interesting|debug) messages that can happen during normal operation?

Definition at line 55 of file gnunet-helper-vpn.c.

MAX_SIZE

#define MAX_SIZE   65536

Maximum size of a GNUnet message (GNUNET_MAX_MESSAGE_SIZE)

Definition at line 60 of file gnunet-helper-vpn.c.

Function Documentation

init_tun()

static int init_tun ( char *  dev )

static

Creates a tun-interface called dev;.

Parameters

dev	is assumed to point to a char[IFNAMSIZ] if *dev == '\0', uses the name supplied by the kernel;

Returns

the fd to the tun or -1 on error

Definition at line 85 of file gnunet-helper-vpn.c.

{
  struct ifreq ifr;
  int fd;
 
  if (NULL == dev)
  {
    errno = EINVAL;
    return -1;
  }
 
  if (-1 == (fd = open ("/dev/net/tun", O_RDWR)))
  {
    fprintf (stderr,
             "Error opening `%s': %s\n",
             "/dev/net/tun",
             strerror (errno));
    return -1;
  }
 
  if (fd >= FD_SETSIZE)
  {
    fprintf (stderr,
             "File descriptor to large: %d",
             fd);
    (void) close (fd);
    return -1;
  }
 
  memset (&ifr, 0, sizeof(ifr));
  ifr.ifr_flags = IFF_TUN;
 
  if ('\0' != *dev)
    strncpy (ifr.ifr_name,
             dev,
             IFNAMSIZ);
 
  if (-1 == ioctl (fd,
                   TUNSETIFF,
                   (void *) &ifr))
  {
    fprintf (stderr,
             "Error with ioctl on `%s': %s\n",
             "/dev/net/tun",
             strerror (errno));
    (void) close (fd);
    return -1;
  }
  strcpy (dev, ifr.ifr_name);
  return fd;
}

Referenced by main().

Here is the caller graph for this function:

set_address6()

static void set_address6 ( const char *  dev, const char *  address, unsigned long  prefix_len  )

static

Sets the IPv6-Address given in address on the interface dev.

Parameters

dev	the interface to configure
address	the IPv6-Address
prefix_len	the length of the network-prefix

Definition at line 146 of file gnunet-helper-vpn.c.

{
  struct ifreq ifr;
  struct in6_ifreq ifr6;
  struct sockaddr_in6 sa6;
  int fd;
 
  /*
   * parse the new address
   */
  memset (&sa6, 0, sizeof(struct sockaddr_in6));
  sa6.sin6_family = AF_INET6;
  if (1 != inet_pton (AF_INET6, address, sa6.sin6_addr.s6_addr))
  {
    fprintf (stderr,
             "Failed to parse IPv6 address `%s'\n",
             address);
    exit (1);
  }
 
  if (-1 == (fd = socket (PF_INET6, SOCK_DGRAM, 0)))
  {
    fprintf (stderr,
             "Error creating socket: %s\n",
             strerror (errno));
    exit (1);
  }
 
  memset (&ifr, 0, sizeof(struct ifreq));
  /*
   * Get the index of the if
   */
  strncpy (ifr.ifr_name,
           dev,
           IFNAMSIZ);
  if (-1 == ioctl (fd,
                   SIOGIFINDEX,
                   &ifr))
  {
    fprintf (stderr,
             "ioctl failed at %d: %s\n",
             __LINE__,
             strerror (errno));
    (void) close (fd);
    exit (1);
  }
 
  memset (&ifr6, 0, sizeof(struct in6_ifreq));
  ifr6.ifr6_addr = sa6.sin6_addr;
  ifr6.ifr6_ifindex = ifr.ifr_ifindex;
  ifr6.ifr6_prefixlen = prefix_len;
 
  /*
   * Set the address
   */
  if (-1 == ioctl (fd,
                   SIOCSIFADDR,
                   &ifr6))
  {
    fprintf (stderr,
             "ioctl failed at line %d: %s\n",
             __LINE__,
             strerror (errno));
    (void) close (fd);
    exit (1);
  }
 
  /*
   * Get the flags
   */
  if (-1 == ioctl (fd,
                   SIOCGIFFLAGS,
                   &ifr))
  {
    fprintf (stderr,
             "ioctl failed at line %d: %s\n",
             __LINE__,
             strerror (errno));
    (void) close (fd);
    exit (1);
  }
 
  /*
   * Add the UP and RUNNING flags
   */
  ifr.ifr_flags |= IFF_UP | IFF_RUNNING;
  if (-1 == ioctl (fd,
                   SIOCSIFFLAGS,
                   &ifr))
  {
    fprintf (stderr,
             "ioctl failed at line %d: %s\n",
             __LINE__,
             strerror (errno));
    (void) close (fd);
    exit (1);
  }
 
  if (0 != close (fd))
  {
    fprintf (stderr,
             "close failed at line %d: %s\n",
             __LINE__,
             strerror (errno));
    exit (1);
  }
}

References address, in6_ifreq::ifr6_addr, in6_ifreq::ifr6_ifindex, and in6_ifreq::ifr6_prefixlen.

Referenced by main().

Here is the caller graph for this function:

set_address4()

static void set_address4 ( const char *  dev, const char *  address, const char *  mask  )

static

Sets the IPv4-Address given in address on the interface dev.

Parameters

dev	the interface to configure
address	the IPv4-Address
mask	the netmask

Definition at line 265 of file gnunet-helper-vpn.c.

{
  int fd;
  struct sockaddr_in *addr;
  struct ifreq ifr;
 
  memset (&ifr, 0, sizeof(struct ifreq));
  addr = (struct sockaddr_in *) &(ifr.ifr_addr);
  addr->sin_family = AF_INET;
 
  /*
   * Parse the address
   */
  if (1 != inet_pton (AF_INET,
                      address,
                      &addr->sin_addr.s_addr))
  {
    fprintf (stderr,
             "Failed to parse IPv4 address `%s'\n",
             address);
    exit (1);
  }
 
  if (-1 == (fd = socket (PF_INET, SOCK_DGRAM, 0)))
  {
    fprintf (stderr,
             "Error creating socket: %s\n",
             strerror (errno));
    exit (1);
  }
 
  strncpy (ifr.ifr_name, dev, IFNAMSIZ);
 
  /*
   * Set the address
   */
  if (-1 == ioctl (fd, SIOCSIFADDR, &ifr))
  {
    fprintf (stderr,
             "ioctl failed at %d: %s\n",
             __LINE__,
             strerror (errno));
    (void) close (fd);
    exit (1);
  }
 
  /*
   * Parse the netmask
   */
  addr = (struct sockaddr_in *) &(ifr.ifr_netmask);
  if (1 != inet_pton (AF_INET,
                      mask,
                      &addr->sin_addr.s_addr))
  {
    fprintf (stderr,
             "Failed to parse IPv4 address mask `%s'\n",
             mask);
    (void) close (fd);
    exit (1);
  }
 
  /*
   * Set the netmask
   */
  if (-1 == ioctl (fd, SIOCSIFNETMASK, &ifr))
  {
    fprintf (stderr,
             "ioctl failed at line %d: %s\n",
             __LINE__,
             strerror (errno));
    (void) close (fd);
    exit (1);
  }
 
  /*
   * Get the flags
   */
  if (-1 == ioctl (fd, SIOCGIFFLAGS, &ifr))
  {
    fprintf (stderr,
             "ioctl failed at line %d: %s\n",
             __LINE__,
             strerror (errno));
    (void) close (fd);
    exit (1);
  }
 
  /*
   * Add the UP and RUNNING flags
   */
  ifr.ifr_flags |= IFF_UP | IFF_RUNNING;
  if (-1 == ioctl (fd, SIOCSIFFLAGS, &ifr))
  {
    fprintf (stderr,
             "ioctl failed at line %d: %s\n",
             __LINE__,
             strerror (errno));
    (void) close (fd);
    exit (1);
  }
 
  if (0 != close (fd))
  {
    fprintf (stderr,
             "close failed at line %d: %s\n",
             __LINE__,
             strerror (errno));
    exit (1);
  }
}

References address.

Referenced by main().

Here is the caller graph for this function:

run()

static void run ( int  fd_tun )

static

Start forwarding to and from the tunnel.

Parameters

fd_tun

tunnel FD

Definition at line 385 of file gnunet-helper-vpn.c.

{
  /*
   * The buffer filled by reading from fd_tun
   */
  unsigned char buftun[MAX_SIZE];
  ssize_t buftun_size = 0;
  unsigned char *buftun_read = NULL;
 
  /*
   * The buffer filled by reading from stdin
   */
  unsigned char bufin[MAX_SIZE];
  ssize_t bufin_size = 0;
  size_t bufin_rpos = 0;
  unsigned char *bufin_read = NULL;
  int r;
 
  fd_set fds_w;
  fd_set fds_r;
 
  /* read refers to reading from fd_tun, writing to stdout */
  int read_open = 1;
 
  /* write refers to reading from stdin, writing to fd_tun */
  int write_open = 1;
 
  while ((1 == read_open) && (1 == write_open))
  {
    FD_ZERO (&fds_w);
    FD_ZERO (&fds_r);
 
    /*
     * We are supposed to read and the buffer is empty
     * -> select on read from tun
     */
    if (read_open && (0 == buftun_size))
      FD_SET (fd_tun, &fds_r);
 
    /*
     * We are supposed to read and the buffer is not empty
     * -> select on write to stdout
     */
    if (read_open && (0 != buftun_size))
      FD_SET (1, &fds_w);
 
    /*
     * We are supposed to write and the buffer is empty
     * -> select on read from stdin
     */
    if (write_open && (NULL == bufin_read))
      FD_SET (0, &fds_r);
 
    /*
     * We are supposed to write and the buffer is not empty
     * -> select on write to tun
     */
    if (write_open && (NULL != bufin_read))
      FD_SET (fd_tun, &fds_w);
 
    r = select (fd_tun + 1, &fds_r, &fds_w, NULL, NULL);
 
    if (-1 == r)
    {
      if (EINTR == errno)
        continue;
      fprintf (stderr,
               "select failed: %s\n",
               strerror (errno));
      exit (1);
    }
 
    if (r > 0)
    {
      if (FD_ISSET (fd_tun, &fds_r))
      {
        buftun_size =
          read (fd_tun, buftun + sizeof(struct GNUNET_MessageHeader),
                MAX_SIZE - sizeof(struct GNUNET_MessageHeader));
        if (-1 == buftun_size)
        {
          fprintf (stderr,
                   "read-error: %s\n",
                   strerror (errno));
          shutdown (fd_tun, SHUT_RD);
          shutdown (1, SHUT_WR);
          read_open = 0;
          buftun_size = 0;
        }
        else if (0 == buftun_size)
        {
          fprintf (stderr, "EOF on tun\n");
          shutdown (fd_tun, SHUT_RD);
          shutdown (1, SHUT_WR);
          read_open = 0;
          buftun_size = 0;
        }
        else
        {
          struct GNUNET_MessageHeader *hdr =
            (struct GNUNET_MessageHeader *) buftun;
          buftun_read = buftun;
          buftun_size += sizeof(struct GNUNET_MessageHeader);
          hdr->type = htons (GNUNET_MESSAGE_TYPE_VPN_HELPER);
          hdr->size = htons (buftun_size);
        }
      }
      else if (FD_ISSET (1, &fds_w))
      {
        ssize_t written = write (1,
                                 buftun_read,
                                 buftun_size);
 
        if (-1 == written)
        {
#if ! DEBUG
          if (errno != EPIPE)
#endif
          fprintf (stderr,
                   "write-error to stdout: %s\n",
                   strerror (errno));
          shutdown (fd_tun, SHUT_RD);
          shutdown (1, SHUT_WR);
          read_open = 0;
          buftun_size = 0;
        }
        else if (0 == written)
        {
          fprintf (stderr,
                   "write returned 0!?\n");
          exit (1);
        }
        else
        {
          buftun_size -= written;
          buftun_read += written;
        }
      }
 
      if (FD_ISSET (0, &fds_r))
      {
        bufin_size = read (0, bufin + bufin_rpos, MAX_SIZE - bufin_rpos);
        if (-1 == bufin_size)
        {
          fprintf (stderr,
                   "read-error: %s\n",
                   strerror (errno));
          shutdown (0, SHUT_RD);
          shutdown (fd_tun, SHUT_WR);
          write_open = 0;
          bufin_size = 0;
        }
        else if (0 == bufin_size)
        {
#if DEBUG
          fprintf (stderr, "EOF on stdin\n");
#endif
          shutdown (0, SHUT_RD);
          shutdown (fd_tun, SHUT_WR);
          write_open = 0;
          bufin_size = 0;
        }
        else
        {
          struct GNUNET_MessageHeader *hdr;
 
PROCESS_BUFFER:
          bufin_rpos += bufin_size;
          if (bufin_rpos < sizeof(struct GNUNET_MessageHeader))
            continue;
          hdr = (struct GNUNET_MessageHeader *) bufin;
          if (ntohs (hdr->type) != GNUNET_MESSAGE_TYPE_VPN_HELPER)
          {
            fprintf (stderr,
                     "protocol violation!\n");
            exit (1);
          }
          if (ntohs (hdr->size) > bufin_rpos)
            continue;
          bufin_read = bufin + sizeof(struct GNUNET_MessageHeader);
          bufin_size = ntohs (hdr->size) - sizeof(struct GNUNET_MessageHeader);
          bufin_rpos -= bufin_size + sizeof(struct GNUNET_MessageHeader);
        }
      }
      else if (FD_ISSET (fd_tun, &fds_w))
      {
        ssize_t written = write (fd_tun,
                                 bufin_read,
                                 bufin_size);
 
        if (-1 == written)
        {
          fprintf (stderr,
                   "write-error to tun: %s\n",
                   strerror (errno));
          shutdown (0, SHUT_RD);
          shutdown (fd_tun, SHUT_WR);
          write_open = 0;
          bufin_size = 0;
        }
        else if (0 == written)
        {
          fprintf (stderr, "write returned 0!?\n");
          exit (1);
        }
        else
        {
          bufin_size -= written;
          bufin_read += written;
          if (0 == bufin_size)
          {
            memmove (bufin, bufin_read, bufin_rpos);
            bufin_read = NULL;           /* start reading again */
            bufin_size = 0;
            goto PROCESS_BUFFER;
          }
        }
      }
    }
  }
}

References GNUNET_MESSAGE_TYPE_VPN_HELPER, MAX_SIZE, GNUNET_MessageHeader::size, and GNUNET_MessageHeader::type.

Referenced by main().

Here is the caller graph for this function:

main()

int main	(	int	argc,
		char **	argv
	)

Open VPN tunnel interface.

Parameters

argc	must be 6
argv	0: binary name (gnunet-helper-vpn) 1: tunnel interface name (gnunet-vpn) 2: IPv6 address (::1), "-" to disable 3: IPv6 netmask length in bits (64), ignored if #2 is "-" 4: IPv4 address (1.2.3.4), "-" to disable 5: IPv4 netmask (255.255.0.0), ignored if #4 is "-"

Definition at line 620 of file gnunet-helper-vpn.c.

{
  char dev[IFNAMSIZ];
  int fd_tun;
  int global_ret;
 
  if (6 != argc)
  {
    fprintf (stderr, "Fatal: must supply 5 arguments!\n");
    return 1;
  }
 
  strncpy (dev,
           argv[1],
           IFNAMSIZ);
  dev[IFNAMSIZ - 1] = '\0';
 
  if (-1 == (fd_tun = init_tun (dev)))
  {
    fprintf (stderr,
             "Fatal: could not initialize tun-interface `%s'  with IPv6 %s/%s and IPv4 %s/%s\n",
             dev,
             argv[2],
             argv[3],
             argv[4],
             argv[5]);
    return 1;
  }
 
  if (0 != strcmp (argv[2], "-"))
  {
    const char *address = argv[2];
    long prefix_len = atol (argv[3]);
 
    if ((prefix_len < 1) || (prefix_len > 127))
    {
      fprintf (stderr,
               "Fatal: prefix_len out of range\n");
      (void) close (fd_tun);
      return 1;
    }
 
    set_address6 (dev,
                  address,
                  prefix_len);
  }
 
  if (0 != strcmp (argv[4], "-"))
  {
    const char *address = argv[4];
    const char *mask = argv[5];
 
    set_address4 (dev, address, mask);
  }
 
#ifdef HAVE_SETRESUID
  {
    uid_t uid = getuid ();
    if (0 != setresuid (uid, uid, uid))
    {
      fprintf (stderr,
               "Failed to setresuid: %s\n",
               strerror (errno));
      global_ret = 2;
      goto cleanup;
    }
  }
#else
  if (0 != (setuid (uid) | seteuid (uid)))
  {
    fprintf (stderr,
             "Failed to setuid: %s\n",
             strerror (errno));
    global_ret = 2;
    goto cleanup;
  }
#endif
 
  if (SIG_ERR == signal (SIGPIPE, SIG_IGN))
  {
    fprintf (stderr,
             "Failed to protect against SIGPIPE: %s\n",
             strerror (errno));
    /* no exit, we might as well die with SIGPIPE should it ever happen */
  }
  run (fd_tun);
  global_ret = 0;
cleanup:
  (void) close (fd_tun);
  return global_ret;
}

References address, cleanup(), global_ret, init_tun(), run(), set_address4(), and set_address6().

Here is the call graph for this function: