static
VOID
GetDriverName(
PDISKENTRY DiskEntry)
{
RTL_QUERY_REGISTRY_TABLE QueryTable[2];
WCHAR KeyName[32];
NTSTATUS Status;
RtlInitUnicodeString(&DiskEntry->DriverName,
NULL);
swprintf(KeyName,
L"\\Scsi\\Scsi Port %lu",
DiskEntry->Port);
RtlZeroMemory(&QueryTable,
sizeof(QueryTable));
QueryTable[0].Name = L"Driver";
QueryTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT;
QueryTable[0].EntryContext = &DiskEntry->DriverName;
Status = RtlQueryRegistryValues(RTL_REGISTRY_DEVICEMAP,
KeyName,
QueryTable,
NULL,
NULL);
if (!NT_SUCCESS(Status))
{
DPRINT1("RtlQueryRegistryValues() failed (Status %lx)\n", Status);
}
}
ULONG TgaTestEv4 (PULONG Result)
{
RTL_QUERY_REGISTRY_TABLE query[2];
ULONG status;
// Initialize the query table to fetch the registry entry for the CPU
// identifier
RtlZeroMemory (query, sizeof(query));
query[0].QueryRoutine = TgaTestEv4Callback;
query[0].Flags = RTL_QUERY_REGISTRY_REQUIRED;
query[0].Name = L"Identifier";
query[0].EntryContext = Result;
query[0].DefaultType = 0;
query[0].DefaultData = NULL;
query[0].DefaultLength = 0;
// Fetch the registry entry. NT will call TgaTestEv4Callback when it
// finds the entry
status = RtlQueryRegistryValues (RTL_REGISTRY_ABSOLUTE,
L"\\Registry\\Machine\\HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0",
query,
Result,
NULL);
return status;
}
/*++
* @name SmProcessFileRenameList
* @implemented
*
* The SmProcessFileRenameList function moves or deletes files thats have been added to the specify registry key for delayed moving.
*
* @param VOID
*
* @return STATUS_SUCCESS in case of success, STATUS_UNSUCCESSFUL
* othwerwise.
*
* @remarks
* This function reads the following registry value:
* HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\PendingFileRenameOperations
* This registry value is of type REG_MULTI_SZ. The each operation is specifed as two file names.
* A first name is a source file, a second name is a destination file.
* In the case of deleting operation a second file name must be the empty string.
* For exapmle:
* szxSrcFile\0szxDestFile\0\0 <-- the szxSrcFile file will be renamed to the szxDestFile file
* szxSomeFile\0\0\0 <-- the szxSomeFile file will be removed
* After it will be done, the registry value will be deleted.
*
*
*--*/
NTSTATUS
SmProcessFileRenameList( VOID )
{
RTL_QUERY_REGISTRY_TABLE QueryTable[2];
NTSTATUS Status;
DPRINT("SmProcessFileRenameList() called\n");
RtlZeroMemory( &QueryTable, sizeof(QueryTable) );
QueryTable[0].Name = L"PendingFileRenameOperations";
QueryTable[0].Flags = RTL_QUERY_REGISTRY_DELETE;
QueryTable[0].DefaultType = REG_NONE;
QueryTable[0].QueryRoutine = SmpMoveFilesQueryRoutine;
Status = RtlQueryRegistryValues(
RTL_REGISTRY_CONTROL,
L"\\Session Manager",
QueryTable,
NULL,
NULL);
if( !NT_SUCCESS(Status) ) {
DPRINT("RtlQueryRegistryValues() failed (Status %lx)\n", Status);
}
/* FIXME: RtlQueryRegistryValues can return an error status if the PendingFileRenameOperations value
does not exist, in this case smss hungs, therefore we always return STATUS_SUCCESS */
return (STATUS_SUCCESS);
}
int regReadString(PWCHAR key, PWCHAR val, PUNICODE_STRING result) {
WCHAR path[1024];
RTL_QUERY_REGISTRY_TABLE qtbl[2];
NTSTATUS status;
result->Buffer[0] = L'\0';
wcscpy(path, L"\\Registry\\Machine\\");
wcscat(path, key);
qtbl[0].QueryRoutine = regReadStringCB;
qtbl[0].Flags = RTL_QUERY_REGISTRY_NOEXPAND;
qtbl[0].Name = val;
qtbl[0].EntryContext = NULL;
qtbl[0].DefaultType = REG_NONE;
qtbl[0].DefaultData = NULL;
qtbl[0].DefaultLength = 0;
memset(&(qtbl[1]), 0, sizeof(qtbl[1]));
status =
RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE,
path,
qtbl,
result,
NULL);
if (status == STATUS_SUCCESS) return 0;
return -1;
}
static
void
_getRegDWord
(
PWSTR key_name,
PWSTR val_name,
ULONG* pvalue
)
{
ULONG temp = 0;
RTL_QUERY_REGISTRY_TABLE queryTable[2];
RtlZeroMemory(&queryTable, sizeof(queryTable));
queryTable[0].QueryRoutine = NULL;
queryTable[0].Name = val_name;
queryTable[0].EntryContext = pvalue;
queryTable[0].DefaultType = REG_DWORD;
queryTable[0].DefaultData = &temp;
queryTable[0].DefaultLength = sizeof(temp);
queryTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT;
//end the table entries
queryTable[1].QueryRoutine = NULL;
queryTable[1].Name = NULL;
//ignore the return value for now..
(void)RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE, key_name, &(queryTable[0]), NULL, NULL);
}
NTSTATUS
PptRegGetDword(
IN ULONG RelativeTo,
IN __nullterminated PWSTR Path,
IN __nullterminated PWSTR ParameterName,
IN OUT PULONG ParameterValue
)
{
NTSTATUS status;
RTL_QUERY_REGISTRY_TABLE paramTable[2];
ULONG defaultValue;
PVOID context = NULL;
if( ( NULL == Path ) || ( NULL == ParameterName ) || ( NULL == ParameterValue ) ) {
return STATUS_INVALID_PARAMETER;
}
//DbgPrint("PptRegGetDword - RelativeTo= %x, Path=<%S>, ParameterName=<%S>\n", RelativeTo, Path, ParameterName);
//
// set up table entries for call to RtlQueryRegistryValues
//
// leave paramTable[1] as all zeros to terminate the table
//
// use original value as default value
//
// use RtlQueryRegistryValues to do the grunge work
//
RtlZeroMemory( paramTable, sizeof(paramTable) );
defaultValue = *ParameterValue;
paramTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT;
paramTable[0].Name = ParameterName;
paramTable[0].EntryContext = ParameterValue;
paramTable[0].DefaultType = REG_DWORD;
paramTable[0].DefaultData = &defaultValue;
paramTable[0].DefaultLength = sizeof(ULONG);
status = RtlQueryRegistryValues( RelativeTo | RTL_REGISTRY_OPTIONAL,
Path,
¶mTable[0],
&context,
NULL);
if( status != STATUS_SUCCESS ) {
DbgPrint("PptRegGetDword - RtlQueryRegistryValues FAILED w/status=%x\n",status);
}
//DbgPrint("PptRegGetDword - post-query <%S> *ParameterValue = %x\n", ParameterName, *ParameterValue);
return status;
}
/**
* @internal
* @brief Retrieves the list of
* registered boot execute programs.
* @return Zero for success,
* negative value otherwise.
*/
static int get_boot_exec_list(struct cmd **list)
{
NTSTATUS status;
RTL_QUERY_REGISTRY_TABLE qt[] = {
{query_routine, 0, L"BootExecute", NULL, REG_SZ, L"", 0},
{NULL, 0, NULL, NULL, 0, NULL, 0}
};
status = RtlQueryRegistryValues(RTL_REGISTRY_CONTROL,
L"Session Manager",qt,(PVOID)list,NULL);
if(!NT_SUCCESS(status)){
strace(status,"cannot get list of boot execute commands");
return (-1);
}
return 0;
}
static NTSTATUS WINAPI
CreateGroupListRoutine(PWSTR ValueName,
ULONG ValueType,
PVOID ValueData,
ULONG ValueLength,
PVOID Context,
PVOID EntryContext)
{
PSERVICE_GROUP Group;
RTL_QUERY_REGISTRY_TABLE QueryTable[2];
NTSTATUS Status;
if (ValueType == REG_SZ)
{
DPRINT("Data: '%S'\n", (PWCHAR)ValueData);
Group = (PSERVICE_GROUP)HeapAlloc(GetProcessHeap(),
HEAP_ZERO_MEMORY,
sizeof(SERVICE_GROUP) + ((wcslen((const wchar_t*) ValueData) + 1) * sizeof(WCHAR)));
if (Group == NULL)
{
return STATUS_INSUFFICIENT_RESOURCES;
}
wcscpy(Group->szGroupName, (const wchar_t*) ValueData);
Group->lpGroupName = Group->szGroupName;
Group->dwRefCount = (DWORD)-1;
RtlZeroMemory(&QueryTable, sizeof(QueryTable));
QueryTable[0].Name = (PWSTR)ValueData;
QueryTable[0].QueryRoutine = CreateGroupOrderListRoutine;
Status = RtlQueryRegistryValues(RTL_REGISTRY_CONTROL,
L"GroupOrderList",
QueryTable,
(PVOID)Group,
NULL);
DPRINT("%x %lu %S\n", Status, Group->TagCount, (PWSTR)ValueData);
InsertTailList(&GroupListHead,
&Group->GroupListEntry);
}
return STATUS_SUCCESS;
}
/*
* @implemented
*/
BOOLEAN
HasNoDriveLetterEntry(IN PMOUNTDEV_UNIQUE_ID UniqueId)
{
BOOLEAN EntryPresent = FALSE;
RTL_QUERY_REGISTRY_TABLE QueryTable[2];
RtlZeroMemory(QueryTable, sizeof(QueryTable));
QueryTable[0].QueryRoutine = CheckForNoDriveLetterEntry;
QueryTable[0].EntryContext = &EntryPresent;
RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE,
DatabasePath,
QueryTable,
UniqueId,
NULL);
return EntryPresent;
}
NTSTATUS
NTAPI
DriverEntry(PDRIVER_OBJECT DriverObject,
PUNICODE_STRING RegistryPath)
{
RTL_QUERY_REGISTRY_TABLE QueryTable[2];
NTSTATUS Status;
UNREFERENCED_PARAMETER(RegistryPath);
DPRINT1("PCMCIA: DriverEntry\n");
DriverObject->MajorFunction[IRP_MJ_CREATE] = PcmciaCreateClose;
DriverObject->MajorFunction[IRP_MJ_CLOSE] = PcmciaCreateClose;
DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = PcmciaDeviceControl;
DriverObject->MajorFunction[IRP_MJ_PNP] = PcmciaPlugPlay;
DriverObject->MajorFunction[IRP_MJ_POWER] = PcmciaPower;
DriverObject->DriverExtension->AddDevice = PcmciaAddDevice;
DriverObject->DriverUnload = PcmciaUnload;
RtlZeroMemory(QueryTable, sizeof(RTL_QUERY_REGISTRY_TABLE) * 2);
QueryTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT | RTL_QUERY_REGISTRY_REQUIRED;
QueryTable[0].Name = L"IoctlInterface";
QueryTable[0].EntryContext = &IoctlEnabled;
Status = RtlQueryRegistryValues(RTL_REGISTRY_SERVICES,
L"Pcmcia\\Parameters",
QueryTable,
NULL,
NULL);
if (!NT_SUCCESS(Status))
{
/* Key not present so assume disabled */
IoctlEnabled = FALSE;
}
DPRINT("PCMCIA: Ioctl interface %s\n",
(IoctlEnabled ? "enabled" : "disabled"));
return STATUS_SUCCESS;
}
NTSTATUS
MrQueryRegistry(IN PUNICODE_STRING RegistryPath)
{
RTL_QUERY_REGISTRY_TABLE QueryTable[2];
int i = 0;
NTSTATUS status;
RtlZeroMemory(&QueryTable[0], sizeof(QueryTable));
/*
* 1 Device List (to be swapped)
*/
QueryTable[i].Flags = RTL_QUERY_REGISTRY_NOEXPAND;
QueryTable[i].Name = MOURE_DEVLIST;
QueryTable[i].DefaultType = REG_MULTI_SZ;
QueryTable[i].DefaultLength = 0;
QueryTable[i].DefaultData = NULL;
QueryTable[i].EntryContext = NULL;
QueryTable[i].QueryRoutine = MrQueryCallback;
i++;
status = RtlQueryRegistryValues(
RTL_REGISTRY_ABSOLUTE,
RegistryPath->Buffer,
&QueryTable[0],
NULL,
NULL
);
/* failed to query registry settings */
if (!NT_SUCCESS(status)) {
if (!g_core.mc_dev_list) {
g_core.mc_dev_bytes = 1024;
g_core.mc_dev_list = MrAlloc(1024);
}
if (!g_core.mc_dev_list)
g_core.mc_dev_bytes = 0;
}
return STATUS_SUCCESS;
}
VOID PPJoyBus_CreateFromRegistry (IN PDEVICE_OBJECT DeviceObject)
{
NTSTATUS ntStatus;
RTL_QUERY_REGISTRY_TABLE QueryTable[2];
PAGED_CODE ();
PPJOY_DBGPRINT (FILE_PPJOYBUS|PPJOY_FENTRY, ("PPJoyBus_CreateFromRegistry(DeviceObject=0x%p)",DeviceObject) );
/* Create table to query registry. 2nd entry is NULL to teminate the list */
RtlZeroMemory (QueryTable,sizeof(QueryTable));
QueryTable->Flags= RTL_QUERY_REGISTRY_REQUIRED;
QueryTable->QueryRoutine= PPJoyBus_RegQueryFunc;
/* Then execute query. Callback function does all the work. */
ntStatus= RtlQueryRegistryValues (RTL_REGISTRY_ABSOLUTE,Globals.ParamRegistryPath.Buffer,QueryTable,(PVOID)DeviceObject,NULL);
PPJOY_EXITPROC (FILE_PPJOYBUS|PPJOY_FEXIT_STATUSOK, "PPJoyBus_CreateFromRegistry:",ntStatus );
return;
}
VOID PPJoyBus_ReadOptionsFromReg (IN PDEVICE_OBJECT DeviceObject)
{
NTSTATUS ntStatus;
RTL_QUERY_REGISTRY_TABLE QueryTable[3];
ULONG DefaultOptionValue= 0;
PAGED_CODE ();
PPJOY_DBGPRINT (FILE_PPJOYBUS|PPJOY_FENTRY, ("PPJoyBus_ReadOptionsFromReg(DeviceObject=0x%p)",DeviceObject) );
/* Create table to query registry. 3rd entry is NULL to teminate the list */
RtlZeroMemory (QueryTable,sizeof(QueryTable));
QueryTable[0].QueryRoutine= NULL;
QueryTable[0].Flags= RTL_QUERY_REGISTRY_DIRECT;
QueryTable[0].Name= PPJOY_OPTNAME_RUNTIMEDEBUG;
QueryTable[0].EntryContext= &PPJoy_Opt_RuntimeDebug;
QueryTable[0].DefaultType= REG_DWORD;
QueryTable[0].DefaultData= &DefaultOptionValue;
QueryTable[0].DefaultLength= sizeof (DefaultOptionValue);
QueryTable[1].QueryRoutine= NULL;
QueryTable[1].Flags= RTL_QUERY_REGISTRY_DIRECT;
QueryTable[1].Name= PPJOY_OPTNAME_PORTFLAGS;
QueryTable[1].EntryContext= &PPJoy_Opt_PortFlags;
QueryTable[1].DefaultType= REG_DWORD;
QueryTable[1].DefaultData= &DefaultOptionValue;
QueryTable[1].DefaultLength= sizeof (DefaultOptionValue);
/* Then execute query. Callback function does all the work. */
ntStatus= RtlQueryRegistryValues (RTL_REGISTRY_ABSOLUTE,Globals.ParamRegistryPath.Buffer,QueryTable,(PVOID)DeviceObject,NULL);
if (PPJoyOptionCallback)
{
PPJoyOptionCallback (PPJOY_OPTION_RUNTIMEDEBUG,PPJoy_Opt_RuntimeDebug);
PPJoyOptionCallback (PPJOY_OPTION_PORTFLAGS,PPJoy_Opt_PortFlags);
}
PPJOY_EXITPROC (FILE_PPJOYBUS|PPJOY_FEXIT_STATUSOK, "PPJoyBus_ReadOptionsFromReg:",ntStatus );
return;
}
//read EnableReplace key from reg to check if replace the key with our define key
void ReadRegistery(IN PUNICODE_STRING RegistryPath)
{
UNICODE_STRING parameter_path;
RTL_QUERY_REGISTRY_TABLE query_table[2];
NTSTATUS status;
parameter_path.Length = 0;
parameter_path.MaximumLength = RegistryPath->Length + sizeof(PARAMETER_KEY);
parameter_path.Buffer = (PWSTR) ExAllocatePool(PagedPool, parameter_path.MaximumLength);
if (parameter_path.Buffer == NULL)
{
return;
}
RtlZeroMemory(parameter_path.Buffer,parameter_path.MaximumLength);
RtlCopyUnicodeString(¶meter_path, RegistryPath);
RtlAppendUnicodeToString(¶meter_path, PARAMETER_KEY);
RtlZeroMemory(&query_table[0], sizeof(query_table));
query_table[0].Flags = RTL_QUERY_REGISTRY_DIRECT | RTL_QUERY_REGISTRY_REQUIRED;
query_table[0].Name = ENABLEWRITEPORT_VALUE;
query_table[0].EntryContext = &bEnableReplace;
status = RtlQueryRegistryValues(
RTL_REGISTRY_ABSOLUTE,
parameter_path.Buffer,
&query_table[0],
NULL,
NULL
);
ExFreePool(parameter_path.Buffer);
if (!NT_SUCCESS(status))
{
KdPrint(("Kb_sniff_Mp: Query registry failed.\n"));
}
}
/*++
*******************************************************************
R e a d I p x D e v i c e N a m e
Routine Description:
Allocates buffer and reads device name exported by the IPX stack
into it
Arguments:
FileName - pointer to buffer to hold the name
Return Value:
STATUS_SUCCESS - tables were created ok
STATUS_INSUFFICIENT_RESOURCES - resource allocation failed
STATUS_OBJECT_NAME_NOT_FOUND - if name value is not found
*******************************************************************
--*/
NTSTATUS
ReadIpxDeviceName (
PWSTR *FileName
) {
NTSTATUS Status;
RTL_QUERY_REGISTRY_TABLE QueryTable[2];
PWSTR Export = L"Export";
PWSTR IpxRegistryPath = L"NwLnkIpx\\Linkage";
//
// Set up QueryTable to do the following:
//
//
// 1) Call SetIpxDeviceName for the string in "Export"
//
QueryTable[0].QueryRoutine = SetIpxDeviceName;
QueryTable[0].Flags = RTL_QUERY_REGISTRY_REQUIRED;
QueryTable[0].Name = Export;
QueryTable[0].EntryContext = FileName;
QueryTable[0].DefaultType = 0;
//
// 2) Stop
//
QueryTable[1].QueryRoutine = NULL;
QueryTable[1].Flags = 0;
QueryTable[1].Name = NULL;
Status = RtlQueryRegistryValues(
RTL_REGISTRY_SERVICES,
IpxRegistryPath,
QueryTable,
NULL,
NULL);
return Status;
}
int regReadString(PWCHAR key, PWCHAR val, PUNICODE_STRING result) {
WCHAR *path;
RTL_QUERY_REGISTRY_TABLE qtbl[2];
NTSTATUS status;
path =
ExAllocatePoolWithTag ( PagedPool, (wcslen(key)+20)*sizeof(WCHAR),
CRASH_TAG);
if (!path) return -1;
result->Buffer[0] = L'\0';
result->Length = 0;
wcscpy(path, L"\\Registry\\Machine\\");
if (wcsncmp(key, path, wcslen(path))==0)
wcscpy(path, key);
else
wcscat(path, key);
qtbl[0].QueryRoutine = regReadStringCB;
qtbl[0].Flags = RTL_QUERY_REGISTRY_NOEXPAND;
qtbl[0].Name = val;
qtbl[0].EntryContext = NULL;
qtbl[0].DefaultType = REG_NONE;
qtbl[0].DefaultData = NULL;
qtbl[0].DefaultLength = 0;
memset(&(qtbl[1]), 0, sizeof(qtbl[1]));
status =
RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE,
path,
qtbl,
result,
NULL);
ExFreePool(path);
if (status == STATUS_SUCCESS) return 0;
return -1;
}
DWORD
ScmCreateGroupList(VOID)
{
RTL_QUERY_REGISTRY_TABLE QueryTable[2];
NTSTATUS Status;
InitializeListHead(&GroupListHead);
InitializeListHead(&UnknownGroupListHead);
/* Build group order list */
RtlZeroMemory(&QueryTable,
sizeof(QueryTable));
QueryTable[0].Name = L"List";
QueryTable[0].QueryRoutine = CreateGroupListRoutine;
Status = RtlQueryRegistryValues(RTL_REGISTRY_CONTROL,
L"ServiceGroupOrder",
QueryTable,
NULL,
NULL);
return RtlNtStatusToDosError(Status);
}
/**
* Queries (gets) a DWORD value from the registry.
*
* @return NTSTATUS
* @param ulRoot Relative path root. See RTL_REGISTRY_SERVICES or RTL_REGISTRY_ABSOLUTE.
* @param pwszPath Path inside path root.
* @param pwszName Actual value name to look up.
* @param puValue On input this can specify the default value (if RTL_REGISTRY_OPTIONAL is
* not specified in ulRoot), on output this will retrieve the looked up
* registry value if found.
*/
NTSTATUS vboxguestwinRegistryReadDWORD(ULONG ulRoot, PCWSTR pwszPath, PWSTR pwszName,
PULONG puValue)
{
if (!pwszPath || !pwszName || !puValue)
return STATUS_INVALID_PARAMETER;
ULONG ulDefault = *puValue;
RTL_QUERY_REGISTRY_TABLE tblQuery[2];
RtlZeroMemory(tblQuery, sizeof(tblQuery));
/** @todo Add RTL_QUERY_REGISTRY_TYPECHECK! */
tblQuery[0].Flags = RTL_QUERY_REGISTRY_DIRECT;
tblQuery[0].Name = pwszName;
tblQuery[0].EntryContext = puValue;
tblQuery[0].DefaultType = REG_DWORD;
tblQuery[0].DefaultData = &ulDefault;
tblQuery[0].DefaultLength = sizeof(ULONG);
return RtlQueryRegistryValues(ulRoot,
pwszPath,
&tblQuery[0],
NULL /* Context */,
NULL /* Environment */);
}
NTSTATUS
ReadRegistryEntries(
IN PUNICODE_STRING RegistryPath,
OUT PI8042_SETTINGS Settings)
{
RTL_QUERY_REGISTRY_TABLE Parameters[17];
NTSTATUS Status;
ULONG DefaultKeyboardDataQueueSize = 0x64;
PCWSTR DefaultKeyboardDeviceBaseName = L"KeyboardPort";
ULONG DefaultMouseDataQueueSize = 0x64;
ULONG DefaultMouseResolution = 3;
ULONG DefaultMouseSynchIn100ns = 20000000;
ULONG DefaultNumberOfButtons = 2;
PCWSTR DefaultPointerDeviceBaseName = L"PointerPort";
ULONG DefaultPollStatusIterations = 1;
ULONG DefaultOverrideKeyboardType = 4;
ULONG DefaultOverrideKeyboardSubtype = 0;
ULONG DefaultPollingIterations = 12000;
ULONG DefaultPollingIterationsMaximum = 12000;
ULONG DefaultResendIterations = 0x3;
ULONG DefaultSampleRate = 60;
ULONG DefaultCrashOnCtrlScroll;
/* Default value for CrashOnCtrlScroll depends if we're
* running a debug build or a normal build.
*/
#if DBG
DefaultCrashOnCtrlScroll = 1;
#else
DefaultCrashOnCtrlScroll = 0;
#endif
RtlZeroMemory(Parameters, sizeof(Parameters));
Parameters[0].Flags = RTL_QUERY_REGISTRY_SUBKEY;
Parameters[0].Name = L"Parameters";
Parameters[1].Flags = RTL_QUERY_REGISTRY_DIRECT | RTL_REGISTRY_OPTIONAL;
Parameters[1].Name = L"KeyboardDataQueueSize";
Parameters[1].EntryContext = &Settings->KeyboardDataQueueSize;
Parameters[1].DefaultType = REG_DWORD;
Parameters[1].DefaultData = &DefaultKeyboardDataQueueSize;
Parameters[1].DefaultLength = sizeof(ULONG);
Parameters[2].Flags = RTL_QUERY_REGISTRY_DIRECT | RTL_REGISTRY_OPTIONAL;
Parameters[2].Name = L"KeyboardDeviceBaseName";
Parameters[2].EntryContext = &Settings->KeyboardDeviceBaseName;
Parameters[2].DefaultType = REG_SZ;
Parameters[2].DefaultData = (PVOID)DefaultKeyboardDeviceBaseName;
Parameters[2].DefaultLength = 0;
Parameters[3].Flags = RTL_QUERY_REGISTRY_DIRECT | RTL_REGISTRY_OPTIONAL;
Parameters[3].Name = L"MouseDataQueueSize";
Parameters[3].EntryContext = &Settings->MouseDataQueueSize;
Parameters[3].DefaultType = REG_DWORD;
Parameters[3].DefaultData = &DefaultMouseDataQueueSize;
Parameters[3].DefaultLength = sizeof(ULONG);
Parameters[4].Flags = RTL_QUERY_REGISTRY_DIRECT | RTL_REGISTRY_OPTIONAL;
Parameters[4].Name = L"MouseResolution";
Parameters[4].EntryContext = &Settings->MouseResolution;
Parameters[4].DefaultType = REG_DWORD;
Parameters[4].DefaultData = &DefaultMouseResolution;
Parameters[4].DefaultLength = sizeof(ULONG);
Parameters[5].Flags = RTL_QUERY_REGISTRY_DIRECT | RTL_REGISTRY_OPTIONAL;
Parameters[5].Name = L"MouseSynchIn100ns";
Parameters[5].EntryContext = &Settings->MouseSynchIn100ns;
Parameters[5].DefaultType = REG_DWORD;
Parameters[5].DefaultData = &DefaultMouseSynchIn100ns;
Parameters[5].DefaultLength = sizeof(ULONG);
Parameters[6].Flags = RTL_QUERY_REGISTRY_DIRECT | RTL_REGISTRY_OPTIONAL;
Parameters[6].Name = L"NumberOfButtons";
Parameters[6].EntryContext = &Settings->NumberOfButtons;
Parameters[6].DefaultType = REG_DWORD;
Parameters[6].DefaultData = &DefaultNumberOfButtons;
Parameters[6].DefaultLength = sizeof(ULONG);
Parameters[7].Flags = RTL_QUERY_REGISTRY_DIRECT | RTL_REGISTRY_OPTIONAL;
Parameters[7].Name = L"PointerDeviceBaseName";
Parameters[7].EntryContext = &Settings->PointerDeviceBaseName;
Parameters[7].DefaultType = REG_SZ;
Parameters[7].DefaultData = (PVOID)DefaultPointerDeviceBaseName;
Parameters[7].DefaultLength = 0;
Parameters[8].Flags = RTL_QUERY_REGISTRY_DIRECT | RTL_REGISTRY_OPTIONAL;
Parameters[8].Name = L"PollStatusIterations";
Parameters[8].EntryContext = &Settings->PollStatusIterations;
Parameters[8].DefaultType = REG_DWORD;
Parameters[8].DefaultData = &DefaultPollStatusIterations;
Parameters[8].DefaultLength = sizeof(ULONG);
Parameters[9].Flags = RTL_QUERY_REGISTRY_DIRECT | RTL_REGISTRY_OPTIONAL;
Parameters[9].Name = L"OverrideKeyboardType";
Parameters[9].EntryContext = &Settings->OverrideKeyboardType;
Parameters[9].DefaultType = REG_DWORD;
Parameters[9].DefaultData = &DefaultOverrideKeyboardType;
Parameters[9].DefaultLength = sizeof(ULONG);
Parameters[10].Flags = RTL_QUERY_REGISTRY_DIRECT | RTL_REGISTRY_OPTIONAL;
Parameters[10].Name = L"OverrideKeyboardSubtype";
Parameters[10].EntryContext = &Settings->OverrideKeyboardSubtype;
Parameters[10].DefaultType = REG_DWORD;
Parameters[10].DefaultData = &DefaultOverrideKeyboardSubtype;
Parameters[10].DefaultLength = sizeof(ULONG);
Parameters[11].Flags = RTL_QUERY_REGISTRY_DIRECT | RTL_REGISTRY_OPTIONAL;
Parameters[11].Name = L"PollingIterations";
Parameters[11].EntryContext = &Settings->PollingIterations;
Parameters[11].DefaultType = REG_DWORD;
Parameters[11].DefaultData = &DefaultPollingIterations;
Parameters[11].DefaultLength = sizeof(ULONG);
Parameters[12].Flags = RTL_QUERY_REGISTRY_DIRECT | RTL_REGISTRY_OPTIONAL;
Parameters[12].Name = L"PollingIterationsMaximum";
Parameters[12].EntryContext = &Settings->PollingIterationsMaximum;
Parameters[12].DefaultType = REG_DWORD;
Parameters[12].DefaultData = &DefaultPollingIterationsMaximum;
Parameters[12].DefaultLength = sizeof(ULONG);
Parameters[13].Flags = RTL_QUERY_REGISTRY_DIRECT | RTL_REGISTRY_OPTIONAL;
Parameters[13].Name = L"ResendIterations";
Parameters[13].EntryContext = &Settings->ResendIterations;
Parameters[13].DefaultType = REG_DWORD;
Parameters[13].DefaultData = &DefaultResendIterations;
Parameters[13].DefaultLength = sizeof(ULONG);
Parameters[14].Flags = RTL_QUERY_REGISTRY_DIRECT | RTL_REGISTRY_OPTIONAL;
Parameters[14].Name = L"SampleRate";
Parameters[14].EntryContext = &Settings->SampleRate;
Parameters[14].DefaultType = REG_DWORD;
Parameters[14].DefaultData = &DefaultSampleRate;
Parameters[14].DefaultLength = sizeof(ULONG);
Parameters[15].Flags = RTL_QUERY_REGISTRY_DIRECT | RTL_REGISTRY_OPTIONAL;
Parameters[15].Name = L"CrashOnCtrlScroll";
Parameters[15].EntryContext = &Settings->CrashOnCtrlScroll;
Parameters[15].DefaultType = REG_DWORD;
Parameters[15].DefaultData = &DefaultCrashOnCtrlScroll;
Parameters[15].DefaultLength = sizeof(ULONG);
Status = RtlQueryRegistryValues(
RTL_REGISTRY_ABSOLUTE,
RegistryPath->Buffer,
Parameters,
NULL,
NULL);
if (NT_SUCCESS(Status))
{
/* Check values */
if (Settings->KeyboardDataQueueSize < 1)
Settings->KeyboardDataQueueSize = DefaultKeyboardDataQueueSize;
if (Settings->MouseDataQueueSize < 1)
Settings->MouseDataQueueSize = DefaultMouseDataQueueSize;
if (Settings->NumberOfButtons < 1)
Settings->NumberOfButtons = DefaultNumberOfButtons;
if (Settings->PollingIterations < 0x400)
Settings->PollingIterations = DefaultPollingIterations;
if (Settings->PollingIterationsMaximum < 0x400)
Settings->PollingIterationsMaximum = DefaultPollingIterationsMaximum;
if (Settings->ResendIterations < 1)
Settings->ResendIterations = DefaultResendIterations;
}
else if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
{
/* Registry path doesn't exist. Set defaults */
Settings->KeyboardDataQueueSize = DefaultKeyboardDataQueueSize;
Settings->MouseDataQueueSize = DefaultMouseDataQueueSize;
Settings->MouseResolution = DefaultMouseResolution;
Settings->MouseSynchIn100ns = DefaultMouseSynchIn100ns;
Settings->NumberOfButtons = DefaultNumberOfButtons;
Settings->PollStatusIterations = DefaultPollStatusIterations;
Settings->OverrideKeyboardType = DefaultOverrideKeyboardType;
Settings->OverrideKeyboardSubtype = DefaultOverrideKeyboardSubtype;
Settings->PollingIterations = DefaultPollingIterations;
Settings->PollingIterationsMaximum = DefaultPollingIterationsMaximum;
Settings->ResendIterations = DefaultResendIterations;
Settings->SampleRate = DefaultSampleRate;
Settings->CrashOnCtrlScroll = DefaultCrashOnCtrlScroll;
if (!RtlCreateUnicodeString(&Settings->KeyboardDeviceBaseName, DefaultKeyboardDeviceBaseName)
|| !RtlCreateUnicodeString(&Settings->PointerDeviceBaseName, DefaultPointerDeviceBaseName))
{
WARN_(I8042PRT, "RtlCreateUnicodeString() failed\n");
Status = STATUS_NO_MEMORY;
}
else
{
Status = STATUS_SUCCESS;
}
}
if (NT_SUCCESS(Status))
{
INFO_(I8042PRT, "KeyboardDataQueueSize : 0x%lx\n", Settings->KeyboardDataQueueSize);
INFO_(I8042PRT, "KeyboardDeviceBaseName : %wZ\n", &Settings->KeyboardDeviceBaseName);
INFO_(I8042PRT, "MouseDataQueueSize : 0x%lx\n", Settings->MouseDataQueueSize);
INFO_(I8042PRT, "MouseResolution : 0x%lx\n", Settings->MouseResolution);
INFO_(I8042PRT, "MouseSynchIn100ns : %lu\n", Settings->MouseSynchIn100ns);
INFO_(I8042PRT, "NumberOfButtons : 0x%lx\n", Settings->NumberOfButtons);
INFO_(I8042PRT, "PointerDeviceBaseName : %wZ\n", &Settings->PointerDeviceBaseName);
INFO_(I8042PRT, "PollStatusIterations : 0x%lx\n", Settings->PollStatusIterations);
INFO_(I8042PRT, "OverrideKeyboardType : 0x%lx\n", Settings->OverrideKeyboardType);
INFO_(I8042PRT, "OverrideKeyboardSubtype : 0x%lx\n", Settings->OverrideKeyboardSubtype);
INFO_(I8042PRT, "PollingIterations : 0x%lx\n", Settings->PollingIterations);
INFO_(I8042PRT, "PollingIterationsMaximum : %lu\n", Settings->PollingIterationsMaximum);
INFO_(I8042PRT, "ResendIterations : 0x%lx\n", Settings->ResendIterations);
INFO_(I8042PRT, "SampleRate : %lu\n", Settings->SampleRate);
}
return Status;
}
/*++
*******************************************************************
G e t R o u t e r P a r a m e t e r s
Routine Description:
Reads the parameters from the registry or sets the defaults
Arguments:
RegistryPath - where to read from.
Return Value:
STATUS_SUCCESS
*******************************************************************
--*/
NTSTATUS
GetForwarderParameters (
IN PUNICODE_STRING RegistryPath
) {
NTSTATUS Status;
PWSTR RegistryPathBuffer;
PWSTR Parameters = L"Parameters";
RTL_QUERY_REGISTRY_TABLE paramTable[11]; // table size = nr of params + 1
RegistryPathBuffer = (PWSTR)ExAllocatePool(NonPagedPool, RegistryPath->Length + sizeof(WCHAR));
if (RegistryPathBuffer == NULL) {
return STATUS_INSUFFICIENT_RESOURCES;
}
RtlCopyMemory (RegistryPathBuffer, RegistryPath->Buffer, RegistryPath->Length);
*(PWCHAR)(((PUCHAR)RegistryPathBuffer)+RegistryPath->Length) = (WCHAR)'\0';
RtlZeroMemory(¶mTable[0], sizeof(paramTable));
paramTable[0].QueryRoutine = NULL;
paramTable[0].Flags = RTL_QUERY_REGISTRY_SUBKEY;
paramTable[0].Name = Parameters;
paramTable[1].Flags = RTL_QUERY_REGISTRY_DIRECT;
paramTable[1].Name = L"MaxRcvPktPoolSize";
paramTable[1].EntryContext = &MaxRcvPktsPoolSize;
paramTable[1].DefaultType = REG_DWORD;
paramTable[1].DefaultData = &MaxRcvPktsPoolSize;
paramTable[1].DefaultLength = sizeof(ULONG);
paramTable[2].Flags = RTL_QUERY_REGISTRY_DIRECT;
paramTable[2].Name = L"RcvPktsPerSegment";
paramTable[2].EntryContext = &RcvPktsPerSegment;
paramTable[2].DefaultType = REG_DWORD;
paramTable[2].DefaultData = &RcvPktsPerSegment;
paramTable[2].DefaultLength = sizeof(ULONG);
paramTable[3].Flags = RTL_QUERY_REGISTRY_DIRECT;
paramTable[3].Name = L"RouteTableSegmentSize";
paramTable[3].EntryContext = &RouteSegmentSize;
paramTable[3].DefaultType = REG_DWORD;
paramTable[3].DefaultData = &RouteSegmentSize;
paramTable[3].DefaultLength = sizeof(ULONG);
paramTable[4].Flags = RTL_QUERY_REGISTRY_DIRECT;
paramTable[4].Name = L"MaxSendPktsQueued";
paramTable[4].EntryContext = &MaxSendPktsQueued;
paramTable[4].DefaultType = REG_DWORD;
paramTable[4].DefaultData = &MaxSendPktsQueued;
paramTable[4].DefaultLength = sizeof(ULONG);
paramTable[5].Flags = RTL_QUERY_REGISTRY_DIRECT;
paramTable[5].Name = L"ClientHashSize";
paramTable[5].EntryContext = &ClientHashSize;
paramTable[5].DefaultType = REG_DWORD;
paramTable[5].DefaultData = &ClientHashSize;
paramTable[5].DefaultLength = sizeof(ULONG);
paramTable[6].Flags = RTL_QUERY_REGISTRY_DIRECT;
paramTable[6].Name = L"InterfaceHashSize";
paramTable[6].EntryContext = &InterfaceHashSize;
paramTable[6].DefaultType = REG_DWORD;
paramTable[6].DefaultData = &InterfaceHashSize;
paramTable[6].DefaultLength = sizeof(ULONG);
paramTable[7].Flags = RTL_QUERY_REGISTRY_DIRECT;
paramTable[7].Name = L"MaxNetbiosPacketsQueued";
paramTable[7].EntryContext = &MaxNetbiosPacketsQueued;
paramTable[7].DefaultType = REG_DWORD;
paramTable[7].DefaultData = &MaxNetbiosPacketsQueued;
paramTable[7].DefaultLength = sizeof(ULONG);
paramTable[8].Flags = RTL_QUERY_REGISTRY_DIRECT;
paramTable[8].Name = L"SpoofingTimeout";
paramTable[8].EntryContext = &SpoofingTimeout;
paramTable[8].DefaultType = REG_DWORD;
paramTable[8].DefaultData = &SpoofingTimeout;
paramTable[8].DefaultLength = sizeof(ULONG);
paramTable[9].Flags = RTL_QUERY_REGISTRY_DIRECT;
paramTable[9].Name = L"DontSuppressNonAgentSapAdvertisements";
paramTable[9].EntryContext = &DontSuppressNonAgentSapAdvertisements;
paramTable[9].DefaultType = REG_DWORD;
paramTable[9].DefaultData = &DontSuppressNonAgentSapAdvertisements;
paramTable[9].DefaultLength = sizeof(ULONG);
Status = RtlQueryRegistryValues(
RTL_REGISTRY_ABSOLUTE,
RegistryPathBuffer,
paramTable,
NULL,
NULL);
if(!NT_SUCCESS(Status)) {
IpxFwdDbgPrint (DBG_REGISTRY, DBG_WARNING,
("IpxFwd: Missing Parameters key in the registry\n"));
}
ExFreePool(RegistryPathBuffer);
if ((RcvPktsPerSegment > MAX_RCV_PKTS_PER_SEGMENT) ||
(RcvPktsPerSegment < MIN_RCV_PKTS_PER_SEGMENT)) {
RcvPktsPerSegment = DEF_RCV_PKTS_PER_SEGMENT;
}
if ((RouteSegmentSize > MAX_ROUTE_SEGMENT_SIZE) ||
(RouteSegmentSize < MIN_ROUTE_SEGMENT_SIZE)) {
RouteSegmentSize = DEF_ROUTE_SEGMENT_SIZE;
}
else
RouteSegmentSize = ROUND_TO_PAGES(RouteSegmentSize);
if ((InterfaceHashSize > MAX_INTERFACE_HASH_SIZE) ||
(InterfaceHashSize < MIN_INTERFACE_HASH_SIZE)) {
InterfaceHashSize = DEF_INTERFACE_HASH_SIZE;
}
if ((ClientHashSize > MAX_CLIENT_HASH_SIZE) ||
(ClientHashSize < MIN_CLIENT_HASH_SIZE)) {
ClientHashSize = DEF_CLIENT_HASH_SIZE;
}
// even if the RtlQueryRegistryValues has failed, we return success and will
// use the defaults.
return STATUS_SUCCESS;
}
/*
* @implemented
*/
NTSTATUS
QuerySymbolicLinkNamesFromStorage(IN PDEVICE_EXTENSION DeviceExtension,
IN PDEVICE_INFORMATION DeviceInformation,
IN PUNICODE_STRING SuggestedLinkName,
IN BOOLEAN UseOnlyIfThereAreNoOtherLinks,
OUT PUNICODE_STRING * SymLinks,
OUT PULONG SymLinkCount,
IN BOOLEAN HasGuid,
IN LPGUID Guid)
{
NTSTATUS Status;
BOOLEAN WriteNew;
RTL_QUERY_REGISTRY_TABLE QueryTable[2];
UNREFERENCED_PARAMETER(DeviceExtension);
/* First of all, count links */
RtlZeroMemory(QueryTable, sizeof(QueryTable));
QueryTable[0].QueryRoutine = SymbolicLinkNamesFromUniqueIdCount;
QueryTable[0].EntryContext = SymLinkCount;
*SymLinkCount = 0;
Status = RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE,
DatabasePath,
QueryTable,
DeviceInformation->UniqueId,
NULL);
if (!NT_SUCCESS(Status))
{
*SymLinkCount = 0;
}
/* Check if we have to write a new one first */
if (SuggestedLinkName && !IsDriveLetter(SuggestedLinkName) &&
UseOnlyIfThereAreNoOtherLinks && *SymLinkCount == 0)
{
WriteNew = TRUE;
}
else
{
WriteNew = FALSE;
}
/* If has GUID, it makes one more link */
if (HasGuid)
{
(*SymLinkCount)++;
}
if (WriteNew)
{
/* Write link */
RtlWriteRegistryValue(RTL_REGISTRY_ABSOLUTE,
DatabasePath,
SuggestedLinkName->Buffer,
REG_BINARY,
DeviceInformation->UniqueId->UniqueId,
DeviceInformation->UniqueId->UniqueIdLength);
/* And recount all the needed links */
RtlZeroMemory(QueryTable, sizeof(QueryTable));
QueryTable[0].QueryRoutine = SymbolicLinkNamesFromUniqueIdCount;
QueryTable[0].EntryContext = SymLinkCount;
*SymLinkCount = 0;
Status = RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE,
DatabasePath,
QueryTable,
DeviceInformation->UniqueId,
NULL);
if (!NT_SUCCESS(Status))
{
return STATUS_NOT_FOUND;
}
}
/* Not links found? */
if (!*SymLinkCount)
{
return STATUS_NOT_FOUND;
}
/* Allocate a buffer big enough to hold symlinks (table of unicode strings) */
*SymLinks = AllocatePool(*SymLinkCount * sizeof(UNICODE_STRING));
if (!*SymLinks)
{
return STATUS_INSUFFICIENT_RESOURCES;
}
/* Prepare to query links */
RtlZeroMemory(*SymLinks, *SymLinkCount * sizeof(UNICODE_STRING));
RtlZeroMemory(QueryTable, sizeof(QueryTable));
QueryTable[0].QueryRoutine = SymbolicLinkNamesFromUniqueIdQuery;
/* No GUID? Keep it that way */
if (!HasGuid)
{
QueryTable[0].EntryContext = *SymLinks;
}
/* Otherwise, first create volume name */
else
{
Status = CreateNewVolumeName(SymLinks[0], Guid);
if (!NT_SUCCESS(Status))
{
FreePool(*SymLinks);
return Status;
}
/* Skip first link (ours) */
QueryTable[0].EntryContext = *SymLinks + 1;
}
/* Now, query */
RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE,
DatabasePath,
QueryTable,
DeviceInformation->UniqueId,
NULL);
return STATUS_SUCCESS;
}
NTSTATUS
Ext2QueryGlobalParameters(IN PUNICODE_STRING RegistryPath)
{
RTL_QUERY_REGISTRY_TABLE QueryTable[8];
int i = 0;
NTSTATUS Status;
RtlZeroMemory(&QueryTable[0], sizeof(RTL_QUERY_REGISTRY_TABLE) * 8);
/*
* 1 writing support
*/
QueryTable[i].Flags = 0;
QueryTable[0].Name = WRITING_SUPPORT;
QueryTable[i].DefaultType = REG_NONE;
QueryTable[i].DefaultLength = 0;
QueryTable[i].DefaultData = NULL;
QueryTable[i].EntryContext = NULL;
QueryTable[i].QueryRoutine = Ext2RegistryQueryCallback;
i++;
/*
* 2 checking bitmap
*/
QueryTable[i].Flags = 0;
QueryTable[i].Name = CHECKING_BITMAP;
QueryTable[i].DefaultType = REG_NONE;
QueryTable[i].DefaultLength = 0;
QueryTable[i].DefaultData = NULL;
QueryTable[i].EntryContext = NULL;
QueryTable[i].QueryRoutine = Ext2RegistryQueryCallback;
i++;
/*
* 3 force writing
*/
QueryTable[i].Flags = 0;
QueryTable[i].Name = EXT3_FORCEWRITING;
QueryTable[i].DefaultType = REG_NONE;
QueryTable[i].DefaultLength = 0;
QueryTable[i].DefaultData = NULL;
QueryTable[i].EntryContext = NULL;
QueryTable[i].QueryRoutine = Ext2RegistryQueryCallback;
i++;
/*
* 4 automount
*/
QueryTable[i].Flags = 0;
QueryTable[i].Name = AUTO_MOUNT;
QueryTable[i].DefaultType = REG_NONE;
QueryTable[i].DefaultLength = 0;
QueryTable[i].DefaultData = NULL;
QueryTable[i].EntryContext = NULL;
QueryTable[i].QueryRoutine = Ext2RegistryQueryCallback;
i++;
/*
* 5 codepage
*/
QueryTable[i].Flags = 0;
QueryTable[i].Name = CODEPAGE_NAME;
QueryTable[i].DefaultType = REG_NONE;
QueryTable[i].DefaultLength = 0;
QueryTable[i].DefaultData = NULL;
QueryTable[i].EntryContext = NULL;
QueryTable[i].QueryRoutine = Ext2RegistryQueryCallback;
i++;
/*
* 6 hidden prefix
*/
QueryTable[i].Flags = 0;
QueryTable[i].Name = HIDING_PREFIX;
QueryTable[i].DefaultType = REG_NONE;
QueryTable[i].DefaultLength = 0;
QueryTable[i].DefaultData = NULL;
QueryTable[i].EntryContext = NULL;
QueryTable[i].QueryRoutine = Ext2RegistryQueryCallback;
i++;
/*
* 7 hidden suffix
*/
QueryTable[i].Flags = 0;
QueryTable[i].Name = HIDING_SUFFIX;
QueryTable[i].DefaultType = REG_NONE;
QueryTable[i].DefaultLength = 0;
QueryTable[i].DefaultData = NULL;
QueryTable[i].EntryContext = NULL;
QueryTable[i].QueryRoutine = Ext2RegistryQueryCallback;
i++;
Status = RtlQueryRegistryValues(
RTL_REGISTRY_ABSOLUTE,
RegistryPath->Buffer,
&QueryTable[0],
NULL,
NULL
);
return NT_SUCCESS(Status);
}
NTSTATUS
DiskAddDevice(
IN PDRIVER_OBJECT DriverObject,
IN PDEVICE_OBJECT PhysicalDeviceObject
)
/*++
Routine Description:
This routine gets a port drivers capabilities, obtains the
inquiry data, searches the SCSI bus for the port driver and creates
the device objects for the disks found.
Arguments:
DriverObject - Pointer to driver object created by system.
Pdo - Device object use to send requests to port driver.
Return Value:
True is returned if one disk was found and successfully created.
--*/
{
ULONG rootPartitionMountable = FALSE;
PCONFIGURATION_INFORMATION configurationInformation;
ULONG diskCount;
NTSTATUS status;
PAGED_CODE();
//
// See if we should be allowing file systems to mount on partition zero.
//
TRY {
HANDLE deviceKey = NULL;
UNICODE_STRING diskKeyName;
OBJECT_ATTRIBUTES objectAttributes = {0};
HANDLE diskKey;
RTL_QUERY_REGISTRY_TABLE queryTable[2] = { 0 };
status = IoOpenDeviceRegistryKey(PhysicalDeviceObject,
PLUGPLAY_REGKEY_DEVICE,
KEY_READ,
&deviceKey);
if(!NT_SUCCESS(status)) {
TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_PNP, "DiskAddDevice: Error %#08lx opening device key "
"for pdo %p\n",
status, PhysicalDeviceObject));
LEAVE;
}
RtlInitUnicodeString(&diskKeyName, L"Disk");
InitializeObjectAttributes(&objectAttributes,
&diskKeyName,
OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
deviceKey,
NULL);
status = ZwOpenKey(&diskKey, KEY_READ, &objectAttributes);
ZwClose(deviceKey);
if(!NT_SUCCESS(status)) {
TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_PNP, "DiskAddDevice: Error %#08lx opening disk key "
"for pdo %p device key %p\n",
status, PhysicalDeviceObject, deviceKey));
LEAVE;
}
queryTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT;
queryTable[0].Name = L"RootPartitionMountable";
queryTable[0].EntryContext = &(rootPartitionMountable);
#pragma prefast(suppress:6309, "We don't have QueryRoutine so Context doesn't make any sense")
status = RtlQueryRegistryValues(RTL_REGISTRY_HANDLE,
diskKey,
queryTable,
NULL,
NULL);
if(!NT_SUCCESS(status)) {
TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_PNP, "DiskAddDevice: Error %#08lx reading value from "
"disk key %p for pdo %p\n",
status, diskKey, PhysicalDeviceObject));
}
ZwClose(diskKey);
} FINALLY {
//
// Do nothing.
//
if(!NT_SUCCESS(status)) {
TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_PNP, "DiskAddDevice: Will %sallow file system to mount on "
"partition zero of disk %p\n",
(rootPartitionMountable ? "" : "not "),
PhysicalDeviceObject));
}
}
//
// Create device objects for disk
//
diskCount = 0;
status = DiskCreateFdo(
DriverObject,
PhysicalDeviceObject,
&diskCount,
(BOOLEAN) !rootPartitionMountable
);
//
// Get the number of disks already initialized.
//
configurationInformation = IoGetConfigurationInformation();
if (NT_SUCCESS(status)) {
//
// Increment system disk device count.
//
configurationInformation->DiskCount++;
}
return status;
} // end DiskAddDevice()
NTSTATUS
ScsiPortStartDevice(
IN PDEVICE_OBJECT LogicalUnit
)
/*++
Routine Description:
This routine will attempt to start the specified device object.
Currently this involves clearing the INITIALIZING flag if it was set,
and running through to the device node and marking itself as started. This
last is a kludge
Arguments:
LogicalUnit - a pointer to the PDO being started
Return Value:
status
--*/
{
PLOGICAL_UNIT_EXTENSION logicalUnitExtension = LogicalUnit->DeviceExtension;
PADAPTER_EXTENSION adapterExtension =
logicalUnitExtension->AdapterExtension;
HANDLE instanceHandle;
NTSTATUS status;
PAGED_CODE();
//
// Open the devnode for this PDO and see if anyone's given us some
// default SRB flags.
//
status = IoOpenDeviceRegistryKey(LogicalUnit,
PLUGPLAY_REGKEY_DEVICE,
KEY_READ,
&instanceHandle);
if(NT_SUCCESS(status)) {
RTL_QUERY_REGISTRY_TABLE queryTable[2];
ULONG zero = 0;
RtlZeroMemory(queryTable, sizeof(queryTable));
queryTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT;
queryTable[0].Name = L"DefaultRequestFlags";
queryTable[0].EntryContext =
&logicalUnitExtension->CommonExtension.SrbFlags;
queryTable[0].DefaultType = REG_DWORD;
queryTable[0].DefaultData = &zero;
queryTable[0].DefaultLength = sizeof(ULONG);
status = RtlQueryRegistryValues(RTL_REGISTRY_HANDLE | RTL_REGISTRY_OPTIONAL,
(PWSTR) instanceHandle,
queryTable,
NULL,
NULL);
//
// BUGBUG - need a way to turn off tagged queuing and caching. Ie.
// keep track of negative flags as well.
//
logicalUnitExtension->CommonExtension.SrbFlags &=
( SRB_FLAGS_DISABLE_DISCONNECT |
SRB_FLAGS_DISABLE_SYNCH_TRANSFER |
SRB_FLAGS_DISABLE_SYNCH_TRANSFER);
DebugPrint((1, "SpStartDevice: Default SRB flags for (%d,%d,%d) are "
"%#08lx\n",
logicalUnitExtension->PathId,
logicalUnitExtension->TargetId,
logicalUnitExtension->Lun,
logicalUnitExtension->CommonExtension.SrbFlags));
ZwClose(instanceHandle);
} else {
DebugPrint((1, "SpStartDevice: Error opening instance key for pdo "
"[%#08lx]\n",
status));
}
//
// If the queue is locked then unlock it to start i/o processing.
//
if(logicalUnitExtension->QueueLockCount > 0) {
status = SpLockUnlockQueue(LogicalUnit,
FALSE,
TRUE);
}
return status;
}
BOOLEAN
Ext2QueryGlobalParameters( IN PUNICODE_STRING RegistryPath)
{
NTSTATUS Status;
UNICODE_STRING ParameterPath;
RTL_QUERY_REGISTRY_TABLE QueryTable[2];
ULONG WritingSupport = 0;
ULONG CheckingBitmap = 0;
ULONG Ext3ForceWriting = 0;
ULONG AutoMount = 0;
UNICODE_STRING UniName;
ANSI_STRING AnsiName;
WCHAR UniBuffer[CODEPAGE_MAXLEN];
USHORT Buffer[HIDINGPAT_LEN];
ParameterPath.Length = 0;
ParameterPath.MaximumLength =
RegistryPath->Length + sizeof(PARAMETERS_KEY) + sizeof(WCHAR);
ParameterPath.Buffer =
(PWSTR) Ext2AllocatePool(
PagedPool,
ParameterPath.MaximumLength,
'LG2E'
);
if (!ParameterPath.Buffer) {
DbgBreak();
DEBUG(DL_ERR, ( "Ex2QueryParameters: failed to allocate Parameters...\n"));
return FALSE;
}
RtlCopyUnicodeString(&ParameterPath, RegistryPath);
RtlAppendUnicodeToString(&ParameterPath, PARAMETERS_KEY);
/* querying value of WritingSupport */
RtlZeroMemory(&QueryTable[0], sizeof(RTL_QUERY_REGISTRY_TABLE) * 2);
QueryTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT | RTL_QUERY_REGISTRY_REQUIRED;
QueryTable[0].Name = WRITING_SUPPORT;
QueryTable[0].EntryContext = &WritingSupport;
Status = RtlQueryRegistryValues(
RTL_REGISTRY_ABSOLUTE,
ParameterPath.Buffer,
&QueryTable[0],
NULL,
NULL );
DEBUG(DL_ERR, ( "Ext2QueryParameters: WritingSupport=%xh\n", WritingSupport));
/* querying value of CheckingBitmap */
RtlZeroMemory(&QueryTable[0], sizeof(RTL_QUERY_REGISTRY_TABLE) * 2);
QueryTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT | RTL_QUERY_REGISTRY_REQUIRED;
QueryTable[0].Name = CHECKING_BITMAP;
QueryTable[0].EntryContext = &CheckingBitmap;
Status = RtlQueryRegistryValues(
RTL_REGISTRY_ABSOLUTE,
ParameterPath.Buffer,
&QueryTable[0],
NULL,
NULL );
DEBUG(DL_ERR, ( "Ext2QueryParameters: CheckingBitmap=%xh\n", CheckingBitmap));
/* querying value of Ext3ForceWriting */
RtlZeroMemory(&QueryTable[0], sizeof(RTL_QUERY_REGISTRY_TABLE) * 2);
QueryTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT | RTL_QUERY_REGISTRY_REQUIRED;
QueryTable[0].Name = EXT3_FORCEWRITING;
QueryTable[0].EntryContext = &Ext3ForceWriting;
Status = RtlQueryRegistryValues(
RTL_REGISTRY_ABSOLUTE,
ParameterPath.Buffer,
&QueryTable[0],
NULL,
NULL );
DEBUG(DL_ERR, ( "Ext2QueryParameters: Ext3ForceWriting=%xh\n", Ext3ForceWriting));
/* querying value of AutoMount */
RtlZeroMemory(&QueryTable[0], sizeof(RTL_QUERY_REGISTRY_TABLE) * 2);
QueryTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT | RTL_QUERY_REGISTRY_REQUIRED;
QueryTable[0].Name = AUTO_MOUNT;
QueryTable[0].EntryContext = &AutoMount;
Status = RtlQueryRegistryValues(
RTL_REGISTRY_ABSOLUTE,
ParameterPath.Buffer,
&QueryTable[0],
NULL,
NULL );
SetLongFlag(Ext2Global->Flags, EXT2_AUTO_MOUNT);
if (NT_SUCCESS(Status) && AutoMount == 0) {
ClearLongFlag(Ext2Global->Flags, EXT2_AUTO_MOUNT);
}
DEBUG(DL_ERR, ( "Ext2QueryParameters: AutoMount=%xh\n", AutoMount));
/* querying codepage */
RtlZeroMemory(&QueryTable[0], sizeof(RTL_QUERY_REGISTRY_TABLE) * 2);
QueryTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT | RTL_QUERY_REGISTRY_REQUIRED;
QueryTable[0].Name = CODEPAGE_NAME;
QueryTable[0].EntryContext = &(UniName);
UniName.MaximumLength = CODEPAGE_MAXLEN * sizeof(WCHAR);
UniName.Length = 0;
UniName.Buffer = (PWSTR)UniBuffer;
Status = RtlQueryRegistryValues(
RTL_REGISTRY_ABSOLUTE,
ParameterPath.Buffer,
&QueryTable[0],
NULL,
NULL );
if (NT_SUCCESS(Status)) {
DEBUG(DL_ERR, ( "Ext2QueryParameters: Ext2CodePage=%wZ\n", &UniName));
AnsiName.MaximumLength = CODEPAGE_MAXLEN;
AnsiName.Length = 0;
AnsiName.Buffer = &(Ext2Global->Codepage.AnsiName[0]);
Status = RtlUnicodeStringToAnsiString(
&AnsiName,
&UniName,
FALSE);
if (!NT_SUCCESS(Status)) {
DEBUG(DL_ERR, ( "Ext2QueryParameters: Wrong CodePage %wZ ...\n", &UniName));
RtlCopyMemory(&(Ext2Global->Codepage.AnsiName[0]),"default\0", 8);
}
} else {
DEBUG(DL_ERR, ( "Ext2QueryParameters: CodePage not specified.\n"));
RtlCopyMemory(&(Ext2Global->Codepage.AnsiName[0]),"default\0", 8);
}
Ext2Global->Codepage.AnsiName[CODEPAGE_MAXLEN - 1] = 0;
/* querying name hiding patterns: prefix*/
RtlZeroMemory(&QueryTable[0], sizeof(RTL_QUERY_REGISTRY_TABLE) * 2);
QueryTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT | RTL_QUERY_REGISTRY_REQUIRED;
QueryTable[0].Name = HIDING_PREFIX;
QueryTable[0].EntryContext = &(UniName);
UniName.MaximumLength = HIDINGPAT_LEN * sizeof(WCHAR);
UniName.Length = 0;
UniName.Buffer = Buffer;
Status = RtlQueryRegistryValues(
RTL_REGISTRY_ABSOLUTE,
ParameterPath.Buffer,
&QueryTable[0],
NULL,
NULL );
if (NT_SUCCESS(Status)) {
DEBUG(DL_ERR, ( "Ext2QueryParameters: HidingPrefix=%wZ\n", &UniName));
AnsiName.MaximumLength =HIDINGPAT_LEN;
AnsiName.Length = 0;
AnsiName.Buffer = &(Ext2Global->sHidingPrefix[0]);
Status = RtlUnicodeStringToAnsiString(
&AnsiName,
&UniName,
FALSE);
if (NT_SUCCESS(Status)) {
Ext2Global->bHidingPrefix = TRUE;
} else {
DEBUG(DL_ERR, ( "Ext2QueryParameters: Wrong HidingPrefix ...\n"));
}
} else {
DEBUG(DL_ERR, ( "Ext2QueryParameters: HidingPrefix not specified.\n"));
}
Ext2Global->sHidingPrefix[HIDINGPAT_LEN - 1] = 0;
/* querying name hiding patterns: suffix */
RtlZeroMemory(&QueryTable[0], sizeof(RTL_QUERY_REGISTRY_TABLE) * 2);
QueryTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT | RTL_QUERY_REGISTRY_REQUIRED;
QueryTable[0].Name = HIDING_SUFFIX;
QueryTable[0].EntryContext = &(UniName);
UniName.MaximumLength = HIDINGPAT_LEN * sizeof(WCHAR);
UniName.Length = 0;
UniName.Buffer = Buffer;
Status = RtlQueryRegistryValues(
RTL_REGISTRY_ABSOLUTE,
ParameterPath.Buffer,
&QueryTable[0],
NULL,
NULL
);
if (NT_SUCCESS(Status)) {
DEBUG(DL_ERR, ( "Ext2QueryParameters: HidingSuffix=%wZ\n", &UniName));
AnsiName.MaximumLength = HIDINGPAT_LEN;
AnsiName.Length = 0;
AnsiName.Buffer = &(Ext2Global->sHidingSuffix[0]);
Status = RtlUnicodeStringToAnsiString(
&AnsiName,
&UniName,
FALSE);
if (NT_SUCCESS(Status)) {
Ext2Global->bHidingSuffix = TRUE;
} else {
DEBUG(DL_ERR, ( "Ext2QueryParameters: Wrong HidingSuffix ...\n"));
}
} else {
DEBUG(DL_ERR, ( "Ext2QueryParameters: HidingSuffix not specified.\n"));
}
Ext2Global->sHidingPrefix[HIDINGPAT_LEN - 1] = 0;
{
if (WritingSupport) {
SetLongFlag(Ext2Global->Flags, EXT2_SUPPORT_WRITING);
} else {
ClearLongFlag(Ext2Global->Flags, EXT2_SUPPORT_WRITING);
}
if (CheckingBitmap) {
SetLongFlag(Ext2Global->Flags, EXT2_CHECKING_BITMAP);
} else {
ClearLongFlag(Ext2Global->Flags, EXT2_CHECKING_BITMAP);
}
if (Ext3ForceWriting) {
DbgPrint("Ext2Fsd -- Warning: Ext3ForceWriting enabled !!!\n");
SetLongFlag(Ext2Global->Flags, EXT3_FORCE_WRITING);
SetLongFlag(Ext2Global->Flags, EXT2_SUPPORT_WRITING);
} else {
ClearLongFlag(Ext2Global->Flags, EXT3_FORCE_WRITING);
}
}
Ext2Global->RegistryPath.Buffer = ParameterPath.Buffer;
Ext2Global->RegistryPath.Length = 0;
Ext2Global->RegistryPath.MaximumLength = ParameterPath.MaximumLength;
RtlCopyUnicodeString(&Ext2Global->RegistryPath, RegistryPath);
RtlAppendUnicodeToString(&Ext2Global->RegistryPath, VOLUMES_KEY);
return TRUE;
}
VOID
NbfReadLinkageInformation(
IN PWSTR RegistryPathBuffer,
IN PCONFIG_DATA * ConfigurationInfo
)
/*++
Routine Description:
This routine is called by NBF to read its linkage information
from the registry. If there is none present, then ConfigData
is filled with a list of all the adapters that are known
to NBF.
Arguments:
RegistryPathBuffer - The null-terminated root of the NBF registry tree.
ConfigurationInfo - Returns NBF's current configuration.
Return Value:
None.
--*/
{
UINT ConfigBindings;
UINT NameCount = 0;
NTSTATUS Status;
RTL_QUERY_REGISTRY_TABLE QueryTable[6];
PWSTR Subkey = L"Linkage";
PWSTR Bind = L"Bind";
PWSTR Export = L"Export";
ULONG BindCount, ExportCount;
UINT i;
//
// Set up QueryTable to do the following:
//
//
// 1) Switch to the Linkage key below NBF
//
QueryTable[0].QueryRoutine = NULL;
QueryTable[0].Flags = RTL_QUERY_REGISTRY_SUBKEY;
QueryTable[0].Name = Subkey;
//
// 2) Call NbfCountEntries for the "Bind" multi-string
//
QueryTable[1].QueryRoutine = NbfCountEntries;
QueryTable[1].Flags = RTL_QUERY_REGISTRY_REQUIRED | RTL_QUERY_REGISTRY_NOEXPAND;
QueryTable[1].Name = Bind;
QueryTable[1].EntryContext = (PVOID)&NameCount;
QueryTable[1].DefaultType = REG_NONE;
//
// 3) Call NbfCountEntries for the "Export" multi-string
//
QueryTable[2].QueryRoutine = NbfCountEntries;
QueryTable[2].Flags = RTL_QUERY_REGISTRY_REQUIRED | RTL_QUERY_REGISTRY_NOEXPAND;
QueryTable[2].Name = Export;
QueryTable[2].EntryContext = (PVOID)&NameCount;
QueryTable[2].DefaultType = REG_NONE;
//
// 4) Call NbfAddBind for each string in "Bind"
//
QueryTable[3].QueryRoutine = NbfAddBind;
QueryTable[3].Flags = 0;
QueryTable[3].Name = Bind;
QueryTable[3].EntryContext = (PVOID)&BindCount;
QueryTable[3].DefaultType = REG_NONE;
//
// 5) Call NbfAddExport for each string in "Export"
//
QueryTable[4].QueryRoutine = NbfAddExport;
QueryTable[4].Flags = 0;
QueryTable[4].Name = Export;
QueryTable[4].EntryContext = (PVOID)&ExportCount;
QueryTable[4].DefaultType = REG_NONE;
//
// 6) Stop
//
QueryTable[5].QueryRoutine = NULL;
QueryTable[5].Flags = 0;
QueryTable[5].Name = NULL;
BindCount = 0;
ExportCount = 0;
Status = RtlQueryRegistryValues(
RTL_REGISTRY_ABSOLUTE,
RegistryPathBuffer,
QueryTable,
(PVOID)ConfigurationInfo,
NULL);
if (Status != STATUS_SUCCESS) {
return;
}
//
// Make sure that BindCount and ExportCount match, if not
// remove the extras.
//
if (BindCount < ExportCount) {
for (i=BindCount; i<ExportCount; i++) {
RemoveDevice (*ConfigurationInfo, i);
}
ConfigBindings = BindCount;
} else if (ExportCount < BindCount) {
for (i=ExportCount; i<BindCount; i++) {
RemoveAdapter (*ConfigurationInfo, i);
}
ConfigBindings = ExportCount;
} else {
ConfigBindings = BindCount; // which is equal to ExportCount
}
(*ConfigurationInfo)->NumAdapters = ConfigBindings;
} /* NbfReadLinkageInformation */
NTSTATUS
NbfGetExportNameFromRegistry(
IN PUNICODE_STRING RegistryPath,
IN PUNICODE_STRING BindName,
OUT PUNICODE_STRING ExportName
)
{
NTSTATUS OpenStatus;
HANDLE ParametersHandle;
HANDLE NbfConfigHandle;
NTSTATUS Status;
PWSTR RegistryPathBuffer;
OBJECT_ATTRIBUTES TmpObjectAttributes;
RTL_QUERY_REGISTRY_TABLE QueryTable[3];
PWSTR Subkey = L"Linkage";
PWSTR Bind = L"Bind";
PWSTR Export = L"Export";
LONG BindNumber;
//
// Open the registry.
//
InitializeObjectAttributes(
&TmpObjectAttributes,
RegistryPath, // name
OBJ_CASE_INSENSITIVE, // attributes
NULL, // root
NULL // security descriptor
);
OpenStatus = ZwOpenKey(
&NbfConfigHandle,
KEY_WRITE,
&TmpObjectAttributes
);
if (!NT_SUCCESS(OpenStatus)) {
NbfPrint1("NBF: Could not open NBF key: %lx\n", OpenStatus);
return OpenStatus;
}
Status = NbfOpenParametersKey (NbfConfigHandle, &ParametersHandle);
if (Status != STATUS_SUCCESS) {
ZwClose (NbfConfigHandle);
return Status;
}
//
// NbfReadLinkageInformation expects a null-terminated path,
// so we have to create one from the UNICODE_STRING.
//
RegistryPathBuffer = (PWSTR)ExAllocatePoolWithTag(
NonPagedPool,
RegistryPath->Length + sizeof(WCHAR),
NBF_MEM_TAG_REGISTRY_PATH);
if (RegistryPathBuffer == NULL) {
NbfCloseParametersKey (ParametersHandle);
ZwClose (NbfConfigHandle);
return STATUS_INSUFFICIENT_RESOURCES;
}
RtlCopyMemory (RegistryPathBuffer, RegistryPath->Buffer, RegistryPath->Length);
*(PWCHAR)(((PUCHAR)RegistryPathBuffer)+RegistryPath->Length) = (WCHAR)'\0';
//
// We have a new device whose binding was absent
// at boot - get export name given the bind name
//
// First we need to get index of the bind name
// Set up QueryTable to do the following:
//
// 1) Switch to the Linkage key below NBF
//
QueryTable[0].QueryRoutine = NULL;
QueryTable[0].Flags = RTL_QUERY_REGISTRY_SUBKEY;
QueryTable[0].Name = Subkey;
//
// 2) Call NbfMatchBindName for each string in "Bind"
//
QueryTable[1].QueryRoutine = NbfMatchBindName;
QueryTable[1].Flags = 0;
QueryTable[1].Name = Bind;
QueryTable[1].EntryContext = (PVOID)&BindNumber;
QueryTable[1].DefaultType = REG_NONE;
//
// 3) Stop
//
QueryTable[2].QueryRoutine = NULL;
QueryTable[2].Flags = 0;
QueryTable[2].Name = NULL;
BindNumber = -1;
Status = RtlQueryRegistryValues(
RTL_REGISTRY_ABSOLUTE,
RegistryPathBuffer,
QueryTable,
(PVOID)BindName,
NULL);
IF_NBFDBG (NBF_DEBUG_PNP) {
NbfPrint2 ("Status from NbfMatchBindName's = %08x, Bind Number = %d\n",
Status, BindNumber);
}
if (Status != STATUS_NO_MORE_MATCHES)
{
#if DBG
DbgBreakPoint();
#endif
if (Status == STATUS_SUCCESS) {
// We did not find the device 'bind name'
Status = NDIS_STATUS_ADAPTER_NOT_FOUND;
IF_NBFDBG (NBF_DEBUG_PNP) {
NbfPrint1 ("NBF - cannot find dynamic binding %S\n", BindName->Buffer);
}
}
NTSTATUS
IpxAddBind(
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 for each piece of the "Bind" multi-string and
saves the information in a Config structure. It
also queries the per-binding information and stores it.
Arguments:
ValueName - The name of the value ("Bind" -- ignored).
ValueType - The type of the value (REG_SZ -- ignored).
ValueData - The null-terminated data for the value.
ValueLength - The length of ValueData.
Context - A pointer to the Config structure.
EntryContext - A pointer to a count of binds that is incremented.
Return Value:
STATUS_SUCCESS
--*/
{
PCONFIG Config = (PCONFIG)Context;
PBINDING_CONFIG Binding;
PULONG CurBindNum = ((PULONG)EntryContext);
RTL_QUERY_REGISTRY_TABLE QueryTable[BINDING_PARAMETERS+4];
ULONG FrameTypeCount, NetworkNumberCount;
ULONG StringLoc;
BOOLEAN AutoDetect;
ULONG AutoDetectLoc;
ULONG SlideCount;
PWCHAR NameBuffer;
NTSTATUS Status;
BOOLEAN FrameTypeUsed[ISN_FRAME_TYPE_MAX];
ULONG Zero = 0;
ULONG One = 1;
ULONG DefaultBindSap = 0x8137;
ULONG DefaultAutoDetectType = ISN_FRAME_TYPE_802_2;
PWSTR Subkey = L"NetConfig\\12345678901234567890"; // BUGBUG: hack
PWSTR ValueDataWstr = (PWSTR)ValueData;
struct {
PWSTR KeyName;
PULONG DefaultValue;
} ParameterValues[BINDING_PARAMETERS] = {
{ L"MaxPktSize", &Zero } ,
{ L"BindSap", &DefaultBindSap } ,
{ L"DefaultAutoDetectType", &DefaultAutoDetectType } ,
{ L"SourceRouting", &One } ,
{ L"SourceRouteDef", &Zero } ,
{ L"SourceRouteBcast", &Zero } ,
{ L"SourceRouteMcast", &Zero } ,
{ L"EnableFuncaddr", &One } ,
{ L"EnableWanRouter", &One } };
ULONG BindingPreference[ISN_FRAME_TYPE_MAX] = {
ISN_FRAME_TYPE_802_2,
ISN_FRAME_TYPE_802_3,
ISN_FRAME_TYPE_ETHERNET_II,
ISN_FRAME_TYPE_SNAP };
UINT i, j, k;
UNREFERENCED_PARAMETER(ValueName);
UNREFERENCED_PARAMETER(ValueType);
Binding = (PBINDING_CONFIG)IpxAllocateMemory (sizeof(BINDING_CONFIG), MEMORY_CONFIG, "Binding");
if (Binding == NULL) {
IpxWriteResourceErrorLog(
(PVOID)Config->DriverObject,
EVENT_TRANSPORT_RESOURCE_POOL,
sizeof(BINDING_CONFIG),
MEMORY_CONFIG);
return STATUS_INSUFFICIENT_RESOURCES;
}
NameBuffer = (PWCHAR)IpxAllocateMemory (ValueLength, MEMORY_CONFIG, "NameBuffer");
if (NameBuffer == NULL) {
IpxFreeMemory (Binding, sizeof(BINDING_CONFIG), MEMORY_CONFIG, "Binding");
IpxWriteResourceErrorLog(
(PVOID)Config->DriverObject,
EVENT_TRANSPORT_RESOURCE_POOL,
ValueLength,
MEMORY_CONFIG);
return STATUS_INSUFFICIENT_RESOURCES;
}
RtlCopyMemory (NameBuffer, ValueData, ValueLength);
Binding->AdapterName.Buffer = NameBuffer;
Binding->AdapterName.Length = (USHORT)(ValueLength - sizeof(WCHAR));
Binding->AdapterName.MaximumLength = (USHORT)ValueLength;
Binding->DriverObject = Config->DriverObject;
FrameTypeCount = 0;
NetworkNumberCount = 0;
//
// The structure is allocated OK, insert it into the list.
//
InsertTailList (&Config->BindingList, &Binding->Linkage);
++(*CurBindNum);
//
// Set up QueryTable to do the following:
//
//
// 1) Switch to the NetConfig\XXXX key below IPX
// (we construct the right name in Subkey,
// first scan back to find the \, then copy
// the rest over, including the final '\0').
//
StringLoc = (ValueLength / sizeof(WCHAR)) - 2;
while (ValueDataWstr[StringLoc] != L'\\') {
--StringLoc;
}
RtlCopyMemory(&Subkey[10], &ValueDataWstr[StringLoc+1], ValueLength - ((StringLoc+1) * sizeof(WCHAR)));
QueryTable[0].QueryRoutine = NULL;
QueryTable[0].Flags = RTL_QUERY_REGISTRY_SUBKEY;
QueryTable[0].Name = Subkey;
//
// 2) Call IpxGetFrameType for each part of the
// "PktType" multi-string.
//
QueryTable[1].QueryRoutine = IpxGetFrameType;
QueryTable[1].Flags = RTL_QUERY_REGISTRY_REQUIRED;
QueryTable[1].Name = L"PktType";
QueryTable[1].EntryContext = &FrameTypeCount;
QueryTable[1].DefaultType = REG_NONE;
//
// 3) Call IpxGetFrameType for each part of the
// "NetworkNumber" multi-string.
//
QueryTable[2].QueryRoutine = IpxGetFrameType;
QueryTable[2].Flags = RTL_QUERY_REGISTRY_REQUIRED;
QueryTable[2].Name = L"NetworkNumber";
QueryTable[2].EntryContext = &NetworkNumberCount;
QueryTable[2].DefaultType = REG_NONE;
//
// 4-11) Call IpxGetBindingValue for each of the keys we
// care about.
//
for (i = 0; i < BINDING_PARAMETERS; i++) {
QueryTable[i+3].QueryRoutine = IpxGetBindingValue;
QueryTable[i+3].Flags = 0;
QueryTable[i+3].Name = ParameterValues[i].KeyName;
QueryTable[i+3].EntryContext = (PVOID)i;
QueryTable[i+3].DefaultType = REG_DWORD;
QueryTable[i+3].DefaultData = (PVOID)(ParameterValues[i].DefaultValue);
QueryTable[i+3].DefaultLength = sizeof(ULONG);
}
//
// 12) Stop
//
QueryTable[BINDING_PARAMETERS+3].QueryRoutine = NULL;
QueryTable[BINDING_PARAMETERS+3].Flags = 0;
QueryTable[BINDING_PARAMETERS+3].Name = NULL;
IPX_DEBUG (CONFIG, ("Read bind key for %ws (%ws)\n", ValueData, Subkey));
Status = RtlQueryRegistryValues(
RTL_REGISTRY_ABSOLUTE,
Config->RegistryPathBuffer,
QueryTable,
(PVOID)Binding,
NULL);
if (Status != STATUS_SUCCESS) {
//
// The binding will get freed during cleanup.
//
IpxWriteGeneralErrorLog(
(PVOID)Config->DriverObject,
EVENT_IPX_ILLEGAL_CONFIG,
906,
Status,
Subkey,
0,
NULL);
return STATUS_DEVICE_CONFIGURATION_ERROR;
}
if (FrameTypeCount == 0) {
IpxWriteGeneralErrorLog(
(PVOID)Config->DriverObject,
EVENT_IPX_NO_FRAME_TYPES,
907,
Status,
Subkey + 10,
0,
NULL);
}
if (FrameTypeCount > NetworkNumberCount) {
for (i = NetworkNumberCount; i <FrameTypeCount; i++) {
Binding->NetworkNumber[i] = 0;
}
}
Binding->FrameTypeCount = FrameTypeCount;
//
// Go through and eliminate duplicates from the frame
// type array.
//
for (i = 0; i < Binding->FrameTypeCount; i++) {
for (j = i+1; j < Binding->FrameTypeCount; j++) {
if (Binding->FrameType[j] == Binding->FrameType[i]) {
IPX_DEBUG (CONFIG, ("Frame types %d and %d identical\n", i, j));
//
// A duplicate, slide everything else down.
//
for (k = j+1; k < Binding->FrameTypeCount; k++) {
Binding->FrameType[k-1] = Binding->FrameType[k];
Binding->NetworkNumber[k-1] = Binding->NetworkNumber[k];
}
--Binding->FrameTypeCount;
--j; // so we check whoever just moved into this spot.
}
}
}
//
// Mark all the explicitly configured frame types, and
// see if we have to auto-detect.
//
for (i = 0; i < 4; i++) {
FrameTypeUsed[i] = FALSE;
}
AutoDetect = FALSE;
for (i = 0; i < Binding->FrameTypeCount; i++) {
if (Binding->FrameType[i] == ISN_FRAME_TYPE_AUTO) {
AutoDetectLoc = i;
AutoDetect = TRUE;
} else {
Binding->AutoDetect[i] = FALSE;
Binding->DefaultAutoDetect[i] = FALSE;
FrameTypeUsed[Binding->FrameType[i]] = TRUE;
}
}
if (!AutoDetect) {
IPX_DEBUG (AUTO_DETECT, ("No bindings auto-detected\n"));
return STATUS_SUCCESS;
}
//
// Slide everything that is past the auto-detect point up
// to the end.
//
SlideCount = Binding->FrameTypeCount - AutoDetectLoc - 1;
for (j = 3; j > 3 - SlideCount; j--) {
Binding->FrameType[j] = Binding->FrameType[j-(3-Binding->FrameTypeCount)];
Binding->NetworkNumber[j] = Binding->NetworkNumber[j-(3-Binding->FrameTypeCount)];
Binding->AutoDetect[j] = Binding->AutoDetect[j-(3-Binding->FrameTypeCount)];
Binding->DefaultAutoDetect[j] = Binding->DefaultAutoDetect[j-(3-Binding->FrameTypeCount)];
}
//
// Now fill in any frame types that are not hard-coded,
// this will start at AutoDetectLoc and exactly fill up
// the gap created when we slid things up above. We
// first put the default auto-detect at the first spot.
//
if (!FrameTypeUsed[Binding->Parameters[BINDING_DEFAULT_AUTO_DETECT]]) {
Binding->FrameType[AutoDetectLoc] = Binding->Parameters[BINDING_DEFAULT_AUTO_DETECT];
Binding->NetworkNumber[AutoDetectLoc] = 0;
Binding->AutoDetect[AutoDetectLoc] = TRUE;
Binding->DefaultAutoDetect[AutoDetectLoc] = TRUE;
++AutoDetectLoc;
FrameTypeUsed[Binding->Parameters[BINDING_DEFAULT_AUTO_DETECT]] = TRUE;
}
//
// Now fill in the array, using the preference order in
// the BindingPreference array (this comes into effect
// because the first frame type in our list that we
// find is used).
//
for (i = 0; i < ISN_FRAME_TYPE_MAX; i++) {
if (!FrameTypeUsed[BindingPreference[i]]) {
Binding->FrameType[AutoDetectLoc] = BindingPreference[i];
Binding->NetworkNumber[AutoDetectLoc] = 0;
Binding->AutoDetect[AutoDetectLoc] = TRUE;
Binding->DefaultAutoDetect[AutoDetectLoc] = FALSE;
++AutoDetectLoc;
}
}
Binding->FrameTypeCount = ISN_FRAME_TYPE_MAX;
#if DBG
for (i = 0; i < ISN_FRAME_TYPE_MAX; i++) {
IPX_DEBUG (AUTO_DETECT, ("%d: type %d, net %d, auto %d\n",
i, Binding->FrameType[i], Binding->NetworkNumber[i], Binding->AutoDetect[i]));
}
#endif
return STATUS_SUCCESS;
} /* IpxAddBind */
VOID NTAPI ClassGetDeviceParameter(
IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension,
IN PWSTR SubkeyName OPTIONAL,
IN PWSTR ParameterName,
IN OUT PULONG ParameterValue // also default value
)
{
NTSTATUS status;
RTL_QUERY_REGISTRY_TABLE queryTable[2];
HANDLE deviceParameterHandle;
HANDLE deviceSubkeyHandle;
ULONG defaultParameterValue;
PAGED_CODE();
//
// open the given parameter
//
status = IoOpenDeviceRegistryKey(FdoExtension->LowerPdo,
PLUGPLAY_REGKEY_DEVICE,
KEY_READ,
&deviceParameterHandle);
if (NT_SUCCESS(status) && (SubkeyName != NULL)) {
UNICODE_STRING subkeyName;
OBJECT_ATTRIBUTES objectAttributes;
RtlInitUnicodeString(&subkeyName, SubkeyName);
InitializeObjectAttributes(&objectAttributes,
&subkeyName,
OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
deviceParameterHandle,
NULL);
status = ZwOpenKey(&deviceSubkeyHandle,
KEY_READ,
&objectAttributes);
if (!NT_SUCCESS(status)) {
ZwClose(deviceParameterHandle);
}
}
if (NT_SUCCESS(status)) {
RtlZeroMemory(queryTable, sizeof(queryTable));
defaultParameterValue = *ParameterValue;
queryTable->Flags = RTL_QUERY_REGISTRY_DIRECT | RTL_QUERY_REGISTRY_REQUIRED;
queryTable->Name = ParameterName;
queryTable->EntryContext = ParameterValue;
queryTable->DefaultType = REG_DWORD;
queryTable->DefaultData = NULL;
queryTable->DefaultLength = 0;
status = RtlQueryRegistryValues(RTL_REGISTRY_HANDLE,
(PWSTR)(SubkeyName ?
deviceSubkeyHandle :
deviceParameterHandle),
queryTable,
NULL,
NULL);
if (!NT_SUCCESS(status)) {
*ParameterValue = defaultParameterValue; // use default value
}
//
// close what we open
//
if (SubkeyName) {
ZwClose(deviceSubkeyHandle);
}
ZwClose(deviceParameterHandle);
}
return;
} // end ClassGetDeviceParameter()
VOID NlsKbdInitializePerSystem(VOID)
{
RTL_QUERY_REGISTRY_TABLE QueryTable[4];
UNICODE_STRING EndString, HelpString;
UNICODE_STRING YesString, NoString;
UNICODE_STRING HomeString, ClearString;
UNICODE_STRING HelpKeyString;
UNICODE_STRING KanaHelpString;
UNICODE_STRING ClearKeyString;
NTSTATUS status;
//
// Set default VK_DBE_xxx status.
//
//
// AlphaNumeric input mode.
//
NlsSetKeyStateToggle(VK_DBE_ALPHANUMERIC);
//
// Single byte character input mode.
//
NlsSetKeyStateToggle(VK_DBE_SBCSCHAR);
//
// No roman input mode.
//
NlsSetKeyStateToggle(VK_DBE_NOROMAN);
//
// No code input mode.
//
NlsSetKeyStateToggle(VK_DBE_NOCODEINPUT);
//
// From Here, below code is for compatibility for Windows NT 3.xx
// for NEC PC-9800 verion.
//
//
// Initialize default strings.
//
RtlInitUnicodeString(&EndString, L"end");
RtlInitUnicodeString(&HelpString,L"help");
RtlInitUnicodeString(&YesString,L"yes");
RtlInitUnicodeString(&NoString, L"no");
RtlInitUnicodeString(&HomeString, L"home");
RtlInitUnicodeString(&ClearString,L"clear");
//
// Initialize recieve buffer.
//
RtlInitUnicodeString(&HelpKeyString,NULL);
RtlInitUnicodeString(&KanaHelpString,NULL);
RtlInitUnicodeString(&ClearKeyString,NULL);
//
// Initalize query tables.
//
// ValueName : "helpkey"
// ValueData : if "end" VK_END, otherwise VK_HELP
//
QueryTable[0].QueryRoutine = NULL;
QueryTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT;
QueryTable[0].Name = (PWSTR) L"helpkey",
QueryTable[0].EntryContext = (PVOID) &HelpKeyString;
QueryTable[0].DefaultType = REG_SZ;
QueryTable[0].DefaultData = &EndString;
QueryTable[0].DefaultLength = 0;
//
// ValueName : "KanaHelpKey"
// ValueData : if "yes" if kana on switch VK_HELP and VK_END
//
QueryTable[1].QueryRoutine = NULL;
QueryTable[1].Flags = RTL_QUERY_REGISTRY_DIRECT;
QueryTable[1].Name = (PWSTR) L"KanaHelpKey",
QueryTable[1].EntryContext = (PVOID) &KanaHelpString;
QueryTable[1].DefaultType = REG_SZ;
QueryTable[1].DefaultData = &YesString;
QueryTable[1].DefaultLength = 0;
//
// ValueName : "clrkey"
// ValueData : if "home" VK_HOME, otherwise VK_CLEAR
//
QueryTable[2].QueryRoutine = NULL;
QueryTable[2].Flags = RTL_QUERY_REGISTRY_DIRECT;
QueryTable[2].Name = (PWSTR) L"clrkey",
QueryTable[2].EntryContext = (PVOID) &ClearKeyString;
QueryTable[2].DefaultType = REG_SZ;
QueryTable[2].DefaultData = &HomeString;
QueryTable[2].DefaultLength = 0;
QueryTable[3].QueryRoutine = NULL;
QueryTable[3].Flags = 0;
QueryTable[3].Name = NULL;
status = RtlQueryRegistryValues(
RTL_REGISTRY_WINDOWS_NT,
NLSKBD_CONFIG_PATH,
QueryTable, NULL, NULL);
if (!NT_SUCCESS(status)) {
RIPMSG1(RIP_WARNING, "FEKBD:RtlQueryRegistryValues fails (%x)\n", status);
return;
}
if (RtlEqualUnicodeString(&HelpKeyString,&HelpString,TRUE)) {
/*
* Generate VK_HELP, when NLSKBD_HELP_OR_END is called.
*/
fNlsKbdConfiguration &= ~GEN_VK_END;
}
if (RtlEqualUnicodeString(&KanaHelpString,&NoString,TRUE)) {
/*
* In case of "yes":
* If 'kana' is on, when NLSKBD_HELP_OR_END is called, switch VK_END and VK_HELP.
* Else, in case of "no":
* Doesn't generate by 'kana' toggle state.
*/
fNlsKbdConfiguration &= ~GEN_KANA_AWARE;
}
if (RtlEqualUnicodeString(&ClearKeyString,&ClearString,TRUE)) {
/*
* Generate VK_CLEAR, when KBDNLS_HOME_OR_CLEAR is called.
*/
fNlsKbdConfiguration &= ~GEN_VK_HOME;
}
return;
}
