781 lines
22 KiB
C++
781 lines
22 KiB
C++
/*++
|
||
|
||
Copyright (c) 1991 Microsoft Corporation
|
||
|
||
Module Name:
|
||
|
||
sockreg.cxx
|
||
|
||
Abstract:
|
||
|
||
Contains the registry/ini-file specific functions from gethost.c
|
||
|
||
Taken from Win95 Winsock 1.1 project
|
||
|
||
Contents:
|
||
SockGetSingleValue
|
||
(CheckRegistryForParameter)
|
||
|
||
Author:
|
||
|
||
Richard L Firth (rfirth) 10-Feb-1994
|
||
|
||
Environment:
|
||
|
||
Win32 user-mode DLL
|
||
|
||
Revision History:
|
||
|
||
10-Feb-1994 (rfirth)
|
||
Created
|
||
|
||
24-Feb-2001 (ssulzer)
|
||
Updated for WinHttp5
|
||
|
||
--*/
|
||
|
||
//
|
||
// includes
|
||
//
|
||
|
||
|
||
#include <wininetp.h>
|
||
#include "aproxp.h"
|
||
|
||
|
||
|
||
//
|
||
// manifests
|
||
//
|
||
|
||
//#define PLATFORM_TYPE_UNKNOWN ((DWORD)(-1))
|
||
//#define PLATFORM_TYPE_WIN95 ((DWORD)(0))
|
||
//#define PLATFORM_TYPE_WINNT ((DWORD)(1))
|
||
|
||
//#define PLATFORM_SUPPORTS_UNICODE 0x00000001
|
||
#define DEVICE_PREFIX "\\Device\\"
|
||
|
||
|
||
//
|
||
// manifests
|
||
//
|
||
|
||
//
|
||
// macros
|
||
//
|
||
|
||
#define FSTRLEN(p) lstrlen((LPSTR)(p))
|
||
#define FSTRCPY(p1, p2) lstrcpy((LPSTR)(p1), (LPSTR)(p2))
|
||
#define FSTRCAT(p1, p2) lstrcat((LPSTR)(p1), (LPSTR)(p2))
|
||
|
||
//
|
||
// MAP_PARAMETER_ID - returns a string corresponding to the database parameter
|
||
//
|
||
// N.B. id MUST start at 1
|
||
//
|
||
|
||
#define MAP_PARAMETER_ID(id) ParameterNames[(id) - 1]
|
||
|
||
//
|
||
// globally available registry keys
|
||
//
|
||
|
||
extern HKEY ServicesKey; // = INVALID_HANDLE_VALUE;
|
||
|
||
|
||
//
|
||
// private prototypes
|
||
//
|
||
|
||
PRIVATE
|
||
UINT
|
||
CheckRegistryForParameter(
|
||
IN UINT ParameterId,
|
||
OUT LPBYTE Data,
|
||
IN UINT DataLength
|
||
);
|
||
|
||
//
|
||
// private data
|
||
//
|
||
|
||
//
|
||
// ParameterNames - the names of the registry values corresponding to the
|
||
// variables retrieved by SockGetSingleValue.
|
||
//
|
||
// N.B. These MUST be in order of the CONFIG_ manifests in sockreg.h
|
||
//
|
||
|
||
PRIVATE const LPCSTR ParameterNames[] = {
|
||
"HostName",
|
||
"Domain",
|
||
"SearchList",
|
||
"NameServer"
|
||
};
|
||
|
||
//
|
||
// functions
|
||
//
|
||
|
||
/*******************************************************************************
|
||
*
|
||
* GetBoundAdapterList
|
||
*
|
||
* Gets a list of names of all adapters bound to a protocol (TCP/IP). Returns
|
||
* a pointer to an array of pointers to strings - basically an argv list. The
|
||
* memory for the strings is concatenated to the array and the array is NULL
|
||
* terminated. If Elnkii1 and IbmTok2 are bound to TCP/IP then this function
|
||
* will return:
|
||
*
|
||
* ---> addr of string1 \
|
||
* addr of string2 \
|
||
* NULL > allocated as one block
|
||
* &string1: "Elnkii1" /
|
||
* &string2: "IbmTok2" /
|
||
*
|
||
* ENTRY BindingsSectionKey
|
||
* - Open registry handle to a linkage key (e.g. Tcpip\Linkage)
|
||
*
|
||
* EXIT
|
||
*
|
||
* RETURNS pointer to argv[] style array, or NULL
|
||
*
|
||
* ASSUMES
|
||
*
|
||
******************************************************************************/
|
||
|
||
LPSTR* GetBoundAdapterList(HKEY BindingsSectionKey)
|
||
{
|
||
|
||
LPSTR* resultBuffer;
|
||
|
||
LONG err;
|
||
DWORD valueType;
|
||
PBYTE valueBuffer = NULL;
|
||
DWORD valueLength;
|
||
LPSTR* nextResult;
|
||
int len;
|
||
DWORD resultLength;
|
||
LPSTR nextValue;
|
||
LPSTR variableData;
|
||
DWORD numberOfBindings;
|
||
|
||
//
|
||
// get required size of value buffer
|
||
//
|
||
|
||
valueLength = 0;
|
||
resultBuffer = NULL;
|
||
|
||
err = RegQueryValueEx(BindingsSectionKey,
|
||
"Bind",
|
||
NULL, // reserved
|
||
&valueType,
|
||
NULL,
|
||
&valueLength
|
||
);
|
||
if (err != ERROR_SUCCESS) {
|
||
goto quit;
|
||
}
|
||
if (valueType != REG_MULTI_SZ) {
|
||
goto quit;
|
||
}
|
||
if (!valueLength) {
|
||
goto quit;
|
||
}
|
||
valueBuffer = (PBYTE)ALLOCATE_ZERO_MEMORY(valueLength);
|
||
if ( valueBuffer == NULL ) {
|
||
goto quit;
|
||
}
|
||
|
||
err = RegQueryValueEx(BindingsSectionKey,
|
||
"Bind",
|
||
NULL, // reserved
|
||
&valueType,
|
||
valueBuffer,
|
||
&valueLength
|
||
);
|
||
if (err != ERROR_SUCCESS) {
|
||
goto quit;
|
||
}
|
||
resultLength = sizeof(LPSTR); // the NULL at the end of the list
|
||
numberOfBindings = 0;
|
||
nextValue = (LPSTR)valueBuffer;
|
||
while (0 != (len = strlen(nextValue))) {
|
||
resultLength += sizeof(LPSTR) + len + 1;
|
||
if (!_strnicmp(nextValue, DEVICE_PREFIX, sizeof(DEVICE_PREFIX) - 1)) {
|
||
resultLength -= sizeof(DEVICE_PREFIX) - 1;
|
||
}
|
||
nextValue += len + 1;
|
||
++numberOfBindings;
|
||
}
|
||
resultBuffer = (LPSTR*)ALLOCATE_ZERO_MEMORY(resultLength);
|
||
if ( resultBuffer == NULL ) {
|
||
goto quit;
|
||
}
|
||
nextValue = (LPSTR)valueBuffer;
|
||
nextResult = resultBuffer;
|
||
variableData = (LPSTR)(((LPSTR*)resultBuffer) + numberOfBindings + 1);
|
||
while (numberOfBindings--) {
|
||
|
||
LPSTR adapterName;
|
||
|
||
adapterName = nextValue;
|
||
if (!_strnicmp(adapterName, DEVICE_PREFIX, sizeof(DEVICE_PREFIX) - 1)) {
|
||
adapterName += sizeof(DEVICE_PREFIX) - 1;
|
||
}
|
||
*nextResult++ = variableData;
|
||
strcpy(variableData, adapterName);
|
||
while (*variableData) {
|
||
++variableData;
|
||
}
|
||
++variableData;
|
||
while (*nextValue) {
|
||
++nextValue;
|
||
}
|
||
++nextValue;
|
||
}
|
||
|
||
*nextResult = NULL;
|
||
|
||
quit:
|
||
|
||
if ( valueBuffer != NULL )
|
||
{
|
||
FREE_MEMORY(valueBuffer);
|
||
}
|
||
|
||
return resultBuffer;
|
||
}
|
||
|
||
|
||
/*******************************************************************************
|
||
*
|
||
* OpenAdapterKey
|
||
*
|
||
* Opens one of the 2 per-adapter registry keys: <Adapter>\Parameters\Tcpip, or
|
||
* NetBT\Adapters\<Adapter>
|
||
*
|
||
* ENTRY KeyType - KEY_TCP or KEY_NBT
|
||
* Name - pointer to adapter name to use
|
||
* Key - pointer to returned key
|
||
*
|
||
* EXIT Key updated
|
||
*
|
||
* RETURNS TRUE if success
|
||
*
|
||
* ASSUMES
|
||
*
|
||
******************************************************************************/
|
||
|
||
BOOL OpenAdapterKey(DWORD KeyType, LPSTR Name, PHKEY Key)
|
||
{
|
||
|
||
LONG err;
|
||
CHAR keyName[MAX_ADAPTER_NAME_LENGTH + sizeof("\\Parameters\\Tcpip")];
|
||
|
||
if ((lstrlen(Name)+sizeof("\\Parameters\\Tcpip")) < ARRAY_ELEMENTS(keyName))
|
||
{
|
||
if (KeyType == KEY_TCP) {
|
||
|
||
//
|
||
// open the handle to this adapter's TCPIP parameter key
|
||
//
|
||
|
||
strcpy(keyName, Name);
|
||
strcat(keyName, "\\Parameters\\Tcpip");
|
||
} else if (KeyType == KEY_NBT) {
|
||
|
||
//
|
||
// open the handle to the NetBT\Adapters\<Adapter> handle
|
||
//
|
||
|
||
strcpy(keyName, "NetBT\\Adapters\\");
|
||
strcat(keyName, Name);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
INET_ASSERT((lstrlen(Name)+sizeof("\\Parameters\\Tcpip")) < ARRAY_ELEMENTS(keyName));
|
||
return FALSE;
|
||
}
|
||
|
||
err = REGOPENKEY(ServicesKey,
|
||
keyName,
|
||
Key
|
||
);
|
||
|
||
|
||
DEBUG_PRINT( SOCKETS,
|
||
INFO,
|
||
("RegOpenKey %s %s %s %d\n",
|
||
SERVICES_KEY_NAME, keyName,
|
||
(err != ERROR_SUCCESS )? "failed":"success",
|
||
GetLastError() ));
|
||
|
||
|
||
return (err == ERROR_SUCCESS);
|
||
}
|
||
|
||
/*******************************************************************************
|
||
*
|
||
* ReadRegistryDword
|
||
*
|
||
* Reads a registry value that is stored as a DWORD
|
||
*
|
||
* ENTRY Key - open registry key where value resides
|
||
* ParameterName - name of value to read from registry
|
||
* Value - pointer to returned value
|
||
*
|
||
* EXIT *Value = value read
|
||
*
|
||
* RETURNS TRUE if success
|
||
*
|
||
* ASSUMES
|
||
*
|
||
******************************************************************************/
|
||
|
||
BOOL ReadRegistryDword(HKEY Key, LPSTR 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))) {
|
||
|
||
return 1;
|
||
} else {
|
||
DEBUG_PRINT(SOCKETS, INFO,
|
||
("ReadRegistryDword(%s): err=%d\n", ParameterName, err ));
|
||
return 0;
|
||
}
|
||
|
||
}
|
||
|
||
/*******************************************************************************
|
||
*
|
||
* ReadRegistryString
|
||
*
|
||
* Reads a registry value that is stored as a string
|
||
*
|
||
* ENTRY Key - open registry key
|
||
* ParameterName - name of value to read from registry
|
||
* String - pointer to returned string
|
||
* Length - IN: length of String buffer. OUT: length of returned string
|
||
*
|
||
* EXIT String contains string read
|
||
*
|
||
* RETURNS TRUE if success
|
||
*
|
||
* ASSUMES
|
||
*
|
||
******************************************************************************/
|
||
|
||
BOOL
|
||
ReadRegistryString(HKEY Key, LPSTR ParameterName, LPSTR String, LPDWORD Length)
|
||
{
|
||
|
||
LONG err;
|
||
DWORD valueType;
|
||
|
||
*String = '\0';
|
||
err = RegQueryValueEx(Key,
|
||
ParameterName,
|
||
NULL, // reserved
|
||
&valueType,
|
||
(LPBYTE)String,
|
||
Length
|
||
);
|
||
|
||
if (err == ERROR_SUCCESS) {
|
||
|
||
INET_ASSERT(valueType == REG_SZ || valueType == REG_MULTI_SZ);
|
||
|
||
return (*Length) > sizeof(char);
|
||
|
||
} else {
|
||
DEBUG_PRINT(SOCKETS,
|
||
INFO,
|
||
("ReadRegistryString(%s): err=%d\n", ParameterName, err ));
|
||
return 0;
|
||
}
|
||
|
||
}
|
||
|
||
|
||
|
||
UINT
|
||
SockGetSingleValue(
|
||
IN UINT ParameterId,
|
||
OUT LPBYTE Data,
|
||
IN UINT DataLength
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Retrieve parameter from Registry/DHCP/TCPIP
|
||
|
||
This is what we look for and where:
|
||
|
||
HostName: 1. HKLM\Services\CurrentControlSet\System\Vxd\MSTCP\HostName (Win95)
|
||
HKLM\Services\CurrentControlSet\System\Tcpip\Parameters\Hostname (NT)
|
||
2. (SYSTEM.INI:DNS.HostName)* (N/A)
|
||
3. GetComputerName()
|
||
|
||
DomainName: 1. HKLM\Services\CurrentControlSet\System\Vxd\MSTCP\Domain (Win95)
|
||
HKLM\Services\CurrentControlSet\System\Tcpip\Parameters\DhcpDomain (NT)
|
||
HKLM\Services\CurrentControlSet\System\Tcpip\Parameters\Domain (NT)
|
||
2. (SYSTEM.INI:DNS.DomainName)* (N/A)
|
||
3. DHCP (Win95)
|
||
|
||
SearchList: 1. HKLM\Services\CurrentControlSet\System\Vxd\MSTCP\SearchList (Win95)
|
||
HKLM\Services\CurrentControlSet\System\Tcpip\Parameters\SearchList (NT)
|
||
2. (SYSTEM.INI:DNS.DNSDomains)* (N/A)
|
||
|
||
NameServer: 1. HKLM\Services\CurrentControlSet\System\Vxd\MSTCP\NameServer (Win95)
|
||
HKLM\Services\CurrentControlSet\System\Tcpip\Parameters\DhcpNameServer (NT)
|
||
HKLM\Services\CurrentControlSet\System\Tcpip\Parameters\NameServer (NT)
|
||
2. (SYSTEM.INI:DNS.DNSServers)* (N/A)
|
||
3. DHCP (Win95)
|
||
|
||
* Entries marked thus are registry backups from SYSTEM.INI until all
|
||
keys are moved into registry or if platform is WFW 3.11 (in which
|
||
case there is no registry)
|
||
|
||
ASSUMES 1. Data is big enough to hold the default value (single byte for
|
||
strings, dword for dwords)
|
||
2. Registry is accessible from 16-bit code too
|
||
|
||
Arguments:
|
||
|
||
ParameterId - identifier of parameter to retrieve
|
||
|
||
Data - pointer to untyped storage space for parameter
|
||
|
||
DataLength - length of data returned (in bytes)
|
||
|
||
Return Value:
|
||
|
||
UINT
|
||
Success - ERROR_SUCCESS
|
||
|
||
Failure - ERROR_PATH_NOT_FOUND
|
||
can't locate required parameter in registry/ini/etc.
|
||
|
||
--*/
|
||
|
||
{
|
||
UINT error = CheckRegistryForParameter(ParameterId, Data, DataLength);
|
||
|
||
//
|
||
// if the value was not in the registry then we must attempt to get it from
|
||
// another place, specific to the particular variable requested
|
||
//
|
||
|
||
if (error != ERROR_SUCCESS) {
|
||
if (ParameterId == CONFIG_HOSTNAME) {
|
||
|
||
//
|
||
// on Win32 platform we can call GetComputerName() to provide the
|
||
// computer name, which is the default host name, if none is
|
||
// specified elsewhere
|
||
//
|
||
|
||
DWORD length;
|
||
|
||
length = DataLength;
|
||
if (!GetComputerName((LPSTR)Data, &length)) {
|
||
error = GetLastError();
|
||
}
|
||
} else if (ParameterId == CONFIG_DOMAIN) {
|
||
if (GlobalPlatformType == PLATFORM_TYPE_WIN95) {
|
||
// error = GetDomainNameFromDhcp(Data, DataLength);
|
||
INET_ASSERT(FALSE && "Not implemented on Win9x; port code from WinInet");
|
||
}
|
||
} else if (ParameterId == CONFIG_NAME_SERVER) {
|
||
if (GlobalPlatformType == PLATFORM_TYPE_WIN95) {
|
||
// error = GetDnsServerListFromDhcp(Data, DataLength);
|
||
INET_ASSERT(FALSE && "Not implemented on Win9x; port code from WinInet");
|
||
}
|
||
} else {
|
||
|
||
//
|
||
// the caller is requesting the domain list (or an invalid config
|
||
// parameter value?!?). We have nowhere else to get this value -
|
||
// return an error
|
||
//
|
||
|
||
error = ERROR_PATH_NOT_FOUND;
|
||
}
|
||
}
|
||
|
||
IF_DEBUG(REGISTRY) {
|
||
if (error != ERROR_SUCCESS) {
|
||
DEBUG_PRINT(SOCKETS, INFO,
|
||
("SockGetSingleValue(%s) returns %d\r",
|
||
MAP_PARAMETER_ID(ParameterId),
|
||
error
|
||
));
|
||
} else {
|
||
DEBUG_PRINT(SOCKETS, INFO,
|
||
("SockGetSingleValue(%s) returns \"%s\"\n",
|
||
MAP_PARAMETER_ID(ParameterId),
|
||
Data
|
||
));
|
||
}
|
||
}
|
||
|
||
return error;
|
||
}
|
||
|
||
|
||
PRIVATE
|
||
UINT
|
||
CheckRegistryForParameter(
|
||
IN UINT ParameterId,
|
||
OUT LPBYTE Data,
|
||
IN UINT DataLength
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Retrieve parameter from registry
|
||
|
||
ASSUMES 1. Data is big enough to hold the default value (single byte for
|
||
strings, dword for dwords)
|
||
|
||
Arguments:
|
||
|
||
ParameterId - identifier of parameter to retrieve
|
||
|
||
Data - pointer to untyped storage space for parameter
|
||
|
||
DataLength - length of data returned (in bytes)
|
||
|
||
Return Value:
|
||
|
||
UINT
|
||
Success - ERROR_SUCCESS
|
||
|
||
Failure - ERROR_PATH_NOT_FOUND
|
||
ERROR_INSUFFICIENT_BUFFER
|
||
|
||
--*/
|
||
|
||
{
|
||
HKEY key;
|
||
LONG error = REGOPENKEY(HKEY_LOCAL_MACHINE,
|
||
(GlobalPlatformType == PLATFORM_TYPE_WINNT)
|
||
? "System\\CurrentControlSet\\Services\\Tcpip\\Parameters"
|
||
: "System\\CurrentControlSet\\Services\\VxD\\MSTCP",
|
||
&key
|
||
);
|
||
if (error == ERROR_SUCCESS) {
|
||
|
||
char dhcpBuffer[128]; // arbitrary
|
||
LPSTR p;
|
||
DWORD length;
|
||
DWORD type;
|
||
BOOL tryDhcp;
|
||
|
||
if (GlobalPlatformType == PLATFORM_TYPE_WINNT) {
|
||
FSTRCPY(dhcpBuffer, "Dhcp");
|
||
p = &dhcpBuffer[sizeof("Dhcp") - 1];
|
||
tryDhcp = TRUE;
|
||
} else {
|
||
p = dhcpBuffer;
|
||
tryDhcp = FALSE;
|
||
}
|
||
|
||
FSTRCPY(p, MAP_PARAMETER_ID(ParameterId));
|
||
|
||
//
|
||
// on NT, we look first for the manually-entered variables e.g. "Domain"
|
||
// and if not found, we look a second time for the DHCP-configured
|
||
// variant, e.g. "DhcpDomain"
|
||
//
|
||
|
||
for (int i = 0; i < 2; ++i) {
|
||
|
||
//
|
||
// if NT, first we try the transient key which is written to the
|
||
// registry when we have a dial-up connection
|
||
//
|
||
|
||
if ((i == 0) && (GlobalPlatformType == PLATFORM_TYPE_WINNT)) {
|
||
|
||
HKEY transientKey;
|
||
|
||
error = REGOPENKEY(key, "Transient", &transientKey);
|
||
if (error == ERROR_SUCCESS) {
|
||
length = DataLength;
|
||
error = RegQueryValueEx(transientKey,
|
||
p,
|
||
NULL, // reserved
|
||
&type,
|
||
Data,
|
||
&length
|
||
);
|
||
REGCLOSEKEY(transientKey);
|
||
|
||
//
|
||
// if we succeeded in retrieving a non-empty string then
|
||
// we're done.
|
||
//
|
||
// We test for > 1 because the registry returns the length
|
||
// including the zero-terminator
|
||
//
|
||
|
||
if ((error == ERROR_SUCCESS) && (length > 1)) {
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
length = DataLength;
|
||
error = RegQueryValueEx(key,
|
||
p,
|
||
NULL, // reserved
|
||
&type,
|
||
Data,
|
||
&length
|
||
);
|
||
|
||
//
|
||
// if the key exists, but there is no value then return an error OR
|
||
// if we didn't find the key (or value) AND NT then try for the DHCP
|
||
// version (Note: We try for DhcpSearchList even though it doesn't
|
||
// exist)
|
||
//
|
||
|
||
if ((error != ERROR_SUCCESS)
|
||
|| (length == 0)
|
||
|| ((length == 1) && (Data[0] == '\0'))) {
|
||
if (tryDhcp) {
|
||
p = dhcpBuffer;
|
||
tryDhcp = FALSE;
|
||
continue;
|
||
} else {
|
||
error = ERROR_PATH_NOT_FOUND;
|
||
break;
|
||
}
|
||
} else if ((UINT)length > DataLength) {
|
||
error = ERROR_INSUFFICIENT_BUFFER;
|
||
break;
|
||
}
|
||
}
|
||
REGCLOSEKEY(key);
|
||
}
|
||
|
||
IF_DEBUG(REGISTRY) {
|
||
DEBUG_PRINT(SOCKETS, INFO,
|
||
("CheckRegistryForParameter(%s): returning %d\n",
|
||
MAP_PARAMETER_ID(ParameterId),
|
||
error
|
||
));
|
||
}
|
||
|
||
return (UINT)error;
|
||
}
|
||
|
||
|
||
|
||
UINT
|
||
GetDhcpServerFromDhcp(
|
||
IN OUT CAdapterInterface * paiInterface
|
||
)
|
||
|
||
/*******************************************************************************
|
||
*
|
||
* GetDhcpServerFromDhcp
|
||
*
|
||
* Updates an CAdapterInterface with the DHCP server from the DHCP info
|
||
*
|
||
* ENTRY paiInterface - pointer to CAdapterInterface to update
|
||
*
|
||
* EXIT paiInterface - DhcpServer may be updated
|
||
*
|
||
* RETURNS TRUE if AdapterInfo->DhcpServer updated
|
||
*
|
||
* ASSUMES 1. AdapterInfo->Address is valid
|
||
*
|
||
******************************************************************************/
|
||
|
||
{
|
||
if ( GlobalPlatformType == PLATFORM_TYPE_WINNT )
|
||
{
|
||
HKEY key;
|
||
|
||
if (paiInterface->GetAdapterName() &&
|
||
OpenAdapterKey(KEY_TCP, paiInterface->GetAdapterName(), &key))
|
||
{
|
||
char dhcpServerAddress[4 * 4];
|
||
DWORD addressLength;
|
||
DWORD fDhcpEnabled = FALSE;
|
||
|
||
ReadRegistryDword(key,
|
||
"EnableDHCP",
|
||
&fDhcpEnabled
|
||
);
|
||
|
||
if ( fDhcpEnabled )
|
||
{
|
||
|
||
addressLength = sizeof(dhcpServerAddress);
|
||
if (ReadRegistryString(key,
|
||
"DhcpServer",
|
||
dhcpServerAddress,
|
||
&addressLength
|
||
))
|
||
{
|
||
DWORD ipAddress = _I_inet_addr(dhcpServerAddress);
|
||
|
||
if ( IS_VALID_NON_LOOPBACK_IP_ADDRESS(ipAddress) )
|
||
{
|
||
paiInterface->AddDhcpServer(ipAddress);
|
||
paiInterface->SetDhcp();
|
||
}
|
||
}
|
||
}
|
||
|
||
//ReadRegistryDword(key,
|
||
// "LeaseObtainedTime",
|
||
// &AdapterInfo->LeaseObtained
|
||
// );
|
||
|
||
//ReadRegistryDword(key,
|
||
// "LeaseTerminatesTime",
|
||
// &AdapterInfo->LeaseExpires
|
||
// );
|
||
|
||
|
||
REGCLOSEKEY(key);
|
||
return fDhcpEnabled;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
INET_ASSERT(FALSE && "GetDhcpServerFromDhcp() not implemented on Win9x; port code from WinInet");
|
||
}
|
||
return FALSE;
|
||
}
|
||
|