如何在Mac OS X上读取和发送UDP数据包？

Question

如何在Mac OS X上读取和发送UDP数据包？

macosudplibpcaptcpdumpnetcat

5

我正在尝试创建一个程序，用于读取UDP数据包的IP地址和端口（在本地主机上），并针对Mac OS X（当前版本10.9.5）进行操作。

目前唯一给我提供了一些有用数据的方法是使用tcpdump和nc（netcat），但只工作了1次。

以下是我所做的：

1° 终端窗口

$ sudo tcpdump -i en0 -X -v 'udp port 60000'
tcpdump: listening on en0, link-type EN10MB (Ethernet), capture size 65535 bytes
* new packet with the string 'Hello' at the end *

2° 终端窗口

$ nc -u 192.168.1.67 60000
Hello
$

我对这个问题没有很多知识，所以最终的问题是：

如果我需要创建一个程序，需要读取任何UDP数据包，给定一个端口号并通过相同的端口向任何IP地址发送UDP数据包，最简单的方法是什么？我已经尝试使用C语言中的libpcap，但没有成功。

- genesisxyz

你想接收发送到你机器上某个特定端口的所有UDP数据包，并回复这些UDP数据包吗？而且没有必要能够看到除了这些数据包之外的任何数据包 - 也就是说，如果它被发送到其他机器，或者被发送到你的机器但不是UDP数据包，或者如果它是发送到你的机器但不是该端口的UDP数据包，那么你不需要看到它。如果是这样，你不需要使用libpcap，只需使用常规的UDP套接字即可。 - user862787

2个回答

3

您可以使用 "Packet Sender" 应用程序。它遵循 "GPL v2 或更高版本" 许可证。

它不仅支持 "Mac OS X"，还支持 "Windows XP ~ 10"，"Linux Desktop"。

- Namo

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- genesisxyz · Accepted Answer

我用C语言库解决了libpcap的问题：

#include <pcap.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netinet/if_ether.h>
#include <netinet/ip.h>
#include <string.h>

