geninst.c File Reference

#include "cmp.h"
#include "stdlib.h"
#include "parseini.h"
#include "geninst.h"

Go to the source code of this file.

Defines
#define	FLG_ADDREG_BINVALUETYPE   ( 0x00000001 )
#define	FLG_ADDREG_NOCLOBBER   ( 0x00000002 )
#define	FLG_ADDREG_DELVAL   ( 0x00000004 )
#define	FLG_ADDREG_APPEND   ( 0x00000008 )
#define	FLG_ADDREG_KEYONLY   ( 0x00000010 )
#define	FLG_ADDREG_OVERWRITEONLY   ( 0x00000020 )
#define	FLG_ADDREG_TYPE_MASK   ( 0xFFFF0000 | FLG_ADDREG_BINVALUETYPE )
#define	FLG_ADDREG_TYPE_SZ   ( 0x00000000 )
#define	FLG_ADDREG_TYPE_MULTI_SZ   ( 0x00010000 )
#define	FLG_ADDREG_TYPE_EXPAND_SZ   ( 0x00020000 )
#define	FLG_ADDREG_TYPE_BINARY   ( 0x00000000 | FLG_ADDREG_BINVALUETYPE )
#define	FLG_ADDREG_TYPE_DWORD   ( 0x00010000 | FLG_ADDREG_BINVALUETYPE )
#define	FLG_ADDREG_TYPE_NONE   ( 0x00020000 | FLG_ADDREG_BINVALUETYPE )
#define	FLG_BITREG_CLEAR   ( 0x00000000 )
#define	FLG_BITREG_SET   ( 0x00000001 )
#define	FLG_BITREG_TYPE_BINARY   ( 0x00000000 )
#define	FLG_BITREG_TYPE_DWORD   ( 0x00000002 )
#define	NUM_OF_INF_RULES   3
Typedefs
typedef BOOLEAN(*	PFN_INFRULE )(IN PVOID InfHandle, IN PCHAR Section, IN PVOID RefData)
typedef BOOLEAN(*	PFN_REGLINE )(IN PVOID InfHandle, IN PCHAR Section, IN ULONG LineIndex)
Functions
BOOLEAN	CmpProcessReg (IN PVOID InfHandle, IN PCHAR Section, IN PVOID RefData)
NTSTATUS	CmpProcessAddRegLine (IN PVOID InfHandle, IN PCHAR Section, IN ULONG LineIndex)
NTSTATUS	CmpProcessDelRegLine (IN PVOID InfHandle, IN PCHAR Section, IN ULONG LineIndex)
NTSTATUS	CmpProcessBitRegLine (IN PVOID InfHandle, IN PCHAR Section, IN ULONG LineIndex)
NTSTATUS	CmpGetAddRegInfData (IN PVOID InfHandle, IN PCHAR Section, IN ULONG LineIndex, IN ULONG ValueIndex, IN ULONG ValueType, OUT PVOID *Data, OUT PULONG DataSize)
NTSTATUS	CmpOpenRegKey (IN OUT PHANDLE Key, IN OUT PULONG Disposition, IN PCHAR Root, IN PCHAR SubKey, IN ULONG DesiredAccess, IN BOOLEAN Create)
NTSTATUS	CmpAppendStringToMultiSz (IN HANDLE Key, IN PCHAR ValueName, IN OUT PVOID *Data, IN OUT PULONG DataSize)
BOOLEAN	CmpGenInstall (IN PVOID InfHandle, IN PCHAR Section)
Variables
struct {
PCHAR   Name
PFN_INFRULE   Action
PVOID   RefData
}	gInfRuleTable [NUM_OF_INF_RULES]

---

Define Documentation

#define FLG_ADDREG_APPEND   ( 0x00000008 )

Definition at line 125 of file geninst.c. Referenced by CmpProcessAddRegLine().

#define FLG_ADDREG_BINVALUETYPE   ( 0x00000001 )

Definition at line 122 of file geninst.c. Referenced by CmpProcessAddRegLine().

#define FLG_ADDREG_DELVAL   ( 0x00000004 )

Definition at line 124 of file geninst.c. Referenced by CmpProcessAddRegLine().

#define FLG_ADDREG_KEYONLY   ( 0x00000010 )

Definition at line 127 of file geninst.c. Referenced by CmpProcessAddRegLine().

#define FLG_ADDREG_NOCLOBBER   ( 0x00000002 )

Definition at line 123 of file geninst.c. Referenced by CmpProcessAddRegLine().

#define FLG_ADDREG_OVERWRITEONLY   ( 0x00000020 )

Definition at line 128 of file geninst.c. Referenced by CmpProcessAddRegLine().

#define FLG_ADDREG_TYPE_BINARY   ( 0x00000000 | FLG_ADDREG_BINVALUETYPE )

Definition at line 134 of file geninst.c. Referenced by CmpProcessAddRegLine().

