You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1549 lines
49 KiB
1549 lines
49 KiB
/*++
|
|
|
|
Copyright (c) 1990-1995 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
init.c
|
|
|
|
Abstract:
|
|
|
|
NDIS wrapper functions initializing drivers.
|
|
|
|
Author:
|
|
|
|
Adam Barr (adamba) 11-Jul-1990
|
|
|
|
Environment:
|
|
|
|
Kernel mode, FSD
|
|
|
|
Revision History:
|
|
|
|
26-Feb-1991 JohnsonA Added Debugging Code
|
|
10-Jul-1991 JohnsonA Implement revised Ndis Specs
|
|
01-Jun-1995 JameelH Re-organized
|
|
|
|
--*/
|
|
|
|
#include <precomp.h>
|
|
#include <atm.h>
|
|
#pragma hdrstop
|
|
|
|
#include <stdarg.h>
|
|
|
|
//
|
|
// Define the module number for debug code.
|
|
//
|
|
#define MODULE_NUMBER MODULE_INIT
|
|
|
|
//
|
|
// Configuration Requests
|
|
//
|
|
|
|
VOID
|
|
NdisOpenConfiguration(
|
|
OUT PNDIS_STATUS Status,
|
|
OUT PNDIS_HANDLE ConfigurationHandle,
|
|
IN NDIS_HANDLE WrapperConfigurationContext
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is used to open the parameter subkey of the
|
|
adapter registry tree.
|
|
|
|
Arguments:
|
|
|
|
Status - Returns the status of the request.
|
|
|
|
ConfigurationHandle - Returns a handle which is used in calls to
|
|
NdisReadConfiguration and NdisCloseConfiguration.
|
|
|
|
WrapperConfigurationContext - a handle pointing to an RTL_QUERY_REGISTRY_TABLE
|
|
that is set up for this driver's parameters.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
{
|
|
//
|
|
// Handle to be returned
|
|
//
|
|
PNDIS_CONFIGURATION_HANDLE HandleToReturn;
|
|
|
|
DBGPRINT_RAW(DBG_COMP_REG, DBG_LEVEL_INFO,
|
|
("==>NdisOpenConfiguration: WrapperConfigurationContext %p\n", WrapperConfigurationContext));
|
|
|
|
//
|
|
// Allocate the configuration handle
|
|
//
|
|
HandleToReturn = ALLOC_FROM_POOL(sizeof(NDIS_CONFIGURATION_HANDLE), NDIS_TAG_CONFIG_HANLDE);
|
|
|
|
*Status = (HandleToReturn != NULL) ? NDIS_STATUS_SUCCESS : NDIS_STATUS_RESOURCES;
|
|
|
|
if (*Status == NDIS_STATUS_SUCCESS)
|
|
{
|
|
HandleToReturn->KeyQueryTable = ((PNDIS_WRAPPER_CONFIGURATION_HANDLE)WrapperConfigurationContext)->ParametersQueryTable;
|
|
HandleToReturn->ParameterList = NULL;
|
|
*ConfigurationHandle = (NDIS_HANDLE)HandleToReturn;
|
|
}
|
|
|
|
DBGPRINT_RAW(DBG_COMP_REG, DBG_LEVEL_INFO,
|
|
("<==NdisOpenConfiguration: WrapperConfigurationContext %p\n", WrapperConfigurationContext));
|
|
}
|
|
|
|
|
|
VOID
|
|
NdisOpenConfigurationKeyByName(
|
|
OUT PNDIS_STATUS Status,
|
|
IN NDIS_HANDLE ConfigurationHandle,
|
|
IN PNDIS_STRING KeyName,
|
|
OUT PNDIS_HANDLE KeyHandle
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is used to open a subkey relative to the configuration handle.
|
|
|
|
Arguments:
|
|
|
|
Status - Returns the status of the request.
|
|
|
|
ConfigurationHandle - Handle to an already open section of the registry
|
|
|
|
KeyName - Name of the subkey to open
|
|
|
|
KeyHandle - Placeholder for the handle to the sub-key.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
{
|
|
//
|
|
// Handle to be returned
|
|
//
|
|
PNDIS_CONFIGURATION_HANDLE SKHandle, ConfigHandle = (PNDIS_CONFIGURATION_HANDLE)ConfigurationHandle;
|
|
PNDIS_WRAPPER_CONFIGURATION_HANDLE WConfigHandle;
|
|
UNICODE_STRING Parent, Child, Sep;
|
|
#define PQueryTable WConfigHandle->ParametersQueryTable
|
|
|
|
DBGPRINT_RAW(DBG_COMP_REG, DBG_LEVEL_INFO,
|
|
("==>NdisOpenConfigurationKeyByName: ConfigurationHandle\n", ConfigurationHandle));
|
|
|
|
ASSERT (KeGetCurrentIrql() < DISPATCH_LEVEL);
|
|
|
|
do
|
|
{
|
|
|
|
if (*ConfigHandle->KeyQueryTable[3].Name)
|
|
{
|
|
RtlInitUnicodeString(&Parent, ConfigHandle->KeyQueryTable[3].Name);
|
|
RtlInitUnicodeString(&Sep, L"\\");
|
|
Child.MaximumLength = KeyName->Length + Parent.Length + Sep.Length + sizeof(WCHAR);
|
|
}
|
|
else
|
|
{
|
|
Child.MaximumLength = KeyName->Length + sizeof(WCHAR);
|
|
}
|
|
|
|
Child.Length = 0;
|
|
|
|
//
|
|
// Allocate the configuration handle
|
|
//
|
|
|
|
SKHandle = ALLOC_FROM_POOL(sizeof(NDIS_CONFIGURATION_HANDLE) +
|
|
sizeof(NDIS_WRAPPER_CONFIGURATION_HANDLE) +
|
|
Child.MaximumLength,
|
|
NDIS_TAG_CONFIG_HANLDE);
|
|
|
|
*Status = (SKHandle != NULL) ? NDIS_STATUS_SUCCESS : NDIS_STATUS_RESOURCES;
|
|
|
|
if (*Status != NDIS_STATUS_SUCCESS)
|
|
{
|
|
*KeyHandle = (NDIS_HANDLE)NULL;
|
|
break;
|
|
}
|
|
|
|
WConfigHandle = (PNDIS_WRAPPER_CONFIGURATION_HANDLE)((PUCHAR)SKHandle + sizeof(NDIS_CONFIGURATION_HANDLE));
|
|
Child.Buffer = (PWSTR)((PUCHAR)WConfigHandle + sizeof(NDIS_WRAPPER_CONFIGURATION_HANDLE));
|
|
|
|
//
|
|
// if there is no parent path, avoid starting the child path with "\\"
|
|
//
|
|
if (*ConfigHandle->KeyQueryTable[3].Name)
|
|
{
|
|
RtlCopyUnicodeString(&Child, &Parent);
|
|
RtlAppendUnicodeStringToString(&Child, &Sep);
|
|
}
|
|
|
|
RtlAppendUnicodeStringToString(&Child, KeyName);
|
|
|
|
SKHandle->KeyQueryTable = WConfigHandle->ParametersQueryTable;
|
|
|
|
|
|
PQueryTable[0].QueryRoutine = NULL;
|
|
PQueryTable[0].Flags = RTL_QUERY_REGISTRY_SUBKEY;
|
|
PQueryTable[0].Name = L"";
|
|
|
|
//
|
|
// 1.
|
|
// Call ndisSaveParameter for a parameter, which will allocate storage for it.
|
|
//
|
|
PQueryTable[1].QueryRoutine = ndisSaveParameters;
|
|
PQueryTable[1].Flags = RTL_QUERY_REGISTRY_REQUIRED | RTL_QUERY_REGISTRY_NOEXPAND;
|
|
PQueryTable[1].DefaultType = REG_NONE;
|
|
|
|
//
|
|
// PQueryTable[0].Name and PQueryTable[0].EntryContext
|
|
// are filled in inside ReadConfiguration, in preparation
|
|
// for the callback.
|
|
//
|
|
// PQueryTable[0].Name = KeywordBuffer;
|
|
// PQueryTable[0].EntryContext = ParameterValue;
|
|
|
|
//
|
|
// 2.
|
|
// Stop
|
|
//
|
|
PQueryTable[2].QueryRoutine = NULL;
|
|
PQueryTable[2].Flags = 0;
|
|
PQueryTable[2].Name = NULL;
|
|
|
|
//
|
|
// NOTE: Some fields in ParametersQueryTable[3] are used to store information for later retrieval.
|
|
//
|
|
PQueryTable[3].QueryRoutine = ConfigHandle->KeyQueryTable[3].QueryRoutine;
|
|
PQueryTable[3].Name = Child.Buffer;
|
|
PQueryTable[3].EntryContext = NULL;
|
|
PQueryTable[3].DefaultData = NULL;
|
|
|
|
SKHandle->ParameterList = NULL;
|
|
*KeyHandle = (NDIS_HANDLE)SKHandle;
|
|
} while (FALSE);
|
|
|
|
DBGPRINT_RAW(DBG_COMP_REG, DBG_LEVEL_INFO,
|
|
("<==NdisOpenConfigurationKeyByName: ConfigurationHandle\n", ConfigurationHandle));
|
|
|
|
#undef PQueryTable
|
|
}
|
|
|
|
|
|
VOID
|
|
NdisOpenConfigurationKeyByIndex(
|
|
OUT PNDIS_STATUS Status,
|
|
IN NDIS_HANDLE ConfigurationHandle,
|
|
IN ULONG Index,
|
|
OUT PNDIS_STRING KeyName,
|
|
OUT PNDIS_HANDLE KeyHandle
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is used to open a subkey relative to the configuration handle.
|
|
|
|
Arguments:
|
|
|
|
Status - Returns the status of the request.
|
|
|
|
ConfigurationHandle - Handle to an already open section of the registry
|
|
|
|
Index - Index of the sub-key to open
|
|
|
|
KeyName - Placeholder for the name of subkey being opened
|
|
|
|
KeyHandle - Placeholder for the handle to the sub-key.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
{
|
|
PNDIS_CONFIGURATION_HANDLE ConfigHandle = (PNDIS_CONFIGURATION_HANDLE)ConfigurationHandle;
|
|
HANDLE Handle = NULL, RootHandle = NULL;
|
|
OBJECT_ATTRIBUTES ObjAttr;
|
|
UNICODE_STRING KeyPath = {0}, Services = {0}, AbsolutePath={0};
|
|
PKEY_BASIC_INFORMATION InfoBuf = NULL;
|
|
ULONG Len;
|
|
PDEVICE_OBJECT PhysicalDeviceObject;
|
|
PNDIS_MINIPORT_BLOCK Miniport;
|
|
|
|
DBGPRINT_RAW(DBG_COMP_REG, DBG_LEVEL_INFO,
|
|
("==>NdisOpenConfigurationKeyByIndex: ConfigurationHandle\n", ConfigurationHandle));
|
|
|
|
ASSERT (KeGetCurrentIrql() < DISPATCH_LEVEL);
|
|
|
|
*KeyHandle = NULL;
|
|
|
|
do
|
|
{
|
|
if (ConfigHandle->KeyQueryTable[3].Name != NULL)
|
|
{
|
|
RtlInitUnicodeString(&KeyPath, ConfigHandle->KeyQueryTable[3].Name);
|
|
}
|
|
|
|
if ((Miniport = (PNDIS_MINIPORT_BLOCK)ConfigHandle->KeyQueryTable[3].QueryRoutine) == NULL)
|
|
{
|
|
//
|
|
// protocols
|
|
//
|
|
|
|
//
|
|
// Open the current key and lookup the Nth subkey. But first conver the service relative
|
|
// path to absolute since this is what ZwOpenKey expects.
|
|
//
|
|
RtlInitUnicodeString(&Services, L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\");
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Adapters
|
|
//
|
|
// for adapters, first we have to open the key for PDO
|
|
//
|
|
|
|
PhysicalDeviceObject = Miniport->PhysicalDeviceObject;
|
|
|
|
#if NDIS_TEST_REG_FAILURE
|
|
*Status = STATUS_UNSUCCESSFUL;
|
|
#else
|
|
|
|
*Status = IoOpenDeviceRegistryKey(PhysicalDeviceObject,
|
|
PLUGPLAY_REGKEY_DRIVER,
|
|
GENERIC_READ | MAXIMUM_ALLOWED,
|
|
&RootHandle);
|
|
|
|
#endif
|
|
|
|
if (!NT_SUCCESS(*Status))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (KeyPath.Length || Services.Length)
|
|
{
|
|
AbsolutePath.MaximumLength = KeyPath.Length + Services.Length + sizeof(WCHAR);
|
|
AbsolutePath.Buffer = (PWSTR)ALLOC_FROM_POOL(AbsolutePath.MaximumLength, NDIS_TAG_DEFAULT);
|
|
if (AbsolutePath.Buffer == NULL)
|
|
{
|
|
*Status = NDIS_STATUS_RESOURCES;
|
|
break;
|
|
}
|
|
NdisMoveMemory(AbsolutePath.Buffer, Services.Buffer, Services.Length);
|
|
AbsolutePath.Length = Services.Length;
|
|
RtlAppendUnicodeStringToString(&AbsolutePath, &KeyPath);
|
|
}
|
|
|
|
InitializeObjectAttributes(&ObjAttr,
|
|
&AbsolutePath,
|
|
OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
|
|
RootHandle,
|
|
NULL);
|
|
|
|
*Status = ZwOpenKey(&Handle,
|
|
GENERIC_READ | MAXIMUM_ALLOWED,
|
|
&ObjAttr);
|
|
|
|
if (!NT_SUCCESS(*Status))
|
|
{
|
|
Handle = NULL;
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Allocate memory for the call to ZwEnumerateKey
|
|
//
|
|
Len = sizeof(KEY_BASIC_INFORMATION) + 256;
|
|
InfoBuf = (PKEY_BASIC_INFORMATION)ALLOC_FROM_POOL(Len, NDIS_TAG_DEFAULT);
|
|
if (InfoBuf == NULL)
|
|
{
|
|
*Status = NDIS_STATUS_RESOURCES;
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Get the Index(th) key, if it exists
|
|
//
|
|
*Status = ZwEnumerateKey(Handle,
|
|
Index,
|
|
KeyValueBasicInformation,
|
|
InfoBuf,
|
|
Len,
|
|
&Len);
|
|
|
|
if (NT_SUCCESS(*Status))
|
|
{
|
|
//
|
|
// This worked. Now simply pick up the name and do a NdisOpenConfigurationKeyByName on it.
|
|
//
|
|
KeyPath.Length = KeyPath.MaximumLength = (USHORT)InfoBuf->NameLength;
|
|
KeyPath.Buffer = InfoBuf->Name;
|
|
NdisOpenConfigurationKeyByName(Status,
|
|
ConfigurationHandle,
|
|
&KeyPath,
|
|
KeyHandle);
|
|
|
|
if (*Status == NDIS_STATUS_SUCCESS)
|
|
{
|
|
PNDIS_CONFIGURATION_HANDLE NewHandle = *(PNDIS_CONFIGURATION_HANDLE *)KeyHandle;
|
|
|
|
//
|
|
// The path in the new handle has the name of the key. Extract it and return to caller
|
|
//
|
|
RtlInitUnicodeString(KeyName, NewHandle->KeyQueryTable[3].Name);
|
|
KeyName->Buffer = (PWSTR)((PUCHAR)KeyName->Buffer + KeyName->Length - KeyPath.Length);
|
|
KeyName->Length = KeyPath.Length;
|
|
KeyName->MaximumLength = KeyPath.MaximumLength;
|
|
}
|
|
}
|
|
|
|
} while (FALSE);
|
|
|
|
if (AbsolutePath.Buffer != NULL)
|
|
{
|
|
FREE_POOL(AbsolutePath.Buffer);
|
|
}
|
|
|
|
if (InfoBuf != NULL)
|
|
{
|
|
FREE_POOL(InfoBuf);
|
|
}
|
|
|
|
if (RootHandle)
|
|
ZwClose (RootHandle);
|
|
|
|
if (Handle)
|
|
ZwClose (Handle);
|
|
|
|
|
|
DBGPRINT_RAW(DBG_COMP_REG, DBG_LEVEL_INFO,
|
|
("<==NdisOpenConfigurationKeyByIndex: ConfigurationHandle\n", ConfigurationHandle));
|
|
}
|
|
|
|
|
|
VOID
|
|
NdisReadConfiguration(
|
|
OUT PNDIS_STATUS Status,
|
|
OUT PNDIS_CONFIGURATION_PARAMETER * ParameterValue,
|
|
IN NDIS_HANDLE ConfigurationHandle,
|
|
IN PNDIS_STRING Keyword,
|
|
IN NDIS_PARAMETER_TYPE ParameterType
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is used to read the parameter for a configuration
|
|
keyword from the configuration database.
|
|
|
|
Arguments:
|
|
|
|
Status - Returns the status of the request.
|
|
|
|
ParameterValue - Returns the value for this keyword.
|
|
|
|
ConfigurationHandle - Handle returned by NdisOpenConfiguration. Points
|
|
to the parameter subkey.
|
|
|
|
Keyword - The keyword to search for.
|
|
|
|
ParameterType - Ignored on NT, specifies the type of the value.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS RegistryStatus;
|
|
PWSTR KeywordBuffer = NULL;
|
|
UINT i;
|
|
PNDIS_CONFIGURATION_HANDLE ConfigHandle = (PNDIS_CONFIGURATION_HANDLE)ConfigurationHandle;
|
|
PDEVICE_OBJECT PhysicalDeviceObject;
|
|
HANDLE Handle = NULL;
|
|
PNDIS_MINIPORT_BLOCK Miniport = NULL;
|
|
PCM_PARTIAL_RESOURCE_LIST pResourceList;
|
|
UINT j;
|
|
ULONG ValueData;
|
|
|
|
#define PQueryTable ConfigHandle->KeyQueryTable
|
|
|
|
//
|
|
// There are some built-in parameters which can always be
|
|
// read, even if not present in the registry. This is the
|
|
// number of them.
|
|
//
|
|
#define BUILT_IN_COUNT 3
|
|
|
|
static NDIS_STRING BuiltInStrings[BUILT_IN_COUNT] =
|
|
{
|
|
NDIS_STRING_CONST ("Environment"),
|
|
NDIS_STRING_CONST ("ProcessorType"),
|
|
NDIS_STRING_CONST ("NdisVersion")
|
|
};
|
|
|
|
static NDIS_STRING MiniportNameStr = NDIS_STRING_CONST ("MiniportName");
|
|
|
|
#define STANDARD_RESOURCE_COUNT 9
|
|
//
|
|
// The names of the standard resource types.
|
|
//
|
|
static NDIS_STRING StandardResourceStrings[STANDARD_RESOURCE_COUNT] =
|
|
{
|
|
NDIS_STRING_CONST ("IoBaseAddress"),
|
|
NDIS_STRING_CONST ("InterruptNumber"),
|
|
NDIS_STRING_CONST ("MemoryMappedBaseAddress"),
|
|
NDIS_STRING_CONST ("DmaChannel"),
|
|
//
|
|
// a few drivers use non-standard keywords, so take care of them for now
|
|
//
|
|
NDIS_STRING_CONST ("IoAddress"),
|
|
NDIS_STRING_CONST ("Interrupt"),
|
|
NDIS_STRING_CONST ("IOBase"),
|
|
NDIS_STRING_CONST ("Irq"),
|
|
NDIS_STRING_CONST ("RamAddress")
|
|
};
|
|
|
|
UCHAR StandardResourceTypes[STANDARD_RESOURCE_COUNT]=
|
|
{
|
|
CmResourceTypePort,
|
|
CmResourceTypeInterrupt,
|
|
CmResourceTypeMemory,
|
|
CmResourceTypeDma,
|
|
CmResourceTypePort,
|
|
CmResourceTypeInterrupt,
|
|
CmResourceTypePort,
|
|
CmResourceTypeInterrupt,
|
|
CmResourceTypeMemory
|
|
};
|
|
|
|
static NDIS_CONFIGURATION_PARAMETER BuiltInParameters[BUILT_IN_COUNT] =
|
|
{ { NdisParameterInteger, NdisEnvironmentWindowsNt },
|
|
{ NdisParameterInteger,
|
|
#if defined(_M_IX86)
|
|
NdisProcessorX86
|
|
#elif defined(_M_MRX000)
|
|
NdisProcessorMips
|
|
#elif defined(_ALPHA_)
|
|
NdisProcessorAlpha
|
|
#else
|
|
NdisProcessorPpc
|
|
#endif
|
|
},
|
|
{ NdisParameterInteger, ((NDIS_MAJOR_VERSION << 16) | NDIS_MINOR_VERSION)}
|
|
};
|
|
|
|
DBGPRINT_RAW(DBG_COMP_REG, DBG_LEVEL_INFO,
|
|
("==>NdisReadConfiguration\n"));
|
|
DBGPRINT_RAW(DBG_COMP_REG, DBG_LEVEL_INFO,
|
|
(" Keyword: "));
|
|
DBGPRINT_UNICODE(DBG_COMP_REG, DBG_LEVEL_INFO,
|
|
Keyword);
|
|
DBGPRINT_RAW(DBG_COMP_REG, DBG_LEVEL_INFO,
|
|
("\n"));
|
|
|
|
ASSERT (KeGetCurrentIrql() < DISPATCH_LEVEL);
|
|
|
|
|
|
do
|
|
{
|
|
KeywordBuffer = Keyword->Buffer;
|
|
|
|
//
|
|
// assume failure
|
|
//
|
|
RegistryStatus = STATUS_UNSUCCESSFUL;
|
|
|
|
//
|
|
// First check if this is one of the built-in parameters.
|
|
//
|
|
for (i = 0; i < BUILT_IN_COUNT; i++)
|
|
{
|
|
if (RtlEqualUnicodeString(Keyword, &BuiltInStrings[i], TRUE))
|
|
{
|
|
RegistryStatus = STATUS_SUCCESS;
|
|
*ParameterValue = &BuiltInParameters[i];
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (NT_SUCCESS(RegistryStatus))
|
|
break;
|
|
|
|
if ((Miniport = (PNDIS_MINIPORT_BLOCK)PQueryTable[3].QueryRoutine) != NULL)
|
|
{
|
|
//
|
|
// check to see if driver is asking for miniport name
|
|
//
|
|
if (RtlEqualUnicodeString(Keyword, &MiniportNameStr, TRUE))
|
|
{
|
|
|
|
RegistryStatus = ndisSaveParameters(MiniportNameStr.Buffer,
|
|
REG_SZ,
|
|
(PVOID)Miniport->MiniportName.Buffer,
|
|
Miniport->MiniportName.Length,
|
|
(PVOID)ConfigHandle,
|
|
(PVOID)ParameterValue);
|
|
|
|
break;
|
|
}
|
|
|
|
//
|
|
// check to see if this is a resource keyword
|
|
//
|
|
for (i = 0; i < STANDARD_RESOURCE_COUNT; i++)
|
|
{
|
|
if (RtlEqualUnicodeString(Keyword, &StandardResourceStrings[i], TRUE))
|
|
break;
|
|
}
|
|
|
|
if (i < STANDARD_RESOURCE_COUNT)
|
|
{
|
|
|
|
NDIS_WARN(TRUE, Miniport, NDIS_GFLAG_WARN_LEVEL_2,
|
|
("NdisReadConfiguration: Miniport %p should use NdisMQueryAdapterResources to get the standard resources.\n", Miniport));
|
|
|
|
do
|
|
{
|
|
if (Miniport->AllocatedResources == NULL)
|
|
break;
|
|
|
|
pResourceList = &(Miniport->AllocatedResources->List[0].PartialResourceList);
|
|
|
|
//
|
|
// walk through resource list and find the first one that matches
|
|
//
|
|
for (j = 0; j < pResourceList->Count; j++)
|
|
{
|
|
if (pResourceList->PartialDescriptors[j].Type == StandardResourceTypes[i])
|
|
{
|
|
//
|
|
// could have used pResourceList->PartialDescriptors[j].Generic.Start.LowPart for all
|
|
// cases, but in the future, memory value can be 64 bit
|
|
//
|
|
|
|
switch (StandardResourceTypes[i])
|
|
{
|
|
|
|
case CmResourceTypePort:
|
|
ValueData = pResourceList->PartialDescriptors[j].u.Port.Start.LowPart;
|
|
break;
|
|
|
|
case CmResourceTypeInterrupt:
|
|
ValueData = pResourceList->PartialDescriptors[j].u.Interrupt.Level;
|
|
break;
|
|
|
|
case CmResourceTypeMemory:
|
|
ValueData = pResourceList->PartialDescriptors[j].u.Memory.Start.LowPart;
|
|
break;
|
|
|
|
case CmResourceTypeDma:
|
|
ValueData = pResourceList->PartialDescriptors[j].u.Dma.Channel;
|
|
break;
|
|
|
|
default:
|
|
ASSERT(FALSE);
|
|
}
|
|
|
|
//
|
|
// call SaveParameter ourselves
|
|
//
|
|
RegistryStatus = ndisSaveParameters(StandardResourceStrings[i].Buffer,
|
|
REG_DWORD,
|
|
(PVOID)&ValueData,
|
|
sizeof(ULONG),
|
|
(PVOID)ConfigHandle,
|
|
(PVOID)ParameterValue);
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (j >= pResourceList->Count)
|
|
{
|
|
RegistryStatus = STATUS_UNSUCCESSFUL;
|
|
}
|
|
|
|
} while (FALSE);
|
|
|
|
//
|
|
// if keyword was a standard resource keyword, we should break here
|
|
// no matter what the outcome of finding the resource in resource list
|
|
//
|
|
break;
|
|
} // end of if it was a resource keyword
|
|
|
|
} // end of if NdisReadConfiguration called for a miniport
|
|
|
|
//
|
|
// the keyword was not a standard resource or built-in keyword
|
|
// get back to our regular programming...
|
|
//
|
|
|
|
//
|
|
// Allocate room for a null-terminated version of the keyword
|
|
//
|
|
KeywordBuffer = (PWSTR)ALLOC_FROM_POOL(Keyword->Length + sizeof(WCHAR), NDIS_TAG_DEFAULT);
|
|
if (KeywordBuffer == NULL)
|
|
{
|
|
RegistryStatus = STATUS_UNSUCCESSFUL;;
|
|
break;
|
|
}
|
|
CopyMemory(KeywordBuffer, Keyword->Buffer, Keyword->Length);
|
|
|
|
*(PWCHAR)(((PUCHAR)KeywordBuffer)+Keyword->Length) = (WCHAR)L'\0';
|
|
|
|
PQueryTable[1].Name = KeywordBuffer;
|
|
PQueryTable[1].EntryContext = ParameterValue;
|
|
|
|
if (Miniport != NULL)
|
|
{
|
|
PhysicalDeviceObject = Miniport->PhysicalDeviceObject;
|
|
|
|
//
|
|
// set the subkey
|
|
//
|
|
PQueryTable[0].Name = PQueryTable[3].Name;
|
|
|
|
#if NDIS_TEST_REG_FAILURE
|
|
RegistryStatus = STATUS_UNSUCCESSFUL;
|
|
#else
|
|
RegistryStatus = IoOpenDeviceRegistryKey(PhysicalDeviceObject,
|
|
PLUGPLAY_REGKEY_DRIVER,
|
|
GENERIC_READ | MAXIMUM_ALLOWED,
|
|
&Handle);
|
|
|
|
#endif
|
|
|
|
if(NT_SUCCESS(RegistryStatus))
|
|
{
|
|
RegistryStatus = RtlQueryRegistryValues(RTL_REGISTRY_HANDLE,
|
|
Handle,
|
|
PQueryTable,
|
|
ConfigHandle, // context
|
|
NULL);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// protocols
|
|
//
|
|
RegistryStatus = RtlQueryRegistryValues(RTL_REGISTRY_SERVICES,
|
|
PQueryTable[3].Name,
|
|
PQueryTable,
|
|
ConfigHandle, // context
|
|
NULL);
|
|
}
|
|
|
|
if (NT_SUCCESS(RegistryStatus))
|
|
{
|
|
//
|
|
// if a value is stored in registry as string but the driver is trying
|
|
// to read it as Integer or HexInteger, do the conversion here
|
|
//
|
|
|
|
if ((*ParameterValue)->ParameterType == NdisParameterString)
|
|
{
|
|
if (ParameterType == NdisParameterInteger)
|
|
{
|
|
RtlUnicodeStringToInteger(&(*ParameterValue)->ParameterData.StringData,
|
|
10, (PULONG)(&(*ParameterValue)->ParameterData.IntegerData));
|
|
(*ParameterValue)->ParameterType = NdisParameterInteger;
|
|
}
|
|
else if (ParameterType == NdisParameterHexInteger)
|
|
{
|
|
RtlUnicodeStringToInteger(&(*ParameterValue)->ParameterData.StringData,
|
|
16, (PULONG)(&(*ParameterValue)->ParameterData.IntegerData));
|
|
(*ParameterValue)->ParameterType = NdisParameterHexInteger;
|
|
}
|
|
}
|
|
}
|
|
|
|
} while (FALSE);
|
|
|
|
if (KeywordBuffer && (KeywordBuffer != Keyword->Buffer))
|
|
{
|
|
FREE_POOL(KeywordBuffer); // no longer needed
|
|
}
|
|
|
|
if (!NT_SUCCESS(RegistryStatus))
|
|
{
|
|
*Status = NDIS_STATUS_FAILURE;
|
|
}
|
|
else
|
|
{
|
|
*Status = NDIS_STATUS_SUCCESS;
|
|
}
|
|
|
|
if (Handle)
|
|
ZwClose(Handle);
|
|
|
|
DBGPRINT_RAW(DBG_COMP_REG, DBG_LEVEL_INFO,
|
|
("<==NdisReadConfiguration\n"));
|
|
|
|
#undef PQueryTable
|
|
}
|
|
|
|
|
|
VOID
|
|
NdisWriteConfiguration(
|
|
OUT PNDIS_STATUS Status,
|
|
IN NDIS_HANDLE ConfigurationHandle,
|
|
IN PNDIS_STRING Keyword,
|
|
PNDIS_CONFIGURATION_PARAMETER ParameterValue
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is used to write a parameter to the configuration database.
|
|
|
|
Arguments:
|
|
|
|
Status - Returns the status of the request.
|
|
|
|
ConfigurationHandle - Handle passed to the driver
|
|
|
|
Keyword - The keyword to set.
|
|
|
|
ParameterValue - Specifies the new value for this keyword.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
{
|
|
PNDIS_CONFIGURATION_HANDLE NdisConfigHandle = (PNDIS_CONFIGURATION_HANDLE)ConfigurationHandle;
|
|
NTSTATUS RegistryStatus;
|
|
PNDIS_MINIPORT_BLOCK Miniport;
|
|
PWSTR KeywordBuffer;
|
|
BOOLEAN FreeKwBuf = FALSE;
|
|
PVOID ValueData = NULL;
|
|
ULONG ValueLength = 0;
|
|
ULONG ValueType = REG_DWORD;
|
|
PDEVICE_OBJECT PhysicalDeviceObject;
|
|
HANDLE Handle, RootHandle;
|
|
OBJECT_ATTRIBUTES ObjAttr;
|
|
UNICODE_STRING RelativePath;
|
|
|
|
DBGPRINT_RAW(DBG_COMP_REG, DBG_LEVEL_INFO,
|
|
("==>NdisWriteConfiguration: ConfigurationHandle %p\n", ConfigurationHandle));
|
|
|
|
ASSERT (KeGetCurrentIrql() < DISPATCH_LEVEL);
|
|
|
|
*Status = NDIS_STATUS_SUCCESS;
|
|
KeywordBuffer = Keyword->Buffer;
|
|
|
|
do
|
|
{
|
|
//
|
|
// Get the value data.
|
|
//
|
|
switch (ParameterValue->ParameterType)
|
|
{
|
|
case NdisParameterHexInteger:
|
|
case NdisParameterInteger:
|
|
ValueData = &ParameterValue->ParameterData.IntegerData;
|
|
ValueLength = sizeof(ParameterValue->ParameterData.IntegerData);
|
|
ValueType = REG_DWORD;
|
|
break;
|
|
|
|
case NdisParameterString:
|
|
ValueData = ParameterValue->ParameterData.StringData.Buffer;
|
|
ValueLength = ParameterValue->ParameterData.StringData.Length;
|
|
ValueType = REG_SZ;
|
|
break;
|
|
|
|
case NdisParameterMultiString:
|
|
ValueData = ParameterValue->ParameterData.StringData.Buffer;
|
|
ValueLength = ParameterValue->ParameterData.StringData.Length;
|
|
ValueType = REG_MULTI_SZ;
|
|
break;
|
|
|
|
case NdisParameterBinary:
|
|
ValueData = ParameterValue->ParameterData.BinaryData.Buffer;
|
|
ValueLength = ParameterValue->ParameterData.BinaryData.Length;
|
|
ValueType = REG_BINARY;
|
|
break;
|
|
|
|
default:
|
|
*Status = NDIS_STATUS_NOT_SUPPORTED;
|
|
break;
|
|
}
|
|
|
|
if (*Status != NDIS_STATUS_SUCCESS)
|
|
break;
|
|
|
|
if (Keyword->MaximumLength <= (Keyword->Length + sizeof(WCHAR)))
|
|
{
|
|
KeywordBuffer = (PWSTR)ALLOC_FROM_POOL(Keyword->Length + sizeof(WCHAR), NDIS_TAG_DEFAULT);
|
|
if (KeywordBuffer == NULL)
|
|
{
|
|
*Status = NDIS_STATUS_RESOURCES;
|
|
break;
|
|
}
|
|
CopyMemory(KeywordBuffer, Keyword->Buffer, Keyword->Length);
|
|
FreeKwBuf = TRUE;
|
|
}
|
|
|
|
*(PWCHAR)(((PUCHAR)KeywordBuffer)+Keyword->Length) = (WCHAR)L'\0';
|
|
|
|
if ((Miniport = (PNDIS_MINIPORT_BLOCK)NdisConfigHandle->KeyQueryTable[3].QueryRoutine) != NULL)
|
|
{
|
|
//
|
|
// Adapters
|
|
//
|
|
PhysicalDeviceObject = Miniport->PhysicalDeviceObject;
|
|
|
|
#if NDIS_TEST_REG_FAILURE
|
|
RegistryStatus = STATUS_UNSUCCESSFUL;
|
|
RootHandle = NULL;
|
|
#else
|
|
RegistryStatus = IoOpenDeviceRegistryKey(PhysicalDeviceObject,
|
|
PLUGPLAY_REGKEY_DRIVER,
|
|
GENERIC_WRITE | MAXIMUM_ALLOWED,
|
|
&RootHandle);
|
|
|
|
#endif
|
|
if (!NT_SUCCESS(RegistryStatus))
|
|
{
|
|
*Status = NDIS_STATUS_FAILURE;
|
|
break;
|
|
}
|
|
|
|
RtlInitUnicodeString(&RelativePath, NdisConfigHandle->KeyQueryTable[3].Name);
|
|
|
|
InitializeObjectAttributes(&ObjAttr,
|
|
&RelativePath,
|
|
OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
|
|
RootHandle,
|
|
NULL);
|
|
|
|
RegistryStatus = ZwOpenKey(&Handle,
|
|
GENERIC_READ | MAXIMUM_ALLOWED,
|
|
&ObjAttr);
|
|
|
|
if (NT_SUCCESS(RegistryStatus))
|
|
{
|
|
RegistryStatus = RtlWriteRegistryValue(RTL_REGISTRY_HANDLE,
|
|
Handle,
|
|
KeywordBuffer,
|
|
ValueType,
|
|
ValueData,
|
|
ValueLength);
|
|
|
|
ZwClose (Handle);
|
|
}
|
|
|
|
ZwClose (RootHandle);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// protocols
|
|
//
|
|
RegistryStatus = RtlWriteRegistryValue(RTL_REGISTRY_SERVICES,
|
|
NdisConfigHandle->KeyQueryTable[3].Name,
|
|
KeywordBuffer,
|
|
ValueType,
|
|
ValueData,
|
|
ValueLength);
|
|
}
|
|
|
|
if (!NT_SUCCESS(RegistryStatus))
|
|
{
|
|
*Status = NDIS_STATUS_FAILURE;
|
|
}
|
|
|
|
} while (FALSE);
|
|
|
|
if (FreeKwBuf)
|
|
{
|
|
FREE_POOL(KeywordBuffer); // no longer needed
|
|
}
|
|
|
|
DBGPRINT_RAW(DBG_COMP_REG, DBG_LEVEL_INFO,
|
|
("<==NdisWriteConfiguration: ConfigurationHandle %p\n", ConfigurationHandle));
|
|
}
|
|
|
|
|
|
VOID
|
|
NdisCloseConfiguration(
|
|
IN NDIS_HANDLE ConfigurationHandle
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is used to close a configuration database opened by
|
|
NdisOpenConfiguration.
|
|
|
|
Arguments:
|
|
|
|
ConfigurationHandle - Handle returned by NdisOpenConfiguration.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
{
|
|
//
|
|
// Obtain the actual configuration handle structure
|
|
//
|
|
PNDIS_CONFIGURATION_HANDLE NdisConfigHandle = (PNDIS_CONFIGURATION_HANDLE)ConfigurationHandle;
|
|
PNDIS_CONFIGURATION_PARAMETER_QUEUE ParameterNode;
|
|
|
|
DBGPRINT_RAW(DBG_COMP_REG, DBG_LEVEL_INFO,
|
|
("==>NdisCloseConfiguration: ConfigurationHandle %p\n", ConfigurationHandle));
|
|
|
|
ASSERT (KeGetCurrentIrql() < DISPATCH_LEVEL);
|
|
|
|
//
|
|
// deallocate the parameter nodes
|
|
//
|
|
ParameterNode = NdisConfigHandle->ParameterList;
|
|
|
|
while (ParameterNode != NULL)
|
|
{
|
|
NdisConfigHandle->ParameterList = ParameterNode->Next;
|
|
|
|
FREE_POOL(ParameterNode);
|
|
|
|
ParameterNode = NdisConfigHandle->ParameterList;
|
|
}
|
|
|
|
FREE_POOL(ConfigurationHandle);
|
|
|
|
DBGPRINT_RAW(DBG_COMP_REG, DBG_LEVEL_INFO,
|
|
("<==NdisCloseConfiguration: ConfigurationHandle %p\n", ConfigurationHandle));
|
|
}
|
|
|
|
|
|
VOID
|
|
NdisReadNetworkAddress(
|
|
OUT PNDIS_STATUS Status,
|
|
OUT PVOID * NetworkAddress,
|
|
OUT PUINT NetworkAddressLength,
|
|
IN NDIS_HANDLE ConfigurationHandle
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is used to read the "NetworkAddress" parameter
|
|
from the configuration database. It reads the value as a
|
|
string separated by hyphens, then converts it to a binary
|
|
array and stores the result.
|
|
|
|
Arguments:
|
|
|
|
Status - Returns the status of the request.
|
|
|
|
NetworkAddress - Returns a pointer to the address.
|
|
|
|
NetworkAddressLength - Returns the length of the address.
|
|
|
|
ConfigurationHandle - Handle returned by NdisOpenConfiguration. Points
|
|
to the parameter subkey.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
{
|
|
NDIS_STRING NetAddrStr = NDIS_STRING_CONST("NetworkAddress");
|
|
PNDIS_CONFIGURATION_PARAMETER ParameterValue;
|
|
NTSTATUS NtStatus = STATUS_UNSUCCESSFUL;
|
|
UCHAR ConvertArray[3];
|
|
PWSTR CurrentReadLoc;
|
|
PWSTR AddressEnd;
|
|
PUCHAR CurrentWriteLoc;
|
|
UINT TotalBytesRead;
|
|
ULONG TempUlong;
|
|
ULONG AddressLength;
|
|
PNDIS_MINIPORT_BLOCK Miniport;
|
|
|
|
DBGPRINT_RAW(DBG_COMP_REG, DBG_LEVEL_INFO,
|
|
("==>NdisReadNetworkAddress: ConfigurationHandle %p\n", ConfigurationHandle));
|
|
|
|
ASSERT (KeGetCurrentIrql() < DISPATCH_LEVEL);
|
|
|
|
Miniport = (PNDIS_MINIPORT_BLOCK)((PNDIS_CONFIGURATION_HANDLE)ConfigurationHandle)->KeyQueryTable[3].QueryRoutine;
|
|
|
|
ASSERT(Miniport != NULL);
|
|
ASSERT(Miniport->Signature == (PVOID)MINIPORT_DEVICE_MAGIC_VALUE);
|
|
|
|
if (Miniport->Signature == (PVOID)MINIPORT_DEVICE_MAGIC_VALUE)
|
|
{
|
|
Miniport->MacOptions |= NDIS_MAC_OPTION_SUPPORTS_MAC_ADDRESS_OVERWRITE;
|
|
Miniport->InfoFlags |= NDIS_MINIPORT_SUPPORTS_MAC_ADDRESS_OVERWRITE;
|
|
}
|
|
|
|
do
|
|
{
|
|
//
|
|
// First read the "NetworkAddress" from the registry
|
|
//
|
|
NdisReadConfiguration(Status, &ParameterValue, ConfigurationHandle, &NetAddrStr, NdisParameterString);
|
|
|
|
if ((*Status != NDIS_STATUS_SUCCESS) ||
|
|
(ParameterValue->ParameterType != NdisParameterString))
|
|
{
|
|
*Status = NDIS_STATUS_FAILURE;
|
|
break;
|
|
}
|
|
|
|
//
|
|
// If there is not an address specified then exit now.
|
|
//
|
|
if (0 == ParameterValue->ParameterData.StringData.Length)
|
|
{
|
|
*Status = NDIS_STATUS_FAILURE;
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Now convert the address to binary (we do this
|
|
// in-place, since this allows us to use the memory
|
|
// already allocated which is automatically freed
|
|
// by NdisCloseConfiguration).
|
|
//
|
|
|
|
ConvertArray[2] = '\0';
|
|
CurrentReadLoc = (PWSTR)ParameterValue->ParameterData.StringData.Buffer;
|
|
CurrentWriteLoc = (PUCHAR)CurrentReadLoc;
|
|
TotalBytesRead = ParameterValue->ParameterData.StringData.Length;
|
|
AddressEnd = CurrentReadLoc + (TotalBytesRead / sizeof(WCHAR));
|
|
AddressLength = 0;
|
|
|
|
//1 is address string a multiple of 2 and if not, what are the implications?
|
|
while ((CurrentReadLoc+2) <= AddressEnd)
|
|
{
|
|
//
|
|
// Copy the current two-character value into ConvertArray
|
|
//
|
|
ConvertArray[0] = (UCHAR)(*(CurrentReadLoc++));
|
|
ConvertArray[1] = (UCHAR)(*(CurrentReadLoc++));
|
|
|
|
//
|
|
// Convert it to a Ulong and update
|
|
//
|
|
NtStatus = RtlCharToInteger((PCSZ)ConvertArray, 16, &TempUlong);
|
|
|
|
if (!NT_SUCCESS(NtStatus))
|
|
{
|
|
*Status = NDIS_STATUS_FAILURE;
|
|
break;
|
|
}
|
|
|
|
*(CurrentWriteLoc++) = (UCHAR)TempUlong;
|
|
++AddressLength;
|
|
|
|
//
|
|
// If the next character is a hyphen, skip it.
|
|
//
|
|
if (CurrentReadLoc < AddressEnd)
|
|
{
|
|
if (*CurrentReadLoc == (WCHAR)L'-')
|
|
{
|
|
++CurrentReadLoc;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!NT_SUCCESS(NtStatus))
|
|
break;
|
|
|
|
*Status = NDIS_STATUS_SUCCESS;
|
|
*NetworkAddress = ParameterValue->ParameterData.StringData.Buffer;
|
|
*NetworkAddressLength = AddressLength;
|
|
if (AddressLength == 0)
|
|
{
|
|
*Status = NDIS_STATUS_FAILURE;
|
|
}
|
|
} while (FALSE);
|
|
|
|
DBGPRINT_RAW(DBG_COMP_REG, DBG_LEVEL_INFO,
|
|
("<==NdisReadNetworkAddress: ConfigurationHandle %p\n", ConfigurationHandle));
|
|
}
|
|
|
|
|
|
VOID
|
|
NdisConvertStringToAtmAddress(
|
|
OUT PNDIS_STATUS Status,
|
|
IN PNDIS_STRING String,
|
|
OUT PATM_ADDRESS AtmAddress
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
|
|
Arguments:
|
|
|
|
Status - Returns the status of the request.
|
|
|
|
String - String representation of the atm address.
|
|
|
|
* Format defined in Section 5.4,
|
|
* "Example Master File Format" in ATM95-1532R4 ATM Name System:
|
|
*
|
|
* AESA format: a string of hexadecimal digits, with '.' characters for punctuation, e.g.
|
|
*
|
|
* 39.246f.00.0e7c9c.0312.0001.0001.000012345678.00
|
|
*
|
|
* E164 format: A '+' character followed by a string of
|
|
* decimal digits, with '.' chars for punctuation, e.g.:
|
|
*
|
|
* +358.400.1234567
|
|
|
|
AtmAddress - The converted Atm address is returned here.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
{
|
|
USHORT i, j, NumDigits;
|
|
PWSTR p, q;
|
|
UNICODE_STRING Us;
|
|
ANSI_STRING As;
|
|
|
|
DBGPRINT_RAW(DBG_COMP_REG, DBG_LEVEL_INFO,
|
|
("==>NdisConvertStringToAtmAddress\n"));
|
|
|
|
//
|
|
// Start off by stripping the punctuation characters from the string. We do this in place.
|
|
//
|
|
for (i = NumDigits = 0, j = String->Length/sizeof(WCHAR), p = q = String->Buffer;
|
|
(i < j) && (*p != 0);
|
|
i++, p++)
|
|
{
|
|
if ((*p == ATM_ADDR_BLANK_CHAR) ||
|
|
(*p == ATM_ADDR_PUNCTUATION_CHAR))
|
|
{
|
|
continue;
|
|
}
|
|
*q++ = *p;
|
|
NumDigits ++;
|
|
}
|
|
|
|
//
|
|
// Look at the first character to determine if the address is E.164 or NSAP.
|
|
// If the address isn't long enough, we assume that it is native E.164.
|
|
//
|
|
p = String->Buffer;
|
|
if ((*p == ATM_ADDR_E164_START_CHAR) || (NumDigits <= 15))
|
|
{
|
|
if (*p == ATM_ADDR_E164_START_CHAR)
|
|
{
|
|
p ++;
|
|
NumDigits --;
|
|
}
|
|
if ((NumDigits == 0) || (NumDigits > ATM_ADDRESS_LENGTH))
|
|
{
|
|
*Status = NDIS_STATUS_INVALID_LENGTH;
|
|
return;
|
|
}
|
|
AtmAddress->AddressType = ATM_E164;
|
|
AtmAddress->NumberOfDigits = NumDigits;
|
|
}
|
|
else
|
|
{
|
|
if (NumDigits != 2*ATM_ADDRESS_LENGTH)
|
|
{
|
|
*Status = NDIS_STATUS_INVALID_LENGTH;
|
|
return;
|
|
}
|
|
AtmAddress->AddressType = ATM_NSAP;
|
|
AtmAddress->NumberOfDigits = NumDigits/sizeof(WCHAR);
|
|
}
|
|
|
|
//
|
|
// Convert the address to Ansi now
|
|
//
|
|
Us.Buffer = p;
|
|
Us.Length = Us.MaximumLength = NumDigits*sizeof(WCHAR);
|
|
As.Buffer = ALLOC_FROM_POOL(NumDigits + 1, NDIS_TAG_CO);
|
|
As.Length = 0;
|
|
As.MaximumLength = NumDigits + 1;
|
|
if (As.Buffer == NULL)
|
|
{
|
|
*Status = NDIS_STATUS_RESOURCES;
|
|
return;
|
|
}
|
|
|
|
*Status = NdisUnicodeStringToAnsiString(&As, &Us);
|
|
if (!NT_SUCCESS(*Status))
|
|
{
|
|
FREE_POOL(As.Buffer);
|
|
*Status = NDIS_STATUS_FAILURE;
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Now get the bytes into the destination ATM Address structure.
|
|
//
|
|
if (AtmAddress->AddressType == ATM_E164)
|
|
{
|
|
//
|
|
// We just need to copy in the digits in ANSI form.
|
|
//
|
|
NdisMoveMemory(AtmAddress->Address, As.Buffer, NumDigits);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// This is in NSAP form. We need to pack the hex digits.
|
|
//
|
|
UCHAR xxString[3];
|
|
ULONG val;
|
|
|
|
xxString[2] = 0;
|
|
for (i = 0; i < ATM_ADDRESS_LENGTH; i++)
|
|
{
|
|
xxString[0] = As.Buffer[i*2];
|
|
xxString[1] = As.Buffer[i*2+1];
|
|
*Status = CHAR_TO_INT((PCSZ)xxString, 16, &val);
|
|
if (!NT_SUCCESS(*Status))
|
|
{
|
|
FREE_POOL(As.Buffer);
|
|
*Status = NDIS_STATUS_FAILURE;
|
|
return;
|
|
}
|
|
AtmAddress->Address[i] = (UCHAR)val;
|
|
}
|
|
}
|
|
|
|
FREE_POOL(As.Buffer);
|
|
|
|
DBGPRINT_RAW(DBG_COMP_REG, DBG_LEVEL_INFO,
|
|
("<==NdisConvertStringToAtmAddress\n"));
|
|
|
|
*Status = NDIS_STATUS_SUCCESS;
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
ndisSaveParameters(
|
|
IN PWSTR ValueName,
|
|
IN ULONG ValueType,
|
|
IN PVOID ValueData,
|
|
IN ULONG ValueLength,
|
|
IN PVOID Context,
|
|
IN PVOID EntryContext
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is a callback routine for RtlQueryRegistryValues
|
|
It is called with the value for a specified parameter. It allocates
|
|
memory to hold the data and copies it over.
|
|
|
|
Arguments:
|
|
|
|
ValueName - The name of the value (ignored).
|
|
|
|
ValueType - The type of the value.
|
|
|
|
ValueData - The null-terminated data for the value.
|
|
|
|
ValueLength - The length of ValueData.
|
|
|
|
Context - Points to the head of the parameter chain.
|
|
|
|
EntryContext - A pointer to
|
|
|
|
Return Value:
|
|
|
|
STATUS_SUCCESS
|
|
|
|
--*/
|
|
{
|
|
NDIS_STATUS Status;
|
|
|
|
//
|
|
// Obtain the actual configuration handle structure
|
|
//
|
|
PNDIS_CONFIGURATION_HANDLE NdisConfigHandle = (PNDIS_CONFIGURATION_HANDLE)Context;
|
|
|
|
//
|
|
// Where the user wants a pointer returned to the data.
|
|
//
|
|
PNDIS_CONFIGURATION_PARAMETER *ParameterValue = (PNDIS_CONFIGURATION_PARAMETER *)EntryContext;
|
|
|
|
//
|
|
// Use this to link parameters allocated to this open
|
|
//
|
|
PNDIS_CONFIGURATION_PARAMETER_QUEUE ParameterNode;
|
|
|
|
//
|
|
// Size of memory to allocate for parameter node
|
|
//
|
|
UINT Size;
|
|
|
|
UNREFERENCED_PARAMETER(ValueName);
|
|
|
|
//
|
|
// Allocate our parameter node
|
|
//
|
|
Size = sizeof(NDIS_CONFIGURATION_PARAMETER_QUEUE);
|
|
if ((ValueType == REG_SZ) || (ValueType == REG_MULTI_SZ) || (ValueType == REG_BINARY))
|
|
{
|
|
Size += ValueLength;
|
|
}
|
|
|
|
ParameterNode = ALLOC_FROM_POOL(Size, NDIS_TAG_PARAMETER_NODE);
|
|
|
|
Status = (ParameterNode != NULL) ? NDIS_STATUS_SUCCESS : STATUS_INSUFFICIENT_RESOURCES;
|
|
|
|
if (Status != NDIS_STATUS_SUCCESS)
|
|
{
|
|
return (NTSTATUS)Status;
|
|
}
|
|
|
|
*ParameterValue = &ParameterNode->Parameter;
|
|
|
|
//
|
|
// Map registry datatypes to ndis data types
|
|
//
|
|
if (ValueType == REG_DWORD)
|
|
{
|
|
//
|
|
// The registry says that the data is in a dword boundary.
|
|
//
|
|
(*ParameterValue)->ParameterType = NdisParameterInteger;
|
|
(*ParameterValue)->ParameterData.IntegerData = *((PULONG) ValueData);
|
|
}
|
|
else if ((ValueType == REG_SZ) || (ValueType == REG_MULTI_SZ))
|
|
{
|
|
(*ParameterValue)->ParameterType =
|
|
(ValueType == REG_SZ) ? NdisParameterString : NdisParameterMultiString;
|
|
|
|
(*ParameterValue)->ParameterData.StringData.Buffer = (PWSTR)((PUCHAR)ParameterNode + sizeof(NDIS_CONFIGURATION_PARAMETER_QUEUE));
|
|
|
|
CopyMemory((*ParameterValue)->ParameterData.StringData.Buffer,
|
|
ValueData,
|
|
ValueLength);
|
|
(*ParameterValue)->ParameterData.StringData.Length = (USHORT)ValueLength;
|
|
(*ParameterValue)->ParameterData.StringData.MaximumLength = (USHORT)ValueLength;
|
|
|
|
//
|
|
// Special fix; if a string ends in a NULL and that is included
|
|
// in the length, remove it.
|
|
//
|
|
if (ValueType == REG_SZ)
|
|
{
|
|
if ((((PUCHAR)ValueData)[ValueLength-1] == 0) &&
|
|
(((PUCHAR)ValueData)[ValueLength-2] == 0))
|
|
{
|
|
(*ParameterValue)->ParameterData.StringData.Length -= 2;
|
|
}
|
|
}
|
|
}
|
|
else if (ValueType == REG_BINARY)
|
|
{
|
|
(*ParameterValue)->ParameterType = NdisParameterBinary;
|
|
(*ParameterValue)->ParameterData.BinaryData.Buffer = ValueData;
|
|
(*ParameterValue)->ParameterData.BinaryData.Length = (USHORT)ValueLength;
|
|
(*ParameterValue)->ParameterData.BinaryData.Buffer = (PWSTR)((PUCHAR)ParameterNode + sizeof(NDIS_CONFIGURATION_PARAMETER_QUEUE));
|
|
CopyMemory((*ParameterValue)->ParameterData.BinaryData.Buffer,
|
|
ValueData,
|
|
ValueLength);
|
|
}
|
|
else
|
|
{
|
|
FREE_POOL(ParameterNode);
|
|
return STATUS_OBJECT_NAME_NOT_FOUND;
|
|
}
|
|
|
|
//
|
|
// Queue this parameter node
|
|
//
|
|
ParameterNode->Next = NdisConfigHandle->ParameterList;
|
|
NdisConfigHandle->ParameterList = ParameterNode;
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
ndisReadParameter(
|
|
IN PWSTR ValueName,
|
|
IN ULONG ValueType,
|
|
IN PVOID ValueData,
|
|
IN ULONG ValueLength,
|
|
IN PVOID Context,
|
|
IN PVOID EntryContext
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is a callback routine for RtlQueryRegistryValues
|
|
It is called with the values for the "Bind" and "Export" multi-strings
|
|
for a given driver. It allocates memory to hold the data and copies
|
|
it over.
|
|
|
|
Arguments:
|
|
|
|
ValueName - The name of the value ("Bind" or "Export" -- ignored).
|
|
|
|
ValueType - The type of the value (REG_MULTI_SZ -- ignored).
|
|
|
|
ValueData - The null-terminated data for the value.
|
|
|
|
ValueLength - The length of ValueData.
|
|
|
|
Context - Unused.
|
|
|
|
EntryContext - A pointer to the pointer that holds the copied data.
|
|
|
|
Return Value:
|
|
|
|
STATUS_SUCCESS
|
|
|
|
--*/
|
|
{
|
|
//1 everwhere this function is called, check for the type and if applicable the range
|
|
//1 make sure anybody using this API, frees the allocated memory,
|
|
PUCHAR * Data = ((PUCHAR *)EntryContext);
|
|
|
|
UNREFERENCED_PARAMETER(ValueName);
|
|
|
|
//
|
|
// Allocate one DWORD more and zero is out
|
|
//
|
|
*Data = ALLOC_FROM_POOL(ValueLength + sizeof(ULONG), NDIS_TAG_REG_READ_DATA_BUFFER);
|
|
|
|
if (*Data == NULL)
|
|
{
|
|
return STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
|
|
ZeroMemory(*Data, ValueLength + sizeof(ULONG));
|
|
CopyMemory(*Data, ValueData, ValueLength);
|
|
|
|
if (Context)
|
|
{
|
|
*((PULONG)Context) = ValueType;
|
|
}
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|