void my_callback(u_char *user, const struct pcap_pkthdr *pkthdr, const u_char *packet) {

    int i = 0;
    int k = 0;

    for (i = 0; i < pkthdr->len; i++) {
        if ((i % 16) == 0) {
            fprintf(stdout, "\n%03x0\t", k);
            k++;
        }
        fprintf(stdout, "%02x ", packet[i]);
    }

    fprintf(stdout, "\n*******************************************************\n");

    u_char ethernet_packet[14];
    u_char ip_header[24];
    u_char udp_header[8];
    int udp_header_start = 34;
    int data_length;

    for (i = 0; i < 14; i++) {
        ethernet_packet[i] = packet[0 + i];
    }

    fprintf(stdout, "Destination Address\t\t%02X:%02X:%02X:%02X:%02X:%02X\n", ethernet_packet[0], ethernet_packet[1], ethernet_packet[2], ethernet_packet[3], ethernet_packet[4], ethernet_packet[5]);
    fprintf(stdout, "Source Address\t\t\t%02X:%02X:%02X:%02X:%02X:%02X\n", ethernet_packet[6], ethernet_packet[7], ethernet_packet[8], ethernet_packet[9], ethernet_packet[10], ethernet_packet[11]);

    if (ethernet_packet[12] == 0x08 &&
        ethernet_packet[13] == 0x00) {

        fprintf(stdout, "Ethertype\t\t\t\tIP Packet\n");

        for (i = 0; i < 20; i++) {
            ip_header[i] = packet[14 + i];
        }

        fprintf(stdout, "Version\t\t\t\t\t%d\n", (ip_header[0] >> 4));
        fprintf(stdout, "IHL\t\t\t\t\t\t%d\n", (ip_header[0] & 0x0F));
        fprintf(stdout, "Type of Service\t\t\t%d\n", ip_header[1]);
        fprintf(stdout, "Total Length\t\t\t%d\n", ip_header[2]);
        fprintf(stdout, "Identification\t\t\t0x%02x 0x%02x\n", ip_header[3], ip_header[4]);
        fprintf(stdout, "Flags\t\t\t\t\t%d\n", ip_header[5] >> 5);
        fprintf(stdout, "Fragment Offset\t\t\t%d\n", (((ip_header[5] & 0x1F) << 8) + ip_header[6]));
        fprintf(stdout, "Time To Live\t\t\t%d\n", ip_header[7]);
        if (ip_header[9] == 0x11) {

            fprintf(stdout, "Protocol\t\t\t\tUDP\n");
        }
        else {
            fprintf(stdout, "Protocol\t\t\t\t%d\n", ip_header[9]);
        }
        fprintf(stdout, "Header Checksum\t\t\t0x%02x 0x%02x\n", ip_header[10], ip_header[11]);
        fprintf(stdout, "Source Address\t\t\t%d.%d.%d.%d\n", ip_header[12], ip_header[13], ip_header[14], ip_header[15]);
        fprintf(stdout, "Destination Address\t\t%d.%d.%d.%d\n", ip_header[16], ip_header[17], ip_header[18], ip_header[19]);
        if ((ip_header[0] & 0x0F) > 5) {
            udp_header_start = 48;
            fprintf(stdout, "Options\t\t\t\t\t0x%02x 0x%02x 0x%02x 0x%02x\n", ip_header[20], ip_header[21], ip_header[22], ip_header[23]);
        }

        if (ip_header[9] == 0x11) {

            fprintf(stdout, "\t\t\t\tUDP HEADER\n");

            for (i = 0; i < 8; i++) {
                udp_header[i] = packet[udp_header_start + i];
            }

            fprintf(stdout, "Source Port\t\t\t\t%d\n", (udp_header[0] << 8) + udp_header[1]);
            fprintf(stdout, "Destination Port\t\t%d\n", (udp_header[2] << 8) + udp_header[3]);
            fprintf(stdout, "Length\t\t\t\t\t%d\n", (udp_header[4] << 8) + udp_header[5]);
            fprintf(stdout, "Checksum\t\t\t\t0x%02x 0x%02x\n", udp_header[6], udp_header[7]);

            data_length = pkthdr->len - (udp_header_start + 8);

            fprintf(stdout, "Data\n");
            for (i = 0; i < data_length; i++) {

                fprintf(stdout, "%02x ", packet[udp_header_start + 8 + i]);
            }
            fprintf(stdout, "\n");
        }
    }
    else {
        fprintf(stdout, "Ethertype\t\t\t\tUnknow\n");
    }
}

int main(int argc,char **argv) {

    char *dev;
    char errbuf[PCAP_ERRBUF_SIZE];
    pcap_t* descr;
    struct bpf_program fp;
    bpf_u_int32 maskp;
    bpf_u_int32 netp;

    dev = pcap_lookupdev(errbuf);
    if(dev == NULL) {
        fprintf(stderr,"%s\n",errbuf); exit(1);
    }

    pcap_lookupnet(dev, &netp, &maskp, errbuf);
    descr = pcap_open_live(dev, BUFSIZ, 1, 1000, errbuf);

    if(descr == NULL) {
        printf("pcap_open_live(): %s\n",errbuf);
        exit(1);
    }

    char filter[] = "udp";
    if(pcap_compile(descr,&fp, filter,0,netp) == -1) {
        fprintf(stderr,"Error calling pcap_compile\n");
        exit(1);
    }

    if(pcap_setfilter(descr,&fp) == -1) {
        fprintf(stderr,"Error setting filter\n");
        exit(1);

    }

    pcap_loop(descr,-1,my_callback,NULL);    

    /* write a packet
    //define a new packet and for each position set its values
    u_char packet[86];


    // Send down the packet
    if (pcap_sendpacket(descr, packet, 86) != 0) {

        fprintf(stderr,"\nError sending the packet: %s\n", pcap_geterr(descr));
        return 2;
    }
    */
    return 0;
}

我们的想法是通过pcap_loop选取数据包并分析我们获得的数据：

在我的例子中，我有一个以太网头部，我使用维基百科来了解它是如何完成的以太网帧。 EtherType设置为0x0800，这表明下一个字节是IP头部IPv4头部。这里的协议显示为UDP数据包 UDP数据包结构。

我已经在OS X 10.9上通过Xcode和pcap库进行了编译，它运行得很好。唯一的问题是这非常静态，需要以太网并且仅适用于IPv4。