2672 lines
77 KiB
C
2672 lines
77 KiB
C
/*++
|
||
|
||
Copyright (c) 1994 Microsoft Corporation
|
||
|
||
Module Name:
|
||
|
||
dhcpreg.c
|
||
|
||
Abstract:
|
||
|
||
Stubs functions that manipulate NT registry.
|
||
|
||
Author:
|
||
|
||
Madan Appiah (madana) 7-Dec-1993.
|
||
|
||
Environment:
|
||
|
||
User Mode - Win32
|
||
|
||
Revision History:
|
||
|
||
--*/
|
||
|
||
#include "precomp.h"
|
||
#include "dhcpglobal.h"
|
||
#include <dhcploc.h>
|
||
#include <dhcppro.h>
|
||
#include <dhcpcapi.h>
|
||
#include <dnsapi.h>
|
||
|
||
#include <align.h>
|
||
#include <lmcons.h>
|
||
#include <ntddndis.h>
|
||
|
||
#define DEFAULT_METRIC (1)
|
||
|
||
extern ULONG
|
||
FixupDhcpClassId(
|
||
IN LPWSTR AdapterName,
|
||
IN BOOL SkipClassEnum
|
||
);
|
||
|
||
//
|
||
// Local function prototypes
|
||
//
|
||
|
||
DWORD
|
||
DhcpRegQueryInfoKey(
|
||
HKEY KeyHandle,
|
||
LPDHCP_KEY_QUERY_INFO QueryInfo
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This function retrieves information about given key.
|
||
|
||
Arguments:
|
||
|
||
KeyHandle - handle to a registry key whose info will be retrieved.
|
||
|
||
QueryInfo - pointer to a info structure where the key info will be
|
||
returned.
|
||
|
||
Return Value:
|
||
|
||
Registry Errors.
|
||
|
||
--*/
|
||
{
|
||
DWORD Error;
|
||
|
||
QueryInfo->ClassSize = DHCP_CLASS_SIZE;
|
||
Error = RegQueryInfoKey(
|
||
KeyHandle,
|
||
QueryInfo->Class,
|
||
&QueryInfo->ClassSize,
|
||
NULL,
|
||
&QueryInfo->NumSubKeys,
|
||
&QueryInfo->MaxSubKeyLen,
|
||
&QueryInfo->MaxClassLen,
|
||
&QueryInfo->NumValues,
|
||
&QueryInfo->MaxValueNameLen,
|
||
&QueryInfo->MaxValueLen,
|
||
&QueryInfo->SecurityDescriptorLen,
|
||
&QueryInfo->LastWriteTime
|
||
);
|
||
|
||
DhcpAssert( Error != ERROR_MORE_DATA );
|
||
|
||
if( Error == ERROR_MORE_DATA ){
|
||
Error = ERROR_SUCCESS;
|
||
}
|
||
|
||
return( Error );
|
||
}
|
||
|
||
|
||
|
||
DWORD
|
||
GetRegistryString(
|
||
HKEY Key,
|
||
LPWSTR ValueStringName,
|
||
LPWSTR *String,
|
||
LPDWORD StringSize
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This function retrieves the specified string value from the
|
||
registry. It allocates local memory for the returned string.
|
||
|
||
Arguments:
|
||
|
||
Key : registry handle to the key where the value is.
|
||
|
||
ValueStringName : name of the value string.
|
||
|
||
String : pointer to a location where the string pointer is returned.
|
||
|
||
StringSize : size of the string data returned. Optional
|
||
|
||
Return Value:
|
||
|
||
The status of the operation.
|
||
|
||
--*/
|
||
{
|
||
DWORD Error;
|
||
DWORD LocalValueType;
|
||
DWORD ValueSize;
|
||
LPWSTR LocalString;
|
||
|
||
DhcpAssert( *String == NULL );
|
||
|
||
//
|
||
// Query DataType and BufferSize.
|
||
//
|
||
|
||
Error = RegQueryValueEx(
|
||
Key,
|
||
ValueStringName,
|
||
0,
|
||
&LocalValueType,
|
||
NULL,
|
||
&ValueSize );
|
||
|
||
if( Error != ERROR_SUCCESS ) {
|
||
return(Error);
|
||
}
|
||
|
||
DhcpAssert( (LocalValueType == REG_SZ) ||
|
||
(LocalValueType == REG_MULTI_SZ) );
|
||
|
||
if( ValueSize == 0 ) {
|
||
|
||
if( StringSize != NULL ) {
|
||
*StringSize = 0;
|
||
}
|
||
|
||
*String = NULL;
|
||
return( ERROR_SUCCESS );
|
||
}
|
||
|
||
//
|
||
// now allocate memory for string data.
|
||
//
|
||
|
||
LocalString = DhcpAllocateMemory( ValueSize );
|
||
|
||
if(LocalString == NULL) {
|
||
return( ERROR_NOT_ENOUGH_MEMORY );
|
||
}
|
||
|
||
//
|
||
// Now query the string data.
|
||
//
|
||
|
||
Error = RegQueryValueEx(
|
||
Key,
|
||
ValueStringName,
|
||
0,
|
||
&LocalValueType,
|
||
(LPBYTE)(LocalString),
|
||
&ValueSize );
|
||
|
||
if( Error != ERROR_SUCCESS ) {
|
||
DhcpFreeMemory(LocalString);
|
||
return(Error);
|
||
}
|
||
|
||
*String = LocalString;
|
||
|
||
if( StringSize != NULL ) {
|
||
*StringSize = ValueSize;
|
||
}
|
||
|
||
return( ERROR_SUCCESS );
|
||
}
|
||
|
||
DWORD
|
||
ParseIpString(
|
||
WCHAR *AddressString,
|
||
DHCP_IP_ADDRESS *IpAddress
|
||
)
|
||
/*++
|
||
|
||
Routine Description
|
||
|
||
This function converts an Internet standard 4-octet dotted decimal
|
||
IP address string into a numeric IP address. Unlike inet_addr(), this
|
||
routine does not support address strings of less than 4 octets nor does
|
||
it support octal and hexadecimal octets.
|
||
|
||
Lifted from tcpip\driver\ipv4\ntip.c
|
||
|
||
Arguments
|
||
|
||
AddressString - IP address in dotted decimal notation
|
||
IpAddress - Pointer to a variable to hold the resulting address
|
||
|
||
Return Value:
|
||
|
||
ERROR_SUCCESS if the address string was converted.
|
||
|
||
--*/
|
||
{
|
||
WCHAR *cp, *startPointer, *endPointer;
|
||
ULONG digit, multiplier;
|
||
int i;
|
||
|
||
*IpAddress = 0;
|
||
startPointer = AddressString;
|
||
endPointer = AddressString;
|
||
i = 3;
|
||
|
||
while (i >= 0) {
|
||
//
|
||
// Collect the characters up to a '.' or the end of the string.
|
||
//
|
||
while ((*endPointer != L'.') && (*endPointer != L'\0')) {
|
||
endPointer++;
|
||
}
|
||
|
||
if (startPointer == endPointer) {
|
||
return ERROR_INVALID_DATA;
|
||
}
|
||
//
|
||
// Convert the number.
|
||
//
|
||
|
||
for (cp = (endPointer - 1), multiplier = 1, digit = 0;
|
||
cp >= startPointer;
|
||
cp--, multiplier *= 10
|
||
) {
|
||
|
||
if ((*cp < L'0') || (*cp > L'9') || (multiplier > 100)) {
|
||
return ERROR_INVALID_DATA;
|
||
}
|
||
digit += (multiplier * ((ULONG) (*cp - L'0')));
|
||
}
|
||
|
||
if (digit > 255) {
|
||
return ERROR_INVALID_DATA;
|
||
}
|
||
digit <<= ((3-i) * 8);
|
||
(*IpAddress) |= digit;
|
||
|
||
//
|
||
// We are finished if we have found and converted 4 octets and have
|
||
// no other characters left in the string.
|
||
//
|
||
if ((i-- == 0) &&
|
||
((*endPointer == L'\0') || (*endPointer == L' '))
|
||
) {
|
||
return ERROR_SUCCESS;
|
||
}
|
||
if (*endPointer == L'\0') {
|
||
return ERROR_INVALID_DATA;
|
||
}
|
||
startPointer = ++endPointer;
|
||
}
|
||
|
||
return ERROR_INVALID_DATA;
|
||
}
|
||
|
||
DWORD
|
||
RegGetIpAndSubnet(
|
||
IN DHCP_CONTEXT *dhcpContext,
|
||
OUT PIP_SUBNET *TcpConf,
|
||
OUT int *Count
|
||
)
|
||
/*++
|
||
|
||
Routine Description
|
||
|
||
This function read a list of <IP,SubnetMask> pairs from TCPIP registry parameters.
|
||
|
||
Lifted from tcpip\driver\ipv4\ntip.c
|
||
|
||
Arguments
|
||
|
||
KeyHandle keyhandle NOT location
|
||
TcpConf The pointer to the array of <IP,SubnetMask>
|
||
Count The # of records.
|
||
|
||
|
||
Return Value:
|
||
|
||
ERROR_SUCCESS if succeed, otherfise fail.
|
||
|
||
--*/
|
||
{
|
||
DWORD Error;
|
||
WCHAR *IpList, *SubnetList, *IpListTmp, *SubnetListTmp;
|
||
int i, cnt;
|
||
PIP_SUBNET IpSubnetArray;
|
||
|
||
*Count = 0;
|
||
*TcpConf = NULL;
|
||
IpList = NULL;
|
||
SubnetList = NULL;
|
||
IpSubnetArray = NULL;
|
||
|
||
Error = DhcpGetRegistryValueWithKey(
|
||
dhcpContext->AdapterInfoKey,
|
||
DHCP_STATIC_IP_ADDRESS_STRING,
|
||
DHCP_STATIC_IP_ADDRESS_STRING_TYPE,
|
||
&IpList);
|
||
if (Error != ERROR_SUCCESS) {
|
||
DhcpAssert(IpList == NULL);
|
||
goto cleanup;
|
||
}
|
||
Error = DhcpGetRegistryValueWithKey(
|
||
dhcpContext->AdapterInfoKey,
|
||
DHCP_STATIC_SUBNET_MASK_STRING,
|
||
DHCP_STATIC_SUBNET_MASK_STRING_TYPE,
|
||
&SubnetList);
|
||
if (Error != ERROR_SUCCESS) {
|
||
DhcpAssert(SubnetList == NULL);
|
||
goto cleanup;
|
||
}
|
||
DhcpAssert(IpList && SubnetList);
|
||
|
||
/*
|
||
* Count the # of valid <IP,subnet_mask>
|
||
*/
|
||
cnt = 0;
|
||
IpListTmp = IpList;
|
||
SubnetListTmp = SubnetList;
|
||
while(*IpListTmp && *SubnetListTmp) {
|
||
DHCP_IP_ADDRESS SubnetMask;
|
||
DHCP_IP_ADDRESS IpAddress;
|
||
Error = ParseIpString(IpListTmp, &IpAddress);
|
||
if (Error == ERROR_SUCCESS && IpAddress != 0xffffffff && IpAddress) {
|
||
Error = ParseIpString(SubnetListTmp, &SubnetMask);
|
||
if (Error == ERROR_SUCCESS) {
|
||
cnt++;
|
||
}
|
||
}
|
||
SubnetListTmp += wcslen(SubnetListTmp) + 1;
|
||
IpListTmp += wcslen(IpListTmp) + 1;
|
||
}
|
||
if (cnt == 0) {
|
||
DhcpPrint(( DEBUG_ERRORS, "No valid IP/SubnetMask pair\n"));
|
||
Error = ERROR_BAD_FORMAT;
|
||
goto cleanup;
|
||
}
|
||
|
||
IpSubnetArray = (PIP_SUBNET)DhcpAllocateMemory(cnt * sizeof(IP_SUBNET));
|
||
if (IpSubnetArray == NULL) {
|
||
Error = ERROR_NOT_ENOUGH_MEMORY;
|
||
goto cleanup;
|
||
}
|
||
|
||
/*
|
||
* copy the Ip and subnet mask
|
||
*/
|
||
*Count = cnt;
|
||
*TcpConf = IpSubnetArray;
|
||
cnt = 0;
|
||
IpListTmp = IpList;
|
||
SubnetListTmp = SubnetList;
|
||
while(*IpListTmp && *SubnetListTmp) {
|
||
DHCP_IP_ADDRESS SubnetMask;
|
||
DHCP_IP_ADDRESS IpAddress;
|
||
Error = ParseIpString(IpListTmp, &IpAddress);
|
||
if (Error == ERROR_SUCCESS && IpAddress != 0xffffffff && IpAddress) {
|
||
Error = ParseIpString(SubnetListTmp, &SubnetMask);
|
||
if (Error == ERROR_SUCCESS) {
|
||
DhcpAssert(cnt < *Count);
|
||
IpSubnetArray[cnt].IpAddress = IpAddress;
|
||
IpSubnetArray[cnt].SubnetMask = SubnetMask;
|
||
cnt++;
|
||
}
|
||
}
|
||
SubnetListTmp += wcslen(SubnetListTmp) + 1;
|
||
IpListTmp += wcslen(IpListTmp) + 1;
|
||
}
|
||
Error = ERROR_SUCCESS;
|
||
|
||
cleanup:
|
||
if (IpList) DhcpFreeMemory(IpList);
|
||
if (SubnetList) DhcpFreeMemory(SubnetList);
|
||
return Error;
|
||
}
|
||
|
||
DWORD
|
||
RegSetIpAddress(
|
||
HKEY KeyHandle,
|
||
LPWSTR ValueName,
|
||
DWORD ValueType,
|
||
DHCP_IP_ADDRESS IpAddress
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This function sets IpAddress Value in the registry.
|
||
|
||
Arguments:
|
||
|
||
KeyHandle - handle to the key.
|
||
|
||
ValueName - name of the value field.
|
||
|
||
ValueType - Type of the value field.
|
||
|
||
IpAddress - Ipaddress to be set.
|
||
|
||
Return Value:
|
||
|
||
Registry Error.
|
||
|
||
--*/
|
||
{
|
||
DWORD Error;
|
||
|
||
LPSTR AnsiAddressString;
|
||
WCHAR UnicodeAddressBuf[DOT_IP_ADDR_SIZE];
|
||
LPWSTR UnicodeAddressString;
|
||
|
||
LPWSTR MultiIpAddressString = NULL;
|
||
LPWSTR NewMultiIpAddressString = NULL;
|
||
DWORD MultiIpAddressStringSize;
|
||
DWORD NewMultiIpAddressStringSize;
|
||
DWORD FirstOldIpAddressSize;
|
||
|
||
AnsiAddressString = inet_ntoa( *(struct in_addr *)&IpAddress );
|
||
|
||
UnicodeAddressString = DhcpOemToUnicode(
|
||
AnsiAddressString,
|
||
UnicodeAddressBuf );
|
||
|
||
DhcpAssert( UnicodeAddressString != NULL );
|
||
|
||
if( ValueType == REG_SZ ) {
|
||
Error = RegSetValueEx(
|
||
KeyHandle,
|
||
ValueName,
|
||
0,
|
||
ValueType,
|
||
(LPBYTE)UnicodeAddressString,
|
||
(wcslen(UnicodeAddressString) + 1) * sizeof(WCHAR) );
|
||
|
||
goto Cleanup;
|
||
}
|
||
|
||
DhcpAssert( ValueType == REG_MULTI_SZ );
|
||
|
||
//
|
||
// replace the first IpAddress.
|
||
//
|
||
|
||
//
|
||
// query current multi-IpAddress string.
|
||
//
|
||
|
||
Error = GetRegistryString(
|
||
KeyHandle,
|
||
ValueName,
|
||
&MultiIpAddressString,
|
||
&MultiIpAddressStringSize );
|
||
|
||
if( Error != ERROR_SUCCESS ) {
|
||
goto Cleanup;
|
||
}
|
||
|
||
//
|
||
// allocate new address string.
|
||
//
|
||
|
||
DhcpAssert(MultiIpAddressString != NULL);
|
||
|
||
FirstOldIpAddressSize =
|
||
(wcslen(MultiIpAddressString) + 1) * sizeof(WCHAR);
|
||
|
||
NewMultiIpAddressStringSize =
|
||
MultiIpAddressStringSize - FirstOldIpAddressSize +
|
||
(wcslen(UnicodeAddressString) + 1) * sizeof(WCHAR);
|
||
|
||
NewMultiIpAddressString = DhcpAllocateMemory( NewMultiIpAddressStringSize );
|
||
|
||
if( NewMultiIpAddressString == NULL ) {
|
||
Error = ERROR_NOT_ENOUGH_MEMORY;
|
||
goto Cleanup;
|
||
}
|
||
|
||
//
|
||
// make new address string first.
|
||
//
|
||
|
||
wcscpy( NewMultiIpAddressString, UnicodeAddressString );
|
||
|
||
//
|
||
// copy rest of the old addresses
|
||
//
|
||
|
||
RtlCopyMemory(
|
||
(LPBYTE)NewMultiIpAddressString +
|
||
(wcslen(UnicodeAddressString) + 1) * sizeof(WCHAR),
|
||
(LPBYTE)MultiIpAddressString + FirstOldIpAddressSize,
|
||
MultiIpAddressStringSize - FirstOldIpAddressSize );
|
||
|
||
Error = RegSetValueEx(
|
||
KeyHandle,
|
||
ValueName,
|
||
0,
|
||
ValueType,
|
||
(LPBYTE)NewMultiIpAddressString,
|
||
NewMultiIpAddressStringSize );
|
||
|
||
Cleanup:
|
||
|
||
if( MultiIpAddressString != NULL) {
|
||
DhcpFreeMemory( MultiIpAddressString );
|
||
}
|
||
|
||
if( NewMultiIpAddressString != NULL) {
|
||
DhcpFreeMemory( NewMultiIpAddressString );
|
||
}
|
||
|
||
return( Error );
|
||
}
|
||
|
||
#if DBG
|
||
|
||
|
||
DWORD
|
||
RegSetTimeField(
|
||
HKEY KeyHandle,
|
||
LPWSTR ValueName,
|
||
DWORD ValueType,
|
||
time_t Time
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This function sets time Value in string form in the registry.
|
||
|
||
Arguments:
|
||
|
||
KeyHandle - handle to the key.
|
||
|
||
ValueName - name of the value field.
|
||
|
||
ValueType - Type of the value field.
|
||
|
||
Time - time value to be set.
|
||
|
||
Return Value:
|
||
|
||
Registry Error.
|
||
|
||
--*/
|
||
{
|
||
DWORD Error;
|
||
WCHAR UnicodeTimeBuf[TIME_STRING_LEN];
|
||
LPWSTR UnicodeTimeString;
|
||
|
||
UnicodeTimeString =
|
||
DhcpOemToUnicode( ctime( &Time ), UnicodeTimeBuf ) ;
|
||
|
||
DhcpAssert( UnicodeTimeString != NULL );
|
||
DhcpAssert( ValueType == REG_SZ );
|
||
|
||
Error = RegSetValueEx(
|
||
KeyHandle,
|
||
ValueName,
|
||
0,
|
||
ValueType,
|
||
(LPBYTE)UnicodeTimeString,
|
||
(wcslen(UnicodeTimeString) + 1) * sizeof(WCHAR) );
|
||
|
||
return( Error );
|
||
}
|
||
|
||
#endif
|
||
|
||
|
||
|
||
DWORD // status
|
||
DhcpGetRegistryValueWithKey( // see defn of GetRegistryValue
|
||
IN HKEY KeyHandle, // keyhandle NOT location
|
||
IN LPWSTR ValueName, // value to read from registry
|
||
IN DWORD ValueType, // type of value
|
||
OUT LPVOID *Data // this will be filled in
|
||
) {
|
||
DWORD Error;
|
||
DWORD LocalValueType;
|
||
DWORD ValueSize;
|
||
LPWSTR LocalString;
|
||
|
||
//
|
||
// Query DataType and BufferSize.
|
||
//
|
||
|
||
Error = RegQueryValueEx(
|
||
KeyHandle,
|
||
ValueName,
|
||
0,
|
||
&LocalValueType,
|
||
NULL,
|
||
&ValueSize
|
||
);
|
||
|
||
if( Error != ERROR_SUCCESS ) goto Cleanup;
|
||
|
||
if( LocalValueType != ValueType ) {
|
||
Error = ERROR_INVALID_PARAMETER;
|
||
goto Cleanup;
|
||
}
|
||
|
||
switch( LocalValueType ) {
|
||
case REG_DWORD:
|
||
|
||
DhcpAssert( ValueSize == sizeof(DWORD) );
|
||
|
||
Error = RegQueryValueEx(
|
||
KeyHandle,
|
||
ValueName,
|
||
0,
|
||
&LocalValueType,
|
||
(LPBYTE)Data,
|
||
&ValueSize
|
||
);
|
||
|
||
if( Error != ERROR_SUCCESS ) goto Cleanup;
|
||
|
||
DhcpAssert( LocalValueType == REG_DWORD );
|
||
DhcpAssert( ValueSize == sizeof(DWORD) );
|
||
|
||
break;
|
||
|
||
case REG_SZ :
|
||
case REG_MULTI_SZ:
|
||
DhcpAssert(*Data == NULL);
|
||
|
||
if( ValueSize == 0 ) {
|
||
Error = ERROR_SUCCESS;
|
||
break;
|
||
}
|
||
|
||
//
|
||
// now allocate memory for string data.
|
||
//
|
||
|
||
LocalString = DhcpAllocateMemory( ValueSize );
|
||
|
||
if(LocalString == NULL) {
|
||
Error = ERROR_NOT_ENOUGH_MEMORY;
|
||
goto Cleanup;
|
||
}
|
||
|
||
//
|
||
// Now query the string data.
|
||
//
|
||
|
||
Error = RegQueryValueEx(
|
||
KeyHandle,
|
||
ValueName,
|
||
0,
|
||
&LocalValueType,
|
||
(LPBYTE)(LocalString),
|
||
&ValueSize
|
||
);
|
||
|
||
if( Error != ERROR_SUCCESS ) {
|
||
DhcpFreeMemory(LocalString);
|
||
goto Cleanup;
|
||
}
|
||
|
||
DhcpAssert( (LocalValueType == REG_SZ) ||
|
||
(LocalValueType == REG_MULTI_SZ) );
|
||
|
||
*Data = (LPBYTE)LocalString;
|
||
Error = ERROR_SUCCESS;
|
||
|
||
break;
|
||
|
||
default:
|
||
Error = ERROR_INVALID_PARAMETER;
|
||
break;
|
||
}
|
||
|
||
Cleanup:
|
||
return( Error );
|
||
}
|
||
|
||
|
||
DWORD
|
||
DhcpGetRegistryValue(
|
||
LPWSTR RegKey,
|
||
LPWSTR ValueName,
|
||
DWORD ValueType,
|
||
PVOID *Data
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This function retrieves the option information from registry.
|
||
|
||
Arguments:
|
||
|
||
RegKey - pointer to registry location. like
|
||
system\currentcontrolset\services\..
|
||
|
||
ValueName - name of the value to read.
|
||
|
||
ValueType - type of reg value, REG_DWORD, REG_SZ ..
|
||
|
||
Data - pointer to a location where the data will be returned.
|
||
For string data and binary data, the function allocates
|
||
memory, the caller is responsible to free it.
|
||
|
||
Return Value:
|
||
|
||
Registry Errors.
|
||
|
||
--*/
|
||
{
|
||
DWORD Error;
|
||
HKEY KeyHandle = NULL;
|
||
DWORD LocalValueType;
|
||
DWORD ValueSize;
|
||
LPWSTR LocalString;
|
||
|
||
Error = RegOpenKeyEx(
|
||
HKEY_LOCAL_MACHINE,
|
||
RegKey,
|
||
0 /* Reserved */,
|
||
DHCP_CLIENT_KEY_ACCESS,
|
||
&KeyHandle
|
||
);
|
||
|
||
if( Error != ERROR_SUCCESS ) return Error;
|
||
|
||
Error = DhcpGetRegistryValueWithKey(
|
||
KeyHandle,
|
||
ValueName,
|
||
ValueType,
|
||
Data
|
||
);
|
||
|
||
RegCloseKey(KeyHandle);
|
||
return Error;
|
||
}
|
||
|
||
DWORD // win32
|
||
DhcpRegRecurseDeleteSub( // delete the key's subkeys, recursing downwards
|
||
IN HKEY Key,
|
||
IN LPWSTR KeyName
|
||
) {
|
||
HKEY SubKey;
|
||
DWORD Error;
|
||
DWORD Index;
|
||
WCHAR NameBuf[512];
|
||
FILETIME Unused;
|
||
|
||
Error = RegOpenKeyEx( // open this key to get its sub keys
|
||
Key,
|
||
KeyName,
|
||
0 /* Reserved */,
|
||
KEY_ALL_ACCESS,
|
||
&SubKey
|
||
);
|
||
if( ERROR_SUCCESS != Error ) return Error;
|
||
|
||
|
||
Error = ERROR_SUCCESS;
|
||
Index = 0;
|
||
while( ERROR_SUCCESS == Error ) { // scan looking for sub keys
|
||
DWORD Size;
|
||
|
||
memset(NameBuf, 0, sizeof(NameBuf)); Size = sizeof(NameBuf);
|
||
Error = RegEnumKeyEx(
|
||
SubKey,
|
||
Index,
|
||
NameBuf,
|
||
&Size,
|
||
NULL /* Reserved */,
|
||
NULL /* Class */,
|
||
NULL /* Class size */,
|
||
&Unused
|
||
);
|
||
if( ERROR_SUCCESS != Error ) break;
|
||
|
||
Error = DhcpRegRecurseDelete(SubKey, NameBuf);
|
||
if( ERROR_SUCCESS != Error ) break;
|
||
|
||
memset(NameBuf, 0, sizeof(NameBuf)); Size = sizeof(NameBuf);
|
||
Error = RegEnumKeyEx(
|
||
SubKey,
|
||
Index,
|
||
NameBuf,
|
||
&Size,
|
||
NULL /* Reserved */,
|
||
NULL /* Class */,
|
||
NULL /* Class size */,
|
||
&Unused
|
||
);
|
||
if( ERROR_SUCCESS != Error ) break;
|
||
|
||
Error = RegDeleteKey(SubKey, NameBuf);
|
||
if( ERROR_SUCCESS != Error ) break;
|
||
|
||
Index ++;
|
||
}
|
||
|
||
RegCloseKey(SubKey);
|
||
if( ERROR_NO_MORE_ITEMS != Error ) return Error;
|
||
|
||
return ERROR_SUCCESS;
|
||
}
|
||
|
||
|
||
DWORD // win32 status
|
||
DhcpRegRecurseDelete( // delete the specified key AND its sub keys
|
||
IN HKEY Key, // root key
|
||
IN LPWSTR KeyName // the key to delete along with subkeys
|
||
) {
|
||
DWORD Error;
|
||
DWORD Error2;
|
||
|
||
Error = DhcpRegRecurseDeleteSub(Key,KeyName);
|
||
Error2 = RegDeleteKey(Key,KeyName);
|
||
|
||
if( ERROR_SUCCESS != Error ) {
|
||
return Error;
|
||
}
|
||
|
||
return Error2;
|
||
}
|
||
|
||
|
||
BOOL
|
||
SetOverRideDefaultGateway(
|
||
LPWSTR AdapterName
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This function reads the override default gateway parameter from
|
||
registry and if this parameter is non-null, it sets the gateway
|
||
value in the TCP/IP stack and return TRUE, otherwise it returns
|
||
FALSE.
|
||
|
||
Arguments:
|
||
|
||
AdapterName - name of the adapter we are working on.
|
||
|
||
Return Value:
|
||
|
||
TRUE: If the override gateway parameter is specified in the registry
|
||
and it is succssfully set in the TCP/IP router table.
|
||
|
||
FALSE : Otherwise.
|
||
|
||
--*/
|
||
{
|
||
DWORD Error;
|
||
LPWSTR RegKey = NULL;
|
||
DWORD RegKeyLength;
|
||
HKEY KeyHandle = NULL;
|
||
LPWSTR DefaultGatewayString = NULL;
|
||
DWORD DefaultGatewayStringSize;
|
||
BOOL EmptyDefaultGatewayString = FALSE;
|
||
LPWSTR DefaultGatewayMetricString = NULL;
|
||
DWORD DefaultGatewayMetricStringSize;
|
||
LPWSTR String;
|
||
LPWSTR Metric;
|
||
DWORD ValueSize,ValueType;
|
||
DWORD DontAddGatewayFlag;
|
||
|
||
RegKeyLength = (DWORD)(sizeof(DHCP_SERVICES_KEY) +
|
||
sizeof(REGISTRY_CONNECT_STRING) +
|
||
wcslen(AdapterName) * sizeof(WCHAR) +
|
||
sizeof(DHCP_ADAPTER_PARAMETERS_KEY));
|
||
|
||
RegKey = DhcpAllocateMemory( RegKeyLength );
|
||
|
||
if( RegKey == NULL ) {
|
||
|
||
Error = ERROR_NOT_ENOUGH_MEMORY;
|
||
goto Cleanup;
|
||
}
|
||
|
||
wcscpy( RegKey, DHCP_SERVICES_KEY );
|
||
wcscat( RegKey, DHCP_ADAPTER_PARAMETERS_KEY );
|
||
wcscat( RegKey, REGISTRY_CONNECT_STRING );
|
||
wcscat( RegKey, AdapterName);
|
||
|
||
Error = RegOpenKeyEx(
|
||
HKEY_LOCAL_MACHINE,
|
||
RegKey,
|
||
0, // Reserved field
|
||
DHCP_CLIENT_KEY_ACCESS,
|
||
&KeyHandle
|
||
);
|
||
|
||
DhcpFreeMemory(RegKey);
|
||
RegKey = NULL;
|
||
|
||
if( Error != ERROR_SUCCESS ) {
|
||
goto Cleanup;
|
||
}
|
||
|
||
DhcpAssert( KeyHandle != NULL );
|
||
|
||
ValueSize = sizeof(DWORD);
|
||
Error = RegQueryValueEx(
|
||
KeyHandle,
|
||
DHCP_DONT_ADD_DEFAULT_GATEWAY_FLAG,
|
||
0,
|
||
&ValueType,
|
||
(LPBYTE)&DontAddGatewayFlag,
|
||
&ValueSize );
|
||
|
||
|
||
if ( Error == ERROR_SUCCESS && DontAddGatewayFlag > 0 ) {
|
||
RegCloseKey(KeyHandle);
|
||
return TRUE;
|
||
}
|
||
|
||
Error = GetRegistryString(
|
||
KeyHandle,
|
||
DHCP_DEFAULT_GATEWAY_PARAMETER,
|
||
&DefaultGatewayString,
|
||
&DefaultGatewayStringSize );
|
||
|
||
if( Error != ERROR_SUCCESS ) {
|
||
goto Cleanup;
|
||
}
|
||
|
||
if ( (DefaultGatewayStringSize == 0) ||
|
||
(wcslen(DefaultGatewayString) == 0) ) {
|
||
|
||
EmptyDefaultGatewayString = TRUE;
|
||
goto Cleanup;
|
||
}
|
||
|
||
Error = GetRegistryString(
|
||
KeyHandle,
|
||
DHCP_DEFAULT_GATEWAY_METRIC_PARAMETER,
|
||
&DefaultGatewayMetricString,
|
||
&DefaultGatewayMetricStringSize
|
||
);
|
||
|
||
if( 0 == DefaultGatewayMetricStringSize ) {
|
||
Metric = NULL;
|
||
} else {
|
||
Metric = DefaultGatewayMetricString;
|
||
}
|
||
|
||
for( String = DefaultGatewayString;
|
||
wcslen(String) != 0;
|
||
String += (wcslen(String) + 1) ) {
|
||
|
||
CHAR OemIpAddressBuffer[DOT_IP_ADDR_SIZE];
|
||
LPSTR OemIpAddressString;
|
||
DHCP_IP_ADDRESS GatewayAddress;
|
||
DWORD GatewayMetric = 1;
|
||
|
||
OemIpAddressString = DhcpUnicodeToOem( String, OemIpAddressBuffer );
|
||
GatewayAddress = DhcpDottedStringToIpAddress( OemIpAddressString );
|
||
|
||
if( Metric && Metric[0] ) {
|
||
LPWSTR MetricEnd;
|
||
GatewayMetric = wcstoul(Metric, &MetricEnd, 0);
|
||
if( GatewayMetric && GatewayMetric != MAXULONG ) {
|
||
Metric += wcslen(Metric) + 1;
|
||
} else {
|
||
GatewayMetric = DEFAULT_METRIC;
|
||
Metric = NULL;
|
||
}
|
||
}
|
||
|
||
Error = SetDefaultGateway(
|
||
DEFAULT_GATEWAY_ADD,
|
||
GatewayAddress,
|
||
GatewayMetric
|
||
);
|
||
|
||
if( Error != ERROR_SUCCESS ) {
|
||
goto Cleanup;
|
||
}
|
||
}
|
||
|
||
Cleanup:
|
||
|
||
if( RegKey != NULL ) {
|
||
DhcpFreeMemory( RegKey );
|
||
}
|
||
|
||
if( KeyHandle != NULL ) {
|
||
RegCloseKey( KeyHandle );
|
||
}
|
||
|
||
if( DefaultGatewayString != NULL ) {
|
||
DhcpFreeMemory( DefaultGatewayString );
|
||
}
|
||
|
||
if( DefaultGatewayMetricString != NULL ) {
|
||
DhcpFreeMemory( DefaultGatewayMetricString );
|
||
}
|
||
|
||
if( Error != ERROR_SUCCESS ) {
|
||
|
||
DhcpPrint((DEBUG_ERRORS,
|
||
"SetOverRideDefaultGateway failed, %ld.\n", Error ));
|
||
|
||
return( FALSE );
|
||
}
|
||
|
||
if( EmptyDefaultGatewayString ) {
|
||
|
||
return( FALSE );
|
||
}
|
||
|
||
return( TRUE );
|
||
}
|
||
|
||
|
||
|
||
DWORD
|
||
SetDhcpOption(
|
||
LPWSTR AdapterName,
|
||
DHCP_OPTION_ID OptionId,
|
||
LPBOOL DefaultGatewaysSet,
|
||
BOOL LastKnownDefaultGateway
|
||
) {
|
||
DhcpAssert(FALSE);
|
||
return 0;
|
||
}
|
||
|
||
DWORD
|
||
DhcpMakeNICEntry(
|
||
PDHCP_CONTEXT *ReturnDhcpContext,
|
||
BYTE HardwareAddressType,
|
||
LPBYTE HardwareAddress,
|
||
DWORD HardwareAddressLength,
|
||
DHCP_CLIENT_IDENTIFIER *pClientID,
|
||
LPWSTR AdapterName,
|
||
LPWSTR RegKey
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This function allocates memory and fills in the fields that are passed as
|
||
parameter. (Only the variable length fields must be here).
|
||
|
||
Arguments:
|
||
|
||
Parameter for new entry :
|
||
HardwareAddressType,
|
||
HardwareAddress,
|
||
HardwareAddressLength,
|
||
ClientId,
|
||
AdapterName,
|
||
RegKey
|
||
|
||
Return Value:
|
||
|
||
Windows Error.
|
||
|
||
History:
|
||
8/26/96 Frankbee Added Client ID (option 61) support
|
||
|
||
--*/
|
||
{
|
||
PDHCP_CONTEXT DhcpContext = NULL;
|
||
ULONG DhcpContextSize;
|
||
PLOCAL_CONTEXT_INFO LocalInfo;
|
||
LPVOID Ptr;
|
||
BYTE StateStringBuffer[200];
|
||
DWORD AdapterNameLen;
|
||
DWORD DeviceNameLen;
|
||
DWORD NetBTDeviceNameLen;
|
||
DWORD RegKeyLen;
|
||
|
||
AdapterNameLen = ((wcslen(AdapterName) + 1) * sizeof(WCHAR));
|
||
NetBTDeviceNameLen =
|
||
((wcslen(DHCP_ADAPTERS_DEVICE_STRING) +
|
||
wcslen(DHCP_NETBT_DEVICE_STRING) +
|
||
wcslen(AdapterName) + 1) * sizeof(WCHAR));
|
||
|
||
RegKeyLen = ((wcslen(RegKey) + 1) * sizeof(WCHAR));
|
||
DhcpContextSize =
|
||
ROUND_UP_COUNT(sizeof(DHCP_CONTEXT), ALIGN_WORST) +
|
||
ROUND_UP_COUNT(HardwareAddressLength, ALIGN_WORST) +
|
||
ROUND_UP_COUNT(sizeof(LOCAL_CONTEXT_INFO), ALIGN_WORST) +
|
||
ROUND_UP_COUNT(AdapterNameLen, ALIGN_WORST) +
|
||
ROUND_UP_COUNT(NetBTDeviceNameLen, ALIGN_WORST) +
|
||
ROUND_UP_COUNT(RegKeyLen, ALIGN_WORST) +
|
||
ROUND_UP_COUNT(DHCP_RECV_MESSAGE_SIZE, ALIGN_WORST);
|
||
|
||
if ( pClientID->fSpecified ) {
|
||
DhcpAssert( pClientID->cbID );
|
||
DhcpContextSize += ROUND_UP_COUNT( pClientID->cbID, ALIGN_WORST );
|
||
}
|
||
|
||
Ptr = DhcpAllocateMemory( DhcpContextSize );
|
||
if ( Ptr == NULL ) return ERROR_NOT_ENOUGH_MEMORY;
|
||
RtlZeroMemory(Ptr, DhcpContextSize);
|
||
|
||
DhcpContext = Ptr;
|
||
Ptr = ROUND_UP_POINTER( (LPBYTE)Ptr + sizeof(DHCP_CONTEXT), ALIGN_WORST);
|
||
|
||
DhcpContext->HardwareAddress = Ptr;
|
||
Ptr = ROUND_UP_POINTER( (LPBYTE)Ptr + HardwareAddressLength, ALIGN_WORST);
|
||
|
||
if ( pClientID->fSpecified ) {
|
||
DhcpContext->ClientIdentifier.pbID = Ptr;
|
||
Ptr = ROUND_UP_POINTER( (LPBYTE)Ptr + pClientID->cbID, ALIGN_WORST );
|
||
}
|
||
|
||
DhcpContext->LocalInformation = Ptr;
|
||
LocalInfo = Ptr;
|
||
Ptr = ROUND_UP_POINTER( (LPBYTE)Ptr + sizeof(LOCAL_CONTEXT_INFO), ALIGN_WORST);
|
||
|
||
LocalInfo->AdapterName= Ptr;
|
||
Ptr = ROUND_UP_POINTER( (LPBYTE)Ptr + AdapterNameLen, ALIGN_WORST);
|
||
|
||
LocalInfo->NetBTDeviceName= Ptr;
|
||
Ptr = ROUND_UP_POINTER( (LPBYTE)Ptr + NetBTDeviceNameLen, ALIGN_WORST);
|
||
|
||
LocalInfo->RegistryKey= Ptr;
|
||
Ptr = ROUND_UP_POINTER( (LPBYTE)Ptr + RegKeyLen, ALIGN_WORST);
|
||
|
||
DhcpContext->MessageBuffer = Ptr;
|
||
|
||
//
|
||
// Fill in the fields
|
||
//
|
||
|
||
DhcpContext->HardwareAddressType = HardwareAddressType;
|
||
DhcpContext->HardwareAddressLength = HardwareAddressLength;
|
||
RtlCopyMemory(DhcpContext->HardwareAddress, HardwareAddress,HardwareAddressLength);
|
||
|
||
DhcpContext->ClientIdentifier.fSpecified = pClientID->fSpecified;
|
||
|
||
if ( pClientID->fSpecified ) {
|
||
DhcpContext->ClientIdentifier.bType = pClientID->bType;
|
||
DhcpContext->ClientIdentifier.cbID = pClientID->cbID;
|
||
|
||
RtlCopyMemory(DhcpContext->ClientIdentifier.pbID,pClientID->pbID,pClientID->cbID);
|
||
}
|
||
|
||
RtlCopyMemory(LocalInfo->AdapterName, AdapterName, AdapterNameLen);
|
||
|
||
wcscpy( LocalInfo->NetBTDeviceName, DHCP_ADAPTERS_DEVICE_STRING );
|
||
wcscat( LocalInfo->NetBTDeviceName, DHCP_NETBT_DEVICE_STRING );
|
||
wcscat( LocalInfo->NetBTDeviceName, AdapterName );
|
||
|
||
RtlCopyMemory(LocalInfo->RegistryKey, RegKey, RegKeyLen);
|
||
|
||
if( ReturnDhcpContext != NULL ) *ReturnDhcpContext = DhcpContext;
|
||
|
||
return( ERROR_SUCCESS );
|
||
}
|
||
|
||
|
||
|
||
BOOL
|
||
ReadClientID(
|
||
HKEY hKey,
|
||
BYTE *pbClientIDType,
|
||
DWORD *pcbClientID,
|
||
BYTE *ppbClientID[]
|
||
)
|
||
/*++
|
||
|
||
Function:
|
||
ReadClientID
|
||
|
||
Routine Description:
|
||
|
||
Reads and validates the optional Client-Identifier option
|
||
|
||
Arguments:
|
||
|
||
hKey - handle to a registry key whose info will be retrieved.
|
||
|
||
pbClientIDType - Recieves the client ID option type
|
||
|
||
pcbClientID - Receives the size of the client id option
|
||
|
||
ppbClientID - Receives a pointer to a buffer containing the
|
||
client ID option
|
||
|
||
Return Value:
|
||
TRUE - A valid client ID was read from the registry
|
||
FALSE - Client ID could not be read
|
||
|
||
Comments:
|
||
If ReadClientID returns false, pbClientIDType, pcbClientID and ppbClientID
|
||
will be set to NULL.
|
||
|
||
History
|
||
7/14/96 Frankbee Created
|
||
|
||
--*/
|
||
{
|
||
DWORD dwResult,
|
||
dwDataType,
|
||
dwcb,
|
||
dwClientIDType,
|
||
dwClientID;
|
||
|
||
BYTE *pbClientID;
|
||
|
||
BOOL fClientIDSpecified = FALSE;
|
||
|
||
//
|
||
// read the client id and client id type, if present
|
||
//
|
||
|
||
dwcb = sizeof(dwClientIDType);
|
||
dwResult = RegQueryValueEx(
|
||
hKey,
|
||
DHCP_CLIENT_IDENTIFIER_FORMAT,
|
||
0,
|
||
&dwDataType,
|
||
(LPBYTE)&dwClientIDType,
|
||
&dwcb );
|
||
if ( ERROR_SUCCESS != dwResult )
|
||
{
|
||
DhcpPrint( (DEBUG_MISC,
|
||
"Client-Indentifier type not present in registry.\n" ));
|
||
//
|
||
// specify ID type 0 to indicate that the client ID is not a hardware
|
||
// address
|
||
//
|
||
|
||
dwClientIDType = 0;
|
||
}
|
||
else
|
||
{
|
||
|
||
//
|
||
// the client id type is present, make sure it is the correct
|
||
// data type and within range
|
||
//
|
||
|
||
if ( DHCP_CLIENT_IDENTIFIER_FORMAT_TYPE != dwDataType || dwClientIDType > 0xFF )
|
||
{
|
||
DhcpPrint( (DEBUG_MISC,
|
||
"Invalid Client-Indentifier type: %d\n", dwClientIDType ));
|
||
|
||
goto done;
|
||
}
|
||
}
|
||
|
||
//
|
||
// Now try to read the client ID
|
||
//
|
||
|
||
// first try to read the size
|
||
dwcb = 0;
|
||
dwResult = RegQueryValueEx(
|
||
hKey,
|
||
DHCP_CLIENT_IDENTIFIER_VALUE,
|
||
0,
|
||
0, // don't care about the type
|
||
NULL, // specify null buffer to obtain size
|
||
&dwcb );
|
||
|
||
// make the the value is present
|
||
if ( ERROR_SUCCESS != dwResult || !dwcb )
|
||
{
|
||
DhcpPrint( (DEBUG_MISC,
|
||
"Client-Identifier is not present or invalid.\n" ));
|
||
goto done;
|
||
}
|
||
|
||
|
||
// allocate the buffer and read the value
|
||
pbClientID = (BYTE*) DhcpAllocateMemory ( dwcb );
|
||
|
||
if ( !pbClientID )
|
||
{
|
||
DhcpPrint( (DEBUG_ERRORS,
|
||
"Unable to allocate memory for Client-Identifier "));
|
||
|
||
|
||
goto done;
|
||
}
|
||
|
||
|
||
dwResult = RegQueryValueEx(
|
||
hKey,
|
||
DHCP_CLIENT_IDENTIFIER_VALUE,
|
||
0,
|
||
0, // client id can be any type
|
||
pbClientID,
|
||
&dwcb );
|
||
if ( ERROR_SUCCESS != dwResult )
|
||
{
|
||
DhcpPrint( (DEBUG_ERRORS,
|
||
"Unable to read Client-Identifier from registry: %d\n", dwResult ));
|
||
|
||
DhcpFreeMemory( pbClientID );
|
||
goto done;
|
||
}
|
||
|
||
//
|
||
// we have a client id
|
||
//
|
||
|
||
fClientIDSpecified = TRUE;
|
||
|
||
done:
|
||
|
||
if ( fClientIDSpecified )
|
||
{
|
||
*pbClientIDType = (BYTE) dwClientIDType;
|
||
*pcbClientID = dwcb;
|
||
*ppbClientID = pbClientID;
|
||
}
|
||
else
|
||
{
|
||
*pbClientIDType = 0;
|
||
*pcbClientID = 0;
|
||
*ppbClientID = NULL;
|
||
}
|
||
|
||
if ( fClientIDSpecified )
|
||
{
|
||
int i;
|
||
|
||
//
|
||
// A valid client-identifier was obtained from the registry. dump out
|
||
// the contents
|
||
//
|
||
|
||
DhcpPrint( (DEBUG_MISC,
|
||
"A Client Identifier was obtained from the registry:\n" ));
|
||
|
||
DhcpPrint( (DEBUG_MISC,
|
||
"Client-Identifier Type == %#2x\n", (int) *pbClientIDType ));
|
||
|
||
DhcpPrint( (DEBUG_MISC,
|
||
"Client-Indentifier length == %d\n", (int) *pcbClientID ));
|
||
|
||
DhcpPrint( (DEBUG_MISC,
|
||
"Client-Identifier == " ));
|
||
|
||
for ( i = 0; i < (int) *pcbClientID; i++ )
|
||
DhcpPrint((DEBUG_MISC, "%#2x ", (int) ((*ppbClientID)[i]) ));
|
||
|
||
DhcpPrint( (DEBUG_MISC, "\n" ));
|
||
}
|
||
|
||
return fClientIDSpecified;
|
||
}
|
||
|
||
BOOL
|
||
GuidToClientID(
|
||
IN LPWSTR GuidString,
|
||
BYTE *pbClientIDType,
|
||
DWORD *pcbClientID,
|
||
BYTE *ppbClientID[]
|
||
)
|
||
{
|
||
GUID guid;
|
||
UNICODE_STRING unGuid;
|
||
BYTE *pbClientID;
|
||
|
||
RtlInitUnicodeString(&unGuid, GuidString);
|
||
if (RtlGUIDFromString(&unGuid, &guid) != STATUS_SUCCESS) {
|
||
return FALSE;
|
||
}
|
||
pbClientID = (BYTE*) DhcpAllocateMemory (sizeof(GUID));
|
||
if (pbClientID == NULL) {
|
||
return FALSE;
|
||
}
|
||
|
||
memcpy(pbClientID, &guid, sizeof(GUID));
|
||
*pbClientIDType = 0; // per RFC 2132, 0 should be used when the ID is not a hardware address
|
||
*pcbClientID = sizeof(GUID);
|
||
*ppbClientID = pbClientID;
|
||
return TRUE;
|
||
}
|
||
|
||
DWORD // status
|
||
DhcpRegExpandString( // replace '?' with AdapterName
|
||
IN LPWSTR InString, // input string to expand
|
||
IN LPWSTR AdapterName, // the adapter name
|
||
OUT LPWSTR *OutString, // the output ptr to store string
|
||
IN OUT LPWSTR Buffer // the buffer to use if non NULL
|
||
) {
|
||
LPWSTR Mem; // the real mem to use
|
||
LPWSTR Tmp, Tmp2, MemTmp;
|
||
DWORD MemSize; // the size of this memory
|
||
DWORD AdapterNameLen;// the amt of bytes for adapter name
|
||
|
||
*OutString = NULL;
|
||
|
||
AdapterNameLen = wcslen(AdapterName) * sizeof(WCHAR);
|
||
if( NULL != Buffer ) { // Buffer already provided
|
||
Mem = Buffer;
|
||
MemSize = 0;
|
||
} else { // need to allocate buffer
|
||
MemSize = wcslen(InString)+1; // calculate memory size needed
|
||
MemSize *= sizeof(WCHAR);
|
||
|
||
Tmp = InString;
|
||
while( Tmp = wcschr(Tmp, OPTION_REPLACE_CHAR ) ) {
|
||
Tmp ++;
|
||
MemSize += AdapterNameLen - sizeof(OPTION_REPLACE_CHAR);
|
||
}
|
||
|
||
Mem = DhcpAllocateMemory(MemSize); // allocate the buffer
|
||
if( NULL == Mem ) return ERROR_NOT_ENOUGH_MEMORY;
|
||
}
|
||
|
||
Tmp = InString; MemTmp = Mem;
|
||
while( Tmp2 = wcschr(Tmp, OPTION_REPLACE_CHAR) ) {
|
||
memcpy(MemTmp, Tmp, (int)(Tmp2 - Tmp) * sizeof(WCHAR) );
|
||
MemTmp += (Tmp2-Tmp);
|
||
memcpy(MemTmp, AdapterName, AdapterNameLen);
|
||
MemTmp += AdapterNameLen/sizeof(WCHAR);
|
||
Tmp = Tmp2+1;
|
||
}
|
||
|
||
wcscpy(MemTmp, Tmp);
|
||
*OutString = Mem;
|
||
|
||
return ERROR_SUCCESS;;
|
||
}
|
||
|
||
DWORD // status
|
||
DhcpRegReadFromLocation( // read from one location
|
||
IN LPWSTR OneLocation, // value to read from
|
||
IN LPWSTR AdapterName, // replace '?' with adapternames
|
||
OUT LPBYTE *Value, // output value
|
||
OUT DWORD *ValueType, // data type of value
|
||
OUT DWORD *ValueSize // the size in bytes
|
||
) {
|
||
DWORD Error;
|
||
LPWSTR NewRegLocation;
|
||
HKEY KeyHandle;
|
||
LPWSTR ValueName;
|
||
|
||
Error = DhcpRegExpandString( // replace all occurences of '?'
|
||
OneLocation,
|
||
AdapterName,
|
||
&NewRegLocation,
|
||
NULL
|
||
);
|
||
if( ERROR_SUCCESS != Error ) return Error;
|
||
|
||
ValueName = wcsrchr(NewRegLocation, REGISTRY_CONNECT);
|
||
if( NULL != ValueName ) *ValueName++ = L'\0'; // split to reg loc and value name
|
||
|
||
Error = RegOpenKeyEx( // open the required key
|
||
HKEY_LOCAL_MACHINE, // running in some process -- expect full path
|
||
NewRegLocation, // this is the new key
|
||
0 /* Reserved */,
|
||
DHCP_CLIENT_KEY_ACCESS,
|
||
&KeyHandle
|
||
);
|
||
|
||
if( ERROR_SUCCESS != Error ) {
|
||
DhcpPrint((DEBUG_ERRORS, "RegOpenKeyEx(%ws):%ld\n", NewRegLocation, Error));
|
||
DhcpFreeMemory(NewRegLocation);
|
||
return Error;
|
||
}
|
||
|
||
*ValueSize = 0;
|
||
*Value = NULL;
|
||
Error = RegQueryValueEx( // first find out how much space reqd
|
||
KeyHandle,
|
||
ValueName,
|
||
0 /* Reserved */,
|
||
ValueType,
|
||
NULL,
|
||
ValueSize
|
||
);
|
||
|
||
*Value = NULL;
|
||
if( ERROR_SUCCESS != Error || 0 == *ValueSize ) {
|
||
DhcpPrint((DEBUG_ERRORS, "RegQueryValueEx(%ws, %ws):%ld\n", NewRegLocation, ValueName, Error));
|
||
DhcpFreeMemory(NewRegLocation);
|
||
RegCloseKey(KeyHandle);
|
||
return Error;
|
||
}
|
||
|
||
if( NULL == (*Value = DhcpAllocateMemory(*ValueSize))) {
|
||
DhcpPrint((DEBUG_ERRORS, "RegReadFromLocation(%s):Allocate(%ld)failed\n", NewRegLocation, *ValueSize));
|
||
DhcpFreeMemory(NewRegLocation);
|
||
RegCloseKey(KeyHandle);
|
||
return ERROR_NOT_ENOUGH_MEMORY;
|
||
}
|
||
|
||
Error = RegQueryValueEx(
|
||
KeyHandle,
|
||
ValueName,
|
||
0 /* Reserved */,
|
||
ValueType,
|
||
*Value,
|
||
ValueSize
|
||
);
|
||
|
||
DhcpFreeMemory(NewRegLocation);
|
||
RegCloseKey(KeyHandle);
|
||
|
||
return Error;
|
||
}
|
||
|
||
DWORD // status
|
||
DhcpRegReadFromAnyLocation( // read from one of many locations
|
||
IN LPWSTR MzRegLocation, // multiple locations thru REG_MULTI_MZ
|
||
IN LPWSTR AdapterName, // may have to replace '?' with AdapterName
|
||
OUT LPBYTE *Value, // data for the value read
|
||
OUT DWORD *ValueType, // type of the data
|
||
OUT DWORD *ValueSize // the size of data
|
||
) {
|
||
DWORD StringSize;
|
||
DWORD Error;
|
||
|
||
if( NULL == Value || NULL == ValueType || NULL == ValueSize ) {
|
||
DhcpAssert( Value && ValueType && ValueSize && "DhcpRegReadFromAnyLocation" );
|
||
return ERROR_INVALID_PARAMETER;
|
||
}
|
||
|
||
while( StringSize = wcslen(MzRegLocation) ) { // read in sequence and see if anything hits
|
||
Error = DhcpRegReadFromLocation(
|
||
MzRegLocation,
|
||
AdapterName,
|
||
Value,
|
||
ValueType,
|
||
ValueSize
|
||
);
|
||
|
||
if( ERROR_SUCCESS == Error) return ERROR_SUCCESS;
|
||
|
||
MzRegLocation += StringSize + 1;
|
||
}
|
||
|
||
return ERROR_FILE_NOT_FOUND;
|
||
}
|
||
|
||
VOID
|
||
DhcpRegReadClassId( // Read the class id stuff
|
||
IN PDHCP_CONTEXT DhcpContext // Input context to read for
|
||
) {
|
||
PLOCAL_CONTEXT_INFO LocalInfo;
|
||
LPWSTR AdapterName;
|
||
LPWSTR RegLocation;
|
||
LPWSTR ValueName;
|
||
LPBYTE Value;
|
||
DWORD ValueSize;
|
||
DWORD ValueType;
|
||
DWORD Error;
|
||
|
||
DhcpContext->ClassId = NULL;
|
||
DhcpContext->ClassIdLength = 0;
|
||
RegLocation = NULL;
|
||
LocalInfo = DhcpContext->LocalInformation;
|
||
AdapterName = LocalInfo->AdapterName;
|
||
|
||
Error = GetRegistryString(
|
||
DhcpGlobalParametersKey,
|
||
DHCP_CLASS_LOCATION_VALUE,
|
||
&RegLocation,
|
||
NULL
|
||
);
|
||
|
||
if( ERROR_SUCCESS != Error || NULL == RegLocation ) {
|
||
RegLocation = NULL;
|
||
}
|
||
|
||
Error = DhcpRegReadFromAnyLocation(
|
||
RegLocation?RegLocation:DEFAULT_USER_CLASS_LOC_FULL,
|
||
AdapterName,
|
||
&Value,
|
||
&ValueType,
|
||
&ValueSize
|
||
);
|
||
|
||
if( ERROR_SUCCESS != Error || NULL == Value ) {
|
||
Error = FixupDhcpClassId(AdapterName, TRUE);
|
||
if (ERROR_SUCCESS == Error) {
|
||
Error = DhcpRegReadFromAnyLocation(
|
||
RegLocation?RegLocation:DEFAULT_USER_CLASS_LOC_FULL,
|
||
AdapterName,
|
||
&Value,
|
||
&ValueType,
|
||
&ValueSize
|
||
);
|
||
}
|
||
}
|
||
|
||
if( NULL != RegLocation ) DhcpFreeMemory(RegLocation);
|
||
|
||
if( ERROR_SUCCESS != Error || NULL == Value ) return;
|
||
|
||
DhcpContext->ClassId = DhcpAddClass(&DhcpGlobalClassesList,Value, ValueSize);
|
||
if( NULL != DhcpContext->ClassId ) DhcpContext->ClassIdLength = ValueSize;
|
||
|
||
DhcpFreeMemory(Value);
|
||
}
|
||
|
||
DWORD INLINE // win32 status
|
||
DhcpMakeContext( // allocate and create a context
|
||
IN LPWSTR AdapterName, // name of adapter
|
||
IN DWORD IpInterfaceContext,
|
||
OUT PDHCP_CONTEXT *pDhcpContext // fill this with the ptr to allocated block
|
||
)
|
||
{
|
||
LPWSTR RegKey;
|
||
HKEY KeyHandle;
|
||
DHCP_CLIENT_IDENTIFIER ClientID;
|
||
BYTE HardwareAddressType;
|
||
LPBYTE HardwareAddress;
|
||
DWORD HardwareAddressLength;
|
||
DWORD Error, OldIpAddress, OldIpMask;
|
||
DWORD IpInterfaceInstance;
|
||
BOOL fInterfaceDown;
|
||
PLOCAL_CONTEXT_INFO LocalInfo;
|
||
DWORD IfIndex;
|
||
|
||
ClientID.pbID = NULL;
|
||
RegKey = NULL;
|
||
KeyHandle = NULL;
|
||
HardwareAddress = NULL;
|
||
|
||
RegKey = DhcpAllocateMemory(
|
||
sizeof(WCHAR) * (
|
||
wcslen(DHCP_SERVICES_KEY) + wcslen(REGISTRY_CONNECT_STRING) +
|
||
wcslen(AdapterName) + wcslen(DHCP_ADAPTER_PARAMETERS_KEY) + 1
|
||
)
|
||
);
|
||
|
||
if( RegKey == NULL ) return ERROR_NOT_ENOUGH_MEMORY;
|
||
|
||
wcscpy( RegKey, DHCP_SERVICES_KEY );
|
||
wcscat( RegKey, DHCP_ADAPTER_PARAMETERS_KEY );
|
||
wcscat( RegKey, REGISTRY_CONNECT_STRING );
|
||
wcscat( RegKey, AdapterName );
|
||
|
||
|
||
DhcpPrint((DEBUG_INIT, "Opening Adapter Key - %ws.\n", RegKey));
|
||
|
||
Error = RegOpenKeyEx(
|
||
HKEY_LOCAL_MACHINE,
|
||
RegKey,
|
||
0, // Reserved field
|
||
DHCP_CLIENT_KEY_ACCESS,
|
||
&KeyHandle
|
||
);
|
||
if( ERROR_SUCCESS != Error ) {
|
||
DhcpPrint((DEBUG_ERRORS, "RegOpenKeyEx(%ws):0x%lx\n", AdapterName, Error));
|
||
DhcpFreeMemory(RegKey);
|
||
return Error;
|
||
}
|
||
|
||
ClientID.fSpecified = ReadClientID(
|
||
KeyHandle,
|
||
&ClientID.bType,
|
||
&ClientID.cbID,
|
||
&ClientID.pbID
|
||
);
|
||
|
||
#ifdef BOOTPERF
|
||
Error = DhcpQueryHWInfoEx( // query the stack for hw info
|
||
IpInterfaceContext,
|
||
&IpInterfaceInstance,
|
||
&OldIpAddress,
|
||
&OldIpMask,
|
||
&fInterfaceDown,
|
||
&HardwareAddressType,
|
||
&HardwareAddress,
|
||
&HardwareAddressLength
|
||
);
|
||
#else
|
||
Error = DhcpQueryHWInfo( // query the stack for hw info
|
||
IpInterfaceContext,
|
||
&IpInterfaceInstance,
|
||
&HardwareAddressType,
|
||
&HardwareAddress,
|
||
&HardwareAddressLength
|
||
);
|
||
#endif BOOTPERF
|
||
|
||
if (HardwareAddressType == HARDWARE_1394 && !ClientID.fSpecified) {
|
||
//
|
||
// Generate a client identifier for 1394 interface
|
||
//
|
||
ClientID.fSpecified = GuidToClientID(
|
||
AdapterName,
|
||
&ClientID.bType,
|
||
&ClientID.cbID,
|
||
&ClientID.pbID
|
||
);
|
||
if (!ClientID.fSpecified) {
|
||
Error = ERROR_BAD_DEVICE;
|
||
}
|
||
}
|
||
|
||
if( ERROR_SUCCESS == Error ) { // now do the real allocate part and get the context
|
||
|
||
IfIndex = QueryIfIndex(IpInterfaceContext, IpInterfaceInstance);
|
||
|
||
Error = DhcpMakeNICEntry(
|
||
pDhcpContext,
|
||
HardwareAddressType,
|
||
HardwareAddress,
|
||
HardwareAddressLength,
|
||
&ClientID,
|
||
AdapterName,
|
||
RegKey
|
||
);
|
||
if( ERROR_SUCCESS == Error ) { // if everything went fine, store the KeyHandle
|
||
ULONG Caps;
|
||
|
||
DhcpAssert((*pDhcpContext));
|
||
(*pDhcpContext)->AdapterInfoKey = KeyHandle;
|
||
(*pDhcpContext)->RefCount = 1;
|
||
KeyHandle = NULL; // null it so that it does not get closed below
|
||
LocalInfo = (PLOCAL_CONTEXT_INFO)((*pDhcpContext)->LocalInformation);
|
||
LocalInfo->IpInterfaceContext = IpInterfaceContext;
|
||
LocalInfo->IpInterfaceInstance = IpInterfaceInstance;
|
||
LocalInfo->IfIndex = IfIndex;
|
||
// IpInterfaceInstance is filled in make context
|
||
LocalInfo->Socket = INVALID_SOCKET;
|
||
// LocalInfo->AdapterName, RegistryKey, NetBtDeviceName ALREADY set in MakeNICEntry
|
||
#ifdef BOOTPERF
|
||
LocalInfo->OldIpAddress = OldIpAddress;
|
||
LocalInfo->OldIpMask = OldIpMask;
|
||
LocalInfo->fInterfaceDown = fInterfaceDown;
|
||
#endif BOOTPERF
|
||
(*pDhcpContext)->fTimersEnabled = FALSE;
|
||
Error = IPGetWOLCapability(DhcpIpGetIfIndex(*pDhcpContext),&Caps);
|
||
if( NO_ERROR == Error ) {
|
||
if( Caps & NDIS_DEVICE_WAKE_UP_ENABLE ) {
|
||
(*pDhcpContext)->fTimersEnabled = TRUE;
|
||
}
|
||
}
|
||
Error = NO_ERROR;
|
||
}
|
||
} else {
|
||
DhcpPrint((DEBUG_ERRORS, "QueryHwInfo(0x%lx)=0x%lx\n", IpInterfaceContext, Error));
|
||
}
|
||
|
||
if( KeyHandle ) RegCloseKey(KeyHandle);
|
||
if( ClientID.pbID ) DhcpFreeMemory(ClientID.pbID);
|
||
if( RegKey ) DhcpFreeMemory(RegKey);
|
||
if( HardwareAddress ) DhcpFreeMemory(HardwareAddress);
|
||
if (Error == NO_ERROR) {
|
||
(*pDhcpContext)->State.UniDirectional = (IsUnidirectionalAdapter(IpInterfaceContext))? 1: 0;
|
||
}
|
||
|
||
return Error;
|
||
}
|
||
|
||
DWORD // win32 status
|
||
DhcpRegFillParams( // re-read all the parameters for this adapter?
|
||
IN OUT PDHCP_CONTEXT DhcpContext, // read for this context
|
||
IN BOOL ReadAllInfo // read all information or just config stuff?
|
||
)
|
||
{
|
||
// currently ReadAllInfo parameter is ignored
|
||
HKEY KeyHandle;
|
||
|
||
DWORD Error;
|
||
DWORD DwordValue;
|
||
DWORD ValueType;
|
||
DWORD ValueSize;
|
||
DWORD AddressType;
|
||
DWORD i;
|
||
DWORD EnableDhcp;
|
||
DWORD dwIPAutoconfigurationEnabled;
|
||
DWORD DontPingGatewayFlag;
|
||
DWORD UseInformFlag;
|
||
DWORD InformSeparationInterval;
|
||
DWORD DwordValuesCount;
|
||
DWORD IpAddrValuesCount;
|
||
DWORD ReleaseOnShutdown;
|
||
DWORD fQuickBootEnabled;
|
||
|
||
DHCP_IP_ADDRESS Address;
|
||
DHCP_IP_ADDRESS IpAddress;
|
||
DHCP_IP_ADDRESS SubnetMask;
|
||
DHCP_IP_ADDRESS DhcpServerAddress;
|
||
DHCP_IP_ADDRESS DesiredIpAddress;
|
||
|
||
DWORD Lease;
|
||
LONG LeaseObtainedTime;
|
||
LONG T1Time;
|
||
LONG T2Time;
|
||
LONG LeaseTerminatedTime;
|
||
|
||
LPWSTR AdapterName;
|
||
LPWSTR ValueName;
|
||
LPWSTR IpAddressString;
|
||
CHAR IpAddressStringBuffer[DOT_IP_ADDR_SIZE];
|
||
|
||
DHCP_IPAUTOCONFIGURATION_CONTEXT IPAutoconfigContext;
|
||
|
||
struct /* anonymous */ {
|
||
LPDWORD Value;
|
||
LPWSTR ValueName;
|
||
} DwordValuesList[] = {
|
||
&EnableDhcp, DHCP_ENABLE_STRING,
|
||
&Lease, DHCP_LEASE,
|
||
&LeaseObtainedTime, DHCP_LEASE_OBTAINED_TIME,
|
||
&T1Time, DHCP_LEASE_T1_TIME,
|
||
&T2Time, DHCP_LEASE_T2_TIME,
|
||
&LeaseTerminatedTime, DHCP_LEASE_TERMINATED_TIME,
|
||
&dwIPAutoconfigurationEnabled, DHCP_IPAUTOCONFIGURATION_ENABLED,
|
||
&IPAutoconfigContext.Seed, DHCP_IPAUTOCONFIGURATION_SEED,
|
||
&AddressType, DHCP_ADDRESS_TYPE_VALUE,
|
||
&DontPingGatewayFlag, DHCP_DONT_PING_GATEWAY_FLAG,
|
||
&UseInformFlag, DHCP_USE_INFORM_FLAG,
|
||
#ifdef BOOTPERF
|
||
&fQuickBootEnabled, DHCP_QUICK_BOOT_FLAG,
|
||
#endif BOOTPERF
|
||
&InformSeparationInterval, DHCP_INFORM_SEPARATION_INTERVAL,
|
||
&ReleaseOnShutdown, DHCP_RELEASE_ON_SHUTDOWN_VALUE
|
||
};
|
||
|
||
struct /* anonymous */ {
|
||
LPDHCP_IP_ADDRESS Address;
|
||
LPWSTR ValueName;
|
||
} IpAddressValuesList[] = {
|
||
// The first element *HAS* to be Ip address -- see the function for why
|
||
&IpAddress, DHCP_IP_ADDRESS_STRING,
|
||
&SubnetMask, DHCP_SUBNET_MASK_STRING,
|
||
&DhcpServerAddress, DHCP_SERVER,
|
||
&IPAutoconfigContext.Address, DHCP_IPAUTOCONFIGURATION_ADDRESS,
|
||
&IPAutoconfigContext.Subnet, DHCP_IPAUTOCONFIGURATION_SUBNET,
|
||
&IPAutoconfigContext.Mask, DHCP_IPAUTOCONFIGURATION_MASK,
|
||
};
|
||
|
||
//
|
||
// Initialize locals
|
||
//
|
||
|
||
KeyHandle = DhcpContext->AdapterInfoKey;
|
||
EnableDhcp = FALSE;
|
||
Lease = 0;
|
||
LeaseObtainedTime = 0;
|
||
T1Time = 0;
|
||
T2Time = 0;
|
||
LeaseTerminatedTime = 0;
|
||
dwIPAutoconfigurationEnabled = (DhcpGlobalAutonetEnabled?TRUE:FALSE);
|
||
AddressType = ADDRESS_TYPE_DHCP;
|
||
DontPingGatewayFlag = DhcpGlobalDontPingGatewayFlag;
|
||
UseInformFlag = DhcpGlobalUseInformFlag;
|
||
#ifdef BOOTPERF
|
||
fQuickBootEnabled = DhcpGlobalQuickBootEnabledFlag;
|
||
#endif BOOTPERF
|
||
IpAddress = 0;
|
||
SubnetMask = 0;
|
||
DhcpServerAddress = 0;
|
||
IPAutoconfigContext.Address = 0;
|
||
IPAutoconfigContext.Subnet = inet_addr(DHCP_IPAUTOCONFIGURATION_DEFAULT_SUBNET);
|
||
IPAutoconfigContext.Mask = inet_addr(DHCP_IPAUTOCONFIGURATION_DEFAULT_MASK);
|
||
IPAutoconfigContext.Seed = 0;
|
||
InformSeparationInterval = DHCP_DEFAULT_INFORM_SEPARATION_INTERVAL;
|
||
ReleaseOnShutdown = DEFAULT_RELEASE_ON_SHUTDOWN;
|
||
|
||
AdapterName = ((PLOCAL_CONTEXT_INFO)(DhcpContext->LocalInformation))->AdapterName;
|
||
|
||
DwordValuesCount = sizeof(DwordValuesList)/sizeof(DwordValuesList[0]);
|
||
IpAddrValuesCount = sizeof(IpAddressValuesList)/sizeof(IpAddressValuesList[0]);
|
||
|
||
for( i = 0; i < DwordValuesCount ; i ++ ) {
|
||
ValueSize = sizeof(DWORD);
|
||
ValueName = DwordValuesList[i].ValueName;
|
||
Error = RegQueryValueEx(
|
||
KeyHandle,
|
||
ValueName,
|
||
0 /* Reserved */,
|
||
&ValueType,
|
||
(LPBYTE)&DwordValue,
|
||
&ValueSize
|
||
);
|
||
if( ERROR_SUCCESS != Error ) {
|
||
DhcpPrint((DEBUG_ERRORS, "RegValue %ws is not found? Error: %ld. Defaults used\n", ValueName, Error));
|
||
continue;
|
||
}
|
||
if( REG_DWORD != ValueType ) {
|
||
DhcpPrint((DEBUG_ERRORS, "RegValue %ws is not a DWORD. Defaults used\n", ValueName));
|
||
continue;
|
||
}
|
||
|
||
DhcpAssert( sizeof(DWORD) == ValueSize);
|
||
*DwordValuesList[i].Value = DwordValue;
|
||
DhcpPrint((DEBUG_TRACE, "RegValue %ws is [%ld]\n", ValueName, DwordValue));
|
||
}
|
||
|
||
if (IS_UNIDIRECTIONAL(DhcpContext)) {
|
||
DhcpPrint((DEBUG_MEDIA, "Detect Unidirectional Adapter: %ws\n", AdapterName));
|
||
EnableDhcp = FALSE;
|
||
dwIPAutoconfigurationEnabled = FALSE;
|
||
}
|
||
|
||
//For this to work correctly, the first element of array has to be the IPADDRESS
|
||
// RAS folks still use the DhcpIpAddress value in the registry, so dont change for them
|
||
if( !EnableDhcp && !NdisWanAdapter(DhcpContext) )
|
||
IpAddressValuesList[0].ValueName = DHCP_IPADDRESS_VALUE;
|
||
|
||
for( i = 0; i < IpAddrValuesCount ; i ++ ) {
|
||
ValueName = IpAddressValuesList[i].ValueName;
|
||
IpAddressString = NULL;
|
||
Error = GetRegistryString(
|
||
KeyHandle,
|
||
ValueName,
|
||
&IpAddressString,
|
||
NULL
|
||
);
|
||
|
||
if( ERROR_SUCCESS != Error ) {
|
||
DhcpPrint((DEBUG_ERRORS, "RegValue %ws : %ld -- Default used\n", ValueName, Error));
|
||
if( IpAddressString ) DhcpFreeMemory(IpAddressString);
|
||
continue;
|
||
}
|
||
|
||
if( wcslen(IpAddressString) >= DOT_IP_ADDR_SIZE ) {
|
||
// either the format is wrong or this is a ' ' separated string?
|
||
DhcpPrint((DEBUG_ERRORS, "String <%ws> is too long, will try to take first address\n", IpAddressString));
|
||
|
||
if( wcschr(IpAddressString, L' ') )
|
||
*wcschr(IpAddressString, L' ') = L'\0' ;
|
||
if( wcschr(IpAddressString, L',') )
|
||
*wcschr(IpAddressString, L',') = L'\0' ;
|
||
if( wcslen(IpAddressString) >= DOT_IP_ADDR_SIZE ) {
|
||
DhcpPrint((DEBUG_ERRORS, "Unable to split string <%ws> to DOT_IP_ADDR_SIZE -- ignoring string\n", IpAddressString));
|
||
if( IpAddressString ) DhcpFreeMemory(IpAddressString);
|
||
continue;
|
||
}
|
||
}
|
||
|
||
Address = inet_addr(DhcpUnicodeToOem(IpAddressString, IpAddressStringBuffer));
|
||
*IpAddressValuesList[i].Address = Address;
|
||
if( IpAddressString ) DhcpFreeMemory(IpAddressString);
|
||
DhcpPrint((DEBUG_TRACE, "RegValue %ws is ip-address %s\n", ValueName,
|
||
inet_ntoa(*(struct in_addr *)&Address)));
|
||
}
|
||
|
||
if( IpAddress == 0 ) DhcpServerAddress = 0;
|
||
|
||
//
|
||
// Sanity check read parameters
|
||
//
|
||
|
||
if( 0 == IPAutoconfigContext.Mask ) {
|
||
IPAutoconfigContext.Mask = inet_addr( DHCP_IPAUTOCONFIGURATION_DEFAULT_MASK);
|
||
IPAutoconfigContext.Subnet = inet_addr( DHCP_IPAUTOCONFIGURATION_DEFAULT_SUBNET);
|
||
}
|
||
|
||
if( (IPAutoconfigContext.Subnet & IPAutoconfigContext.Mask) != IPAutoconfigContext.Subnet) {
|
||
DhcpPrint((DEBUG_ERRORS, "Illegal (auto) Subnet address or mask\n"));
|
||
IPAutoconfigContext.Mask = inet_addr( DHCP_IPAUTOCONFIGURATION_DEFAULT_MASK);
|
||
IPAutoconfigContext.Subnet = inet_addr( DHCP_IPAUTOCONFIGURATION_DEFAULT_SUBNET);
|
||
}
|
||
|
||
if( 0 != IPAutoconfigContext.Address &&
|
||
(IPAutoconfigContext.Address & IPAutoconfigContext.Mask) != IPAutoconfigContext.Subnet) {
|
||
DhcpPrint((DEBUG_ERRORS, "Illegal (auto) IP address: %s\n",
|
||
inet_ntoa(*(struct in_addr *)&IPAutoconfigContext.Address)));
|
||
// cant use the specified address.. really.
|
||
IPAutoconfigContext.Address = 0;
|
||
}
|
||
|
||
DesiredIpAddress = IpAddress;
|
||
|
||
if( EnableDhcp && (time( NULL ) > LeaseTerminatedTime) || 0 == IpAddress ) {
|
||
IpAddress = 0;
|
||
SubnetMask = htonl(DhcpDefaultSubnetMask( IpAddress ));
|
||
|
||
Lease = 0;
|
||
LeaseObtainedTime = T1Time = T2Time = LeaseTerminatedTime = 0;
|
||
}
|
||
|
||
//
|
||
// fill in the fields of the context
|
||
//
|
||
|
||
// DhcpContext->NicListEntry will be done at the end
|
||
// DhcpContext->Haredware* already done in MakeNICEntry
|
||
DhcpContext->IpAddress = IpAddress;
|
||
DhcpContext->SubnetMask = SubnetMask;
|
||
DhcpContext->DhcpServerAddress = DhcpServerAddress;
|
||
if( ReadAllInfo ) DhcpContext->DesiredIpAddress = DesiredIpAddress;
|
||
DhcpContext->IPAutoconfigurationContext = IPAutoconfigContext;
|
||
// ClientID is filled in in MakeNICEntry
|
||
if( ReadAllInfo ) {
|
||
DhcpContext->Lease = Lease;
|
||
DhcpContext->LeaseObtained = LeaseObtainedTime;
|
||
DhcpContext->T1Time = T1Time;
|
||
DhcpContext->T2Time = T2Time;
|
||
DhcpContext->LeaseExpires = LeaseTerminatedTime;
|
||
}
|
||
// renewal list entry, run time, seconds since boot, renewal function
|
||
// send list, recd list, option cache, renew handle, class id
|
||
// --- all the above are handled elsewhere
|
||
|
||
DhcpContext->DontPingGatewayFlag = (DontPingGatewayFlag)?TRUE:FALSE;
|
||
DhcpContext->UseInformFlag = (UseInformFlag)?TRUE:FALSE;
|
||
DhcpContext->InformSeparationInterval = InformSeparationInterval;
|
||
DhcpContext->ReleaseOnShutdown = ReleaseOnShutdown;
|
||
#ifdef BOOTPERF
|
||
DhcpContext->fQuickBootEnabled = (fQuickBootEnabled ? TRUE : FALSE);
|
||
#endif BOOTPERF
|
||
|
||
// AdapterInfoKey is set in MakeContext
|
||
// RenewHandle is set in AddNICtoListEx
|
||
// DhcpContext->MessageBuffer set in MakeNICEntry
|
||
if( dwIPAutoconfigurationEnabled ) AUTONET_ENABLED(DhcpContext); else AUTONET_DISABLED(DhcpContext);
|
||
if( ReadAllInfo ) {
|
||
// DhcpContext->MessageBuffer set in MakeNICEntry
|
||
if( EnableDhcp ) ADDRESS_UNPLUMBED(DhcpContext); else ADDRESS_PLUMBED(DhcpContext);
|
||
SERVER_UNREACHED(DhcpContext);
|
||
if( dwIPAutoconfigurationEnabled ) AUTONET_ENABLED(DhcpContext); else AUTONET_DISABLED(DhcpContext);
|
||
CTXT_WAS_NOT_LOOKED(DhcpContext);
|
||
if( EnableDhcp ) DHCP_ENABLED(DhcpContext); else DHCP_DISABLED(DhcpContext);
|
||
if( ADDRESS_TYPE_AUTO != AddressType ) ACQUIRED_DHCP_ADDRESS(DhcpContext); else ACQUIRED_AUTO_ADDRESS(DhcpContext);
|
||
if( IS_ADDRESS_AUTO(DhcpContext) ) {
|
||
DhcpContext->IpAddress = 0; // this is useless if it is an autonet address
|
||
}
|
||
MEDIA_CONNECTED(DhcpContext);
|
||
// local info is setup in make context
|
||
}
|
||
|
||
return ERROR_SUCCESS;
|
||
}
|
||
|
||
DWORD // win32 status
|
||
DhcpRegFillFallbackConfig( // get the fallback config for this adapter
|
||
IN OUT PDHCP_CONTEXT DhcpContext // adapter context to fill in
|
||
)
|
||
{
|
||
DWORD Error; // returned error code
|
||
HKEY KeyHandle; // registry key to the configurations location
|
||
LPWSTR FbConfigName = NULL; // fallback configuration name
|
||
DWORD FbConfigNameLen; // length of the fallback configuration name
|
||
DWORD FbConfigNameType; // reg type of the configuration name
|
||
|
||
// start assuming there is no fallback configuration set
|
||
FALLBACK_DISABLED(DhcpContext);
|
||
|
||
// get the list of active configurations for this adapter.
|
||
// For now we expect (and handle) only one, the fallback config.
|
||
// For the future, the MULTI_SZ might contain several config names
|
||
// that will be involved in autodetection.
|
||
|
||
// query the registry for the configuration's name size
|
||
// [HKLM\SYSTEM\CCS\Services\Tcpip\Parameters\Interfaces\{Intf_GUID}]
|
||
// ActiveConfigurations = (REG_MULTI_SZ)
|
||
Error = RegQueryValueEx(
|
||
DhcpContext->AdapterInfoKey,
|
||
DHCP_IPAUTOCONFIGURATION_CFG,
|
||
NULL,
|
||
&FbConfigNameType,
|
||
NULL,
|
||
&FbConfigNameLen);
|
||
|
||
// if something went wrong or the value has not the
|
||
// expected type, break out with an error
|
||
if (Error != ERROR_SUCCESS ||
|
||
FbConfigNameType != DHCP_IPAUTOCONFIGURATION_CFG_TYPE)
|
||
{
|
||
// if no error was signaled it means we found a key but
|
||
// its type is different from the one expected. Convert
|
||
// the success to an ERROR_BAD_FORMAT failure
|
||
if (Error == ERROR_SUCCESS)
|
||
Error = ERROR_BAD_FORMAT;
|
||
|
||
// if we didn't find the pointer to the fallback config,
|
||
// it means we don't have one, hence is pure autonet.
|
||
// this is not a failure so return success
|
||
if (Error == ERROR_FILE_NOT_FOUND)
|
||
Error = ERROR_SUCCESS;
|
||
|
||
return Error;
|
||
}
|
||
|
||
// allocate space for the registry path where the configuration is stored.
|
||
// [HKLM\SYSTEM\CCS\Services\Dhcp\Configurations\{configuration_name}]
|
||
FbConfigName = DhcpAllocateMemory(
|
||
sizeof(DHCP_CLIENT_CONFIGURATIONS_KEY) +
|
||
sizeof(REGISTRY_CONNECT_STRING) +
|
||
FbConfigNameLen);
|
||
|
||
// if allocation failed, break out with error.
|
||
if (FbConfigName == NULL)
|
||
return ERROR_NOT_ENOUGH_MEMORY;
|
||
|
||
// build up the prefix of the path: "SYSTEM\CCS\Services\Dhcp\Configurations\"
|
||
wcscpy(FbConfigName, DHCP_CLIENT_CONFIGURATIONS_KEY REGISTRY_CONNECT_STRING);
|
||
|
||
// now, since we know what to expect and we have the storage
|
||
// for it, get the config name from the same location as above
|
||
Error = RegQueryValueEx(
|
||
DhcpContext->AdapterInfoKey,
|
||
DHCP_IPAUTOCONFIGURATION_CFG,
|
||
NULL,
|
||
&FbConfigNameType,
|
||
(LPBYTE)(FbConfigName + wcslen(FbConfigName)),
|
||
&FbConfigNameLen);
|
||
|
||
// the registry call above is expected to succeed and data
|
||
// to have the right type - we tested this before.
|
||
DhcpAssert(Error == ERROR_SUCCESS &&
|
||
FbConfigNameType == DHCP_IPAUTOCONFIGURATION_CFG_TYPE);
|
||
|
||
// open the registry key for this configuration
|
||
// [HKLM\SYSTEM\CCS\Services\Dhcp\Configurations\{Config_Name}]
|
||
Error = RegOpenKey(
|
||
HKEY_LOCAL_MACHINE,
|
||
FbConfigName,
|
||
&KeyHandle);
|
||
|
||
// in case of success...
|
||
if (Error == ERROR_SUCCESS)
|
||
{
|
||
// ...build up the FbOptionsList from that registry location
|
||
// from the "Options" value (REG_BINARY)
|
||
Error = DhcpRegReadOptionCache(
|
||
&DhcpContext->FbOptionsList,
|
||
KeyHandle,
|
||
DHCP_IPAUTOCONFIGURATION_CFGOPT,
|
||
TRUE // Add DhcpGlobalClassesList
|
||
);
|
||
|
||
if (Error == ERROR_SUCCESS)
|
||
{
|
||
// At this point we know for sure a fallback configuration
|
||
// is available. Set its flag accordingly
|
||
FALLBACK_ENABLED(DhcpContext);
|
||
}
|
||
// regardless success or failure, cleanup.
|
||
RegCloseKey(KeyHandle);
|
||
}
|
||
|
||
// free up the memory previously allocated
|
||
DhcpFreeMemory(FbConfigName);
|
||
|
||
// return the error code
|
||
return Error;
|
||
}
|
||
|
||
DWORD // win32 status
|
||
DhcpAddNICtoListEx( // create a context and add it to renew list
|
||
IN LPWSTR AdapterName, // adapter to create context for
|
||
IN DWORD IpInterfaceContext,
|
||
OUT PDHCP_CONTEXT *pDhcpContext // allocate a structure and fill this ptr
|
||
) {
|
||
DWORD Error;
|
||
HANDLE RenewHandle;
|
||
PDHCP_CONTEXT DhcpContext;
|
||
CHAR StateStringBuffer[200];
|
||
PLOCAL_CONTEXT_INFO LocalInfo;
|
||
|
||
RenewHandle = CreateSemaphore(
|
||
NULL, // No security
|
||
1, // count = 1
|
||
1, // MaxCount = 1
|
||
NULL // No name
|
||
);
|
||
if( NULL == RenewHandle ) {
|
||
Error = GetLastError();
|
||
|
||
DhcpPrint((DEBUG_ERRORS, "CreateSemaphore: %ld\n", Error));
|
||
return Error;
|
||
}
|
||
|
||
(*pDhcpContext) = NULL;
|
||
Error = DhcpMakeContext(AdapterName, IpInterfaceContext, pDhcpContext);
|
||
|
||
if( Error != ERROR_SUCCESS ) {
|
||
CloseHandle(RenewHandle);
|
||
return Error;
|
||
}
|
||
|
||
DhcpContext = (*pDhcpContext); // initialize some simple params
|
||
DhcpContext->RenewHandle = RenewHandle;
|
||
DhcpContext->NumberOfWaitingThreads = 0;
|
||
DhcpContext->CancelEvent = WSACreateEvent();
|
||
if (DhcpContext->CancelEvent == WSA_INVALID_EVENT) {
|
||
DhcpPrint((DEBUG_ERRORS, "WSAEvent 0x%lx could not be created: 0x%lx.\n",
|
||
DhcpContext->CancelEvent,
|
||
WSAGetLastError()));
|
||
}
|
||
|
||
DhcpContext->RunTime = 0;
|
||
DhcpContext->SecondsSinceBoot = 0;
|
||
DhcpContext->RenewalFunction = NULL;
|
||
InitializeListHead(&DhcpContext->RenewalListEntry);
|
||
InitializeListHead(&DhcpContext->SendOptionsList);
|
||
InitializeListHead(&DhcpContext->RecdOptionsList);
|
||
InitializeListHead(&DhcpContext->FbOptionsList);
|
||
|
||
Error = DhcpRegFillParams( // read all the registry parameters
|
||
DhcpContext,
|
||
TRUE // and yes, fill em up in the context
|
||
);
|
||
|
||
// read the fallback configuration (if any)
|
||
Error = DhcpRegFillFallbackConfig(
|
||
DhcpContext
|
||
);
|
||
|
||
DhcpPrint((DEBUG_TRACK,"Fallback: Loading returned %d.\n", Error));
|
||
|
||
#ifdef BOOTPERF
|
||
LocalInfo = (PLOCAL_CONTEXT_INFO)DhcpContext->LocalInformation;
|
||
|
||
if( IS_DHCP_DISABLED(DhcpContext) ) {
|
||
//
|
||
// Don't care about interface down info.
|
||
//
|
||
LocalInfo->fInterfaceDown = 0;
|
||
LocalInfo->OldIpAddress = 0;
|
||
LocalInfo->OldIpMask = 0;
|
||
} else {
|
||
//
|
||
// For DHCP enabled interfaces, if the interface is down,
|
||
// then bring it up with zero ip address. The protocol will
|
||
// take care of using the right IP address later on.
|
||
//
|
||
if( LocalInfo->fInterfaceDown ) {
|
||
DhcpPrint((DEBUG_ERRORS, "Interface already down\n"));
|
||
LocalInfo->OldIpAddress = 0;
|
||
LocalInfo->OldIpMask = 0;
|
||
LocalInfo->fInterfaceDown = 0;
|
||
IPResetIPAddress(
|
||
LocalInfo->IpInterfaceContext,
|
||
DhcpDefaultSubnetMask(0)
|
||
);
|
||
Error = BringUpInterface(LocalInfo);
|
||
if( ERROR_SUCCESS != Error ) {
|
||
DhcpPrint((DEBUG_ERRORS, "Interface can't be brought up: 0x%lx\n", Error));
|
||
}
|
||
}
|
||
}
|
||
#endif BOOTPERF
|
||
|
||
LOCK_OPTIONS_LIST();
|
||
DhcpRegReadClassId(DhcpContext); // fill in the class id first
|
||
Error = DhcpRegFillSendOptions( // figure the default list of options to send
|
||
&DhcpContext->SendOptionsList,
|
||
AdapterName,
|
||
DhcpContext->ClassId,
|
||
DhcpContext->ClassIdLength
|
||
);
|
||
if( ERROR_SUCCESS != Error ) {
|
||
DhcpPrint((DEBUG_ERRORS, "DhcpRegFillSendOptions(%ws):%ld\n", Error));
|
||
}
|
||
|
||
if( IS_DHCP_ENABLED( DhcpContext ) ) {
|
||
// read in the list of options we had before?
|
||
Error = DhcpRegReadOptionCache(
|
||
&DhcpContext->RecdOptionsList,
|
||
DhcpGlobalParametersKey,
|
||
AdapterName,
|
||
TRUE // Add DhcpGlobalClassesList
|
||
);
|
||
if( ERROR_SUCCESS != Error ) {
|
||
DhcpPrint((DEBUG_ERRORS, "DhcpRegReadOptionCache(%ws): %ld\n", AdapterName, Error));
|
||
}
|
||
} else {
|
||
//
|
||
// ignore any option cache for static addresses because
|
||
// of bug # 413319. Instead for non-ndiswan stuff, clear
|
||
// the option cache.
|
||
//
|
||
|
||
if( !NdisWanAdapter(DhcpContext) ) {
|
||
DhcpRegSaveOptions(
|
||
&DhcpContext->RecdOptionsList, AdapterName,
|
||
DhcpContext->ClassId, DhcpContext->ClassIdLength
|
||
);
|
||
}
|
||
}
|
||
|
||
UNLOCK_OPTIONS_LIST();
|
||
|
||
if (NdisWanAdapter(DhcpContext))
|
||
InterlockedIncrement(&DhcpGlobalNdisWanAdaptersCount);
|
||
|
||
LOCK_RENEW_LIST(); // insert this into the renew list
|
||
InsertTailList( &DhcpGlobalNICList, &DhcpContext->NicListEntry );
|
||
UNLOCK_RENEW_LIST();
|
||
|
||
DhcpPrint((DEBUG_INIT, "DhcpMakeAndInsertNICEntryEx: DhcpContext %lx, Flags %s\n",
|
||
DhcpContext, ConvertStateToString(DhcpContext, StateStringBuffer)));
|
||
|
||
return ERROR_SUCCESS;
|
||
}
|
||
|
||
#ifdef BOOTPERF
|
||
VOID
|
||
DhcpRegDeleteQuickBootValues(
|
||
IN HKEY Key
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
This routine deletes the values used for quickboot.
|
||
(If the values are not presentt they are ignored).
|
||
|
||
The values deleted are:
|
||
"TempIpAddress", "TempMask" and "TempLeaseExpirationTime"
|
||
|
||
Arguments:
|
||
Key -- key under which these values are deleted.
|
||
|
||
--*/
|
||
{
|
||
//
|
||
// ignore errors and silently delete values..
|
||
//
|
||
|
||
(void) RegDeleteValue(Key, DHCP_TEMP_IPADDRESS_VALUE );
|
||
(void) RegDeleteValue(Key, DHCP_TEMP_MASK_VALUE );
|
||
(void) RegDeleteValue(Key, DHCP_TEMP_LEASE_EXP_TIME_VALUE );
|
||
|
||
}
|
||
|
||
VOID
|
||
DhcpRegSaveQuickBootValues(
|
||
IN HKEY Key,
|
||
IN ULONG IpAddress,
|
||
IN ULONG Mask,
|
||
IN ULONGLONG LeaseExpirationTime
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
This routine saves the values needed to the registry.
|
||
Values saved are:
|
||
"TempIpAddress", "TempMask", "TempLeaseExpirationTime"
|
||
|
||
Arguments:
|
||
Key -- key to save under
|
||
IpAddress -- non-zero Ip address value
|
||
Mask -- non-zero mask value
|
||
LeaseExpirationTime -- lease expiration value.
|
||
|
||
--*/
|
||
{
|
||
ULONG Error;
|
||
|
||
if( NULL == Key ) return;
|
||
|
||
DhcpAssert( 0 != IpAddress || 0 != Mask );
|
||
Error = RegSetIpAddress(
|
||
Key, DHCP_TEMP_IPADDRESS_VALUE, REG_SZ, IpAddress
|
||
);
|
||
DhcpAssert( ERROR_SUCCESS == Error );
|
||
|
||
Error = RegSetIpAddress(
|
||
Key, DHCP_TEMP_MASK_VALUE, REG_SZ, Mask
|
||
);
|
||
DhcpAssert( ERROR_SUCCESS == Error );
|
||
|
||
Error = RegSetValueEx(
|
||
Key,
|
||
DHCP_TEMP_LEASE_EXP_TIME_VALUE,
|
||
0 /* Reserved */,
|
||
REG_BINARY,
|
||
(PVOID)&LeaseExpirationTime,
|
||
sizeof(LeaseExpirationTime)
|
||
);
|
||
DhcpAssert(ERROR_SUCCESS == Error);
|
||
}
|
||
|
||
#endif BOOTPERF
|
||
|
||
DHCP_IP_ADDRESS // the static ip address of the adapter
|
||
DhcpRegReadIpAddress( // get the first ip address
|
||
LPWSTR AdapterName, // the adaptor of interest
|
||
LPWSTR ValueName // the ip address value to read
|
||
) {
|
||
DWORD Error;
|
||
LPWSTR RegKey;
|
||
HKEY KeyHandle;
|
||
DWORD ValueType;
|
||
DWORD ValueSize;
|
||
LPWSTR IpAddressString;
|
||
CHAR OemIpAddressString[DOT_IP_ADDR_SIZE];
|
||
DHCP_IP_ADDRESS RetVal;
|
||
|
||
RetVal = inet_addr("0.0.0.0");
|
||
RegKey = NULL;
|
||
KeyHandle = NULL;
|
||
IpAddressString = NULL;
|
||
|
||
Error = ERROR_NOT_ENOUGH_MEMORY;
|
||
RegKey = DhcpAllocateMemory(
|
||
(wcslen(DHCP_SERVICES_KEY) +
|
||
wcslen(REGISTRY_CONNECT_STRING) +
|
||
wcslen(AdapterName) +
|
||
wcslen(DHCP_ADAPTER_PARAMETERS_KEY) + 1) *
|
||
sizeof(WCHAR) ); // termination char.
|
||
|
||
if( RegKey == NULL ) goto Cleanup;
|
||
|
||
wcscpy( RegKey, DHCP_SERVICES_KEY );
|
||
wcscat( RegKey, DHCP_ADAPTER_PARAMETERS_KEY );
|
||
wcscat( RegKey, REGISTRY_CONNECT_STRING );
|
||
wcscat( RegKey, AdapterName );
|
||
|
||
Error = RegOpenKeyEx(
|
||
HKEY_LOCAL_MACHINE,
|
||
RegKey,
|
||
0, // Reserved field
|
||
DHCP_CLIENT_KEY_ACCESS,
|
||
&KeyHandle
|
||
);
|
||
|
||
if( Error != ERROR_SUCCESS ) goto Cleanup;
|
||
|
||
Error = GetRegistryString(
|
||
KeyHandle,
|
||
ValueName,
|
||
&IpAddressString,
|
||
NULL
|
||
);
|
||
|
||
if( ERROR_SUCCESS != Error ) goto Cleanup;
|
||
|
||
DhcpPrint((DEBUG_MISC, "Static adapter <%ws> has ip address %ws\n",
|
||
AdapterName, IpAddressString));
|
||
|
||
DhcpAssert(NULL != IpAddressString);
|
||
|
||
RetVal = inet_addr(DhcpUnicodeToOem(IpAddressString, OemIpAddressString));
|
||
|
||
Cleanup:
|
||
|
||
if( RegKey) DhcpFreeMemory(RegKey);
|
||
if( KeyHandle ) DhcpFreeMemory(KeyHandle);
|
||
if( IpAddressString ) DhcpFreeMemory(IpAddressString);
|
||
|
||
if( ERROR_SUCCESS != Error ) {
|
||
DhcpPrint((DEBUG_ERRORS, "DhcpRegReadIpAddress: %ld\n", Error));
|
||
}
|
||
|
||
return RetVal;
|
||
}
|
||
|
||
BOOL // obtained a static address?
|
||
DhcpRegDomainName( // get the static domain name if any
|
||
IN PDHCP_CONTEXT DhcpContext, // adapter to get static domain for..
|
||
IN OUT LPBYTE DomainNameBuf, // buffer to fill with static domain name
|
||
IN ULONG BufSize // size of above buffer in bytes..
|
||
)
|
||
{
|
||
WCHAR DomBuf[260];
|
||
DWORD Result;
|
||
DWORD ValueType;
|
||
DWORD Size;
|
||
|
||
#if 0 // this is not really needed.
|
||
if( NULL == DhcpGlobalTcpipParametersKey ) { // maybe running in RAS context?
|
||
return FALSE; // no domain name in this context..
|
||
}
|
||
|
||
Size = BufSize;
|
||
Result = RegQueryValueExA( // first read the value from global
|
||
DhcpGlobalTcpipParametersKey, // Tcpip\Parameters\Domain key
|
||
DHCP_STATIC_DOMAIN_VALUE_A, // "Domain"
|
||
0,
|
||
&ValueType,
|
||
DomainNameBuf,
|
||
&BufSize
|
||
);
|
||
if( ERROR_SUCCESS == Result && REG_SZ == ValueType && BufSize > 1 ) {
|
||
return TRUE; // got a domain name! aha
|
||
}
|
||
BufSize = Size;
|
||
#endif
|
||
|
||
if( NULL == DhcpContext->AdapterInfoKey ) { // uh? dont know what this means..
|
||
return FALSE; // cant get global information in this case
|
||
}
|
||
|
||
Size = sizeof(DomBuf);
|
||
Result = RegQueryValueExW( // now try to read the per-adapter stuff..
|
||
DhcpContext->AdapterInfoKey, // per-adapter key is already there for us
|
||
DHCP_DOMAINNAME_VALUE, // same value.. "Domain"
|
||
0,
|
||
&ValueType,
|
||
(LPBYTE)DomBuf,
|
||
&Size
|
||
);
|
||
|
||
if( ERROR_SUCCESS == Result && REG_SZ == ValueType && Size > sizeof(WCHAR) ) {
|
||
if( NULL == DhcpUnicodeToOem(DomBuf, DomainNameBuf) ) return FALSE;
|
||
return TRUE;
|
||
}
|
||
|
||
return FALSE; // did not find a static domain in either place..
|
||
}
|
||
|
||
STATIC
|
||
struct /* anonymous */ {
|
||
DHCPKEY *GlobalKey;
|
||
LPWSTR KeyLocation;
|
||
} GlobalKeyList[] = { // the list of keys that need to be opened
|
||
&DhcpGlobalParametersKey, DHCP_CLIENT_PARAMETER_KEY,
|
||
&DhcpGlobalTcpipParametersKey, DHCP_TCPIP_PARAMETERS_KEY,
|
||
&DhcpGlobalClientOptionKey, DHCP_CLIENT_OPTION_KEY,
|
||
&DhcpGlobalServicesKey, DHCP_SERVICES_KEY,
|
||
NULL, NULL,
|
||
};
|
||
|
||
ULONG DwordDisplayPopup;
|
||
STATIC
|
||
struct /* anonymous */ {
|
||
DWORD *DwordValue;
|
||
LPWSTR ValueName;
|
||
} GlobalTcpipDwordParameters[] = { // The global list of DWORDS
|
||
&UseMHAsyncDns, DHCP_USE_MHASYNCDNS_FLAG,
|
||
&DhcpGlobalAutonetEnabled, DHCP_IPAUTOCONFIGURATION_ENABLED,
|
||
&AutonetRetriesSeconds, DHCP_AUTONET_RETRIES_VALUE,
|
||
&DhcpGlobalUseInformFlag, DHCP_USE_INFORM_FLAG,
|
||
&DhcpGlobalDontPingGatewayFlag,DHCP_DONT_PING_GATEWAY_FLAG,
|
||
#ifdef BOOTPERF
|
||
&DhcpGlobalQuickBootEnabledFlag,DHCP_QUICK_BOOT_FLAG,
|
||
#endif BOOTPERF
|
||
NULL, NULL,
|
||
},
|
||
GlobalDhcpDwordParameters[] = { // stored in Services\Dhcp\Params..
|
||
#if DBG
|
||
&DhcpGlobalDebugFlag, DHCP_DEBUG_FLAG_VALUE,
|
||
&DhcpGlobalServerPort, DHCP_SERVER_PORT_VALUE,
|
||
&DhcpGlobalClientPort, DHCP_CLIENT_PORT_VALUE,
|
||
#endif DBG
|
||
&DwordDisplayPopup, DHCP_DISPLAY_POPUPS_FLAG,
|
||
NULL, NULL,
|
||
};
|
||
|
||
DWORD // Win32 status
|
||
DhcpInitRegistry( // Initialize registry based globals
|
||
VOID
|
||
) {
|
||
DWORD Error;
|
||
DWORD i;
|
||
DWORD Type;
|
||
DWORD Size;
|
||
DWORD DwordValue;
|
||
LPWSTR ValueName;
|
||
|
||
DhcpGlobalAutonetEnabled = TRUE;
|
||
|
||
i = 0;
|
||
while( NULL != GlobalKeyList[i].GlobalKey ) {
|
||
Error = RegOpenKeyEx(
|
||
HKEY_LOCAL_MACHINE,
|
||
GlobalKeyList[i].KeyLocation,
|
||
0 /* Reserved */,
|
||
DHCP_CLIENT_KEY_ACCESS,
|
||
GlobalKeyList[i].GlobalKey
|
||
);
|
||
if( ERROR_SUCCESS != Error ) return Error;
|
||
i ++;
|
||
}
|
||
|
||
i = 0;
|
||
while( NULL != GlobalTcpipDwordParameters[i].DwordValue ) {
|
||
ValueName = GlobalTcpipDwordParameters[i++].ValueName;
|
||
Size = sizeof(DwordValue);
|
||
Error = RegQueryValueEx(
|
||
DhcpGlobalTcpipParametersKey,
|
||
ValueName,
|
||
0 /* Reserved */,
|
||
&Type,
|
||
(LPBYTE)&DwordValue,
|
||
&Size
|
||
);
|
||
|
||
if( ERROR_SUCCESS != Error ) {
|
||
DhcpPrint((DEBUG_INIT, "Did not find value %ws in the registry\n", ValueName));
|
||
continue;
|
||
}
|
||
|
||
if( REG_DWORD != Type ) {
|
||
DhcpPrint((DEBUG_ERRORS, "RegValue %ws is not DWORD type -- ignored\n", ValueName));
|
||
continue;
|
||
}
|
||
|
||
DhcpAssert(sizeof(DWORD) == Size);
|
||
*GlobalTcpipDwordParameters[i-1].DwordValue = DwordValue;
|
||
|
||
DhcpPrint((DEBUG_TRACE, "RegValue %ws = %ld = 0x%X\n", ValueName, DwordValue, DwordValue));
|
||
}
|
||
|
||
DwordDisplayPopup = 0;
|
||
i = 0;
|
||
while( NULL != GlobalDhcpDwordParameters[i].DwordValue ) {
|
||
ValueName = GlobalDhcpDwordParameters[i++].ValueName;
|
||
Size = sizeof(DwordValue);
|
||
Error = RegQueryValueEx(
|
||
DhcpGlobalParametersKey,
|
||
ValueName,
|
||
0 /* Reserved */,
|
||
&Type,
|
||
(LPBYTE)&DwordValue,
|
||
&Size
|
||
);
|
||
|
||
if( ERROR_SUCCESS != Error ) {
|
||
DhcpPrint((DEBUG_INIT, "Did not find value %ws in the registry\n", ValueName));
|
||
continue;
|
||
}
|
||
|
||
if( REG_DWORD != Type ) {
|
||
DhcpPrint((DEBUG_ERRORS, "RegValue %ws is not DWORD type -- ignored\n", ValueName));
|
||
continue;
|
||
}
|
||
|
||
DhcpAssert(sizeof(DWORD) == Size);
|
||
*GlobalDhcpDwordParameters[i-1].DwordValue = DwordValue;
|
||
|
||
DhcpPrint((DEBUG_TRACE, "RegValue %ws = %ld = 0x%X\n", ValueName, DwordValue, DwordValue));
|
||
}
|
||
|
||
if( DwordDisplayPopup ) DhcpGlobalDisplayPopup = TRUE ; else DhcpGlobalDisplayPopup = FALSE;
|
||
return DhcpRegReadOptionDefList();
|
||
}
|
||
|
||
VOID
|
||
DhcpCleanupRegistry( // undo the effects of InitReg call
|
||
VOID
|
||
) {
|
||
DWORD i;
|
||
|
||
i = 0;
|
||
while( NULL != GlobalKeyList[i].GlobalKey ) {
|
||
if( *GlobalKeyList[i].GlobalKey ) RegCloseKey(*GlobalKeyList[i].GlobalKey);
|
||
(*GlobalKeyList[i].GlobalKey) = NULL;
|
||
i ++ ;
|
||
}
|
||
}
|
||
//--------------------------------------------------------------------------------
|
||
// End of file
|
||
//--------------------------------------------------------------------------------
|
||
|