Chinaunix首页 | 论坛 | 博客
  • 博客访问: 2381495
  • 博文数量: 298
  • 博客积分: 7876
  • 博客等级: 准将
  • 技术积分: 5500
  • 用 户 组: 普通用户
  • 注册时间: 2011-02-23 13:39
文章存档

2013年(2)

2012年(142)

2011年(154)

分类: LINUX

2011-04-07 11:02:33

15)数据链路访问

 

注:所以文章红色字体代表需要特别注意和有问题还未解决的地方,蓝色字体表示需要注意的地方

 

1.     本文所介绍的程序平台

开发板:arm9-mini2440

虚拟机为:Red Hat Enterprise Linux 5

开发板上系统内核版本:linux-2.6.32.2

 

2.  数据链路访问简介

并不是所有的网络数据都能通过原来所讲的套接字读写来获取的,即使是原始套接字所接收的IP包也是有限制的,对于某些应用特别是网络安全方面的必须要获取所有的网络数据,至少是所有的IP数据包,为了解决上述问题,必须访问数据链路层,直接从数据链路层获取数据。

目前主要的数据链路访问方法包括:

    BSD包过滤器(BPF)

    SVR4数据链路供应接口(DLPI)

    Linux套接字包接口(SOCK_PACKET)

    libpcap(数据包捕获函数库)

 

2.1 BSD包过滤器(BPF)

BSD系统提供了BPF来访问数据链路,BPF具有很强的包过滤能力,每个应用都可以打开BPF设备,并导入自己的过滤器,再由BPF将这些过滤器应用于每个捕获的包,再将过滤后的包传递给程序。

BPF过滤器在系统内核里,只有过滤后的包才能拷贝给应用程序,另外BPF仅当其缓冲区满或超时才将缓冲区内拷贝给程序。

 

2.2 DLPI

SVR4系统提供了DLPI来访问数据链路,他是一个协议独立的接口,与BPF类似,但是过滤机制不同,比BPF速度慢。

 

2.3 SOCK_PACKET

Linux系统提供了SOCK_PACKET来访问数据链路,与套接字创建相同,也使用了socket函数,套接字类型为SOCK_PACKET,套接字协议要指明所要捕获的包的类型,如以太帧或Ipv4包:

Sockfd = socket(AF_INET, SOCK_PACKET, hton(ETH_P_ALL))

Sockfd = socket(AF_INET, SOCK_PACKET, hton(ETH_P_IP))

SOCK_PACKET没有系统内核缓冲区以及内核过滤器,因此过滤效率低

 

2.4 libpcap

Libpcap是一个独立于操作系统执行的访问数据链路的方法,他是一个数据包捕获函数库,该库提供的C函数接口可用于捕获所有经过网络接口的数据包。

由于他独立于操作系统,具有良好的移植性。

 

3. libpcap应用

 

 

主要接口函数说明如下:头文件

pcap_t *pcap_open_live(char * device, int  snaplen,int  promisc, int  to_ms, char * ebuf);
    描述:该函数用于打开网卡用于捕获数据报。单词live的意思就是表示一个运行的网卡(相对于offline而言)被打开了,如同一个保存有被抓数据报的文件被打开一样。在捕获数据报之前这个函数必须被执行。所有的其他的用于处理数据报捕获的函数用到的捕获数据报的描述符由该函数产生。查看 pcap_open_offlin()函数的定义,了解如何打开一个预先保存的包含数据报的文件的细节。
    参数:
    char *device:网卡的描述符指针,由pcap_looupdev函数获取;
    int snaplen:规定捕获的每个数据报的最大字节数;
    int promisc:1为混杂模式;0为非混杂模式;????
    int to_ms:规定读超时的微秒(milliseconds)数;
    char *ebuf:存放错误信息,只有在pcap_open_live失败时才被设置;
    返回值:如果函数成功执行,则返回一个指向数据报捕获的指针;如果错误,返回null,ebuf存放出错信息;

    pcap_t *pcap_open_offline(char *fname, char *ebuf)

      打开以前保存捕获数据包的文件,用于读取。fname参数指定打开的文
      件名。该文件中的数据格式与tcpdumptcpslice兼容。"-"为标准输
      入。ebuf参数则仅在pcap_open_offline()函数出错返回NULL时用于传
      递错误消息。

    pcap_dumper_t *pcap_dump_open(pcap_t *p, char *fname)

      打开用于保存捕获数据包的文件,用于写入。fname参数为"-"时表示
      标准输出。出错时返回NULLp参数为调用pcap_open_offline()
      pcap_open_live()函数后返回的pcap结构指针。fname参数指定打开
      的文件名。如果返回NULL,则可调用pcap_geterr()函数获取错误消
      息。


