Linux网络调试必备：抓网卡出口数据 (linux 抓网卡出口数据)

在网络调试过程中，有很多情况下需要抓取网络流量数据来分析网络问题。抓取网络数据包是一种非常有效的分析网络问题的方法，在Linux系统中，我们可以使用类似Tcpdump或Wireshark的工具来抓取网络数据包。但是仅仅使用这些工具仅仅能够抓取入口数据，对于调试网络问题来说，往往还需要抓取网卡出口的数据包。接下来，我们将介绍如何在Linux系统中抓取网卡出口数据。

抓取网卡出口数据

抓取网卡出口数据的常见场景是调试网络防火墙或者路由器等设备时。在这种情况下，我们需要抓取从网卡中发出的数据，可以使用libpcap库中的pcap_sendpacket函数发送一个数据包到网卡中，并通过数据包捕获工具抓取数据包。

我们需要打开一个网卡并捕获它的数据包，可以使用以下命令：

“`

sudo tcpdump -i eth0 -w /tmp/capture.pcap

“`

这样，我们就可以在/tmp目录下生成一个捕获网卡eth0数据的文件。接下来，我们就可以使用libpcap库中的pcap_sendpacket函数向网卡中发送数据包并捕获。下面是一个捕获出口数据包的示例：

“`C

#include

#define ETHER_ADDR_LEN 6

/* Ethernet header */

struct sniff_ethernet {

u_char ether_dhost[ETHER_ADDR_LEN]; /* destination host address */

u_char ether_shost[ETHER_ADDR_LEN]; /* source host address */

u_short ether_type; /* IP? ARP? RARP? etc */

};

/* IP header */

struct sniff_ip {

u_char ip_vhl; /* version > 2 */

u_char ip_tos; /* type of service */

u_short ip_len; /* total length */

u_short ip_id; /* identification */

u_short ip_off; /* fragment offset field */

#define IP_RF 0x8000 /* reserved fragment flag */

#define IP_DF 0x4000 /* don’t fragment flag */

#define IP_MF 0x2023 /* more fragments flag */

#define IP_OFFMASK 0x1fff /* mask for fragmenting bits */

u_char ip_ttl; /* time to live */

u_char ip_p; /* protocol */

u_short ip_sum; /* checksum */

struct in_addr ip_src,ip_dst; /* source and dest address */

};

void send_packet(char *iface, u_char *pkt, int pkt_len)

{

char errbuf[PCAP_ERRBUF_SIZE];

pcap_t *iface_handle;

u_char* pkt_ptr;

struct pcap_pkthdr *hdr;

struct sniff_ethernet *eth_hdr;

struct sniff_ip *ip_hdr;

iface_handle = pcap_open_live(iface, 65535 /* snaplen */, 0 /* non-promiscuous */, 1000 /* read timeout, ms */, errbuf);

if (iface_handle == NULL) {

printf(“Fled to open device %s: %s\n”, iface, errbuf);

exit(1);

}

pkt_ptr = pkt;

memset((void *)pkt_ptr, 0, pkt_len);

memcpy((void *)pkt_ptr, “\x00\x11\x22\x33\x44\x55”, ETHER_ADDR_LEN); // destination MAC

memcpy((void *)(pkt_ptr+ETHER_ADDR_LEN), “\x66\x55\x44\x33\x22\x11”, ETHER_ADDR_LEN); // source MAC

eth_hdr = (struct sniff_ethernet *)pkt_ptr;

eth_hdr->ether_type = htons(0x0800);

pkt_ptr += sizeof(struct sniff_ethernet);

ip_hdr = (struct sniff_ip *)pkt_ptr;

ip_hdr->ip_vhl = 0x45; // version 4 and header length 5

ip_hdr->ip_tos = 0x00; // type of service

ip_hdr->ip_len = htons(pkt_len – sizeof(struct sniff_ethernet)); // length of the packet without the Ethernet header

ip_hdr->ip_id = 0x0000; // identification

ip_hdr->ip_off = 0x0000; // no fragmentation

ip_hdr->ip_ttl = 0xff; // time to live

ip_hdr->ip_p = 0x11; // protocol: ICMP

ip_hdr->ip_src.s_addr = inet_addr(“192.168.1.1”); // source IP address

ip_hdr->ip_dst.s_addr = inet_addr(“192.168.1.2”); // destination IP address

pkt_ptr += sizeof(struct sniff_ip);

/* dummy payload, 48 bytes */

memset((void *)pkt_ptr, ‘A’, 48);

pcap_sendpacket(iface_handle, pkt, pkt_len);

printf(“Packet sent to %s\n”, iface);

hdr = NULL;

pkt_ptr = NULL;

pkt_ptr = pcap_next(iface_handle, hdr);

if (pkt_ptr != NULL) {

printf(“Packet captured from device %s, length %d\n”, iface, hdr->len);

/* print ethernet and IP headers */

eth_hdr = (struct sniff_ethernet *)pkt_ptr;

printf(“source MAC address: %.2x:%.2x:%.2x:%.2x:%.2x:%.2x\n”, eth_hdr->ether_shost[0], eth_hdr->ether_shost[1], eth_hdr->ether_shost[2], eth_hdr->ether_shost[3], eth_hdr->ether_shost[4], eth_hdr->ether_shost[5]);

printf(“destination MAC address: %.2x:%.2x:%.2x:%.2x:%.2x:%.2x\n”, eth_hdr->ether_dhost[0], eth_hdr->ether_dhost[1], eth_hdr->ether_dhost[2], eth_hdr->ether_dhost[3], eth_hdr->ether_dhost[4], eth_hdr->ether_dhost[5]);

ip_hdr = (struct sniff_ip *)(pkt_ptr + sizeof(struct sniff_ethernet));

printf(“source IP address: %s\n”, inet_ntoa(ip_hdr->ip_src));

printf(“destination IP address: %s\n”, inet_ntoa(ip_hdr->ip_dst));

}

return;

}

int mn() {

char iface[] = “eth0”;

u_char pkt[1024];

memset((void *)pkt, 0, sizeof(pkt));

send_packet(iface, pkt, 1024);

return 0;

}

“`

在这个例子中，我们使用的是pcap_sendpacket函数发送一个数据包到网卡中。可以看到我们先使用pcap_open_live打开了一个网卡句柄iface_handle，然后我们构造了一个Ethernet和IP数据包并使用pcap_sendpacket函数将该数据包发送到网卡中。最后使用pcap_next函数捕获从该网卡中发出的数据包。

相关问题拓展阅读：