netboot.c File Reference

#include "iop.h"
#include <ntddip.h>
#include <nbtioctl.h>
#include <ntddnfs.h>
#include <ntddbrow.h>
#include <ntddtcp.h>
#include <setupblk.h>
#include <remboot.h>
#include <oscpkt.h>
#include <windef.h>
#include <tdiinfo.h>
#include <ipinfo.h>

Go to the source code of this file.

Defines
#define	DEFAULT_DEST   0
#define	DEFAULT_DEST_MASK   0
#define	DEFAULT_METRIC   1
Functions
NTSTATUS	IopWriteIpAddressToRegistry (HANDLE handle, PWCHAR regkey, PUCHAR value)
NTSTATUS	IopTCPQueryInformationEx (IN HANDLE TCPHandle, IN TDIObjectID FAR *ID, OUT void FAR *Buffer, IN OUT DWORD FAR *BufferSize, IN OUT BYTE FAR *Context)
NTSTATUS	IopTCPSetInformationEx (IN HANDLE TCPHandle, IN TDIObjectID FAR *ID, IN void FAR *Buffer, IN DWORD FAR BufferSize)
NTSTATUS	IopSetDefaultGateway (IN ULONG GatewayAddress)
NTSTATUS	IopCacheNetbiosNameForIpAddress (IN PLOADER_PARAMETER_BLOCK LoaderBlock)
VOID	IopAssignNetworkDriveLetter (IN PLOADER_PARAMETER_BLOCK LoaderBlock)
NTSTATUS	IopAddRemoteBootValuesToRegistry (PLOADER_PARAMETER_BLOCK LoaderBlock)
NTSTATUS	IopStartNetworkForRemoteBoot (PLOADER_PARAMETER_BLOCK LoaderBlock)
VOID	IopAssignNetworkDriveLetter (PLOADER_PARAMETER_BLOCK LoaderBlock)
NTSTATUS	IopStartTcpIpForRemoteBoot (PLOADER_PARAMETER_BLOCK LoaderBlock)
BOOLEAN	IopIsRemoteBootCard (IN PDEVICE_NODE DeviceNode, IN PLOADER_PARAMETER_BLOCK LoaderBlock, IN PWCHAR HwIds)
NTSTATUS	IopSetupRemoteBootCard (IN PLOADER_PARAMETER_BLOCK LoaderBlock, IN HANDLE UniqueIdHandle, IN PUNICODE_STRING UnicodeDeviceInstance)
__inline long	htonl (long x)
Variables
BOOLEAN	ExpInTextModeSetup

---

Define Documentation

#define DEFAULT_DEST   0

Definition at line 59 of file netboot.c. Referenced by IopSetDefaultGateway().

#define DEFAULT_DEST_MASK   0

Definition at line 60 of file netboot.c. Referenced by IopSetDefaultGateway().

#define DEFAULT_METRIC   1

Definition at line 61 of file netboot.c. Referenced by IopSetDefaultGateway().

---

Function Documentation

__inline long htonl (  long  x  )

Definition at line 4238 of file netboot.c. References L. Referenced by IopCacheNetbiosNameForIpAddress(). { return((((x) >> 24) & 0x000000FFL) | (((x) >> 8) & 0x0000FF00L) | (((x) << 8) & 0x00FF0000L) | (((x) << 24) & 0xFF000000L)); }

NTSTATUS IopAddRemoteBootValuesToRegistry (  PLOADER_PARAMETER_BLOCK  LoaderBlock  )