char *pcap_lookupdev(char * errbuf);
    描述:    这个函数用于获取一个合适的网卡描述,以供pcap_open_liver函数和pcap_lookupnet函数使用。如果找不到网卡或者所有网卡为 off,则返回null。如果一个系统中有多个网卡,那么该函数返回找到的第一个on的网卡。最后才是回环接口。回环网卡一直被忽略;
    参数:
    char * errbuf     存放pcap_lookupdev函数的出错信息,只有在pcap_lookup失败是才有值。
    返回值:    如果函数执行成功,则返回一个用于描述系统上的一个网卡的描述符的指针。如果失败,返回null,errbuf中存放出错信息。

int pcap_lookupnet(char * device, bpf_u_int32 * netp, bpf_u_int32 * maskp,char * errbuf);
    描述:该函数用于监测网卡所在网络的网络地址和子网掩码。
    参数:
    char *devic:网卡的描述符指针,由pcap_looupdev函数获取;
    bpf_u_int32 *netp:存放网络地址;
    bpf_u_int32 *maskp:存放子网掩码;
    char * errbuf: 存放出错信息;
    返回值:如果函数执行成功,则返回值为0,否则返回值为-1,并在errbuf中存放出错信息。

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

      捕获并处理数据包。cnt参数指定函数返回前所处理数据包的最大值。
      cnt=-1表示在一个缓冲区中处理所有的数据包。cnt=0表示处理所有
      数据包,直到产生以下错误之一:读取到EOF;超时读取。callback
      参数指定一个带有三个参数的回调函数,这三个参数为:一个从
      pcap_dispatch()函数传递过来的u_char指针,一个pcap_pkthdr结构
      的指针,和一个数据包大小的u_char指针。如果成功则返回读取到的
      字节数。读取到EOF时则返回零值。出错时则返回-1,此时可调用
      pcap_perror()pcap_geterr()函数获取错误消息。

int pcap_loop(pcap_t * p, int  cnt, pcap_handler  callback,u_char * user);
    描述:
    该函数用于读取和处理数据报。既可以用来处理事先捕获的保存在文件中的数据报,也可以用来处理实时捕获的数据报;
    这个函数类似于pcap_dispatch函数,除了它继续读取数据报直至完成cnt个报的处理,或者文件处理完(在offline情况下),或者有错误发生为止。它不会在实时读超时时返回(而如果为pcap_open_live()函数指定了一个非零值的超时设置,然后调用pcap_dispatch()函数,则当超时发生时pcap_dispatch()函数会返回。) 注意第三个参数,callbackpcap_handler类型的变量。这是一个用户提供的有着三个参数的子函数。定义为:
void user_routine(u_char *user, struct pcap_pkthdr *phrd, u_char *pdata)
这三个参数中,user,是传递给pcap_dispatch()的那个参数;phdr,是个pcap_pkthdr类型的指针,是savefile中的数据报的头指针,pdata,指向数据报数据;这个函数允许用户定义子集的数据报过滤程序;
    参数:
    pcap_t * p:pcap_open_live返回的数据报捕获的指针;
    int cnt:规定了函数返回前应处理的数据报数目;
    pcap_handler callback:指向一个用户自定义的函数,在处理每个报后自动调用该函数进行再处理;
    u_char *user:该指针用于传递给callback.(不知道有什么用?)
    返回值:
    如果函数成功执行(包括读文件时读到EOF),则返回0.否则返回-1,那么错误信息将由函数pcap_geterrpcap_perror给出;

 


    void pcap_dump(u_char *user, struct pcap_pkthdr *h,
          u_char *sp)

      向调用pcap_dump_open()函数打开的文件输出一个数据包。该函数可
      作为pcap_dispatch()函数的回调函数。

