共享跨越进程边界内核对象的方法?
来源:互联网 发布:淘宝客服外包合算吗 编辑:程序博客网 时间:2024/05/16 16:54
许多情况下,在不同进程中运行的线程需要共享内核对象。下面是为何需要共享的原因: • 文件映射对象使你能够在同一台机器上运行的两个进程之间共享数据块。 • 邮箱和指定的管道使得应用程序能够在连网的不同机器上运行的进程之间发送数据块。 • 互斥对象、信标和事件使得不同进程中的线程能够同步它们的连续运行,这与一个应用程序在完成某项任务时需要将情况通知另一个应用程序的情况相同。
由于内核对象句柄与进程相关,因此这些任务的执行情况是不同的。不过,M i c r o s o f t 公司有若干很好的理由将句柄设计成与进程相关的句 柄。最重要的理由是要实现它的健壮性。如果内核对象句柄是系统范围的值,那么一个进程就能很容易获得另一个进程使用的对象的句柄,从而对该 进程造成很大的破坏。另一个理由是安全性。内核对象是受安全性保护的,进程在试图操作一个对象之前,首先必须申请获得操作该对象的许可权。 对象的创建人只需要拒绝向用户赋予许可权,就能防止未经授权的用户接触该对象。
在下面的各节中,将要介绍允许进程共享内核对象的3 个不同的机制。
3.3.1 对象句柄的继承性
只有当进程具有父子关系时,才能使用对象句柄的继承性。在这种情况下,父进程可以使用一个或多个内核对象句柄,并且该父进程可以决定生成一 个子进程,为子进程赋予对父进程的内核对象的访问权。若要使这种类型的继承性能够实现,父进程必须执行若干个操作步骤。
首先,当父进程创建内核对象时,必须向系统指明,它希望对象的句柄是个可继承的句柄。请记住,虽然内核对象句柄具有继承性,但是内核对象本 身不具备继承性。
若要创建能继承的句柄,父进程必须指定一个S E C U R I T Y _ AT T R I B U T E S 结构并对它进行初始化,然后将该结构的地址传递给特定的C r e a t e 函数。下面的代码用于创建一个互斥对象,并将一个可继承的句柄返回给它:
SECURITY_ATTRIBUTES sa; sa.nLength = sizeof(sa); sa.lpSecuntyDescriptor = NULL; //Make the returned handle inheritable. sa.bInheritHandle =- TRUE; HANDLE hMutex = CreateMutex(&sa, FALSE, NULL);
Windows 98 尽管Windows 98 不拥有完整的对安全性的支持,但是它却支持继承性,因此,Windows 98 能够正确地使用b I n h e r i t H a n d l e 成员的值。
现在介绍存放在进程句柄表项目中的标志。每个句柄表项目都有一个标志位,用来指明该句柄是否具有继承性。当创建一个内核对象时,如果传递N U L L 作为P S E C U R I T Y _ AT T R I B U T E S 的参数,那么返回的句柄是不能继承的,并且该标志位是0 。如果将b I n h e r i t H a n d l e 成员置为T R U E ,那么该标志位将被置为1 。
表3 - 2 显示了一个进程的句柄表。
表3-2 包含两个有效项目的进程句柄表
表3 - 2 表示该进程拥有对两个内核对象(句柄1 和3 )的访问权。句柄1 是不可继承的,而句柄3 是可继承的。
使用对象句柄继承性时要执行的下一个步骤是让父进程生成子进程。这要使用C r e a t eP r o c e s s 函数来完成:
BOOL CreateProcess( PCTSTR pszApplicationName, PTSTR pszCommandLine, PSECURITY_ATTRIBUTES psaProcess, PSECURITY_ATTRIBUTES psaThread, BOOL bInheritHandles, DWORD fdwCreale, PVOIO pvEnvironment, PCTSTR pszCurDir, PSTARTUPINFO psiStartInfo, PPROCESS_INFORMATION ppiProcInfo);
但是,如果为该参数传递T R U E ,那么子进程就可以继承父进程的可继承句柄值。当传递T R U E 时,操作系统就创建该新子进程,但是不允许子 进程立即开始执行它的代码。当然,系统为子进程创建一个新的和空的句柄表,就像它为任何新进程创建句柄表那样。不过,由于将T R U E 传递给 了C r e a t e P r o c e s s 的b I n h e r i t H a n d l e s 参数,因此系统要进行另一项操作,即它要遍历父进程的句柄表,对于它找到的 包含有效的可继承句柄的每个项目,系统会将该项目准确地拷贝到子进程的句柄表中。该项目拷贝到子进程的句柄表中的位置将与父进程的句柄表中 的位置完全相同。这个情况非常重要,因为它意味着在父进程与子进程中,标识内核对象所用的句柄值是相同的。
除了拷贝句柄表项目外,系统还要递增内核对象的使用计数,因为现在两个进程都使用该对象。如果要撤消内核对象,那么父进程和子进程必须调用 该对象上的C l o s e H a n d l e 函数,也可以终止进程的运行。子进程不必首先终止运行,但是父进程也不必首先终止运行。实际上,C r e a t e P r o c e s s 函数返回后,父进程可以立即关闭对象的句柄,而不影响子进程对该对象进行操作的能力。
表3 - 3 显示了子进程被允许运行前该进程的句柄表。可以看到,项目1 和项目2 尚未初始化,因此是个无效句柄,子进程是无法使用的。但是,项 目3 确实标识了一个内核对象。实际上,它标识的内核对象的地址是0 x F 0 0 0 0 0 1 0 ,这与父进程的句柄表中的对象地址相同。访问屏蔽与父进程中的屏蔽相同,两者的标志也相同。这意味着如果该子进程要生成它自己的子进程(即父进程的孙进程),该孙进程也将继承与该内核对象句 柄相同的句柄值、同样的访问权和相同的标志,同时,对象的使用计数再次被递增。
表3-3 继承父进程的可继承句柄后的子进程句柄表
对象句柄的继承性有一个非常奇怪的特征,那就是当使用它时,子进程不知道它已经继承了任何句柄。只有在另一个进程生成子进程时记录了这样一个情况,即它希望被赋予对内核对象的访问权时,才能使用内核对象句柄的继承权。通常,父应用程序和子应用程序都是由同一个公司编写的,但是,如果另一个公司记录了子应用程序期望的对象,那么该公司也能够编写子应用程序。
子进程为了确定它期望的内核对象的句柄值,最常用的方法是将句柄值作为一个命令行参数传递给子进程,该子进程的初始化代码对命令行进行分析(通常通过调用s s c a n f 函数来进行分析),并取出句柄值。一旦子进程拥有该句柄值,它就具有对该对象的无限访问权。请注意,句柄继承权起作用的唯一原因是,父进程和子进程中的共享内核对象的句柄值是相同的,这就是为什么父进程能够将句柄值作为命令行参数来传递的原因。
当然,可以使用其他形式的进程间通信,将已继承的内核对象句柄值从父进程传送给子进程。方法之一是让父进程等待子进程完成初始化(使用第9 章介绍的Wa i t F o r I n p u I d l e 函数),然后,父进程可以将一条消息发送或展示在子进程中的一个线程创建的窗口中。
另一个方法是让父进程将一个环境变量添加给它的环境程序块。该变量的名字是子进程知道要查找的某种信息,而变量的值则是内核对象要继承的值。这样,当父进程生成子进程时,子进程就继承父进程的环境变量,并且能够非常容易地调用G e t E n v i r o n m e n t Va r i a b l e 函数,以获取被继承对象的句柄值。如果子进程要生成另一个子进程,那么使用这种方法是极好的,因为环境变量可以被再次继承。
3.3.2 改变句柄的标志
有时会遇到这样一种情况,父进程创建一个内核对象,以便检索可继承的句柄,然后生成两个子进程。父进程只想要一个子进程来继承内核对象的句柄。换句话说,有时可能想要控制哪个子进程来继承内核对象的句柄。若要改变内核对象句柄的继承标志,可以调用S e t H a n d l e I n f o r m a t i o n 函数:
BOOL SetHandleInformation( HANDLE hObject, DWORD dwMask, DWORD dwFlags);
#define HANDLE FLAG_INHERIT 0x00000001 #define HANDLE FLAG PROTECT FROM CLOSE 0x00000002
SetHandleInformation(hobj, HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT);
SetHandleInformation(hobj, HANDLE_FLAG_INHERIT, 0);
SetHandleInformation(hobj, HANDLE_FLAG_PROTECT_FROM_CLOSE, HANDLE_FLAG_PROTECT_FROM_CLOSE); CloseHandle(hobj); //Exception is raised
但是这种处理方法有一个问题。子进程可以调用下面的代码来关闭H A N D L E _ F L A G _P R O T E C T _ F R O M _ C L O S E 标志,然后关闭句柄。
SetHandleInformation(hobj, HANDLEMFLAG_PROlECl_FROM_CLOSE, 0); CloseHandle(hobj);
为了完整地说明问题,也要讲一下G e t H a n d l e I n f o r m a t i o n 函数的情况:
BOOL GetHandleInformation( HANDLE hObj, PDWORD pdwFlags);
DWORD dwFlags; GetHandleInformation(hObj, &dwFlags); BOOL fHandleIsInheritable = (0 != (dwFlags & HANDLE_FLAG_INHERIT));
共享跨越进程边界的内核对象的第二种方法是给对象命名。许多(虽然不是全部)内核对象都是可以命名的。例如,下面的所有函数都可以创建命名的内核对象:
HANDLE CreateMutex( PSLCURITY_ATTRIBUTES psa, BOOL bInitialOwner, PCTSTR pszName);HANDLE CreateEvent( PSECURITY_ATTRIBUTES psa, BOOL bManualReset, BOOL bInitialState, PCTSTR pszName);HANDLE CreateSemaphore( PSECURITY_ATTRIBUTES psa, LONG lInitialCount, LONG lMaximumCount, PCTSTR pszNarne);HANDLE CreateWaitableTimer( PSLCURITY_ATTRIBUTES psa, BOOL bManualReset, PCTSTR pszName);HANDLE CreateFileMapping( HANDLE hFile, PSECURITY_ATTRIBUTES psa, DWORD flProtect, DWORD dwMaximumSizeHigh, DWORD dwMaximumSizeLow, PCTSTR pszName);HANDLE CreateJobObject( PSECURITY_ATTRIBUTES psa, PCTSTR pszName);
如果没有为p s z N a m e 参数传递M U L L ,应该传递一个以0 结尾的字符串名字的地址。该名字的长度最多可以达到M A X _ PAT H (定义为2 6 0 )个字符。但是,M i c r o s o f t 没有提供为内核对象赋予名字的指导原则。例如,如果试图创建一个称为“J e ff O b j ”的对象,那么不能保证系统中不存在一个名字为“J e ff O b j ”的对象。更为糟糕的是,所有这些对象都共享单个名空间。由于这个原因,对下面这个C r e a t e S e m a p h o r e 函数的调用将总是返回N U L L :
HANDLE hMutex = CreateMutex(NULL. FALSE, "JeffObj");HANDLE hSem = CreateSemaphore(NULL, 1, 1, "JeffObj");DWORD dwErrorCode = GetLastError();
既然已知道如何给对象命名,那么让我们来看一看如何用这种方法来共享对象。比如说,Process A 启动运行,并调用下面的函数:
HANDLE hMutexPronessA = CreateMutex(NULL, FALSE, "JeffMutex");
过些时候,某个进程会生成Process B 。Process B 不一定是Process A 的子进程。它可能是E x p l o r e r 或其他任何应用程序生成的进程。Process B 不必是Process A 的子进程这一事实正是使用命名对象而不是继承性的优越性。当Process B 启动运行时,它执行下面的代码:
HANDLE hMutexProcessB = CreateMutex(NULL, FALSE, "JeffMutex");
注意当你的多个内核对象拥有相同的名字时,有一个非常重要的细节必须知道。当Process B 调用C r e a t e M u t e x 时,它将安全属性信息和第二个参数传递给该函数。如果已经存在带有指定名字的对象,那么这些参数将被忽略。应用程序能够确定它是否确实创建了一个新内核对象,而不是打开了一个现有的对象。方法是在调用C r e a t e *函数后立即调用G e t L a s t E r r o r :
HANDLE hMutex = CreateMutex(&sa, FALSE, "JeffObj");if (GetLastError() == ERROR_ALREADY_EXISTS){ //Opened a handle to an existing object. //sa.lpSecurityDescriptor and the second parameter //(FALSE) are ignored}else{ //Created a brand new object. //sa.lpSecurityDescriptor and the second parameter //(FALSE) are used to construct the object.}
HANDLE OpenMutex( DWORD dwDesiredAccess, BOOL bInheritHandle, PCTSTR pszName);HANDLE OpenEvent( DWORD dwDesiredAccess, BOOL bInheritHandle, PCTSTR pszName);HANDLE OpenSemaphore( DWORD dwDesiredAccess, BOOL bInheritHandle, PCTSTR pszName),HANDLE OpenWaitableTimer( DWORD dwDesiredAccess, BOOL bInheritHandle, PCTSTR pszName);HANDLE OpenFileMapping( DWORD dwDesiredAccess, BOOL bInheritHandle, PCTSTR pszName);HANDLE Openjob0bject( DWORD dwDesiredAccess, BOOL bInheritHandle, PCTSTR pszName);
调用C r e a t e *函数与调用O p e n *函数之间的主要差别是,如果对象并不存在,那么C r e a t e *函数将创建该对象,而O p e n *函数则运行失败。
如前所述,M i c r o s o f t 没有提供创建唯一对象名的指导原则。换句话说,如果用户试图运行来自不同公司的两个程序,而每个程序都试图创建一个称为“M y O b j e c t ”的对象,那么这就是个问题。为了保证对象的唯一性,建议创建一个G U I D ,并将G U I D 的字符串表达式用作对象名。命名对象常常用来防止运行一个应用程序的多个实例。若要做到这一点,只需要调用m a i n 或Wi n M a i n 函数中C r e a t e *函数,以便创建一个命名对象(创建的是什么对象则是无所谓的)。当C r e a t e *函数返回时,调用G e t L a s t E r r o r 函数。如果G e t L a s t E r r o r 函数返回E R R O R _ A L R E A D Y _ E X I S T S ,那么你的应用程序的另一个实例正在运行,新实例可以退出。下面是说明这种情况的部分代码:
int WINAPI WinMain(HINSTANCE hinstExe, HINSTANCE, PSTR pszCmdLine, int nCmdShow){ HANDLE h = CreateMutex(NULL, FALSE, "{FA531CC1-0497-11d3-A180-00105A276C3E}"); lf (GetLastError() == ERROR_ALREADY_EXISTS) { //There is already an instance //of the application running return(0), } //This is the first instance of this application running. //Before exiting ,close the object. CloseHandle(h), return(0);}
注意,终端服务器能够稍稍改变上面所说的情况。终端服务器拥有内核对象的多个名字空间。如果存在一个可供内核对象使用的全局名字空间,就意味着它可以供所有的客户程序会话访问。该名字空间主要供服务程序使用。此外,每个客户程序会话都有它自己的名字空间。它能防止运行相同应用程序的两个或多个会话之间出现互相干扰的情况,也就是说一个会话无法访问另一个会话的对象,尽管该对象拥有相同的名字。在没有终端服务器的机器上,服务程序和应用程序拥有上面所说的相同的内核对象名字空间,而在拥有终端服务器的机器上,却不是这样。
服务程序的名字空间对象总是放在全局名字空间中。按照默认设置,在终端服务器中,应用程序的命名内核对象将放入会话的名字空间中。但是,如果像下面这样将“G l o b a l /”置于对象名的前面,就可以使命名对象进入全局名字空间:
HANDLE h = CreateEvenL(NULL, FALSE, FALSE, "Global//MyName");
HANDLE h = CreateEvent(NULL, FALSE, FALSE, "Local//MyName");
3.3.5 复制对象句柄
共享跨越进程边界的内核对象的最后一个方法是使用D u p l i c a t e H a n d l e 函数:
BOOL DuplicateHandle( HANDLE hSourceProcessHandle, HANDLE hSourceHandle, HANDLE hTargetProcessHandle, PHANDLE phTargetHandle, DWORD dwDesiredAccess, BOOL bInheritHandle, DWORD dwOptions);
当调用D u p l i c a t e H a n d l e 函数时,第一和第三个参数h S o u r c e P r o c e s s H a n d l e 和h Ta rg e tP r o c e s s H a n d l e 是内核对象句柄。这些句柄本身必须与调用D u p l i c a t e H a n d l e 函数的进程相关。此外,这两个参数必须标识进程的内核对象。如果将句柄传递给任何其他类型的内核对象,那么该函数运行就会失败。第4 章将详细介绍进程的内核对象,而现在只需要知道,每当系统中启动一个新进程时都会创建一个进程内核对象。
第二个参数h S o u r c e H a n d l e 是任何类型的内核对象的句柄。但是该句柄值与调用D u p l i c a t eH a n d l e 的进程并无关系。相反,该句柄必须与h S o u r c e P r o c e s s H a n d l e 句柄标识的进程相关。第四个参数p h Ta rg e t H a n d l e 是H A N D L E 变量的地址,它将接收获取源进程句柄信息拷贝的项目索引。返回的句柄值与h Ta rg e t P r o c e s s H a n d l e 标识的进程相关。
D u p l i c a t e H a n d l e 的最后3 个参数用于指明该目标进程的内核对象句柄表项目中使用的访问屏蔽值和继承性标志。d w O p t i o n s 参数可以是0 (零),也可以是下面两个标志的任何组合:D U P L I C AT E _ S A M E _ A C C E S S 和D U P L I C AT E _ C L O S E _ S O U R C E 。
如果设定了D U P L I C AT E _ S A M E _ A C C E S S 标志,则告诉D u p l i c a t e H a n d l e 函数,你希望目标进程的句柄拥有与源进程句柄相同的访问屏蔽。使用该标志将使D u p l i c a t e H a n d l e 忽略它的d w D e s i r e d A c c e s s 参数。
如果设定了D U P L I C AT E _ C L O S E _ S O U R C E 标志,则可以关闭源进程中的句柄。该标志使得一个进程能够很容易地将内核对象传递给另一个进程。当使用该标志时,内核对象的使用计数不会受到影响。
下面用一个例子来说明D u p l i c a t e H a n d l e 函数是如何运行的。在这个例子中,Process S 是目前可以访问某个内核对象的源进程,Process T 是将要获取对该内核对象的访问权的目标进程。Process C 是执行对D u p l i c a t e H a n d l e 调用的催化进程。Process C 的句柄表(表3 - 4 )包含两个句柄值,即1 和2 。句柄值1 用于标识Process S 的进程内核对象,句柄值2 则用于标识Process T 的进程内核对象。
表3-4 Process C 的句柄表
表3-5 Process S 的句柄表
表3-6 调用D u p l i c a t e H a n d l e 函数之前Process T 的句柄表
表3-7 调用D u p l i c a t e H a n d l e 函数之后Process T 的句柄表
由于D U P L I C AT E _ S A M E _ A C C E S S 标志被传递给了D u p l i c a t e H a n d l e ,因此Process T 的句柄表中该句柄的访问屏蔽与Process S 的句柄表项目中的访问屏蔽是相同的。另外,传递D U P L I C AT E _ S A M E _ A C C E S S 标志将使D u p l i c a t e H a n d l e 忽略它的D e s i r e d A c c e s s 参数。最后请注意,继承位标志已经被打开,因为给D u p l i c a t e H a n d l e 的b I n h e r i t H a n d l e 参数传递的是T R U E 。
显然,你永远不会像在这个例子中所做的那样,调用传递硬编码数字值的D u p l i c a t e H a n d l e函数。这里使用硬编码数字,只是为了展示函数是如何运行的。在实际应用程序中,变量可能拥有各种不同的句柄值,可以传递该变量,作为函数的参数。
与继承性一样,D u p l i c a t e H a n d l e 函数存在的奇怪现象之一是,目标进程没有得到关于新内核对象现在可以访问它的通知。因此,Process C 必须以某种方式来通知Process T,它现在拥有对内核对象的访问权,并且必须使用某种形式的进程间通信方式,以便将h O b j 中的句柄值传递给Process T 。显然,使用命令行参数或者改变Process T 的环境变量是不行的,因为该进程已经启动运行。因此必须使用窗口消息或某种别的I P C 机制。
上面是D u p l i c a t e H a n d l e 的最普通的用法。如你所见,它是个非常灵活的函数。不过,它很少在涉及3 个不同进程的情况下被使用(因为Process C 不可能知道对象的句柄值正在被P r o c e s s使用)。通常,当只涉及两个进程时,才调用D u p l i c a t e H a n d l e 函数。比如一个进程拥有对另一个进程想要访问的对象的访问权,或者一个进程想要将内核对象的访问权赋予另一个进程。例如,Process S 拥有对一个内核对象的访问权,并且想要让Process T 能够访问该对象。若要做到这一点,可以像下面这样调用D u p l i c a t e H a n d l e :
//ALL of the following code is executed by Process S.//Create a mutex object accessible by Process S.HANDLE hObjProcessS = CreateMutex(NULL, FALSE, NULL);//Open a handle to Process T's kernel object.HANDLE hProcessT = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwProcessIdT);//An uninitilized handle relative to Process T.HANDLE hObjProcessT; //Give Process T accesss to our mutex objectDuplicateHandle(GetCurrentProcess(), hObjProcessS, hProcessT, &hObjProcessT, 0, FALSE, DUPLICATE_SAME_ACCESS);//Use some IPC mechanism to get the handle//value in hOnjProcess S into Process T//We no longer need to communicate with Process T.CloseHandle(hProcessT);//When Process S no longer needs to Use the mutex,//it should close it.CloseHandle(hObjProcessS);
//Process S should never attempt to close the duplicated handleCloseHandle(hObjProcessT);
下面是使用D u p l i c a t e H a n d l e 函数的另一种方法。假设一个进程拥有对一个文件映射对象的读和写访问权。在某个位置上,一个函数被调用,它通过读取文件映射对象来访问它。为了使应用程序更加健壮,可以使用D u p l i c a t e H a n d l e 为现有的对象创建一个新句柄,并确保这个新句柄拥有对该对象的只读访问权。然后将只读句柄传递给该函数,这样,该函数中的代码就永远不会偶然对该文件映射对象执行写入操作。下面这个代码说明了这个例子:
int WINAPI WinMain(HINSTANCE hinstExe, HINSTANCE, PSTR pszCmdLine, int nCmdShow){ //Create a file-mapping object; //the handle has read/write access. HANDLE hFileMapRW = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGF_READWRITE, 0, 10240, NULL); //Create anotherhandle to the file-mapping object; //the handle has read-only access. HANDLE hFileMapRO; DuplicateHandle(GetCurrentProcess(), hFileMapRW, GetCurrentProcess(), &hFileMdpRO, FILE_MAP_READ, FALSE, 0); //Call the function that should only read //from the mapping. ReadFromTheFileMapping(hFileMapRO); //Close the read-only file-mapping object. CloseHandle(hFileMapRO); //We can still read/write the file-mapping //object using hFileMapRW.When the main code //doesnot access the file mapping anymore CloseHandle(hFileMapRW);}
- 共享跨越进程边界内核对象的方法?
- 3.3 跨越进程边界共享内核对象
- 3.3 跨越进程边界共享内核对象
- 3.3 跨越进程边界共享内核对象
- 跨越进程边界共享内核对象
- 内核对象(2)之跨越边界进程共享内核对象
- windows笔记-跨越进程边界共享内核对象【命名对象】
- -跨越进程边界共享内核对象【复制对象句柄】
- -跨越进程边界共享内核对象【命名对象】
- 跨越进程边界共享内核对象【命名对象】
- 跨越进程边界共享内核对象【复制对象句柄】
- windows笔记-跨越进程边界共享内核对象【对象句柄的继承性】
- -跨越进程边界共享内核对象【对象句柄的继承性】
- windows笔记-跨越进程边界共享内核对象【对象句柄的继承性】
- windows笔记-跨越进程边界共享内核对象【对象句柄的继承性】
- windows笔记-跨越进程边界共享内核对象【复制对象句柄】
- windows笔记-跨越进程边界共享内核对象【复制对象句柄】
- windows笔记-跨越进程边界共享内核对象【复制对象句柄】
- 男人的想法
- 用程序设置打印纸张类型
- 句柄继承权起的作用?
- 如何用创建命名对象来判断应用程序是否已有一个实例在运行?
- 让你少走弯路的10条忠告
- 共享跨越进程边界内核对象的方法?
- 图片按比例缩放
- About the class Crgn
- 如何确定用户运行的是哪个Wi n d o w s 版本?即GetVersion()与GetVersionEx()的区别.
- Bitmap transfer into the Region
- 确定用户运行的是哪个Windows版本,以及如何验证?
- 利用ajaxpro.dll进行Ajax的开发
- Internet信息获取能力
- 缩小客户区(扩大非客户区)的方法