Definition at line 314 of file netboot.c. References _LOADER_PARAMETER_BLOCK::ArcBootDeviceName, ASSERT, CHAR, CmRegistryMachineSystemCurrentControlSetServices, _SETUP_LOADER_BLOCK::ComputerName, _SETUP_LOADER_BLOCK::DefaultRouter, DWORD, FALSE, _SETUP_LOADER_BLOCK::Flags, IopOpenRegistryKey(), IopWriteIpAddressToRegistry(), _SETUP_LOADER_BLOCK::IpAddress, L, _SETUP_LOADER_BLOCK::MachineDirectoryPath, _SETUP_LOADER_BLOCK::NetbootCardDriverName, _SETUP_LOADER_BLOCK::NetbootCardServiceName, NT_SUCCESS, _LOADER_PARAMETER_BLOCK::NtBootPathName, NtClose(), NtDeleteValueKey(), NtOpenKey(), NtQueryValueKey(), NtSetValueKey(), NTSTATUS(), NULL, RtlAnsiStringToUnicodeString(), RtlDnsHostNameToComputerName(), RtlFreeUnicodeString(), RtlInitAnsiString(), RtlInitUnicodeString(), SETUPBLK_FLAGS_IS_TEXTMODE, _LOADER_PARAMETER_BLOCK::SetupLoaderBlock, _SETUP_LOADER_BLOCK::SubnetMask, TITLE_INDEX_VALUE, and TRUE. Referenced by IoInitSystem(). { NTSTATUS status = STATUS_SUCCESS; HANDLE handle; HANDLE serviceHandle; OBJECT_ATTRIBUTES objectAttributes; UNICODE_STRING string; CHAR addressA[16]; WCHAR addressW[16]; STRING addressStringA; UNICODE_STRING addressStringW; PUCHAR addressPointer; PUCHAR p; PUCHAR q; UCHAR ntName[128]; WCHAR imagePath[128]; STRING ansiString; UNICODE_STRING unicodeString; UNICODE_STRING dnsNameString; UNICODE_STRING netbiosNameString; ULONG tmpValue; if (LoaderBlock->SetupLoaderBlock->ComputerName[0] != 0) { // // Convert the name to a Netbios name. // _wcsupr( LoaderBlock->SetupLoaderBlock->ComputerName ); RtlInitUnicodeString( &dnsNameString, LoaderBlock->SetupLoaderBlock->ComputerName ); status = RtlDnsHostNameToComputerName( &netbiosNameString, &dnsNameString, TRUE); // allocate netbiosNameString if ( !NT_SUCCESS(status) ) { KdPrint(( "IopAddRemoteBootValuesToRegistry: Failed RtlDnsHostNameToComputerName: %x\n", status )); goto cleanup; } // // Add a value for the computername. // RtlInitUnicodeString( &string, L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\ComputerName\\ComputerName" ); InitializeObjectAttributes( &objectAttributes, &string, OBJ_CASE_INSENSITIVE, NULL, NULL ); status = NtOpenKey( &handle, KEY_ALL_ACCESS, &objectAttributes ); if ( !NT_SUCCESS(status) ) { KdPrint(( "IopAddRemoteBootValuesToRegistry: Unable to open ComputerName key: %x\n", status )); RtlFreeUnicodeString( &netbiosNameString ); goto cleanup; } RtlInitUnicodeString( &string, L"ComputerName" ); status = NtSetValueKey( handle, &string, 0, REG_SZ, netbiosNameString.Buffer, netbiosNameString.Length + sizeof(WCHAR) ); NtClose( handle ); RtlFreeUnicodeString( &netbiosNameString ); if ( !NT_SUCCESS(status) ) { KdPrint(( "IopAddRemoteBootValuesToRegistry: Unable to set ComputerName value: %x\n", status )); goto cleanup; } // // Add a value for the host name. // RtlInitUnicodeString( &string, L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\Tcpip\\Parameters" ); InitializeObjectAttributes( &objectAttributes, &string, OBJ_CASE_INSENSITIVE, NULL, NULL ); status = NtOpenKey( &handle, KEY_ALL_ACCESS, &objectAttributes ); if ( !NT_SUCCESS(status) ) { KdPrint(( "IopAddRemoteBootValuesToRegistry: Unable to open Tcpip\\Parameters key: %x\n", status )); goto cleanup; } _wcslwr( LoaderBlock->SetupLoaderBlock->ComputerName ); RtlInitUnicodeString( &string, L"Hostname" ); status = NtSetValueKey( handle, &string, 0, REG_SZ, LoaderBlock->SetupLoaderBlock->ComputerName, (wcslen(LoaderBlock->SetupLoaderBlock->ComputerName) + 1) * sizeof(WCHAR) ); NtClose( handle ); if ( !NT_SUCCESS(status) ) { KdPrint(( "IopAddRemoteBootValuesToRegistry: Unable to set Hostname value: %x\n", status )); goto cleanup; } } // // If the UNC path to the system files is supplied then store it in the registry. // ASSERT( _stricmp(LoaderBlock->ArcBootDeviceName,"net(0)") == 0 ); RtlInitUnicodeString( &string, L"\\Registry\\Machine\\System\\CurrentControlSet\\Control" ); InitializeObjectAttributes( &objectAttributes, &string, OBJ_CASE_INSENSITIVE, NULL, NULL ); status = NtOpenKey( &handle, KEY_ALL_ACCESS, &objectAttributes ); if ( !NT_SUCCESS(status) ) { KdPrint(( "IopAddRemoteBootValuesToRegistry: Unable to open Control key: %x\n", status )); goto skiproot; } p = strrchr( LoaderBlock->NtBootPathName, '\\' ); // find last separator if ( (p != NULL) && (*(p+1) == 0) ) { // // NtBootPathName ends with a backslash, so we need to back up // to the previous backslash. // q = p; *q = 0; p = strrchr( LoaderBlock->NtBootPathName, '\\' ); // find last separator *q = '\\'; } if ( p == NULL ) { KdPrint(( "IopAddRemoteBootValuesToRegistry: malformed NtBootPathName: %s\n", LoaderBlock->NtBootPathName )); NtClose( handle ); goto skiproot; } *p = 0; // terminate \server\share\images\machine #if defined(REMOTE_BOOT) // // Store the server path in the shared user data area. Note that we need // to add an extra \ at the beginning of this path to make it a UNC name. // SharedUserData->RemoteBootServerPath[0] = L'\\'; RtlInitAnsiString( &ansiString, LoaderBlock->NtBootPathName ); unicodeString.MaximumLength = sizeof(SharedUserData->RemoteBootServerPath) - (2 * sizeof(WCHAR)); unicodeString.Buffer = &SharedUserData->RemoteBootServerPath[1]; RtlAnsiStringToUnicodeString( &unicodeString, &ansiString, FALSE ); SharedUserData->RemoteBootServerPath[1 + (unicodeString.Length/sizeof(WCHAR))] = 0; #endif // defined(REMOTE_BOOT) strcpy( ntName, "\\Device\\LanmanRedirector"); strcat( ntName, LoaderBlock->NtBootPathName ); // append \server\share\images\machine *p = '\\'; RtlInitAnsiString( &ansiString, ntName ); RtlAnsiStringToUnicodeString( &unicodeString, &ansiString, TRUE ); RtlInitUnicodeString( &string, L"RemoteBootRoot" ); status = NtSetValueKey( handle, &string, 0, REG_SZ, unicodeString.Buffer, unicodeString.Length + sizeof(WCHAR) ); RtlFreeUnicodeString( &unicodeString ); if ( !NT_SUCCESS(status) ) { KdPrint(( "IopAddRemoteBootValuesToRegistry: Unable to set RemoteBootRoot value: %x\n", status )); } if ((LoaderBlock->SetupLoaderBlock->Flags & SETUPBLK_FLAGS_IS_TEXTMODE) != 0) { strcpy( ntName, "\\Device\\LanmanRedirector"); strcat( ntName, LoaderBlock->SetupLoaderBlock->MachineDirectoryPath ); RtlInitAnsiString( &ansiString, ntName ); RtlAnsiStringToUnicodeString( &unicodeString, &ansiString, TRUE ); RtlInitUnicodeString( &string, L"RemoteBootMachineDirectory" ); status = NtSetValueKey( handle, &string, 0, REG_SZ, unicodeString.Buffer, unicodeString.Length + sizeof(WCHAR) ); RtlFreeUnicodeString( &unicodeString ); if ( !NT_SUCCESS(status) ) { KdPrint(( "IopAddRemoteBootValuesToRegistry: Unable to set RemoteBootMachineDirectory value: %x\n", status )); } } NtClose( handle ); skiproot: #if defined(REMOTE_BOOT) StartCsc = INIT_CSC; IopSetFlushCSC(READ_CSC); if ( (StartCsc != FLUSH_CSC) && ((LoaderBlock->SetupLoaderBlock->Flags & SETUPBLK_FLAGS_REPIN) != 0) ) { StartCsc = FLUSH_CSC; IopSetFlushCSC(SET_FLUSH_CSC); } #if 0 RtlInitUnicodeString( &string, L"\\Registry\\Machine\\Software\\Microsoft\\Windows\\CSCSettings" ); InitializeObjectAttributes( &objectAttributes, &string, OBJ_CASE_INSENSITIVE, NULL, NULL ); status = NtOpenKey( &handle, KEY_ALL_ACCESS, &objectAttributes ); if ( NT_SUCCESS(status) ) { PKEY_VALUE_PARTIAL_INFORMATION keyValue; UCHAR buffer[FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION, Data) + sizeof(DWORD)]; ULONG length; DWORD disabled; #define ONE_BOOT 2 RtlInitUnicodeString( &string, L"DisableAgent" ); if ( (LoaderBlock->SetupLoaderBlock->Flags & SETUPBLK_FLAGS_DISABLE_CSC) == 0 ) { // // Disable CSC for this boot. // disabled = ONE_BOOT; status = NtSetValueKey( handle, &string, 0, REG_DWORD, &disabled, sizeof(DWORD)); } else { keyValue = (PKEY_VALUE_PARTIAL_INFORMATION)buffer; status = NtQueryValueKey( handle, &string, KeyValuePartialInformation, keyValue, sizeof(buffer), &length); if (NT_SUCCESS(status)) { disabled = *((DWORD *)(&keyValue->Data[0])); if (disabled == ONE_BOOT) { // Only disabled for last boot so re-enable now. status = NtDeleteValueKey( handle, &string); // BUGBUG should we repin? } } } NtClose( handle ); if ( !NT_SUCCESS(status) ) { KdPrint(( "IopAddRemoteBootValuesToRegistry: Unable to set CSCSettings: %x\n", status )); goto cleanup; } } #endif #endif // defined(REMOTE_BOOT) // // Add registry values for the IP address and subnet mask received // from DHCP. These are stored under the Tcpip service key and are // read by both Tcpip and Netbt. The adapter name used is the known // GUID for the NetbootCard. // RtlInitUnicodeString( &string, L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\Tcpip\\Parameters\\Interfaces\\{54C7D140-09EF-11D1-B25A-F5FE627ED95E}" ); InitializeObjectAttributes( &objectAttributes, &string, OBJ_CASE_INSENSITIVE, NULL, NULL ); status = NtOpenKey( &handle, KEY_ALL_ACCESS, &objectAttributes ); if ( !NT_SUCCESS(status) ) { KdPrint(( "IopAddRemoteBootValuesToRegistry: Unable to open Tcpip\\Parameters\\Interfaces\\{54C7D140-09EF-11D1-B25A-F5FE627ED95E} key: %x\n", status )); goto cleanup; } status = IopWriteIpAddressToRegistry(handle, L"DhcpIPAddress", (PUCHAR)&(LoaderBlock->SetupLoaderBlock->IpAddress) ); if ( !NT_SUCCESS(status)) { NtClose(handle); KdPrint(( "IopAddRemoteBootValuesToRegistry: Unable to write DhcpIPAddress: %x\n", status )); goto cleanup; } status = IopWriteIpAddressToRegistry(handle, L"DhcpSubnetMask", (PUCHAR)&(LoaderBlock->SetupLoaderBlock->SubnetMask) ); if ( !NT_SUCCESS(status)) { NtClose(handle); KdPrint(( "IopAddRemoteBootValuesToRegistry: Unable to write DhcpSubnetMask: %x\n", status )); goto cleanup; } status = IopWriteIpAddressToRegistry(handle, L"DhcpDefaultGateway", (PUCHAR)&(LoaderBlock->SetupLoaderBlock->DefaultRouter) ); NtClose(handle); if ( !NT_SUCCESS(status)) { KdPrint(( "IopAddRemoteBootValuesToRegistry: Unable to write DhcpDefaultGateway: %x\n", status )); goto cleanup; } // // Create the service key for the netboot card. We need to have // the Type value there or the card won't be initialized. // status = IopOpenRegistryKey(&handle, NULL, &CmRegistryMachineSystemCurrentControlSetServices, KEY_ALL_ACCESS, FALSE ); if (!NT_SUCCESS(status)) { KdPrint(( "IopAddRemoteBootValuesToRegistry: Unable to open CurrentControlSet\\Services: %x\n", status )); goto cleanup; } RtlInitUnicodeString(&string, LoaderBlock->SetupLoaderBlock->NetbootCardServiceName); InitializeObjectAttributes(&objectAttributes, &string, OBJ_CASE_INSENSITIVE, handle, (PSECURITY_DESCRIPTOR)NULL ); status = ZwCreateKey(&serviceHandle, KEY_ALL_ACCESS, &objectAttributes, 0, (PUNICODE_STRING)NULL, 0, &tmpValue // disposition ); ZwClose(handle); if (!NT_SUCCESS(status)) { KdPrint(( "IopAddRemoteBootValuesToRegistry: Unable to open/create netboot card service key: %x\n", status )); goto cleanup; } // // Store the image path. // PiWstrToUnicodeString(&string, L"ImagePath"); wcscpy(imagePath, L"system32\\drivers\\"); wcscat(imagePath, LoaderBlock->SetupLoaderBlock->NetbootCardDriverName); status = ZwSetValueKey(serviceHandle, &string, TITLE_INDEX_VALUE, REG_SZ, imagePath, (wcslen(imagePath) + 1) * sizeof(WCHAR) ); if (!NT_SUCCESS(status)) { NtClose(serviceHandle); KdPrint(( "IopAddRemoteBootValuesToRegistry: Unable to write ImagePath: %x\n", status )); goto cleanup; } // // Store the type. // PiWstrToUnicodeString(&string, L"Type"); tmpValue = 1; ZwSetValueKey(serviceHandle, &string, TITLE_INDEX_VALUE, REG_DWORD, &tmpValue, sizeof(tmpValue) ); NtClose(serviceHandle); if (!NT_SUCCESS(status)) { KdPrint(( "IopAddRemoteBootValuesToRegistry: Unable to write Type: %x\n", status )); } cleanup: return status; }

VOID IopAssignNetworkDriveLetter (  PLOADER_PARAMETER_BLOCK  LoaderBlock  )

Definition at line 1546 of file netboot.c. References _SETUP_LOADER_BLOCK::Flags, IoCreateSymbolicLink(), KeBugCheck(), L, NT_SUCCESS, _LOADER_PARAMETER_BLOCK::NtBootPathName, NTSTATUS(), NULL, RtlAnsiStringToUnicodeString(), RtlFreeUnicodeString(), RtlInitAnsiString(), RtlInitUnicodeString(), SETUPBLK_FLAGS_REMOTE_INSTALL, SETUPBLK_FLAGS_SYSPREP_INSTALL, _LOADER_PARAMETER_BLOCK::SetupLoaderBlock, and TRUE. Referenced by IopStartNetworkForRemoteBoot(). { PUCHAR p; PUCHAR q; UCHAR ntName[128]; STRING ansiString; UNICODE_STRING unicodeString; UNICODE_STRING unicodeString2; NTSTATUS status; // // Create the symbolic link of X: to the redirector. We do this // after the redirector has loaded, but before AssignDriveLetters // is called the first time in textmode setup (once that has // happened, the drive letters will stick). // // Note that we use X: for the textmode setup phase of a remote // installation. But for a true remote boot, we use C:. // if ((LoaderBlock->SetupLoaderBlock->Flags & (SETUPBLK_FLAGS_REMOTE_INSTALL | SETUPBLK_FLAGS_SYSPREP_INSTALL)) != 0) { RtlInitUnicodeString( &unicodeString2, L"\\DosDevices\\X:"); } else { RtlInitUnicodeString( &unicodeString2, L"\\DosDevices\\C:"); } // // If this is a remote boot setup boot, NtBootPathName is of the // form <server><share>\setup<install-directory><platform>. // We want the root of the X: drive to be the root of the install // directory. // // If this is a normal remote boot, NtBootPathName is of the form // <server><share>\images<machine>\winnt. We want the root of // the X: drive to be the root of the machine directory. // // Thus in either case, we need to remove the last element of the // path. // p = strrchr( LoaderBlock->NtBootPathName, '\\' ); // find last separator if ( (p != NULL) && (*(p+1) == 0) ) { // // NtBootPathName ends with a backslash, so we need to back up // to the previous backslash. // q = p; *q = 0; p = strrchr( LoaderBlock->NtBootPathName, '\\' ); // find last separator *q = '\\'; } if ( p == NULL ) { KdPrint(( "IopAssignNetworkDriveLetter: malformed NtBootPathName: %s\n", LoaderBlock->NtBootPathName )); KeBugCheck( ASSIGN_DRIVE_LETTERS_FAILED ); } *p = 0; // terminate \server\share\images\machine strcpy( ntName, "\\Device\\LanmanRedirector"); strcat( ntName, LoaderBlock->NtBootPathName ); // append \server\share\images\machine RtlInitAnsiString( &ansiString, ntName ); RtlAnsiStringToUnicodeString( &unicodeString, &ansiString, TRUE ); status = IoCreateSymbolicLink(&unicodeString2, &unicodeString); if (!NT_SUCCESS(status)) { KdPrint(( "IopAssignNetworkDriveLetter: unable to create DOS link for redirected boot drive: %x\n", status )); KeBugCheck( ASSIGN_DRIVE_LETTERS_FAILED ); } // DbgPrint("IopAssignNetworkDriveLetter: assigned %wZ to %wZ\n", &unicodeString2, &unicodeString); RtlFreeUnicodeString( &unicodeString ); *p = '\\'; // restore string return; }

VOID IopAssignNetworkDriveLetter (  IN PLOADER_PARAMETER_BLOCK  LoaderBlock  )

NTSTATUS IopCacheNetbiosNameForIpAddress (  IN PLOADER_PARAMETER_BLOCK  LoaderBlock  )

Definition at line 4247 of file netboot.c. References ASSERT, BYTE, DWORD, Handle, htonl(), L, NT_SUCCESS, NtClose(), NtCreateFile(), NtDeviceIoControlFile(), NTSTATUS(), NULL, RtlInitUnicodeString(), Size, and Status. Referenced by IopStartNetworkForRemoteBoot(). : This function takes an IP address, and submits it to NetBt for name resolution. Arguments: IpAddress - Address to resolve Return Value: Error Code. --*/ { NTSTATUS Status; HANDLE Handle = NULL; BYTE Context[CONTEXT_SIZE]; DWORD Size; OBJECT_ATTRIBUTES objectAttributes; UNICODE_STRING NameString; IO_STATUS_BLOCK ioStatusBlock; tREMOTE_CACHE cacheInfo; PCHAR serverName; PCHAR endOfServerName; // // Open NetBT. // RtlInitUnicodeString( &NameString, L"\\Device\\NetBT_Tcpip_{54C7D140-09EF-11D1-B25A-F5FE627ED95E}" ); InitializeObjectAttributes( &objectAttributes, &NameString, OBJ_CASE_INSENSITIVE, NULL, NULL ); Status = NtCreateFile( &Handle, GENERIC_READ | GENERIC_WRITE, &objectAttributes, &ioStatusBlock, NULL, 0, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, FILE_OPEN, FILE_SYNCHRONOUS_IO_NONALERT, NULL, 0 ); if ( !NT_SUCCESS(Status) ) { KdPrint(( "IopCacheNetbiosNameForIpAddress: Unable to open NETBT: %x\n", Status )); return Status; } // // Get the server's name. // // If this is a remote boot setup boot, NtBootPathName is of the // form <server><share>\setup<install-directory><platform>. // If this is a normal remote boot, NtBootPathName is of the form // <server><share>\images<machine>\winnt. // // Thus in either case, we need to isolate the first element of the // path. // serverName = LoaderBlock->NtBootPathName; if ( *serverName == '\\' ) { serverName++; } endOfServerName = strchr( serverName, '\\' ); if ( endOfServerName == NULL ) { endOfServerName = strchr( serverName, '\0' ); } // // Fill in the tREMOTE_CACHE structure. // memset(&cacheInfo, 0x0, sizeof(cacheInfo)); memset(cacheInfo.name, ' ', NETBIOS_NAMESIZE); memcpy(cacheInfo.name, serverName, (ULONG)(endOfServerName - serverName)); cacheInfo.IpAddress = htonl(LoaderBlock->SetupLoaderBlock->ServerIpAddress); cacheInfo.Ttl = MAXULONG; // // Submit the IOCTL. // Status = NtDeviceIoControlFile( Handle, NULL, NULL, NULL, &ioStatusBlock, IOCTL_NETBT_ADD_TO_REMOTE_TABLE, &cacheInfo, sizeof(cacheInfo), Context, sizeof(Context) ); ASSERT( Status != STATUS_PENDING ); if ( NT_SUCCESS(Status) ) { Status = ioStatusBlock.Status; } if ( !NT_SUCCESS(Status) ) { KdPrint(( "IopCacheNetbiosNameForIpAddress: Adapter status failed: %x\n", Status )); } NtClose(Handle); return Status; }

BOOLEAN IopIsRemoteBootCard (  IN PDEVICE_NODE  DeviceNode, IN PLOADER_PARAMETER_BLOCK  LoaderBlock, IN PWCHAR  HwIds )

Definition at line 1903 of file netboot.c. References BusNumber, FALSE, L, _SETUP_LOADER_BLOCK::NetbootCardHardwareId, _SETUP_LOADER_BLOCK::NetbootCardInfo, PSETUP_LOADER_BLOCK, and TRUE. Referenced by IopProcessNewDeviceNode(). 01911 : 01912 01913 This function determines if the card described by the hwIds is the 01914 remote boot network card. It checks against the hardware ID for the 01915 card that is stored in the setup loader block. 01916 01917 THIS ASSUMES THAT IOREMOTEBOOTCLIENT IS TRUE AND THAT LOADERBLOCK 01918 IS VALID. 01919 01920 Arguments: 01921 01922 DeviceNode - Device node for the card in question. 01923 01924 LoaderBlock - Supplies a pointer to the loader parameter block that was 01925 created by the OS Loader. 01926 01927 HwIds - The hardware IDs for the device in question. 01928 01929 Return Value: 01930 01931 TRUE or FALSE. 01932 01933 --*/ 01934 01935 { 01936 PSETUP_LOADER_BLOCK setupLoaderBlock; 01937 PWCHAR curHwId; 01938 01939 // 01940 // setupLoaderBlock will always be non-NULL if we are 01941 // remote booting, even if we are not in setup. 01942 // 01943 01944 setupLoaderBlock = LoaderBlock->SetupLoaderBlock; 01945 01946 // 01947 // Scan through the HwIds for a match. 01948 // 01949 01950 curHwId = HwIds; 01951 01952 while (*curHwId != L'\0') { 01953 if (wcscmp(curHwId, setupLoaderBlock->NetbootCardHardwareId) == 0) { 01954 01955 ULONG BusNumber, SlotNumber; 01956 01957 BusNumber = (ULONG)((((PNET_CARD_INFO)setupLoaderBlock->NetbootCardInfo)->pci.BusDevFunc) >> 8); 01958 SlotNumber = (ULONG)(((((PNET_CARD_INFO)setupLoaderBlock->NetbootCardInfo)->pci.BusDevFunc) & 0xf8) >> 3); 01959 01960 KdPrint(("IopIsRemoteBootCard: FOUND %ws\n", setupLoaderBlock->NetbootCardHardwareId)); 01961 if ((DeviceNode->ResourceRequirements->BusNumber != BusNumber) || 01962 (DeviceNode->ResourceRequirements->SlotNumber != SlotNumber)) { 01963 KdPrint(("IopIsRemoteBootCard: ignoring non-matching card:\n")); 01964 KdPrint((" devnode bus %d, busdevfunc bus %d\n", 01965 DeviceNode->ResourceRequirements->BusNumber, 01966 BusNumber)); 01967 KdPrint((" devnode slot %d, busdevfunc slot %d\n", 01968 DeviceNode->ResourceRequirements->SlotNumber, 01969 SlotNumber)); 01970 return FALSE; 01971 } else { 01972 return TRUE; 01973 } 01974 } 01975 curHwId += (wcslen(curHwId) + 1); 01976 } 01977 01978 return FALSE; 01979 }

NTSTATUS IopSetDefaultGateway (  IN ULONG  GatewayAddress  )

Definition at line 4017 of file netboot.c. References BYTE, DEFAULT_DEST, DEFAULT_DEST_MASK, DEFAULT_METRIC, DWORD, ExAllocatePoolWithTag, ExFreePool(), Handle, ID, IopTCPQueryInformationEx(), IopTCPSetInformationEx(), NT_SUCCESS, NtClose(), NtCreateFile(), NTSTATUS(), NULL, PagedPool, RtlInitUnicodeString(), Size, and Status. Referenced by IopStartNetworkForRemoteBoot(). : This function adds a default gateway entry from the router table. Arguments: GatewayAddress - Address of the default gateway. Return Value: Error Code. --*/ { NTSTATUS Status; HANDLE Handle = NULL; BYTE Context[CONTEXT_SIZE]; TDIObjectID ID; DWORD Size; IPSNMPInfo IPStats; IPAddrEntry *AddrTable = NULL; DWORD NumReturned; DWORD Type; DWORD i; DWORD MatchIndex; IPRouteEntry RouteEntry; OBJECT_ATTRIBUTES objectAttributes; UNICODE_STRING NameString; IO_STATUS_BLOCK ioStatusBlock; if (GatewayAddress == 0) { return STATUS_SUCCESS; } RtlInitUnicodeString( &NameString, DD_TCP_DEVICE_NAME ); InitializeObjectAttributes( &objectAttributes, &NameString, OBJ_CASE_INSENSITIVE, NULL, NULL ); Status = NtCreateFile( &Handle, GENERIC_READ | GENERIC_WRITE, &objectAttributes, &ioStatusBlock, NULL, 0, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, FILE_OPEN, FILE_SYNCHRONOUS_IO_NONALERT, NULL, 0 ); if ( !NT_SUCCESS(Status) ) { KdPrint(( "IopSetDefaultGateway: Unable to open TCPIP: %x\n", Status )); return Status; } // // Get the NetAddr info, to find an interface index for the gateway. // ID.toi_entity.tei_entity = CL_NL_ENTITY; ID.toi_entity.tei_instance = 0; ID.toi_class = INFO_CLASS_PROTOCOL; ID.toi_type = INFO_TYPE_PROVIDER; ID.toi_id = IP_MIB_STATS_ID; Size = sizeof(IPStats); memset(&IPStats, 0x0, Size); memset(Context, 0x0, CONTEXT_SIZE); Status = IopTCPQueryInformationEx( Handle, &ID, &IPStats, &Size, Context); if (!NT_SUCCESS(Status)) { KdPrint(( "IopSetDefaultGateway: Unable to query TCPIP(1): %x\n", Status )); goto Cleanup; } Size = IPStats.ipsi_numaddr * sizeof(IPAddrEntry); AddrTable = ExAllocatePoolWithTag(PagedPool, Size, 'bRoI'); if (AddrTable == NULL) { Status = STATUS_NO_MEMORY; goto Cleanup; } ID.toi_id = IP_MIB_ADDRTABLE_ENTRY_ID; memset(Context, 0x0, CONTEXT_SIZE); Status = IopTCPQueryInformationEx( Handle, &ID, AddrTable, &Size, Context); if (!NT_SUCCESS(Status)) { KdPrint(( "IopSetDefaultGateway: Unable to query TCPIP(2): %x\n", Status )); goto Cleanup; } NumReturned = Size/sizeof(IPAddrEntry); // // We've got the address table. Loop through it. If we find an exact // match for the gateway, then we're adding or deleting a direct route // and we're done. Otherwise try to find a match on the subnet mask, // and remember the first one we find. // Type = IRE_TYPE_INDIRECT; for (i = 0, MatchIndex = 0xffff; i < NumReturned; i++) { if( AddrTable[i].iae_addr == GatewayAddress ) { // // Found an exact match. // MatchIndex = i; Type = IRE_TYPE_DIRECT; break; } // // The next hop is on the same subnet as this address. If // we haven't already found a match, remember this one. // if ( (MatchIndex == 0xffff) && (AddrTable[i].iae_addr != 0) && (AddrTable[i].iae_mask != 0) && ((AddrTable[i].iae_addr & AddrTable[i].iae_mask) == (GatewayAddress & AddrTable[i].iae_mask)) ) { MatchIndex = i; } } // // We've looked at all of the entries. See if we found a match. // if (MatchIndex == 0xffff) { // // Didn't find a match. // Status = STATUS_UNSUCCESSFUL; KdPrint(( "IopSetDefaultGateway: Unable to find match for gateway\n" )); goto Cleanup; } // // We've found a match. Fill in the route entry, and call the // Set API. // RouteEntry.ire_dest = DEFAULT_DEST; RouteEntry.ire_index = AddrTable[MatchIndex].iae_index; RouteEntry.ire_metric1 = DEFAULT_METRIC; RouteEntry.ire_metric2 = (DWORD)(-1); RouteEntry.ire_metric3 = (DWORD)(-1); RouteEntry.ire_metric4 = (DWORD)(-1); RouteEntry.ire_nexthop = GatewayAddress; RouteEntry.ire_type = Type; RouteEntry.ire_proto = IRE_PROTO_LOCAL; RouteEntry.ire_age = 0; RouteEntry.ire_mask = DEFAULT_DEST_MASK; RouteEntry.ire_metric5 = (DWORD)(-1); RouteEntry.ire_context = NULL; Size = sizeof(RouteEntry); ID.toi_id = IP_MIB_RTTABLE_ENTRY_ID; Status = IopTCPSetInformationEx( Handle, &ID, &RouteEntry, Size ); if (!NT_SUCCESS(Status)) { KdPrint(( "IopSetDefaultGateway: Unable to set default gateway: %x\n", Status )); } NtClose(Handle); Handle = NULL; Cleanup: if (Handle != NULL) { NtClose(Handle); } if( AddrTable != NULL ) { ExFreePool( AddrTable ); } return Status; }

NTSTATUS IopSetupRemoteBootCard (  IN PLOADER_PARAMETER_BLOCK  LoaderBlock, IN HANDLE  UniqueIdHandle, IN PUNICODE_STRING  UnicodeDeviceInstance )

Definition at line 1982 of file netboot.c. References CmRegistryMachineSystemCurrentControlSet, CmRegistryMachineSystemCurrentControlSetControlClass, FALSE, IopOpenRegistryKey(), IopRemoteBootCardInitialized, L, _SETUP_LOADER_BLOCK::NetbootCardDriverName, _SETUP_LOADER_BLOCK::NetbootCardHardwareId, _SETUP_LOADER_BLOCK::NetbootCardInfo, _SETUP_LOADER_BLOCK::NetbootCardRegistry, _SETUP_LOADER_BLOCK::NetbootCardServiceName, NT_SUCCESS, NTSTATUS(), NULL, RtlAnsiStringToUnicodeString(), RtlEqualUnicodeString(), RtlInitAnsiString(), RtlInitString(), RtlInitUnicodeString(), strlen(), TITLE_INDEX_VALUE, and TRUE. Referenced by IopProcessNewDeviceNode(). 01990 : 01991 01992 This function modifies the registry to set up the netboot card. 01993 We must do this here since the card is needed to boot, we can't 01994 wait for the class installer to run. 01995 01996 THIS ASSUMES THAT IOREMOTEBOOTCLIENT IS TRUE. 01997 01998 Arguments: 01999 02000 LoaderBlock - Supplies a pointer to the loader parameter block that was 02001 created by the OS Loader. 02002 02003 UniqueIdHandle - A handle to the device's unique node under the 02004 Enum key. 02005 02006 UnicodeDeviceInstance - The device instance assigned to the device. 02007 02008 Return Value: 02009 02010 Status of the operation. 02011 02012 --*/ 02013 02014 { 02015 PSETUP_LOADER_BLOCK setupLoaderBlock; 02016 UNICODE_STRING unicodeName, pnpInstanceId, keyName; 02017 HANDLE tmpHandle; 02018 HANDLE parametersHandle = NULL; 02019 HANDLE currentControlSetHandle = NULL; 02020 HANDLE remoteBootHandle = NULL; 02021 HANDLE instanceHandle = NULL; 02022 PWCHAR componentIdBuffer, curComponentIdLoc; 02023 PCHAR registryList; 02024 ULONG componentIdLength; 02025 WCHAR tempNameBuffer[32]; 02026 WCHAR tempValueBuffer[128]; 02027 NTSTATUS status; 02028 ULONG tmpValue, length; 02029 PKEY_VALUE_PARTIAL_INFORMATION keyValue; 02030 PKEY_VALUE_BASIC_INFORMATION keyValueBasic; 02031 UCHAR dataBuffer[FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION, Data) + 128]; 02032 ULONG enumerateIndex; 02033 OBJECT_ATTRIBUTES objectAttributes; 02034 ULONG disposition; 02035 02036 // 02037 // If we already think we have initialized a remote boot card, then 02038 // exit (should not really happen once we identify cards using the 02039 // bus/slot. 02040 // 02041 02042 if (IopRemoteBootCardInitialized) { 02043 return STATUS_SUCCESS; 02044 } 02045 02046 // 02047 // setupLoaderBlock will always be non-NULL if we are 02048 // remote booting, even if we are not in setup. 02049 // 02050 02051 setupLoaderBlock = LoaderBlock->SetupLoaderBlock; 02052 02053 // 02054 // Open the current control set. 02055 // 02056 02057 status = IopOpenRegistryKey(&currentControlSetHandle, 02058 NULL, 02059 &CmRegistryMachineSystemCurrentControlSet, 02060 KEY_ALL_ACCESS, 02061 FALSE 02062 ); 02063 02064 if (!NT_SUCCESS(status)) { 02065 goto cleanup; 02066 } 02067 02068 // 02069 // Open the Control\RemoteBoot key, which may not exist. 02070 // 02071 02072 PiWstrToUnicodeString(&unicodeName, L"Control\\RemoteBoot"); 02073 02074 InitializeObjectAttributes(&objectAttributes, 02075 &unicodeName, 02076 OBJ_CASE_INSENSITIVE, 02077 currentControlSetHandle, 02078 (PSECURITY_DESCRIPTOR)NULL 02079 ); 02080 02081 status = ZwCreateKey(&remoteBootHandle, 02082 KEY_ALL_ACCESS, 02083 &objectAttributes, 02084 0, 02085 (PUNICODE_STRING)NULL, 02086 0, 02087 &disposition 02088 ); 02089 02090 if (!NT_SUCCESS(status)) { 02091 goto cleanup; 02092 } 02093 02094 // 02095 // Open the key where the netui code stores information about the cards. 02096 // During textmode setup this will fail because the Control\Network 02097 // key is not there. After that it should work, although we may need 02098 // to create the last node in the path. 02099 // 02100 02101 PiWstrToUnicodeString(&unicodeName, L"Control\\Network\\{4D36E972-E325-11CE-BFC1-08002BE10318}\\{54C7D140-09EF-11D1-B25A-F5FE627ED95E}"); 02102 02103 InitializeObjectAttributes(&objectAttributes, 02104 &unicodeName, 02105 OBJ_CASE_INSENSITIVE, 02106 currentControlSetHandle, 02107 (PSECURITY_DESCRIPTOR)NULL 02108 ); 02109 02110 status = ZwCreateKey(&instanceHandle, 02111 KEY_ALL_ACCESS, 02112 &objectAttributes, 02113 0, 02114 (PUNICODE_STRING)NULL, 02115 0, 02116 &disposition 02117 ); 02118 02119 if (NT_SUCCESS(status)) { 02120 02121 // 02122 // If the PnpInstanceID of the first netboot card matches the one 02123 // for this device node, and the NET_CARD_INFO that the loader 02124 // found is the same as the one we saved, then this is the same 02125 // card with the same instance ID as before, so we don't need to 02126 // do anything. 02127 // 02128 02129 PiWstrToUnicodeString(&unicodeName, L"PnPInstanceID"); 02130 keyValue = (PKEY_VALUE_PARTIAL_INFORMATION)dataBuffer; 02131 RtlZeroMemory(dataBuffer, sizeof(dataBuffer)); 02132 02133 status = ZwQueryValueKey( 02134 instanceHandle, 02135 &unicodeName, 02136 KeyValuePartialInformation, 02137 keyValue, 02138 sizeof(dataBuffer), 02139 &length); 02140 02141 // 02142 // Check that it matches. We can init the string because we zeroed 02143 // the dataBuffer before reading the key, so even if the 02144 // registry value had no NULL at the end that is OK. 02145 // 02146 02147 if ((NT_SUCCESS(status)) && 02148 (keyValue->Type == REG_SZ)) { 02149 02150 RtlInitUnicodeString(&pnpInstanceId, (PWSTR)(keyValue->Data)); 02151 02152 if (RtlEqualUnicodeString(UnicodeDeviceInstance, &pnpInstanceId, TRUE)) { 02153 02154 // 02155 // Instance ID matched, see if the NET_CARD_INFO matches. 02156 // 02157 02158 PiWstrToUnicodeString(&unicodeName, L"NetCardInfo"); 02159 RtlZeroMemory(dataBuffer, sizeof(dataBuffer)); 02160 02161 status = ZwQueryValueKey( 02162 remoteBootHandle, 02163 &unicodeName, 02164 KeyValuePartialInformation, 02165 keyValue, 02166 sizeof(dataBuffer), 02167 &length); 02168 02169 if ((NT_SUCCESS(status)) && 02170 (keyValue->Type == REG_BINARY) && 02171 (keyValue->DataLength == sizeof(NET_CARD_INFO)) && 02172 (memcmp(keyValue->Data, setupLoaderBlock->NetbootCardInfo, sizeof(NET_CARD_INFO)) == 0)) { 02173 02174 // 02175 // Everything matched, so no need to do any setup. 02176 // 02177 02178 status = STATUS_SUCCESS; 02179 goto cleanup; 02180 02181 } 02182 } 02183 } 02184 } 02185 02186 02187 // 02188 // We come through here if the saved registry data was missing or 02189 // not correct. Write all the relevant values to the registry. 02190 // 02191 02192 02193 // 02194 // Service name is in the loader block. 02195 // 02196 02197 PiWstrToUnicodeString(&unicodeName, REGSTR_VALUE_SERVICE); 02198 ZwSetValueKey(UniqueIdHandle, 02199 &unicodeName, 02200 TITLE_INDEX_VALUE, 02201 REG_SZ, 02202 setupLoaderBlock->NetbootCardServiceName, 02203 (wcslen(setupLoaderBlock->NetbootCardServiceName) + 1) * sizeof(WCHAR) 02204 ); 02205 02206 // 02207 // ClassGUID is the known net card GUID. 02208 // 02209 02210 PiWstrToUnicodeString(&unicodeName, REGSTR_VALUE_CLASSGUID); 02211 ZwSetValueKey(UniqueIdHandle, 02212 &unicodeName, 02213 TITLE_INDEX_VALUE, 02214 REG_SZ, 02215 L"{4D36E972-E325-11CE-BFC1-08002BE10318}", 02216 sizeof(L"{4D36E972-E325-11CE-BFC1-08002BE10318}") 02217 ); 02218 02219 // 02220 // Driver is the first net card. 02221 // 02222 02223 PiWstrToUnicodeString(&unicodeName, REGSTR_VALUE_DRIVER); 02224 ZwSetValueKey(UniqueIdHandle, 02225 &unicodeName, 02226 TITLE_INDEX_VALUE, 02227 REG_SZ, 02228 L"{4D36E972-E325-11CE-BFC1-08002BE10318}\\0000", 02229 sizeof(L"{4D36E972-E325-11CE-BFC1-08002BE10318}\\0000") 02230 ); 02231 02232 #ifdef REMOTE_BOOT 02233 // 02234 // Identify this as the netboot card so the network class 02235 // installer knows to assign the reserved GUID. 02236 // 02237 02238 PiWstrToUnicodeString(&unicodeName, REGSTR_VALUE_CONFIG_FLAGS); 02239 02240 keyValue = (PKEY_VALUE_PARTIAL_INFORMATION)dataBuffer; 02241 RtlZeroMemory(dataBuffer, sizeof(dataBuffer)); 02242 02243 status = ZwQueryValueKey(UniqueIdHandle, 02244 &unicodeName, 02245 KeyValuePartialInformation, 02246 keyValue, 02247 sizeof(dataBuffer), 02248 &length); 02249 02250 if ((NT_SUCCESS(status)) && 02251 (keyValue->Type == REG_DWORD)) { 02252 // 02253 // The ConfigFlags value exists in the registry 02254 // 02255 tmpValue = (*(PULONG)keyValue->Data) | CONFIGFLAG_NETBOOT_CARD; 02256 } else { 02257 tmpValue = CONFIGFLAG_NETBOOT_CARD; 02258 } 02259 02260 ZwSetValueKey(UniqueIdHandle, 02261 &unicodeName, 02262 TITLE_INDEX_VALUE, 02263 REG_DWORD, 02264 &tmpValue, 02265 sizeof(tmpValue) 02266 ); 02267 #endif 02268 02269 02270 // 02271 // Open a handle for card parameters. We write RemoteBootCard plus 02272 // whatever the BINL server told us to write. 02273 // 02274 02275 status = IopOpenRegistryKey(&tmpHandle, 02276 NULL, 02277 &CmRegistryMachineSystemCurrentControlSetControlClass, 02278 KEY_ALL_ACCESS, 02279 FALSE 02280 ); 02281 02282 if (!NT_SUCCESS(status)) { 02283 goto cleanup; 02284 } 02285 02286 PiWstrToUnicodeString(&unicodeName, L"{4D36E972-E325-11CE-BFC1-08002BE10318}\\0000"); 02287 02288 status = IopOpenRegistryKey(&parametersHandle, 02289 tmpHandle, 02290 &unicodeName, 02291 KEY_ALL_ACCESS, 02292 FALSE 02293 ); 02294 02295 ZwClose(tmpHandle); 02296 02297 if (!NT_SUCCESS(status)) { 02298 goto cleanup; 02299 } 02300 02301 // 02302 // We know that this is a different NIC, so remove all the old parameters. 02303 // 02304 02305 keyValueBasic = (PKEY_VALUE_BASIC_INFORMATION)dataBuffer; 02306 enumerateIndex = 0; 02307 02308 while (TRUE) { 02309 02310 RtlZeroMemory(dataBuffer, sizeof(dataBuffer)); 02311 02312 status = ZwEnumerateValueKey( 02313 parametersHandle, 02314 enumerateIndex, 02315 KeyValueBasicInformation, 02316 keyValueBasic, 02317 sizeof(dataBuffer), 02318 &length 02319 ); 02320 if (status == STATUS_NO_MORE_ENTRIES) { 02321 status = STATUS_SUCCESS; 02322 break; 02323 } 02324 02325 if (!NT_SUCCESS(status)) { 02326 goto cleanup; 02327 } 02328 02329 // 02330 // We don't delete "NetCfgInstanceID", it won't change and 02331 // its presence signifies to the net class installer that 02332 // this is a replacement not a clean install. 02333 // 02334 02335 if (_wcsicmp(keyValueBasic->Name, L"NetCfgInstanceID") != 0) { 02336 02337 RtlInitUnicodeString(&keyName, keyValueBasic->Name); 02338 status = ZwDeleteValueKey( 02339 parametersHandle, 02340 &keyName 02341 ); 02342 02343 if (!NT_SUCCESS(status)) { 02344 goto cleanup; 02345 } 02346 02347 } else { 02348 02349 enumerateIndex = 1; // leave NetCfgInstanceID at index 0 02350 } 02351 02352 } 02353 02354 // 02355 // Write a parameter called RemoteBootCard set to TRUE, this 02356 // is primarily so NDIS can recognize this as such. 02357 // 02358 02359 PiWstrToUnicodeString(&unicodeName, L"RemoteBootCard"); 02360 tmpValue = 1; 02361 ZwSetValueKey(parametersHandle, 02362 &unicodeName, 02363 TITLE_INDEX_VALUE, 02364 REG_DWORD, 02365 &tmpValue, 02366 sizeof(tmpValue) 02367 ); 02368 02369 02370 // 02371 // Store any other parameters sent from the server. 02372 // 02373 02374 registryList = setupLoaderBlock->NetbootCardRegistry; 02375 02376 if (registryList != NULL) { 02377 02378 STRING aString; 02379 UNICODE_STRING uString, uString2; 02380 02381 // 02382 // The registry list is a series of name\0type\0value\0, with 02383 // a final \0 at the end. It is in ANSI, not UNICODE. 02384 // 02385 // All values are stored under parametersHandle. Type is 1 for 02386 // DWORD and 2 for SZ. 02387 // 02388 02389 uString.Buffer = tempNameBuffer; 02390 uString.MaximumLength = sizeof(tempNameBuffer); 02391 02392 while (*registryList != '\0') { 02393 02394 // 02395 // First the name. 02396 // 02397 02398 RtlInitString(&aString, registryList); 02399 RtlAnsiStringToUnicodeString(&uString, &aString, FALSE); 02400 02401 // 02402 // Now the type. 02403 // 02404 02405 registryList += (strlen(registryList) + 1); 02406 02407 if (*registryList == '1') { 02408 02409 // 02410 // A DWORD, parse it. 02411 // 02412 02413 registryList += 2; // skip "1\0" 02414 tmpValue = 0; 02415 02416 while (*registryList != '\0') { 02417 tmpValue = (tmpValue * 10) + (*registryList - '0'); 02418 ++registryList; 02419 } 02420 02421 ZwSetValueKey(parametersHandle, 02422 &uString, 02423 TITLE_INDEX_VALUE, 02424 REG_DWORD, 02425 &tmpValue, 02426 sizeof(tmpValue) 02427 ); 02428 02429 registryList += (strlen(registryList) + 1); 02430 02431 } else if (*registryList == '2') { 02432 02433 // 02434 // An SZ, convert to Unicode. 02435 // 02436 02437 registryList += 2; // skip "2\0" 02438 02439 uString2.Buffer = tempValueBuffer; 02440 uString2.MaximumLength = sizeof(tempValueBuffer); 02441 RtlInitAnsiString(&aString, registryList); 02442 RtlAnsiStringToUnicodeString(&uString2, &aString, FALSE); 02443 02444 ZwSetValueKey(parametersHandle, 02445 &uString, 02446 TITLE_INDEX_VALUE, 02447 REG_SZ, 02448 uString2.Buffer, 02449 uString2.Length + sizeof(WCHAR) 02450 ); 02451 02452 registryList += (strlen(registryList) + 1); 02453 02454 } else { 02455 02456 // 02457 // Not "1" or "2", so stop processing registryList. 02458 // 02459 02460 break; 02461 02462 } 02463 02464 } 02465 02466 } 02467 02468 // 02469 // Save the NET_CARD_INFO so we can check it next time. 02470 // 02471 02472 PiWstrToUnicodeString(&unicodeName, L"NetCardInfo"); 02473 02474 ZwSetValueKey(remoteBootHandle, 02475 &unicodeName, 02476 TITLE_INDEX_VALUE, 02477 REG_BINARY, 02478 setupLoaderBlock->NetbootCardInfo, 02479 sizeof(NET_CARD_INFO) 02480 ); 02481 02482 02483 // 02484 // Save the hardware ID, driver name, and service name, 02485 // so the loader can read those if the server is down 02486 // on subsequent boots. 02487 // 02488 02489 PiWstrToUnicodeString(&unicodeName, L"HardwareId"); 02490 02491 ZwSetValueKey(remoteBootHandle, 02492 &unicodeName, 02493 TITLE_INDEX_VALUE, 02494 REG_SZ, 02495 setupLoaderBlock->NetbootCardHardwareId, 02496 (wcslen(setupLoaderBlock->NetbootCardHardwareId) + 1) * sizeof(WCHAR) 02497 ); 02498 02499 PiWstrToUnicodeString(&unicodeName, L"DriverName"); 02500 02501 ZwSetValueKey(remoteBootHandle, 02502 &unicodeName, 02503 TITLE_INDEX_VALUE, 02504 REG_SZ, 02505 setupLoaderBlock->NetbootCardDriverName, 02506 (wcslen(setupLoaderBlock->NetbootCardDriverName) + 1) * sizeof(WCHAR) 02507 ); 02508 02509 PiWstrToUnicodeString(&unicodeName, L"ServiceName"); 02510 02511 ZwSetValueKey(remoteBootHandle, 02512 &unicodeName, 02513 TITLE_INDEX_VALUE, 02514 REG_SZ, 02515 setupLoaderBlock->NetbootCardServiceName, 02516 (wcslen(setupLoaderBlock->NetbootCardServiceName) + 1) * sizeof(WCHAR) 02517 ); 02518 02519 // 02520 // Save the device instance, in case we need to ID the card later. 02521 // 02522 02523 PiWstrToUnicodeString(&unicodeName, L"DeviceInstance"); 02524 02525 ZwSetValueKey(remoteBootHandle, 02526 &unicodeName, 02527 TITLE_INDEX_VALUE, 02528 REG_SZ, 02529 UnicodeDeviceInstance->Buffer, 02530 UnicodeDeviceInstance->Length + sizeof(WCHAR) 02531 ); 02532 02533 // 02534 // Make sure we only pick one card to setup this way! 02535 // 02536 02537 IopRemoteBootCardInitialized = TRUE; 02538 02539 02540 cleanup: 02541 if (instanceHandle != NULL) { 02542 ZwClose(instanceHandle); 02543 } 02544 if (remoteBootHandle != NULL) { 02545 ZwClose(remoteBootHandle); 02546 } 02547 if (parametersHandle != NULL) { 02548 ZwClose(parametersHandle); 02549 } 02550 if (currentControlSetHandle != NULL) { 02551 ZwClose(currentControlSetHandle); 02552 } 02553 02554 return status; 02555 02556 }

NTSTATUS IopStartNetworkForRemoteBoot (  PLOADER_PARAMETER_BLOCK  LoaderBlock  )

Definition at line 770 of file netboot.c. References ASSERT, _SETUP_LOADER_BLOCK::DefaultRouter, ExAllocatePoolWithTag, ExFreePool(), FALSE, _SETUP_LOADER_BLOCK::Flags, IoGetCurrentProcess(), IopAssignNetworkDriveLetter(), IopCacheNetbiosNameForIpAddress(), IopSetDefaultGateway(), KeDelayExecutionThread(), KernelMode, L, max, MAX_PATH, _SETUP_LOADER_BLOCK::NetbootCardDriverName, _SETUP_LOADER_BLOCK::NetBootSecret, NonPagedPool, NT_SUCCESS, NtClose(), NtCreateFile(), NtDeviceIoControlFile(), NtFsControlFile(), NtOpenKey(), NtQueryValueKey(), NTSTATUS(), NULL, _EPROCESS::Pcb, RtlCreateUnicodeString(), RtlFreeUnicodeString(), RtlInitUnicodeString(), SETUPBLK_FLAGS_IS_TEXTMODE, _LOADER_PARAMETER_BLOCK::SetupLoaderBlock, and TRUE. Referenced by IoInitSystem(). { NTSTATUS status; HANDLE dgHandle; HANDLE keyHandle; OBJECT_ATTRIBUTES objectAttributes; IO_STATUS_BLOCK ioStatusBlock; UNICODE_STRING string; UNICODE_STRING computerName; UNICODE_STRING domainName; PUCHAR buffer; ULONG bufferLength; PLMR_REQUEST_PACKET rrp; PLMDR_REQUEST_PACKET drrp; WKSTA_INFO_502 wkstaConfig; WKSTA_TRANSPORT_INFO_0 wkstaTransportInfo; LARGE_INTEGER interval; ULONG length; PKEY_VALUE_PARTIAL_INFORMATION keyValue; BOOLEAN startDatagramReceiver; ULONG enumerateAttempts; #if defined(REMOTE_BOOT) PWSTR NetHDCSCPartition; BOOLEAN leaveRdrHandleOpen; BOOLEAN pinNetDriver; #else HANDLE RdrHandle; #endif // defined(REMOTE_BOOT) // // Initialize for cleanup. // buffer = NULL; computerName.Buffer = NULL; domainName.Buffer = NULL; dgHandle = NULL; RdrHandle = NULL; #if defined(REMOTE_BOOT) NetHDCSCPartition = NULL; leaveRdrHandleOpen = FALSE; pinNetDriver = FALSE; #endif // defined(REMOTE_BOOT) // // Allocate a temporary buffer. It has to be big enough for all the // various FSCTLs we send down. // bufferLength = max(sizeof(LMR_REQUEST_PACKET) + (MAX_PATH + 1) * sizeof(WCHAR) + (DNLEN + 1) * sizeof(WCHAR), max(sizeof(LMDR_REQUEST_PACKET), FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION, Data) + MAX_PATH)); bufferLength = max(bufferLength, sizeof(LMMR_RI_INITIALIZE_SECRET)); #if defined(REMOTE_BOOT) NetHDCSCPartition = ExAllocatePoolWithTag( NonPagedPool, (80 * sizeof(WCHAR)) + bufferLength, 'bRoI' ); if (NetHDCSCPartition == NULL) { KdPrint(( "IopStartNetworkForRemoteBoot: Unable to allocate buffer\n")); status = STATUS_INSUFFICIENT_RESOURCES; goto cleanup; } buffer = (PUCHAR)(NetHDCSCPartition + 80); #else buffer = ExAllocatePoolWithTag( NonPagedPool, bufferLength, 'bRoI' ); if (buffer == NULL) { KdPrint(( "IopStartNetworkForRemoteBoot: Unable to allocate buffer\n")); status = STATUS_INSUFFICIENT_RESOURCES; goto cleanup; } #endif // defined(REMOTE_BOOT) rrp = (PLMR_REQUEST_PACKET)buffer; drrp = (PLMDR_REQUEST_PACKET)buffer; // // Open the redirector and the datagram receiver. // RtlInitUnicodeString( &string, L"\\Device\\LanmanRedirector" ); InitializeObjectAttributes( &objectAttributes, &string, OBJ_CASE_INSENSITIVE, NULL, NULL ); status = NtCreateFile( &RdrHandle, GENERIC_READ | GENERIC_WRITE, &objectAttributes, &ioStatusBlock, NULL, 0, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, FILE_OPEN, FILE_SYNCHRONOUS_IO_NONALERT, NULL, 0 ); if ( !NT_SUCCESS(status) ) { KdPrint(( "IopStartNetworkForRemoteBoot: Unable to open redirector: %x\n", status )); goto cleanup; } #if defined(REMOTE_BOOT) RdrHandleProcess = &IoGetCurrentProcess()->Pcb; #endif // defined(REMOTE_BOOT) RtlInitUnicodeString( &string, DD_BROWSER_DEVICE_NAME_U ); InitializeObjectAttributes( &objectAttributes, &string, OBJ_CASE_INSENSITIVE, NULL, NULL ); status = NtCreateFile( &dgHandle, GENERIC_READ | GENERIC_WRITE, &objectAttributes, &ioStatusBlock, NULL, 0, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, FILE_OPEN, FILE_SYNCHRONOUS_IO_NONALERT, NULL, 0 ); if ( !NT_SUCCESS(status) ) { KdPrint(( "IopStartNetworkForRemoteBoot: Unable to open datagram receiver: %x\n", status )); goto cleanup; } // // If the setup loader block has a disk secret in it provided by the // loader, pass this down to the redirector (do this before sending // the LMR_START, since that uses this information). // #if defined(REMOTE_BOOT) if (LoaderBlock->SetupLoaderBlock->NetBootSecret) #endif // defined(REMOTE_BOOT) { PLMMR_RI_INITIALIZE_SECRET RbInit = (PLMMR_RI_INITIALIZE_SECRET)buffer; ASSERT(LoaderBlock->SetupLoaderBlock->NetBootSecret != NULL); RtlCopyMemory( &RbInit->Secret, LoaderBlock->SetupLoaderBlock->NetBootSecret, sizeof(RI_SECRET)); #if defined(REMOTE_BOOT) RbInit->UsePassword2 = LoaderBlock->SetupLoaderBlock->NetBootUsePassword2; #endif // defined(REMOTE_BOOT) status = NtFsControlFile( RdrHandle, NULL, NULL, NULL, &ioStatusBlock, FSCTL_LMMR_RI_INITIALIZE_SECRET, buffer, sizeof(LMMR_RI_INITIALIZE_SECRET), NULL, 0 ); if ( NT_SUCCESS(status) ) { status = ioStatusBlock.Status; } if ( !NT_SUCCESS(status) ) { KdPrint(( "IopStartNetworkForRemoteBoot: Unable to FSCTL(RB initialize) redirector: %x\n", status )); goto cleanup; } } // // Read the computer name and domain name from the registry so we // can give them to the datagram receiver. During textmode setup // the domain name will not be there, so we won't start the datagram // receiver, which is fine. // // BUGBUG: Figure out the correct location to read the domain name // from -- this one is a special hack in winnt.sif just for this. // RtlInitUnicodeString( &string, L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\ComputerName\\ComputerName" ); InitializeObjectAttributes( &objectAttributes, &string, OBJ_CASE_INSENSITIVE, NULL, NULL ); status = NtOpenKey( &keyHandle, KEY_ALL_ACCESS, &objectAttributes ); if ( !NT_SUCCESS(status) ) { KdPrint(( "IopStartNetworkForRemoteBoot: Unable to open ComputerName key: %x\n", status )); goto cleanup; } RtlInitUnicodeString( &string, L"ComputerName" ); keyValue = (PKEY_VALUE_PARTIAL_INFORMATION)buffer; RtlZeroMemory(buffer, bufferLength); status = NtQueryValueKey( keyHandle, &string, KeyValuePartialInformation, keyValue, bufferLength, &length); NtClose( keyHandle ); if ( !NT_SUCCESS(status) ) { KdPrint(( "IopStartNetworkForRemoteBoot: Unable to query ComputerName value: %x\n", status )); goto cleanup; } if ( !RtlCreateUnicodeString(&computerName, (PWSTR)keyValue->Data) ) { KdPrint(( "IopStartNetworkForRemoteBoot: Unable to create ComputerName string\n" )); status = STATUS_INSUFFICIENT_RESOURCES; goto cleanup; } domainName.Length = 0; RtlInitUnicodeString( &string, L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\ComputerName\\DomainName" ); InitializeObjectAttributes( &objectAttributes, &string, OBJ_CASE_INSENSITIVE, NULL, NULL ); status = NtOpenKey( &keyHandle, KEY_ALL_ACCESS, &objectAttributes ); if ( !NT_SUCCESS(status) ) { KdPrint(( "IopStartNetworkForRemoteBoot: Unable to open DomainName key: %x\n", status )); startDatagramReceiver = FALSE; } else { RtlInitUnicodeString( &string, L"DomainName" ); keyValue = (PKEY_VALUE_PARTIAL_INFORMATION)buffer; RtlZeroMemory(buffer, bufferLength); status = NtQueryValueKey( keyHandle, &string, KeyValuePartialInformation, keyValue, bufferLength, &length); NtClose( keyHandle ); if ( !NT_SUCCESS(status) ) { KdPrint(( "IopStartNetworkForRemoteBoot: Unable to query Domain value: %x\n", status )); startDatagramReceiver = FALSE; } else { if ( !RtlCreateUnicodeString(&domainName, (PWSTR)keyValue->Data) ) { KdPrint(( "IopStartNetworkForRemoteBoot: Unable to create DomainName string\n" )); status = STATUS_INSUFFICIENT_RESOURCES; goto cleanup; } startDatagramReceiver = TRUE; } } // // Tell the redir to start. // rrp->Type = ConfigInformation; rrp->Version = REQUEST_PACKET_VERSION; rrp->Parameters.Start.RedirectorNameLength = computerName.Length; RtlCopyMemory(rrp->Parameters.Start.RedirectorName, computerName.Buffer, computerName.Length); rrp->Parameters.Start.DomainNameLength = domainName.Length; RtlCopyMemory(((PUCHAR)rrp->Parameters.Start.RedirectorName) + computerName.Length, domainName.Buffer, domainName.Length); RtlFreeUnicodeString(&computerName); RtlFreeUnicodeString(&domainName); wkstaConfig.wki502_char_wait = 3600; wkstaConfig.wki502_maximum_collection_count = 16; wkstaConfig.wki502_collection_time = 250; wkstaConfig.wki502_keep_conn = 600; wkstaConfig.wki502_max_cmds = 5; wkstaConfig.wki502_sess_timeout = 45; wkstaConfig.wki502_siz_char_buf = 512; wkstaConfig.wki502_max_threads = 17; wkstaConfig.wki502_lock_quota = 6144; wkstaConfig.wki502_lock_increment = 10; wkstaConfig.wki502_lock_maximum = 500; wkstaConfig.wki502_pipe_increment = 10; wkstaConfig.wki502_pipe_maximum = 500; wkstaConfig.wki502_cache_file_timeout = 40; wkstaConfig.wki502_dormant_file_limit = 45; wkstaConfig.wki502_read_ahead_throughput = MAXULONG; wkstaConfig.wki502_num_mailslot_buffers = 3; wkstaConfig.wki502_num_srv_announce_buffers = 20; wkstaConfig.wki502_max_illegal_datagram_events = 5; wkstaConfig.wki502_illegal_datagram_event_reset_frequency = 60; wkstaConfig.wki502_log_election_packets = FALSE; wkstaConfig.wki502_use_opportunistic_locking = TRUE; wkstaConfig.wki502_use_unlock_behind = TRUE; wkstaConfig.wki502_use_close_behind = TRUE; wkstaConfig.wki502_buf_named_pipes = TRUE; wkstaConfig.wki502_use_lock_read_unlock = TRUE; wkstaConfig.wki502_utilize_nt_caching = TRUE; wkstaConfig.wki502_use_raw_read = TRUE; wkstaConfig.wki502_use_raw_write = TRUE; wkstaConfig.wki502_use_write_raw_data = TRUE; wkstaConfig.wki502_use_encryption = TRUE; wkstaConfig.wki502_buf_files_deny_write = TRUE; wkstaConfig.wki502_buf_read_only_files = TRUE; wkstaConfig.wki502_force_core_create_mode = TRUE; wkstaConfig.wki502_use_512_byte_max_transfer = FALSE; status = NtFsControlFile( RdrHandle, NULL, NULL, NULL, &ioStatusBlock, FSCTL_LMR_START | 0x80000000, rrp, sizeof(LMR_REQUEST_PACKET) + rrp->Parameters.Start.RedirectorNameLength + rrp->Parameters.Start.DomainNameLength, &wkstaConfig, sizeof(wkstaConfig) ); if ( NT_SUCCESS(status) ) { status = ioStatusBlock.Status; } if ( !NT_SUCCESS(status) ) { KdPrint(( "IopStartNetworkForRemoteBoot: Unable to FSCTL(start) redirector: %x\n", status )); goto cleanup; } if (startDatagramReceiver) { // // Tell the datagram receiver to start. // drrp->Version = LMDR_REQUEST_PACKET_VERSION; drrp->Parameters.Start.NumberOfMailslotBuffers = 16; drrp->Parameters.Start.NumberOfServerAnnounceBuffers = 20; drrp->Parameters.Start.IllegalDatagramThreshold = 5; drrp->Parameters.Start.EventLogResetFrequency = 60; drrp->Parameters.Start.LogElectionPackets = FALSE; drrp->Parameters.Start.IsLanManNt = FALSE; status = NtDeviceIoControlFile( dgHandle, NULL, NULL, NULL, &ioStatusBlock, IOCTL_LMDR_START, drrp, sizeof(LMDR_REQUEST_PACKET), NULL, 0 ); if ( NT_SUCCESS(status) ) { status = ioStatusBlock.Status; } NtClose( dgHandle ); dgHandle = NULL; if ( !NT_SUCCESS(status) ) { KdPrint(( "IopStartNetworkForRemoteBoot: Unable to IOCTL(start) datagram receiver: %x\n", status )); goto cleanup; } } else { NtClose( dgHandle ); dgHandle = NULL; // // Tell the redir to bind to the transports. // // Note: In the current redirector implementation, this call just // tells the redirector to register for TDI PnP notifications. // Starting the datagram receiver also does this, so we only issue // this FSCTL if we're not starting the datagram receiver. // status = NtFsControlFile( RdrHandle, NULL, NULL, NULL, &ioStatusBlock, FSCTL_LMR_BIND_TO_TRANSPORT | 0x80000000, NULL, 0, NULL, 0 ); if ( NT_SUCCESS(status) ) { status = ioStatusBlock.Status; } if ( !NT_SUCCESS(status) ) { KdPrint(( "IopStartNetworkForRemoteBoot: Unable to FSCTL(bind) redirector: %x\n", status )); goto cleanup; } } #if defined(REMOTE_BOOT) if (((LoaderBlock->SetupLoaderBlock->Flags & SETUPBLK_FLAGS_IS_TEXTMODE) == 0) && ((LoaderBlock->SetupLoaderBlock->Flags & SETUPBLK_FLAGS_FORMAT_NEEDED) == 0)) { // // Get the path to the boot partition on the disk for CSC and redirection // Note: On failure, this defaults to \Device\Harddisk0\Partition1 // IopGetHarddiskInfo(NetHDCSCPartition); // // Tell the redirector to initialize remote boot redirection (back // to the local disk). Note that we only do this if we're NOT doing // textmode setup. During textmode, we let Setup do this so that it // can do so AFTER it has reformatted the local disk. // status = NtFsControlFile( RdrHandle, NULL, NULL, NULL, &ioStatusBlock, FSCTL_LMR_START_RBR, NetHDCSCPartition, wcslen(NetHDCSCPartition) * sizeof(WCHAR), NULL, 0 ); if (NT_SUCCESS(status) ) { status = ioStatusBlock.Status; } if ( !NT_SUCCESS(status) ) { KdPrint(( "IopStartNetworkForRemoteBoot: Unable to FSCTL(RBR) redirector: %x\n", status )); } } if ( (LoaderBlock->SetupLoaderBlock->Flags & SETUPBLK_FLAGS_DISCONNECTED) == 0 ) #endif // defined(REMOTE_BOOT) { // // Loop until the redirector is bound to the transport. It may take a // while because TDI defers notification of binding to a worker thread. // We start with a half a second wait and double it each time, trying // five times total. // interval.QuadPart = -500 * 1000 * 10; // 1/2 second, relative enumerateAttempts = 0; while (TRUE) { KeDelayExecutionThread(KernelMode, FALSE, &interval); RtlZeroMemory(rrp, sizeof(LMR_REQUEST_PACKET)); rrp->Type = EnumerateTransports; rrp->Version = REQUEST_PACKET_VERSION; status = NtFsControlFile( RdrHandle, NULL, NULL, NULL, &ioStatusBlock, FSCTL_LMR_ENUMERATE_TRANSPORTS, rrp, sizeof(LMR_REQUEST_PACKET), &wkstaTransportInfo, sizeof(wkstaTransportInfo) ); if ( NT_SUCCESS(status) ) { status = ioStatusBlock.Status; } if ( !NT_SUCCESS(status) ) { //KdPrint(( "IopStartNetworkForRemoteBoot: Unable to FSCTL(enumerate) redirector: %x\n", status )); } else if (rrp->Parameters.Get.TotalBytesNeeded == 0) { //KdPrint(( "IopStartNetworkForRemoteBoot: FSCTL(enumerate) returned 0 entries\n" )); } else { break; } ++enumerateAttempts; if (enumerateAttempts == 5) { KdPrint(( "IopStartNetworkForRemoteBoot: Redirector didn't start\n" )); status = STATUS_REDIRECTOR_NOT_STARTED; goto cleanup; } interval.QuadPart *= 2; } } // // Prime the transport. // #if defined(REMOTE_BOOT) IopEnableRemoteBootSecurity(LoaderBlock); #endif // defined(REMOTE_BOOT) IopSetDefaultGateway(LoaderBlock->SetupLoaderBlock->DefaultRouter); IopCacheNetbiosNameForIpAddress(LoaderBlock); #if defined(REMOTE_BOOT) // // CSC needs to be initialized after binding to the transport because ResetCSC // (if needed) will try to enumerate the files and directories on the server. // if (((LoaderBlock->SetupLoaderBlock->Flags & SETUPBLK_FLAGS_IS_TEXTMODE) == 0) && ((LoaderBlock->SetupLoaderBlock->Flags & SETUPBLK_FLAGS_FORMAT_NEEDED) == 0) #if 0 && ((LoaderBlock->SetupLoaderBlock->Flags & SETUPBLK_FLAGS_DISABLE_CSC) != 0) #endif ) { wcstombs(buffer, NetHDCSCPartition, wcslen(NetHDCSCPartition) + 1); strcat(buffer, REMOTE_BOOT_IMIRROR_PATH_A REMOTE_BOOT_CSC_SUBDIR_A); status = IopInitCsc( buffer ); // // If we are connected and either we are part way through a reset of // the csc or the init failed then reset the csc. // if ( NT_SUCCESS(status) ) { if (StartCsc == FLUSH_CSC ) { if ((LoaderBlock->SetupLoaderBlock->Flags & SETUPBLK_FLAGS_DISCONNECTED) == 0) { // // CSC may have lost the pin information. // status = IopResetCsc( buffer ); if ( !NT_SUCCESS(status) ) { KdPrint(("IopStartNetworkForRemoteBoot: reset of Csc failed %x\n", status)); } } else { IoCscInitializationFailed = TRUE; } } else if ((LoaderBlock->SetupLoaderBlock->Flags & SETUPBLK_FLAGS_PIN_NET_DRIVER) && (LoaderBlock->SetupLoaderBlock->NetbootCardDriverName[0] != L'\0')) { // // if we are connected and we're not repinning all files and // we have a new net card driver to pin, then pin it below // after we've created called IopAssignNetworkDriveLetter // pinNetDriver = TRUE; } } if ( !NT_SUCCESS(status) ) { KdPrint(("IopStartNetworkForRemoteBoot: initialization of Csc failed %x\n", status)); IoCscInitializationFailed = TRUE; SharedUserData->SystemFlags |= SYSTEM_FLAG_DISKLESS_CLIENT; } } else { IoCscInitializationFailed = TRUE; SharedUserData->SystemFlags |= SYSTEM_FLAG_DISKLESS_CLIENT; } #endif // defined(REMOTE_BOOT) IopAssignNetworkDriveLetter(LoaderBlock); #if defined(REMOTE_BOOT) if (pinNetDriver) { // // Pin the new net card driver simply by opening it. if it // fails, it's not fatal, as we'll eventually pin it since // the directory it's in is marked as system/inherit. // HANDLE driverHandle = NULL; PWCHAR fullDriverName; fullDriverName = (PWCHAR) ExAllocatePoolWithTag( NonPagedPool, sizeof( L"\\SystemRoot\\System32\\Drivers\\" ) + sizeof( LoaderBlock->SetupLoaderBlock->NetbootCardDriverName ), 'bRoI' ); if (fullDriverName != NULL) { wcscpy(fullDriverName, L"\\SystemRoot\\System32\\Drivers\\"); wcscat(fullDriverName, LoaderBlock->SetupLoaderBlock->NetbootCardDriverName); RtlInitUnicodeString( &string, fullDriverName ); InitializeObjectAttributes( &objectAttributes, &string, OBJ_CASE_INSENSITIVE, NULL, NULL ); status = NtCreateFile( &driverHandle, GENERIC_READ, &objectAttributes, &ioStatusBlock, NULL, FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ, FILE_OPEN, FILE_SYNCHRONOUS_IO_NONALERT, NULL, 0 ); if ( !NT_SUCCESS(status) ) { // // this is not a fatal error, the redir should pin it eventually // KdPrint(( "IopStartNetworkForRemoteBoot: Unable to open new net driver: 0x%x\n", status )); } if (driverHandle != NULL) { NtClose( driverHandle ); } ExFreePool( fullDriverName ); } else { // // this is not a fatal error, the redir should pin it eventually // KdPrint(( "IopStartNetworkForRemoteBoot: Unable to allocate buffer to pin netcard driver\n" )); } } leaveRdrHandleOpen = TRUE; #endif // defined(REMOTE_BOOT) cleanup: RtlFreeUnicodeString( &computerName ); RtlFreeUnicodeString( &domainName ); #if defined(REMOTE_BOOT) if ( NetHDCSCPartition != NULL ) { ExFreePool( NetHDCSCPartition ); } #else if ( buffer != NULL ) { ExFreePool( buffer ); } #endif // defined(REMOTE_BOOT) if ( dgHandle != NULL ) { NtClose( dgHandle ); } #if defined(REMOTE_BOOT) // // If requested, exit with RdrHandle still set so that we can close CSC quickly. // if ( !leaveRdrHandleOpen && (RdrHandle != NULL) ) { NtClose( RdrHandle ); RdrHandle = NULL; } #endif // defined(REMOTE_BOOT) return status; }

NTSTATUS IopStartTcpIpForRemoteBoot (  PLOADER_PARAMETER_BLOCK  LoaderBlock  )

Definition at line 1834 of file netboot.c. References _SETUP_LOADER_BLOCK::IpAddress, NT_SUCCESS, NtClose(), NtCreateFile(), NtDeviceIoControlFile(), NTSTATUS(), NULL, RtlInitUnicodeString(), _LOADER_PARAMETER_BLOCK::SetupLoaderBlock, _SETUP_LOADER_BLOCK::SubnetMask, and USHORT. Referenced by IopInitializeBootDrivers(). { UNICODE_STRING IpString; NTSTATUS status = STATUS_SUCCESS; HANDLE handle; OBJECT_ATTRIBUTES objectAttributes; IO_STATUS_BLOCK ioStatusBlock; IP_SET_ADDRESS_REQUEST IpRequest; RtlInitUnicodeString( &IpString, DD_IP_DEVICE_NAME ); InitializeObjectAttributes( &objectAttributes, &IpString, OBJ_CASE_INSENSITIVE, NULL, NULL ); IpRequest.Context = (USHORT)2; IpRequest.Address = LoaderBlock->SetupLoaderBlock->IpAddress; IpRequest.SubnetMask = LoaderBlock->SetupLoaderBlock->SubnetMask; status = NtCreateFile( &handle, GENERIC_READ | GENERIC_WRITE, &objectAttributes, &ioStatusBlock, NULL, 0, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, FILE_OPEN, FILE_SYNCHRONOUS_IO_NONALERT, NULL, 0 ); if ( !NT_SUCCESS(status) ) { KdPrint(( "IopStartTcpIpForRemoteBoot: Unable to open IP: %x\n", status )); goto cleanup; } status = NtDeviceIoControlFile( handle, NULL, NULL, NULL, &ioStatusBlock, IOCTL_IP_SET_ADDRESS_DUP, &IpRequest, sizeof(IP_SET_ADDRESS_REQUEST), NULL, 0 ); NtClose( handle ); if ( !NT_SUCCESS(status) ) { KdPrint(( "IopStartTcpIpForRemoteBoot: Unable to IOCTL IP: %x\n", status )); goto cleanup; } cleanup: return status; }

NTSTATUS IopTCPQueryInformationEx (  IN HANDLE  TCPHandle, IN TDIObjectID FAR *  ID, OUT void FAR *  Buffer, IN OUT DWORD FAR *  BufferSize, IN OUT BYTE FAR *  Context )

Definition at line 4377 of file netboot.c. References ASSERT, Buffer, BufferSize, DWORD, ID, NT_SUCCESS, NtDeviceIoControlFile(), NTSTATUS(), and NULL. Referenced by IopSetDefaultGateway(). : This routine provides the interface to the TDI QueryInformationEx facility of the TCP/IP stack on NT. Someday, this facility will be part of TDI. Arguments: TCPHandle - Open handle to the TCP driver ID - The TDI Object ID to query Buffer - Data buffer to contain the query results BufferSize - Pointer to the size of the results buffer. Filled in with the amount of results data on return. Context - Context value for the query. Should be zeroed for a new query. It will be filled with context information for linked enumeration queries. Return Value: An NTSTATUS value. --*/ { TCP_REQUEST_QUERY_INFORMATION_EX queryBuffer; DWORD queryBufferSize; NTSTATUS status; IO_STATUS_BLOCK ioStatusBlock; if (TCPHandle == NULL) { return(STATUS_INVALID_PARAMETER); } queryBufferSize = sizeof(TCP_REQUEST_QUERY_INFORMATION_EX); memcpy(&(queryBuffer.ID), ID, sizeof(TDIObjectID)); memcpy(&(queryBuffer.Context), Context, CONTEXT_SIZE); status = NtDeviceIoControlFile( TCPHandle, // Driver handle NULL, // Event NULL, // APC Routine NULL, // APC context &ioStatusBlock, // Status block IOCTL_TCP_QUERY_INFORMATION_EX, // Control code &queryBuffer, // Input buffer queryBufferSize, // Input buffer size Buffer, // Output buffer *BufferSize // Output buffer size ); ASSERT( status != STATUS_PENDING ); if ( NT_SUCCESS(status) ) { status = ioStatusBlock.Status; } if (status == STATUS_SUCCESS) { // // Copy the return context to the caller's context buffer // memcpy(Context, &(queryBuffer.Context), CONTEXT_SIZE); *BufferSize = (ULONG)ioStatusBlock.Information; status = ioStatusBlock.Status; } else { *BufferSize = 0; } return(status); }

NTSTATUS IopTCPSetInformationEx (  IN HANDLE  TCPHandle, IN TDIObjectID FAR *  ID, IN void FAR *  Buffer, IN DWORD FAR  BufferSize )

Definition at line 4458 of file netboot.c. References ASSERT, Buffer, BufferSize, DWORD, ExAllocatePoolWithTag, ExFreePool(), ID, NT_SUCCESS, NtDeviceIoControlFile(), NTSTATUS(), NULL, and PagedPool. Referenced by IopSetDefaultGateway(). 04466 : 04467 04468 This routine provides the interface to the TDI SetInformationEx 04469 facility of the TCP/IP stack on NT. Someday, this facility will be 04470 part of TDI. 04471 04472 Arguments: 04473 04474 TCPHandle - Open handle to the TCP driver 04475 ID - The TDI Object ID to set 04476 Buffer - Data buffer containing the information to be set 04477 BufferSize - The size of the set data buffer. 04478 04479 Return Value: 04480 04481 An NTSTATUS value. 04482 04483 --*/ 04484 04485 { 04486 PTCP_REQUEST_SET_INFORMATION_EX setBuffer; 04487 NTSTATUS status; 04488 IO_STATUS_BLOCK ioStatusBlock; 04489 DWORD setBufferSize; 04490 04491 04492 if (TCPHandle == NULL) { 04493 return(STATUS_INVALID_PARAMETER); 04494 } 04495 04496 setBufferSize = FIELD_OFFSET(TCP_REQUEST_SET_INFORMATION_EX, Buffer) + BufferSize; 04497 04498 setBuffer = ExAllocatePoolWithTag(PagedPool, setBufferSize, 'bRoI'); 04499 04500 if (setBuffer == NULL) { 04501 return(STATUS_INSUFFICIENT_RESOURCES); 04502 } 04503 04504 setBuffer->BufferSize = BufferSize; 04505 04506 memcpy(&(setBuffer->ID), ID, sizeof(TDIObjectID)); 04507 04508 memcpy(&(setBuffer->Buffer[0]), Buffer, BufferSize); 04509 04510 status = NtDeviceIoControlFile( 04511 TCPHandle, // Driver handle 04512 NULL, // Event 04513 NULL, // APC Routine 04514 NULL, // APC context 04515 &ioStatusBlock, // Status block 04516 IOCTL_TCP_SET_INFORMATION_EX, // Control code 04517 setBuffer, // Input buffer 04518 setBufferSize, // Input buffer size 04519 NULL, // Output buffer 04520 0 // Output buffer size 04521 ); 04522 04523 ASSERT( status != STATUS_PENDING ); 04524 if ( NT_SUCCESS(status) ) { 04525 status = ioStatusBlock.Status; 04526 } 04527 04528 ExFreePool(setBuffer); 04529 04530 return(status); 04531 }

NTSTATUS IopWriteIpAddressToRegistry (  HANDLE  handle, PWCHAR  regkey, PUCHAR  value )

Definition at line 3974 of file netboot.c. References CHAR, FALSE, NT_SUCCESS, NtSetValueKey(), NTSTATUS(), RtlAnsiStringToUnicodeString(), RtlInitAnsiString(), RtlInitUnicodeString(), and sprintf(). Referenced by IopAddRemoteBootValuesToRegistry(). { NTSTATUS status; UNICODE_STRING string; CHAR addressA[16]; WCHAR addressW[16]; STRING addressStringA; UNICODE_STRING addressStringW; RtlInitUnicodeString( &string, regkey ); sprintf(addressA, "%d.%d.%d.%d", value[0], value[1], value[2], value[3]); RtlInitAnsiString(&addressStringA, addressA); addressStringW.Buffer = addressW; addressStringW.MaximumLength = sizeof(addressW); RtlAnsiStringToUnicodeString(&addressStringW, &addressStringA, FALSE); status = NtSetValueKey( handle, &string, 0, REG_MULTI_SZ, addressW, addressStringW.Length + sizeof(WCHAR) ); if ( !NT_SUCCESS(status) ) { KdPrint(( "IopWriteIpAddressToRegistry: Unable to set %ws value: %x\n", regkey, status )); } return status; }

---

Variable Documentation

BOOLEAN ExpInTextModeSetup

Definition at line 53 of file netboot.c.

---