879 lines
23 KiB
C
879 lines
23 KiB
C
/*++
|
||
|
||
Copyright (c) 1995-2001 Microsoft Corporation
|
||
|
||
Module Name:
|
||
|
||
cutil.c
|
||
|
||
Abstract:
|
||
|
||
This module contains general utility routines used by both cfgmgr32
|
||
and umpnpmgr.
|
||
|
||
IsLegalDeviceId
|
||
SplitDeviceInstanceString
|
||
DeletePrivateKey
|
||
RegDeleteNode
|
||
Split1
|
||
Split2
|
||
GetDevNodeKeyPath
|
||
MapRpcExceptionToCR
|
||
|
||
Author:
|
||
|
||
Paula Tomlinson (paulat) 7-12-1995
|
||
|
||
Environment:
|
||
|
||
User mode only.
|
||
|
||
Revision History:
|
||
|
||
12-July-1995 paulat
|
||
|
||
Creation and initial implementation.
|
||
|
||
--*/
|
||
|
||
|
||
//
|
||
// includes
|
||
//
|
||
#include "precomp.h"
|
||
#include "umpnplib.h"
|
||
|
||
|
||
|
||
//
|
||
// Common private utility routines (used by client and server)
|
||
//
|
||
|
||
BOOL
|
||
IsLegalDeviceId(
|
||
IN LPCWSTR pszDeviceInstance
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine parses the device instance string and validates whether it
|
||
conforms to the appropriate rules, including:
|
||
|
||
- Total length of the device instance path must not be longer than
|
||
MAX_DEVICE_ID_LEN characters.
|
||
|
||
- The device instance path must contain exactly 3 non-empty path components.
|
||
|
||
- The device instance path string must not contain any "invalid characters".
|
||
|
||
Invalid characters are:
|
||
c <= 0x20 (' ')
|
||
c > 0x7F
|
||
c == 0x2C (',')
|
||
|
||
Arguments:
|
||
|
||
pszDeviceInstance - Device instance path.
|
||
|
||
Return value:
|
||
|
||
The return value is TRUE if the device instance path string conforms to the
|
||
rules.
|
||
|
||
--*/
|
||
|
||
{
|
||
BOOL Status;
|
||
LPCWSTR p;
|
||
ULONG ulTotalLength = 0;
|
||
ULONG ulComponentLength = 0, ulComponents = 1;
|
||
|
||
try {
|
||
//
|
||
// An empty string is used for an optional device instance path.
|
||
//
|
||
if ((pszDeviceInstance == NULL) || (*pszDeviceInstance == L'\0')) {
|
||
Status = TRUE;
|
||
goto Clean0;
|
||
}
|
||
|
||
//
|
||
// Walk over the entire device instance path, counting the total length,
|
||
// individual path component lengths, and checking for the presence of
|
||
// invalid characters.
|
||
//
|
||
for (p = pszDeviceInstance; *p; p++) {
|
||
//
|
||
// Make sure the device instance path isn't too long.
|
||
//
|
||
ulTotalLength++;
|
||
|
||
if (ulTotalLength > MAX_DEVICE_ID_LEN) {
|
||
KdPrintEx((DPFLTR_PNPMGR_ID,
|
||
DBGF_ERRORS,
|
||
"PNP: IsLegalDeviceId: "
|
||
"device instance path %ws longer than "
|
||
"MAX_DEVICE_ID_LEN characters!\n",
|
||
pszDeviceInstance));
|
||
//ASSERT(ulTotalLength <= MAX_DEVICE_ID_LEN);
|
||
Status = FALSE;
|
||
goto Clean0;
|
||
}
|
||
|
||
//
|
||
// Check for the presence of invalid characters.
|
||
//
|
||
if ((*p <= L' ') || (*p > (WCHAR)0x7F) || (*p == L',')) {
|
||
KdPrintEx((DPFLTR_PNPMGR_ID,
|
||
DBGF_ERRORS,
|
||
"PNP: IsLegalDeviceId: "
|
||
"device instance path %ws contains invalid character (0x%lx)!\n",
|
||
pszDeviceInstance, *p));
|
||
//ASSERT((*p > L' ') && (*p <= (WCHAR)0x7F) && (*p != L','));
|
||
Status = FALSE;
|
||
goto Clean0;
|
||
}
|
||
|
||
//
|
||
// Check the length of individual path components.
|
||
//
|
||
if (*p == L'\\') {
|
||
//
|
||
// It is illegal for a device instance path to have multiple
|
||
// consecutive path separators, or to start with one.
|
||
//
|
||
if (ulComponentLength == 0) {
|
||
KdPrintEx((DPFLTR_PNPMGR_ID,
|
||
DBGF_ERRORS,
|
||
"PNP: IsLegalDeviceId: "
|
||
"device instance path %ws contains "
|
||
"invalid path component!\n",
|
||
pszDeviceInstance));
|
||
//ASSERT(ulComponentLength != 0);
|
||
Status = FALSE;
|
||
goto Clean0;
|
||
}
|
||
|
||
ulComponentLength = 0;
|
||
ulComponents++;
|
||
|
||
} else {
|
||
//
|
||
// Count the length of this path component to verify it's not empty.
|
||
//
|
||
ulComponentLength++;
|
||
}
|
||
}
|
||
|
||
//
|
||
// It is illegal for a device instance path to end with a path separator
|
||
// character.
|
||
//
|
||
if (ulComponentLength == 0) {
|
||
KdPrintEx((DPFLTR_PNPMGR_ID,
|
||
DBGF_ERRORS,
|
||
"PNP: IsLegalDeviceId: "
|
||
"device instance path %ws has trailing '\\' char!\n",
|
||
pszDeviceInstance));
|
||
//ASSERT(ulComponentLength != 0);
|
||
Status = FALSE;
|
||
goto Clean0;
|
||
}
|
||
|
||
//
|
||
// A valid device instance path must contain exactly 3 path components:
|
||
// an enumerator id, a device id, and an instance id.
|
||
//
|
||
if (ulComponents != 3) {
|
||
KdPrintEx((DPFLTR_PNPMGR_ID,
|
||
DBGF_ERRORS,
|
||
"PNP: IsLegalDeviceId: "
|
||
"device instance path %ws contains "
|
||
"invalid number of path components!\n",
|
||
pszDeviceInstance));
|
||
//ASSERT(ulComponents == 3);
|
||
Status = FALSE;
|
||
goto Clean0;
|
||
}
|
||
|
||
Status = TRUE;
|
||
|
||
Clean0:
|
||
NOTHING;
|
||
|
||
} except(EXCEPTION_EXECUTE_HANDLER) {
|
||
KdPrintEx((DPFLTR_PNPMGR_ID,
|
||
DBGF_ERRORS,
|
||
"PNP: Exception in IsLegalDeviceId!! "
|
||
"exception code = %d\n",
|
||
GetExceptionCode()));
|
||
Status = FALSE;
|
||
}
|
||
|
||
return Status;
|
||
|
||
} // IsLegalDeviceId
|
||
|
||
|
||
|
||
BOOL
|
||
SplitDeviceInstanceString(
|
||
IN LPCWSTR pszDeviceInstance,
|
||
OUT LPWSTR pszBase,
|
||
OUT LPWSTR pszDeviceID,
|
||
OUT LPWSTR pszInstanceID
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine parses a device instance string into it's three component
|
||
parts. Since this is an internal routine, NO error checking is done on
|
||
the pszBase, pszDeviceID, and pszInstanceID routines; I always assume that
|
||
valid pointers are passed in and that each of these buffers is at least
|
||
MAX_DEVICE_ID_LEN characters in length. I do some error checking on the
|
||
pszDeviceInstance string since it is passed in from the client side.
|
||
|
||
Arguments:
|
||
|
||
|
||
Return value:
|
||
|
||
The return value is TRUE if the function suceeds and FALSE if it fails.
|
||
|
||
--*/
|
||
|
||
{
|
||
UINT ulLength, i, j;
|
||
|
||
|
||
ulLength = lstrlen(pszDeviceInstance);
|
||
|
||
//
|
||
// parse the string for the first backslash character
|
||
//
|
||
|
||
for (i=0; i < ulLength && pszDeviceInstance[i] != '\0' &&
|
||
pszDeviceInstance[i] != '\\'; i++);
|
||
|
||
if (pszDeviceInstance[i] != '\\') {
|
||
lstrcpyn(pszBase, pszDeviceInstance,MAX_DEVICE_ID_LEN);
|
||
*pszDeviceID = '\0';
|
||
*pszInstanceID = '\0';
|
||
return FALSE; // not a complete device instance string
|
||
}
|
||
|
||
i++; // increment past the backslash character
|
||
if (i < ulLength && pszDeviceInstance[i] != '\0') {
|
||
lstrcpyn(pszBase, pszDeviceInstance, min(i,MAX_DEVICE_ID_LEN));
|
||
}
|
||
else {
|
||
*pszBase = '\0';
|
||
*pszDeviceID = '\0';
|
||
*pszInstanceID = '\0';
|
||
return FALSE;
|
||
}
|
||
|
||
|
||
//
|
||
// parse the string for second backslash character
|
||
//
|
||
for (j=i; j < ulLength && pszDeviceInstance[j] != '\0' &&
|
||
pszDeviceInstance[j] != '\\'; j++);
|
||
|
||
if (pszDeviceInstance[j] != '\\' || j > ulLength) {
|
||
lstrcpyn(pszDeviceID, &pszDeviceInstance[i],MAX_DEVICE_ID_LEN);
|
||
*pszInstanceID = '\0';
|
||
return FALSE;
|
||
}
|
||
|
||
j++;
|
||
lstrcpyn(pszDeviceID, &pszDeviceInstance[i], min(j-i,MAX_DEVICE_ID_LEN));
|
||
lstrcpyn(pszInstanceID, &pszDeviceInstance[j], min((ulLength-j+1),MAX_DEVICE_ID_LEN));
|
||
|
||
return TRUE;
|
||
|
||
} // SplitDeviceInstanceString
|
||
|
||
|
||
|
||
CONFIGRET
|
||
DeletePrivateKey(
|
||
IN HKEY hBranchKey,
|
||
IN LPCWSTR pszParentKey,
|
||
IN LPCWSTR pszChildKey
|
||
)
|
||
{
|
||
CONFIGRET Status = CR_SUCCESS;
|
||
LONG RegStatus = ERROR_SUCCESS;
|
||
WCHAR RegStr[2*MAX_CM_PATH],
|
||
szKey1[MAX_CM_PATH],
|
||
szKey2[MAX_CM_PATH];
|
||
HKEY hKey = NULL;
|
||
ULONG ulSubKeys = 0;
|
||
|
||
|
||
//
|
||
// Make sure the specified registry key paths are valid.
|
||
//
|
||
if ((pszParentKey == NULL) ||
|
||
(pszChildKey == NULL) ||
|
||
((lstrlen(pszParentKey) + 1) > MAX_CM_PATH) ||
|
||
((lstrlen(pszChildKey) + 1) > MAX_CM_PATH)) {
|
||
Status = CR_INVALID_POINTER;
|
||
goto Clean0;
|
||
}
|
||
|
||
//
|
||
// is the specified child key a compound registry key?
|
||
//
|
||
if (!Split1(pszChildKey, szKey1, szKey2)) {
|
||
|
||
//------------------------------------------------------------------
|
||
// Only a single child key was specified, so just open the parent
|
||
// registry key and delete the child (and any of its subkeys)
|
||
//------------------------------------------------------------------
|
||
|
||
if (RegOpenKeyEx(hBranchKey, pszParentKey, 0,
|
||
KEY_READ | KEY_WRITE, &hKey) != ERROR_SUCCESS) {
|
||
goto Clean0; // no error, nothing to delete
|
||
}
|
||
|
||
if (!RegDeleteNode(hKey, pszChildKey)) {
|
||
Status = CR_REGISTRY_ERROR;
|
||
goto Clean0;
|
||
}
|
||
}
|
||
|
||
else {
|
||
|
||
//------------------------------------------------------------------
|
||
// if a compound registry path was passed in, such as key1\key2
|
||
// then always delete key2 but delete key1 only if it has no other
|
||
// subkeys besides key2.
|
||
//------------------------------------------------------------------
|
||
|
||
//
|
||
// open the first level key
|
||
//
|
||
wsprintf(RegStr, TEXT("%s\\%s"),
|
||
pszParentKey,
|
||
szKey1);
|
||
|
||
RegStatus = RegOpenKeyEx(
|
||
hBranchKey, RegStr, 0, KEY_QUERY_VALUE | KEY_SET_VALUE,
|
||
&hKey);
|
||
|
||
if (RegStatus != ERROR_SUCCESS) {
|
||
goto Clean0; // no error, nothing to delete
|
||
}
|
||
|
||
//
|
||
// try to delete the second level key
|
||
//
|
||
if (!RegDeleteNode(hKey, szKey2)) {
|
||
goto Clean0; // no error, nothing to delete
|
||
}
|
||
|
||
//
|
||
// How many subkeys are remaining?
|
||
//
|
||
RegStatus = RegQueryInfoKey(
|
||
hKey, NULL, NULL, NULL, &ulSubKeys,
|
||
NULL, NULL, NULL, NULL, NULL, NULL, NULL);
|
||
|
||
if (RegStatus != ERROR_SUCCESS) {
|
||
goto Clean0; // nothing to delete
|
||
}
|
||
|
||
//
|
||
// if no more subkeys, then delete the first level key
|
||
//
|
||
if (ulSubKeys == 0) {
|
||
|
||
RegCloseKey(hKey);
|
||
hKey = NULL;
|
||
|
||
RegStatus = RegOpenKeyEx(
|
||
hBranchKey, pszParentKey, 0,
|
||
KEY_QUERY_VALUE | KEY_SET_VALUE, &hKey);
|
||
|
||
if (RegStatus != ERROR_SUCCESS) {
|
||
goto Clean0; // no error, nothing to delete
|
||
}
|
||
|
||
if (!RegDeleteNode(hKey, szKey1)) {
|
||
Status = CR_REGISTRY_ERROR;
|
||
goto Clean0;
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
Clean0:
|
||
|
||
if (hKey != NULL) {
|
||
RegCloseKey(hKey);
|
||
}
|
||
|
||
return Status;
|
||
|
||
} // DeletePrivateKey
|
||
|
||
|
||
|
||
BOOL
|
||
RegDeleteNode(
|
||
HKEY hParentKey,
|
||
LPCWSTR szKey
|
||
)
|
||
{
|
||
ULONG ulSize = 0;
|
||
LONG RegStatus = ERROR_SUCCESS;
|
||
HKEY hKey = NULL;
|
||
WCHAR szSubKey[MAX_PATH];
|
||
|
||
|
||
//
|
||
// attempt to delete the key
|
||
//
|
||
if (RegDeleteKey(hParentKey, szKey) != ERROR_SUCCESS) {
|
||
|
||
RegStatus = RegOpenKeyEx(
|
||
hParentKey, szKey, 0, KEY_ALL_ACCESS, &hKey);
|
||
|
||
//
|
||
// enumerate subkeys and delete those nodes
|
||
//
|
||
while (RegStatus == ERROR_SUCCESS) {
|
||
//
|
||
// enumerate the first level children under the profile key
|
||
// (always use index 0, enumeration looses track when a key
|
||
// is added or deleted)
|
||
//
|
||
ulSize = MAX_PATH;
|
||
RegStatus = RegEnumKeyEx(
|
||
hKey, 0, szSubKey, &ulSize, NULL, NULL, NULL, NULL);
|
||
|
||
if (RegStatus == ERROR_SUCCESS) {
|
||
RegDeleteNode(hKey, szSubKey);
|
||
}
|
||
}
|
||
|
||
//
|
||
// either an error occured that prevents me from deleting the
|
||
// keys (like the key doesn't exist in the first place or an
|
||
// access violation) or the subkeys have been deleted, try
|
||
// deleting the top level key again
|
||
//
|
||
RegCloseKey(hKey);
|
||
RegDeleteKey(hParentKey, szKey);
|
||
}
|
||
|
||
return TRUE;
|
||
|
||
} // RegDeleteNode
|
||
|
||
|
||
|
||
BOOL
|
||
Split1(
|
||
IN LPCWSTR pszString,
|
||
OUT LPWSTR pszString1,
|
||
OUT LPWSTR pszString2
|
||
)
|
||
{
|
||
BOOL Status = TRUE;
|
||
LPWSTR p;
|
||
|
||
|
||
//
|
||
// Split the string at the first backslash character
|
||
//
|
||
|
||
try {
|
||
|
||
lstrcpy(pszString1, pszString);
|
||
for (p = pszString1; (*p) && (*p != TEXT('\\')); p++);
|
||
|
||
if (*p == TEXT('\0')) {
|
||
Status = FALSE;
|
||
goto Clean0;
|
||
}
|
||
|
||
*p = TEXT('\0'); // truncate string1
|
||
p++;
|
||
lstrcpy(pszString2, p); // the rest is string2
|
||
|
||
|
||
Clean0:
|
||
NOTHING;
|
||
|
||
} except(EXCEPTION_EXECUTE_HANDLER) {
|
||
Status = FALSE;
|
||
}
|
||
|
||
return Status;
|
||
|
||
} // Split1
|
||
|
||
|
||
|
||
BOOL
|
||
Split2(
|
||
IN LPCWSTR pszString,
|
||
OUT LPWSTR pszString1,
|
||
OUT LPWSTR pszString2
|
||
)
|
||
{
|
||
BOOL Status = TRUE;
|
||
LPWSTR p;
|
||
|
||
|
||
//
|
||
// Split the string at the second backslash character
|
||
//
|
||
|
||
try {
|
||
|
||
lstrcpy(pszString1, pszString);
|
||
for (p = pszString1; (*p) && (*p != TEXT('\\')); p++); // first
|
||
for (p++; (*p) && (*p != TEXT('\\')); p++); // second
|
||
|
||
*p = TEXT('\0'); // truncate string1
|
||
p++;
|
||
lstrcpy(pszString2, p); // the rest is string2
|
||
|
||
} except(EXCEPTION_EXECUTE_HANDLER) {
|
||
Status = FALSE;
|
||
}
|
||
|
||
return Status;
|
||
|
||
} // Split2
|
||
|
||
|
||
|
||
CONFIGRET
|
||
GetDevNodeKeyPath(
|
||
IN handle_t hBinding,
|
||
IN LPCWSTR pDeviceID,
|
||
IN ULONG ulFlags,
|
||
IN ULONG ulHardwareProfile,
|
||
OUT LPWSTR pszBaseKey,
|
||
OUT LPWSTR pszPrivateKey
|
||
)
|
||
{
|
||
CONFIGRET Status = CR_SUCCESS;
|
||
WCHAR szClassInstance[MAX_PATH], szEnumerator[MAX_DEVICE_ID_LEN];
|
||
ULONG ulSize, ulDataType = 0;
|
||
ULONG ulTransferLen;
|
||
|
||
|
||
//-------------------------------------------------------------
|
||
// form the key for the software branch case
|
||
//-------------------------------------------------------------
|
||
|
||
if (ulFlags & CM_REGISTRY_SOFTWARE) {
|
||
//
|
||
// retrieve the class name and instance ordinal by calling
|
||
// the server's reg prop routine
|
||
//
|
||
ulSize = ulTransferLen = sizeof(szClassInstance);
|
||
|
||
RpcTryExcept {
|
||
|
||
Status = PNP_GetDeviceRegProp(
|
||
hBinding,
|
||
pDeviceID,
|
||
CM_DRP_DRIVER,
|
||
&ulDataType,
|
||
(LPBYTE)szClassInstance,
|
||
&ulTransferLen,
|
||
&ulSize,
|
||
0);
|
||
}
|
||
RpcExcept (I_RpcExceptionFilter(RpcExceptionCode())) {
|
||
KdPrintEx((DPFLTR_PNPMGR_ID,
|
||
DBGF_ERRORS,
|
||
"PNP_GetDeviceRegProp caused an exception (%d)\n",
|
||
RpcExceptionCode()));
|
||
|
||
Status = MapRpcExceptionToCR(RpcExceptionCode());
|
||
}
|
||
RpcEndExcept
|
||
|
||
if (Status != CR_SUCCESS || *szClassInstance == '\0') {
|
||
//
|
||
// no Driver (class instance) value yet so ask the server to
|
||
// create a new unique one
|
||
//
|
||
ulSize = sizeof(szClassInstance);
|
||
|
||
RpcTryExcept {
|
||
|
||
Status = PNP_GetClassInstance(
|
||
hBinding,
|
||
pDeviceID,
|
||
szClassInstance,
|
||
ulSize);
|
||
}
|
||
RpcExcept (I_RpcExceptionFilter(RpcExceptionCode())) {
|
||
KdPrintEx((DPFLTR_PNPMGR_ID,
|
||
DBGF_ERRORS,
|
||
"PNP_GetClassInstance caused an exception (%d)\n",
|
||
RpcExceptionCode()));
|
||
|
||
Status = MapRpcExceptionToCR(RpcExceptionCode());
|
||
}
|
||
RpcEndExcept
|
||
|
||
if (Status != CR_SUCCESS) {
|
||
goto Clean0;
|
||
}
|
||
}
|
||
|
||
//
|
||
// the <instance> part of the class instance is the private part
|
||
//
|
||
Split1(szClassInstance, szClassInstance, pszPrivateKey);
|
||
|
||
//
|
||
// config-specific software branch case
|
||
//
|
||
if (ulFlags & CM_REGISTRY_CONFIG) {
|
||
//
|
||
// curent config
|
||
//
|
||
// System\CCC\Hardware Profiles\Current
|
||
// \System\CCC\Control\Class\<DevNodeClassInstance>
|
||
//
|
||
if (ulHardwareProfile == 0) {
|
||
|
||
wsprintf(pszBaseKey, TEXT("%s\\%s\\%s\\%s"),
|
||
REGSTR_PATH_HWPROFILES,
|
||
REGSTR_KEY_CURRENT,
|
||
REGSTR_PATH_CLASS_NT,
|
||
szClassInstance);
|
||
}
|
||
|
||
//
|
||
// all configs, use substitute string for profile id
|
||
//
|
||
else if (ulHardwareProfile == 0xFFFFFFFF) {
|
||
|
||
wsprintf(pszBaseKey, TEXT("%s\\%s\\%s\\%s"),
|
||
REGSTR_PATH_HWPROFILES,
|
||
TEXT("%s"),
|
||
REGSTR_PATH_CLASS_NT,
|
||
szClassInstance);
|
||
}
|
||
|
||
//
|
||
// specific profile specified
|
||
//
|
||
// System\CCC\Hardware Profiles\<profile>
|
||
// \System\CCC\Control\Class\<DevNodeClassInstance>
|
||
//
|
||
else {
|
||
wsprintf(pszBaseKey, TEXT("%s\\%04u\\%s\\%s"),
|
||
REGSTR_PATH_HWPROFILES,
|
||
ulHardwareProfile,
|
||
REGSTR_PATH_CLASS_NT,
|
||
szClassInstance);
|
||
}
|
||
}
|
||
|
||
//
|
||
// not config-specific
|
||
// System\CCC\Control\Class\<DevNodeClassInstance>
|
||
//
|
||
else {
|
||
wsprintf(pszBaseKey, TEXT("%s\\%s"),
|
||
REGSTR_PATH_CLASS_NT,
|
||
szClassInstance);
|
||
}
|
||
}
|
||
|
||
|
||
//-------------------------------------------------------------
|
||
// form the key for the hardware branch case
|
||
//-------------------------------------------------------------
|
||
|
||
else {
|
||
//
|
||
// config-specific hardware branch case
|
||
//
|
||
if (ulFlags & CM_REGISTRY_CONFIG) {
|
||
|
||
//
|
||
// for profile specific, the <device>\<instance> part of
|
||
// the device id is the private part
|
||
//
|
||
Split1(pDeviceID, szEnumerator, pszPrivateKey);
|
||
|
||
//
|
||
// curent config
|
||
//
|
||
if (ulHardwareProfile == 0) {
|
||
|
||
wsprintf(pszBaseKey, TEXT("%s\\%s\\%s\\%s"),
|
||
REGSTR_PATH_HWPROFILES,
|
||
REGSTR_KEY_CURRENT,
|
||
REGSTR_PATH_SYSTEMENUM,
|
||
szEnumerator);
|
||
}
|
||
|
||
//
|
||
// all configs, use replacement symbol for profile id
|
||
//
|
||
else if (ulHardwareProfile == 0xFFFFFFFF) {
|
||
|
||
wsprintf(pszBaseKey, TEXT("%s\\%s\\%s\\%s"),
|
||
REGSTR_PATH_HWPROFILES,
|
||
TEXT("%s"),
|
||
REGSTR_PATH_SYSTEMENUM,
|
||
szEnumerator);
|
||
}
|
||
|
||
//
|
||
// specific profile specified
|
||
//
|
||
else {
|
||
wsprintf(pszBaseKey, TEXT("%s\\%04u\\%s\\%s"),
|
||
REGSTR_PATH_HWPROFILES,
|
||
ulHardwareProfile,
|
||
REGSTR_PATH_SYSTEMENUM,
|
||
szEnumerator);
|
||
}
|
||
}
|
||
|
||
else if (ulFlags & CM_REGISTRY_USER) {
|
||
//
|
||
// for hardware user key, the <device>\<instance> part of
|
||
// the device id is the private part
|
||
//
|
||
Split1(pDeviceID, szEnumerator, pszPrivateKey);
|
||
|
||
wsprintf(pszBaseKey, TEXT("%s\\%s"),
|
||
REGSTR_PATH_SYSTEMENUM,
|
||
szEnumerator);
|
||
}
|
||
|
||
//
|
||
// not config-specific
|
||
//
|
||
else {
|
||
wsprintf(pszBaseKey, TEXT("%s\\%s"),
|
||
REGSTR_PATH_SYSTEMENUM,
|
||
pDeviceID);
|
||
|
||
lstrcpy(pszPrivateKey, REGSTR_KEY_DEVICEPARAMETERS);
|
||
}
|
||
}
|
||
|
||
|
||
Clean0:
|
||
|
||
return Status;
|
||
|
||
} // GetDevNodeKeyPath
|
||
|
||
|
||
|
||
CONFIGRET
|
||
MapRpcExceptionToCR(
|
||
ULONG ulRpcExceptionCode
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine takes an rpc exception code (typically received by
|
||
calling RpcExceptionCode) and returns a corresponding CR_ error
|
||
code.
|
||
|
||
Arguments:
|
||
|
||
ulRpcExceptionCode An RPC_S_ or RPC_X_ exception error code.
|
||
|
||
Return Value:
|
||
|
||
Return value is one of the CR_ error codes.
|
||
|
||
--*/
|
||
|
||
{
|
||
CONFIGRET Status = CR_FAILURE;
|
||
|
||
|
||
switch(ulRpcExceptionCode) {
|
||
|
||
//
|
||
// binding or machine name errors
|
||
//
|
||
case RPC_S_INVALID_STRING_BINDING: // 1700L
|
||
case RPC_S_WRONG_KIND_OF_BINDING: // 1701L
|
||
case RPC_S_INVALID_BINDING: // 1702L
|
||
case RPC_S_PROTSEQ_NOT_SUPPORTED: // 1703L
|
||
case RPC_S_INVALID_RPC_PROTSEQ: // 1704L
|
||
case RPC_S_INVALID_STRING_UUID: // 1705L
|
||
case RPC_S_INVALID_ENDPOINT_FORMAT: // 1706L
|
||
case RPC_S_INVALID_NET_ADDR: // 1707L
|
||
case RPC_S_NO_ENDPOINT_FOUND: // 1708L
|
||
case RPC_S_NO_MORE_BINDINGS: // 1806L
|
||
case RPC_S_CANT_CREATE_ENDPOINT: // 1720L
|
||
|
||
Status = CR_INVALID_MACHINENAME;
|
||
break;
|
||
|
||
//
|
||
// general rpc communication failure
|
||
//
|
||
case RPC_S_INVALID_NETWORK_OPTIONS: // 1724L
|
||
case RPC_S_CALL_FAILED: // 1726L
|
||
case RPC_S_CALL_FAILED_DNE: // 1727L
|
||
case RPC_S_PROTOCOL_ERROR: // 1728L
|
||
case RPC_S_UNSUPPORTED_TRANS_SYN: // 1730L
|
||
|
||
Status = CR_REMOTE_COMM_FAILURE;
|
||
break;
|
||
|
||
//
|
||
// couldn't make connection to that machine
|
||
//
|
||
case RPC_S_SERVER_UNAVAILABLE: // 1722L
|
||
case RPC_S_SERVER_TOO_BUSY: // 1723L
|
||
|
||
Status = CR_MACHINE_UNAVAILABLE;
|
||
break;
|
||
|
||
|
||
//
|
||
// server doesn't exist or not right version
|
||
//
|
||
case RPC_S_INVALID_VERS_OPTION: // 1756L
|
||
case RPC_S_INTERFACE_NOT_FOUND: // 1759L
|
||
case RPC_S_UNKNOWN_IF: // 1717L
|
||
|
||
Status = CR_NO_CM_SERVICES;
|
||
break;
|
||
|
||
//
|
||
// any other RPC exceptions will just be general failures
|
||
//
|
||
default:
|
||
Status = CR_FAILURE;
|
||
break;
|
||
}
|
||
|
||
return Status;
|
||
|
||
} // MapRpcExceptionToCR
|
||
|
||
|
||
|