#define FLG_ADDREG_TYPE_DWORD   ( 0x00010000 | FLG_ADDREG_BINVALUETYPE )

Definition at line 135 of file geninst.c. Referenced by CmpProcessAddRegLine().

#define FLG_ADDREG_TYPE_EXPAND_SZ   ( 0x00020000 )

Definition at line 133 of file geninst.c. Referenced by CmpProcessAddRegLine().

#define FLG_ADDREG_TYPE_MASK   ( 0xFFFF0000 | FLG_ADDREG_BINVALUETYPE )

Definition at line 130 of file geninst.c. Referenced by CmpProcessAddRegLine().

#define FLG_ADDREG_TYPE_MULTI_SZ   ( 0x00010000 )

Definition at line 132 of file geninst.c. Referenced by CmpProcessAddRegLine().

#define FLG_ADDREG_TYPE_NONE   ( 0x00020000 | FLG_ADDREG_BINVALUETYPE )

Definition at line 136 of file geninst.c. Referenced by CmpProcessAddRegLine().

#define FLG_ADDREG_TYPE_SZ   ( 0x00000000 )

Definition at line 131 of file geninst.c. Referenced by CmpProcessAddRegLine().

#define FLG_BITREG_CLEAR   ( 0x00000000 )

Definition at line 138 of file geninst.c.

#define FLG_BITREG_SET   ( 0x00000001 )

Definition at line 139 of file geninst.c. Referenced by CmpProcessBitRegLine().

#define FLG_BITREG_TYPE_BINARY   ( 0x00000000 )

Definition at line 140 of file geninst.c.

#define FLG_BITREG_TYPE_DWORD   ( 0x00000002 )

Definition at line 141 of file geninst.c. Referenced by CmpProcessBitRegLine().

#define NUM_OF_INF_RULES   3

Definition at line 147 of file geninst.c. Referenced by CmpGenInstall().

---

Typedef Documentation

typedef BOOLEAN(* PFN_INFRULE)(IN PVOID InfHandle, IN PCHAR Section, IN PVOID RefData)

Definition at line 37 of file geninst.c.

typedef BOOLEAN(* PFN_REGLINE)(IN PVOID InfHandle, IN PCHAR Section, IN ULONG LineIndex)

Definition at line 45 of file geninst.c. Referenced by CmpProcessReg().

---

Function Documentation

NTSTATUS CmpAppendStringToMultiSz (  IN HANDLE  Key, IN PCHAR  ValueName, IN OUT PVOID *  Data, IN OUT PULONG  DataSize )

Definition at line 1392 of file geninst.c. References ASSERT, DbgPrint, ExAllocatePoolWithTag, ExFreePool(), Key, NT_SUCCESS, NtQueryValueKey(), NTSTATUS(), NULL, PagedPool, RtlAnsiStringToUnicodeString(), RtlFreeUnicodeString(), RtlInitAnsiString(), TRUE, and ValueName. Referenced by CmpProcessAddRegLine(). 01401 : 01402 01403 This routine opens\creates a handle to the registry key. 01404 01405 Input Parameters: 01406 01407 Key - Receives the handle to the key. 01408 01409 ValueName - Name of the value to be appended to. 01410 01411 Data - Buffer containing the multi-sz to be appended. 01412 01413 DataSize - Size of the data. 01414 01415 Return Value: 01416 01417 Standard NT status value. 01418 01419 --*/ 01420 01421 { 01422 NTSTATUS status; 01423 ULONG size; 01424 ANSI_STRING ansiString; 01425 UNICODE_STRING unicodeString; 01426 PKEY_VALUE_FULL_INFORMATION valueInfo; 01427 PVOID buffer; 01428 PVOID str; 01429 01430 ASSERT(DataSize && *DataSize); 01431 ASSERT(*Data); 01432 01433 RtlInitAnsiString(&ansiString, ValueName); 01434 status = RtlAnsiStringToUnicodeString(&unicodeString, &ansiString, TRUE); 01435 if (NT_SUCCESS(status)) 01436 { 01437 size = 0; 01438 status = NtQueryValueKey( Key, 01439 &unicodeString, 01440 KeyValueFullInformation, 01441 NULL, 01442 0, 01443 &size); 01444 if (size) 01445 { 01446 buffer = ExAllocatePoolWithTag(PagedPool, size, CM_GENINST_TAG); 01447 if (buffer) 01448 { 01449 status = NtQueryValueKey( Key, 01450 &unicodeString, 01451 KeyValueFullInformation, 01452 buffer, 01453 size, 01454 &size); 01455 if (NT_SUCCESS(status)) 01456 { 01457 valueInfo = (PKEY_VALUE_FULL_INFORMATION)buffer; 01458 str = ExAllocatePoolWithTag( PagedPool, 01459 valueInfo->DataLength + 01460 *DataSize - sizeof(UNICODE_NULL), 01461 CM_GENINST_TAG); 01462 if (str) 01463 { 01464 memcpy( str, 01465 (PCHAR)buffer + valueInfo->DataOffset, 01466 valueInfo->DataLength); 01467 memcpy( (PCHAR)str + valueInfo->DataLength - sizeof(UNICODE_NULL), 01468 *Data, 01469 *DataSize); 01470 ExFreePool(*Data); 01471 *Data = str; 01472 *DataSize += valueInfo->DataLength - sizeof(UNICODE_NULL); 01473 } 01474 else 01475 { 01476 DbgPrint("CmpAppendStringToMultiSz: Failed to allocate memory!\n"); 01477 ASSERT(str); 01478 status = STATUS_NO_MEMORY; 01479 } 01480 } 01481 ExFreePool(buffer); 01482 } 01483 else 01484 { 01485 DbgPrint("CmpAppendStringToMultiSz: Failed to allocate memory!\n"); 01486 ASSERT(buffer); 01487 status = STATUS_NO_MEMORY; 01488 } 01489 } 01490 RtlFreeUnicodeString(&unicodeString); 01491 } 01492 01493 return (status); 01494 } }

