729 lines
22 KiB
C++
729 lines
22 KiB
C++
/*
|
|
* CiderPress
|
|
* Copyright (C) 2007 by faddenSoft, LLC. All Rights Reserved.
|
|
* See the file LICENSE for distribution terms.
|
|
*/
|
|
/*
|
|
* Windows Registry operations.
|
|
*/
|
|
#include "stdafx.h"
|
|
#include "Registry.h"
|
|
#include "Main.h"
|
|
#include "MyApp.h"
|
|
|
|
#define kRegAppName L"CiderPress"
|
|
#define kRegExeName L"CiderPress.exe"
|
|
#define kCompanyName L"faddenSoft"
|
|
|
|
static const WCHAR kRegKeyCPKVersions[] = L"vrs";
|
|
static const WCHAR kRegKeyCPKExpire[] = L"epr";
|
|
|
|
/*
|
|
* Application path. Add two keys:
|
|
*
|
|
* (default) = FullPathName
|
|
* Full pathname of the executable file.
|
|
* Path = Path
|
|
* The $PATH that will be in effect when the program starts (but only if
|
|
* launched from the Windows explorer).
|
|
*/
|
|
static const WCHAR kAppKeyBase[] =
|
|
L"HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\" kRegExeName;
|
|
|
|
/*
|
|
* Local settings. App stuff goes in the per-user key, registration info is
|
|
* in the per-machine key.
|
|
*/
|
|
static const WCHAR kMachineSettingsBaseKey[] =
|
|
L"HKEY_LOCAL_MACHINE\\SOFTWARE\\" kCompanyName L"\\" kRegAppName;
|
|
static const WCHAR kUserSettingsBaseKey[] =
|
|
L"HKEY_CURRENT_USER\\Software\\" kCompanyName L"\\" kRegAppName;
|
|
|
|
/*
|
|
* Set this key + ".XXX" to (Default)=AppID. This associates the file
|
|
* type with kRegAppID.
|
|
*/
|
|
//static const char* kFileExtensionBase = L"HKEY_CLASSES_ROOT";
|
|
|
|
/*
|
|
* Description of data files. Set this key + AppID to 40-char string, e.g.
|
|
* (Default)=CompanyName AppName Version DataType
|
|
*
|
|
* Can also set DefaultIcon = Pathname [,Index]
|
|
*/
|
|
//static const char* kAppIDBase = L"HKEY_CLASSES_ROOT";
|
|
|
|
/*
|
|
* Put one of these under the AppID to specify the icon for a file type.
|
|
*/
|
|
static const WCHAR* kDefaultIcon = L"DefaultIcon";
|
|
|
|
static const WCHAR* kRegKeyCPKStr = L"CPK";
|
|
|
|
/*
|
|
* Table of file type associations. They will appear in the UI in the same
|
|
* order that they appear here, so try to maintain alphabetical order.
|
|
*/
|
|
#define kAppIDNuFX L"CiderPress.NuFX"
|
|
#define kAppIDDiskImage L"CiderPress.DiskImage"
|
|
#define kAppIDBinaryII L"CiderPress.BinaryII"
|
|
#define kNoAssociation L"(no association)"
|
|
const MyRegistry::FileTypeAssoc MyRegistry::kFileTypeAssoc[] = {
|
|
{ L".2MG", kAppIDDiskImage },
|
|
{ L".APP", kAppIDDiskImage },
|
|
{ L".BNY", kAppIDBinaryII },
|
|
{ L".BQY", kAppIDBinaryII },
|
|
{ L".BSE", kAppIDNuFX },
|
|
{ L".BXY", kAppIDNuFX },
|
|
{ L".D13", kAppIDDiskImage },
|
|
{ L".DDD", kAppIDDiskImage },
|
|
{ L".DO", kAppIDDiskImage },
|
|
{ L".DSK", kAppIDDiskImage },
|
|
{ L".FDI", kAppIDDiskImage },
|
|
{ L".HDV", kAppIDDiskImage },
|
|
{ L".IMG", kAppIDDiskImage },
|
|
{ L".NIB", kAppIDDiskImage },
|
|
{ L".PO", kAppIDDiskImage },
|
|
{ L".SDK", kAppIDDiskImage },
|
|
{ L".SEA", kAppIDNuFX },
|
|
{ L".SHK", kAppIDNuFX },
|
|
// { L".DC", kAppIDDiskImage },
|
|
// { L".DC6", kAppIDDiskImage },
|
|
// { L".GZ", kAppIDDiskImage },
|
|
// { L".NB2", kAppIDDiskImage },
|
|
// { L".RAW", kAppIDDiskImage },
|
|
// { L".ZIP", kAppIDDiskImage },
|
|
};
|
|
|
|
static const struct {
|
|
const char* user;
|
|
const char* reg;
|
|
} gBadKeys[] = {
|
|
{ "Nimrod Bonehead", "CP1-68C069-62CC9444" },
|
|
{ "Connie Tan", "CP1-877B2C-A428FFD6" },
|
|
};
|
|
|
|
|
|
/*
|
|
* ==========================================================================
|
|
* One-time install/uninstall
|
|
* ==========================================================================
|
|
*/
|
|
|
|
/*
|
|
* This is called immediately after installation finishes.
|
|
*
|
|
* We want to snatch up any unused file type associations. We define them
|
|
* as "unused" if the entry does not exist in the registry at all. A more
|
|
* thorough installer would also verify that the appID actually existed
|
|
* and "steal" any apparent orphans, but we can let the user do that manually.
|
|
*/
|
|
void
|
|
MyRegistry::OneTimeInstall(void) const
|
|
{
|
|
/* start by stomping on our appIDs */
|
|
WMSG0(" Removing appIDs\n");
|
|
RegDeleteKeyNT(HKEY_CLASSES_ROOT, kAppIDNuFX);
|
|
RegDeleteKeyNT(HKEY_CLASSES_ROOT, kAppIDDiskImage);
|
|
RegDeleteKeyNT(HKEY_CLASSES_ROOT, kAppIDBinaryII);
|
|
|
|
/* configure the appIDs */
|
|
FixBasicSettings();
|
|
|
|
/* configure extensions */
|
|
int i, res;
|
|
for (i = 0; i < NELEM(kFileTypeAssoc); i++) {
|
|
HKEY hExtKey;
|
|
res = RegOpenKeyEx(HKEY_CLASSES_ROOT, kFileTypeAssoc[i].ext, 0,
|
|
KEY_READ, &hExtKey);
|
|
if (res == ERROR_SUCCESS) {
|
|
WMSG1(" Found existing HKCR\\'%ls', leaving alone\n",
|
|
kFileTypeAssoc[i].ext);
|
|
RegCloseKey(hExtKey);
|
|
} else if (res == ERROR_FILE_NOT_FOUND) {
|
|
OwnExtension(kFileTypeAssoc[i].ext, kFileTypeAssoc[i].appID);
|
|
} else {
|
|
WMSG2(" Got error %ld opening HKCR\\'%ls', leaving alone\n",
|
|
res, kFileTypeAssoc[i].ext);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Remove things that the standard uninstall script won't.
|
|
*
|
|
* We want to un-set any of our file associations. We don't really need to
|
|
* clean up the ".xxx" entries, because removing their appID entries is enough
|
|
* to fry their little brains, but it's probably the right thing to do.
|
|
*
|
|
* We definitely want to strip out our appIDs.
|
|
*/
|
|
void
|
|
MyRegistry::OneTimeUninstall(void) const
|
|
{
|
|
/* drop any associations we hold */
|
|
int i;
|
|
for (i = 0; i < NELEM(kFileTypeAssoc); i++) {
|
|
CString ext, handler;
|
|
bool ours;
|
|
|
|
GetFileAssoc(i, &ext, &handler, &ours);
|
|
if (ours) {
|
|
DisownExtension(ext);
|
|
}
|
|
}
|
|
|
|
/* remove our appIDs */
|
|
WMSG0(" Removing appIDs\n");
|
|
RegDeleteKeyNT(HKEY_CLASSES_ROOT, kAppIDNuFX);
|
|
RegDeleteKeyNT(HKEY_CLASSES_ROOT, kAppIDDiskImage);
|
|
RegDeleteKeyNT(HKEY_CLASSES_ROOT, kAppIDBinaryII);
|
|
}
|
|
|
|
|
|
/*
|
|
* ==========================================================================
|
|
* Shareware registration logic
|
|
* ==========================================================================
|
|
*/
|
|
|
|
/* [removed] */
|
|
|
|
/*
|
|
* ==========================================================================
|
|
* Windows shell game
|
|
* ==========================================================================
|
|
*/
|
|
|
|
/*
|
|
* Return the application's registry key. This is used as the argument to
|
|
* CWinApp::SetRegistryKey(). The GetProfile{Int,String} calls combine this
|
|
* (in m_pszRegistryKey) with the app name (in m_pszProfileName) and prepend
|
|
* "HKEY_CURRENT_USER\Software\".
|
|
*/
|
|
const WCHAR*
|
|
MyRegistry::GetAppRegistryKey(void) const
|
|
{
|
|
return kCompanyName;
|
|
}
|
|
|
|
/*
|
|
* See if an AppID is one we recognize.
|
|
*/
|
|
bool
|
|
MyRegistry::IsOurAppID(const WCHAR* id) const
|
|
{
|
|
return (wcsicmp(id, kAppIDNuFX) == 0 ||
|
|
wcsicmp(id, kAppIDDiskImage) == 0 ||
|
|
wcsicmp(id, kAppIDBinaryII) == 0);
|
|
}
|
|
|
|
/*
|
|
* Fix the basic registry settings, e.g. our AppID classes.
|
|
*
|
|
* We don't overwrite values that already exist. We want to hold on to the
|
|
* installer's settings, which should get whacked if the program is
|
|
* uninstalled or reinstalled. This is here for "installer-less" environments
|
|
* and to cope with registry damage.
|
|
*/
|
|
void
|
|
MyRegistry::FixBasicSettings(void) const
|
|
{
|
|
const WCHAR* exeName = gMyApp.GetExeFileName();
|
|
ASSERT(exeName != nil && wcslen(exeName) > 0);
|
|
|
|
WMSG0("Fixing any missing file type AppID entries in registry\n");
|
|
|
|
ConfigureAppID(kAppIDNuFX, L"NuFX Archive (CiderPress)", exeName, 1);
|
|
ConfigureAppID(kAppIDBinaryII, L"Binary II (CiderPress)", exeName, 2);
|
|
ConfigureAppID(kAppIDDiskImage, L"Disk Image (CiderPress)", exeName, 3);
|
|
}
|
|
|
|
/*
|
|
* Set up the registry goodies for one appID.
|
|
*/
|
|
void
|
|
MyRegistry::ConfigureAppID(const WCHAR* appID, const WCHAR* descr,
|
|
const WCHAR* exeName, int iconIdx) const
|
|
{
|
|
WMSG2(" Configuring '%ls' for '%ls'\n", appID, exeName);
|
|
|
|
HKEY hAppKey = nil;
|
|
HKEY hIconKey = nil;
|
|
|
|
DWORD dw;
|
|
if (RegCreateKeyEx(HKEY_CLASSES_ROOT, appID, 0, REG_NONE,
|
|
REG_OPTION_NON_VOLATILE, KEY_WRITE|KEY_READ, NULL,
|
|
&hAppKey, &dw) == ERROR_SUCCESS)
|
|
{
|
|
ConfigureAppIDSubFields(hAppKey, descr, exeName);
|
|
|
|
if (RegCreateKeyEx(hAppKey, kDefaultIcon, 0, REG_NONE,
|
|
REG_OPTION_NON_VOLATILE, KEY_WRITE|KEY_READ, NULL,
|
|
&hIconKey, &dw) == ERROR_SUCCESS)
|
|
{
|
|
DWORD type, size;
|
|
unsigned char buf[512];
|
|
long res;
|
|
|
|
size = sizeof(buf); // size in bytes
|
|
res = RegQueryValueEx(hIconKey, L"", nil, &type, buf, &size);
|
|
if (res == ERROR_SUCCESS && size > 1) {
|
|
WMSG1(" Icon for '%ls' already exists, not altering\n", appID);
|
|
} else {
|
|
CString iconStr;
|
|
iconStr.Format(L"%ls,%d", exeName, iconIdx);
|
|
|
|
if (RegSetValueEx(hIconKey, L"", 0, REG_SZ,
|
|
(const BYTE*)(LPCTSTR) iconStr,
|
|
wcslen(iconStr) * sizeof(WCHAR)) == ERROR_SUCCESS)
|
|
{
|
|
WMSG2(" Set icon for '%ls' to '%ls'\n", appID,
|
|
(LPCWSTR) iconStr);
|
|
} else {
|
|
WMSG2(" WARNING: unable to set DefaultIcon for '%ls' to '%ls'\n",
|
|
appID, (LPCWSTR) iconStr);
|
|
}
|
|
}
|
|
} else {
|
|
WMSG1("WARNING: couldn't set up DefaultIcon for '%ls'\n", appID);
|
|
}
|
|
} else {
|
|
WMSG1("WARNING: couldn't create AppID='%ls'\n", appID);
|
|
}
|
|
|
|
RegCloseKey(hIconKey);
|
|
RegCloseKey(hAppKey);
|
|
}
|
|
|
|
/*
|
|
* Set up the current key's default (which is used as the explorer
|
|
* description) and put the "Open" command in "...\shell\open\command".
|
|
*/
|
|
void
|
|
MyRegistry::ConfigureAppIDSubFields(HKEY hAppKey, const WCHAR* descr,
|
|
const WCHAR* exeName) const
|
|
{
|
|
HKEY hShellKey, hOpenKey, hCommandKey;
|
|
DWORD dw;
|
|
|
|
ASSERT(hAppKey != nil);
|
|
ASSERT(descr != nil);
|
|
ASSERT(exeName != nil);
|
|
hShellKey = hOpenKey = hCommandKey = nil;
|
|
|
|
if (RegSetValueEx(hAppKey, L"", 0, REG_SZ, (const BYTE*) descr,
|
|
wcslen(descr) * sizeof(WCHAR)) != ERROR_SUCCESS)
|
|
{
|
|
WMSG1(" WARNING: unable to set description to '%ls'\n", descr);
|
|
}
|
|
|
|
if (RegCreateKeyEx(hAppKey, L"shell", 0, REG_NONE,
|
|
REG_OPTION_NON_VOLATILE, KEY_WRITE|KEY_READ, NULL,
|
|
&hShellKey, &dw) == ERROR_SUCCESS)
|
|
{
|
|
if (RegCreateKeyEx(hShellKey, L"open", 0, REG_NONE,
|
|
REG_OPTION_NON_VOLATILE, KEY_WRITE|KEY_READ, NULL,
|
|
&hOpenKey, &dw) == ERROR_SUCCESS)
|
|
{
|
|
if (RegCreateKeyEx(hOpenKey, L"command", 0, REG_NONE,
|
|
REG_OPTION_NON_VOLATILE, KEY_WRITE|KEY_READ, NULL,
|
|
&hCommandKey, &dw) == ERROR_SUCCESS)
|
|
{
|
|
DWORD type, size;
|
|
WCHAR buf[MAX_PATH+8];
|
|
long res;
|
|
|
|
size = sizeof(buf); // size in bytes
|
|
res = RegQueryValueEx(hCommandKey, L"", nil, &type, (LPBYTE) buf,
|
|
&size);
|
|
if (res == ERROR_SUCCESS && size > 1) {
|
|
WMSG1(" Command already exists, not altering ('%ls')\n", buf);
|
|
} else {
|
|
CString openCmd;
|
|
|
|
openCmd.Format(L"\"%ls\" \"%%1\"", exeName);
|
|
if (RegSetValueEx(hCommandKey, L"", 0, REG_SZ,
|
|
(LPBYTE)(LPCWSTR) openCmd,
|
|
wcslen(openCmd) * sizeof(WCHAR)) == ERROR_SUCCESS)
|
|
{
|
|
WMSG1(" Set command to '%ls'\n", openCmd);
|
|
} else {
|
|
WMSG1(" WARNING: unable to set open cmd '%ls'\n", openCmd);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
RegCloseKey(hCommandKey);
|
|
RegCloseKey(hOpenKey);
|
|
RegCloseKey(hShellKey);
|
|
}
|
|
|
|
|
|
/*
|
|
* Return the number of file type associations.
|
|
*/
|
|
int
|
|
MyRegistry::GetNumFileAssocs(void) const
|
|
{
|
|
return NELEM(kFileTypeAssoc);
|
|
}
|
|
|
|
#if 0
|
|
/*
|
|
* Return information on a file association.
|
|
*
|
|
* Check to see if we're the application that will be launched.
|
|
*
|
|
* Problem: the file must *actually exist* for this to work.
|
|
*/
|
|
void
|
|
MyRegistry::GetFileAssoc(int idx, CString* pExt, CString* pHandler,
|
|
bool* pOurs) const
|
|
{
|
|
char buf[MAX_PATH];
|
|
|
|
*pExt = kFileTypeAssoc[idx].ext;
|
|
*pHandler = "";
|
|
*pOurs = false;
|
|
|
|
HINSTANCE res = FindExecutable(*pExt, "\\", buf);
|
|
if ((long) res > 32) {
|
|
WMSG1("Executable is '%s'\n", buf);
|
|
*pHandler = buf;
|
|
} else {
|
|
WMSG1("FindExecutable failed (err=%d)\n", res);
|
|
*pHandler = kNoAssociation;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
|
|
/*
|
|
* Return information on a file association.
|
|
*
|
|
* We check to see if the file extension is associated with one of our
|
|
* application ID strings. We don't bother to check whether the appID
|
|
* strings are still associated with CiderPress, since nobody should be
|
|
* messing with those.
|
|
*
|
|
* BUG: we should be checking to see what the shell actually does to
|
|
* take into account the overrides that users can set.
|
|
*/
|
|
void
|
|
MyRegistry::GetFileAssoc(int idx, CString* pExt, CString* pHandler,
|
|
bool* pOurs) const
|
|
{
|
|
ASSERT(idx >= 0 && idx < NELEM(kFileTypeAssoc));
|
|
long res;
|
|
|
|
*pExt = kFileTypeAssoc[idx].ext;
|
|
*pHandler = "";
|
|
|
|
CString appID;
|
|
HKEY hExtKey = nil;
|
|
|
|
res = RegOpenKeyEx(HKEY_CLASSES_ROOT, *pExt, 0, KEY_READ, &hExtKey);
|
|
if (res == ERROR_SUCCESS) {
|
|
WCHAR buf[260];
|
|
DWORD type;
|
|
DWORD size = sizeof(buf); // size in bytes
|
|
|
|
res = RegQueryValueEx(hExtKey, L"", nil, &type, (LPBYTE)buf, &size);
|
|
if (res == ERROR_SUCCESS) {
|
|
WMSG1(" Got '%ls'\n", buf);
|
|
appID = buf;
|
|
|
|
if (GetAssocAppName(appID, pHandler) != 0)
|
|
*pHandler = appID;
|
|
} else {
|
|
WMSG1("RegQueryValueEx failed on '%ls'\n", (LPCWSTR) *pExt);
|
|
}
|
|
} else {
|
|
WMSG1(" RegOpenKeyEx failed on '%ls'\n", *pExt);
|
|
}
|
|
|
|
*pOurs = false;
|
|
if (pHandler->IsEmpty()) {
|
|
*pHandler = kNoAssociation;
|
|
} else {
|
|
*pOurs = IsOurAppID(appID);
|
|
}
|
|
|
|
RegCloseKey(hExtKey);
|
|
}
|
|
|
|
/*
|
|
* Given an application ID, determine the application's name.
|
|
*
|
|
* This requires burrowing down into HKEY_CLASSES_ROOT\<appID>\shell\open\.
|
|
*/
|
|
int
|
|
MyRegistry::GetAssocAppName(const CString& appID, CString* pCmd) const
|
|
{
|
|
CString keyName;
|
|
WCHAR buf[260];
|
|
HKEY hAppKey = nil;
|
|
long res;
|
|
int result = -1;
|
|
|
|
keyName = appID + L"\\shell\\open\\command";
|
|
|
|
res = RegOpenKeyEx(HKEY_CLASSES_ROOT, keyName, 0, KEY_READ, &hAppKey);
|
|
if (res == ERROR_SUCCESS) {
|
|
DWORD type;
|
|
DWORD size = sizeof(buf); // size in bytes
|
|
|
|
res = RegQueryValueEx(hAppKey, L"", nil, &type, (LPBYTE) buf, &size);
|
|
if (res == ERROR_SUCCESS) {
|
|
CString cmd(buf);
|
|
int pos;
|
|
|
|
/* cut it down to just the EXE name */
|
|
ReduceToToken(&cmd);
|
|
|
|
pos = cmd.ReverseFind('\\');
|
|
if (pos != -1 && pos != cmd.GetLength()-1) {
|
|
cmd = cmd.Right(cmd.GetLength() - pos -1);
|
|
}
|
|
|
|
*pCmd = cmd;
|
|
result = 0;
|
|
} else {
|
|
WMSG1("Unable to open shell\\open\\command for '%ls'\n", appID);
|
|
}
|
|
} else {
|
|
CString errBuf;
|
|
GetWin32ErrorString(res, &errBuf);
|
|
|
|
WMSG2("Unable to open AppID key '%ls' (%ls)\n",
|
|
keyName, (LPCWSTR) errBuf);
|
|
}
|
|
|
|
RegCloseKey(hAppKey);
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
* Reduce a compound string to just its first token.
|
|
*/
|
|
void
|
|
MyRegistry::ReduceToToken(CString* pStr) const
|
|
{
|
|
WCHAR* argv[1];
|
|
int argc = 1;
|
|
WCHAR* mangle = wcsdup(*pStr);
|
|
|
|
VectorizeString(mangle, argv, &argc);
|
|
|
|
if (argc == 1)
|
|
*pStr = argv[0];
|
|
|
|
free(mangle);
|
|
}
|
|
|
|
/*
|
|
* Set the state of a file association. There are four possibilities:
|
|
*
|
|
* - We own it, we want to keep owning it: do nothing.
|
|
* - We don't own it, we want to keep not owning it: do nothing.
|
|
* - We own it, we don't want it anymore: remove ".xxx" entry.
|
|
* - We don't own it, we want to own it: remove ".xxx" entry and replace it.
|
|
*
|
|
* Returns 0 on success, nonzero on failure.
|
|
*/
|
|
int
|
|
MyRegistry::SetFileAssoc(int idx, bool wantIt) const
|
|
{
|
|
const WCHAR* ext;
|
|
bool weOwnIt;
|
|
int result = 0;
|
|
|
|
ASSERT(idx >= 0 && idx < NELEM(kFileTypeAssoc));
|
|
|
|
ext = kFileTypeAssoc[idx].ext;
|
|
weOwnIt = GetAssocState(ext);
|
|
WMSG3("SetFileAssoc: ext='%ls' own=%d want=%d\n", ext, weOwnIt, wantIt);
|
|
|
|
if (weOwnIt && !wantIt) {
|
|
/* reset it */
|
|
WMSG1(" SetFileAssoc: clearing '%ls'\n", ext);
|
|
result = DisownExtension(ext);
|
|
} else if (!weOwnIt && wantIt) {
|
|
/* take it */
|
|
WMSG1(" SetFileAssoc: taking '%ls'\n", ext);
|
|
result = OwnExtension(ext, kFileTypeAssoc[idx].appID);
|
|
} else {
|
|
WMSG1(" SetFileAssoc: do nothing with '%ls'\n", ext);
|
|
/* do nothing */
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Determine whether or not the filetype described by "ext" is one that we
|
|
* currently manage.
|
|
*
|
|
* Returns "true" if so, "false" if not. Returns "false" on any errors
|
|
* encountered.
|
|
*/
|
|
bool
|
|
MyRegistry::GetAssocState(const WCHAR* ext) const
|
|
{
|
|
WCHAR buf[260];
|
|
HKEY hExtKey = nil;
|
|
int res;
|
|
bool result = false;
|
|
|
|
res = RegOpenKeyEx(HKEY_CLASSES_ROOT, ext, 0, KEY_READ, &hExtKey);
|
|
if (res == ERROR_SUCCESS) {
|
|
DWORD type;
|
|
DWORD size = sizeof(buf); // size in bytes
|
|
res = RegQueryValueEx(hExtKey, L"", nil, &type, (LPBYTE) buf, &size);
|
|
if (res == ERROR_SUCCESS && type == REG_SZ) {
|
|
/* compare it to known appID values */
|
|
WMSG2(" Found '%ls', testing '%ls'\n", ext, buf);
|
|
if (IsOurAppID((WCHAR*)buf))
|
|
result = true;
|
|
}
|
|
}
|
|
|
|
RegCloseKey(hExtKey);
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
* Drop ownership of a file extension.
|
|
*
|
|
* We assume we own it.
|
|
*
|
|
* Returns 0 on success, -1 on error.
|
|
*/
|
|
int
|
|
MyRegistry::DisownExtension(const WCHAR* ext) const
|
|
{
|
|
ASSERT(ext != nil);
|
|
ASSERT(ext[0] == '.');
|
|
if (ext == nil || wcslen(ext) < 2)
|
|
return -1;
|
|
|
|
if (RegDeleteKeyNT(HKEY_CLASSES_ROOT, ext) == ERROR_SUCCESS) {
|
|
WMSG1(" HKCR\\%ls subtree deleted\n", ext);
|
|
} else {
|
|
WMSG1(" Failed deleting HKCR\\'%ls'\n", ext);
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Take ownership of a file extension.
|
|
*
|
|
* Returns 0 on success, -1 on error.
|
|
*/
|
|
int
|
|
MyRegistry::OwnExtension(const WCHAR* ext, const WCHAR* appID) const
|
|
{
|
|
ASSERT(ext != nil);
|
|
ASSERT(ext[0] == '.');
|
|
if (ext == nil || wcslen(ext) < 2)
|
|
return -1;
|
|
|
|
HKEY hExtKey = nil;
|
|
DWORD dw;
|
|
int res, result = -1;
|
|
|
|
/* delete the old key (which might be a hierarchy) */
|
|
res = RegDeleteKeyNT(HKEY_CLASSES_ROOT, ext);
|
|
if (res == ERROR_SUCCESS) {
|
|
WMSG1(" HKCR\\%ls subtree deleted\n", ext);
|
|
} else if (res == ERROR_FILE_NOT_FOUND) {
|
|
WMSG1(" No HKCR\\%ls subtree to delete\n", ext);
|
|
} else {
|
|
WMSG1(" Failed deleting HKCR\\'%ls'\n", ext);
|
|
goto bail;
|
|
}
|
|
|
|
/* set the new key */
|
|
if (RegCreateKeyEx(HKEY_CLASSES_ROOT, ext, 0, REG_NONE,
|
|
REG_OPTION_NON_VOLATILE, KEY_WRITE|KEY_READ, NULL,
|
|
&hExtKey, &dw) == ERROR_SUCCESS)
|
|
{
|
|
res = RegSetValueEx(hExtKey, L"", 0, REG_SZ,
|
|
(LPBYTE) appID, wcslen(appID) * sizeof(WCHAR));
|
|
if (res == ERROR_SUCCESS) {
|
|
WMSG2(" Set '%ls' to '%ls'\n", ext, appID);
|
|
result = 0;
|
|
} else {
|
|
WMSG3("Failed setting '%ls' to '%ls' (res=%d)\n", ext, appID, res);
|
|
goto bail;
|
|
}
|
|
}
|
|
|
|
bail:
|
|
RegCloseKey(hExtKey);
|
|
return result;
|
|
}
|
|
|
|
|
|
// (This comes from the MSDN sample sources.)
|
|
//
|
|
// The sample code makes no attempt to check or recover from partial
|
|
// deletions.
|
|
//
|
|
// A registry key that is opened by an application can be deleted
|
|
// without error by another application in both Windows 95 and
|
|
// Windows NT. This is by design.
|
|
//
|
|
#define MAX_KEY_LENGTH 256 // not in any header I can find ++ATM
|
|
DWORD
|
|
MyRegistry::RegDeleteKeyNT(HKEY hStartKey, LPCTSTR pKeyName) const
|
|
{
|
|
DWORD dwRtn, dwSubKeyLength;
|
|
LPTSTR pSubKey = NULL;
|
|
TCHAR szSubKey[MAX_KEY_LENGTH]; // (256) this should be dynamic.
|
|
HKEY hKey;
|
|
|
|
// Do not allow NULL or empty key name
|
|
if ( pKeyName && lstrlen(pKeyName))
|
|
{
|
|
if( (dwRtn=RegOpenKeyEx(hStartKey,pKeyName,
|
|
0, KEY_ENUMERATE_SUB_KEYS | DELETE, &hKey )) == ERROR_SUCCESS)
|
|
{
|
|
while (dwRtn == ERROR_SUCCESS )
|
|
{
|
|
dwSubKeyLength = MAX_KEY_LENGTH;
|
|
dwRtn=RegEnumKeyEx(
|
|
hKey,
|
|
0, // always index zero, because we're deleting it
|
|
szSubKey,
|
|
&dwSubKeyLength,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL
|
|
);
|
|
|
|
if(dwRtn == ERROR_NO_MORE_ITEMS)
|
|
{
|
|
dwRtn = RegDeleteKey(hStartKey, pKeyName);
|
|
break;
|
|
}
|
|
else if(dwRtn == ERROR_SUCCESS)
|
|
dwRtn=RegDeleteKeyNT(hKey, szSubKey);
|
|
}
|
|
RegCloseKey(hKey);
|
|
// Do not save return code because error
|
|
// has already occurred
|
|
}
|
|
}
|
|
else
|
|
dwRtn = ERROR_BADKEY;
|
|
|
|
return dwRtn;
|
|
}
|