概要

   SECTIONS
      .bss  READ WRITE SHARED
      .data READ WRITE SHARED
						

link -section:.data,rws -section:.bss,rws
						

更多信息

回到顶端

在文章《浅析Windows CE跨进程内存注入实现窗体消息挂接（上）》中，我们已经得到了这个七巧板游戏所需要的所有小板块，剩下的事就是等待我们按一定顺序将合适的板块放到合适的位置，本章我们开始进行真刀真枪的实战演练。

程序目标：捕获explore窗体（也就是程序窗体的消息并输出到WinProcInfo.txt中）

程序的执行步骤设计如下：

1、编写一个窗体消息挂接DLL，这个DLL提供一个，函数中利用setwindowlong函数将窗体的默认消息处理过程改为这个挂接DLL中定义的一个窗体过程。

2、在C#程序中利用findwindow等API函数获得exlore类窗体的句柄及窗体所属的进程，并使用performcallback4在目标进程空间中执行coredll.dll的loadLibrary函数将我们写的挂接dll放到目标进程中。

3、在C#程序中使用performcallback4在目标进程空间中执行挂接DLL提供的导出接口函数实现跨进程窗体消息截获.

一、程序的实现如下：

在VS2005中建立一个智能设备的MFC DLL，命名为HookWindowsProcMFCDLL。

在HookWindowsProcMFCDLL.cpp中进行挂接DLL的核心编码：

而在C#的主程序中，我们使用这个DLL挂接explore类的程序窗体，以下给出挂接部分的代码：

取消挂接的代码根据上述代码很容易就可以建立，不再细叙。

注：clsCECoreAPI的函数全是封装的标准CE API，由于这些API在msdn 中都有详细的文档注释，因篇幅所限，不再将代码一一列举.

在执行这个程序时，将模拟器的共享路径设为PC机的桌面，这样模拟器的storage card目录就等同桌面了，点模拟器的开始菜单，选程序，你就可以看到explore窗体的消息都输出到桌面的WinProcInfo.txt文件中了，运行结果如下：

　　

　目前本程序只在PPC2003/wm5 for PPC测试通过,由于smartphone系统在编译时使用了和ppc系统不同的机制，内存运作不明，本程序在smartphone上无法正确运行，有好的建议的话请指教一二,谢谢.

#include <windows.h>

#include<Windev.h>

#include <stdio.h>

#include "objbase.h"

#include "initguid.h"

#include "foo.h"

//char data1[10];

int  WinMain(void)

{

    HANDLE hnd;

    COPY_STRUCT cs[1];

    int i;

    //static char data1[10];

  auto char data1[10];

    auto char data2[10];

    static char* p1,*p2;

    //cs.pBuffer1 = (char *)malloc(10);

    //cs.pBuffer2 = (char*)malloc(10);

    //cs.nLen = 10;

    p1 = (char *)LocalAlloc(LPTR,10);

    p2 = (char *)malloc(10);

    //cs[0].pBuffer1 = (char *)malloc(10);

    //cs[0].pBuffer2 = (char*)malloc(10);

    cs[0].pBuffer1 = &data1[0];

    cs[0].pBuffer2 = &data2[0];

    cs[0].nLen = 10;

    memset(cs[0].pBuffer1,'a',10);

    hnd = CreateFile(FOO_DEV_NAME,GENERIC_READ|GENERIC_WRITE,0,NULL,0,0,NULL);

    if(hnd==NULL)

    {

           printf("Open device falied!\n");

           return;

    }

    DeviceIoControl(hnd,IOCTL_FOO_XER,&cs[0],sizeof(COPY_STRUCT),NULL,0,NULL,NULL);

    //for(i=0;i<9;i++)

    //{

           //printf(" %c",*(cs.pBuffer2++));

    //}

    printf("\n");

    CloseHandle(hnd);

//  free(cs[0].pBuffer1);

//  free(cs[0].pBuffer2);

}

可以通过evc的单步调试看结果。好了一切都完成了，我们来看看系统是怎么工作的吧，从应用程序开始，

CreateFile(FOO_DEV_NAME,GENERIC_READ|GENERIC_WRITE,0,NULL,0,0,NULL);

会调用到

FOO_Open(DWORD dwContext, DWORD AccessCode, DWORD ShareMode)

而FOO_DEV_NAME名字定义在foo.h里面。

#define       FOO_DEV_NAME L"Foo1:"

注意后面是 1 ,这个是和注册表的这一项匹配的

"Index"=dword:1

当调用CreateFile发生了什么，slot之间的转换，一系列系统操作后，调用到我们自己的driver函数FOO_Open，在这个函数里我们返回了一个句柄，它可以用来存储我们的自己driver的信息。在其它I/O操作中可以使用。

Driver什么时候加载的？在注册表里，device manager会一个个的加载，会调用到FOO_Init函数。这个函数返回一个指针，在调用FOO_Open又传回来了，这样我们就可以实现初始化一些自己driver的东西。

接着一个重要的函数，

DeviceIoControl(hnd,IOCTL_FOO_XER,&cs[0],sizeof(COPY_STRUCT),NULL,0,NULL,NULL);

调用到

FOO_IOControl

走到这里

case IOCTL_FOO_XER:

           if((pInBuf==NULL))

                  {

                         SetLastError(ERROR_INVALID_PARAMETER);

                         break;

                  }

                  pcs = (COPY_STRUCT*)pInBuf;

                  __try{

                         pMap1 =  MapPtrToProcess(pcs->pBuffer1,GetCallerProcess());

                         pMap2 =  MapPtrToProcess(pcs->pBuffer2,GetCallerProcess());

                         DEBUG_OUT(1, (TEXT("+FOO_IOControl(0x%x,0x%x)\r\n"),pcs->pBuffer1,pcs->pBuffer2));

                         memcpy(pcs->pBuffer2,pcs->pBuffer1,pcs->nLen);

                         bResult = TRUE;

                         }

                  __except(EXCEPTION_EXECUTE_HANDLER){

                         DEBUG_OUT(1,(TEXT("Exception:FOO_IOCTL\r\n")));

                         break;                         

                  }

                  break;

           default:

                  break;

这里又很多东西要研究，

从应用程序传来的参数有， control code，IOCTL_FOO_XER和一个重要的输入参数&cs[0],它是一个指针。cs 是一个结构体，定义在FOO.H

typedef struct {

    char* pBuffer1;

    char* pBuffer2;

    int nLen;

}COPY_STRUCT;

而且这个结构体里有两个指针。

DeviceIoControl 传过来的指针可以用吗？它包含的两个指针可以直接用吗？

按照PB连接帮助文档看，

The operating system (OS ) manages pointers passed directly as parameters. Drivers must map all pointers contained in structures. DeviceIoControl buffers are often structures that contain data, some of which might be pointers.

You can map a pointer contained in a structure by calling MapPtrToProcess, setting the first parameter to the pointer, and then setting the second parameter to GetCallerProcess.