BOOLEAN CmpGenInstall (  IN PVOID  InfHandle, IN PCHAR  Section )

Definition at line 176 of file geninst.c. References CmpGetKeyName(), CmpGetSectionLineIndex(), CmpSearchInfSection(), FALSE, gInfRuleTable, Name, NULL, NUM_OF_INF_RULES, and TRUE. Referenced by CmpMatchInfList(), and CmpMatchInstallRule(). : This routine does a GenInstall of the section in the inf. Input Parameters: InfHandle - Handle to the inf to be read. Section - Name of the section to be read. Return Value: TRUE iff the entire section was processed successfully. --*/ { ULONG ruleNumber; ULONG i; PCHAR ruleName; PCHAR regSection; BOOLEAN result = FALSE; if (CmpSearchInfSection(InfHandle, Section)) { // // Go through all the rules in the section and try to process // each of them. // for ( ruleNumber = 0; ruleName = CmpGetKeyName(InfHandle, Section, ruleNumber); ruleNumber++) { // // Search for the proceesing function in our table. // for ( i = 0; i < NUM_OF_INF_RULES && _stricmp(ruleName, gInfRuleTable[i].Name); i++); if ( i >= NUM_OF_INF_RULES || (regSection = CmpGetSectionLineIndex( InfHandle, Section, ruleNumber, 0)) == NULL || !CmpSearchInfSection(InfHandle, Section)) { result = FALSE; break; } if (!(*gInfRuleTable[i].Action)(InfHandle, regSection, gInfRuleTable[i].RefData)) { result = FALSE; } } // // All inf rules processed. // if (ruleNumber) { result = TRUE; } } return (result); }

NTSTATUS CmpGetAddRegInfData (  IN PVOID  InfHandle, IN PCHAR  Section, IN ULONG  LineIndex, IN ULONG  ValueIndex, IN ULONG  ValueType, OUT PVOID *  Data, OUT PULONG  DataSize )

Definition at line 987 of file geninst.c. References ASSERT, CmpGetBinaryField(), CmpGetIntField(), CmpGetSectionLineIndex(), CmpGetSectionLineIndexValueCount(), ExAllocatePoolWithTag, FALSE, NT_SUCCESS, NTSTATUS(), NULL, PagedPool, RtlAnsiStringToUnicodeString(), RtlInitAnsiString(), strlen(), and USHORT. Referenced by CmpProcessAddRegLine(). : This routine reads AddReg data from the inf. Input Parameters: InfHandle - Handle to the inf to be read. Section - Name of the section to be read. LineIndex - Index of the line to be read. ValueIndex - Index of the value to be read. ValueType - Data type to be read. Data - Receives pointer to the buffer in which data has been read. DataSize - Receives the size of the data buffer. Return Value: Standard NT status value. --*/ { NTSTATUS status = STATUS_UNSUCCESSFUL; PCHAR str; ULONG count; ULONG i; ANSI_STRING ansiString; UNICODE_STRING unicodeString; // // Validate the required fields. // ASSERT(Data); ASSERT(DataSize); switch (ValueType) { case REG_DWORD: *DataSize = sizeof(ULONG); *Data = ExAllocatePoolWithTag(PagedPool, *DataSize, CM_GENINST_TAG); if (*Data) { // // DWORD data is specified as four bytes in W9x. // if (CmpGetSectionLineIndexValueCount( InfHandle, Section, LineIndex) == 8) { if (!CmpGetBinaryField( InfHandle, Section, LineIndex, ValueIndex, *Data, *DataSize, NULL)) { *((PULONG)*Data) = 0; } status = STATUS_SUCCESS; } else { // // Get the DWORD value. // if (!CmpGetIntField( InfHandle, Section, LineIndex, 4, *Data)) { *((PULONG)*Data) = 0; } status = STATUS_SUCCESS; } } else { ASSERT(*Data); status = STATUS_NO_MEMORY; } break; case REG_SZ: case REG_EXPAND_SZ: // // Null terminated string. Gets converted to unicode before being // added into the registry. // str = CmpGetSectionLineIndex( InfHandle, Section, LineIndex, ValueIndex); if (str) { RtlInitAnsiString(&ansiString, str); *DataSize = (ansiString.Length << 1) + sizeof(UNICODE_NULL); unicodeString.MaximumLength = (USHORT)*DataSize; unicodeString.Buffer = ExAllocatePoolWithTag(PagedPool, *DataSize, CM_GENINST_TAG); *Data = NULL; if (unicodeString.Buffer) { status = RtlAnsiStringToUnicodeString(&unicodeString, &ansiString, FALSE); if (NT_SUCCESS(status)) { *Data = unicodeString.Buffer; status = STATUS_SUCCESS; } } else { ASSERT(unicodeString.Buffer); status = STATUS_NO_MEMORY; } } else { ASSERT(str); status = STATUS_NO_MEMORY; } break; case REG_MULTI_SZ: *DataSize = 0; *Data = NULL; // // Loop to determine the total memory that needs to be allocated. // count = CmpGetSectionLineIndexValueCount( InfHandle, Section, LineIndex); if (count > ValueIndex) { count -= ValueIndex; for (i = 0; i < count; i++) { str = CmpGetSectionLineIndex( InfHandle, Section, LineIndex, ValueIndex + i); if (str == NULL) { break; } *DataSize += ((strlen(str) * sizeof(WCHAR)) + sizeof(UNICODE_NULL)); } if (i == count) { // // Account for the terminating NULL. // *DataSize += sizeof(UNICODE_NULL); *Data = ExAllocatePoolWithTag(PagedPool, *DataSize, CM_GENINST_TAG); if (*Data) { for ( i = 0, unicodeString.Buffer = *Data; i < count; i++, (PCHAR)unicodeString.Buffer += unicodeString.MaximumLength) { str = CmpGetSectionLineIndex( InfHandle, Section, LineIndex, ValueIndex + i); if (str == NULL) { break; } RtlInitAnsiString(&ansiString, str); unicodeString.MaximumLength = (ansiString.Length * sizeof(WCHAR)) + sizeof(UNICODE_NULL); status = RtlAnsiStringToUnicodeString(&unicodeString, &ansiString, FALSE); if (!NT_SUCCESS(status)) { break; } } // // Terminate the multi-sz string. // if (i == count) { unicodeString.Buffer[0] = UNICODE_NULL; status = STATUS_SUCCESS; } } else { ASSERT(*Data); status = STATUS_NO_MEMORY; } } } break; case REG_BINARY: default: // // Free form binary data. // if (CmpGetBinaryField( InfHandle, Section, LineIndex, ValueIndex, NULL, 0, DataSize) && *DataSize) { *Data = ExAllocatePoolWithTag(PagedPool, *DataSize, CM_GENINST_TAG); if (*Data) { if (CmpGetBinaryField( InfHandle, Section, LineIndex, 4, *Data, *DataSize, NULL)) { status = STATUS_SUCCESS; } } else { ASSERT(*Data); status = STATUS_NO_MEMORY; } } else { status = STATUS_UNSUCCESSFUL; } break; } return (status); }

NTSTATUS CmpOpenRegKey (  IN OUT PHANDLE  Key, IN OUT PULONG  Disposition, IN PCHAR  Root, IN PCHAR  SubKey, IN ULONG  DesiredAccess, IN BOOLEAN  Create )

Definition at line 1264 of file geninst.c. References ASSERT, Create(), ExAllocatePoolWithTag, ExFreePool(), Key, NT_SUCCESS, NtCreateKey(), NtOpenKey(), NTSTATUS(), NULL, PagedPool, RtlAnsiStringToUnicodeString(), RtlFreeUnicodeString(), RtlInitAnsiString(), strlen(), and TRUE. Referenced by CmpProcessAddRegLine(), CmpProcessBitRegLine(), and CmpProcessDelRegLine(). : This routine opens\creates a handle to the registry key. Input Parameters: Key - Receives the handle to the key. Disposition - Receives the disposition of the key. Root - Abbreviated name of the root key. SubKey - Name of the subkey under the root. DesiredAccess - Desired access flags for the key. Create - TRUE if the key needs to be created instead of opened. Return Value: Standard NT status value. --*/ { NTSTATUS status = STATUS_OBJECT_NAME_INVALID; ULONG size; PCHAR str; ANSI_STRING ansiString; UNICODE_STRING unicodeString; OBJECT_ATTRIBUTES objectAttributes; str = NULL; size = strlen(SubKey) + 1; // // Check if we understand the specified root name. // if (_stricmp(Root, "HKLM") == 0) { size += strlen("\\Registry\\Machine\\"); str = ExAllocatePoolWithTag(PagedPool, size, CM_GENINST_TAG); if (str) { strcpy(str, "\\Registry\\Machine\\"); strcat(str, SubKey); } else { ASSERT(str); status = STATUS_NO_MEMORY; } } else { ASSERT(_stricmp(Root, "HKLM") == 0); } // // Proceed if we have a valid key name. // if (str) { RtlInitAnsiString(&ansiString, str); status = RtlAnsiStringToUnicodeString(&unicodeString, &ansiString, TRUE); if (NT_SUCCESS(status)) { InitializeObjectAttributes( &objectAttributes, &unicodeString, OBJ_CASE_INSENSITIVE, NULL, NULL); if (Create) { // // Create a new key or open an existing one. // status = NtCreateKey( Key, DesiredAccess, &objectAttributes, 0, NULL, REG_OPTION_NON_VOLATILE, Disposition ? Disposition : &size); } else { // // Open existing key. // if (Disposition) { *Disposition = REG_OPENED_EXISTING_KEY; } status = NtOpenKey( Key, DesiredAccess, &objectAttributes); } RtlFreeUnicodeString(&unicodeString); } else { ASSERT(NT_SUCCESS(status)); } ExFreePool(str); } return (status); }

NTSTATUS CmpProcessAddRegLine (  IN PVOID  InfHandle, IN PCHAR  Section, IN ULONG  LineIndex )

Definition at line 311 of file geninst.c. References CmpAppendStringToMultiSz(), CmpGetAddRegInfData(), CmpGetIntField(), CmpGetSectionLineIndex(), CmpOpenRegKey(), FALSE, FLG_ADDREG_APPEND, FLG_ADDREG_BINVALUETYPE, FLG_ADDREG_DELVAL, FLG_ADDREG_KEYONLY, FLG_ADDREG_NOCLOBBER, FLG_ADDREG_OVERWRITEONLY, FLG_ADDREG_TYPE_BINARY, FLG_ADDREG_TYPE_DWORD, FLG_ADDREG_TYPE_EXPAND_SZ, FLG_ADDREG_TYPE_MASK, FLG_ADDREG_TYPE_MULTI_SZ, FLG_ADDREG_TYPE_NONE, FLG_ADDREG_TYPE_SZ, NT_SUCCESS, NtClose(), NtDeleteValueKey(), NtQueryValueKey(), NtSetValueKey(), NTSTATUS(), NULL, RtlAnsiStringToUnicodeString(), RtlFreeUnicodeString(), RtlInitAnsiString(), and TRUE. : This routine processes a AddReg line in the inf. Input Parameters: InfHandle - Handle to the inf to be read. Section - Name of the section to be read. LineIndex - Index of the line to be read. Return Value: Standard NT status value. --*/ { NTSTATUS status = STATUS_UNSUCCESSFUL; PCHAR rootKeyName; PCHAR subKeyName; PCHAR valueName; ULONG flags; ULONG valueType; PCHAR buffer; HANDLE key; ULONG disposition; BOOLEAN dontSet; PVOID data = 0; ULONG dataSize = 0; ANSI_STRING ansiString; UNICODE_STRING unicodeString; OBJECT_ATTRIBUTES objectAttributes; // // Get the root-key name. // rootKeyName = CmpGetSectionLineIndex( InfHandle, Section, LineIndex, 0); if (rootKeyName) { // // Get the optional sub-key name. // subKeyName = CmpGetSectionLineIndex( InfHandle, Section, LineIndex, 1); // // Value name is optional. Can be NULL or "". // valueName = CmpGetSectionLineIndex( InfHandle, Section, LineIndex, 2); // // If we don't have a value name, the type is REG_SZ to force // the right behavior in RegSetValueEx. Otherwise get the data type. // valueType = REG_SZ; // // Read in the flags. // if (!CmpGetIntField( InfHandle, Section, LineIndex, 3, &flags)) { flags = 0; } // // Convert the flags to the registry type. // switch(flags & FLG_ADDREG_TYPE_MASK) { case FLG_ADDREG_TYPE_SZ: valueType = REG_SZ; break; case FLG_ADDREG_TYPE_MULTI_SZ: valueType = REG_MULTI_SZ; break; case FLG_ADDREG_TYPE_EXPAND_SZ: valueType = REG_EXPAND_SZ; break; case FLG_ADDREG_TYPE_BINARY: valueType = REG_BINARY; break; case FLG_ADDREG_TYPE_DWORD: valueType = REG_DWORD; break; case FLG_ADDREG_TYPE_NONE: valueType = REG_NONE; break; default : // // If the FLG_ADDREG_BINVALUETYPE is set, then the highword // can contain just about any random reg data type ordinal value. // if(flags & FLG_ADDREG_BINVALUETYPE) { // // Disallow the following reg data types: // // REG_NONE, REG_SZ, REG_EXPAND_SZ, REG_MULTI_SZ // valueType = HIGHWORD(flags); if(valueType < REG_BINARY || valueType == REG_MULTI_SZ) { return (STATUS_INVALID_PARAMETER); } } else { return (STATUS_INVALID_PARAMETER); } break; } // // Presently, the append behavior flag is only supported for // REG_MULTI_SZ values. // if((flags & FLG_ADDREG_APPEND) && valueType != REG_MULTI_SZ) { return (STATUS_INVALID_PARAMETER); } // // W9x compatibility. // if( (!valueName || *valueName == '\0') && valueType == REG_EXPAND_SZ) { valueType = REG_SZ; } status = CmpGetAddRegInfData( InfHandle, Section, LineIndex, 4, valueType, &data, &dataSize); if (NT_SUCCESS(status)) { // // Open the specified key if possible. // status = CmpOpenRegKey( &key, &disposition, rootKeyName, subKeyName, KEY_QUERY_VALUE | KEY_SET_VALUE, (BOOLEAN)!(flags & FLG_ADDREG_OVERWRITEONLY)); // // This variable gets set to TRUE if we dont actually want to set // the value. // dontSet = FALSE; if (NT_SUCCESS(status)) { if (flags & FLG_ADDREG_APPEND) { status = CmpAppendStringToMultiSz( key, valueName, &data, &dataSize); } if (NT_SUCCESS(status)) { // // W9x compatibility. // if (disposition == REG_OPENED_EXISTING_KEY) { if ( (flags & FLG_ADDREG_NOCLOBBER) && (valueName == NULL || *valueName == '\0')) { RtlInitAnsiString(&ansiString, ""); status = RtlAnsiStringToUnicodeString(&unicodeString, &ansiString, TRUE); if (NT_SUCCESS(status)) { status = NtQueryValueKey( key, &unicodeString, KeyValueBasicInformation, NULL, 0, &disposition); if (NT_SUCCESS(status) || status == STATUS_BUFFER_TOO_SMALL) { flags &= ~FLG_ADDREG_NOCLOBBER; } status = STATUS_SUCCESS; RtlFreeUnicodeString(&unicodeString); } } if (flags & FLG_ADDREG_DELVAL) { // // setupx compatibility. // dontSet = TRUE; if (valueName) { // // Delete the specified value. // RtlInitAnsiString(&ansiString, valueName); status = RtlAnsiStringToUnicodeString(&unicodeString, &ansiString, TRUE); if (NT_SUCCESS(status)) { status = NtDeleteValueKey(key, &unicodeString); RtlFreeUnicodeString(&unicodeString); } } } } else { flags &= ~FLG_ADDREG_NOCLOBBER; } if (!dontSet) { // // Respect the key only flag. // if (!(flags & FLG_ADDREG_KEYONLY)) { // // If no clobber flag is set, make sure that the value does not // already exist. // RtlInitAnsiString(&ansiString, valueName); status = RtlAnsiStringToUnicodeString(&unicodeString, &ansiString, TRUE); if (NT_SUCCESS(status)) { NTSTATUS existStatus; if (flags & FLG_ADDREG_NOCLOBBER) { existStatus = NtQueryValueKey( key, &unicodeString, KeyValueBasicInformation, NULL, 0, &disposition); if (NT_SUCCESS(existStatus) || existStatus == STATUS_BUFFER_TOO_SMALL) { dontSet = TRUE; } } else { if (flags & FLG_ADDREG_OVERWRITEONLY) { existStatus = NtQueryValueKey( key, &unicodeString, KeyValueBasicInformation, NULL, 0, &disposition); if (!NT_SUCCESS(existStatus) && existStatus != STATUS_BUFFER_TOO_SMALL) { dontSet = TRUE; } } } if (!dontSet) { status = NtSetValueKey( key, &unicodeString, 0, valueType, data, dataSize); } RtlFreeUnicodeString(&unicodeString); } } } } NtClose(key); } else if (flags & FLG_ADDREG_OVERWRITEONLY) { status = STATUS_SUCCESS; } } } return (status); }

NTSTATUS CmpProcessBitRegLine (  IN PVOID  InfHandle, IN PCHAR  Section, IN ULONG  LineIndex )

Definition at line 776 of file geninst.c. References ASSERT, CmpGetIntField(), CmpGetSectionLineIndex(), CmpOpenRegKey(), DbgPrint, ExAllocatePoolWithTag, ExFreePool(), FALSE, FLG_BITREG_SET, FLG_BITREG_TYPE_DWORD, NT_SUCCESS, NtClose(), NtQueryValueKey(), NtSetValueKey(), NTSTATUS(), NULL, PagedPool, RtlAnsiStringToUnicodeString(), RtlFreeUnicodeString(), RtlInitAnsiString(), and TRUE. : This routine processes a BitReg line in the inf. Input Parameters: InfHandle - Handle to the inf to be read. Section - Name of the section to be read. LineIndex - Index of the line to be read. Return Value: Standard NT status value. --*/ { NTSTATUS status = STATUS_UNSUCCESSFUL; PCHAR rootKeyName; PCHAR subKeyName; PCHAR valueName; ULONG flags; ULONG mask; ULONG field; HANDLE key; ULONG disposition; ANSI_STRING ansiString; UNICODE_STRING unicodeString; PCHAR buffer; ULONG size; PKEY_VALUE_FULL_INFORMATION valueInfo; // // Get the root-key name. // rootKeyName = CmpGetSectionLineIndex( InfHandle, Section, LineIndex, 0); if (rootKeyName) { // // Get the optional sub-key name. // subKeyName = CmpGetSectionLineIndex( InfHandle, Section, LineIndex, 1); // // Value name is optional. Can be NULL or "". // valueName = CmpGetSectionLineIndex( InfHandle, Section, LineIndex, 2); if (valueName && *valueName) { // // Read in the flags. // if (!CmpGetIntField( InfHandle, Section, LineIndex, 3, &flags)) { flags = 0; } if (!CmpGetIntField( InfHandle, Section, LineIndex, 4, &mask)) { mask = 0; } if (!(flags & FLG_BITREG_TYPE_DWORD)) { if (!CmpGetIntField( InfHandle, Section, LineIndex, 5, &field)) { return (status); } } // // Open the specified registry key. // status = CmpOpenRegKey( &key, &disposition, rootKeyName, subKeyName, KEY_ALL_ACCESS, FALSE); if (NT_SUCCESS(status)) { // // Read the existing data. // RtlInitAnsiString(&ansiString, valueName); status = RtlAnsiStringToUnicodeString(&unicodeString, &ansiString, TRUE); if (NT_SUCCESS(status)) { size = 0; status = NtQueryValueKey( key, &unicodeString, KeyValueFullInformation, NULL, 0, &size); if (size) { status = STATUS_NO_MEMORY; buffer = ExAllocatePoolWithTag(PagedPool, size, CM_GENINST_TAG); if (buffer) { status = NtQueryValueKey( key, &unicodeString, KeyValueFullInformation, buffer, size, &size); if (NT_SUCCESS(status)) { valueInfo = (PKEY_VALUE_FULL_INFORMATION)buffer; if (flags & FLG_BITREG_TYPE_DWORD) { if (valueInfo->Type == REG_DWORD && valueInfo->DataLength == sizeof(ULONG)) { if (flags & FLG_BITREG_SET) { *(PULONG)(buffer + valueInfo->DataOffset) |= mask; } else { *(PULONG)(buffer + valueInfo->DataOffset) &= ~mask; } } } else { if (valueInfo->Type == REG_BINARY && field < valueInfo->DataLength) { if (flags & FLG_BITREG_SET) { *(PUCHAR)(buffer + valueInfo->DataOffset + field) |= mask; } else { *(PUCHAR)(buffer + valueInfo->DataOffset + field) &= ~mask; } } } status = NtSetValueKey( key, &unicodeString, 0, valueInfo->Type, buffer + valueInfo->DataOffset, valueInfo->DataLength); } else { DbgPrint("Value cannot be read for BitReg in %s line %d\n", Section, LineIndex); ASSERT(NT_SUCCESS(status)); } ExFreePool(buffer); } else { ASSERT(buffer); status = STATUS_NO_MEMORY; } } RtlFreeUnicodeString(&unicodeString); } // // Close the key handle. // NtClose(key); } } } return (status); }

NTSTATUS CmpProcessDelRegLine (  IN PVOID  InfHandle, IN PCHAR  Section, IN ULONG  LineIndex )

Definition at line 658 of file geninst.c. References CmpGetSectionLineIndex(), CmpOpenRegKey(), FALSE, NT_SUCCESS, NtClose(), NtDeleteKey(), NtDeleteValueKey(), NTSTATUS(), RtlAnsiStringToUnicodeString(), RtlFreeUnicodeString(), RtlInitAnsiString(), and TRUE. : This routine processes a DelReg line in the inf. Input Parameters: InfHandle - Handle to the inf to be read. Section - Name of the section to be read. LineIndex - Index of the line to be read. Return Value: Standard NT status value. --*/ { NTSTATUS status = STATUS_UNSUCCESSFUL; PCHAR rootKeyName; PCHAR subKeyName; PCHAR valueName; HANDLE key; ULONG disposition; ANSI_STRING ansiString; UNICODE_STRING unicodeString; // // Read the required fields. // rootKeyName = CmpGetSectionLineIndex( InfHandle, Section, LineIndex, 0); subKeyName = CmpGetSectionLineIndex( InfHandle, Section, LineIndex, 1); if (rootKeyName && subKeyName) { // // Read the optional field. // valueName = CmpGetSectionLineIndex( InfHandle, Section, LineIndex, 2); // // Open the specified registry key. // status = CmpOpenRegKey( &key, &disposition, rootKeyName, subKeyName, KEY_ALL_ACCESS, FALSE); // // Proceed if we successfully opened the registry key. // if (NT_SUCCESS(status)) { // // If the key was successfully opened, do the DelReg. // if (valueName) { // // Delete the specified value. // RtlInitAnsiString(&ansiString, valueName); status = RtlAnsiStringToUnicodeString(&unicodeString, &ansiString, TRUE); if (NT_SUCCESS(status)) { status = NtDeleteValueKey(key, &unicodeString); RtlFreeUnicodeString(&unicodeString); } } else { // // No value specified. The subkey needs to be deleted. // status = NtDeleteKey(key); } // // Close the key handle. // NtClose(key); } } return (status); }

BOOLEAN CmpProcessReg (  IN PVOID  InfHandle, IN PCHAR  Section, IN PVOID  RefData )

Definition at line 258 of file geninst.c. References CmpSearchInfLine(), FALSE, NT_SUCCESS, NTSTATUS(), PFN_REGLINE, RefData, and TRUE. : This routine processes a AddReg section in the inf. Input Parameters: InfHandle - Handle to the inf to be read. Section - Name of the section to be read. Return Value: TRUE iff the entire section was processed successfully. --*/ { ULONG lineIndex; NTSTATUS status = STATUS_SUCCESS; NTSTATUS temp; // // Process all the lines in the xxxReg Section. // for ( lineIndex = 0; CmpSearchInfLine(InfHandle, Section, lineIndex); lineIndex++) { temp = (*(PFN_REGLINE)RefData)(InfHandle, Section, lineIndex); if (!NT_SUCCESS(temp)) { status = temp; } } if (NT_SUCCESS(status)) { return (TRUE); } return (FALSE); }

---

Variable Documentation

PFN_INFRULE Action

Definition at line 155 of file geninst.c.

struct { ... } gInfRuleTable[NUM_OF_INF_RULES]

Referenced by CmpGenInstall().

PCHAR Name

Definition at line 154 of file geninst.c. Referenced by ArbInitializeArbiterInstance(), CmGetSystemControlValues(), CmGetSystemDriverList(), CmpAssignSecurityDescriptor(), CmpCheckKey(), CmpCheckValueList(), CmpCreateLinkNode(), CmpCreatePredefined(), CmpCreateRootNode(), CmpDoCreate(), CmpDoCreateChild(), CmpFindControlSet(), CmpFindDrivers(), CmpFindNameInList(), CmpFindNLSData(), CmpFindProfileOption(), CmpFindValueByNameFromCache(), CmpGenInstall(), CmpGetKeySecurity(), CmpGetNameControlBlock(), CmpGetObjectSecurity(), CmpInitializeHiveList(), CmpInterlockedFunction(), CmpIsLoadType(), CmpMatchDescription(), CmpNameSize(), CmpPostNotify(), CmpQueryKeyData(), CmpQueryKeyName(), CmpQueryKeyValueData(), CmpSetCurrentProfile(), CmpSortDriverList(), CmQueryKey(), CmRestoreKey(), CompareNamesCaseSensitive(), CompareUnicodeStrings(), ComputeNameLength(), ComputeUnicodeNameLength(), DumpObjectDirs(), EhCreateChild(), EhOpenChildByName(), ExCreateDebugLogTag(), FsRtlCompareNodeAndKey(), FsRtlDoesDbcsContainWildCards(), FsRtlDoesNameContainWildCards(), FsRtlFindInTunnelCache(), FsRtlIsDbcsInExpression(), FsRtlIsNameInExpression(), FsRtlIsNameInExpressionPrivate(), GetNextWchar(), IopCaptureObjectName(), IsVolumeName(), LB_CreateLBLine(), LdrpGetFileVersion(), LdrpNameToOrdinal(), LdrpWalkImportDescriptor(), LdrQueryApplicationCompatibilityGoo(), main(), NtQueryInformationAtom(), ObpLookupDirectoryEntry(), RiInitializeRegistryFromAsciiFile(), RtlAddAtomToAtomTable(), RtlComputeLfnChecksum(), RtlGenerate8dot3Name(), RtlIsNameLegalDOS8Dot3(), RtlpCallQueryRegistryRoutine(), RtlpDphIsDllTargeted(), RtlpDphTargetDllsLoadCallBack(), RtlpGetIntegerAtom(), RtlpHashStringToAtom(), RtlpNtEnumerateSubKey(), RtlQueryEnvironmentVariable_U(), RtlSetEnvironmentVariable(), SepClientOpenPipe(), SepInitializationPhase1(), SetEnvironment(), UdfCandidateShortName(), UdfConvertCS0DstringToUnicode(), UdfFindDirEntry(), UdfFindNameLink(), UdfInsertPrefix(), UdfRenderNameToLegalUnicode(), UdfUpcaseName(), and ValidateName().

PVOID RefData

Definition at line 156 of file geninst.c. Referenced by CmpProcessReg().

---