Protocolo de camada de enlace customizado no UNIX [closed]

Question

Eu queria saber se alguém tem alguma informação sobre como implementar um portocol de camada de link que usa os GPIOs (por exemplo, em um Raspberry Pi).

A idéia é implementar uma interface customizada (semelhante a eth0) que seria ponto-a-ponto e quando uma mensagem é enviada através dessa interface ao invés de chamar o módulo ethernet, meu novo módulo do kernel (driver de dispositivo) seria chamado que usaria os GPIOs para enviar o pacote.

Eu gostaria de saber algumas coisas:

• Alguém sabe de algum livro / artigo / ... com um exemplo de algo semelhante ou informações que eu precisaria saber? Eu encontrei muitas coisas nos módulos do kernel e assim, mas nada sobre "conectar" a nova interface com o módulo do kernel.

• Ele precisa ser implementado com TCP / IP se eu quiser que ele apareça como uma nova interface? (Suponho que a resposta seja sim)

Minha pesquisa me levou a algumas páginas da Web interessantes:

• Implementação do driver de dispositivo exemplo para o raspberry pi ( controlando GPIOs).

Implementação da RFC1149

Mas ainda estou bastante perdido quando se trata da parte de implementação da interface e como "conectá-la" ao driver. Então, quando eu faço um ping usando a nova interface, ele envia o pacote IP para o meu driver de dispositivo, então eu deveria encapsulá-lo e enviá-lo através do meu hardware.

Obrigado, espero obter algumas respostas!

    

Answer 1

Supondo que seja suficiente para o seu protocolo controlar os pinos GPIO do userspace via /sys/class/gpio/ , a maneira mais simples é escrever um driver tap do espaço do usuário. Da documentação do kernel linux/Documentation/networking/tuntap.txt :

TUN/TAP provides packet reception and transmission for user space programs. It can be seen as a simple Point-to-Point or Ethernet device, which, instead of receiving packets from physical media, receives them from user space program and instead of sending packets via physical media writes them to the user space program.

In order to use the driver a program has to open /dev/net/tun and issue a corresponding ioctl() to register a network device with the kernel. A network device will appear as tunXX or tapXX, depending on the options chosen. When the program closes the file descriptor, the network device and all corresponding routes will disappear.

Depending on the type of device chosen the userspace program has to read/write IP packets (with tun) or ethernet frames (with tap). Which one is being used depends on the flags given with the ioctl().

The package from http://vtun.sourceforge.net/tun contains two simple examples for how to use tun and tap devices. Both programs work like a bridge between two network interfaces.

• br_select.c - bridge based on select system call.
• br_sigio.c - bridge based on async io and SIGIO signal.

However, the best example is VTun http://vtun.sourceforge.net :))

Você também pode pesquisar no Google muitos tutoriais (embora a maioria provavelmente seja sobre uma interface tun , ou seja, pacotes IP em vez de quadros Ethernet).

Mesmo que o produto final precise ser um módulo do kernel, eu ainda começaria com um driver tap , porque eles são muito mais fáceis de depurar. Você ainda pode transformá-lo em um módulo do kernel depois que a maioria já funciona.