《Windows核心编程》笔记2 --- 内核对象二

续上......

内核对象如何在进程边界共享?
1.对象句柄的继承
    当进程具有父子关系,就能使用对象句柄的继承性。父进程有一个或多个对象句柄,并且父进程可以决定生成一个子进程,为子进程赋于父进程的内核对象的访问权。
    具体实现:
    在安全描述符中指定,如:
   
SECURITY_ATTRIGBUTES sa
    sa.nLength
=sizeof(sa);
    sa.lpSecuntyDescriptor
=null;
    sa.bInherithandle
=TRUE; //指定子进程可以继承该父进程的内核对象。
    HANDLE hMutex    =    CreateMutex(@sa,FALSE,NULL);
   
    然后,在进程中使用CreateProcess函数:
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);
为bInheritHandles指定TRUE,则告诉系统,子进程继承父进程的句柄表中的可继承句柄。

2.改变句柄标志:
    因为每个进程都会有个内核对象句柄表,指明该进程所拥有的句柄信息。那么,我们可以直接设置进程的句柄表,以获取某个内核对象的访问权。
    句柄表的样式:
索引 内核对象内存块的指针 访问屏蔽(标志位的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
    设置句柄标志的函数:
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
比如,打开一个内核对象的继承标志,则可以这样:
SetHandleInformation(hobj, HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT);
关闭该标志,则可以:
SetHandleInformation(hobj, HANDLE_FLAG_INHERIT, 0);

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);

    如果创建时最后的参数设置NULL,则创建一个末名命的内核对象当创建一个未命名的对象时,可以通过使用继承性(如上一节介绍的那样)或D u p l i c a t e H a n d l e (下一节将要介绍)共享跨越进程的对象。若要按名字共享对象,必须为对象赋予一个名字
    实现:我们在ProcessA中创建一个内核对象:
    HANDLE hMutexPronessA = CreateMutex(NULL, FALSE, "JeffMutex");
    然后,在ProcessB中创建一个与ProcessA中同名的内核对象:
    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 则使用它自己的句柄值来操作一个互斥内核对象。

按名字共享对象的另一种方法是,进程不调用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);

调用Create*与调用Open*来创建打开内核对象有什么区别呢?
调用C r e a t e *函数与调用O p e n *函数之间的主要差别是,如果对象并不存在,那么C r e a t e *函数将创建该对象,而O p e n *函数则运行失败。

4.复制内核对象句柄:
    共享跨越进程边界的内核对象的最后一个方法是使用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);

简单说来,该函数取出一个进程的句柄表中的项目,并将该项目拷贝到另一个进程的句柄表中。

二,进程

1.何为进程,进程有何特性?
    所谓进程,就是一个正在运行程序的实例。它由两部分组成:
    • 一个是操作系统用来管理进程的内核对象。
    • 另一个是地址空间,它包含所有可执行模块或D L L 模块的代码和数据。它还包含动态内存分配的空间。如线程堆栈和堆分配空间。

   注意,进程是不活泼的,即进程完成的操作,是需要靠进程中的线程来完成。每个进程都必须有一个线程,也可以有多个线程。线程负责执行包含在进程地址空间内的代码。所谓多线程,就是多个线程同时执行包含在地址空间内的代码。
    若要使线程执行进程内的代码,操作系统必须为线程分配CPU时间片。它是以一种循环的方式来提供时间片的,即给每个线程多少时间,时间完成之后,收回CPU,转交给另外的线程。
    创建一个进程,系统会自动为其进程创建一个主线程。然后,可利用该线程可以创建其它的线程,其正是多线程。
posted @ 2005-08-24 11:04  shipfi  阅读(854)  评论(1编辑  收藏  举报