mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
744 lines
17 KiB
744 lines
17 KiB
/*****************************************************************************
|
|
*
|
|
* DIReg.c
|
|
*
|
|
* Copyright (c) 1996 Microsoft Corporation. All Rights Reserved.
|
|
*
|
|
* Abstract:
|
|
*
|
|
* OLE self-registration.
|
|
*
|
|
* Contents:
|
|
*
|
|
* DllRegisterServer()
|
|
* DllUnregisterServer()
|
|
*
|
|
*****************************************************************************/
|
|
|
|
#include "dinputpr.h"
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* The sqiffle for this file.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
#define sqfl sqflDll
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* RegSetStringEx
|
|
*
|
|
* Add a REG_SZ to hkey\sub::value.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
void INTERNAL
|
|
RegSetStringEx(HKEY hk, LPCTSTR ptszValue, LPCTSTR ptszData)
|
|
{
|
|
LONG lRc = RegSetValueEx(hk, ptszValue, 0, REG_SZ,
|
|
(PV)ptszData, cbCtch(lstrlen(ptszData)+1));
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* RegDelStringEx
|
|
*
|
|
* Remove a REG_SZ from hkey\sub::value. The data is ignored.
|
|
* It's passed so that RegDelStringEx matches the prototype for a
|
|
* REGSTRINGACTION.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
void INTERNAL
|
|
RegDelStringEx(HKEY hk, LPCTSTR ptszValue, LPCTSTR ptszData)
|
|
{
|
|
LONG lRc = RegDeleteValue(hk, ptszValue);
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* RegCloseFinish
|
|
*
|
|
* Just close the subkey already.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
void INTERNAL
|
|
RegCloseFinish(HKEY hk, LPCTSTR ptszSub, HKEY hkSub)
|
|
{
|
|
LONG lRc = RegCloseKey(hkSub);
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* RegDelFinish
|
|
*
|
|
* Delete a key if there is nothing in it.
|
|
*
|
|
* OLE unregistration rules demand that you not delete a key if OLE
|
|
* has added something to it.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
void INTERNAL
|
|
RegDelFinish(HKEY hk, LPCTSTR ptszSub, HKEY hkSub)
|
|
{
|
|
LONG lRc;
|
|
DWORD cKeys = 0, cValues = 0;
|
|
RegQueryInfoKey(hkSub, 0, 0, 0, &cKeys, 0, 0, &cValues, 0, 0, 0, 0);
|
|
RegCloseKey(hkSub);
|
|
if ((cKeys | cValues) == 0) {
|
|
|
|
#ifdef WINNT
|
|
lRc = DIWinnt_RegDeleteKey(hk, ptszSub);
|
|
#else
|
|
lRc = RegDeleteKey(hk, ptszSub);
|
|
#endif
|
|
|
|
} else {
|
|
lRc = 0;
|
|
}
|
|
}
|
|
|
|
|
|
#ifdef WINNT //The following are only used on WINNT
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func void | RegSetPermissionsOnDescendants |
|
|
*
|
|
* Sets the specified permissions on all descendants of the specified key.
|
|
*
|
|
* @parm HKEY | hKey |
|
|
*
|
|
* The reg key on whose descendants we're operating.
|
|
*
|
|
* @parm SECURITY_DESCRIPTOR* | psd |
|
|
*
|
|
* Ptr to the SECURITY_DESCRIPTOR we're using.
|
|
*
|
|
* @returns
|
|
*
|
|
* Nothing.
|
|
* Note that this recurses while having TCHAR szKeyName[MAX_PATH+1]
|
|
* for each level. If stack space is a concern, can allocate it on the heap,
|
|
* and free after obtain the HKEY (i.e. before recursing).
|
|
*
|
|
*****************************************************************************/
|
|
|
|
void INTERNAL
|
|
RegSetPermissionsOnDescendants(HKEY hKey, SECURITY_DESCRIPTOR* psd)
|
|
{
|
|
DWORD dwIndex = 0;
|
|
LONG lRetCode = ERROR_SUCCESS;
|
|
|
|
while (lRetCode == ERROR_SUCCESS)
|
|
{
|
|
TCHAR szKeyName[MAX_PATH+1];
|
|
DWORD cbKeyName = MAX_PATH+1;
|
|
lRetCode = RegEnumKeyEx(hKey,
|
|
dwIndex,
|
|
szKeyName,
|
|
&cbKeyName,
|
|
NULL, NULL, NULL, NULL);
|
|
|
|
if (lRetCode == ERROR_SUCCESS)
|
|
{
|
|
LONG lRetSub;
|
|
HKEY hkSubKey;
|
|
lRetSub = RegOpenKeyEx(hKey, szKeyName, 0, DI_KEY_ALL_ACCESS | WRITE_DAC, &hkSubKey);
|
|
if (lRetSub == ERROR_SUCCESS)
|
|
{
|
|
//set security on it and its descendants
|
|
lRetSub = RegSetKeySecurity(hkSubKey,
|
|
(SECURITY_INFORMATION)DACL_SECURITY_INFORMATION,
|
|
psd);
|
|
RegSetPermissionsOnDescendants(hkSubKey, psd);
|
|
RegCloseKey(hkSubKey);
|
|
|
|
if(lRetSub != ERROR_SUCCESS)
|
|
{
|
|
RPF("Couldn't RegSetKeySecurity on %hs", szKeyName);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
RPF("Couldn't open enumed subkey %hs", szKeyName);
|
|
}
|
|
|
|
dwIndex++;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func HRESULT | RegSetSecurity |
|
|
*
|
|
* Set the security of
|
|
* SYSTEM\\CurrentControlSet\\Control\\MediaProperties\\PrivateProperties\\Joystick\\OEM
|
|
* SYSTEM\\CurrentControlSet\\Control\\MediaResources\\Joystick\\Dinput.dll
|
|
* to be accessible to Everyone on Win2K,
|
|
*. to be accessible to Everyone but without WRITE_DAC and WRITE_OWNER permissions on WinXP;
|
|
* SYSTEM\\CurrentControlSet\\Control\\MediaProperties\\PrivateProperties\\DirectInput
|
|
* to be accessible to Everyone but without WRITE_DAC and WRITE_OWNER permissions on Win2k and WinXP.
|
|
*
|
|
* @returns
|
|
*
|
|
* S_OK on success, E_FAIL on error.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
HRESULT INTERNAL
|
|
RegSetSecurity(void)
|
|
{
|
|
SID_IDENTIFIER_AUTHORITY sia = SECURITY_WORLD_SID_AUTHORITY;
|
|
PSID pEveryoneSid = NULL;
|
|
SECURITY_DESCRIPTOR sd;
|
|
PACL pDacl = NULL;
|
|
DWORD dwAclSize;
|
|
HKEY hkOEM, hkJoy, hkDin, hkPP, hkMedR, hkJDi;
|
|
LONG lRetCode;
|
|
BOOL bSuccess = FALSE; // assume this function fails
|
|
BOOL bWinXP = FALSE;
|
|
|
|
//determine whether we're running on Win2k or WinXP, since we would like
|
|
//on Win2k to emulate the same behaviour as previously, but set different reg key
|
|
//permissions on WinXp (see Whistler bugs 318865, 326784).
|
|
if (DIGetOSVersion() == WINWH_OS)
|
|
{
|
|
bWinXP = TRUE;
|
|
}
|
|
|
|
//
|
|
// open the keys for WRITE_DAC access
|
|
//
|
|
//MediaProperties/PrivateProperties/DirectInput
|
|
lRetCode = RegOpenKeyEx(
|
|
HKEY_LOCAL_MACHINE,
|
|
REGSTR_PATH_PRIVATEPROPERTIES,
|
|
0,
|
|
KEY_WRITE,
|
|
&hkPP
|
|
);
|
|
|
|
if(lRetCode != ERROR_SUCCESS) {
|
|
RPF("Couldn't open REGSTR_PATH_PRIVATEPROPERTIES");
|
|
return E_FAIL;
|
|
}
|
|
|
|
lRetCode = RegCreateKeyEx(
|
|
hkPP,
|
|
TEXT("DirectInput"),
|
|
0,
|
|
NULL,
|
|
REG_OPTION_NON_VOLATILE,
|
|
DI_KEY_ALL_ACCESS | WRITE_DAC,
|
|
NULL,
|
|
&hkDin,
|
|
NULL
|
|
);
|
|
|
|
if(lRetCode != ERROR_SUCCESS) {
|
|
RPF("Couldn't open DirectInput");
|
|
return E_FAIL;
|
|
}
|
|
|
|
//MediaResources/Joystick/Dinput.dll
|
|
lRetCode = RegOpenKeyEx(
|
|
HKEY_LOCAL_MACHINE,
|
|
REGSTR_PATH_MEDIARESOURCES,
|
|
0,
|
|
KEY_WRITE,
|
|
&hkMedR
|
|
);
|
|
|
|
if(lRetCode != ERROR_SUCCESS) {
|
|
RPF("Couldn't open REGSTR_PATH_MEDIARESOURCES");
|
|
return E_FAIL;
|
|
}
|
|
|
|
//on Win2K, we need to create MediaResources\Joystick\Dinput.dll reg key w/ KEY_ALL_ACCESS (Whistler bug 326874)
|
|
if (bWinXP == TRUE)
|
|
{
|
|
lRetCode = RegCreateKeyEx(
|
|
hkMedR,
|
|
TEXT("Joystick"),
|
|
0,
|
|
NULL,
|
|
REG_OPTION_NON_VOLATILE,
|
|
KEY_WRITE,
|
|
NULL,
|
|
&hkJoy,
|
|
NULL
|
|
);
|
|
|
|
if(lRetCode != ERROR_SUCCESS) {
|
|
RPF("Couldn't open Joystick");
|
|
return E_FAIL;
|
|
}
|
|
|
|
lRetCode = RegCreateKeyEx(
|
|
hkJoy,
|
|
TEXT("Dinput.dll"),
|
|
0,
|
|
NULL,
|
|
REG_OPTION_NON_VOLATILE,
|
|
DI_KEY_ALL_ACCESS | WRITE_DAC,
|
|
NULL,
|
|
&hkJDi,
|
|
NULL
|
|
);
|
|
|
|
if(lRetCode != ERROR_SUCCESS) {
|
|
RPF("Couldn't open Dinput.dll");
|
|
return E_FAIL;
|
|
}
|
|
|
|
//MediaProperties/Joystick/OEM
|
|
lRetCode = RegOpenKeyEx(
|
|
HKEY_LOCAL_MACHINE,
|
|
REGSTR_PATH_JOYOEM,
|
|
0,
|
|
WRITE_DAC | KEY_ENUMERATE_SUB_KEYS,
|
|
&hkOEM
|
|
);
|
|
|
|
if(lRetCode != ERROR_SUCCESS) {
|
|
RPF("Couldn't open REGSTR_PATH_JOYOEM");
|
|
return E_FAIL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
lRetCode = RegCreateKeyEx(
|
|
hkMedR,
|
|
TEXT("Joystick"),
|
|
0,
|
|
NULL,
|
|
REG_OPTION_NON_VOLATILE,
|
|
KEY_ALL_ACCESS,
|
|
NULL,
|
|
&hkJoy,
|
|
NULL
|
|
);
|
|
|
|
if(lRetCode != ERROR_SUCCESS) {
|
|
RPF("Couldn't open Joystick");
|
|
return E_FAIL;
|
|
}
|
|
|
|
lRetCode = RegCreateKeyEx(
|
|
hkJoy,
|
|
TEXT("Dinput.dll"),
|
|
0,
|
|
NULL,
|
|
REG_OPTION_NON_VOLATILE,
|
|
KEY_ALL_ACCESS,
|
|
NULL,
|
|
&hkJDi,
|
|
NULL
|
|
);
|
|
|
|
if(lRetCode != ERROR_SUCCESS) {
|
|
RPF("Couldn't open Dinput.dll");
|
|
return E_FAIL;
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// prepare a Sid representing any Interactively logged-on user
|
|
//
|
|
if(!AllocateAndInitializeSid(
|
|
&sia,
|
|
1,
|
|
SECURITY_WORLD_RID,
|
|
0, 0, 0, 0, 0, 0, 0,
|
|
&pEveryoneSid
|
|
))
|
|
{
|
|
RPF("Couldn't AllocateAndInitializeSid");
|
|
goto cleanup;
|
|
}
|
|
|
|
//
|
|
// compute size of new acl
|
|
//
|
|
dwAclSize = sizeof(ACL) + sizeof(ACCESS_ALLOWED_ACE) - sizeof(DWORD)
|
|
+ GetLengthSid(pEveryoneSid);
|
|
|
|
//
|
|
// allocate storage for Acl
|
|
//
|
|
pDacl = (PACL)HeapAlloc(GetProcessHeap(), 0, dwAclSize);
|
|
if(pDacl == NULL) {
|
|
RPF("pACl is NULL");
|
|
goto cleanup;
|
|
}
|
|
|
|
if(!InitializeAcl(pDacl, dwAclSize, ACL_REVISION)) {
|
|
RPF("Couldn't InitializeAcl");
|
|
goto cleanup;
|
|
}
|
|
|
|
//
|
|
// grant the Interactive Sid KEY_READ access to the perf key
|
|
//
|
|
if(!AddAccessAllowedAceEx(
|
|
pDacl,
|
|
ACL_REVISION,
|
|
CONTAINER_INHERIT_ACE,
|
|
DI_KEY_ALL_ACCESS,
|
|
pEveryoneSid
|
|
))
|
|
{
|
|
RPF("Couldn't AddAccessAllowedAceEx");
|
|
goto cleanup;
|
|
}
|
|
|
|
if(!InitializeSecurityDescriptor(&sd, SECURITY_DESCRIPTOR_REVISION))
|
|
{
|
|
RPF("Couldn't InitilizeSecurityDescriptor");
|
|
goto cleanup;
|
|
}
|
|
|
|
if(!SetSecurityDescriptorDacl(&sd, TRUE, pDacl, FALSE))
|
|
{
|
|
RPF("Couldn't SetSecurityDescriptorDacl");
|
|
goto cleanup;
|
|
}
|
|
|
|
//make sure that it is not overwritten by the parent's security changes
|
|
if(!SetSecurityDescriptorControl(&sd, SE_DACL_PROTECTED, SE_DACL_PROTECTED))
|
|
{
|
|
RPF("Couldn't SetSecurityDescriptorControl");
|
|
goto cleanup;
|
|
}
|
|
|
|
//
|
|
// apply the security descriptor to the registry keys and their subkeys
|
|
//
|
|
//MediaProperties/PrivateProperties/DirectInput and its subkeys
|
|
lRetCode = RegSetKeySecurity(
|
|
hkDin,
|
|
(SECURITY_INFORMATION)DACL_SECURITY_INFORMATION,
|
|
&sd
|
|
);
|
|
|
|
if(lRetCode != ERROR_SUCCESS) {
|
|
RPF("Couldn't RegSetKeySecurity on DirectInput");
|
|
goto cleanup;
|
|
}
|
|
|
|
RegSetPermissionsOnDescendants(hkDin, &sd);
|
|
|
|
|
|
//on WinXP, we set the same permissions on Joystick/OEM and MediaResources/Joystick/Dinput.dll and their subkeys
|
|
if (bWinXP == TRUE)
|
|
{
|
|
//Joystick/OEM
|
|
lRetCode = RegSetKeySecurity(
|
|
hkOEM,
|
|
(SECURITY_INFORMATION)DACL_SECURITY_INFORMATION,
|
|
&sd
|
|
);
|
|
|
|
if(lRetCode != ERROR_SUCCESS) {
|
|
RPF("Couldn't RegSetKeySecurity on OEM");
|
|
goto cleanup;
|
|
}
|
|
|
|
RegSetPermissionsOnDescendants(hkOEM, &sd);
|
|
|
|
//MediaResources/Joystick/Dinput.dll and its subkeys
|
|
lRetCode = RegSetKeySecurity(
|
|
hkJDi,
|
|
(SECURITY_INFORMATION)DACL_SECURITY_INFORMATION,
|
|
&sd
|
|
);
|
|
|
|
if(lRetCode != ERROR_SUCCESS) {
|
|
RPF("Couldn't RegSetKeySecurity on Dinput.dll");
|
|
goto cleanup;
|
|
}
|
|
|
|
RegSetPermissionsOnDescendants(hkJDi, &sd);
|
|
|
|
//indicate success
|
|
bSuccess = TRUE;
|
|
}
|
|
else
|
|
{
|
|
//on Win2K, we leave Joystick/OEM keys alone,
|
|
//and give full access to MediaResources\Joystick\Dinput.dll and its subkeys to everyone
|
|
PACL pDaclFull = NULL;
|
|
pDaclFull = (PACL)HeapAlloc(GetProcessHeap(), 0, dwAclSize);
|
|
if(pDaclFull == NULL) {
|
|
RPF("pAClFull is NULL");
|
|
goto cleanupW2k;
|
|
}
|
|
|
|
if(!InitializeAcl(pDaclFull, dwAclSize, ACL_REVISION)) {
|
|
RPF("Couldn't InitializeAcl");
|
|
goto cleanupW2k;
|
|
}
|
|
|
|
if(!AddAccessAllowedAceEx(
|
|
pDaclFull,
|
|
ACL_REVISION,
|
|
CONTAINER_INHERIT_ACE,
|
|
KEY_ALL_ACCESS,
|
|
pEveryoneSid
|
|
))
|
|
{
|
|
RPF("Couldn't AddAccessAllowedAceEx");
|
|
goto cleanupW2k;
|
|
}
|
|
|
|
if(!SetSecurityDescriptorDacl(&sd, TRUE, pDaclFull, FALSE))
|
|
{
|
|
RPF("Couldn't SetSecurityDescriptorDacl");
|
|
goto cleanupW2k;
|
|
}
|
|
|
|
//make sure that it is not overwritten by the parent's security changes
|
|
if(!SetSecurityDescriptorControl(&sd, SE_DACL_PROTECTED, SE_DACL_PROTECTED))
|
|
{
|
|
RPF("Couldn't SetSecurityDescriptorControl");
|
|
goto cleanupW2k;
|
|
}
|
|
|
|
//apply it to the key and its subkeys
|
|
lRetCode = RegSetKeySecurity(
|
|
hkJoy,
|
|
(SECURITY_INFORMATION)DACL_SECURITY_INFORMATION,
|
|
&sd
|
|
);
|
|
|
|
if(lRetCode != ERROR_SUCCESS) {
|
|
RPF("Couldn't RegSetKeySecurity on Dinput.dll");
|
|
goto cleanupW2k;
|
|
}
|
|
|
|
lRetCode = RegSetKeySecurity(
|
|
hkJDi,
|
|
(SECURITY_INFORMATION)DACL_SECURITY_INFORMATION,
|
|
&sd
|
|
);
|
|
|
|
if(lRetCode != ERROR_SUCCESS) {
|
|
RPF("Couldn't RegSetKeySecurity on Dinput.dll");
|
|
goto cleanupW2k;
|
|
}
|
|
|
|
RegSetPermissionsOnDescendants(hkJDi, &sd);
|
|
|
|
//indicate success
|
|
bSuccess = TRUE;
|
|
|
|
cleanupW2k:;
|
|
if(pDaclFull != NULL)
|
|
{
|
|
HeapFree(GetProcessHeap(), 0, pDaclFull);
|
|
}
|
|
}
|
|
|
|
|
|
cleanup:
|
|
|
|
RegCloseKey(hkOEM);
|
|
RegCloseKey(hkJDi);
|
|
RegCloseKey(hkDin);
|
|
RegCloseKey(hkPP);
|
|
RegCloseKey(hkMedR);
|
|
RegCloseKey(hkJoy);
|
|
|
|
//
|
|
// free allocated resources
|
|
//
|
|
if(pDacl != NULL) {
|
|
HeapFree(GetProcessHeap(), 0, pDacl);
|
|
}
|
|
|
|
if(pEveryoneSid != NULL) {
|
|
FreeSid(pEveryoneSid);
|
|
}
|
|
|
|
if(bSuccess) {
|
|
return S_OK;
|
|
} else {
|
|
return E_FAIL;
|
|
}
|
|
}
|
|
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func HRESULT | DummyRegSetSecurity |
|
|
*
|
|
* Do nothing
|
|
*
|
|
* @returns
|
|
*
|
|
* S_OK.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
HRESULT INTERNAL
|
|
DummyRegSetSecurity(void)
|
|
{
|
|
return S_OK;
|
|
}
|
|
|
|
#endif //WINNT
|
|
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* REGVTBL
|
|
*
|
|
* Functions for dorking with a registry key, either coming or going.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
typedef struct REGVTBL {
|
|
/* How to create/open a key */
|
|
LONG (INTERNAL *KeyAction)(HKEY hk, LPCTSTR ptszSub, PHKEY phkOut);
|
|
|
|
/* How to create/delete a string */
|
|
void (INTERNAL *StringAction)(HKEY hk, LPCTSTR ptszValue, LPCTSTR ptszData);
|
|
|
|
/* How to finish using a key */
|
|
void (INTERNAL *KeyFinish)(HKEY hk, LPCTSTR ptszSub, HKEY hkSub);
|
|
|
|
#ifdef WINNT
|
|
/* How to set security on OEM key */
|
|
HRESULT (INTERNAL *SetSecurity)( void );
|
|
#endif //WINNT
|
|
|
|
} REGVTBL, *PREGVTBL;
|
|
typedef const REGVTBL *PCREGVTBL;
|
|
|
|
#ifdef WINNT
|
|
const REGVTBL c_vtblAdd = { RegCreateKey, RegSetStringEx, RegCloseFinish, RegSetSecurity };
|
|
const REGVTBL c_vtblDel = { RegOpenKey, RegDelStringEx, RegDelFinish, DummyRegSetSecurity };
|
|
#else
|
|
const REGVTBL c_vtblAdd = { RegCreateKey, RegSetStringEx, RegCloseFinish };
|
|
const REGVTBL c_vtblDel = { RegOpenKey, RegDelStringEx, RegDelFinish };
|
|
#endif //WINNT
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func void | DllServerAction |
|
|
*
|
|
* Register or unregister our objects with OLE/COM/ActiveX/
|
|
* whatever its name is.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
#pragma BEGIN_CONST_DATA
|
|
|
|
extern const TCHAR c_tszNil[];
|
|
|
|
#define ctchClsid ctchGuid
|
|
|
|
const TCHAR c_tszClsidGuid[] =
|
|
TEXT("CLSID\\{%08lX-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}");
|
|
|
|
const TCHAR c_tszInProcServer32[] = TEXT("InProcServer32");
|
|
const TCHAR c_tszThreadingModel[] = TEXT("ThreadingModel");
|
|
const TCHAR c_tszBoth[] = TEXT("Both");
|
|
|
|
#pragma END_CONST_DATA
|
|
|
|
void INTERNAL
|
|
DllServerAction(PCREGVTBL pvtbl)
|
|
{
|
|
TCHAR tszThisDll[MAX_PATH];
|
|
UINT iclsidmap;
|
|
|
|
GetModuleFileName(g_hinst, tszThisDll, cA(tszThisDll));
|
|
|
|
for (iclsidmap = 0; iclsidmap < cclsidmap; iclsidmap++) {
|
|
TCHAR tszClsid[7+ctchClsid];
|
|
HKEY hkClsid;
|
|
HKEY hkSub;
|
|
REFCLSID rclsid = c_rgclsidmap[iclsidmap].rclsid;
|
|
|
|
wsprintf(tszClsid, c_tszClsidGuid,
|
|
rclsid->Data1, rclsid->Data2, rclsid->Data3,
|
|
rclsid->Data4[0], rclsid->Data4[1],
|
|
rclsid->Data4[2], rclsid->Data4[3],
|
|
rclsid->Data4[4], rclsid->Data4[5],
|
|
rclsid->Data4[6], rclsid->Data4[7]);
|
|
|
|
if (pvtbl->KeyAction(HKEY_CLASSES_ROOT, tszClsid, &hkClsid) == 0) {
|
|
TCHAR tszName[127];
|
|
|
|
/* Do the type name */
|
|
LoadString(g_hinst, c_rgclsidmap[iclsidmap].ids,
|
|
tszName, cA(tszName));
|
|
pvtbl->StringAction(hkClsid, 0, tszName);
|
|
|
|
/* Do the in-proc server name and threading model */
|
|
if (pvtbl->KeyAction(hkClsid, c_tszInProcServer32, &hkSub) == 0) {
|
|
pvtbl->StringAction(hkSub, 0, tszThisDll);
|
|
pvtbl->StringAction(hkSub, c_tszThreadingModel, c_tszBoth);
|
|
pvtbl->KeyFinish(hkClsid, c_tszInProcServer32, hkSub);
|
|
}
|
|
|
|
pvtbl->KeyFinish(HKEY_CLASSES_ROOT, tszClsid, hkClsid);
|
|
|
|
}
|
|
}
|
|
|
|
#ifdef WINNT
|
|
pvtbl->SetSecurity();
|
|
#endif
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func void | DllRegisterServer |
|
|
*
|
|
* Register our classes with OLE/COM/ActiveX/whatever its name is.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
void EXTERNAL
|
|
DllRegisterServer(void)
|
|
{
|
|
DllServerAction(&c_vtblAdd);
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func void | DllUnregisterServer |
|
|
*
|
|
* Unregister our classes from OLE/COM/ActiveX/whatever its name is.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
void EXTERNAL
|
|
DllUnregisterServer(void)
|
|
{
|
|
DllServerAction(&c_vtblDel);
|
|
}
|