Comment envoyer des données sur un raw connecteur ethernet à l'aide de sendto sans l'aide de sockaddr_ll?

Autant que je suis conscient de l'Enea OSE vient avec ces en-têtes

#include <sys/socket.h>
#include <netpacket/packet.h>

Ce dernier déclare struct sockaddr_ll qui devrait vous permettre d'envoyer des paquets ethernet à un socket de type

int sockfd = socket(AF_PACKET, type, protocol);

Type peut être SOCK_DGRAM ou SOCK_RAW (vous en aurez besoin pour créer l'en-tête ethernet vous-même).

Je n'ai pas le droit d'en-tête pour les protocoles ethernet. Vous aurez besoin de chercher vos en-têtes pour ETH_* définit et trouver le bon en-tête ethernet

Je n'ai pas de bonne réponse, mais sous Linux une fois que vous liez l'adresse que l'exposition vous pouvez utiliser de l'écriture.
alors, pourquoi voulez-vous utiliser sendto() ?

tout d'abord pour envoyer les paquets sous Linux (je ne sais pas votre système d'exploitation temps réel, mais vous devriez regarder pour le manque définit dans les fichiers fournis par l'OS)
vous aurez besoin d'être root sur votre système ou de l'utilisation de la setcap de commande pour ajouter des premières capacités
par exemple:

sudo setcap 'CAP_NET_RAW+eip CAP_NET_ADMIN+eip' /path/to/your/executable

dans vous programme:

#include <stdlib.h>
#include <ctype.h>
#include <unistd.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <linux/if.h>
#include <linux/if_packet.h>
#include <linux/if_ether.h>
int main()
{
char* ifname = "eth0";
unsigned char srcMac[6];
unsigned char dstMac[6] = {0, 0xDE, 0xAD, 0xBE, 0xEF, 0};
int fd = socket( PF_PACKET, SOCK_RAW, htons( ETH_P_ALL ) );
/* bind to interface */
struct ifreq req;
memset( &req, 0, sizeof( req ) );
strcpy( (char*)req.ifr_name, (char*)ifname );
if ( ioctl( fd, SIOCGIFINDEX, &req ) < 0 )
{
perror( "init: ioctl" );
close( fd );
return -1;
}
struct sockaddr_ll addr;
memset( &addr, 0, sizeof( addr ) );
addr.sll_family   = PF_PACKET;
addr.sll_protocol = 0;
addr.sll_ifindex  = req.ifr_ifindex;
if ( bind( fd, (const struct sockaddr*)&addr, sizeof( addr ) ) < 0 )
{
perror( "init: bind fails" );
close( fd );
return -1;
}
if ( ioctl( fd, SIOCGIFHWADDR, &req ) < 0 )
{
perror( "init: ioctl SIOCGIFHWADDR" );
close( fd );
return -1;
}
/* store your mac address somewhere you'll need it! in your packet */
memcpy( srcMac, (unsigned char*)req.ifr_hwaddr.sa_data, ETH_ALEN );
int length = 60;
unsigned char txPkt[ length ];
unsigned char* pkt = txPkt;
memset( txPkt, 0, sizeof( txPkt ) );
//destination mac address
memcpy( pkt, dstMac, 6 );
pkt += 6;
//source mac address
memcpy( pkt, srcMac, 6 );
pkt += 6;
//add more data, like a type field!  etc
int bytes = write( fd, txPkt, length );
}

Comme vous l'écrivez un raw paquet que vous aurez à mettre dans les adresses mac etc. vous-même.
Le FCS peuvent être laissés de côté(ce qui devrait être gérée par hw) de sorte que le minimum de la taille des paquets est de 60 octets, vous devez envoyer 60 octets je crois.
Si vous capturez sur les sortants de cartes vous ne verrez pas la FCS.

Je suppose que vous devez être en mesure d'utiliser la fonction sendto() au lieu de l'écrire, mais note que le struct sockaddr_ll ne contient pas toutes les informations sur la destination, alors pourquoi s'embêter?