使用 libnet 与 libpcap 构造 TCPIP 协议软件

char *pcap_lookupdev (char *errbuf)

int pcap_lookupnet (char *device, bpf_u_int32 *netp,bpf_u_int32 *maskp, char *errbuf)

pcap_t *pcap_open_live (char *device, int snaplen,int promisc, int to_ms,char *ebuf)

int pcap_compile (pcap_t *p, struct bpf_program *fp,char *str, int optimize, bpf_u_int32 netmask)

int pcap_setfilter (pcap_t *p, struct bpf_program *fp)

int pcap_dispatch (pcap_t *p, int cnt,pcap_handler callback, u_char *user)

int pcap_loop (pcap_t *p, int cnt, pcap_handler callback, u_char *user)

u_char *pcap_next (pcap_t *p, struct pcap_pkthdr *h)

void pcap_close (pcap_t *p)

FILE *pcap_file (pcap_t *p)

int pcap_fileno (pcap_t *p)

/* tell destination host with ip 'dstip' that the host with request ip'srcip' is with mac address srcmac
 * author: white cpf  2003.5.15.
 * compile: gcc arp.c -lnet -lpcap -o arp
 */
#include <libnet.h>
#include <pcap.h>

void usage(char *exename) {
    printf("tell dstip with dstmac that srcip is at srcmac. \n");
    printf("usage: % s -d dstip -s srcip -D dstmac -S srcmac \n", exename);
    return;
}

// 程序输入：来自命令行参数
u_char ip_src[4], ip_dst[4];
u_char enet_src[6], enet_dst[6];

extern int mac_strtochar6(u_char *enet, char *macstr);    // 将字符串格式的 MAC 地址转换为 6 字节类型 r
int        get_cmdline(int argc, char *argv[]);           // 命令行参数处理函数

int main(int argc, char *argv[]) {
    libnet_t          *l;
    libnet_ptag_t      t;
    u_char            *packet;
    u_long             packet_s;
    char               device[5] = "eth0";
    char               errbuf[LIBNET_ERRBUF_SIZE];
    char               filter_str[100] = "";
    struct bpf_program fp; /* hold compiled program     */
    char              *dev;
    pcap_t            *descr;
    struct pcap_pkthdr hdr; /* pcap.h    */
    u_char            *packet;
    bpf_u_int32        maskp;             /* subnet mask               */
    bpf_u_int32        netp;              /* ip                        */
    int                promisc       = 0; /* set to promisc mode?        */
    int                pcap_time_out = 5;
    int                c, ret;
    u_long             i;

    if(get_cmdline(argc, argv) <= 0) {
        usage(argv[0]);
        exit(0);
    }

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

    ret = pcap_lookupnet(dev, &netp, &maskp, errbuf);
    if(ret == -1) {
        fprintf(stderr, "% s\n", errbuf);
        return -1;
    }

    descr = pcap_open_live(dev, BUFSIZ, promisc, pcap_time_out, errbuf);
    if(descr == NULL) {
        printf("pcap_open_live (): % s\n", errbuf);
        return -1;
    }

    sprintf(filter_str, "arp and (src net % d.% d.% d.% d)", ip_dst[0], ip_dst[1], ip_dst[2], ip_dst[3]);
    if(pcap_compile(descr, &fp, filter_str, 0, netp) == -1) {
        printf("Error calling pcap_compile\n");
        return -1;
    }

    if(pcap_setfilter(descr, &fp) == -1) {
        printf("Error setting filter\n");
        return -1;
    }

    while(1) {
        printf("wait packet:filter:% s\n", filter_str);
        packet = pcap_next(descr, &hdr);
        if(packet == NULL) {
            continue;
        }

        l = libnet_init(LIBNET_LINK_ADV, device, errbuf);
        if(l == NULL) {
            fprintf(stderr, "libnet_init () failed: % s", errbuf);
            exit(EXIT_FAILURE);
        }

        t = libnet_build_arp(ARPHRD_ETHER, /* hardware addr */
                             ETHERTYPE_IP, /* protocol addr */
                             6,            /* hardware addr size */
                             4,            /* protocol addr size */
                             ARPOP_REPLY,  /* operation type */
                             enet_src,     /* sender hardware addr */
                             ip_src,       /* sender protocol addr */
                             enet_dst,     /* target hardware addr */
                             ip_dst,       /* target protocol addr */
                             NULL,         /* payload */
                             0,            /* payload size */
                             l,            /* libnet handle */
                             0);           /* libnet id */
        if(t == -1) {
            fprintf(stderr, "Can't build ARP header: % s\n", libnet_geterror(l));
            goto bad;
        }

        t = libnet_autobuild_ethernet(enet_dst,      /* ethernet destination */
                                      ETHERTYPE_ARP, /* protocol type */
                                      l);            /* libnet handle */
        if(t == -1) {
            fprintf(stderr, "Can't build ethernet header: % s\n", libnet_geterror(l));
            goto bad;
        }

        c = libnet_adv_cull_packet(l, &packet, &packet_s);
        if(c == -1) {
            fprintf(stderr, "libnet_adv_cull_packet: % s\n", libnet_geterror(l));
            goto bad;
        }

        c = libnet_write(l);
        if(c == -1) {
            fprintf(stderr, "Write error: % s\n", libnet_geterror(l));
            goto bad;
        }

        continue;
bad:
        libnet_destroy(l);
        return (EXIT_FAILURE);
    }
    libnet_destroy(l);

    return (EXIT_FAILURE);
}

