Como a interface com o driver tun Linux

Question

Eu estou tendo um momento difícil descobrir este problema fora - Estou tentando escrever um programa que irá interagir com o motorista túnel Linux. Em um nível muito básico, eu simplesmente quero criar um aplicativo que é capaz de transferir dados através de um túnel de rede. No entanto, estou completamente em uma perda a respeito de como configurar corretamente o motorista do túnel, a fim de alcançar este objetivo.

Estou desenvolvendo no Ubuntu 9.04, e eu tenho o módulo do kernel motorista túnel carregado.

Existe a /dev/net/tun dispositivo, no entanto não existem dispositivos /dev/tunX. Eu sou incapaz de criar esses dispositivos usando ifconfig - sempre que eu executar /sbin/ifconfig tun0 up, por exemplo, eu recebo o seguinte erro:

tun0: erro ao obter bandeiras de interface:. Sem tal dispositivo

Se eu tentar olhar para o dispositivo /dev/net/tun, o seguinte erro é apresentado:

cat: / dev / net / tun:. Descritor de arquivo em mau estado

A tentativa de /dev/tunX aberta através de um pequeno programa, basicamente, um simples

tun_fd = open( "/dev/tun0", O_RDWR )

retorna -1: o aplicativo é executado como root e ainda não pode abrir este dispositivo túnel. É possível /dev/net/tun aberto, no entanto, este não parece gerar um novo dispositivo /dev/tunX para usar em vez.

Assim, em resumo - como se faz para escrever um aplicativo que deseje usar o driver túnel Linux? Qualquer idéias seria muito apreciada.

Graças; ~ Robert

Answer 1

Leia /usr/src/linux/Documentation/networking/tuntap.txt .

Você é suposto open o dispositivo /dev/net/tun. A ioctl posterior na fd aberto irá criar o tun0 (ou o que você deseja nomeá-lo) de interface de rede. interfaces de rede do Linux não correspondem a qualquer dispositivo /dev/*.

Answer 2

Não existem arquivos de dispositivos /dev/tunX. Em vez disso, você abre o /dev/net/tun e configurá-lo via ioctl() para "apontar" para tun0. Para mostrar o procedimento básico, vou criar o TUN interface usando a ferramenta de linha de comando ip tun tap e, em seguida, mostrar o código C para ler a partir desse dispositivo TUN. Portanto, para criar a interface tun via linha de comandos:

sudo ip tuntap add mode tun dev tun0
ip addr add 10.0.0.0/24 dev tun0  # give it an ip
ip link set dev tun0 up  # bring the if up
ip route get 10.0.0.2  # check that packets to 10.0.0.x are going through tun0
ping 10.0.0.2  # leave this running in another shell to be able to see the effect of the next example

Agora temos tun0 criado. Para ler / pacotes de gravação para esta interface de um programa de espaço de usuário que você precisa para interagir com o arquivo de dispositivo /dev/net/tun usando ioctl(). Aqui está um exemplo que irá ler os pacotes que chegam na interface tun0 e imprimir o tamanho:

#include <fcntl.h>  /* O_RDWR */
#include <string.h> /* memset(), memcpy() */
#include <stdio.h> /* perror(), printf(), fprintf() */
#include <stdlib.h> /* exit(), malloc(), free() */
#include <sys/ioctl.h> /* ioctl() */

/* includes for struct ifreq, etc */
#include <sys/types.h>
#include <sys/socket.h>
#include <linux/if.h>
#include <linux/if_tun.h>

int tun_open(char *devname)
{
  struct ifreq ifr;
  int fd, err;

  if ( (fd = open("/dev/net/tun", O_RDWR)) == -1 ) {
       perror("open /dev/net/tun");exit(1);
  }
  memset(&ifr, 0, sizeof(ifr));
  ifr.ifr_flags = IFF_TUN;
  strncpy(ifr.ifr_name, devname, IFNAMSIZ); // devname = "tun0" or "tun1", etc 

  /* ioctl will use ifr.if_name as the name of TUN 
   * interface to open: "tun0", etc. */
  if ( (err = ioctl(fd, TUNSETIFF, (void *) &ifr)) == -1 ) {
    perror("ioctl TUNSETIFF");close(fd);exit(1);
  }

  /* After the ioctl call the fd is "connected" to tun device specified
   * by devname ("tun0", "tun1", etc)*/

  return fd;
}


int main(int argc, char *argv[])
{
  int fd, nbytes;
  char buf[1600];

  fd = tun_open("tun0"); /* devname = ifr.if_name = "tun0" */
  printf("Device tun0 opened\n");
  while(1) {
    nbytes = read(fd, buf, sizeof(buf));
    printf("Read %d bytes from tun0\n", nbytes);
  }
  return 0;
}

Answer 3

me deparei com uma introdução agradável tutorial sobre este

http://backreference.org/2010/03/26/tuntap -interface-tutorial /

Ele vem com um tarball fonte.

Foi no mesmo conjunto de resultados do Google como esta questão. :-)