cs指针已经映射好了，但是它指向的结构里的指针我们需要自己使用MapPtrToProcess函数映射。

这也就是：

                         pMap1 =  MapPtrToProcess(pcs->pBuffer1,GetCallerProcess());

                         pMap2 =  MapPtrToProcess(pcs->pBuffer2,GetCallerProcess());

的由来，可是后面的代码没有使用pMap1，pMap2。而是直接使用：

memcpy(pcs->pBuffer2,pcs->pBuffer1,pcs->nLen);

而且它还工作了，没有出现exception。很奇怪。我第一次在一个家伙的代码里看见这种情况，很吃惊，但是它工作的很好，是文档出错了？

我们来分析一下，看看应用程序的代码：

    COPY_STRUCT cs[1];

  auto char data1[10];

    auto char data2[10];

cs结构和data1，data2数组都是自动变量，存放在堆栈里。假设这个应用程序被加载到0x18000000位置的slot里，那么他们的地址都是0x18XXXXXX。不熟悉wince memory architecture的可以看看资料，了解一下slot。当调用了

DeviceIoControl，按照文档的说法，cs指针得到了转换，因为从应用程序的进程转到了device.exe进程，而device进程又是当前的运行的进程，被映射到了slot0，系统负责转换cs指针。而cs包含的pBuffer1和pBuffer2是没有映射不能直接用的。

事实上，我们传过来的指针根本就是不需要映射，因为他们都是0x18xxxxxx,在应用程序的slot里，所以只要device.exe有访问应用程序的权限，就可以了。而这个权限，系统已经帮我们设置好了。

那什么情况下要自己映射呢？

如果应用程序在定义 data1和data2使用static关键字，或者使用LocalAlloc，HeapAlloc的时候，一定要自己映射cs里的指针。

在应用程序里这样写：

    cs.pBuffer1 = (char *)malloc(10);

    cs.pBuffer2 = (char*)malloc(10);

    cs.nLen = 10;

如果不使用MapPtrToProcess完成映射，那就出现data abort exception.

为什么呢？

因为这些变量都是在堆里分配的，而当应用程序运行时，被映射到slot0，堆的地址也就是处于slot的范围内，传递到device.exe后，device.exe被映射到了slot0，这个时候必须要将应用程序的指针映射回应用程序所在的slot。否则访问的是device.exe的空间，会发生不可知道的结果。

验证一下上面说的地址分配问题。

我们这样定义

COPY_STRUCT cs[1];

  static char data1[10]; 堆里

  auto char data2[10];   栈里

这样赋值：

  cs[0].pBuffer1 = &data1[0];

  cs[0].pBuffer2 = &data2[0];

  cs[0].nLen = 10;

调试信息：

cs[0].pBuffer1 = &data1[0];

