880 lines
21 KiB
C
880 lines
21 KiB
C
/*++
|
|
|
|
Copyright (c) 1997-1998 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
rtmcnfg.c
|
|
|
|
Abstract:
|
|
Routines that operate on configuration
|
|
information for RTM in the registry.
|
|
|
|
Author:
|
|
Chaitanya Kodeboyina (chaitk) 21-Aug-1998
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "pchrtm.h"
|
|
|
|
#pragma hdrstop
|
|
|
|
DWORD
|
|
RtmWriteDefaultConfig (
|
|
IN USHORT RtmInstanceId
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Write default configuration information into the
|
|
registry.
|
|
|
|
Arguments:
|
|
|
|
RtmInstanceId - Unique Id for this RTM instance
|
|
|
|
Return Value:
|
|
|
|
Status of the operation.
|
|
|
|
--*/
|
|
|
|
{
|
|
RTM_INSTANCE_CONFIG InstanceConfig;
|
|
RTM_ADDRESS_FAMILY_CONFIG AddrFamConfig;
|
|
DWORD Status;
|
|
|
|
CHECK_FOR_RTM_API_INITIALIZED();
|
|
|
|
TraceEnter("RtmWriteDefaultConfig");
|
|
|
|
//
|
|
// We have no RTM instance parameters at present
|
|
//
|
|
|
|
Status = RtmWriteInstanceConfig(RtmInstanceId, &InstanceConfig);
|
|
|
|
if (Status != NO_ERROR)
|
|
{
|
|
Trace1(ERR, "Default Config: Error %d writing instance key", Status);
|
|
|
|
TraceLeave("RtmWriteDefaultConfig");
|
|
|
|
return Status;
|
|
}
|
|
|
|
//
|
|
// Set up default address family parameters
|
|
//
|
|
|
|
AddrFamConfig.AddressSize = DEFAULT_ADDRESS_SIZE;
|
|
|
|
AddrFamConfig.MaxOpaqueInfoPtrs = DEFAULT_OPAQUE_INFO_PTRS;
|
|
AddrFamConfig.MaxNextHopsInRoute = DEFAULT_NEXTHOPS_IN_ROUTE;
|
|
|
|
AddrFamConfig.ViewsSupported = DEFAULT_VIEWS_SUPPORTED;
|
|
|
|
AddrFamConfig.MaxHandlesInEnum = DEFAULT_MAX_HANDLES_IN_ENUM;
|
|
AddrFamConfig.MaxChangeNotifyRegns = DEFAULT_MAX_NOTIFY_REGS;
|
|
|
|
//
|
|
// Write the default address family config
|
|
//
|
|
|
|
Status = RtmWriteAddressFamilyConfig(RtmInstanceId,
|
|
AF_INET,
|
|
&AddrFamConfig);
|
|
|
|
if (Status != NO_ERROR)
|
|
{
|
|
Trace1(ERR,
|
|
"Default Config: Error %d writing address family subkey",
|
|
Status);
|
|
}
|
|
|
|
TraceLeave("RtmWriteDefaultConfig");
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
DWORD
|
|
WINAPI
|
|
RtmReadInstanceConfig (
|
|
IN USHORT RtmInstanceId,
|
|
OUT PRTM_INSTANCE_CONFIG InstanceConfig
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Reads the configuration information for a particular
|
|
instance at creation time.
|
|
|
|
Arguments:
|
|
|
|
RtmInstanceId - Unique Id for this instance,
|
|
|
|
InstanceConfig - Buffer in which config info is retd.
|
|
|
|
Return Value:
|
|
|
|
Status of the operation.
|
|
|
|
--*/
|
|
|
|
{
|
|
HKEY ConfigHandle;
|
|
ULONG KeySize;
|
|
DWORD Status;
|
|
|
|
UNREFERENCED_PARAMETER(InstanceConfig);
|
|
|
|
CHECK_FOR_RTM_API_INITIALIZED();
|
|
|
|
TraceEnter("RtmReadInstanceConfig");
|
|
|
|
//
|
|
// Open the key that holds this instance's config
|
|
//
|
|
|
|
_snprintf(RtmGlobals.RegistryPath + RTM_CONFIG_ROOT_SIZE - 1,
|
|
MAX_CONFIG_KEY_SIZE,
|
|
REG_KEY_INSTANCE_TEMPLATE,
|
|
RtmInstanceId);
|
|
|
|
Status = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
|
|
RtmGlobals.RegistryPath,
|
|
0,
|
|
KEY_READ,
|
|
&ConfigHandle);
|
|
|
|
if (Status != NO_ERROR)
|
|
{
|
|
Trace1(ERR, "Instance Config: Error %d opening instance key", Status);
|
|
|
|
TraceLeave("RtmReadInstanceConfig");
|
|
|
|
return Status;
|
|
}
|
|
|
|
do
|
|
{
|
|
//
|
|
// Query values for parameters in instance config
|
|
//
|
|
|
|
KeySize = sizeof(DWORD);
|
|
|
|
|
|
// Nothing in the instance config at present
|
|
|
|
|
|
//
|
|
// Close the instance key once you are done querying
|
|
//
|
|
|
|
RegCloseKey(ConfigHandle);
|
|
|
|
TraceLeave("RtmReadInstanceConfig");
|
|
|
|
return NO_ERROR;
|
|
}
|
|
while (FALSE);
|
|
|
|
//
|
|
// Some error in the config - close handle and ret error
|
|
//
|
|
|
|
RegCloseKey(ConfigHandle);
|
|
|
|
TraceLeave("RtmReadInstanceConfig");
|
|
|
|
return (Status != NO_ERROR) ? Status: ERROR_BAD_CONFIGURATION;
|
|
}
|
|
|
|
|
|
DWORD
|
|
WINAPI
|
|
RtmWriteInstanceConfig (
|
|
IN USHORT RtmInstanceId,
|
|
IN PRTM_INSTANCE_CONFIG InstanceConfig
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Write the input instance config information into the
|
|
registry.
|
|
|
|
Arguments:
|
|
|
|
RtmInstanceId - Unique Id for this instance,
|
|
|
|
InstanceConfig - Config info for this instance.
|
|
|
|
Return Value:
|
|
|
|
Status of the operation.
|
|
|
|
--*/
|
|
|
|
{
|
|
HKEY ConfigHandle;
|
|
DWORD Status;
|
|
|
|
UNREFERENCED_PARAMETER(InstanceConfig);
|
|
|
|
CHECK_FOR_RTM_API_INITIALIZED();
|
|
|
|
TraceEnter("RtmWriteInstanceConfig");
|
|
|
|
//
|
|
// Create a key (or open existing) to hold instance's config
|
|
//
|
|
|
|
_snprintf(RtmGlobals.RegistryPath + RTM_CONFIG_ROOT_SIZE - 1,
|
|
MAX_CONFIG_KEY_SIZE,
|
|
REG_KEY_INSTANCE_TEMPLATE,
|
|
RtmInstanceId);
|
|
|
|
Status = RegCreateKeyEx(HKEY_LOCAL_MACHINE,
|
|
RtmGlobals.RegistryPath,
|
|
0,
|
|
NULL,
|
|
REG_OPTION_NON_VOLATILE,
|
|
KEY_WRITE,
|
|
NULL,
|
|
&ConfigHandle,
|
|
NULL);
|
|
|
|
if (Status != NO_ERROR)
|
|
{
|
|
Trace1(ERR, "Instance Config: Error %d creating instance key", Status);
|
|
|
|
TraceLeave("RtmWriteInstanceConfig");
|
|
|
|
return Status;
|
|
}
|
|
|
|
do
|
|
{
|
|
//
|
|
// Write values in instance config into the registry
|
|
//
|
|
|
|
|
|
// Nothing in the instance config at present time
|
|
|
|
|
|
//
|
|
// Close the instance key once you are done writing
|
|
//
|
|
|
|
RegCloseKey(ConfigHandle);
|
|
|
|
TraceLeave("RtmWriteInstanceConfig");
|
|
|
|
return NO_ERROR;
|
|
}
|
|
while (FALSE);
|
|
|
|
//
|
|
// Error writing values; close the handle and delete the key
|
|
//
|
|
|
|
Trace1(ERR,
|
|
"Instance Config: Error %d writing instance config parameters",
|
|
Status);
|
|
|
|
RegCloseKey(ConfigHandle);
|
|
|
|
RegDeleteKey(HKEY_LOCAL_MACHINE, RtmGlobals.RegistryPath);
|
|
|
|
TraceLeave("RtmWriteInstanceConfig");
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
DWORD
|
|
WINAPI
|
|
RtmReadAddressFamilyConfig (
|
|
IN USHORT RtmInstanceId,
|
|
IN USHORT AddressFamily,
|
|
OUT PRTM_ADDRESS_FAMILY_CONFIG AddrFamilyConfig
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Reads the configuration information for a particular
|
|
address family at creation time.
|
|
|
|
Arguments:
|
|
|
|
RtmInstanceId - ID (IPv4..) for this addr family info,
|
|
|
|
AddrFamilyConfig - Buffer in which addr family info is retd.
|
|
|
|
Return Value:
|
|
|
|
Status of the operation.
|
|
|
|
--*/
|
|
|
|
{
|
|
HKEY ConfigHandle;
|
|
ULONG KeySize;
|
|
ULONG KeyValue;
|
|
ULONG KeyType;
|
|
DWORD Status;
|
|
|
|
CHECK_FOR_RTM_API_INITIALIZED();
|
|
|
|
TraceEnter("RtmReadAddressFamilyConfig");
|
|
|
|
//
|
|
// Open the key that holds this address family's config
|
|
//
|
|
|
|
_snprintf(RtmGlobals.RegistryPath + RTM_CONFIG_ROOT_SIZE - 1,
|
|
MAX_CONFIG_KEY_SIZE,
|
|
REG_KEY_ADDR_FAMILY_TEMPLATE,
|
|
RtmInstanceId,
|
|
AddressFamily);
|
|
|
|
Status = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
|
|
RtmGlobals.RegistryPath,
|
|
0,
|
|
KEY_READ,
|
|
&ConfigHandle);
|
|
|
|
if (Status != NO_ERROR)
|
|
{
|
|
Trace1(ERR,
|
|
"Address Family Config: Error %d opening address family key",
|
|
Status);
|
|
|
|
TraceLeave("RtmReadAddressFamilyConfig");
|
|
|
|
return Status;
|
|
}
|
|
|
|
do
|
|
{
|
|
//
|
|
// Query values for parameters in address family config
|
|
//
|
|
|
|
KeySize = sizeof(DWORD);
|
|
|
|
//
|
|
// Query the 'address size' parameter
|
|
//
|
|
|
|
Status = RegQueryValueEx(ConfigHandle,
|
|
REG_KEY_ADDRESS_SIZE,
|
|
NULL,
|
|
&KeyType,
|
|
(PBYTE)&KeyValue,
|
|
&KeySize);
|
|
|
|
if ((Status != NO_ERROR) || (KeyType != REG_DWORD))
|
|
{
|
|
Trace1(ERR,
|
|
"Address Family Config: Error %d reading address size key",
|
|
Status);
|
|
break;
|
|
}
|
|
|
|
if ((KeyValue < MINIMUM_ADDRESS_SIZE) ||
|
|
(KeyValue > MAXIMUM_ADDRESS_SIZE))
|
|
{
|
|
Trace1(ERR,
|
|
"Address Family Config: Address Size %d out of bounds",
|
|
KeyValue);
|
|
break;
|
|
}
|
|
|
|
AddrFamilyConfig->AddressSize = KeyValue;
|
|
|
|
|
|
//
|
|
// Query the 'views supported' parameter
|
|
//
|
|
|
|
Status = RegQueryValueEx(ConfigHandle,
|
|
REG_KEY_VIEWS_SUPPORTED,
|
|
NULL,
|
|
&KeyType,
|
|
(PBYTE)&KeyValue,
|
|
&KeySize);
|
|
|
|
AddrFamilyConfig->ViewsSupported = DEFAULT_VIEWS_SUPPORTED;
|
|
|
|
if (Status == NO_ERROR)
|
|
{
|
|
if (KeyValue == 0)
|
|
{
|
|
Trace0(ERR, "Address Family Config: No supported views");
|
|
break;
|
|
}
|
|
|
|
AddrFamilyConfig->ViewsSupported = KeyValue;
|
|
}
|
|
|
|
|
|
//
|
|
// Query the 'max change notifications' parameter
|
|
//
|
|
|
|
Status = RegQueryValueEx(ConfigHandle,
|
|
REG_KEY_MAX_NOTIFY_REGS,
|
|
NULL,
|
|
&KeyType,
|
|
(PBYTE)&KeyValue,
|
|
&KeySize);
|
|
|
|
AddrFamilyConfig->MaxChangeNotifyRegns = DEFAULT_MAX_NOTIFY_REGS;
|
|
|
|
if (Status == NO_ERROR)
|
|
{
|
|
if ((KeyValue < MIN_MAX_NOTIFY_REGS) ||
|
|
(KeyValue > MAX_MAX_NOTIFY_REGS))
|
|
{
|
|
Trace1(ERR,
|
|
"Address Family Config: # notifications out of range",
|
|
KeyValue);
|
|
break;
|
|
}
|
|
|
|
AddrFamilyConfig->MaxChangeNotifyRegns = KeyValue;
|
|
}
|
|
|
|
|
|
//
|
|
// Query the 'max opaque info ptrs' parameter
|
|
//
|
|
|
|
Status = RegQueryValueEx(ConfigHandle,
|
|
REG_KEY_OPAQUE_INFO_PTRS,
|
|
NULL,
|
|
&KeyType,
|
|
(PBYTE)&KeyValue,
|
|
&KeySize);
|
|
|
|
AddrFamilyConfig->MaxOpaqueInfoPtrs = DEFAULT_OPAQUE_INFO_PTRS;
|
|
|
|
if (Status == NO_ERROR)
|
|
{
|
|
if (((int)KeyValue < MIN_OPAQUE_INFO_PTRS) ||
|
|
(KeyValue > MAX_OPAQUE_INFO_PTRS))
|
|
{
|
|
Trace1(ERR,
|
|
"Address Family Config: # opaque ptrs out of range",
|
|
KeyValue);
|
|
break;
|
|
}
|
|
|
|
AddrFamilyConfig->MaxOpaqueInfoPtrs = KeyValue;
|
|
}
|
|
|
|
|
|
//
|
|
// Query the 'max next hops per route' parameter
|
|
//
|
|
|
|
Status = RegQueryValueEx(ConfigHandle,
|
|
REG_KEY_NEXTHOPS_IN_ROUTE,
|
|
NULL,
|
|
&KeyType,
|
|
(PBYTE)&KeyValue,
|
|
&KeySize);
|
|
|
|
AddrFamilyConfig->MaxNextHopsInRoute = DEFAULT_NEXTHOPS_IN_ROUTE;
|
|
|
|
if (Status == NO_ERROR)
|
|
{
|
|
if ((KeyValue < MIN_NEXTHOPS_IN_ROUTE) ||
|
|
(KeyValue > MAX_NEXTHOPS_IN_ROUTE))
|
|
{
|
|
Trace1(ERR,
|
|
"Address Family Config: # nexthops out of range",
|
|
KeyValue);
|
|
break;
|
|
}
|
|
|
|
AddrFamilyConfig->MaxNextHopsInRoute = KeyValue;
|
|
}
|
|
|
|
|
|
//
|
|
// Query the 'max handles returned in enum' parameter
|
|
//
|
|
|
|
Status = RegQueryValueEx(ConfigHandle,
|
|
REG_KEY_MAX_HANDLES_IN_ENUM,
|
|
NULL,
|
|
&KeyType,
|
|
(PBYTE)&KeyValue,
|
|
&KeySize);
|
|
|
|
AddrFamilyConfig->MaxHandlesInEnum = DEFAULT_MAX_HANDLES_IN_ENUM;
|
|
|
|
if (Status == NO_ERROR)
|
|
{
|
|
if ((KeyValue < MIN_MAX_HANDLES_IN_ENUM) ||
|
|
(KeyValue > MAX_MAX_HANDLES_IN_ENUM))
|
|
{
|
|
Trace1(ERR,
|
|
"Address Family Config: # handles returned in enum",
|
|
KeyValue);
|
|
break;
|
|
}
|
|
|
|
AddrFamilyConfig->MaxHandlesInEnum = KeyValue;
|
|
}
|
|
|
|
//
|
|
// Close the instance key once you are done querying
|
|
//
|
|
|
|
RegCloseKey(ConfigHandle);
|
|
|
|
TraceLeave("RtmReadAddressFamilyConfig");
|
|
|
|
return NO_ERROR;
|
|
}
|
|
while (FALSE);
|
|
|
|
//
|
|
// Some error in the config - close handle and ret error
|
|
//
|
|
|
|
RegCloseKey(ConfigHandle);
|
|
|
|
TraceLeave("RtmReadAddressFamilyConfig");
|
|
|
|
return (Status != NO_ERROR) ? Status: ERROR_BAD_CONFIGURATION;
|
|
}
|
|
|
|
|
|
DWORD
|
|
WINAPI
|
|
RtmWriteAddressFamilyConfig (
|
|
IN USHORT RtmInstanceId,
|
|
IN USHORT AddressFamily,
|
|
IN PRTM_ADDRESS_FAMILY_CONFIG AddrFamilyConfig
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Write the input address family config information
|
|
into the registry.
|
|
|
|
Arguments:
|
|
|
|
RtmInstanceId - Instance to which addr family belongs to,
|
|
|
|
AddressFamily - ID for this address family,
|
|
|
|
AddrFamilyConfig - Configuration info for this address family.
|
|
|
|
Return Value:
|
|
|
|
Status of the operation.
|
|
|
|
--*/
|
|
|
|
{
|
|
CHAR AddressFamilySubKey[MAX_CONFIG_KEY_SIZE];
|
|
HKEY InstanceConfig;
|
|
HKEY ConfigHandle;
|
|
ULONG KeyValue;
|
|
DWORD Status;
|
|
|
|
CHECK_FOR_RTM_API_INITIALIZED();
|
|
|
|
TraceEnter("RtmWriteAddressFamilyConfig");
|
|
|
|
//
|
|
// Open the existing key that holds this RTM instance's config
|
|
//
|
|
|
|
_snprintf(RtmGlobals.RegistryPath + RTM_CONFIG_ROOT_SIZE - 1,
|
|
MAX_CONFIG_KEY_SIZE,
|
|
REG_KEY_INSTANCE_TEMPLATE,
|
|
RtmInstanceId);
|
|
|
|
Status = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
|
|
RtmGlobals.RegistryPath,
|
|
0,
|
|
KEY_READ,
|
|
&InstanceConfig);
|
|
|
|
if (Status != NO_ERROR)
|
|
{
|
|
//
|
|
// Need to create an instance before creating addr family
|
|
//
|
|
|
|
Trace1(ERR,
|
|
"Address Family Config: Error %d opening instance key",
|
|
Status);
|
|
|
|
TraceLeave("RtmWriteAddressFamilyConfig");
|
|
|
|
return Status;
|
|
}
|
|
|
|
//
|
|
// Create (or open existing) key to hold addr family's config
|
|
//
|
|
|
|
_snprintf(AddressFamilySubKey,
|
|
MAX_CONFIG_KEY_SIZE,
|
|
REG_KEY_ADDR_FAMILY_SUBKEY,
|
|
AddressFamily);
|
|
|
|
Status = RegCreateKeyEx(InstanceConfig,
|
|
AddressFamilySubKey,
|
|
0,
|
|
NULL,
|
|
REG_OPTION_NON_VOLATILE,
|
|
KEY_WRITE,
|
|
NULL,
|
|
&ConfigHandle,
|
|
NULL);
|
|
|
|
// Close the instance key as you no longer need it
|
|
RegCloseKey(InstanceConfig);
|
|
|
|
if (Status != NO_ERROR)
|
|
{
|
|
Trace1(ERR,
|
|
"Address Family Config: Error %d creating address family key",
|
|
Status);
|
|
|
|
TraceLeave("RtmWriteAddressFamilyConfig");
|
|
|
|
return Status;
|
|
}
|
|
|
|
//
|
|
// Write values in address family config into the registry
|
|
//
|
|
|
|
do
|
|
{
|
|
//
|
|
// Write the 'address size' value into the registry
|
|
//
|
|
|
|
KeyValue = AddrFamilyConfig->AddressSize;
|
|
if ((KeyValue < MINIMUM_ADDRESS_SIZE) ||
|
|
(KeyValue > MAXIMUM_ADDRESS_SIZE))
|
|
{
|
|
Trace1(ERR,
|
|
"Address Family Config: Address Size %d out of bounds",
|
|
KeyValue);
|
|
break;
|
|
}
|
|
|
|
Status = RegSetValueEx(ConfigHandle,
|
|
REG_KEY_ADDRESS_SIZE,
|
|
0,
|
|
REG_DWORD,
|
|
(PBYTE)&KeyValue,
|
|
sizeof(ULONG));
|
|
|
|
if (Status != NO_ERROR)
|
|
{
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Write the 'views supported' value into the registry
|
|
//
|
|
|
|
KeyValue = AddrFamilyConfig->ViewsSupported;
|
|
if (KeyValue == 0)
|
|
{
|
|
Trace0(ERR, "Address Family Config: No supported views");
|
|
break;
|
|
}
|
|
|
|
Status = RegSetValueEx(ConfigHandle,
|
|
REG_KEY_VIEWS_SUPPORTED,
|
|
0,
|
|
REG_DWORD,
|
|
(PBYTE)&KeyValue,
|
|
sizeof(ULONG));
|
|
|
|
if (Status != NO_ERROR)
|
|
{
|
|
break;
|
|
}
|
|
|
|
|
|
//
|
|
// Write 'max change notifications' value into registry
|
|
//
|
|
|
|
KeyValue = AddrFamilyConfig->MaxChangeNotifyRegns;
|
|
if ((KeyValue < MIN_MAX_NOTIFY_REGS) ||
|
|
(KeyValue > MAX_MAX_NOTIFY_REGS))
|
|
{
|
|
Trace1(ERR,
|
|
"Address Family Config: # Change notify regs out of range",
|
|
KeyValue);
|
|
break;
|
|
}
|
|
|
|
Status = RegSetValueEx(ConfigHandle,
|
|
REG_KEY_MAX_NOTIFY_REGS,
|
|
0,
|
|
REG_DWORD,
|
|
(PBYTE)&KeyValue,
|
|
sizeof(ULONG));
|
|
|
|
if (Status != NO_ERROR)
|
|
{
|
|
break;
|
|
}
|
|
|
|
|
|
//
|
|
// Write 'max opaque info ptrs' value into registry
|
|
//
|
|
|
|
KeyValue = AddrFamilyConfig->MaxOpaqueInfoPtrs;
|
|
if (((int)KeyValue < MIN_OPAQUE_INFO_PTRS) ||
|
|
(KeyValue > MAX_OPAQUE_INFO_PTRS))
|
|
{
|
|
Trace1(ERR,
|
|
"Address Family Config: # opaque ptrs out of range",
|
|
KeyValue);
|
|
break;
|
|
}
|
|
|
|
Status = RegSetValueEx(ConfigHandle,
|
|
REG_KEY_OPAQUE_INFO_PTRS,
|
|
0,
|
|
REG_DWORD,
|
|
(PBYTE)&KeyValue,
|
|
sizeof(ULONG));
|
|
|
|
if (Status != NO_ERROR)
|
|
{
|
|
break;
|
|
}
|
|
|
|
|
|
//
|
|
// Write 'max next hops per route' value into registry
|
|
//
|
|
|
|
KeyValue = AddrFamilyConfig->MaxNextHopsInRoute;
|
|
if ((KeyValue < MIN_NEXTHOPS_IN_ROUTE) ||
|
|
(KeyValue > MAX_NEXTHOPS_IN_ROUTE))
|
|
{
|
|
Trace1(ERR,
|
|
"Address Family Config: # nexthops out of range",
|
|
KeyValue);
|
|
break;
|
|
}
|
|
|
|
Status = RegSetValueEx(ConfigHandle,
|
|
REG_KEY_NEXTHOPS_IN_ROUTE,
|
|
0,
|
|
REG_DWORD,
|
|
(PBYTE)&KeyValue,
|
|
sizeof(ULONG));
|
|
|
|
if (Status != NO_ERROR)
|
|
{
|
|
break;
|
|
}
|
|
|
|
|
|
//
|
|
// Write 'max handles returned in enum' value into registry
|
|
//
|
|
|
|
KeyValue = AddrFamilyConfig->MaxHandlesInEnum;
|
|
if ((KeyValue < MIN_MAX_HANDLES_IN_ENUM) ||
|
|
(KeyValue > MAX_MAX_HANDLES_IN_ENUM))
|
|
{
|
|
Trace1(ERR,
|
|
"Address Family Config: # handles returned in enum",
|
|
KeyValue);
|
|
break;
|
|
}
|
|
|
|
Status = RegSetValueEx(ConfigHandle,
|
|
REG_KEY_MAX_HANDLES_IN_ENUM,
|
|
0,
|
|
REG_DWORD,
|
|
(PBYTE)&KeyValue,
|
|
sizeof(ULONG));
|
|
|
|
if (Status != NO_ERROR)
|
|
{
|
|
break;
|
|
}
|
|
|
|
|
|
//
|
|
// Close the address family key once you are done writing
|
|
//
|
|
|
|
RegCloseKey(ConfigHandle);
|
|
|
|
TraceLeave("RtmWriteAddressFamilyConfig");
|
|
|
|
return NO_ERROR;
|
|
}
|
|
while (FALSE);
|
|
|
|
//
|
|
// Were config values out of bounds ? Adjust err code
|
|
//
|
|
|
|
if (Status == NO_ERROR)
|
|
{
|
|
Status = ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
//
|
|
// Error occured, close the handle and delete the key
|
|
//
|
|
|
|
Trace1(ERR,
|
|
"Address Family Config: Error %d writing address family params",
|
|
Status);
|
|
|
|
RegCloseKey(ConfigHandle);
|
|
|
|
_snprintf(RtmGlobals.RegistryPath + RTM_CONFIG_ROOT_SIZE - 1,
|
|
MAX_CONFIG_KEY_SIZE,
|
|
REG_KEY_ADDR_FAMILY_TEMPLATE,
|
|
RtmInstanceId,
|
|
AddressFamily);
|
|
|
|
RegDeleteKey(HKEY_LOCAL_MACHINE, RtmGlobals.RegistryPath);
|
|
|
|
TraceLeave("RtmWriteAddressFamilyConfig");
|
|
|
|
return Status;
|
|
}
|