int get_cmdline(int argc, char *argv[]) {
    char c;
    char string[] = "d:s:D:S:h";

    while((c = getopt(argc, argv, string)) != EOF) {
        if(c == 'd') *((unsigned int *)ip_dst) = (unsigned int)inet_addr(optarg);
        else if(c == 's')
            *((unsigned int *)ip_src) = (unsigned int)inet_addr(optarg);
        else if(c == 'D')
            mac_strtochar6(enet_dst, optarg);
        else if(c == 'S')
            mac_strtochar6(enet_dst, optarg);
        else if(c == 'h')
            return 0;
        else
            return -1;
    }
    return 1;
}

int main (){
   初始化 libnet、libpcap；分配接收、发送缓冲区；初始化定时器；等等
   while (1){
      if (发送缓冲区有数据){
         发送数据
      }
      调用 select () 函数等待 3 个文件描述符是否准备好，这三个文件描述符分别是：PCAP 文件描述符、周知口管道读文件描述符、标准输入文件描述符
      if (PCAP 文件描述符准备好){
         调用 pcap_next () 函数来获得下一个抓到的数据包
      }
      if (周知口读文件描述符准备好){
         读取数据
   根据进程内部的 TCB 中的信息，按照 TCP 协议规范进行分析处理
      }
      if (标准输入文件描述符准备好){
         读取数据
   分析处理，比如将内部信息回馈到标准输出文件描述符
      }
      if (超时){
            超时处理
      }
   }
}

struct mini_sock {
    u8  type;     //=TCP or UDP
    u32 dip;      // destination ip
    u32 dport;    // destination port
    u16 sip;      // source ip
    u16 sport;    // source port
    // ……
}

int mini_socket (struct mini_sock*)

/***************************************************
 * Simple tcp echo client using libnet and libpcap and mini_socket.c
 * file:      miniecho.c
 * Date:     2003.5.
 * Author:   white cpf
 * compile:  gcc -Wall -lpcap -lnet miniecho.c mini_socket.c -o miniecho
 * Run:     readhat 8.0 you must be root and run ifconfig to see eth0 OK
 *****************************************************/
#include <libnet.h>
#include <pcap.h>
#include "mini_socket.h"
#define uchar     unsigned char
#define MAXBUFLEN 2048
char buf[MAXBUFLEN];
int  buflen;
char recvbuf[MAXBUFLEN];
int  recvedlen;
int  main(int argc, char *argv[]) {
     int           ret;
     int           i;
     char          sip[40]   = "169.254.159.112";
     char          sport[10] = "7777";
     char          dip[40]   = "169.254.159.111";
     char          dport[10] = "5000";
     struct socket ti;
     int           s;
     ti.sip   = inet_addr(sip);
     ti.dip   = inet_addr(dip);
     ti.sport = (unsigned short)atoi(sport);
     ti.dport = (unsigned short)atoi(dport);
     s        = mini_socket(&ti);
     if(s < 0) {
         printf("mini_socket () error\n");
         return 0;
    }
     ret = mini_connect(s);    // connect to tcpip using TCP three time handshaking
     if(ret < 0) {
         printf("mini_connect () error\n");
         return 0;
    }
     while(1) {
         // get input from stdin,  quit when EOF or "myquit!" input
        if(fgets(buf, sizeof(buf), stdin) == 0) break;
        if(strcmp(buf, "myquit!") == 0) break;
        ret = mini_send(s, buf, strlen(buf));
        if(ret <= 0) {
             printf("mini_send () return % d\n", ret);
             break;
        }
        ret = mini_recv(s, recvbuf, &recvedlen);
        if(ret <= 0) {
             printf("mini_recv () return % d\n", ret);
             break;
        }
        recvbuf[recvedlen] = 0;
        printf("recved [% d bytes]:% s\n", recvedlen, recvbuf);
    }
     mini_close(s);    // close tcpip using TCP three time handshaking
}