180112D0   ldr       r2, [pc, #0xD0]

180112D4   str       r2, [sp, #0x10]

读取&data1[0]使用的是PC作为基址，而此时的应用程序处于运行阶段映射到slot0，那么pc也就在0~01ffffff范围，我的调试结果是在0x000112D0+8,使用的是arm，流水线机制，当前指令地址＋8才是pc值。

143:      cs[0].pBuffer2 = &data2[0];

180112D8   add       r0, sp, #0x20

180112DC   str       r0, [sp, #0x14]

读取&data2[0]采用的是sp作为基址，sp在应用程序加载到slot的时候就确定了的。所以保持了在应用程序slot的值，处于0x18xxxxxx范围。

我们看到因为wince的slot机制，我们有时候需要映射，有时候不需要。所以wince文档说结构里的指针要映射。毕竟你不知道应用程序怎么写。

当然，你可以根本不映射，只要把那个结构屏蔽调，写一个STATIC LIBRARY给用户使用，自己保证使用正确的地址分配就可以了。上面我说的那个家伙就是这么干的。

好了，接着

调用：

  CloseHandle(hnd);

程序结束了，完成了一次简单的拷贝。

每个进程都拥有自己的虚拟地址空间，那么怎样才能访问这个空间呢？这就需要用到Windows API函数。这些函数直接与编写程序相关，因而更受软件工程师的关注。有关这方面的函数较多，这里介绍几个重要的函数。

1.3.1  获取系统信息

在一个程序中不能直接应用某个系统的设备参数，否则将不利于程序的移植。因此，如果确实需要用到这样的设备参数，则需要一个系统信息函数来获得。VC++ 编译器所提供这样的函数为GetSystemInfo()。该函数需要一个指向SYSTEM_INFO结构的指针作为参数。其原型表示为：

l           

void GetSystemInfo(LPSYSTEM_INFO lpSystemInfo);

l           

其中lpSystemInfo返回LPSYSTEM_INFO结构的地址，用于装载适当的系统信息，这个结构体定义为：

l           

typedef struct _SYSTEM_INFO { 

    union {   

        DWORD dwOemId;   

        struct {     

            WORD wProcessorArchitecture;      

            WORD wReserved;   

        };

    }; 

    DWORD  dwPageSize; 

    LPVOID  lpMinimumApplicationAddress; 

    LPVOID  lpMaximumApplicationAddress; 

    DWORD_PTR  dwActiveProcessorMask; 

    DWORD  dwNumberOfProcessors; 

    DWORD  dwProcessorType; 

    DWORD  dwAllocationGranularity; 

    WORD   wProcessorLevel; 

    WORD   wProcessorRevision;

} SYSTEM_INFO;

l           

其中参数含义如下所述。

dwOemId：是一个过时选项，用于与Windows NT 3.5以及以前的版本兼容。

wProcessorArchitecture：指明处理的结构，如Intel、Alpha、Intel 64位或Alpha       64位。

dwPageSize：用于显示CPU的页面大小。在x86 CPU上，这个值是4096字节。在Alpha CPU上，这个值是8192字节。在IA-64上，这个值是8192字节。

lpMinimumApplicationAddress：用于给出每个进程可用地址空间的最小内存地址。在Windows 98上，这个值是0x400000，因为每个进程的地址空间中下面的4MB是不能使用的。在Windows 2K/XP上，这个值是0x10000，因为每个进程的地址空间中开头的64KB总是空闲的。

lpMaximumApplicationAddress：用于给出每个进程可用地址空间的最大内存地址。在Windows 98上，这个地址是0x7FFFFFFF，因为共享内存映射文件区域和共享操作系统代码包含在上面的2GB分区中。在Windows XP上，这个地址是0x7FFEFFFF。

dwActiveProcessorMask：位屏蔽，指明哪个CPU是活动的。

dwNumberOfProcessors：计算机中CPU的数目。

dwProcessorType：处理器类型。

dwAllocationGranularity：保留的地址空间区域的分配粒度。

wProcessorLevel：进一步细分处理器的结构。

wProcessorRevision：用于进一步细分处理器的级别。

wReserved：保留供将来使用。

在以上参数中只有lpMinimumApplicationAddress、lpMaximumApplicationAddress、dwPageSize和dwAllocationGranularity与内存有关。

1.3.2  在应用程序中使用虚拟内存

对内存分配可以采用不同的方法，常用的方法有：用C/C++语言的内存分配函数，例如，用malloc() 和 free()、new 和 delete 函数分配和释放堆内存；用Windows传统的全局或者局部内存分配函数，如GlobalAlloc()和GlobalFree()；用Win32的堆分配函数，如HeapAlloc()和HeapFree()；用Win32的虚拟内存分配函数，如VirtualAlloc()和VirtualFree()。注意，用不同的方法分配内存后，要用相对应的函数来释放所占用的内存。这里只介绍Win32的虚拟内存分配函数。

在进程创建之初并被赋予地址空间时，其虚拟地址空间尚未分配，处于空闲状态。这时地址空间内的内存是不能使用的，必须通过VirtualAlloc()函数来分配其中的各个区域，对其进行保留。VirtualAlloc()函数原型为：

l           

LPVOID VirtualAlloc(

    LPVOID lpAddress,

    DWORD dwSize,

    DWORD flAllocationType,

    DWORD flProtect

    );

l           

该函数用来分配一定范围的虚拟页。参数1指定起始地址；参数2指定分配内存的长度；参数3指定分配方式，取值MEM_COMMINT或者MEM_RESERVE；参数4指定控制访问本次分配的内存的标识，取值为PAGE_READONLY、PAGE_READWRITE或者PAGE_NOACCESS。

分配完成后，即在进程的虚拟地址空间中保留了一个区域，可以对此区域中的内存进行保护权限许可范围内的访问。当不再需要访问此地址空间区域时，应释放此区域，由VirtualFree()负责完成。其函数原型为：

l           

BOOL VirtualFree(

    LPVOID lpAddress,

    DWORD dwSize,

    DWORD dwFreeType

    );

l           

其中参数含义如下所述。

lpAddress：指向待释放页面区域的指针。如果参数dwFreeType指定了MEM_RELEASE，则lpAddress必须为页面区域保留由VirtualAlloc()所返回的基地址。

dwSize：指定了要释放的地址空间区域的大小，如果参数dwFreeType指定了MEM_RELEASE标志，则将dwSize设置为0，由系统计算在特定内存地址上的待释放区域的大小。

dwFreeType：为所执行的释放操作的类型，其可能的取值为MEM_RELEASE和MEM_DECOMMIT，其中MEM_RELEASE标志指明要释放指定的保留页面区域，MEM_DECOMMIT标志则对指定的占用页面区域进行占用的解除。

如果VirtualFree()执行完成，将回收全部范围的已分配页面，此后如再对这些已释  放页面区域内存进行访问将引发内存访问异常。释放后的页面区域可供系统继续分配   使用。

1.3.3  获取虚存状态

Windows API函数GlobalMemoryStatus()可用于检索关于当前内存状态的动态信息。在软件的About对话框中，通常用这个函数来获取系统内存的使用情况。其函数原型为：

l           

void GlobalMemoryStatus(LPMEMORYSTATUS lpmstMemStat);

l           

其中lpmstMemStat返回MEMORYSTATUS结构的地址，这个结构体的定义为：

l           

typedef struct MEMORYSTATUS{

    DWORD dwLength;

    DWORD dwMemoryLoad;        

    DWORD dwTotalPhys;

    DWORD dwAvailPhys;

    DWORD dwTotalPageFile;

    DWORD dwAvailPageFile;

    DWORD dwTotalVirtual;

    DWORD dwAvailVirtual; 

} MEMORYSTATUS ,* LPMEMORYSTATUS;

l           

其中参数含义如下所述。

dwLength：MEMORYSTATUS结构大小。

dwMemoryLoad：已使用内存所占的百分比。

dwTotalPhys：物理存储器的总字节数。

dwAvailPhys：空闲物理存储器的字节数。

dwTotalPageFile：页文件包含的最大字节数。

dwAvailPageFile：用户模式分区中空闲内存大小。

dwTotalVirtual：用户模式分区大小。

dwAvailVirtual：表示当前进程中还剩下的自由区域的总和。

在调用GlobalMemoryStatus()之前，必须将dwLength成员初始化为用字节表示的结构的大小，即一个MEMORYSTATUS结构的大小。这个初始化操作使得Microsoft能够在新版本Windows系统中将新成员添加到这个结构中，而不会破坏现有的应用程序。当调用GlobalMemoryStatus()时，它将对该结构的其余成员进行初始化并返回。

如果某个应用程序在内存大于4GB的计算机上运行，或者合计交换文件的大小大于4GB，那么可以使用新的GlobalMemoryStatusEx()函数。其函数的原型为：

l           

BOOL GlobalMemoryStatusEx(MEMORYSTATUSEX  &mst);

l           

其中mst返回MEMORYSTATUSEX结构的填充信息，该结构体与原先的MEMORYSTATUS结构基本相同，差别在于新结构的所有成员的大小都是64位宽，因此它的值可以大于4 GB。

1.3.4  确定虚拟地址空间的状态

对内存的管理除了对当前内存的使用状态信息进行获取外，还经常需要获取有关进程的虚拟地址空间的状态信息。例如，如何得到一个进程已提交的页面范围？这就要用到两个 API函数VirtualQuery()或VirtualQueryEx()来进行查询。这两个函数的功能相似，不同就是VirtualQuery()只是查询本进程内存空间信息，而VirtualQueryEx()可以查询指定进程的内存空间信息。VirtualQuery()函数原型如下：

l           

DWORD VirtualQuery(

    LPVOID lpAddress,     

    PMEMORY_BASIC_INFORMATION lpBuffer,

    DWORD dwLength

    );

l           

VirtualQueryEx()函数原型如下：

l           

DWORD VirtualQueryEx(

    HANDLE hProcess ,

    LPCVOID lpAddress ,

    PMEMORY_BASIC_INFORMATION lpBuffer ,

    DWORD dwLength

    );

l           

其中参数含义如下所述。

hProcess：进程的句柄。

lpAddress：想要了解其信息的虚存地址。

lpBuffer：返回MEMORY_ BASIC_INFORMATION结构的地址。

dwLength：返回的字节数。

PWEMORY_BASIC_INFORMATION的定义如下：

l           

typedef struct _MEMORY_BASIC_INFORMATION{

    PVOID BaseAddress;  

    PVOID AllocationBase;

    DWORD AllocationProtect;

    DWORD RegionSize;

    DWORD State;

    DWORD Protect;

    DWORD Type;

} MEMORY_BASIC_INFORMATION, * PMEMORY_BASIC_INFORMATION;

l           

其中参数含义如下所述。

BaseAddress：被查询内存块的基地址。

AllocationBase：用VirtualAlloc()分配该内存时实际分配的基地址。

AllocationProtect：分配该页面时，页面的一些属性，如PAGE_READWRITE、PAGE_EXECUTE等（其他属性可参考 Platform SDK）。

RegionSize：从BaseAddress开始，具有相同属性的页面的大小。

State：页面的状态，有3种可能值：MEM_COMMIT、MEM_FREE和MEM_ RESERVE，这个参数是最重要的，从中可知指定内存页面的状态。

Protect：页面的属性，它可能的取值与 AllocationProtect 相同。

Type：指明了该内存块的类型，有3种可能值：MEM_IMAGE、MEM_MAPPED和MEM_PRIVATE。

1.3.5  改变内存页面保护属性

在进行进程挂钩时，经常要向内存页中写入部分代码，这就需要改变内存页的保护属性。有幸的是Win32提供了两个API函数VirtualProtect()和VirtualProtectEx()，它们可以对改变内存页保护。例如，在使用这两个函数时，可以先按PAGE_READWRITE属性来提交一个页的地址，并且立即将数据填写到该页中，然后再把该页的属性改变为PAGE_READONLY，这样可以有效地保护数据不被该进程中的任何其他线程重写。在调用这两个函数之前最好先了解有关页面的信息，可以通过VirtualQuery()来实现。

VirtualProtect()与VirtualProtectEx()函数的区别在于VirtualProtect()只适用于本进程，而VirtualProtectEx()可以适用于其他进程。VirtualProtect()函数原型如下：

BOOL VirtualProtect(

    PVOID pvAddress,

    DWORD dwSize,

    DWORD flNewProtect,

    PDWORD pflOldProtect

    );

l           

VirtualProtectEx()函数原型如下：

l           

BOOL VirtualProtectEx(

    HANDLE hProcess,

    PVOID pvAddress,

    DWORD dwSize,

    DWORD flNewProtect,

    PDWORD pflOldProtect

    );

l           

其中参数的含义如下所述。

hProcess：要修改内存的进程句柄。

pvAddress：指向内存的基地址（它必须位于进程的用户方式分区中）。

dwSize：用于指明想要改变保护属性的字节数。

flNewProtect：代表PAGE_*保护属性标志中的任何一个标志，但PAGE_ WRITECOPY和PAGE_EXECUTE_WRITECOPY这两个标志除外。

pflOldProtect：是DWORD大小的地址，VirtualProtect()和VirtualProtectEx()将用原先与pvAddress位置上的字节相关的保护属性填入该地址。尽管许多应用程序并不需要该信息，但是必须为该参数传递一个有效地址，否则该函数的运行将会失败。

1.3.6  进行一个进程的内存读写

前面已经说明了如何获得一个进程的内存属性、如何分配内存和如何改变内存页的保护属性，其最终的目的是要对一个进程中内存内容进行读写。要完成此工作，需要用到两个函数：ReadProcessMemory() 和WriteProcessMemory()，这两个函数非常有用。如果知道了一个进程的句柄和内存地址，就可以用ReadProcessMemory()函数来得到该进程和该地址中的内容，此函数的原型为：

l           

BOOL ReadProcessMemory(

    HANDLE hProcess,

    LPCVOID lpBaseAddress,

    LPVOID lpBuffer,

    DWORD nSize, 

    LPDWORD lpNumberOfBytesRead

    );

l           

其中hProcess为要读入的进程句柄，lpBaseAddress为读内存的起始地址，lpBuffer为读入数据的地址，nSize为要读入的字节数，lpNumberOfBytesRead为实际读入的字   节数。

同样，如果知道了一个进程的句柄和内存地址，可以用WriteProcessMemory()函数向该进程和该地址中写入新的内容，这个函数的原型为：

l           

BOOL WriteProcessMemory(

    HANDLE hProcess,

    LPVOID lpBaseAddress,

    LPVOID lpBuffer,

    DWORD nSize,

    LPDWORD lpNumberOfBytesWritten

    );

l           

其中参数hProcess为要写入的进程句柄，lpBaseAddress为写内存的起始地址，lpBuffer为写入数据的地址，nSize为要写入的字节数，lpNumberOfBytesWritten为实际写入的字节数。

Windows CE的有些函数中需要用到物理内存结构体PHYSICAL_ADDRESS， Windows CE在ceddk.h中定义了PHYSICAL_ADDRESS，它其实是LARGE_INTEGER类型，其定义如下：

// in ceddk.h

typedef LARGE_INTEGER PHYSICAL_ADDRESS, *PPHYSICAL_ADDRESS;

// in winnt.h

typedef union _LARGE_INTEGER{

 struct{

    DWORD LowPart;

    LONG HighPart;

 };

 LONGLONG QuadPart;

} LARGE_INTEGER;

可见，Windows CE中用64个Bit来代表物理地址，对于大多数32位的CPU而言，只需要把它的HighPart设置为0就可以了。

如果要直接访问某一个地址的物理内存，Windows CE提供了VirtualAlloc()和VirtualCopy()函数，VirtualAlloc负责在虚拟内存空间内保留一段虚拟内存，而VirtualCopy负责把一段物理内存和虚拟内存绑定，这样，最终对物理内存的访问还是通过虚拟地址进行。它们的声明如下：

// 申请虚拟内存

LPVOID VirtualAlloc(

 LPVOID lpAddress,     // 希望的虚拟内存起始地址

 DWORD dwSize,             // 以字节为单位的大小

 DWORD flAllocationType,  // 申请类型，分为Reserve和Commit

 DWORD flProtect           // 访问权限

);

// 把物理内存绑定到虚拟地址空间

BOOL VirtualCopy(

 LPVOID lpvDest,           // 虚拟内存的目标地址

 LPVOID lpvSrc,            // 物理内存地址

 DWORD cbSize,             // 要绑定的大小

 DWORD fdwProtect          // 访问权限

);

VirtualAlloc对虚拟内存的申请分为两步，保留MEM_RESERVE和提交MEM_COMMIT。其中MEM_RESERVE只是在进程的虚拟地址空间内保留一段，并不分配实际的物理内存，因此保留的虚拟内存并不能被应用程序直接使用。MEM_COMMIT阶段才真正的为虚拟内存分配物理内存。

下面的代码显示了如何使用VirtualAlloc和VirtualCopy来访问物理内存。因为VirtualCopy负责把一段物理内存和虚拟内存绑定，所以VirtualAlloc的时候只需要对内存保留，没有必要提交。

FpDriverGlobals =

(PDRIVER_GLOBALS) VirtualAlloc(

    0,

    DRIVER_GLOBALS_PHYSICAL_MEMORY_SIZE,

    MEM_RESERVE,

    PAGE_NOACCESS);

 if (FpDriverGlobals == NULL) {

    ERRORMSG(DRIVER_ERROR_MSG, (TEXT(" VirtualAlloc failed!\r\n")));

    return;

 }

 else {

    if (!VirtualCopy(

    (PVOID)FpDriverGlobals,

    (PVOID)(DRIVER_GLOBALS_PHYSICAL_MEMORY_START),

    DRIVER_GLOBALS_PHYSICAL_MEMORY_SIZE,

    (PAGE_READWRITE | PAGE_NOCACHE))) {

       ERRORMSG(DRIVER_ERROR_MSG, (TEXT("VirtualCopy failed!\r\n")));

       return;

    }

 }

CEDDK还提供了函数MmMapIoSpace用来把一段物理内存直接映射到虚拟内存。此函数的原形如下：

PVOID MmMapIoSpace(

 PHYSICAL_ADDRESS PhysicalAddress, // 起始物理地址

 ULONG NumberOfBytes,                  // 要映射的字节数

 BOOLEAN CacheEnable                   // 是否缓存

);

其实，MmMapIoSpace函数内部也是调用VirtualAlloc和VirtualCopy函数来实现物理地址到虚拟地址的映射的。MmMapIoSpace函数的原代码是公开的，我们可以从%_WINCEROOT%\PUBLIC\COMMON\OAK\DRIVERS\CEDDK\DDK_MAP\ddk_map.c得到。从MmMapIoSpace的实现我们也可以看出VirtualAlloc和VirtualCopy的用法：

PVOID MmMapIoSpace (

    IN PHYSICAL_ADDRESS PhysicalAddress,

    IN ULONG NumberOfBytes,

    IN BOOLEAN CacheEnable

    )

{

PVOID pVirtualAddress; ULONGLONG SourcePhys;

ULONG SourceSize; BOOL bSuccess;

    SourcePhys = PhysicalAddress.QuadPart & ~(PAGE_SIZE - 1);

    SourceSize = NumberOfBytes + (PhysicalAddress.LowPart & (PAGE_SIZE - 1));

    pVirtualAddress = VirtualAlloc(0, SourceSize, MEM_RESERVE, PAGE_NOACCESS);

    if (pVirtualAddress != NULL)

    {

        bSuccess = VirtualCopy(

            pVirtualAddress, (PVOID)(SourcePhys >> 8), SourceSize,

            PAGE_PHYSICAL | PAGE_READWRITE | (CacheEnable ? 0 : PAGE_NOCACHE));

        if (bSuccess) {

            (ULONG)pVirtualAddress += PhysicalAddress.LowPart & (PAGE_SIZE - 1);

        }

        else {

            VirtualFree(pVirtualAddress, 0, MEM_RELEASE);

            pVirtualAddress = NULL;

        }

    }

    return pVirtualAddress;

}

此外，Windows CE还供了AllocPhysMem函数和FreePhysMem函数，用来申请和释放一段连续的物理内存。函数可以保证申请的物理内存是连续的，如果函数成功，会返回虚拟内存的句柄和物理内存的起始地址。这对于DMA设备尤为有用。在这里就不详细介绍了，读者可以参考Windows CE的联机文档。

在程序中赋值：

my_function = 0x00;

然后调用函数：

my_function();

程序就会跳转到0x00地址开始执行，常用于BootLoader程序中．

类似的还有直接向某个地址写入数据：

int *my_address = 0x05555555;

*my_address = 0x22222222;

直接向0x05555555地址写入数据0x22222222.

　　(2) 第二个问题的答案也很简单：如果移动 n 位，那么移位的位数要不小于 0 ，并且一定要小于 n 。这样就不会在一次操作中把所有数据都移走。

　　比如，如果整型数据占 32 位，n 是一整型数据，则 n << 31 和 n << 0 都合法，而 n << 32 和 n << -1 都不合法。

　　注意即使腾空位填符号位，有符号整数的右移也不相当与除以。为了证明这一点，我们可以想一下 -1 >> 1 不可能为 0 。

　　问题：位段结构

struct RPR_ATD_TLV_HEADER
{
ULONG res1:6;
ULONG type:10;
ULONG res1:6;
ULONG length:10;
};

　　位段结构是一种特殊的结构, 在需按位访问一个字节或字的多个位时, 位结构比按位运算符更加方便。

　　位结构定义的一般形式为:

struct 位结构名 {
　数据类型 变量名: 整型常数 ;
　数据类型 变量名: 整型常数 ;
} 位结构变量;  

　　其中: 整型常数必须是非负的整数, 范围是0~15, 表示二进制位的个数, 即表示有多少位。

　　变量名是选择项, 可以不命名, 这样规定是为了排列需要。

　　例如: 下面定义了一个位结构。

struct{
　unsigned incon: 8; /*incon占用低字节的0~7共8位 */
　unsigned txcolor: 4;/*txcolor占用高字节的0~3位共4位 */
　unsigned bgcolor: 3;/*bgcolor占用高字节的4~6位共3位 */
　unsigned blink: 1; /*blink占用高字节的第7位 */
}ch;  

　　位结构成员的访问与结构成员的访问相同。

　　例如: 访问上例位结构中的bgcolor成员可写成:

ch.bgcolor  

　　位结构成员可以与其它结构成员一起使用。按位访问与设置，方便&节省

　　例如:

struct info{
　 char name[8];
　 int age;
　 struct addr address;
　 float pay;
　 unsigned state: 1;
　 unsigned pay: 1;
}workers;'  

　　上例的结构定义了关于一个工从的信息。其中有两个位结构成员, 每个位结构成员只有一位, 因此只占一个字节但保存了两个信息, 该字节中第一位表示工人的状态, 第二位表示工资是否已发放。由此可见使用位结构可以节省存贮空间。

　　注意不要超过值限制

　　问题：字节对齐

　　我在使用VC编程的过程中，有一次调用DLL中定义的结构时，发觉结构都乱掉了，完全不能读取正确的值，后来发现这是因为DLL和调用程序使用的字节对齐选项不同，那么我想问一下，字节对齐究竟是怎么一回事？

　　答案与分析：

　　关于字节对齐：

　　1、 当不同的结构使用不同的字节对齐定义时，可能导致它们之间交互变得很困难。

　　2、 在跨CPU进行通信时，可以使用字节对齐来保证唯一性，诸如通讯协议、写驱动程序时候寄存器的结构等。

　　三种对齐方式：

　　1、 自然对齐方式（Natural Alignment）：与该数据类型的大小相等。

　　2、 指定对齐方式 ：

#pragma pack(8) // 指定Align为 8；
#pragma pack() // 恢复到原先值

　　3、 实际对齐方式：

Actual Align = min ( Order Align, Natual Align )

　　对于复杂数据类型（比如结构等）：实际对齐方式是其成员最大的实际对齐方式：

Actual Align = max( Actual align1,2,3，…)

　　编译器的填充规律：

　　1、 成员为成员Actual Align的整数倍，在前面加Padding。

　　成员Actual Align = min( 结构Actual Align，设定对齐方式)

　　2、 结构为结构Actual Align的整数倍，在后面加Padding.

　　例子分析：

#pragma pack(8) // 指定Align为 8
struct STest1
{
char ch1;
long lo1;
char ch2;
} test1;
#pragma pack()

　　现在

Align of STest1 = 4 , sizeof STest1 = 12 ( 4 * 3 )

　　test1在内存中的排列如下（ FF 为 padding ）：

00 -- -- -- 04 -- -- -- 08 -- -- -- 12 -- -- --
01 FF FF FF 01 01 01 01 01 FF FF FF
ch1 -- lo1 -- ch2
#pragma pack(2) // 指定Align为 2
struct STest2
{
char ch3;
STest1 test;
} test2;
#pragma pack()

　　现在 Align of STest1 = 2, Align of STest2 = 2 , sizeof STest2 = 14 ( 7 * 2 )

　　test2在内存中的排列如下：

00 -- -- -- 04 -- -- -- 08 -- -- -- 12 -- -- --
02 FF 01 FF FF FF 01 01 01 01 01 FF FF FF
ch3 ch1 -- lo1 -- ch2

　　注意事项：

　　1、 这样一来，编译器无法为特定平台做优化，如果效率非常重要，就尽量不要使用#pragma pack，如果必须使用，也最好仅在需要的地方进行设置。

　　2、 需要加pack的地方一定要在定义结构的头文件中加，不要依赖命令行选项，因为如果很多人使用该头文件，并不是每个人都知道应该pack。这特别表现在为别人开发库文件时，如果一个库函数使用了struct作为其参数，当调用者与库文件开发者使用不同的pack时，就会造成错误，而且该类错误很不好查。

　　3、 在VC及BC提供的头文件中，除了能正好对齐在四字节上的结构外，都加了pack，否则我们编的Windows程序哪一个也不会正常运行。

　　4、 在 #pragma pack(n) 后一定不要include其他头文件，若包含的头文件中改变了align值，将产生非预期结果。

　　5、 不要多人同时定义一个数据结构。这样可以保证一致的pack值。

　　问题：按位运算符

　　C语言和其它高级语言不同的是它完全支持按位运算符。这与汇编语言的位操作有些相似。 C中按位运算符列出如下:

━━━━━━━━━━━━━━━━━━━━━━━━━━━━
操作符 作用
────────────────────────────
& 位逻辑与
| 位逻辑或
^ 位逻辑异或
- 位逻辑反
>> 右移
<< 左移
━━━━━━━━━━━━━━━━━━━━━━━━━━━━

　　注意：

　　1、 按位运算是对字节或字中的实际位进行检测、设置或移位, 它只适用于字符型和整数型变量以及它们的变体, 对其它数据类型不适用。

　　2、 关系运算和逻辑运算表达式的结果只能是1或0。 而按位运算的结果可以取0或1以外的值。要注意区别按位运算符和逻辑运算符的不同, 例如, 若x=7, 则x&&8 的值为真(两个非零值相与仍为非零), 而x&8的值为0。

　　3、 | 与 ||，&与&&，~与! 的关系

　　&、| 和 ~ 操作符把它们的操作数当作一个为序列，按位单独进行操作。比如：10 & 12 = 8，这是因为"&"操作符把 10 和 12 当作二进制描述 1010 和 1100 ，所以只有当两个操作数的相同位同时为 1 时，产生的结果中相应位才为 1 。同理，10 | 12 = 14 ( 1110 )，通过补码运算，~10 = -11 ( 11...110101 )。<以多少为一个位序列> &&、|| 和！操作符把它们的操作数当作"真"或"假"，并且用 0 代表"假"，任何非 0 值被认为是"真"。它们返回 1 代表"真"，0 代表"假"，对于"&&"和"||"操作符，如果左侧的操作数的值就可以决定表达式的值，它们根本就不去计算右侧的操作数。所以，!10 是 0 ，因为 10 非 0 ；10 && 12 是 1 ，因为 10 和 12 均非 0 ；10 || 12也是 1 ，因为 10 非 0 。并且，在最后一个表达式中，12 根本就没被计算，在表达式 10 || f( ) 中也是如此。

一．系统环境 2
二．gSOAP的简要使用例子 2
三．图示说明 6
四．要注意的问题 6
五．参考文档 7
六．备注 7

一．系统环境
linux操作系统kernel2.4.2，安装gsoap2.6到目录/usr/local/gsoap
二．gSOAP的简要使用例子
下面是一个简单的例子，实现一个加法运算的WebService，具体功能是cli端输入num1和num2，server端返回一个num1和num2相加的结果sum。

1． 首先，我们需要做的是写一个函数声明文件，来定义接口函数ns__add，文件名字为add.h，内容如下：

//gsoap ns service name: add
//gsoap ns service namespace: http://mail.263.net/add.wsdl
//gsoap ns service location: http://mail.263.net
//gsoap ns service executable: add.cgi
//gsoap ns service encoding: encoded
//gsoap ns schema namespace: urn:add

int ns__add( int num1, int num2, int* sum );

2． 然后我们需要创建文件Makefile，从而利用gsoapcpp2工具由add.h生成一些.xml文件、.c文件和.h文件，这些文件均为自动生成，Makefile的内容如下：

GSOAP_ROOT=/usr/local/gsoap
WSNAME=add
CC=g++ -g -DWITH_NONAMESPACES
INCLUDE=-I $(GSOAP_ROOT)
SERVER_OBJS=$(WSNAME)C.o $(WSNAME)Server.o stdsoap2.o
CLIENT_OBJS=$(GSOAP_ROOT)/env/envC.o $(WSNAME)ClientLib.o stdsoap2.o
ALL_OBJS=${WSNAME}server.o $(WSNAME)C.o $(WSNAME)Server.o ${WSNAME}test.o ${WSNAME}client.o $(WSNAME)ClientLib.o

#总的目标
all:server

${WSNAME}.wsdl:${WSNAME}.h
$(GSOAP_ROOT)/soapcpp2 -p$(WSNAME) -i -n -c ${WSNAME}.h

stdsoap2.o:$(GSOAP_ROOT)/stdsoap2.c
$(CC) -c $?

#编译一样生成规则的.o文件
$(ALL_OBJS):%.o:%.c
$(CC) -c $? $(INCLUDE)

#编译服务器端
server:Makefile ${WSNAME}.wsdl ${WSNAME}server.o $(SERVER_OBJS)
$(CC) ${WSNAME}server.o $(SERVER_OBJS) -o ${WSNAME}server

#编译客户端
client:Makefile ${WSNAME}.wsdl ${WSNAME}client.c ${WSNAME}test.c $(ALL_OBJS) stdsoap2.o
$(CC) ${WSNAME}test.o ${WSNAME}client.o $(CLIENT_OBJS) -o ${WSNAME}test

cl:
rm -f *.o *.xml *.a *.wsdl *.nsmap $(WSNAME)H.h $(WSNAME)C.c $(WSNAME)Server.c $(WSNAME)Client.c $(WSNAME)Stub.* $(WSNAME)$(WSNAME)Proxy.* $(WSNAME)$(WSNAME)Object.* $(WSNAME)ServerLib.c $(WSNAME)ClientLib.c $(WSNAME)server ns.xsd $(WSNAME)test

3．我们先来做一个server端，创建文件addserver.c文件，内容如下：

#include "addH.h"
#include "add.nsmap"

int main(int argc, char **argv)
{
int m, s; /* master and slave sockets */
struct soap add_soap;
soap_init(&add_soap);
soap_set_namespaces(&add_soap, add_namespaces);
if (argc < 2)
{
printf("usage: %s <server_port> \n", argv[0]);
exit(1);
}
else
{
m = soap_bind(&add_soap, NULL, atoi(argv[1]), 100);
if (m < 0)
{
soap_print_fault(&add_soap, stderr);
exit(-1);
}
fprintf(stderr, "Socket connection successful: master socket = %d\n", m);
for ( ; ; )
{
s = soap_accept(&add_soap);
if (s < 0)
{
soap_print_fault(&add_soap, stderr);
exit(-1);
}
fprintf(stderr, "Socket connection successful: slave socket = %d\n", s);
add_serve(&add_soap);//该句说明该server的服务
soap_end(&add_soap);
}
}
return 0;
}
//server端的实现函数与add.h中声明的函数相同，但是多了一个当前的soap连接的参数
int ns__add(struct soap *add_soap, int num1, int num2, int *sum)
{
*sum = num1 + num2;
return 0;
}

4．让我们的server跑起来吧：
shell>make
shell>./addserver 8888
如果终端打印出“Socket connection successful: master socket = 3”，那么你的server已经在前台run起来了，应该是值得高兴的&#61514;。
打开IE，键入http://本机IP:8888，显示XML，服务已经启动，终端打印出“Socket connection successful: slave socket = 4”，表示服务接收到了一次soap的连接。

5．让我们再来写个客户端（这个只是将soap的客户端函数封装一下，具体的调用参见下面的addtest.c），创建文件addclient.c，内容如下：

#include "addStub.h"
#include "add.nsmap"
/**
* 传入参数：server：server的地址
* num1,num2：需要相加的数
* 传出参数：sum：num1和num2相加的结果
* 返回值：0为成功，其他为失败
*/
int add( const char* server, int num1, int num2, int *sum )
{
struct soap add_soap;
int result = 0;
soap_init(&add_soap);
soap_set_namespaces(&add_soap, add_namespaces);

//该函数是客户端调用的主要函数，后面几个参数和add.h中声明的一样，前面多了3个参数，函数名是接口函数名ns__add前面加上soap_call_
soap_call_ns__add( &add_soap, server, "", num1, num2, sum );
if(add_soap.error)
{
printf("soap error:%d,%s,%s\n", add_soap.error, *soap_faultcode(&add_soap), *soap_faultstring(&add_soap) );
result = add_soap.error;
}
soap_end(&add_soap);
soap_done(&add_soap);
return result;
}

6．我们最终写一个可以运行的客户端调用程序，创建文件addtest.c，内容如下：

#include <stdio.h>
#include <stdlib.h>

int add(const char* server, int num1, int num2, int *sum);

int main(int argc, char **argv)
{
int result = -1;
char* server="http://localhost:8888";
int num1 = 0;
int num2 = 0;
int sum = 0;
if( argc < 3 )
{
printf("usage: %s num1 num2 \n", argv[0]);
exit(0);
}

num1 = atoi(argv[1]);
num2 = atoi(argv[2]);

result = add(server, num1, num2, &sum);
if (result != 0)
{
printf("soap err,errcode = %d\n", result);
}
else
{
printf("%d+%d=%d\n", num1, num2, sum );
}
return 0;
}

7．让我们的client端和server端通讯
shell>make client
shell>./addtest 7 8
当然，你的server应该还在run，这样得到输出结果7+8=15，好了，你成功完成了你的第一个C写的WebService，恭喜。
三．图示说明

四．要注意的问题
1． add.h文件前面的几句注释不能删除，为soapcpp2需要识别的标志
2． 接口函数的返回值只能是int，是soap调用的结果，一般通过soap.error来判断soap的连接情况，这个返回值没有用到。
3． 接口函数的最后一个参数为传出参数，如果需要传出多个参数，需要自己定义一个结构将返回项封装。
4． 在.h文件中不能include别的.h文件，可能不能生效，需要用到某些结构的时候需要在该文件中直接声明。
5． 如果客户端的调用不需要返回值，那么最后一个参数
五．参考文档
1．gsoap主页
http://gsoap2.sourceforge.net

2．跟我一起写Makefile
http://dev.csdn.net/develop/article/20/20025.shtm

3．Web Services： A Technical Introduction（机械工业出版社）
六．备注
192.168.18.233和192.168.18.234的/usr/local/gsoap目录下的3个需要的文件及一个env目录，不是编译安装的，是在别的地方编译好了直接copy过来的（实际编译结果中还有wsdl2h工具及其他一些文件，但是我们的实际开发中只是用到了这3个文件及env目录）。因为时间仓促，本人还没有时间研究编译的问题，相关细节可以查看参考文档1。
在192.168.18.233的/home/weiqiong/soap/sample目录下及192.168.18.234的/tmp/soap/sample目录下有本文讲到的加法运算的例子。

  event_set_pstn_ring,
  event_set_sip_ring,
  event_set_alarm_ring,
  event_set_ring_volume
  
};

typedef struct msgbuf
{
 long   msgtype;
 unsigned long msgid;
 unsigned long lp;
 unsigned long wp;
}MSGBuf, *pMSGBuf;

int vvMSGSend(long thread_id, unsigned long msgid, unsigned long lp, unsigned long wp);
int vvMSGRecv(long thread_id, struct msgbuf *msg, int is_wait);

#ifndef _WINDOWS

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <unistd.h>

#define MSG_FILE_NAME    "/rw/"      //"/mnt/"
#define MSG_FLAG   (IPC_CREAT  | 00666)
//| IPC_EXCL
 

typedef struct sendMsg
{
 int sd;
 void *content;
}SendMsg, *pSendMsg;

#endif

#endif //MSG_H





#include "vvmsg.h"
#include <ps_log.h>

#ifndef _WINDOWS
#include <phone_Interface.h>
#include <pthread.h>
#include <basegdi.h>
#include <keyboard.h>
//#include "hash.h"
extern  pthread_t g_incomingthread;
//extern  hash_table table;
#endif

int vvMSGSend(long thread_id, unsigned long msgid, unsigned long lp, unsigned long wp)
{ 
 struct msgbuf bmsg;
#ifndef _WINDOWS
 key_t key;

 int msg_id;
 bmsg.msgtype = thread_id;
 bmsg.msgid = msgid;
 bmsg.lp = lp;
 bmsg.wp = wp;

 if((key = ftok(MSG_FILE_NAME,'a')) == -1)
 {
  return -1;
 }

 if((msg_id = msgget(key,MSG_FLAG)) == -1)
 {
  return -1;
 }

 if (msgsnd(msg_id, &bmsg, sizeof(struct msgbuf), IPC_NOWAIT) == -1)
 {
  return -1;
 }
#endif
 return 1;

}

int vvMSGRecv(long thread_id, struct msgbuf *msg, int is_wait)
{
 #ifndef _WINDOWS
 key_t key;  
 int msg_id;
 if((key = ftok(MSG_FILE_NAME,'a')) == -1)
 {
  printf("Recv msg error 1!\n");
  return -1;
 }
 if((msg_id = msgget(key,MSG_FLAG)) == -1)
 {
  printf("Recv msg error 2!\n");
  return -1;
 }
 if (is_wait != 1)
 {
  if (msgrcv(msg_id, msg, sizeof(struct msgbuf), thread_id, IPC_NOWAIT) == -1)
  {
   printf("Recv msg error 3!\n");
   return -1;
  } 
 }
 else
 {
  if (msgrcv(msg_id, msg, sizeof(struct msgbuf), thread_id, 0) == -1)
  {
   //printf("Recv msg error 4!\n");
   return -1;
  }
 }
  #endif
 return 1;

}

void *skype_thread_start(void *arg)
{
 #ifndef _WINDOWS
 MSGBuf msg;
 pthread_setcancelstate(PTHREAD_CANCEL_ENABLE,0);//设置线程属性
 pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS,0);
 for (;;)
 {
  pthread_testcancel();//设置取消点
  if (vvMSGRecv((long)g_incomingthread, &msg, 1) == -1)
   continue;
  
  // analysis the message
  switch (msg.msgid)
  {
   ps_show_str(log_DEBUG, "vvmsg event!!!!!!!!!!!!!!!%d\r\n", msg.msgid);
  case event_login:
   {
    userLogin();
    
   }
   break;
  case event_logout:
   {
    userLogout();
   }
  case event_sip_clean:
   {
    SipClean();
   }
   break;
  case event_sip_init_para:
   {
    ps_show_str(log_DEBUG, "event before################UpdateSipInitPara\r\n");
    UpdateSipInitPara();
    ps_show_str(log_DEBUG, "event after##################UpdateSipInitPara\r\n");
   }
   break;
  case event_log_init_para:
   {
    UpdateLogInitPara();
   }
   break;
  case event_set_dtmf_mode:
   {
    int i = (int)msg.lp;
    ps_show_str(log_DEBUG, "event_set_dtmf_mode########################%d\r\n", i);
    SetDTMFMode(i);
   }
   break;
  case event_set_dhcp:
   {
    SetDHCP();
   }
   break;
  case event_set_pppoe:
   {
    SetPPPOE();
   }
   break;

  case event_pstn_call_out:
   {
    pstncall((char*)msg.lp);
   }
   break;
  case event_sip_call_out:
   {
    
    sipcall((char*)msg.lp);
   }
   break;

  case event_answer_sipcall:
   {
    callmgr_answercall((LINE_ID_T *)msg.lp);
   }
   break;
        case event_release_sipcall:
   {
    callmgr_releasecall((LINE_ID_T *)msg.lp);
   }
   break;
  case event_loadBMP_init:
   {
    CreateSysBmp();
    
   }
   break;
   

  case event_pstn_call_in:
   {
    LINE_ID_T *line = (LINE_ID_T *)msg.wp;
    sipcome_create(line);
   }
   break;
  case event_sip_call_in:
   {
    LINE_ID_T *line = (LINE_ID_T *)msg.wp;
    sipcome_create(line);
   }
   break;
 
  case event_remote_establish_call:
   {
    
    LINE_ID_T *line = (LINE_ID_T *)msg.wp;
    pstnchat_create(line);
    if(g_Hwnd[HWND_CALLOUT]!=0)
    calling_destroy(g_Hwnd[HWND_CALLOUT]);
    
   }
   break;
  case event_remote_cancelcall:
   {
    if(g_Hwnd[HWND_CALLIN]!=0)
   SendMessage(g_Hwnd[HWND_CALLIN],MSG_KEYDOWN,KEY_SW_RSK,0);
   }
   break;
  case event_remote_release_call:
   {
    if(g_Hwnd[HWND_CHAT]!=0)
    SendMessage(g_Hwnd[HWND_CHAT],MSG_KEYDOWN,KEY_SW_RSK,0);
   }
   break;
  case event_login_return:
   {
    printf("sfds0000000000000000000000000000000dssssssss^^^^^^^^^^^^^^^^^\r\n");
    if(g_Hwnd[HWND_MAINSCREEN]!=0)
    {
     UpdateWindow(g_Hwnd[HWND_MAINSCREEN],1);
    // SetFocusChild(g_Hwnd[HWND_MAINSCREEN]);
    // ShowWindow(g_Hwnd[HWND_MAINSCREEN], SW_SHOW);
    }
   }
   break;
  case event_remote_ignore:
   {
    if(g_Hwnd[HWND_CALLOUT]!=0)
    SendMessage(g_Hwnd[HWND_CALLOUT],MSG_KEYDOWN,KEY_SW_RSK,0); 
   }
   break;
  case event_set_pstn_ring:
   {
    SetPstnRing((int)msg.lp);
   }
   break;
  case event_set_sip_ring:
   {
    SetSipRing((int)msg.lp);
   }
   break;
  case event_set_ring_volume:
   {
    SetRingVolume((int)msg.lp);
   }
   break;
  }

 }
 #endif
}

附（创建线程）：if (pthread_create(&g_incomingthread, NULL, skype_thread_start, NULL))
  return -1;

static void strtoupper(char *p)
{
 int i;
 int j=strlen(p);
 for(i=0;i<j;i++)
  {
 *p=toupper(*p);
 p++;
 }
};
int main( void )
{
 
 
 int fd;
 DIR * dir;
 struct dirent * ent;
 
 char *p1;
 char *p2;
 char temp[255];
 char lower[50];
 memset(temp,0,sizeof(temp));
 memset(lower,0,sizeof(lower));
 
 
 if(!(dir=opendir("/opt/sip_ui/res/."))){ //目录
 perror("opendir");
 return;
 }
 errno=0;
 

 if((fd=open("hw",O_TRUNC|O_CREAT|O_WRONLY,0644))<0){
 perror("open");
 exit(1); 
 }
 
 while((ent=readdir(dir))){
  
 if(strstr(ent->d_name,".bmp")){ //后缀名
 p1=strtok(ent->d_name,".");
 p2=strtok(NULL,".");
 memcpy(lower,p1,strlen(p1));
 lower[strlen(p1)]='\0';
 strtoupper(p1);
 strtoupper(p2);
 
  strcat(p1,"_PIC");
 //strcat(p1,p2);
 
 sprintf(temp,"#define %s \"res\" PATH_SEP \"%s.\" RESFILE_EXT\n",p1,lower);
 
      
     

 if(write(fd,temp,strlen(temp)) < 0){
 perror("write");
 exit(1);
 }
 }
 errno=0;
 }
 if(errno)
 {
 perror("readdir");
 return ;
 }
 
 close(fd);
 closedir(dir);
 return 1;
}