int pcap_compile(pcap_t * p, struct bpf_ program *fp, char * str,int  optimize, bpf_u_int32  netmask);
    描述:该函数用于将str指定的规则整合到fp过滤程序中去,并生成过滤程序入口地址,用于过滤选择期望的数据报;
    参数:
    pcap_t *ppcap_open_live返回的数据报捕获的指针;
    struct bpf_program *fp:指向一个子函数用于过滤,在pcap_compile()函数中被赋值;
    char *str:该字符串规定过滤规则;
    int optimize:规定了在结果代码上的选择是否被执行;
    bpf_u_int32 netmask:该网卡的子网掩码,可以通过pcap_lookupnet()获取;
    返回值:
    如果成功执行,返回0,否则返回-1

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

      指定一个过滤程序。fp参数是bpf_program结构指针,通常取自
      pcap_compile()函数调用。出错时返回-1;成功时返回0

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

      返回指向下一个数据包的u_char指针。

    int pcap_datalink(pcap_t *p)

      返回数据链路层类型,例如DLT_EN10MB

    int pcap_snapshot(pcap_t *p)

      返回pcap_open_live被调用后的snapshot参数值。

    int pcap_is_swapped(pcap_t *p)

      返回当前系统主机字节与被打开文件的字节顺序是否不同。

    int pcap_major_version(pcap_t *p)

      返回写入被打开文件所使用的pcap函数的主版本号。

    int pcap_minor_version(pcap_t *p)

      返回写入被打开文件所使用的pcap函数的辅版本号。

    int pcap_stats(pcap_t *p, struct pcap_stat *ps)

      pcap_stat结构赋值。成功时返回0。这些数值包括了从开始
      捕获数据以来至今共捕获到的数据包统计。如果出错或不支持
      数据包统计,则返回-1,且可调用pcap_perror()
      pcap_geterr()函数来获取错误消息。

    FILE *pcap_file(pcap_t *p)

      返回被打开文件的文件名。

    int pcap_fileno(pcap_t *p)

      返回被打开文件的文件描述字号码。

    void pcap_perror(pcap_t *p, char *prefix)

      在标准输出设备上显示最后一个pcap库错误消息。以prefix
      数指定的字符串为消息头。

    char *pcap_geterr(pcap_t *p)

      返回最后一个pcap库错误消息。

    char *pcap_strerror(int error)

      如果strerror()函数不可用,则可调用pcap_strerror函数替代。

    void pcap_close(pcap_t *p)

      关闭p参数相应的文件,并释放资源。

    void pcap_dump_close(pcap_dumper_t *p)

      关闭相应的被打开文件。


4. libpcap的数据类型


libpcap的数据类型定义:

struct pcap_addr:网卡地址描述
{
    pcap_addr * next;
    sockaddr * addr;
    sockaddr * netmask;
    sockaddr *broadaddr;
    sockaddr *dstaddr;
};
pcap_addr * next;
    如果非空,指向链表中一个元素的指针;空表示链表中的最后一个元素。
sockaddr * addr;
    指向包含一个地址的sockaddr的结构的指针。
sockaddr * netmask;
    如果非空,指向包含相对于addr指向的地址的一个网络掩码的结构。
sockaddr * broadaddr;
    如果非空,指向包含相对于addr指向的地址的一个广播地址,如果网络不支持广播可能为空。
sockaddr * dstaddr;
    如果非空,指向一个相对于addr指向的源地址的目的地址,如果网络不支持点对点通讯,则为空。

struct pcap_file_header {
    bpf_u_int32 magic;
    u_short version_major;
    u_short version_minor;
    bpf_int32 thiszone;    /* gmt to local correction */
    bpf_u_int32 sigfigs;    /* accuracy of timestamps */
    bpf_u_int32 snaplen;    /* max length saved portion of each pkt */
    bpf_u_int32 linktype;    /* data link type (LINKTYPE_*) */
};

bpf_u_int32 magic;
    ????????????????????????????????
u_short version_major;
    Libpcap的主版本号。
u_shart version_minor;
    Libpcap的从版本号。
bpf_u_int32 sigfigs;
    时间戳描述。
bpf_u_int32 snaplen;
    保存的每个pkt的分片号的最大值。
bpf_u_int32 linktype;
    数据链的类型。
细节说明:
    libpcap dump文件头;
    libpcap dump文件中的第一个记录包含了一些标志的保存值,这些标志在打印阶段用到。这儿的很多域都是32位的int,所以compilers不用进行转化;这些文件需要具有跨层次的可交换性。
    无论如何不要改变结构的层次(包括仅仅改变这个结构中域的长度);


struct pcap_if {          /*网卡数据链的一个元素*/
    struct pcap_if *next;
    char *name;        /* name to hand to "pcap_open_live()" */
    char *description;    /* textual description of interface, or NULL */
    struct pcap_addr *addresses;
    u_int flags;        /* PCAP_IF_ interface flags */
};

pcap_if *next;
    如果非空,指向链的下一个元素。如果为空是链的最后一个元素。
char * name;
    指向一个字符串,该字符串是传给pcap_open_live()函数的设备名;
char * description;
    如果非空,指向一个对设备的人性化的描述字符串。
pcap_addr *addresses;
    指向网卡地址链中的第一个元素。
