跨越进程边界共享内核对象
许多情况下，在不同进程中运行的线程需要共享内核对象。下面是为何需要共享的原因： ? 文件映射对象使你能够在同一台机器上运行的两个进程之间共享数据块。 ? 邮箱和指定的管道使得应用程序能够在连网的不同机器上运行的进程之间发送数据块。 ? 互斥对象、信标和事件使得不同进程中的线程能够同步它们的连续运行，这与一个应用程序在完成某项任务时需要将情况通知另一个应用程序的情况相同。
由于内核对象句柄与进程相关，因此这些任务的执行情况是不同的。不过，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);
该代码对一个S E C U R I T Y _ AT T R I B U T E S 结构进行初始化，指明该对象应该使用默认安全性（在Windows 98 中该安全性被忽略）来创 建，并且返回的句柄应该是可继承的。
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 包含两个有效项目的进程句柄表
索引 内核对象内存块的指针 访问屏蔽（标志位的D W O R D ） 标志（标志位的D W O R D ）
1 0 x F 0 0 0 0 0 0 0 0 x ? ? ? ? ? ? ? ? 0 x 0 0 0 0 0 0 0 0
2 0 x 0 0 0 0 0 0 0 0 (无) (无)
3 0 x F 0 0 0 0 0 1 0 0 x ? ? ? ? ? ? ? ? 0 x 0 0 0 0 0 0 0 1
表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);
下一章将详细介绍这个函数的用法，不过现在我想要让你注意b I n h e r i t H a n d l e 这个参数。一般来说，当生成一个进程时，将为该参数 传递FA L S E 。该值告诉系统，不希望子进程继承父进程的句柄表中的可继承句柄。
但是，如果为该参数传递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 继承父进程的可继承句柄后的子进程句柄表
索引 内核对象内存块的指针 访问屏蔽（标志位的D W O R D ） 标志（标志位的D W O R D ）
1 0 x 0 0 0 0 0 0 0 0 (无) (无)
2 0 x 0 0 0 0 0 0 0 0 (无) (无)
3 0 x F 0 0 0 0 0 1 0 0 x ? ? ? ? ? ? ? ? 0 x 0 0 0 0 0 0 0 1
应该知道，对象句柄的继承性只有在生成子进程的时候才能使用。如果父进程准备创建带有可继承句柄的新内核对象，那么已经在运行的子进程将无法继承这些新句柄。
对象句柄的继承性有一个非常奇怪的特征，那就是当使用它时，子进程不知道它已经继承了任何句柄。只有在另一个进程生成子进程时记录了这样一个情况，即它希望被赋予对内核对象的访问权时，才能使用内核对象句柄的继承权。通常，父应用程序和子应用程序都是由同一个公司编写的，但是，如果另一个公司记录了子应用程序期望的对象，那么该公司也能够编写子应用程序。
子进程为了确定它期望的内核对象的句柄值，最常用的方法是将句柄值作为一个命令行参数传递给子进程，该子进程的初始化代码对命令行进行分析（通常通过调用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);
可以看到，该函数拥有3 个参数。第一个参数h O b j e c t 用于标识一个有效的句柄。第二个参数d w M a s k 告诉该函数想要改变哪个或那几个标志。目前有两个标志与每个句柄相关联：
#define HANDLE FLAG_INHERIT 0x00000001
#define HANDLE FLAG PROTECT FROM CLOSE 0x00000002
如果想同时改变该对象的两个标志，可以逐位用O R 将这些标志连接起来。S e t H a n d l eI n f o r m a t i o n 函数的第三个参数是d w F l a g s ，用于指明想将该标志设置成什么值。例如，若要打开一个内核对象句柄的继承标志，请创建下面的代码：
SetHandleInformation(hobj,
HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT);
若要关闭该标志，请创建下面的代码：
SetHandleInformation(hobj, HANDLE_FLAG_INHERIT, 0);
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, HANDLE_FLAG_PROTECT_FROM_CLOSE,
HANDLE_FLAG_PROTECT_FROM_CLOSE);
CloseHandle(hobj); //Exception is raised
如果一个线程试图关闭一个受保护的句柄，C l o s e H a n d l e 就会产生一个异常条件。很少想要将句柄保护起来，使他人无法将它关闭。但是如果一个进程生成了子进程，而子进程又生成了孙进程，那么该标志可能有用。父进程可能希望孙进程继承赋予子进程的对象句柄。不过，子进程有可能在生成孙进程之前关闭该句柄。如果出现这种情况，父进程就无法与孙进程进行通信，因为孙进程没有继承该内核对象。通过将句柄标明为“受保护不能关闭”，那么孙进程就能继承该对象。
但是这种处理方法有一个问题。子进程可以调用下面的代码来关闭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);
该函数返回p d w F l a g s 指向的D W O R D 中特定句柄的当前标志的设置值。若要了解句柄是否是可继承的，请使用下面的代码：
DWORD dwFlags;
GetHandleInformation(hObj, &dwFlags);
BOOL fHandleIsInheritable = (0 != (dwFlags &
HANDLE_FLAG_INHERIT));
3.3.3 命名对象
共享跨越进程边界的内核对象的第二种方法是给对象命名。许多（虽然不是全部）内核对象都是可以命名的。例如，下面的所有函数都可以创建命名的内核对象：
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 。当为该参数传递N U L L 时，就向系统指明了想创建一个未命名的（匿名）内核对象。当创建一个未命名的对象时，可以通过使用继承性（如上一节介绍的那样）或D u p l i c a t e H a n d l e (下一节将要介绍)共享跨越进程的对象。若要按名字共享对象，必须为对象赋予一个名字。
如果没有为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();
如果在执行上面的代码后观察d w E r r o r c o d e 的值，会看到返回的代码是6 （E R R O R _I N VA L I D _ H A N D L E )。这个错误代码没有很强的表意性，但是你又能够做什么呢？
既然已知道如何给对象命名，那么让我们来看一看如何用这种方法来共享对象。比如说，Process A 启动运行，并调用下面的函数：
HANDLE hMutexPronessA = CreateMutex(NULL, FALSE, "JeffMutex");
调用该函数能创建一个新的互斥内核对象，为它赋予名字“J e ff M u t e x ”。请注意，P r o c e s sA 的句柄h M u t e x P r o c e s s A 不是一个可继承的句柄，并且当你只是命名对象时，它不必是个可继承的句柄。
过些时候，某个进程会生成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 时，系统首先要查看是否已经存在一个名字为“J e ff M u t e x ”的内核对象。由于确实存在一个带有该名字的对象，因此内核要检查对象的类型。由于试图创建一个互斥对象，而名字为“J e ff M u t e x ”的对象也是个互斥对象，因此系统会执行一次安全检查，以确定调用者是否拥有对该对象的完整的访问权。如果拥有这种访问权，系统就在Process B 的句柄表中找出一个空项目，并对该项目进行初始化，使该项目指向现有的内核对象。如果该对象类型不匹配，或者调用者被拒绝访问，那么C r e a t e M u t e x 将运行失败（返回N U L L ）。当Process B 对C r e a t e M u t e x 的调用取得成功时，它并不实际创建一个互斥对象。相反，Process B 只是被赋予一个与进程相关的句柄值，用于标识内核中现有的互斥对象。当然，由于Process B 的句柄表中的一个新项目要引用该对象，互斥对象的使用计数就会递增。在Process A和Process B 同时关闭它们的对象句柄之前，该对象是不会被撤消的。请注意，这两个进程中的句柄值很可能是不同的值。这是可以的。Process A 将使用它的句柄值，而Process B 则使用它自己的句柄值来操作一个互斥内核对象。
注意当你的多个内核对象拥有相同的名字时，有一个非常重要的细节必须知道。当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.
}
按名字共享对象的另一种方法是，进程不调用C r e a t e *函数，而是调用下面显示的O p e n *函数中的某一个：
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);
注意，所有这些函数都拥有相同的原型。最后一个参数p s z N a m e 用于指明内核对象的名字。不能为该参数传递N U L L ，必须传递以0 结尾的地址。这些函数要搜索内核对象的单个名空间，以便找出匹配的空间。如果不存在带有指定名字的内核对象，该函数返回N U L L ，G e t L a s t E r r o r返回2 （E R R O R _ F I L E _ N O T _ F O U N D ）。但是，如果存在带有指定名字的内核对象，并且它是相同类型的对象，那么系统就要查看是否允许执行所需的访问（通过d w D e s i r e d A c c e s s 参数进行访问）。如果拥有该访问权，调用进程的句柄表就被更新，对象的使用计数被递增。如果为b I n h e r i t H a n d l e 参数传递T R U E ，那么返回的句柄将是可继承的。
调用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);
}
3.3.4 终端服务器的名字空间
注意，终端服务器能够稍稍改变上面所说的情况。终端服务器拥有内核对象的多个名字空间。如果存在一个可供内核对象使用的全局名字空间，就意味着它可以供所有的客户程序会话访问。该名字空间主要供服务程序使用。此外，每个客户程序会话都有它自己的名字空间。它能防止运行相同应用程序的两个或多个会话之间出现互相干扰的情况，也就是说一个会话无法访问另一个会话的对象，尽管该对象拥有相同的名字。在没有终端服务器的机器上，服务程序和应用程序拥有上面所说的相同的内核对象名字空间，而在拥有终端服务器的机器上，却不是这样。
服务程序的名字空间对象总是放在全局名字空间中。按照默认设置，在终端服务器中，应用程序的命名内核对象将放入会话的名字空间中。但是，如果像下面这样将“G l o b a l \”置于对象名的前面，就可以使命名对象进入全局名字空间：
HANDLE h = CreateEvenL(NULL, FALSE, FALSE, "Global\\MyName");
也可以显式说明想让内核对象进入会话的名字空间，方法是将“L o c a l \”置于对象名的前面：
HANDLE h = CreateEvent(NULL, FALSE, FALSE, "Local\\MyName");
M i c r o s o f t 将G l o b a l 和L o c a l 视为保留关键字，除非要强制使用特定的名字空间，否则不应该使用这两个关键字。M i c r o s o f t 还将S e s s i o n 视为保留关键字，虽然目前它没有任何意义。请注意，所有这些保留关键字是区分大小写字母的。如果主机不运行终端服务器，这些关键字将被忽略。
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 函数配有若干个参数，但是实际上它是非常简单的。D u p l i c a t e H a n d l e 函数最普通的用法要涉及系统中运行的3 个不同进程。
当调用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 的句柄表
索引 内核对象内存块的指针 访问屏蔽（标志位的D W O R D ） 标志（标志位的D W O R D ）
1 0 x F 0 0 0 0 0 0 0(Process S 的内核对象） 0 x ? ? ? ? ? ? ? ? 0 x 0 0 0 0 0 0 0 0
2 0 x F 0 0 0 0 0 1 0(Process T 的内核对象） 0 x ? ? ? ? ? ? ? ? 0 x 0 0 0 0 0 0 0 0
表3 - 5 是Process S 的句柄表，它包含句柄值为2 的单个项目。该句柄可以标识任何类型的内核对象，就是说它不必是进程的内核对象。
表3-5 Process S 的句柄表
索引 内核对象内存块的指针 访问屏蔽（标志位的D W O R D ） 标志（标志位的D W O R D ）
1 0 x 0 0 0 0 0 0 0 0 (无) (无)
2 0 x F 0 0 0 0 0 2 0 0 x ? ? ? ? ? ? ? ? 0 x 0 0 0 0 0 0 0 0
表3 - 6 显示了Process C 调用D u p l i c a t e H a n d l e 函数之前Process T 的句柄表包含的项目。如你所见，Process T 的句柄表只包含句柄值为2 的单个项目，句柄项目1 目前未用。
表3-6 调用D u p l i c a t e H a n d l e 函数之前Process T 的句柄表
索引 内核对象内存块的指针 访问屏蔽（标志位的D W O R D ） 标志（标志位的D W O R D ）
1 0 x 0 0 0 0 0 0 0 0 (无) (无)
2 0 x F 0 0 0 0 0 3 0 0 x ? ? ? ? ? ? ? ? 0 x 0 0 0 0 0 0 0 0
如果Process C 现在使用下面的代码来调用D u p l i c a t e H a n d l e ，那么只有Process T 的句柄表改变更，如表3 - 7 所示。
表3-7 调用D u p l i c a t e H a n d l e 函数之后Process T 的句柄表
索引 内核对象内存块的指针 访问屏蔽（标志位的D W O R D ） 标志（标志位的D W O R D ）
1 0 x F 0 0 0 0 0 2 0 0 x ? ? ? ? ? ? ? ? 0 x 0 0 0 0 0 0 0 1
2 0 x F 0 0 0 0 0 3 0 0 x ? ? ? ? ? ? ? ? 0 x 0 0 0 0 0 0 0 0
Process S 的句柄表中的第二项已经被拷贝到Process T 的句柄表中的第一项。D u p l i c a t eH a n d l e 也已经将值1 填入Process C 的h O b j 变量中。值1 是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 object
DuplicateHandle(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);
在这个例子中，对G e t C u r r e n t P r o c e s s 的调用将返回一个伪句柄，该句柄总是用来标识调用端的进程Process S 。一旦D u p l i c a t e H a n d l e 返回，h O b j P r o c e s s T 就是与Process T 相关的句柄，它所标识的对象与引用Process S 中的代码时h O b j P r o c e s s S 的句柄标识的对象相同。Process S 决不应该执行下面的代码：
//Process S should never attempt to close the duplicated handle
CloseHandle(hObjProcessT);
如果Process S 要执行该代码，那么对代码的调用可能失败，也可能不会失败。如果P r o c e s s S 恰好拥有对内核对象的访问权，其句柄值与h O b j P r o c e s s T 的值相同，那么调用就会成功。该代码的调用将会关闭某个对象，这样Process 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 为现有的对象创建一个新句柄，并确保这个新句柄拥有对该对象的只读访问权。然后将只读句柄传递给该函数，这样，该函数中的代码就永远不会偶然对该文件映射对象执行写入操作。下面这个代码说明了这个例子：
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);
}
