Comment s'interfacer avec le pilote de tuner Linux

Je vais avoir un moment difficile de déterminer ce problème - je suis en train d'écrire un programme qui interagit avec l'Linux tunnel pilote. À un niveau très basique, je veux simplement créer une application qui est capable de transférer des données sur un réseau de tunnel. Cependant, je suis tout à fait à une perte quant à la façon de configurer correctement le tunnel pilote afin d'accomplir cette tâche.

Je suis en train d'élaborer sur Ubuntu 9.04, et j'ai le tunnel pilote de module de noyau chargé.

Il existe le dispositif /dev/net/tuncependant il n'y a pas /dev/tunX appareils. Je suis incapable de créer ces périphériques à l'aide de ifconfig - chaque fois que j'exécute /sbin/ifconfig tun0 uppar exemple, j'obtiens l'erreur suivante:

tun0: ERREUR lors de l'obtention drapeaux de l'interface: Aucun périphérique.

Si je tente de regarder la /dev/net/tun de l'appareil, le message d'erreur suivant est présenté:

chat: /dev/net/tun: descripteur de Fichier en mauvais état.

De tenter de l'ouvrir /dev/tunX via un petit programme, en fait, un simple

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

retourne -1: l'application s'exécute en tant que root et ne peut toujours pas ouvrir ce tunnel de l'appareil. Il est possible d'ouvrir /dev/net/tuncependant cela ne semble pas générer un nouveau /dev/tunX appareil à utiliser à la place.

Donc, en résumé - comment fait-on pour écrire une application qui souhaite utiliser le Linux tunnel pilote? Toutes les suggestions seraient grandement appréciés.

Grâce;
~Robert

source d'informationauteur rmrobins

  1. 14

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

    Vous êtes censé open la /dev/net/tun appareil. Une ultérieure ioctl sur le fd va créer le tun0 (ou ce que vous voulez l'appeler) de l'interface réseau. Linux interfaces réseau ne correspondent pas à des /dev/* appareil.

  2. 10

    Il n'y a pas /dev/tunX les fichiers de périphériques. Au lieu de cela, vous ouvrez la /dev/net/tun et de le configurer via ioctl() au "point" à tun0. Pour afficher la procédure de base, je vais créer l'interface TUN à l'aide de l'outil de ligne de commande ip tun tap et puis afficher le code C pour lire que TUN de l'appareil. Ainsi, pour créer l'interface tun via la ligne de commandes: 

    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

    Maintenant, nous avons tun0 créé. Pour lire /écrire des paquets à cette interface à partir d'un programme de l'espace utilisateur, vous devez interagir avec le /dev/net/tun fichier de périphérique à l'aide de ioctl(). Voici un exemple qui va lire les paquets arrivant à la tun0 de l'interface et de l'imprimer à la taille:

    #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;
}
  3. 2

    Je suis tombé sur une belle intro tutoriel à propos de cette

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

    Il est livré avec une archive source.

    Il était dans le même ensemble de résultats de Google comme cette question. 🙂