u_int flags;
    PCAP_IF_ 网卡的标志。现在唯一可用的标识是PCAP_IF_LOOKBACK,它被用来标识网卡是不是lookback网卡。

struct pcap_pkthdr结构位于真正的物理帧前面,用于消除不同的链路层的差异。
struct pcap_pkthdr {         /*dump 文件中的数据包头*/
    struct timeval ts;    /* time stamp */
    bpf_u_int32 caplen;    /* length of portion present */
    bpf_u_int32 len;    /* length this packet (off wire) */
};
timeval ts;
    数据报时间戳;
bpf_u_int32 caplen;
    当前分片的长度;
dpf_u_int32 len;
    这个数据报的长度;
细节描述:
    dump文件中的每个数据报都有这样一个报头。它用来处理不同数据报网卡的不同报头问题。

struct pcap_stat {        /*用来保存网卡静态变量的结构*/
    u_int ps_recv;        /* number of packets received */
    u_int ps_drop;        /* number of packets dropped */
    u_int ps_ifdrop;    /* drops by interface XXX not yet supported */
};
u_int ps_recv;
    接受数据报的数目;
u_int ps_drop;
    被驱动程序丢弃的数据报的数目;
u_int ps_ifdrop;
    被网卡丢弃的数据报的数目;


struct pcap_sf {    //pacapsavefile结构 定义
        FILE *rfile;    //该指针指向savefile文件
        int swapped;    //
        int hdrsize;    //头大小吗?
        int version_major;//主版本号
        int version_minor;//从版本号
        u_char *base;//
};
struct pcap_md { //
        struct pcap_stat stat;
        /*XXX*/
        int use_bpf;            /* using kernel filter */
        u_long  TotPkts;        /* can't oflow for 79 hrs on ether */
        u_long  TotAccepted;    /* count accepted by filter */
        u_long  TotDrops;       /* count of dropped packets */
        long    TotMissed;      /* missed by i/f during this run */
        long    OrigMissed;     /* missed by i/f before this run */
#ifdef linux
        int     sock_packet;    /* using Linux 2.0 compatible interface */
        int     timeout;        /* timeout specified to pcap_open_live */
        int     clear_promisc;  /* must clear promiscuous mode when we close */
        int     cooked;         /* using SOCK_DGRAM rather than SOCK_RAW */
        int     lo_ifindex;     /* interface index of the loopback device */
        char    *device;        /* device name */
        struct pcap *next;      /* list of open promiscuous sock_packet pcaps */
#endif
};

struct pcap {    //这个结构很重要
        int fd;
        int snapshot;
        int linktype;
        int tzoff;              /* timezone offset */
        int offset;             /* offset for proper alignment */
        struct pcap_sf sf;
        struct pcap_md md;
        /*
         * Read buffer.
         */
        int bufsize;
        u_char *buffer;
        u_char *bp;
        int cc;
        /*
         * Place holder for pcap_next().
         */
        u_char *pkt;
       
        /*
         * Placeholder for filter code if bpf not in kernel.
         */
        struct bpf_program fcode;
        char errbuf[PCAP_ERRBUF_SIZE];
};

lipcap的声明:
#define PCAP_VERSION_MAJOR 2
    libpcap dump文件的主版本号;
#define PCAP_VERSION_MINOR   4   
    libpcap dump文件的从版本号;
#define PCAP_ERRBUF_SIZE   256
    用来存放libpcap出错信息的缓冲区的大小;
#define PCAP_IF_LOOPBACK   0x00000001
    网卡是回环网卡;
#define MODE_CAPT   0
    抓报模式,在调用pcap_setmode()时使用;
#define MODE_STAT   1
    静态模式,在调用pcap_setmode()时使用;

libpcap的类型定义:
typedef int bpf_int32   
    32bit 的整形;
typedef    u_int bpf_u_int32
    32bit 的无类型整形;
typedef pcap pcap_t
    Descriptor of an open capture instance(一个打开的捕获实例的描述符?)这个结构对用户是不透明的。
typedef pcap_dumper pcap_dumper_t
    libpcap保存文件的描述符。
typedef pcap_if pcap_if_t
    网卡链表的一个元素;
typedef pcap_addr pcap_addr_t
    网卡地址的表示;

5.过滤程序

Libpcap提供了过滤程序,但是应用需要提供相应的过滤规则,来决定捕获哪些包,过滤规则通过pcap_compile函数编译到过滤程序中,再通过pcap_setfilter函数将其设置为过滤器,从而对包进行过滤,当然也可以自己编译自己的过滤程序,不必通过pcap_compile进行编译。

