registry.cpp
上传用户:bjlvip
上传日期:2010-02-08
资源大小:744k
文件大小:6k
源码类别:

Windows编程

开发平台:

Visual C++

  1. // Registry.cpp
  2. #include <objbase.h>
  3. #include <assert.h>
  4. #include "registry.h"
  5. // Set the given key and its value.
  6. BOOL setKeyAndValue(const char* pszPath, const char* szSubkey, const char* szValue);
  7. // Open a key and set a value.
  8. BOOL setValueInKey(const char* szKey, const char* szNamedValue, const char* szValue);
  9. // Convert a CLSID into a char string.
  10. void CLSIDtochar(REFCLSID clsid, char* szCLSID, int length);
  11. // Delete szKeyChild and all of its descendents.
  12. LONG recursiveDeleteKey(HKEY hKeyParent, const char* szKeyChild);
  13. // Size of a CLSID as a string
  14. const int CLSID_STRING_SIZE = 39;
  15. // Register the component in the registry.
  16. HRESULT RegisterServer(const char* szModuleName,     // DLL module handle
  17.                        REFCLSID clsid,               // Class ID
  18.                        const char* szFriendlyName,   // Friendly Name
  19.                        const char* szVerIndProgID,   // Programmatic
  20.                        const char* szProgID,         // IDs
  21.    const char* szThreadingModel) // ThreadingModel
  22. {
  23. // Get server location.
  24. char szModule[512];
  25. HMODULE hModule = GetModuleHandle(szModuleName);
  26. DWORD dwResult = GetModuleFileName(hModule, szModule, sizeof(szModule)/sizeof(char));
  27. assert(dwResult != 0);
  28. // Convert the CLSID into a char.
  29. char szCLSID[CLSID_STRING_SIZE];
  30. CLSIDtochar(clsid, szCLSID, sizeof(szCLSID));
  31. // Build the key CLSID\{...}
  32. char szKey[64];
  33. strcpy(szKey, "CLSID\");
  34. strcat(szKey, szCLSID);
  35.   
  36. // Add the CLSID to the registry.
  37. setKeyAndValue(szKey, NULL, szFriendlyName);
  38. // Add the server filename subkey under the CLSID key.
  39. if(strstr(szModuleName, ".exe") == NULL)
  40. {
  41. setKeyAndValue(szKey, "InprocServer32", szModule);
  42. char szInproc[64];
  43. strcpy(szInproc, szKey);
  44. strcat(szInproc, "\InprocServer32");
  45. setValueInKey(szInproc, "ThreadingModel", szThreadingModel);
  46. }
  47. else
  48. setKeyAndValue(szKey, "LocalServer32", szModule);
  49. // Add the ProgID subkey under the CLSID key.
  50. setKeyAndValue(szKey, "ProgID", szProgID);
  51. // Add the version-independent ProgID subkey under CLSID key.
  52. setKeyAndValue(szKey, "VersionIndependentProgID", szVerIndProgID);
  53. // Add the version-independent ProgID subkey under HKEY_CLASSES_ROOT.
  54. setKeyAndValue(szVerIndProgID, NULL, szFriendlyName); 
  55. setKeyAndValue(szVerIndProgID, "CLSID", szCLSID);
  56. setKeyAndValue(szVerIndProgID, "CurVer", szProgID);
  57. // Add the versioned ProgID subkey under HKEY_CLASSES_ROOT.
  58. setKeyAndValue(szProgID, NULL, szFriendlyName); 
  59. setKeyAndValue(szProgID, "CLSID", szCLSID);
  60. return S_OK;
  61. }
  62. // Remove the component from the registry.
  63. LONG UnregisterServer(REFCLSID clsid,             // Class ID
  64.                       const char* szVerIndProgID, // Programmatic
  65.                       const char* szProgID)       // IDs
  66. {
  67. // Convert the CLSID into a char.
  68. char szCLSID[CLSID_STRING_SIZE];
  69. CLSIDtochar(clsid, szCLSID, sizeof(szCLSID));
  70. // Build the key CLSID\{...}
  71. char szKey[64];
  72. strcpy(szKey, "CLSID\");
  73. strcat(szKey, szCLSID);
  74. // Delete the CLSID Key - CLSID{...}
  75. LONG lResult = recursiveDeleteKey(HKEY_CLASSES_ROOT, szKey);
  76. assert((lResult == ERROR_SUCCESS) || (lResult == ERROR_FILE_NOT_FOUND)); // Subkey may not exist.
  77. // Delete the version-independent ProgID Key.
  78. lResult = recursiveDeleteKey(HKEY_CLASSES_ROOT, szVerIndProgID);
  79. assert((lResult == ERROR_SUCCESS) || (lResult == ERROR_FILE_NOT_FOUND)); // Subkey may not exist.
  80. // Delete the ProgID key.
  81. lResult = recursiveDeleteKey(HKEY_CLASSES_ROOT, szProgID);
  82. assert((lResult == ERROR_SUCCESS) || (lResult == ERROR_FILE_NOT_FOUND)); // Subkey may not exist.
  83. return S_OK;
  84. }
  85. // Convert a CLSID to a char string.
  86. void CLSIDtochar(REFCLSID clsid, char* szCLSID, int length)
  87. {
  88. assert(length >= CLSID_STRING_SIZE);
  89. // Get CLSID
  90. LPOLESTR wszCLSID = NULL;
  91. HRESULT hr = StringFromCLSID(clsid, &wszCLSID);
  92. assert(SUCCEEDED(hr));
  93. // Covert from wide characters to non-wide.
  94. wcstombs(szCLSID, wszCLSID, length);
  95. // Free memory.
  96. CoTaskMemFree(wszCLSID);
  97. }
  98. // Delete a key and all of its descendents.
  99. LONG recursiveDeleteKey(HKEY hKeyParent,           // Parent of key to delete
  100.                         const char* lpszKeyChild)  // Key to delete
  101. {
  102. // Open the child.
  103. HKEY hKeyChild;
  104. LONG lRes = RegOpenKeyEx(hKeyParent, lpszKeyChild, 0, KEY_ALL_ACCESS, &hKeyChild);
  105. if(lRes != ERROR_SUCCESS)
  106. return lRes;
  107. // Enumerate all of the decendents of this child.
  108. FILETIME time;
  109. char szBuffer[256];
  110. DWORD dwSize = 256;
  111. while(RegEnumKeyEx(hKeyChild, 0, szBuffer, &dwSize, NULL, NULL, NULL, &time) == S_OK)
  112. {
  113. // Delete the decendents of this child.
  114. lRes = recursiveDeleteKey(hKeyChild, szBuffer);
  115. if(lRes != ERROR_SUCCESS)
  116. {
  117. // Cleanup before exiting.
  118. RegCloseKey(hKeyChild);
  119. return lRes;
  120. }
  121. dwSize = 256;
  122. }
  123. // Close the child.
  124. RegCloseKey(hKeyChild);
  125. // Delete this child.
  126. return RegDeleteKey(hKeyParent, lpszKeyChild);
  127. }
  128. // Create a key and set its value.
  129. BOOL setKeyAndValue(const char* szKey, const char* szSubkey, const char* szValue)
  130. {
  131. HKEY hKey;
  132. char szKeyBuf[1024];
  133. // Copy keyname into buffer.
  134. strcpy(szKeyBuf, szKey);
  135. // Add subkey name to buffer.
  136. if(szSubkey != NULL)
  137. {
  138. strcat(szKeyBuf, "\");
  139. strcat(szKeyBuf, szSubkey );
  140. }
  141. // Create and open key and subkey.
  142. long lResult = RegCreateKeyEx(HKEY_CLASSES_ROOT, szKeyBuf, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hKey, NULL);
  143. if(lResult != ERROR_SUCCESS)
  144. return FALSE;
  145. // Set the Value.
  146. if(szValue != NULL)
  147. RegSetValueEx(hKey, NULL, 0, REG_SZ, (BYTE *)szValue, strlen(szValue)+1);
  148. RegCloseKey(hKey);
  149. return TRUE;
  150. }
  151. // Open a key and set a value.
  152. BOOL setValueInKey(const char* szKey, const char* szNamedValue, const char* szValue)
  153. {
  154. HKEY hKey;
  155. char szKeyBuf[1024];
  156. // Copy keyname into buffer.
  157. strcpy(szKeyBuf, szKey);
  158. // Create and open key and subkey.
  159. long lResult = RegOpenKeyEx(HKEY_CLASSES_ROOT, szKeyBuf, 0, KEY_SET_VALUE, &hKey);
  160. if(lResult != ERROR_SUCCESS)
  161. return FALSE;
  162.     // Set the Value.
  163. if(szValue != NULL)
  164. RegSetValueEx(hKey, szNamedValue, 0, REG_SZ, (BYTE*)szValue, strlen(szValue)+1);
  165. RegCloseKey(hKey);
  166. return TRUE;
  167. }