Windows核心编程 第三章 内核对象
第3章內核對象
? ? ??在介紹Windows API的時候，首先要講述內核對象以及它們的句柄。本章將要介紹一些比較抽象的概念，在此并不討論某個特定內核對象的特性，相反只是介紹適用于所有內核對象的特性。
首先介紹一個比較具體的問題，準確地理解內核對象對于想要成為一名 Wi n d o w s軟件開發能手的人來說是至關重要的。內核對象可以供系統和應用程序使用來管理各種各樣的資源，比如進程、線程和文件等。本章講述的概念也會出現在本書的其他各章之中。但是，在你開始使用實際的函數來操作內核對象之前，是無法深刻理解本章講述的部分內容的。因此當閱讀本書的其他章節時，可能需要經常回過來參考本章的內容。
3.1 什么是內核對象
? ??作為一個Wi n d o w s軟件開發人員，你經常需要創建、打開和操作各種內核對象。系統要創建和操作若干類型的內核對象，比如存取符號對象、事件對象、文件對象、文件映射對象、I / O完成端口對象、作業對象、信箱對象、互斥對象、管道對象、進程對象、信標對象、線程對象和等待計時器對象等。這些對象都是通過調用函數來創建的。例如，C r e a t e F i l e M a p p i n g函數可使系統能夠創建一個文件映射對象。每個內核對象只是內核分配的一個內存塊，并且只能由該內核訪問。該內存塊是一種數據結構，它的成員負責維護該對象的各種信息。有些數據成員（如安全性描述符、使用計數等）在所有對象類型中是相同的，但大多數數據成員屬于特定的對象類型。例如，進程對象有一個進程I D、一個基本優先級和一個退出代碼，而文件對象則擁有一個字節位移、一個共享模式和一個打開模式。
????由于內核對象的數據結構只能被內核訪問，因此應用程序無法在內存中找到這些數據結構并直接改變它們的內容。M i c r o s o f t規定了這個限制條件，目的是為了確保內核對象結構保持狀態的一致。這個限制也使M i c r o s o f t能夠在不破壞任何應用程序的情況下在這些結構中添加、刪除和修改數據成員。
????如果我們不能直接改變這些數據結構，那么我們的應用程序如何才能操作這些內核對象
呢？解決辦法是，Wi n d o w s提供了一組函數，以便用定義得很好的方法來對這些結構進行操作。這些內核對象始終都可以通過這些函數進行訪問。當調用一個用于創建內核對象的函數時，該函數就返回一個用于標識該對象的句柄。該句柄可以被視為一個不透明值，你的進程中的任何線程都可以使用這個值。將這個句柄傳遞給Wi n d o w s的各個函數，這樣，系統就能知道你想操作哪個內核對象。本章后面還要詳細講述這些句柄的特性。
? ? 為了使操作系統變得更加健壯，這些句柄值是與進程密切相關的。因此，如果將該句柄值傳遞給另一個進程中的一個線程（使用某種形式的進程間的通信）那么這另一個進程使用你的進程的句柄值所作的調用就會失敗。在3 . 3節“跨越進程邊界共享內核對象”中，將要介紹3種機制，使多個進程能夠成功地共享單個內核對象。
3.1.1 內核對象的使用計數
? ? 內核對象由內核所擁有，而不是由進程所擁有。換句話說，如果你的進程調用了一個創建內核對象的函數，然后你的進程終止運行，那么內核對象不一定被撤消。在大多數情況下，對象將被撤消，但是如果另一個進程正在使用你的進程創建的內核對象，那么該內核知道，在另一個進程停止使用該對象前不要撤消該對象，必須記住的是，內核對象的存在時間可以比創建該對象的進程長。內核知道有多少進程正在使用某個內核對象，因為每個對象包含一個使用計數。使用計數是所有內核對象類型常用的數據成員之一。當一個對象剛剛創建時，它的使用計數被置為1。然后，當另一個進程訪問一個現有的內核對象時，使用計數就遞增1。當進程終止運行時，內核就自動確定該進程仍然打開的所有內核對象的使用計數。如果內核對象的使用計數降為0，內核就撤消該對象。這樣可以確保在沒有進程引用該對象時系統中不保留任何內核對象。
3.1.2 安全性
? ? 內核對象能夠得到安全描述符的保護。安全描述符用于描述誰創建了該對象，誰能夠訪問或使用該對象，誰無權訪問該對象。安全描述符通常在編寫服務器應用程序時使用，如果你編寫客戶機端的應用程序，那么可以忽略內核對象的這個特性。
Windows 98 根據原來的設計，Windows 98并不用作服務器端的操作系統。為此，M i c r o s o f t公司沒有在Windows 98中配備安全特性。不過，如果你現在為 Windows 98設計軟件，在實現你的應用程序時仍然應該了解有關的安全問題，并且使用相應的訪問信息，以確保它能在Windows 2000上正確地運行
用于創建內核對象的函數幾乎都有一個指向 S E C U R I T Y _ AT T R I B U T E S結構的指針作為其參數，下面顯示了C r e a t e F i l e M a p p i n g函數的指針：
HANDLE?CreateFileMapping(
????_In_ HANDLE hFile,
????_In_opt_ LPSECURITY_ATTRIBUTES lpFileMappingAttributes,
????_In_ DWORD flProtect,
????_In_ DWORD dwMaximumSizeHigh,
????_In_ DWORD dwMaximumSizeLow,
????_In_opt_ LPCWSTR lpName
????);
? ? 大多數應用程序只是為該參數傳遞 N U L L，這樣就可以創建帶有默認安全性的內核對象。默認安全性意味著對象的管理小組的任何成員和對象的創建者都擁有對該對象的全部訪問權，而其他所有人均無權訪問該對象。但是，可以指定一個S E C U R I T Y _ AT T R I B U T E S結構，對它進行初始化，并為該參數傳遞該結構的地址。S E C U R I T Y _ AT T R I B U T E S結構類似下面的樣子：
typedef struct _SECURITY_ATTRIBUTES {
????DWORD nLength;
????LPVOID lpSecurityDescriptor;
????BOOL bInheritHandle;
} SECURITY_ATTRIBUTES;
? ? 盡管該結構稱為S E C U R I T Y _ AT T R I B U T E S，但是它包含的與安全性有關的成員實際上只有一個，即l p S e c u r i t y D e s c r i p t o r。如果你想要限制人們對你創建的內核對象的訪問，必須創建一個安全性描述符，然后像下面這樣對S E C U R I T Y _ AT T R I B U T E S結構進行初始化：
SECURITY_ATTRIBUTES sa;
sa.nLength = sizeof(sa);
sa.lpSecurityDescriptor = pSD;
sa.bInheritHandle = FALSE;
HANDLE hFileMapping = CreateFileMapping(INVALID_HANDLE_VALUE ,&sa,
PAGE_READWRITE ,0 ,1024 ,_TEXT("MyFileMapping"));
? ? 由于b I n h e r i t H a n d l e這個成員與安全性毫無關系，因此準備推遲到本章后面部分繼承性一節中再介紹b I n h e r i t H a n d l e這個成員。
當你想要獲得對相應的一個內核對象的訪問權（而不是創建一個新對象）時，必須設定要對該對象執行什么操作。例如，如果想要訪問一個現有的文件映射內核對象，以便讀取它的數據，那么應該調用下面這個O p e n f i l e M a p p i n g函數：
HANDLE??hFileMapping = OpenFileMapping(FILE_MAP_READ ,FALSE ,
_TEXT("MyFileMapping"));
????通過將F I L E _ M A P _ R E A D作為第一個參數傳遞給O p e n F i l e M a p p i n g，指明打算在獲得對該文件映象的訪問權后讀取該文件，O p e n F i l e M a p p i n g函數在返回一個有效的句柄值之前，首先執行一次安全檢查。如果（已登錄用戶）被允許訪問現有的文件映射內核對象，O p e n F i l eM a p p i n g就返回一個有效的句柄。但是，如果被拒絕訪問該對象，O p e n F i l e M a p p i n g將返回N U L L，而調用G e t L a s t E r r o r函數則返回5（E R R O R _ A C C E S S _ D E N I E D） ，同樣，大多數應用程序并不使用該安全性，因此將不進一步討論這個問題。
????Windows 98 雖然許多應用程序不需要考慮安全性問題，但是Wi n d o w s的許多函數要
求傳遞必要的安全訪問信息。為Windows 98設計的若干應用程序在Windows 2000上無
法正確地運行，因為在實現這些應用程序時沒有對安全問題給于足夠的考慮。例如，假設一個應用程序在開始運行時要從注冊表的子關鍵字中讀取一些數據。為了正確地進行這項操作，你的代碼應該調用R e g O p e n K e y E x，傳遞K E Y _ Q U E RY _VA L U E，以便獲得必要的訪問權。但是，許多應用程序原先是為Windows 98開發的，當時沒有考慮到運行Wi n d o w s
2 0 0 0的需要。由于Windows 98沒有解決注冊表的安全問題，因此軟件開發人員常常要
調用R e g O p e n K e y E x函數，傳遞K E Y _ A l l _ A C C E S S，作為必要的訪問權。開發人員這樣做的原因是，它是一種比較簡單的解決方案，意味著開發人員不必考慮究竟需要什
么訪問權。問題是注冊表的子關鍵字可以被用戶讀取，但是不能寫入。
????因此，當該應用程序現在放在Windows 2000上運行時，用K E Y _ A L L _ A C C E S S調用R e g O p e n K e y E x就會失敗，而且，沒有相應的錯誤檢查方法，應用程序的運行就會產生不可預料的結果。
????如果開發人員想到安全問題，把K E Y _ A L L _ A C C E S S改為K E Y _ Q U E RY _ VA L U E ,
則該產品可適用于兩種操作系統平臺。
????開發人員的最大錯誤之一就是忽略安全訪問標志。使用正確的標志會使最初為
Windows 98 設計的應用程序更易于向Windows 2000轉換。
????除了內核對象外，你的應用程序也可以使用其他類型的對象，如菜單、窗口、鼠標光標、
刷子和字體等。這些對象屬于用戶對象或圖形設備接口（ G D I）對象，而不是內核對象。當初次著手為Wi n d o w s編程時，如果想要將用戶對象或G D I對象與內核對象區分開來，你一定會感到不知所措。比如，圖標究竟是用戶對象還是內核對象呢？若要確定一個對象是否屬于內核對象，最容易的方法是觀察創建該對象所用的函數。創建內核對象的所有函數幾乎都有一個參數，你可以用來設定安全屬性的信息，這與前面講到的C r e a t e F i l e M a p p i n g函數是相同的。
用于創建用戶對象或G D I對象的函數都沒有P S E C U R I T Y _ AT T R I B U T E S參數。例如,讓我們來看一看下面這個C r e a t e I c o n函數:
HICON CreateIcon(
????_In_opt_ HINSTANCE hInstance,
????_In_ int nWidth,
????_In_ int nHeight,
????_In_ BYTE cPlanes,
????_In_ BYTE cBitsPixel,
????_In_ CONST BYTE *lpbANDbits,
????_In_ CONST BYTE *lpbXORbits);
3.2 進程的內核對象句柄表
? ? 當一個進程被初始化時,系統要為它分配一個句柄表。該句柄表只用于內核對象,不用于用戶對象或G D I對象。句柄表的詳細結構和管理方法并沒有具體的資料說明。通常我并不介紹操作系統中沒有文檔資料的那些部分。不過，在這種情況下，我會進行例外處理，因為，作為一個稱職的Wi n d o w s程序員，必須懂得如何管理進程的句柄表。由于這些信息沒有文檔資料，因此不能保證所有的詳細信息都正確無誤，同時，在Windows 2000、Windows 98和Windows CE中，它們的實現方法是不同的。為此，請認真閱讀下面介紹的內容以加深理解，在此不學習系統是如何進行操作的。表3 - 1顯示了進程的句柄表的樣子。可以看到，它只是個數據結構的數組。每個結構都包含一個指向內核對象的指針、一個訪問屏蔽和一些標志。
?
3.2.1 創建內核對象
????當進程初次被初始化時，它的句柄表是空的。然后，當進程中的線程調用創建內核對象的函數時，比如C r e a t e F i l e M a p p i n g，內核就為該對象分配一個內存塊，并對它初始化。這時，內核對進程的句柄表進行掃描，找出一個空項。由于表3 - 1中的句柄表是空的，內核便找到索引1位置上的結構并對它進行初始化。該指針成員將被設置為內核對象的數據結構的內存地址，訪問屏蔽設置為全部訪問權，同時，各個標志也作了設置（關于標志，將在本章后面部分的繼承性一節中介紹） 。
下面列出了用于創建內核對象的一些函數（但這決不是個完整的列表） ：
HANDLE CreateThread(
????_In_opt_ LPSECURITY_ATTRIBUTES lpThreadAttributes,
????_In_ SIZE_T dwStackSize,
????_In_ LPTHREAD_START_ROUTINE lpStartAddress,
????_In_opt_ __drv_aliasesMem LPVOID lpParameter,
????_In_ DWORD dwCreationFlags,
????_Out_opt_ LPDWORD lpThreadId
????);
?
HANDLE CreateFileW(
????_In_ LPCWSTR lpFileName,
????_In_ DWORD dwDesiredAccess,
????_In_ DWORD dwShareMode,
????_In_opt_ LPSECURITY_ATTRIBUTES lpSecurityAttributes,
????_In_ DWORD dwCreationDisposition,
????_In_ DWORD dwFlagsAndAttributes,
????_In_opt_ HANDLE hTemplateFile
????);
HANDLE CreateFileMappingW(
????_In_ HANDLE hFile,
????_In_opt_ LPSECURITY_ATTRIBUTES lpFileMappingAttributes,
????_In_ DWORD flProtect,
????_In_ DWORD dwMaximumSizeHigh,
????_In_ DWORD dwMaximumSizeLow,
????_In_opt_ LPCWSTR lpName
????);
?
HANDLE CreateSemaphoreW(
????_In_opt_ LPSECURITY_ATTRIBUTES lpSemaphoreAttributes,
????_In_ ????LONG lInitialCount,
????_In_ ????LONG lMaximumCount,
????_In_opt_ LPCWSTR lpName
????);
? ? 用于創建內核對象的所有函數均返回與進程相關的句柄，這些句柄可以被在相同進程中運行的任何或所有線程成功地加以使用。該句柄值實際上是放入進程的句柄表中的索引，它用于標識內核對象的信息存放的位置。因此當調試一個應用程序并且觀察內核對象句柄的實際值時，會看到一些較小的值，如1，2等。請記住，句柄的含義并沒有記入文檔資料，并且可能隨時變更。實際上在Windows 2000中，返回的值用于標識放入進程的句柄表的該對象的字節數，而不是索引號本身。
每當調用一個將內核對象句柄接受為參數的函數時，就要傳遞由一個 C r e a t e * &函數返回的值。從內部來說，該函數要查看進程的句柄表，以獲取要生成的內核對象的地址，然后按定義得很好的方式來生成該對象的數據結構。
????如果傳遞了一個無效索引（句柄） ，該函數便返回失敗，而 G e t L a s t E r r o r則返回 6（E R R O R _ I N VA L I D _ H A N D L E） 。由于句柄值實際上是放入進程句柄表的索引，因此這些句柄是與進程相關的，并且不能由其他進程成功地使用。
????如果調用一個函數以便創建內核對象，但是調用失敗了，那么返回的句柄值通常是 0
（N U L L） 。發生這種情況是因為系統的內存非常短缺，或者遇到了安全方面的問題。不過有少數函數在運行失敗時返回的句柄值是-1（I N VA L I D _ H A N D L E _ VA L U E） 。例如，如果C r e a t e F i l e未能打開指定的文件，那么它將返回I N VA L I D _ H A N D L E _ VA L U E，而不是返回N U L L。當查看創建內核對象的函數返回值時，必須格外小心。特別要注意的是，只有當調用C r e a t e F i l e函數時，才能將該值與I N VA L I D _ H A N D L E _ VA L U E進行比較。下面的代碼是不正確的：
HANDLE hMutex = CreateMutex(...);
if(hMutex == INVALID_HANDLE_VALUE){
//We will never execute this code beacuse
//CreateMutex return NULL if it fails.
}
同樣，下面的代碼也不正確：
HANDLE hFile = CreateFile(...);
if(hFile == NULL){
//We while never execute this code because CreateFile
//returns INVALID_HANDLE_VALUE(-1) if it fails.
}
?
3.2.2 關閉內核對象
????無論怎樣創建內核對象，都要向系統指明將通過調用C l o s e H a n d l e來結束對該對象的操作：該函數首先檢查調用進程的句柄表，以確保傳遞給它的索引（句柄）用于標識一個進程實際上無權訪問的對象。如果該索引是有效的，那么系統就可以獲得內核對象的數據結構的地址，并可確定該結構中的使用計數的數據成員。如果使用計數是0，該內核便從內存中撤消該內核對象。如果將一個無效句柄傳遞給C l o s e H a n d l e，將會出現兩種情況之一。如果進程運行正常，C l o s e H a n d l e返回FA L S E，而G e t L a s t E r r o r則返回E R R O R _ I N VA L I D _ H A N D L E。如果進程正在排除錯誤，系統將通知調試程序，以便能排除它的錯誤。在C l o s e H a n d l e返回之前，它會清除進程的句柄表中的項目，該句柄現在對你的進程已經無效，不應該試圖使用它。無論內核對象是否已經撤消，都會發生清除操作。當調用
C l o s e H a n d l e函數之后，將不再擁有對內核對象的訪問權，不過，如果該對象的使用計數沒有遞減為0，那么該對象尚未被撤消。這沒有問題，它只是意味著一個或多個其他進程正在使用該對象。當其他進程停止使用該對象時（通過調用C l o s e H a n d l e） ，該對象將被撤消。
????假如忘記調用C l o s e H a n d l e函數，那么會不會出現內存泄漏呢？答案是可能的，但是也不一定。在進程運行時，進程有可能泄漏資源（如內核對象） 。但是，當進程終止運行時，操作系統能夠確保該進程使用的任何資源或全部資源均被釋放，這是有保證的。對于內核對象來說，系統將執行下列操作：當進程終止運行時，系統會自動掃描進程的句柄表。如果該表擁有任何無效項目（即在終止進程運行前沒有關閉的對象）系統將關閉這些對象句柄。如果這些對象中的任何對象的使用計數降為0，那么內核便撤消該對象。
????因此，應用程序在運行時有可能泄漏內核對象，但是當進程終止運行時，系統將能確保所有內容均被正確地清除。另外，這個情況適用于所有對象、資源和內存塊，也就是說，當進程終止運行時，系統將保證進程不會留下任何對象。
3.3 跨越進程邊界共享內核對象
? ? 許多情況下，在不同進程中運行的線程需要共享內核對象。下面是為何需要共享的原因：
? ? ? 文件映射對象使你能夠在同一臺機器上運行的兩個進程之間共享數據塊。
? ? ? 郵箱和指定的管道使得應用程序能夠在連網的不同機器上運行的進程之間發送數據塊。
? ? ? 互斥對象、信標和事件使得不同進程中的線程能夠同步它們的連續運行，這與一個應用程序在完成某項任務時需要將情況通知另一個應用程序的情況相同。
? ? 由于內核對象句柄與進程相關，因此這些任務的執行情況是不同的。不過， 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.lpSecurityDescriptor = NULL;
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表示該進程擁有對兩個內核對象（句柄1和3）的訪問權。句柄1是不可繼承的，而句柄3是可繼承的。
使用對象句柄繼承性時要執行的下一個步驟是讓父進程生成子進程。這要使用 C r e a t eP r o c e s s函數來完成：
BOOLCreateProcessW(
????_In_opt_ LPCWSTR lpApplicationName,
????_Inout_opt_ LPWSTR lpCommandLine,
????_In_opt_ LPSECURITY_ATTRIBUTES lpProcessAttributes,
????_In_opt_ LPSECURITY_ATTRIBUTES lpThreadAttributes,
????_In_ BOOL bInheritHandles,
????_In_ DWORD dwCreationFlags,
????_In_opt_ LPVOID lpEnvironment,
????_In_opt_ LPCWSTR lpCurrentDirectory,
????_In_ LPSTARTUPINFOW lpStartupInfo,
????_Out_ LPPROCESS_INFORMATION lpProcessInformation
????);
????下一章將詳細介紹這個函數的用法，不過現在我想要讓你注意 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，這與父進程的句柄表中的對象地址相同。訪問屏蔽與父進程中的屏蔽相同，兩者的標志也相同。這意味著如果該子進程要生成它自己的子進程（即父進程的孫進程） ，該孫進程也將繼承與該內核對象句柄相同的句柄值、同樣的訪問權和相同的標志，同時，對象的使用計數再次被遞增。
?
? ? 應該知道，對象句柄的繼承性只有在生成子進程的時候才能使用。如果父進程準備創建帶有可繼承句柄的新內核對象，那么已經在運行的子進程將無法繼承這些新句柄。
? ? 對象句柄的繼承性有一個非常奇怪的特征，那就是當使用它時，子進程不知道它已經繼承了任何句柄。只有在另一個進程生成子進程時記錄了這樣一個情況，即它希望被賦予對內核對象的訪問權時，才能使用內核對象句柄的繼承權。通常，父應用程序和子應用程序都是由同一個公司編寫的，但是，如果另一個公司記錄了子應用程序期望的對象，那么該公司也能夠編寫子應用程序。
? ? 子進程為了確定它期望的內核對象的句柄值，最常用的方法是將句柄值作為一個命令行參數傳遞給子進程，該子進程的初始化代碼對命令行進行分析（通常通過調用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(
????_In_ HANDLE hObject,
????_In_ DWORD dwMask,
????_In_ 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);
????如果一個線程試圖關閉一個受保護的句柄， 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 ,HANDLE_FLAG_PROTECT_FROM_CLOSE,0);
父進程可能打賭說，子進程將不執行該代碼。當然，父進程也可能打賭說，子進程將生成孫進程。因此這種打賭沒有太大的風險。
為了完整地說明問題，也要講一下G e t H a n d l e I n f o r m a t i o n函數的情況：
????BOOL GetHandleInformation(
????????_In_ HANDLE hObject,
????????_Out_ LPDWORD lpdwFlags
????????);
? ? 該函數返回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 命名對象
????共享跨越進程邊界的內核對象的第二種方法是給對象命名。許多（雖然不是全部）內核對
象都是可以命名的。例如，下面的所有函數都可以創建命名的內核對象：
?
? ? 所有這些函數都有一個共同的最后參數 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 ,_TEXT("JeffObj"));
HANDLE hSem = CreateSemaphore(NULL ,1 ,1 ,_TEXT("JeffObj"));
DWORD dwErroeCode = 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 hMutexProcessA = CreateMutex(NULL ,FALSE ,_TEXT("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 ,_TEXT("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：
if(GetLastError() == ERROR_ALREADY_EXTSTS){
??//Opend a handle to an existing objuce.
??//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 boject.
????按名字共享對象的另一種方法是，進程不調用 C r e a t e *函數，而是調用下面顯示的O p e n *函數中的某一個：
?
? ? 注意，所有這些函數都擁有相同的原型。最后一個參數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，那么你的應用程序的另一個實例正在運行，新實例可以退出。
下面是說明這種情況的部分代碼：
?
3.3.4 終端服務器的名字空間
????注意，終端服務器能夠稍稍改變上面所說的情況。終端服務器擁有內核對象的多個名字空間。如果存在一個可供內核對象使用的全局名字空間，就意味著它可以供所有的客戶程序會話訪問。該名字空間主要供服務程序使用。此外，每個客戶程序會話都有它自己的名字空間。它能防止運行相同應用程序的兩個或多個會話之間出現互相干擾的情況，也就是說一個會話無法訪問另一個會話的對象，盡管該對象擁有相同的名字。在沒有終端服務器的機器上，服務程序和應用程序擁有上面所說的相同的內核對象名字空間，而在擁有終端服務器的機器上，卻不是這樣。
? ? 服務程序的名字空間對象總是放在全局名字空間中。按照默認設置，在終端服務器中，應用程序的命名內核對象將放入會話的名字空間中。但是，如果像下面這樣將“ G l o b a l \”置于對象名的前面，就可以使命名對象進入全局名字空間：
HANDLE h = CreateEvent(NULL ,FALSE ,FALSE ,_TEXT("Global\\MyName"));
? ? 也可以顯式說明想讓內核對象進入會話的名字空間，方法是將“ L o c a l \”置于對象名的前面：
HANDLE h1 = CreateEvent(NULL ,FALSE ,FALSE ,_TEXT("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(
????__in ???????HANDLE hSourceProcessHandle,
????__in ???????HANDLE hSourceHandle,
????__in ???????HANDLE hTargetProcessHandle,
????__deref_out LPHANDLE lpTargetHandle,
????__in ???????DWORD dwDesiredAccess,
????__in ???????BOOL bInheritHandle,
????__in ???????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 - 5是Process S的句柄表，它包含句柄值為2的單個項目。該句柄可以標識任何類型的內核對象，就是說它不必是進程的內核對象。
?
表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目前未用。
?
? ? 如果Process C現在使用下面的代碼來調用D u p l i c a t e H a n d l e，那么只有Process T的句柄表改變更，如表3 - 7所示。
?
? ? 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 sS使用） 。通常，當只涉及兩個進程時，才調用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 boject.
HANDLE hProcessT = OpenProcess(PROCESS_ALL_ACCESS ,FALSE ,dwProcessIdT);
HANDLE hObjProcessT; ?//An uninitialized handle relative to Process T.
?
//Give Process T access to out mutex boject.
DuplicateHandle(GetCurrentProcess() ,hObjProcessS ,hProcessT,
&hObjProcessT ,0 ,FALSE ,DUPLICATE_SAME_ACCESS);
//Use some IPC mechanism to get the handle
//value in hObjProcessS into Process T.
.
.
.
//We no longer need to communicate with Process T.
CloseHandle(hProcessT);
.
.
.
//We no longer need to communtcate with Process T.
CloseHandle(hProcessT);
.
.
.
//When Process S no longer needs to use the mutex,it shoule 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 sS恰好擁有對內核對象的訪問權，其句柄值與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為現有的對象創建一個新句柄，并確保這個新句柄擁有對該對象的只讀訪問權。然后將只讀句柄傳遞給該函數，這樣，該函數中的代碼就永遠不會偶然對該文件映射對象執行寫入操作。下面這個代碼說明了這個例子：
?
//Create a file-mapping object; the handle has read/write access.
HANDLE hFileMapRW = CreateFileMapping(INVALID_HANDLE_VALUE,
??NULL ,PAGE_READWRITE ,0 ,10240 ,NULL);
//Create another handle to the file-mapping object;
//the handle has read-onle access.
HANDLE hFileMapRO;
DuplicateHandle(GetCurrentProcess() ,hFileMapRW ,GetCurrentProcess() ,
&hFileMapRO ,FILE_MAP_READ ,FALSE ,0);
?
//Call the function that should only read fron the file mapping.
ReadFromTheFileMapping(hFileMapRO);
?
//Close the read-only file-mapping object using hFileMapRW.
.
.
.
//When the main code doesn't access the file mapping anymore.
//close it.
CloseHandle(hFileMapRW);
?
總結
以上是生活随笔為你收集整理的Windows核心编程 第三章 内核对象的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： Intel汇编语言程序设计学习-第五章
- 下一篇： Windows核心编程 第四章 进程（上