过滤规则:(以字符串形式表达)

类型限定:类型包括hostnetport,比如,host myhost表示捕获带有主机地址myhost的包;net 201.9.200表示捕获子网201.9.200内的包;port 20表示捕获端口号为20的包

方向限定:指明何种方向的包捕获。方向包括srcdstsrc or dst src and dst,例如 src myhost 表示捕获源地址为 myhost的包

协议限定:指明捕获某种协议的包,协议包括etherfddiiparprarptcpudp等,例如 tcp port 80 表示捕获端口号为80TCP

5.1 数据链路访问实例

#include

 #include

 #include

 #include

 #include

 #include

 #include

 

 #define BUFSIZ  1000

 #define PCAP_ERRBUF_SIZE  200

 void Display( const u_char * packet, const size_t length );

 

 /* list all packets be filtered      */

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

 {

     Display( ( u_char * )packet, ( size_t )( pkthdr->caplen ) );

     return;

 } 

 

 int main(int argc,char **argv)

 {

     int i;

     char *dev;

     char errbuf[PCAP_ERRBUF_SIZE];

     pcap_t* descr;

     const u_char *packet;

     struct pcap_pkthdr hdr;    

     struct ether_header *eptr;

     struct bpf_program fp;    

     bpf_u_int32 maskp;         

     bpf_u_int32 netp;          

     char rule[64];

 

     if(argc != 1){

       fprintf(stdout,"Usage: %s \n"  ,argv[0]);

       return 0;

       }

    printf("input rule:");

    gets(rule);

     /* grab a device */

     dev = pcap_lookupdev(errbuf);

     if(dev == NULL) {

       fprintf(stderr,"%s\n",errbuf);

       exit(1);

       }

 

     /* ask pcap for the network address and mask of the device */

     pcap_lookupnet(dev,&netp,&maskp,errbuf);

 

     /* open device for reading this time lets set it in promiscuous

     * mode so we can monitor traffic to another machine             */

     descr = pcap_open_live(dev,BUFSIZ,1,-1,errbuf);

     if(descr == NULL) {

       printf("pcap_open_live(): %s\n",errbuf);

       exit(1);

       }

 

     /* Lets try and compile the program.. non-optimized */

     if(pcap_compile(descr,&fp,rule,0,netp) == -1) {

        perror("pcap_compile:");//这个报的是错误的错误信息

        pcap_perror(descr ,"pcap_compile:");//注意应该使用这个报错

       exit(1);

       }

 

     /* set the compiled program as the filter */

     if(pcap_setfilter(descr,&fp) == -1) {

       fprintf(stderr,"Error setting filter\n");

       exit(1);

       }

 

     /* capture packets */

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

 

     return 0;

 }

 

 void Display ( const u_char * packet, const size_t length )

 {

     u_long offset;

     int    i, j, k;

 

     printf( "packet [ %lu bytes ]: \n", ( long unsigned int )length );

     if ( length <= 0 ) {

     return;

     }

     i   = 0;

     offset = 0;

     for ( k = length / 16; k > 0; k--, offset += 16 ){

       printf( "%08X ", ( unsigned int )offset );

       for ( j = 0; j < 16; j++, i++ ) {

         if ( j == 8 ){

           printf( "-%02X", packet[i] );

           }

        else  printf( " %02X", packet[i] );

        }

       printf( "    " );

       i -= 16;

       for ( j = 0; j < 16; j++, i++ ) {

         /* if ( isprint( (int)packet[i] ) ) */

         if ( ( packet[i] >= ' ' ) && ( packet[i] <= 255 ) )  {

         printf( "%c", packet[i] );

         }

         else   printf( "." );

         }

       printf( "\n" );

       }

     k = length - i;

     if ( k <= 0 ){

       return;

       }

     printf( "%08X ", ( unsigned int )offset );

     for ( j = 0 ; j < k; j++, i++ ){

       if ( j == 8 ){

         printf( "-%02X", packet[i] );

         }

       else  printf( " %02X", packet[i] );

       }

     i -= k;

     for ( j = 16 - k; j > 0; j-- )  {

       printf( "   " );

       }

     printf( "    " );

     for ( j = 0; j < k; j++, i++ ){

       if ( ( packet[i] >= ' ' ) && ( packet[i] <= 255 ) ) {

         printf( "%c", packet[i] );

         }

       else   {

         printf( "." );

         }

       }

     printf( "\n" );

     return;

 }

 

 

 

 

 

部分内容来自 http://blog.csdn.net/bat603/archive/2006/09/04/1175729.aspx

阅读(1198) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~