OS_Develop/Windows-Server-2003
OS_Develop/Windows-Server-2003
1
0
Fork 0
Code Pull Requests Activity
7507d3c0e1
Windows-Server-2003/base/boot/tftplib/helper.c

1227 lines
37 KiB
C
Raw Normal View History

Initiall commit
2024-08-04 01:28:15 +02:00
/*++
Copyright (c) 1997 Microsoft Corporation
Module Name:
helper.c
Abstract:
Helper functions for the loader.
Author:
Adam Barr (adamba) Aug 29, 1997
Revision History:
Who When What
-------- -------- ----------------------------------------------
adamba 08-29-97 created
Notes:
--*/
#include "precomp.h"
#pragma hdrstop
#include <pxe_cmn.h>
#include <pxe_api.h>
#include <undi_api.h>
#include <ntexapi.h>
#ifdef EFI
#define BINL_PORT 0x0FAB // 4011 (decimal) in little-endian
#else
#define BINL_PORT 0xAB0F // 4011 (decimal) in big-endian
#endif
//
// This removes macro redefinitions which appear because we define __RPC_DOS__,
// but rpc.h defines __RPC_WIN32__
//
#pragma warning(disable:4005)
//
// As of 12/17/98, SECURITY_DOS is *not* defined - adamba
//
#if defined(SECURITY_DOS)
//
// These appear because we defined SECURITY_DOS
//
#define __far
#define __pascal
#define __loadds
#endif
#include <security.h>
#include <rpc.h>
#include <spseal.h>
#ifdef EFI
#include "bldr.h"
#include "efi.h"
#include "efip.h"
#include "bldria64.h"
#include "extern.h"
extern EFI_HANDLE EfiImageHandle;
#endif
#if defined(SECURITY_DOS)
//
// PSECURITY_STRING is not supposed to be used when SECURITY_DOS is
// defined -- it should be a WCHAR*. Unfortunately ntlmsp.h breaks
// this rule and even uses the SECURITY_STRING structure, which there
// is really no equivalent for in 16-bit mode.
//
typedef SEC_WCHAR * SECURITY_STRING; // more-or-less the intention where it is used
typedef SEC_WCHAR * PSECURITY_STRING;
#endif
#include <ntlmsp.h>
extern ULONG TftpSecurityHandle;
extern CtxtHandle TftpClientContextHandle;
extern BOOLEAN TftpClientContextHandleValid;
//
// From conn.c.
//
ULONG
ConnItoa (
IN ULONG Value,
OUT PUCHAR Buffer
);
ULONG
ConnSafeAtol (
IN PUCHAR Buffer,
IN PUCHAR BufferEnd
);
// for now, we pull the hack mac list and code so that we only support new ROMs
#ifdef EFI
#pragma pack(1)
typedef struct {
UINT16 VendorId;
UINT16 DeviceId;
UINT16 Command;
UINT16 Status;
UINT8 RevisionID;
UINT8 ClassCode[3];
UINT8 CacheLineSize;
UINT8 LaytencyTimer;
UINT8 HeaderType;
UINT8 BIST;
} PCI_DEVICE_INDEPENDENT_REGION;
typedef struct {
UINT32 Bar[6];
UINT32 CISPtr;
UINT16 SubsystemVendorID;
UINT16 SubsystemID;
UINT32 ExpansionRomBar;
UINT32 Reserved[2];
UINT8 InterruptLine;
UINT8 InterruptPin;
UINT8 MinGnt;
UINT8 MaxLat;
} PCI_DEVICE_HEADER_TYPE_REGION;
typedef struct {
PCI_DEVICE_INDEPENDENT_REGION Hdr;
PCI_DEVICE_HEADER_TYPE_REGION Device;
} PCI_TYPE00;
typedef struct {
UINT32 Bar[2];
UINT8 PrimaryBus;
UINT8 SecondaryBus;
UINT8 SubordinateBus;
UINT8 SecondaryLatencyTimer;
UINT8 IoBase;
UINT8 IoLimit;
UINT16 SecondaryStatus;
UINT16 MemoryBase;
UINT16 MemoryLimit;
UINT16 PrefetchableMemoryBase;
UINT16 PrefetchableMemoryLimit;
UINT32 PrefetchableBaseUpper32;
UINT32 PrefetchableLimitUpper32;
UINT16 IoBaseUpper16;
UINT16 IoLimitUpper16;
UINT32 Reserved;
UINT32 ExpansionRomBAR;
UINT8 InterruptLine;
UINT8 InterruptPin;
UINT16 BridgeControl;
} PCI_BRIDGE_CONTROL_REGISTER;
typedef struct {
PCI_DEVICE_INDEPENDENT_REGION Hdr;
PCI_BRIDGE_CONTROL_REGISTER Bridge;
} PCI_TYPE01;
NTSTATUS
GetBusNumberFromAcpiPath(
IN EFI_DEVICE_IO_INTERFACE *DeviceIo,
IN UINTN UID,
IN UINTN HID,
OUT UINT16 *BusNumber
)
/*++
Routine Description:
Given an ACPI UID and HID, find the bus # corresponding to this data.
Arguments:
DeviceIo - pointer to device io interface.
UID - unique id for acpi device
HID - hardware id for acpi device
BusNumber - receives bus # for device if found.
This entire routine runs in physical mode.
Return Value:
STATUS_SUCCESS
STATUS_UNSUCCESSFUL
--*/
{
EFI_STATUS SegStatus = EFI_SUCCESS;
EFI_STATUS BusStatus = EFI_SUCCESS;
UINT32 Seg;
UINT8 Bus;
UINT64 PciAddress;
EFI_DEVICE_PATH *PciDevicePath;
EFI_DEVICE_PATH_ALIGNED DevicePathAligned;
NTSTATUS ReturnCode = STATUS_UNSUCCESSFUL;
//
// walk through every segment and every bus looking for a bus that matches
// the UID/HID that we're looking for.
//
for (Seg=0;!EFI_ERROR (SegStatus);Seg++) {
PciAddress = Seg << 32;
SegStatus = DeviceIo->PciDevicePath(DeviceIo, PciAddress, &PciDevicePath);
if (!EFI_ERROR (SegStatus)) {
//
// Segment exists
//
for (Bus=0;!EFI_ERROR (BusStatus);Bus++) {
PciAddress = (Seg << 32) | (Bus << 24);
BusStatus = DeviceIo->PciDevicePath(DeviceIo, PciAddress, &PciDevicePath);
//
// Bus exists
//
if (!EFI_ERROR (BusStatus)) {
EfiAlignDp(
&DevicePathAligned,
PciDevicePath,
DevicePathNodeLength(PciDevicePath) );
//
// now see if the acpi device path for the bus matches the UID
// and HID passed in.
//
while ( DevicePathAligned.DevPath.Type != END_DEVICE_PATH_TYPE) {
if ( (DevicePathAligned.DevPath.Type == ACPI_DEVICE_PATH) &&
(DevicePathAligned.DevPath.SubType == ACPI_DP)) {
ACPI_HID_DEVICE_PATH *AcpiDevicePath;
AcpiDevicePath = (ACPI_HID_DEVICE_PATH *)&DevicePathAligned;
if (AcpiDevicePath->UID == UID &&
AcpiDevicePath->HID == HID) {
//
// success. return bus number.
//
*BusNumber = Bus;
ReturnCode = STATUS_SUCCESS;
goto exit;
}
}
//
// Get the next structure in our packed array.
//
PciDevicePath = NextDevicePathNode( PciDevicePath );
EfiAlignDp(&DevicePathAligned,
PciDevicePath,
DevicePathNodeLength(PciDevicePath));
}
}
}
}
}
exit:
return(ReturnCode);
}
NTSTATUS
NetQueryCardInfo(
IN OUT PNET_CARD_INFO CardInfo
)
/*++
Routine Description:
This routine queries the ROM for information about the card.
Arguments:
CardInfo - returns the structure defining the card.
Return Value:
STATUS_SUCCESS
STATUS_UNSUCCESSFUL
--*/
{
EFI_STATUS Status = EFI_UNSUPPORTED;
EFI_DEVICE_PATH *DevicePath = NULL;
EFI_DEVICE_PATH *OriginalRootDevicePath = NULL;
EFI_DEVICE_PATH_ALIGNED DevicePathAligned;
UINT16 BusNumber = 0;
UINT8 DeviceNumber = 0;
UINT8 FunctionNumber = 0;
BOOLEAN FoundACPIDevice = FALSE;
BOOLEAN FoundPCIDevice = FALSE;
EFI_GUID DeviceIoProtocol = DEVICE_IO_PROTOCOL;
EFI_GUID EFIPciIoProtocol = EFI_PCI_IO_PROTOCOL;
EFI_HANDLE MyHandle;
EFI_DEVICE_IO_INTERFACE *IoDev;
EFI_LOADED_IMAGE *EfiImageInfo;
EFI_PCI_IO_INTERFACE *PciIoDev;
EFI_HANDLE PciIoHandle;
UINT16 SegmentNumber = 0;
UINTN Seg = 0;
UINTN Bus = 0;
UINTN Dev = 0;
UINTN Func = 0;
UINTN HID;
UINTN UID;
BOOLEAN PciIoProtocolSupported = TRUE;
RtlZeroMemory(CardInfo, sizeof(NET_CARD_INFO));
//
// Get the image info for the loader
//
FlipToPhysical();
Status = EfiST->BootServices->HandleProtocol (EfiImageHandle,
&EfiLoadedImageProtocol,
&EfiImageInfo);
FlipToVirtual();
if (Status != EFI_SUCCESS)
{
if( BdDebuggerEnabled ) {
DbgPrint( "NetQueryCardInfo: HandleProtocol failed -LoadedImageProtocol (%d)\n", Status);
}
return (NTSTATUS)Status;
}
//
// get the device path to the image
//
FlipToPhysical();
Status = EfiST->BootServices->HandleProtocol (EfiImageInfo->DeviceHandle,
&EfiDevicePathProtocol,
&DevicePath);
FlipToVirtual();
if (Status != EFI_SUCCESS)
{
if( BdDebuggerEnabled ) {
DbgPrint( "NetQueryCardInfo: HandleProtocol failed -DevicePathProtocol (%d)\n", Status);
}
return (NTSTATUS)Status;
}
FlipToPhysical();
EfiAlignDp( &DevicePathAligned,
DevicePath,
DevicePathNodeLength(DevicePath));
Status = EfiST->BootServices->LocateDevicePath ( &EFIPciIoProtocol,
&DevicePath,
&PciIoHandle);
FlipToVirtual();
//
// we may be on an older system that doesn't support the pci io
// protocol
//
if (Status != EFI_SUCCESS) {
PciIoProtocolSupported = FALSE;
}
//
// Save off this root DevicePath in case we need it later.
//
OriginalRootDevicePath = DevicePath;
//
// Now we need to read the PCI header information from the specific
// card.
//
//
// use the pci io protocol if it's supported to get the bus dev func for
// the card.
//
if (PciIoProtocolSupported) {
FlipToPhysical();
Status = EfiST->BootServices->HandleProtocol (PciIoHandle,
&EFIPciIoProtocol,
&PciIoDev);
FlipToVirtual();
if (Status != EFI_SUCCESS)
{
if( BdDebuggerEnabled ) {
DbgPrint( "NetQueryCardInfo: HandleProtocol failed -EFIPciIoProtocol (%d)\n", Status);
}
return (NTSTATUS)Status;
}
// find the location of the device - segment, bus, dev and func
FlipToPhysical();
Status = PciIoDev->GetLocation(PciIoDev,
&Seg,
&Bus,
&Dev,
&Func );
SegmentNumber = (UINT16)Seg;
BusNumber = (UINT16)Bus;
DeviceNumber = (UINT8)Dev;
FunctionNumber = (UINT8)Func;
FlipToVirtual();
if (Status != EFI_SUCCESS)
{
if( BdDebuggerEnabled ) {
DbgPrint( "NetQueryCardInfo: EfiPciIo failed -GetLocation (%d)\n", Status);
}
return (NTSTATUS)Status;
}
FoundPCIDevice = TRUE;
FoundACPIDevice = TRUE;
}
//
// if the pci io protocol is not supported we do it the old way.
// this involves walking the device path till we get to the device.
// note that we make a questionable assumption here, that the UID for
// the acpi device path is really the bus number. it works on some
// machines, but the pci io protocol is better as it removes this
// assumption.
//
// AcpiDevicePath = (ACPI_HID_DEVICE_PATH *)&DevicePathAligned;
// BusNumber = AcpiDevicePath->UID
//
// PciDevicePath = (PCI_DEVICE_PATH *)&DevicePathAligned;
// DeviceNumber = PciDevicePath->Device
// FunctionNumber = PciDevicePath->Function
//
if (!PciIoProtocolSupported) {
FlipToPhysical();
Status = EfiST->BootServices->LocateDevicePath ( &DeviceIoProtocol,
&DevicePath,
&MyHandle);
if (Status != EFI_SUCCESS) {
FlipToVirtual();
if( BdDebuggerEnabled ) {
DbgPrint( "NetQueryCardInfo: LocateDevicePath failed -IoProtocol (%d)\n", Status);
}
return (NTSTATUS)Status;
}
Status = EfiST->BootServices->HandleProtocol(
MyHandle,
&DeviceIoProtocol,
&IoDev);
if (Status != EFI_SUCCESS) {
FlipToVirtual();
if( BdDebuggerEnabled ) {
DbgPrint( "NetQueryCardInfo: HandleProtocol failed -IoProtocol (%d)\n", Status);
}
return (NTSTATUS)Status;
}
while( DevicePathAligned.DevPath.Type != END_DEVICE_PATH_TYPE) {
if( (DevicePathAligned.DevPath.Type == ACPI_DEVICE_PATH) &&
(DevicePathAligned.DevPath.SubType == ACPI_DP) &&
(FoundACPIDevice == FALSE)) {
//
// We'll find the BusNumber here.
//
ACPI_HID_DEVICE_PATH *AcpiDevicePath;
AcpiDevicePath = (ACPI_HID_DEVICE_PATH *)&DevicePathAligned;
UID = AcpiDevicePath->UID;
HID = AcpiDevicePath->HID;
Status = (NTSTATUS)GetBusNumberFromAcpiPath(IoDev, UID,HID, &BusNumber);
FoundACPIDevice = TRUE;
if (! NT_SUCCESS(Status)) {
FlipToVirtual();
if (BdDebuggerEnabled) {
DbgPrint( "NetQueryCardInfo: GetBusNumberFromAcpiPath failed (%x)\n", Status);
}
Status = ENODEV;
return (NTSTATUS)Status;
}
}
if( (DevicePathAligned.DevPath.Type == HARDWARE_DEVICE_PATH) &&
(DevicePathAligned.DevPath.SubType == HW_PCI_DP) ) {
//
// We'll find DeviceNumber and FunctionNumber here.
//
PCI_DEVICE_PATH *PciDevicePath;
if ( FoundPCIDevice ) {
//
// we have already found a PCI device. that device must have
// been a bridge. we must find the new bus # on the downstream
// side of the bridge
//
UINT64 BridgeAddress;
PCI_TYPE01 PciBridge;
EFI_DEVICE_PATH *BridgeDevicePath;
//
// Get a Handle for the device
//
BridgeDevicePath = OriginalRootDevicePath;
Status = EfiST->BootServices->LocateDevicePath( &DeviceIoProtocol,
&BridgeDevicePath,
&MyHandle );
if( Status != EFI_SUCCESS ) {
FlipToVirtual();
if (BdDebuggerEnabled) {
DbgPrint( "NetQueryCardInfo: LocateDevicePath(bridge) failed (%x)\n", Status);
}
return (NTSTATUS)Status;
}
Status = EfiST->BootServices->HandleProtocol( MyHandle,
&DeviceIoProtocol,
(VOID*)&IoDev );
if( Status != EFI_SUCCESS ) {
FlipToVirtual();
if (BdDebuggerEnabled) {
DbgPrint( "NetQueryCardInfo: HandleProtocol(bridge) failed (%X)\n", Status);
}
return (NTSTATUS)Status;
}
//
// Generate the address, then read the PCI header from the device.
//
BridgeAddress = EFI_PCI_ADDRESS( BusNumber, DeviceNumber, FunctionNumber );
RtlZeroMemory(&PciBridge, sizeof(PCI_TYPE01));
Status = IoDev->Pci.Read( IoDev,
IO_UINT32,
BridgeAddress,
sizeof(PCI_TYPE01) / sizeof(UINT32),
&PciBridge );
if( Status != EFI_SUCCESS ) {
FlipToVirtual();
if (BdDebuggerEnabled) {
DbgPrint( "NetQueryCardInfo: Pci.Read(bridge) failed (%X)\r\n", Status);
}
return (NTSTATUS)Status;
}
//
// Bridges are requred to store 3 registers. the PrimaryBus, SecondaryBus and
// SubordinateBus. The PrimaryBus is the Bus number on the upstream side of
// the bridge. The SecondaryBus is the Bus number on the downstream side
// and the SubordinateBus is the greatest bus number that can be reached through
// the particular bus. we simply want to change BusNumber to the SecondaryBus
//
BusNumber = (UINT16) PciBridge.Bridge.SecondaryBus;
}
PciDevicePath = (PCI_DEVICE_PATH *)&DevicePathAligned;
DeviceNumber = PciDevicePath->Device;
FunctionNumber = PciDevicePath->Function;
FoundPCIDevice = TRUE;
}
//
// Get the next structure in our packed array.
//
DevicePath = NextDevicePathNode( DevicePath );
EfiAlignDp(&DevicePathAligned,
DevicePath,
DevicePathNodeLength(DevicePath));
}
FlipToVirtual();
}
//
// Derive the function pointer that will allow us to read from
// PCI space.
//
DevicePath = OriginalRootDevicePath;
FlipToPhysical();
Status = EfiST->BootServices->LocateDevicePath( &DeviceIoProtocol,
&DevicePath,
&MyHandle );
FlipToVirtual();
if( Status != EFI_SUCCESS ) {
if (BdDebuggerEnabled) {
DbgPrint( "NetQueryCardInfo: LocateDevicePath failed (%X)\n", Status);
}
return (NTSTATUS)Status;
}
FlipToPhysical();
Status = EfiST->BootServices->HandleProtocol( MyHandle,
&DeviceIoProtocol,
(VOID*)&IoDev );
FlipToVirtual();
if( Status != EFI_SUCCESS ) {
if (BdDebuggerEnabled) {
DbgPrint( "NetQueryCardInfo: HandleProtocol(2) failed (%X)\n", Status);
}
return (NTSTATUS)Status;
}
//
// We've got the Bus, Device, and Function number for this device. Go read
// his header (with the PCI-Read function that we just derived) and get
// the information we're after.
//
if( FoundPCIDevice && FoundACPIDevice ) {
UINT64 Address;
PCI_TYPE00 Pci;
if (BdDebuggerEnabled) {
DbgPrint( "NetQueryCardInfo: Found all the config info for the device.\n" );
DbgPrint( " BusNumber: %d DeviceNumber: %d FunctionNumber: %d\n", BusNumber, DeviceNumber, FunctionNumber );
}
//
// Generate the address, then read the PCI header from the device.
//
Address = EFI_PCI_ADDRESS( BusNumber, DeviceNumber, FunctionNumber );
RtlZeroMemory(&Pci, sizeof(PCI_TYPE00));
FlipToPhysical();
Status = IoDev->Pci.Read( IoDev,
IO_UINT32,
Address,
sizeof(PCI_TYPE00) / sizeof(UINT32),
&Pci );
FlipToVirtual();
if( Status != EFI_SUCCESS ) {
if (BdDebuggerEnabled) {
DbgPrint( "NetQueryCardInfo: Pci.Read failed (%X)\n", Status);
}
return (NTSTATUS)Status;
}
//
// It all worked. Copy the information from the device into
// the CardInfo structure and exit.
//
CardInfo->NicType = 2; // He's PCI
CardInfo->pci.Vendor_ID = Pci.Hdr.VendorId;
CardInfo->pci.Dev_ID = Pci.Hdr.DeviceId;
CardInfo->pci.Rev = Pci.Hdr.RevisionID;
// BusDevFunc is defined as 16 bits built as follows:
// 15-8 --------------------------- Bus Number
// 7-3 ----------------------- Device Number
// 2-0 ------------------- Function Number
CardInfo->pci.BusDevFunc = ((BusNumber & 0xFF) << 8);
CardInfo->pci.BusDevFunc |= ((DeviceNumber & 0x1F) << 3);
CardInfo->pci.BusDevFunc |= (FunctionNumber & 0x7);
// SubSys_ID is actually ((SubsystemID << 16) | SubsystemVendorID)
CardInfo->pci.Subsys_ID = Pci.Device.SubsystemID;
CardInfo->pci.Subsys_ID = (CardInfo->pci.Subsys_ID << 16) | (Pci.Device.SubsystemVendorID);
#if DBG
if (BdDebuggerEnabled) {
DbgPrint( "\n" );
DbgPrint( "NetQueryCardInfo: Pci.Hdr.VendorId %x\n", Pci.Hdr.VendorId );
DbgPrint( " Pci.Hdr.DeviceId %x\n", Pci.Hdr.DeviceId );
DbgPrint( " Pci.Hdr.Command %x\n", Pci.Hdr.Command );
DbgPrint( " Pci.Hdr.Status %x\n", Pci.Hdr.Status );
DbgPrint( " Pci.Hdr.RevisionID %x\n", Pci.Hdr.RevisionID );
DbgPrint( " Pci.Hdr.HeaderType %x\n", Pci.Hdr.HeaderType );
DbgPrint( " Pci.Hdr.BIST %x\n", Pci.Hdr.BIST );
DbgPrint( " Pci.Device.SubsystemVendorID %x\n", Pci.Device.SubsystemVendorID );
DbgPrint( " Pci.Device.SubsystemID %x\n", Pci.Device.SubsystemID );
DbgPrint( "\n" );
DbgPrint( "NetQueryCardInfo: CardInfo->NicType %x\n", CardInfo->NicType );
DbgPrint( " CardInfo->pci.Vendor_ID %x\n", CardInfo->pci.Vendor_ID );
DbgPrint( " CardInfo->pci.Dev_ID %x\n", CardInfo->pci.Dev_ID );
DbgPrint( " CardInfo->pci.Rev %x\n", CardInfo->pci.Rev );
DbgPrint( " CardInfo->pci.Subsys_ID %x\n", CardInfo->pci.Subsys_ID );
DbgPrint( "\n" );
}
#endif
Status = STATUS_SUCCESS;
} else {
if (BdDebuggerEnabled) {
DbgPrint( "NetQueryCardInfo: Failed to find all the config info for the device.\n" );
}
Status = STATUS_UNSUCCESSFUL;
}
return (NTSTATUS)Status;
}
#else
NTSTATUS
NetQueryCardInfo(
IN OUT PNET_CARD_INFO CardInfo
)
/*++
Routine Description:
This routine queries the ROM for information about the card.
Arguments:
CardInfo - returns the structure defining the card.
Return Value:
STATUS_SUCCESS
STATUS_UNSUCCESSFUL
--*/
{
ULONG status;
t_PXENV_UNDI_GET_NIC_TYPE nicType;
RtlZeroMemory(CardInfo, sizeof(NET_CARD_INFO));
status = RomGetNicType( &nicType );
if ((status != PXENV_EXIT_SUCCESS) || (nicType.Status != PXENV_EXIT_SUCCESS)) {
#if DBG
DbgPrint( "RomGetNicType returned 0x%x, nicType.Status = 0x%x. Time to upgrade your netcard ROM\n",
status, nicType.Status );
#endif
status = STATUS_UNSUCCESSFUL;
} else {
#if DBG
if ( nicType.NicType == 2 ) {
DbgPrint( "Vendor_ID: %04x, Dev_ID: %04x\n",
nicType.pci_pnp_info.pci.Vendor_ID,
nicType.pci_pnp_info.pci.Dev_ID );
DbgPrint( "Base_Class: %02x, Sub_Class: %02x, Prog_Intf: %02x\n",
nicType.pci_pnp_info.pci.Base_Class,
nicType.pci_pnp_info.pci.Sub_Class,
nicType.pci_pnp_info.pci.Prog_Intf );
DbgPrint( "Rev: %02x, BusDevFunc: %04x, SubSystem: %04x\n",
nicType.pci_pnp_info.pci.Rev,
nicType.pci_pnp_info.pci.BusDevFunc,
nicType.pci_pnp_info.pci.Subsys_ID );
} else {
DbgPrint( "NicType: 0x%x EISA_Dev_ID: %08x\n",
nicType.NicType,
nicType.pci_pnp_info.pnp.EISA_Dev_ID );
DbgPrint( "Base_Class: %02x, Sub_Class: %02x, Prog_Intf: %02x\n",
nicType.pci_pnp_info.pnp.Base_Class,
nicType.pci_pnp_info.pnp.Sub_Class,
nicType.pci_pnp_info.pnp.Prog_Intf );
DbgPrint( "CardSelNum: %04x\n",
nicType.pci_pnp_info.pnp.CardSelNum );
}
#endif
//
// The call worked, so copy the information.
//
CardInfo->NicType = nicType.NicType;
if (nicType.NicType == 2) {
CardInfo->pci.Vendor_ID = nicType.pci_pnp_info.pci.Vendor_ID;
CardInfo->pci.Dev_ID = nicType.pci_pnp_info.pci.Dev_ID;
CardInfo->pci.Base_Class = nicType.pci_pnp_info.pci.Base_Class;
CardInfo->pci.Sub_Class = nicType.pci_pnp_info.pci.Sub_Class;
CardInfo->pci.Prog_Intf = nicType.pci_pnp_info.pci.Prog_Intf;
CardInfo->pci.Rev = nicType.pci_pnp_info.pci.Rev;
CardInfo->pci.BusDevFunc = nicType.pci_pnp_info.pci.BusDevFunc;
CardInfo->pci.Subsys_ID = nicType.pci_pnp_info.pci.Subsys_ID;
status = STATUS_SUCCESS;
} else {
status = STATUS_UNSUCCESSFUL;
}
}
return status;
}
#endif // EFI
NTSTATUS
UdpSendAndReceiveForNetQuery(
IN PVOID SendBuffer,
IN ULONG SendBufferLength,
IN ULONG SendRemoteHost,
IN USHORT SendRemotePort,
IN ULONG SendRetryCount,
IN PVOID ReceiveBuffer,
IN ULONG ReceiveBufferLength,
IN ULONG ReceiveTimeout,
IN ULONG ReceiveSignatureCount,
IN PCHAR ReceiveSignatures[]
)
{
ULONG i, j;
ULONG length;
ULONG RemoteHost;
USHORT RemotePort;
//
// Try sending the packet SendRetryCount times, until we receive
// a response with the right signature, waiting ReceiveTimeout
// each time.
//
for (i = 0; i < SendRetryCount; i++) {
length = UdpSend(
SendBuffer,
SendBufferLength,
SendRemoteHost,
SendRemotePort);
if ( length != SendBufferLength ) {
DbgPrint("UdpSend only sent %d bytes, not %d\n", length, SendBufferLength);
return STATUS_UNEXPECTED_NETWORK_ERROR;
}
ReReceive:
//
// NULL out the first 12 bytes in case we get shorter data.
//
memset(ReceiveBuffer, 0x0, 12);
length = UdpReceive(
ReceiveBuffer,
ReceiveBufferLength,
&RemoteHost,
&RemotePort,
ReceiveTimeout);
if ( length == 0 ) {
DPRINT( ERROR, ("UdpReceive timed out\n") );
continue;
}
//
// Make sure the signature is one of the ones we expect.
//
for (j = 0; j < ReceiveSignatureCount; j++) {
if (memcmp(ReceiveBuffer, ReceiveSignatures[j], 4) == 0) {
return STATUS_SUCCESS;
}
}
DbgPrint("UdpReceive got wrong signature\n");
// ISSUE NTRAID #60513: CLEAN THIS UP -- but the idea is not to UdpSend
// again just because we got a bad signature. Still need to respect the
// original ReceiveTimeout however!
goto ReReceive;
}
//
// We timed out.
//
return STATUS_IO_TIMEOUT;
}
#define NETCARD_REQUEST_RESPONSE_BUFFER_SIZE 4096
NTSTATUS
NetQueryDriverInfo(
IN PNET_CARD_INFO CardInfo,
IN PCHAR SetupPath,
IN PCHAR NtBootPathName,
IN OUT PWCHAR HardwareId,
IN ULONG HardwareIdLength,
IN OUT PWCHAR DriverName,
IN OUT PCHAR DriverNameAnsi OPTIONAL,
IN ULONG DriverNameLength,
IN OUT PWCHAR ServiceName,
IN ULONG ServiceNameLength,
OUT PCHAR * Registry,
OUT ULONG * RegistryLength
)
/*++
Routine Description:
This routine does an exchange with the server to get information
about the card described by CardInfo.
Arguments:
CardInfo - Information about the card.
SetupPath - UNC path (with only a single leading backslash) to our setup directory
NtBootPathName - UNC path (with only a single leading backslash) to our boot directory
HardwareId - returns the hardware ID of the card.
HardwareIdLength - the length (in bytes) of the passed-in HardwareId buffer.
DriverName - returns the name of the driver.
DriverNameAnsi - if present, returns the name of the driver in ANSI.
DriverNameLength - the length (in bytes) of the passed-in DriverName buffer
(it is assumed that DriverNameAnsi is at least half this length).
ServiceName - returns the service key of the driver.
ServiceNameLength - the length (in bytes) of the passed-in ServiceName buffer.
Registry - if needed, allocates and returns extra registry parameters
for the card.
RegistryLength - the length of Registry.
Return Value:
STATUS_SUCCESS
STATUS_BUFFER_OVERFLOW if either of the buffers are too small.
STATUS_INSUFFICIENT_RESOURCES if we cannot allocate memory for Registry.
STATUS_IO_TIMEOUT if we can't get a response from the server.
--*/
{
NTSTATUS Status;
USHORT localPort;
PNETCARD_REQUEST_PACKET requestPacket;
PCHAR ReceiveSignatures[2];
PCHAR ReceiveBuffer;
ULONG GuidLength;
PUCHAR Guid;
ULONG sendSize;
PNETCARD_REQUEST_PACKET allocatedRequestPacket = NULL;
ARC_STATUS ArcStatus;
//
// Get the local UDP port.
//
localPort = UdpUnicastDestinationPort;
//
// Construct the outgoing packet. Also allocate memory for
// the receive packet.
//
sendSize = sizeof(NETCARD_REQUEST_PACKET) +
((SetupPath) ? (strlen(SetupPath) + 1) : 0);
requestPacket = BlAllocateHeap( sendSize );
if (requestPacket == NULL) {
Status = STATUS_BUFFER_OVERFLOW;
goto done;
}
ReceiveBuffer = BlAllocateHeap( NETCARD_REQUEST_RESPONSE_BUFFER_SIZE );
if (ReceiveBuffer == NULL) {
Status = STATUS_BUFFER_OVERFLOW;
goto done;
}
RtlCopyMemory(requestPacket->Signature, NetcardRequestSignature, sizeof(requestPacket->Signature));
requestPacket->Length = sizeof(NETCARD_REQUEST_PACKET) - FIELD_OFFSET(NETCARD_REQUEST_PACKET, Version);
requestPacket->Version = OSCPKT_NETCARD_REQUEST_VERSION;
#if defined(_IA64_)
requestPacket->Architecture = PROCESSOR_ARCHITECTURE_IA64;
#endif
#if defined(_X86_)
requestPacket->Architecture = PROCESSOR_ARCHITECTURE_INTEL;
#endif
requestPacket->SetupDirectoryLength = SetupPath ? (strlen( SetupPath ) + 1) : 0;
if (requestPacket->SetupDirectoryLength) {
requestPacket->SetupDirectoryPath[0] = '\\';
strcpy( &requestPacket->SetupDirectoryPath[1], SetupPath );
}
ArcStatus = GetGuid(&Guid, &GuidLength);
if (ArcStatus != ESUCCESS) {
//
// normalize the error and exit.
//
switch (ArcStatus) {
case ENOMEM:
Status = STATUS_NO_MEMORY;
goto done;
break;
case ENODEV:
Status = STATUS_OBJECT_NAME_NOT_FOUND;
goto done;
break;
default:
Status = STATUS_UNSUCCESSFUL;
goto done;
break;
}
}
if (GuidLength == sizeof(requestPacket->Guid)) {
memcpy(requestPacket->Guid, Guid, GuidLength);
}
RtlCopyMemory(&requestPacket->CardInfo, CardInfo, sizeof(NET_CARD_INFO));
ReceiveSignatures[0] = NetcardResponseSignature;
ReceiveSignatures[1] = NetcardErrorSignature;
Status = UdpSendAndReceiveForNetQuery(
requestPacket,
sendSize,
NetServerIpAddress,
BINL_PORT,
100, // retry count
ReceiveBuffer,
NETCARD_REQUEST_RESPONSE_BUFFER_SIZE,
60, // receive timeout... may have to parse INF files
2,
ReceiveSignatures
);
if (Status == STATUS_SUCCESS) {
PWCHAR stringInPacket;
ULONG maxOffset;
UNICODE_STRING uString;
ULONG len;
PNETCARD_RESPONSE_PACKET responsePacket;
responsePacket = (PNETCARD_RESPONSE_PACKET)ReceiveBuffer;
if (responsePacket->Status != STATUS_SUCCESS) {
Status = responsePacket->Status;
goto done;
}
if (responsePacket->Length < sizeof( NETCARD_RESPONSE_PACKET )) {
Status = STATUS_UNSUCCESSFUL;
goto done;
}
//
// The exchange succeeded, so copy the results back.
//
maxOffset = NETCARD_REQUEST_RESPONSE_BUFFER_SIZE -
sizeof( NETCARD_RESPONSE_PACKET );
if (responsePacket->HardwareIdOffset < sizeof(NETCARD_RESPONSE_PACKET) ||
responsePacket->HardwareIdOffset >= maxOffset ) {
Status = STATUS_BUFFER_OVERFLOW;
goto done;
}
//
// pick up the hardwareId string. It's given to us as an offset
// within the packet to a unicode null terminated string.
//
stringInPacket = (PWCHAR)(PCHAR)((PCHAR)responsePacket +
responsePacket->HardwareIdOffset );
RtlInitUnicodeString( &uString, stringInPacket );
if (uString.Length + sizeof(WCHAR) > HardwareIdLength) {
Status = STATUS_BUFFER_OVERFLOW;
goto done;
}
RtlCopyMemory( HardwareId, uString.Buffer, uString.Length + sizeof(WCHAR));
//
// pick up the driverName string. It's given to us as an offset
// within the packet to a unicode null terminated string.
//
stringInPacket = (PWCHAR)(PCHAR)((PCHAR)responsePacket +
responsePacket->DriverNameOffset );
RtlInitUnicodeString( &uString, stringInPacket );
if (uString.Length + sizeof(WCHAR) > DriverNameLength) {
Status = STATUS_BUFFER_OVERFLOW;
goto done;
}
RtlCopyMemory( DriverName, uString.Buffer, uString.Length + sizeof(WCHAR));
//
// we convert this one into ansi if the caller requested
//
if (ARGUMENT_PRESENT(DriverNameAnsi)) {
RtlUnicodeToMultiByteN( DriverNameAnsi,
DriverNameLength,
NULL,
uString.Buffer,
uString.Length + sizeof(WCHAR));
}
//
// pick up the serviceName string. It's given to us as an offset
// within the packet to a unicode null terminated string.
//
stringInPacket = (PWCHAR)(PCHAR)((PCHAR)responsePacket +
responsePacket->ServiceNameOffset );
RtlInitUnicodeString( &uString, stringInPacket );
if (uString.Length + sizeof(WCHAR) > ServiceNameLength) {
Status = STATUS_BUFFER_OVERFLOW;
goto done;
}
RtlCopyMemory( ServiceName, uString.Buffer, uString.Length + sizeof(WCHAR));
//
// If any extra registry params were passed back, allocate/copy those.
//
*RegistryLength = responsePacket->RegistryLength;
if (*RegistryLength) {
*Registry = BlAllocateHeap(*RegistryLength);
if (*Registry == NULL) {
Status = STATUS_INSUFFICIENT_RESOURCES;
goto done;
}
stringInPacket = (PWCHAR)(PCHAR)((PCHAR)responsePacket +
responsePacket->RegistryOffset );
RtlCopyMemory(*Registry, stringInPacket, *RegistryLength);
} else {
*Registry = NULL;
}
}
done:
if (requestPacket) {
//
// we would free this memory
// if the loader had a free routine
//
// free(requestPacket);
}
return Status;
}
Copy Permalink