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.
372 lines
11 KiB
372 lines
11 KiB
//++
|
|
//
|
|
// Copyright (C) Microsoft Corporation, 1987 - 1999
|
|
//
|
|
// Module Name:
|
|
//
|
|
// regutil.c
|
|
//
|
|
// Abstract:
|
|
//
|
|
// Queries into network drivers
|
|
//
|
|
// Author:
|
|
//
|
|
// Anilth - 4-20-1998
|
|
//
|
|
// Environment:
|
|
//
|
|
// User mode only.
|
|
// Contains NT-specific code.
|
|
//
|
|
// Revision History:
|
|
//
|
|
//--
|
|
|
|
#include "precomp.h"
|
|
#include "ipcfg.h"
|
|
|
|
//Registry Reading functions, should be able to be replaced by HrReg... standard routines
|
|
|
|
BOOL ReadRegistryString(HKEY Key, LPCTSTR ParameterName, LPTSTR String, LPDWORD Length)
|
|
{
|
|
|
|
LONG err;
|
|
DWORD valueType;
|
|
|
|
*String = '\0';
|
|
err = RegQueryValueEx(Key,
|
|
ParameterName,
|
|
NULL, // reserved
|
|
&valueType,
|
|
(LPBYTE)String,
|
|
Length
|
|
);
|
|
|
|
if (err == ERROR_SUCCESS) {
|
|
|
|
ASSERT(valueType == REG_SZ || valueType == REG_MULTI_SZ);
|
|
|
|
DEBUG_PRINT(("ReadRegistryString(%s): val = \"%s\", type = %d, len = %d\n",
|
|
ParameterName,
|
|
String,
|
|
valueType,
|
|
*Length
|
|
));
|
|
|
|
|
|
} else {
|
|
|
|
DEBUG_PRINT(("ReadRegistryString(%s): err = %d\n", ParameterName, err));
|
|
|
|
}
|
|
|
|
return ((err == ERROR_SUCCESS) && (*Length > sizeof('\0')));
|
|
}
|
|
|
|
|
|
|
|
BOOL ReadRegistryIpAddrString(HKEY Key, LPCTSTR ParameterName, PIP_ADDR_STRING IpAddr)
|
|
{
|
|
|
|
LONG err;
|
|
DWORD valueLength = 0;
|
|
DWORD valueType;
|
|
LPBYTE valueBuffer;
|
|
|
|
UINT stringCount;
|
|
LPTSTR stringPointer;
|
|
LPTSTR stringAddress[MAX_STRING_LIST_LENGTH + 1];
|
|
UINT i;
|
|
|
|
err = RegQueryValueEx(Key,
|
|
ParameterName,
|
|
NULL, // reserved
|
|
&valueType,
|
|
NULL,
|
|
&valueLength
|
|
);
|
|
if ((err == ERROR_SUCCESS))
|
|
{
|
|
if((valueLength > 1) && (valueType == REG_SZ)
|
|
|| (valueLength > 2) && (valueType == REG_MULTI_SZ) )
|
|
{
|
|
valueBuffer = Malloc(valueLength);
|
|
if( NULL == valueBuffer)
|
|
{
|
|
DebugMessage("Out of Memory!");
|
|
err = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto Error;
|
|
}
|
|
err = RegQueryValueEx(Key,
|
|
ParameterName,
|
|
NULL, // reserved
|
|
&valueType,
|
|
valueBuffer,
|
|
&valueLength
|
|
);
|
|
|
|
if ((err == ERROR_SUCCESS) && (valueLength > 1))
|
|
{
|
|
stringPointer = valueBuffer;
|
|
|
|
DEBUG_PRINT(("ReadRegistryIpAddrString(%s): \"%s\", len = %d\n",
|
|
ParameterName,
|
|
valueBuffer,
|
|
valueLength
|
|
));
|
|
|
|
if( REG_SZ == valueType )
|
|
{
|
|
stringPointer += strspn(stringPointer, STRING_ARRAY_DELIMITERS);
|
|
stringAddress[0] = stringPointer;
|
|
stringCount = 1;
|
|
while (stringPointer = strpbrk(stringPointer, STRING_ARRAY_DELIMITERS))
|
|
{
|
|
*stringPointer++ = '\0';
|
|
stringPointer += strspn(stringPointer, STRING_ARRAY_DELIMITERS);
|
|
stringAddress[stringCount] = stringPointer;
|
|
if (*stringPointer)
|
|
{
|
|
++stringCount;
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < stringCount; ++i)
|
|
{
|
|
AddIpAddressString(IpAddr, stringAddress[i], "");
|
|
}
|
|
}
|
|
else if( REG_MULTI_SZ == valueType )
|
|
{
|
|
stringCount = 0;
|
|
while(strlen(stringPointer))
|
|
{
|
|
AddIpAddressString(IpAddr, stringPointer, "");
|
|
stringPointer += 1+strlen(stringPointer);
|
|
stringCount ++;
|
|
}
|
|
if( 0 == stringCount )
|
|
err = ERROR_PATH_NOT_FOUND;
|
|
}
|
|
else
|
|
{
|
|
err = ERROR_PATH_NOT_FOUND;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
|
|
DEBUG_PRINT(("ReadRegistryIpAddrString(%s): err = %d, len = %d\n",
|
|
ParameterName,
|
|
err,
|
|
valueLength
|
|
));
|
|
|
|
err = ERROR_PATH_NOT_FOUND;
|
|
}
|
|
|
|
Free(valueBuffer);
|
|
}
|
|
else
|
|
{
|
|
|
|
DEBUG_PRINT(("ReadRegistryIpAddrString(%s): err = %d, type = %d, len = %d\n",
|
|
ParameterName,
|
|
err,
|
|
valueType,
|
|
valueLength
|
|
));
|
|
|
|
err = ERROR_PATH_NOT_FOUND;
|
|
}
|
|
}
|
|
Error:
|
|
return (err == ERROR_SUCCESS);
|
|
}
|
|
|
|
BOOL ReadRegistryOemString(HKEY Key, LPWSTR ParameterName, LPTSTR String, LPDWORD Length)
|
|
{
|
|
|
|
LONG err;
|
|
DWORD valueType;
|
|
DWORD valueLength = 0;
|
|
|
|
//
|
|
// first, get the length of the string
|
|
//
|
|
|
|
*String = '\0';
|
|
err = RegQueryValueExW(Key,
|
|
ParameterName,
|
|
NULL, // reserved
|
|
&valueType,
|
|
NULL,
|
|
&valueLength
|
|
);
|
|
if ((err == ERROR_SUCCESS) && (valueType == REG_SZ))
|
|
{
|
|
if ((valueLength <= *Length) && (valueLength > sizeof(L'\0')))
|
|
{
|
|
|
|
UNICODE_STRING unicodeString;
|
|
OEM_STRING oemString;
|
|
LPWSTR str = (LPWSTR)Malloc(valueLength);
|
|
|
|
if(NULL == str)
|
|
{
|
|
assert(FALSE);
|
|
DebugMessage("Out of memory!\n");
|
|
err = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto Error;
|
|
}
|
|
|
|
//
|
|
// read the UNICODE string into allocated memory
|
|
//
|
|
|
|
err = RegQueryValueExW(Key,
|
|
ParameterName,
|
|
NULL,
|
|
&valueType,
|
|
(LPBYTE)str,
|
|
&valueLength
|
|
);
|
|
if (err == ERROR_SUCCESS) {
|
|
|
|
//
|
|
// convert the UNICODE string to OEM character set
|
|
//
|
|
RtlInitUnicodeString(&unicodeString, str);
|
|
if ( RtlUnicodeStringToOemString(&oemString, &unicodeString, TRUE) == STATUS_SUCCESS)
|
|
{
|
|
if (oemString.Buffer != NULL)
|
|
{
|
|
strcpy(String, oemString.Buffer);
|
|
DEBUG_PRINT(("ReadRegistryOemString(%ws): val = \"%s\", len = %d\n",
|
|
ParameterName,
|
|
String,
|
|
valueLength
|
|
));
|
|
}
|
|
RtlFreeOemString(&oemString);
|
|
}
|
|
|
|
} else {
|
|
|
|
DEBUG_PRINT(("ReadRegistryOemString(%ws): err = %d, type = %d, len = %d\n",
|
|
ParameterName,
|
|
err,
|
|
valueType,
|
|
valueLength
|
|
));
|
|
|
|
}
|
|
|
|
Free(str);
|
|
|
|
}
|
|
else
|
|
{
|
|
DEBUG_PRINT(("ReadRegistryOemString(%ws): err = %d, type = %d, len = %d\n",
|
|
ParameterName,
|
|
err,
|
|
valueType,
|
|
valueLength
|
|
));
|
|
|
|
err = !ERROR_SUCCESS;
|
|
}
|
|
} else {
|
|
|
|
DEBUG_PRINT(("ReadRegistryOemString(%ws): err = %d, type = %d, len = %d\n",
|
|
ParameterName,
|
|
err,
|
|
valueType,
|
|
valueLength
|
|
));
|
|
|
|
err = !ERROR_SUCCESS;
|
|
}
|
|
Error:
|
|
|
|
return (err == ERROR_SUCCESS);
|
|
}
|
|
|
|
BOOL ReadRegistryDword(HKEY Key, LPCTSTR ParameterName, LPDWORD Value)
|
|
{
|
|
|
|
LONG err;
|
|
DWORD valueLength;
|
|
DWORD valueType;
|
|
|
|
valueLength = sizeof(*Value);
|
|
err = RegQueryValueEx(Key,
|
|
ParameterName,
|
|
NULL, // reserved
|
|
&valueType,
|
|
(LPBYTE)Value,
|
|
&valueLength
|
|
);
|
|
if ((err == ERROR_SUCCESS) && (valueType == REG_DWORD) && (valueLength == sizeof(DWORD)))
|
|
{
|
|
|
|
DEBUG_PRINT(("ReadRegistryDword(%s): val = %d, type = %d, len = %d\n",
|
|
ParameterName,
|
|
*Value,
|
|
valueType,
|
|
valueLength
|
|
));
|
|
|
|
} else {
|
|
|
|
DEBUG_PRINT(("ReadRegistryDword(%d,%s): err = %d\n",
|
|
Key, ParameterName, err));
|
|
|
|
err = !ERROR_SUCCESS;
|
|
}
|
|
|
|
return (err == ERROR_SUCCESS);
|
|
}
|
|
|
|
BOOL
|
|
OpenAdapterKey(
|
|
const LPTSTR AdapterName,
|
|
PHKEY Key
|
|
)
|
|
{
|
|
LONG err;
|
|
CHAR keyName[MAX_ADAPTER_NAME_LENGTH + sizeof(TCPIP_PARAMS_INTER_KEY)];
|
|
HKEY ServicesKey;
|
|
|
|
if (NULL == AdapterName) {
|
|
DEBUG_PRINT("No Adapter Name");
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// open the handle to this adapter's TCPIP parameter key
|
|
//
|
|
|
|
strcpy(keyName, TCPIP_PARAMS_INTER_KEY );
|
|
strcat(keyName, AdapterName);
|
|
|
|
err = RegOpenKey(HKEY_LOCAL_MACHINE,SERVICES_KEY,&ServicesKey);
|
|
|
|
if (err != ERROR_SUCCESS) {
|
|
DEBUG_PRINT("Opening Services key failed!\n");
|
|
return FALSE;
|
|
}
|
|
|
|
err = RegOpenKey(ServicesKey, keyName, Key );
|
|
|
|
if( err != ERROR_SUCCESS ){
|
|
DEBUG_PRINT(("OpenAdapterKey: RegOpenKey ServicesKey %s, err=%d\n",
|
|
keyName, GetLastError() ));
|
|
}else{
|
|
TRACE_PRINT(("Exit OpenAdapterKey: %s ok\n", keyName ));
|
|
}
|
|
|
|
return (err == ERROR_SUCCESS);
|
|
}
|
|
|