https://opensourceforu.com/2015/03/a-guide-to-using-raw-sockets/
In this tutorial, lets take a look at how raw sockets can be used to receive data packets and send those packets to specific user applications, bypassing the normal TCP/IP protocols.
If you have no knowledge of the Linux kernel, yet are interested in the contents of network packets, raw sockets are the answer. A raw socket is used to receive raw packets. This means packets received at the Ethernet layer will directly pass to the raw socket. Stating it precisely, a raw socket bypasses the normal TCP/IP processing and sends the packets to the specific user application (see Figure 1).
Figure 1: Graphical demonstration of a raw socket
A raw socket vs other sockets
Other sockets like stream sockets and data gram sockets receive data
from the transport layer that contains no headers but only the payload.
This means that there is no information about the source IP address and
MAC address. If applications running on the same machine or on different
machines are communicating, then they are only exchanging data.
The purpose of a raw socket is absolutely different. A raw socket allows
an application to directly access lower level protocols, which means a
raw socket receives un-extracted packets (see Figure 2). There is no
need to provide the port and IP address to a raw socket, unlike in the
case of stream and datagram sockets.
Figure 2: Graphical demonstration of how a raw socket works compared to other sockets
Network packets and packet sniffers
When an application sends data into the network, it is processed by
various network layers. Before sending data, it is wrapped in various
headers of the network layer. The wrapped form of data, which contains
all the information like the source and destination address, is called a
network packet (see Figure 3). According to Ethernet protocols, there
are various types of network packets like Internet Protocol packets,
Xerox PUP packets, Ethernet Loopback packets, etc. In Linux, we can see
all protocols in the if_ether.h header file (see Figure 4).
When we connect to the Internet, we receive network packets, and our
machine extracts all network layer headers and sends data to a
particular application. For example, when we type www.google.com
in our browser, we receive packets sent from Google, and our machine
extracts all the headers of the network layer and gives the data to our
browser.
By default, a machine receives those packets that have the same
destination address as that of the machine, and this mode is called the
non-promiscuous mode. But if we want to receive all the packets, we have
to switch into the promiscuous mode. We can go into the promiscuous
mode with the help of ioctls.
If we are interested in the contents or the structure of the headers of
different network layers, we can access these with the help of a packet
sniffer. There are various packet sniffers available for Linux, like
Wireshark. There is a command line sniffer called tcpdump,
which is also a very good packet sniffer. And if we want to make our own
packet sniffer, it can easily be done if we know the basics of C and
networking.
Figure 3: A generic representation of a network packet
Figure 4: Network Packet for internet Protocol
A packet sniffer with a raw socket
To develop a packet sniffer, you first have to open a raw socket. Only processes with an effective user ID of 0 or the CAP_NET_RAW capability are allowed to open raw sockets. So, during the execution of the program, you have to be the root user.
Opening a raw socket
To open a socket, you have to know three things the socket family,
socket type and protocol. For a raw socket, the socket family is AF_PACKET, the socket type is SOCK_RAW and for the protocol, see the if_ether.h header file. To receive all packets, the macro is ETH_P_ALL and to receive IP packets, the macro is ETH_P_IP for the protocol field.
int sock_r;
sock_r=socket(AF_PACKET,SOCK_RAW,htons(ETH_P_ALL));
if(sock_r<)
{
printf(error in socket\n);
return -;
}
Reception of the network packet
After successfully opening a raw socket, its time to receive network packets, for which you need to use the recvfrom api. We can also use the recv api. But recvfrom provides additional information.
unsigned char *buffer = (unsigned char *) malloc(); //to receive data
memset(buffer,,);
struct sockaddr saddr;
int saddr_len = sizeof (saddr); //Receive a network packet and copy in to buffer
buflen=recvfrom(sock_r,buffer,,,&saddr,(socklen_t *)&saddr_len);
if(buflen<)
{
printf(error in reading recvfrom function\n);
return -;
}
In saddr, the underlying protocol provides the source address of the packet.
Figure 5: Structure of Ethernet header
Extracting the Ethernet header
Now that we have the network packets in our buffer, we will get
information about the Ethernet header. The Ethernet header contains the
physical address of the source and destination, or the MAC address and
protocol of the receiving packet. The if_ether.h header contains the structure of the Ethernet header (see Figure 5).
Now, we can easily access these fields:
struct ethhdr *eth = (struct ethhdr *)(buffer);
printf(\nEthernet Header\n);
printf(\t|-Source Address : %.2X-%.2X-%.2X-%.2X-%.2X-%.2X\n,eth->h_source[],eth->h_source[],eth->h_source[],eth->h_source[],eth->h_source[],eth->h_source[]);
printf(\t|-Destination Address : %.2X-%.2X-%.2X-%.2X-%.2X-%.2X\n,eth->h_dest[],eth->h_dest[],eth->h_dest[],eth->h_dest[],eth->h_dest[],eth->h_dest[]);
printf(\t|-Protocol : %d\n,eth->h_proto);
h_proto gives information about the next layer. If you get 0x800 (ETH_P_IP), it means that the next header is the IP header. Later, we will consider the next header as the IP header.
Note 1: The physical address is 6 bytes.
Note 2: We can also direct the output to a file for better understanding.
fprintf(log_txt,\t|-Source Address : %.2X-%.2X-%.2X-%.2X-%.2X-%.2X\n,eth->h_source[],eth->h_source[],eth->h_source[],eth->h_source[],eth->h_source[],eth->h_source[]);
Use fflush to avoid the input-output buffer problem when writing into a file.
Figure 6: Structure of IP Header
Extracting the IP header
The IP layer gives various pieces of information like the source and
destination IP address, the transport layer protocol, etc. The structure
of the IP header is defined in the ip.h header file (see Figure 6).
Now, to get this information, you need to increment your buffer pointer
by the size of the Ethernet header because the IP header comes after the
Ethernet header:
unsigned short iphdrlen;
struct iphdr *ip = (struct iphdr*)(buffer + sizeof(struct ethhdr));
memset(&source, , sizeof(source));
source.sin_addr.s_addr = ip->saddr;
memset(&dest, , sizeof(dest));
dest.sin_addr.s_addr = ip->daddr; fprintf(log_txt, \t|-Version : %d\n,(unsigned int)ip->version);
fprintf(log_txt , \t|-Internet Header Length : %d DWORDS or %d Bytes\n,(unsigned int)ip->ihl,((unsigned int)(ip->ihl))*);
fprintf(log_txt , \t|-Type Of Service : %d\n,(unsigned int)ip->tos);
fprintf(log_txt , \t|-Total Length : %d Bytes\n,ntohs(ip->tot_len));
fprintf(log_txt , \t|-Identification : %d\n,ntohs(ip->id));
fprintf(log_txt , \t|-Time To Live : %d\n,(unsigned int)ip->ttl);
fprintf(log_txt , \t|-Protocol : %d\n,(unsigned int)ip->protocol);
fprintf(log_txt , \t|-Header Checksum : %d\n,ntohs(ip->check));
fprintf(log_txt , \t|-Source IP : %s\n, inet_ntoa(source.sin_addr));
fprintf(log_txt , \t|-Destination IP : %s\n,inet_ntoa(dest.sin_addr));
The transport layer header
There are various transport layer protocols. Since the underlying header
was the IP header, we have various IP or Internet protocols. You can
see these protocols in the /etc/protocls file. The TCP and UDP
protocol structures are defined in tcp.h and udp.h respectively. These
structures provide the port number of the source and destination. With
the help of the port number, the system gives data to a particular
application (see Figures 7 and 8).
The size of the IP header varies from 20 bytes to 60 bytes. We can
calculate this from the IP header field or IHL. IHL means Internet
Header Length (IHL), which is the number of 32-bit words in the header.
So we have to multiply the IHL by 4 to get the size of the header in
bytes:
struct iphdr *ip = (struct iphdr *)( buffer + sizeof(struct ethhdr) );
/* getting actual size of IP header*/
iphdrlen = ip->ihl*;
/* getting pointer to udp header*/
struct tcphdr *udp=(struct udphdr*)(buffer + iphdrlen + sizeof(struct ethhdr)); We now have the pointer to the UDP header. So lets check some of its fields.
Note: If your machine is little endian, you have to use ntohs because the network uses the big endian scheme.
fprintf(log_txt , \t|-Source Port : %d\n , ntohs(udp->source));
fprintf(log_txt , \t|-Destination Port : %d\n , ntohs(udp->dest));
fprintf(log_txt , \t|-UDP Length : %d\n , ntohs(udp->len));
fprintf(log_txt , \t|-UDP Checksum : %d\n , ntohs(udp->check));
Similarly, we can access the TCP header field.
Extracting data
After the transport layer header, there is data payload remaining. For
this, we will move the pointer to the data, and then print.
unsigned char * data = (buffer + iphdrlen + sizeof(struct ethhdr) + sizeof(struct udphdr));
Now, lets print data, and for better representation, let us print 16 bytes in a line.
int remaining_data = buflen - (iphdrlen + sizeof(struct ethhdr) + sizeof(struct udphdr)); for(i=;i<remaining_data;i++)
{
if(i!= && i%==)
fprintf(log_txt,\n);
fprintf(log_txt, %.2X ,data[i]);
}
When you receive a packet, it will look like whats shown is Figures 9 and 10.
Figure 9: UDP Packet 
Figure 10: TCP Packet
Sending packets with a raw socket
To send a packet, we first have to know the source and destination IP addresses as well as the MAC address. Use your friends MAC & IP address as the destination IP and MAC address. There are two ways to find out your IP address and MAC address:
1. Enter ifconfig and get the IP and MAC for a particular interface.
2. Enter ioctl and get the IP and MAC.
The second way is more efficient and will make your program machine-independent, which means you should not enter ifconfig in each machine.
Opening a raw socket
To open a raw socket, you have to know three fields of socket API — Family- AF_PACKET, Type- SOCK_RAW and for the protocol, lets use IPPROTO_RAW because we are trying to send an IP packet. IPPROTO_RAW macro is defined in the in.h header file:
sock_raw=socket(AF_PACKET,SOCK_RAW,IPPROTO_RAW);
if(sock_raw == -)
printf(error in socket);
What is struct ifreq?
Linux supports some standard ioctls to configure network devices. They
can be used on any sockets file descriptor, regardless of the family or
type. They pass an ifreq structure, which means that if you want to
know some information about the network, like the interface index or
interface name, you can use ioctl and it will fill the value of the ifreq structure passed as a third argument. In short, the ifreq
structure is a way to get and set the network configuration. It is
defined in the if.h header file or you can check the man page of netdevice (see Figure 11).
Figure 12: Graphical representation of packets with their structure and payload
Getting the index of the interface to send a packet
There may be various interfaces in your machine like loopback, wired interface and wireless interface.
So you have to decide the interface through which we can send our
packet. After deciding on the interface, you have to get the index of
that interface. For this, first give the name of the interface by
setting the field ifr_name of ifreq structure, and then use ioctl. Then use the SIOCGIFINDEX macro defined in sockios.h and you will receive the index number in the ifreq structure:
struct ifreq ifreq_i;
memset(&ifreq_i,,sizeof(ifreq_i));
strncpy(ifreq_i.ifr_name,wlan0,IFNAMSIZ-); //giving name of Interface if((ioctl(sock_raw,SIOCGIFINDEX,&ifreq_i))<)
printf(error in index ioctl reading);//getting Index Name printf(index=%d\n,ifreq_i.ifr_ifindex);
Getting the MAC address of the interface
Similarly, you can get the MAC address of the interface, for which you need to use the SIOCGIFHWADDR macro to ioctl:
struct ifreq ifreq_c;
memset(&ifreq_c,,sizeof(ifreq_c));
strncpy(ifreq_c.ifr_name,wlan0,IFNAMSIZ-);//giving name of Interface if((ioctl(sock_raw,SIOCGIFHWADDR,&ifreq_c))<) //getting MAC Address
printf(error in SIOCGIFHWADDR ioctl reading);
Getting the IP address of the interface
For this, use the SIOCGIFADDR macro:
struct ifreq ifreq_ip;
memset(&ifreq_ip,,sizeof(ifreq_ip));
strncpy(ifreq_ip.ifr_name,wlan0,IFNAMSIZ-);//giving name of Interface
if(ioctl(sock_raw,SIOCGIFADDR,&ifreq_ip)<) //getting IP Address
{
printf(error in SIOCGIFADDR \n);
}
Constructing the Ethernet header
After getting the index, as well as the MAC and IP addresses of an
interface, its time to construct the Ethernet header. First, take a
buffer in which you will place all information like the Ethernet header,
IP header, UDP header and data. That buffer will be your packet.
sendbuff=(unsigned char*)malloc(); // increase in case of more data
memset(sendbuff,,);
To construct the Ethernet header, fill all the fields of the ethhdr structure:
struct ethhdr *eth = (struct ethhdr *)(sendbuff); eth->h_source[] = (unsigned char)(ifreq_c.ifr_hwaddr.sa_data[]);
eth->h_source[] = (unsigned char)(ifreq_c.ifr_hwaddr.sa_data[]);
eth->h_source[] = (unsigned char)(ifreq_c.ifr_hwaddr.sa_data[]);
eth->h_source[] = (unsigned char)(ifreq_c.ifr_hwaddr.sa_data[]);
eth->h_source[] = (unsigned char)(ifreq_c.ifr_hwaddr.sa_data[]);
eth->h_source[] = (unsigned char)(ifreq_c.ifr_hwaddr.sa_data[]); /* filling destination mac. DESTMAC0 to DESTMAC5 are macro having octets of mac address. */
eth->h_dest[] = DESTMAC0;
eth->h_dest[] = DESTMAC1;
eth->h_dest[] = DESTMAC2;
eth->h_dest[] = DESTMAC3;
eth->h_dest[] = DESTMAC4;
eth->h_dest[] = DESTMAC5; eth->h_proto = htons(ETH_P_IP); //means next header will be IP header /* end of ethernet header */
total_len+=sizeof(struct ethhdr);
Constructing the IP header
To construct the IP header, increment sendbuff by the size of the Ethernet header and fill each field of the iphdr
structure. Data after the IP header is called the payload for the IP
header and, in the same way, data after the Ethernet header is called
the payload for the Ethernet header. In the IP header, there is a field
called Total Length, which contains the size of the IP header plus the
payload. To know the size of the payload of the IP header, you must know
the size of the UDP header and the UDP payload. So, some field of the iphdr structure will get the value after filling the UDP header field.
struct iphdr *iph = (struct iphdr*)(sendbuff + sizeof(struct ethhdr));
iph->ihl = ;
iph->version = ;
iph->tos = ;
iph->id = htons();
iph->ttl = ;
iph->protocol = ;
iph->saddr = inet_addr(inet_ntoa((((struct sockaddr_in *)&(ifreq_ip.ifr_addr))->sin_addr)));
iph->daddr = inet_addr(destination_ip); // put destination IP address total_len += sizeof(struct iphdr);
Construct the UDP header
Constructing the UDP header is very similar to constructing the IP header. Assign values to the fields of the udphdr structure. For this, increment the sendbuff pointer by the size of the Ethernet and the IP headers.
struct udphdr *uh = (struct udphdr *)(sendbuff + sizeof(struct iphdr) + sizeof(struct ethhdr)); uh->source = htons();
uh->dest = htons();
uh->check = ; total_len+= sizeof(struct udphdr);
Like the IP header, the UDP also has the field len, which contains the size of the UDP header and its payload. So, first, you have to know the UDP payload, which is the actual data that will be sent.
Adding data or the UDP payload
We can send any data:
sendbuff[total_len++] = 0xAA;
sendbuff[total_len++] = 0xBB;
sendbuff[total_len++] = 0xCC;
sendbuff[total_len++] = 0xDD;
sendbuff[total_len++] = 0xEE;
Filling the remaining fields of the IP and UDP headers
We now have the total_len pointer and with the help of this, we can fill the remaining fields of the IP and UDP headers:
uh->len = htons((total_len - sizeof(struct iphdr) - sizeof(struct ethhdr)));
//UDP length field
iph->tot_len = htons(total_len - sizeof(struct ethhdr));
//IP length field
The IP header checksum
There is one more field remaining in the IP header check, which is used
to have a checksum. A checksum is used for error checking of the header.
When the packet arrives at the router, it calculates the checksum, and
if the calculated checksum does not match with the checksum field of the
header, the router will drop the packet; and if it matches, the router
will decrement the time to the live field by one, and forward it.
To calculate the checksum, sum up all the 16-bit words of the IP
header and if there is any carry, add it again to get a 16-bit word.
After this, find the complement of 1s and that is our checksum. To
check whether our checksum is correct, use the above algorithm.
unsigned short checksum(unsigned short* buff, int _16bitword)
{
unsigned long sum;
for(sum=;_16bitword>;_16bitword--)
sum+=htons(*(buff)++);
sum = ((sum >> ) + (sum & 0xFFFF));
sum += (sum>>);
return (unsigned short)(~sum);
} iph->check = checksum((unsigned short*)(sendbuff + sizeof(struct ethhdr)), (sizeof(struct iphdr)/));
Sending the packet
Now we have our packet but before sending it, lets fill the sockaddr_ll structure with the destination MAC address:
struct sockaddr_ll sadr_ll;
sadr_ll.sll_ifindex = ifreq_i.ifr_ifindex; // index of interface
sadr_ll.sll_halen = ETH_ALEN; // length of destination mac address
sadr_ll.sll_addr[] = DESTMAC0;
sadr_ll.sll_addr[] = DESTMAC1;
sadr_ll.sll_addr[] = DESTMAC2;
sadr_ll.sll_addr[] = DESTMAC3;
sadr_ll.sll_addr[] = DESTMAC4;
sadr_ll.sll_addr[] = DESTMAC5;
And now its time to send it, for which lets use the sendto api:
send_len = sendto(sock_raw,sendbuff,,,(const struct sockaddr*)&sadr_ll,sizeof(struct sockaddr_ll));
if(send_len<)
{
printf(error in sending....sendlen=%d....errno=%d\n,send_len,errno);
return -; }
How to run the program
Go to root user, then compile and run your program in a
machine. And in another machine, or in your destination machine, run the
packet sniffer program as the root user and analyse the data that you
are sending.
What to do next
We made a packet sniffer as well as a packet sender, but this is a user
space task. Now lets try the same things in kernel space. For this, try
to understand struct sk_buff and make a module that can perform the same things in kernel space.
You can get the complete code used in this article from http://1drv.ms/14yN6jr
附录：
include/linux/if_ether.h：
/*
* INET An implementation of the TCP/IP protocol suite for the LINUX
* operating system. INET is implemented using the BSD Socket
* interface as the means of communication with the user level.
*
* Global definitions for the Ethernet IEEE 802.3 interface.
*
* Version: @(#)if_ether.h 1.0.1a 02/08/94
*
* Author: Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
* Donald Becker, <becker@super.org>
* Alan Cox, <alan@lxorguk.ukuu.org.uk>
* Steve Whitehouse, <gw7rrm@eeshack3.swan.ac.uk>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version
* 2 of the License, or (at your option) any later version.
*/ #ifndef _LINUX_IF_ETHER_H
#define _LINUX_IF_ETHER_H #include <linux/types.h> /*
* IEEE 802.3 Ethernet magic constants. The frame sizes omit the preamble
* and FCS/CRC (frame check sequence).
*/ #define ETH_ALEN 6 /* Octets in one ethernet addr */
#define ETH_HLEN 14 /* Total octets in header. */
#define ETH_ZLEN 60 /* Min. octets in frame sans FCS */
#define ETH_DATA_LEN 1500 /* Max. octets in payload */
#define ETH_FRAME_LEN 1514 /* Max. octets in frame sans FCS */
#define ETH_FCS_LEN 4 /* Octets in the FCS */ /*
* These are the defined Ethernet Protocol ID's.
*/ #define ETH_P_LOOP 0x0060 /* Ethernet Loopback packet */
#define ETH_P_PUP 0x0200 /* Xerox PUP packet */
#define ETH_P_PUPAT 0x0201 /* Xerox PUP Addr Trans packet */
#define ETH_P_IP 0x0800 /* Internet Protocol packet */
#define ETH_P_X25 0x0805 /* CCITT X.25 */
#define ETH_P_ARP 0x0806 /* Address Resolution packet */
#define ETH_P_BPQ 0x08FF /* G8BPQ AX.25 Ethernet Packet [ NOT AN OFFICIALLY REGISTERED ID ] */
#define ETH_P_IEEEPUP 0x0a00 /* Xerox IEEE802.3 PUP packet */
#define ETH_P_IEEEPUPAT 0x0a01 /* Xerox IEEE802.3 PUP Addr Trans packet */
#define ETH_P_DEC 0x6000 /* DEC Assigned proto */
#define ETH_P_DNA_DL 0x6001 /* DEC DNA Dump/Load */
#define ETH_P_DNA_RC 0x6002 /* DEC DNA Remote Console */
#define ETH_P_DNA_RT 0x6003 /* DEC DNA Routing */
#define ETH_P_LAT 0x6004 /* DEC LAT */
#define ETH_P_DIAG 0x6005 /* DEC Diagnostics */
#define ETH_P_CUST 0x6006 /* DEC Customer use */
#define ETH_P_SCA 0x6007 /* DEC Systems Comms Arch */
#define ETH_P_TEB 0x6558 /* Trans Ether Bridging */
#define ETH_P_RARP 0x8035 /* Reverse Addr Res packet */
#define ETH_P_ATALK 0x809B /* Appletalk DDP */
#define ETH_P_AARP 0x80F3 /* Appletalk AARP */
#define ETH_P_8021Q 0x8100 /* 802.1Q VLAN Extended Header */
#define ETH_P_IPX 0x8137 /* IPX over DIX */
#define ETH_P_IPV6 0x86DD /* IPv6 over bluebook */
#define ETH_P_PAUSE 0x8808 /* IEEE Pause frames. See 802.3 31B */
#define ETH_P_SLOW 0x8809 /* Slow Protocol. See 802.3ad 43B */
#define ETH_P_WCCP 0x883E /* Web-cache coordination protocol
* defined in draft-wilson-wrec-wccp-v2-.txt */
#define ETH_P_PPP_DISC 0x8863 /* PPPoE discovery messages */
#define ETH_P_PPP_SES 0x8864 /* PPPoE session messages */
#define ETH_P_MPLS_UC 0x8847 /* MPLS Unicast traffic */
#define ETH_P_MPLS_MC 0x8848 /* MPLS Multicast traffic */
#define ETH_P_ATMMPOA 0x884c /* MultiProtocol Over ATM */
#define ETH_P_ATMFATE 0x8884 /* Frame-based ATM Transport
* over Ethernet
*/
#define ETH_P_PAE 0x888E /* Port Access Entity (IEEE 802.1X) */
#define ETH_P_AOE 0x88A2 /* ATA over Ethernet */
#define ETH_P_TIPC 0x88CA /* TIPC */
#define ETH_P_1588 0x88F7 /* IEEE 1588 Timesync */
#define ETH_P_FCOE 0x8906 /* Fibre Channel over Ethernet */
#define ETH_P_FIP 0x8914 /* FCoE Initialization Protocol */
#define ETH_P_EDSA 0xDADA /* Ethertype DSA [ NOT AN OFFICIALLY REGISTERED ID ] */ /*
* Non DIX types. Won't * for 1500 types.
*/ #define ETH_P_802_3 0x0001 /* Dummy type for 802.3 frames */
#define ETH_P_AX25 0x0002 /* Dummy protocol id for AX.25 */
#define ETH_P_ALL 0x0003 /* Every packet (be careful!!!) */
#define ETH_P_802_2 0x0004 /* 802.2 frames */
#define ETH_P_SNAP 0x0005 /* Internal only */
#define ETH_P_DDCMP 0x0006 /* DEC DDCMP: Internal only */
#define ETH_P_WAN_PPP 0x0007 /* Dummy type for WAN PPP frames*/
#define ETH_P_PPP_MP 0x0008 /* Dummy type for PPP MP frames */
#define ETH_P_LOCALTALK 0x0009 /* Localtalk pseudo type */
#define ETH_P_CAN 0x000C /* Controller Area Network */
#define ETH_P_PPPTALK 0x0010 /* Dummy type for Atalk over PPP*/
#define ETH_P_TR_802_2 0x0011 /* 802.2 frames */
#define ETH_P_MOBITEX 0x0015 /* Mobitex (kaz@cafe.net) */
#define ETH_P_CONTROL 0x0016 /* Card specific control frames */
#define ETH_P_IRDA 0x0017 /* Linux-IrDA */
#define ETH_P_ECONET 0x0018 /* Acorn Econet */
#define ETH_P_HDLC 0x0019 /* HDLC frames */
#define ETH_P_ARCNET 0x001A /* 1A for ArcNet :-) */
#define ETH_P_DSA 0x001B /* Distributed Switch Arch. */
#define ETH_P_TRAILER 0x001C /* Trailer switch tagging */
#define ETH_P_PHONET 0x00F5 /* Nokia Phonet frames */
#define ETH_P_IEEE802154 0x00F6 /* IEEE802.15.4 frame */ /*
* This is an Ethernet frame header.
*/ struct ethhdr {
unsigned char h_dest[ETH_ALEN]; /* destination eth addr */
unsigned char h_source[ETH_ALEN]; /* source ether addr */
__be16 h_proto; /* packet type ID field */
} __attribute__((packed)); #ifdef __KERNEL__
#include <linux/skbuff.h> static inline struct ethhdr *eth_hdr(const struct sk_buff *skb)
{
return (struct ethhdr *)skb_mac_header(skb);
} int eth_header_parse(const struct sk_buff *skb, unsigned char *haddr); #ifdef CONFIG_SYSCTL
extern struct ctl_table ether_table[];
#endif extern ssize_t sysfs_format_mac(char *buf, const unsigned char *addr, int len); /*
* Display a 6 byte device address (MAC) in a readable format.
*/
extern char *print_mac(char *buf, const unsigned char *addr) __deprecated;
#define MAC_FMT "%02x:%02x:%02x:%02x:%02x:%02x"
#define MAC_BUF_SIZE 18
#define DECLARE_MAC_BUF(var) char var[MAC_BUF_SIZE] #endif #endif /* _LINUX_IF_ETHER_H */