diff options
| author | vanjeff <vanjeff@6f19259b-4bc3-4df7-8a09-765794883524> | 2008-01-04 02:29:30 +0000 |
|---|---|---|
| committer | vanjeff <vanjeff@6f19259b-4bc3-4df7-8a09-765794883524> | 2008-01-04 02:29:30 +0000 |
| commit | dc361cc5a04657ddc8c74bd8f044f7ad30c4118a (patch) | |
| tree | 03af8f70c486a2c0eff924045afb18da768c22d8 /MdeModulePkg/Universal/Network/UefiPxeBcDxe/PxeBcDhcp.c | |
| parent | 822360ee34e8b3e9274f371bc6cc020181851af6 (diff) | |
| download | edk2-dc361cc5a04657ddc8c74bd8f044f7ad30c4118a.zip edk2-dc361cc5a04657ddc8c74bd8f044f7ad30c4118a.tar.gz edk2-dc361cc5a04657ddc8c74bd8f044f7ad30c4118a.tar.bz2 | |
1. Import UEFI PxeBc module in MdeModulePkg
2. Remove some SMBIOS definitions defined in PxeBc module, use those who are defined in MdePkg.
git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@4495 6f19259b-4bc3-4df7-8a09-765794883524
Diffstat (limited to 'MdeModulePkg/Universal/Network/UefiPxeBcDxe/PxeBcDhcp.c')
| -rw-r--r-- | MdeModulePkg/Universal/Network/UefiPxeBcDxe/PxeBcDhcp.c | 1746 |
1 files changed, 1746 insertions, 0 deletions
diff --git a/MdeModulePkg/Universal/Network/UefiPxeBcDxe/PxeBcDhcp.c b/MdeModulePkg/Universal/Network/UefiPxeBcDxe/PxeBcDhcp.c new file mode 100644 index 0000000..b76461a --- /dev/null +++ b/MdeModulePkg/Universal/Network/UefiPxeBcDxe/PxeBcDhcp.c @@ -0,0 +1,1746 @@ +/** @file
+
+Copyright (c) 2007, Intel Corporation
+All rights reserved. This program and the accompanying materials
+are licensed and made available under the terms and conditions of the BSD License
+which accompanies this distribution. The full text of the license may be found at
+http://opensource.org/licenses/bsd-license.php
+
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+Module Name:
+
+ PxeBcDhcp.c
+
+Abstract:
+
+ Support for PxeBc dhcp functions
+
+
+**/
+
+
+#include "PxeBcImpl.h"
+
+//
+// This is a map from the interested DHCP4 option tags' index to the tag value.
+//
+UINT8 mInterestedDhcp4Tags[PXEBC_DHCP4_TAG_INDEX_MAX] = {
+ PXEBC_DHCP4_TAG_BOOTFILE_LEN,
+ PXEBC_DHCP4_TAG_VENDOR,
+ PXEBC_DHCP4_TAG_OVERLOAD,
+ PXEBC_DHCP4_TAG_MSG_TYPE,
+ PXEBC_DHCP4_TAG_SERVER_ID,
+ PXEBC_DHCP4_TAG_CLASS_ID,
+ PXEBC_DHCP4_TAG_BOOTFILE
+};
+
+
+/**
+ GC_NOTO: Add function description
+
+ @param Seed GC_NOTO: add argument description
+ @param Udp4 GC_NOTO: add argument description
+
+ @return GC_NOTO: add return values
+
+**/
+VOID
+PxeBcInitSeedPacket (
+ IN EFI_DHCP4_PACKET *Seed,
+ IN EFI_UDP4_PROTOCOL *Udp4
+ )
+{
+ EFI_SIMPLE_NETWORK_MODE Mode;
+ EFI_DHCP4_HEADER *Header;
+
+ Udp4->GetModeData (Udp4, NULL, NULL, NULL, &Mode);
+
+ Seed->Size = sizeof (EFI_DHCP4_PACKET);
+ Seed->Length = sizeof (Seed->Dhcp4);
+
+ Header = &Seed->Dhcp4.Header;
+
+ NetZeroMem (Header, sizeof (EFI_DHCP4_HEADER));
+ Header->OpCode = PXEBC_DHCP4_OPCODE_REQUEST;
+ Header->HwType = Mode.IfType;
+ Header->HwAddrLen = (UINT8) Mode.HwAddressSize;
+ NetCopyMem (Header->ClientHwAddr, &Mode.CurrentAddress, Header->HwAddrLen);
+
+ Seed->Dhcp4.Magik = PXEBC_DHCP4_MAGIC;
+ Seed->Dhcp4.Option[0] = PXEBC_DHCP4_TAG_EOP;
+}
+
+
+/**
+ GC_NOTO: Add function description
+
+ @param Dst GC_NOTO: add argument description
+ @param Src GC_NOTO: add argument description
+
+ @return GC_NOTO: add return values
+
+**/
+VOID
+PxeBcCopyEfiDhcp4Packet (
+ IN EFI_DHCP4_PACKET *Dst,
+ IN EFI_DHCP4_PACKET *Src
+ )
+{
+ ASSERT (Dst->Size >= Src->Length);
+
+ NetCopyMem (&Dst->Dhcp4, &Src->Dhcp4, Src->Length);
+ Dst->Length = Src->Length;
+}
+
+
+/**
+ GC_NOTO: Add function description
+
+ @param Private GC_NOTO: add argument description
+ @param OfferIndex GC_NOTO: add argument description
+
+ @return GC_NOTO: add return values
+
+**/
+VOID
+PxeBcCopyProxyOffer (
+ IN PXEBC_PRIVATE_DATA *Private,
+ IN UINT32 OfferIndex
+ )
+{
+ EFI_PXE_BASE_CODE_MODE *Mode;
+ EFI_DHCP4_PACKET *Offer;
+
+ ASSERT (OfferIndex < Private->NumOffers);
+
+ Mode = Private->PxeBc.Mode;
+ Offer = &Private->Dhcp4Offers[OfferIndex].Packet.Offer;
+
+ PxeBcCopyEfiDhcp4Packet (&Private->ProxyOffer.Packet.Offer, Offer);
+ NetCopyMem (&Mode->ProxyOffer, &Offer->Dhcp4, Offer->Length);
+ Mode->ProxyOfferReceived = TRUE;
+
+ PxeBcParseCachedDhcpPacket (&Private->ProxyOffer);
+}
+
+
+/**
+ Parse the cached dhcp packet.
+
+ @param CachedPacket Pointer to cached dhcp packet
+
+ @return TRUE : Success to parse and validation
+ @return FALSE : Fail to parse or validation
+
+**/
+BOOLEAN
+PxeBcParseCachedDhcpPacket (
+ IN PXEBC_CACHED_DHCP4_PACKET *CachedPacket
+ )
+{
+ EFI_DHCP4_PACKET *Offer;
+ EFI_DHCP4_PACKET_OPTION **Options;
+ EFI_DHCP4_PACKET_OPTION *Option;
+ UINT8 OfferType;
+ UINTN Index;
+
+ CachedPacket->IsPxeOffer = FALSE;
+ NetZeroMem (CachedPacket->Dhcp4Option, sizeof (CachedPacket->Dhcp4Option));
+ NetZeroMem (&CachedPacket->PxeVendorOption, sizeof (CachedPacket->PxeVendorOption));
+
+ Offer = &CachedPacket->Packet.Offer;
+ Options = CachedPacket->Dhcp4Option;
+
+ //
+ // Parse interested dhcp options and store their pointers in CachedPacket->Dhcp4Option.
+ //
+ for (Index = 0; Index < PXEBC_DHCP4_TAG_INDEX_MAX; Index++) {
+ Options[Index] = PxeBcParseExtendOptions (
+ Offer->Dhcp4.Option,
+ GET_OPTION_BUFFER_LEN (Offer),
+ mInterestedDhcp4Tags[Index]
+ );
+ }
+
+ //
+ // Check whether is an offer with PXEClient or not.
+ //
+ Option = Options[PXEBC_DHCP4_TAG_INDEX_CLASS_ID];
+ if ((Option != NULL) && (Option->Length >= 9) &&
+ (NetCompareMem (Option->Data, DEFAULT_CLASS_ID_DATA, 9) == 0)) {
+
+ CachedPacket->IsPxeOffer = TRUE;
+ }
+
+ //
+ // Parse pxe vendor options and store their content/pointers in CachedPacket->PxeVendorOption.
+ //
+ Option = Options[PXEBC_DHCP4_TAG_INDEX_VENDOR];
+ if (CachedPacket->IsPxeOffer && (Option != NULL)) {
+
+ if (!PxeBcParseVendorOptions (Option, &CachedPacket->PxeVendorOption)) {
+ return FALSE;
+ }
+ }
+
+ //
+ // Check whether bootfilename/serverhostname overloaded (See details in dhcp spec).
+ // If overloaded, parse this buffer as nested dhcp options, or just parse bootfilename/
+ // serverhostname option.
+ //
+ Option = Options[PXEBC_DHCP4_TAG_INDEX_OVERLOAD];
+ if ((Option != NULL) && (Option->Data[0] & PXEBC_DHCP4_OVERLOAD_FILE)) {
+
+ Options[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] = PxeBcParseExtendOptions (
+ (UINT8 *) Offer->Dhcp4.Header.BootFileName,
+ sizeof (Offer->Dhcp4.Header.BootFileName),
+ PXEBC_DHCP4_TAG_BOOTFILE
+ );
+
+ } else if ((Options[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] == NULL) &&
+ (Offer->Dhcp4.Header.BootFileName[0] != 0)) {
+ //
+ // If the bootfile is not present and bootfilename is present in dhcp packet, just parse it.
+ // And do not count dhcp option header, or else will destory the serverhostname.
+ //
+ Options[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] = (EFI_DHCP4_PACKET_OPTION *) (&Offer->Dhcp4.Header.BootFileName[0] -
+ EFI_FIELD_OFFSET (EFI_DHCP4_PACKET_OPTION, Data[0]));
+
+ }
+
+ //
+ // Determine offer type of the dhcp packet.
+ //
+ Option = Options[PXEBC_DHCP4_TAG_INDEX_MSG_TYPE];
+ if ((Option == NULL) || (Option->Data[0] == 0)) {
+ //
+ // It's a bootp offer
+ //
+ Option = CachedPacket->Dhcp4Option[PXEBC_DHCP4_TAG_INDEX_BOOTFILE];
+ if (Option == NULL) {
+ //
+ // bootp offer without bootfilename, discard it.
+ //
+ return FALSE;
+ }
+
+ OfferType = DHCP4_PACKET_TYPE_BOOTP;
+
+ } else {
+
+ if (IS_VALID_DISCOVER_VENDOR_OPTION (CachedPacket->PxeVendorOption.BitMap)) {
+ //
+ // It's a pxe10 offer with PXEClient and discover vendor option.
+ //
+ OfferType = DHCP4_PACKET_TYPE_PXE10;
+ } else if (IS_VALID_MTFTP_VENDOR_OPTION (CachedPacket->PxeVendorOption.BitMap)) {
+ //
+ // It's a wfm11a offer with PXEClient and mtftp vendor option, and
+ // return false since mtftp not supported currently.
+ //
+ return FALSE;
+#if 0
+ //
+ // WFM11A, make sure bootfile is present
+ //
+ if (CachedPacket->Dhcp4Option[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] == NULL) {
+ //
+ // Discard this offer.
+ //
+ return ;
+ }
+
+ OfferType = DHCP4_PACKET_TYPE_WFM11A;
+#endif
+ } else {
+ //
+ // If the binl offer with only PXEClient.
+ //
+ OfferType = (UINT8) ((CachedPacket->IsPxeOffer) ? DHCP4_PACKET_TYPE_BINL : DHCP4_PACKET_TYPE_DHCP_ONLY);
+ }
+ }
+
+ CachedPacket->OfferType = OfferType;
+
+ return TRUE;
+}
+
+
+/**
+ GC_NOTO: Add function description
+
+ @param Private GC_NOTO: add argument description
+ @param Index GC_NOTO: add argument description
+
+ @return GC_NOTO: add return values
+
+**/
+BOOLEAN
+PxeBcTryBinl (
+ IN PXEBC_PRIVATE_DATA *Private,
+ IN UINT32 Index
+ )
+{
+ EFI_DHCP4_PACKET *Offer;
+ EFI_IP_ADDRESS ServerIp;
+ EFI_STATUS Status;
+ PXEBC_CACHED_DHCP4_PACKET *CachedPacket;
+ EFI_DHCP4_PACKET *Reply;
+
+ ASSERT (Private->Dhcp4Offers[Index].OfferType == DHCP4_PACKET_TYPE_BINL);
+
+ Offer = &Private->Dhcp4Offers[Index].Packet.Offer;
+ if (Offer->Dhcp4.Header.ServerAddr.Addr[0] == 0) {
+ //
+ // next server ip address is zero, use server id option instead.
+ //
+ NetCopyMem (
+ &ServerIp.Addr[0],
+ Private->Dhcp4Offers[Index].Dhcp4Option[PXEBC_DHCP4_TAG_INDEX_SERVER_ID]->Data,
+ sizeof (EFI_IPv4_ADDRESS)
+ );
+ } else {
+ //
+ // use next server ip address.
+ //
+ NetCopyMem (&ServerIp.Addr[0], &Offer->Dhcp4.Header.ServerAddr, sizeof (EFI_IPv4_ADDRESS));
+ }
+
+ CachedPacket = &Private->ProxyOffer;
+ Reply = &CachedPacket->Packet.Offer;
+
+ Status = PxeBcDiscvBootService (
+ Private,
+ 0,
+ NULL,
+ FALSE,
+ &ServerIp,
+ 0,
+ NULL,
+ FALSE,
+ Reply
+ );
+ if (EFI_ERROR (Status)) {
+ return FALSE;
+ }
+
+ if (!PxeBcParseCachedDhcpPacket (CachedPacket)) {
+ return FALSE;
+ }
+
+ if ((CachedPacket->OfferType != DHCP4_PACKET_TYPE_PXE10) &&
+ (CachedPacket->Dhcp4Option[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] == NULL)) {
+ //
+ // This BINL ack doesn't have discovery options set or bootfile name
+ // specified.
+ //
+ return FALSE;
+ }
+
+ Private->PxeBc.Mode->ProxyOfferReceived = TRUE;
+ NetCopyMem (&Private->PxeBc.Mode->ProxyOffer, &Reply->Dhcp4, Reply->Length);
+
+ return TRUE;
+}
+
+
+/**
+ GC_NOTO: Add function description
+
+ @param Private GC_NOTO: add argument description
+ @param OfferIndex GC_NOTO: add argument description
+
+ @return GC_NOTO: add return values
+
+**/
+BOOLEAN
+PxeBcTryBinlProxy (
+ IN PXEBC_PRIVATE_DATA *Private,
+ OUT UINT32 *OfferIndex
+ )
+{
+ UINT32 Index;
+
+ for (Index = 0; Index < Private->ProxyIndex[DHCP4_PACKET_TYPE_BINL]; Index++) {
+
+ *OfferIndex = Private->BinlIndex[Index];
+ //
+ // Try this BINL proxy offer
+ //
+ if (PxeBcTryBinl (Private, *OfferIndex)) {
+ return TRUE;
+ }
+ }
+
+ return FALSE;
+}
+
+
+/**
+ GC_NOTO: Add function description
+
+ @param Private GC_NOTO: add argument description
+
+ @return GC_NOTO: add return values
+
+**/
+EFI_STATUS
+PxeBcCheckSelectedOffer (
+ IN PXEBC_PRIVATE_DATA *Private
+ )
+{
+ PXEBC_CACHED_DHCP4_PACKET *SelectedOffer;
+ EFI_DHCP4_PACKET_OPTION **Options;
+ UINT32 Index;
+ EFI_DHCP4_PACKET *Offer;
+ UINT32 ProxyOfferIndex;
+ EFI_STATUS Status;
+ EFI_PXE_BASE_CODE_MODE *Mode;
+ EFI_DHCP4_PACKET *Ack;
+
+ ASSERT (Private->SelectedOffer != 0);
+
+ Status = EFI_SUCCESS;
+ SelectedOffer = &Private->Dhcp4Offers[Private->SelectedOffer - 1];
+ Options = SelectedOffer->Dhcp4Option;
+
+ if (SelectedOffer->OfferType == DHCP4_PACKET_TYPE_BINL) {
+ //
+ // The addresses are acquired from a BINL dhcp offer, try BINL to get
+ // the bootfile name
+ //
+ if (!PxeBcTryBinl (Private, Private->SelectedOffer - 1)) {
+ Status = EFI_NO_RESPONSE;
+ }
+ } else if ((SelectedOffer->OfferType == DHCP4_PACKET_TYPE_DHCP_ONLY) &&
+ (Options[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] == NULL)) {
+ //
+ // The selected offer to finish the D.O.R.A. is a DHCP only offer and
+ // bootfile name is not provided in this offer, we need try proxy offers
+ // to get the bootfile name or the discovery info
+ //
+ ProxyOfferIndex = Private->NumOffers;
+
+ if (Private->SortOffers) {
+ //
+ // Choose proxy offer from the type we stored during DHCP offer selection
+ //
+ ASSERT (Private->ProxyIndex[Private->ProxyOfferType] > 0);
+
+ if (Private->ProxyOfferType == DHCP4_PACKET_TYPE_BINL) {
+ //
+ // We buffer all received BINL proxy offers, try them all one by one
+ //
+ if (!PxeBcTryBinlProxy (Private, &ProxyOfferIndex)) {
+ Status = EFI_NO_RESPONSE;
+ }
+ } else {
+ //
+ // For other types, only one proxy offer is buffered.
+ //
+ ProxyOfferIndex = Private->ProxyIndex[Private->ProxyOfferType] - 1;
+ }
+ } else {
+ //
+ // Choose proxy offer in the received order.
+ //
+ Status = EFI_NO_RESPONSE;
+
+ for (Index = 0; Index < Private->NumOffers; Index++) {
+
+ Offer = &Private->Dhcp4Offers[Index].Packet.Offer;
+ if (!IS_PROXY_DHCP_OFFER (Offer)) {
+ //
+ // Skip non proxy dhcp offers.
+ //
+ continue;
+ }
+
+ if (Private->Dhcp4Offers[Index].OfferType == DHCP4_PACKET_TYPE_BINL) {
+ //
+ // Try BINL
+ //
+ if (!PxeBcTryBinl (Private, Index)) {
+ //
+ // Failed, skip to the next offer
+ //
+ continue;
+ }
+ }
+
+ Status = EFI_SUCCESS;
+ break;
+ }
+ }
+
+ if (!EFI_ERROR (Status) && (Private->ProxyOfferType != DHCP4_PACKET_TYPE_BINL)) {
+ //
+ // Copy the proxy offer to Mode and set the flag
+ //
+ PxeBcCopyProxyOffer (Private, ProxyOfferIndex);
+ }
+ }
+
+ if (!EFI_ERROR (Status)) {
+ //
+ // Everything is OK, set the flag and copy the DHCP packets.
+ //
+ Mode = Private->PxeBc.Mode;
+ Offer = &SelectedOffer->Packet.Offer;
+
+ //
+ // The discover packet is already copied, just set flag here.
+ //
+ Mode->DhcpDiscoverValid = TRUE;
+
+ Ack = &Private->Dhcp4Ack.Packet.Ack;
+ if (SelectedOffer->OfferType == DHCP4_PACKET_TYPE_BOOTP) {
+ //
+ // Other type of ACK is already cached. Bootp is special that we should
+ // use the bootp reply as the ACK and put it into the DHCP_ONLY buffer.
+ //
+ PxeBcCopyEfiDhcp4Packet (&Private->Dhcp4Ack.Packet.Ack, Offer);
+ }
+
+ PxeBcParseCachedDhcpPacket (&Private->Dhcp4Ack);
+
+ Mode->DhcpAckReceived = TRUE;
+
+ //
+ // Copy the dhcp ack.
+ //
+ NetCopyMem (&Mode->DhcpAck, &Ack->Dhcp4, Ack->Length);
+ }
+
+ return Status;
+}
+
+
+/**
+ GC_NOTO: Add function description
+
+ @param Private GC_NOTO: add argument description
+ @param RcvdOffer GC_NOTO: add argument description
+
+ @return GC_NOTO: add return values
+
+**/
+VOID
+PxeBcCacheDhcpOffer (
+ IN PXEBC_PRIVATE_DATA *Private,
+ IN EFI_DHCP4_PACKET *RcvdOffer
+ )
+{
+ PXEBC_CACHED_DHCP4_PACKET *CachedOffer;
+ EFI_DHCP4_PACKET *Offer;
+ UINT8 OfferType;
+
+ CachedOffer = &Private->Dhcp4Offers[Private->NumOffers];
+ Offer = &CachedOffer->Packet.Offer;
+
+ //
+ // Cache the orignal dhcp packet
+ //
+ PxeBcCopyEfiDhcp4Packet (Offer, RcvdOffer);
+
+ //
+ // Parse and validate the options (including dhcp option and vendor option)
+ //
+ if (!PxeBcParseCachedDhcpPacket (CachedOffer)) {
+ return ;
+ }
+
+ OfferType = CachedOffer->OfferType;
+
+ if (OfferType == DHCP4_PACKET_TYPE_BOOTP) {
+
+ if (Private->BootpIndex != 0) {
+ //
+ // Only cache the first bootp offer, discard others.
+ //
+ return ;
+ } else {
+ //
+ // Take as a dhcp only offer, but record index specifically.
+ //
+ Private->BootpIndex = Private->NumOffers + 1;
+ }
+ } else {
+
+ if (IS_PROXY_DHCP_OFFER (Offer)) {
+ //
+ // It's a proxy dhcp offer with no your address, including pxe10, wfm11a or binl offer.
+ //
+ if (OfferType == DHCP4_PACKET_TYPE_BINL) {
+ //
+ // Cache all binl offers.
+ //
+ Private->BinlIndex[Private->ProxyIndex[DHCP4_PACKET_TYPE_BINL]] = Private->NumOffers;
+ Private->ProxyIndex[DHCP4_PACKET_TYPE_BINL]++;
+ } else if (Private->ProxyIndex[OfferType] != 0) {
+ //
+ // Only cache the first pxe10/wfm11a offers each, discard the others.
+ //
+ return ;
+ } else {
+ //
+ // Record index of the proxy dhcp offer with type other than binl.
+ //
+ Private->ProxyIndex[OfferType] = Private->NumOffers + 1;
+ }
+ } else {
+ //
+ // It's a dhcp offer with your address.
+ //
+ Private->OfferIndex[OfferType][Private->ServerCount[OfferType]] = Private->NumOffers;
+ Private->ServerCount[OfferType]++;
+ }
+ }
+
+ //
+ // Count the accepted offers.
+ //
+ Private->NumOffers++;
+}
+
+
+/**
+ GC_NOTO: Add function description
+
+ @param Private GC_NOTO: add argument description
+
+ @return GC_NOTO: add return values
+
+**/
+VOID
+PxeBcSelectOffer (
+ IN PXEBC_PRIVATE_DATA *Private
+ )
+{
+ UINT32 Index;
+ UINT32 OfferIndex;
+ EFI_DHCP4_PACKET *Offer;
+ BOOLEAN GotProxyOffer;
+
+ Private->SelectedOffer = 0;
+
+ if (Private->SortOffers) {
+ //
+ // Select offer according to the priority
+ //
+ if (Private->ServerCount[DHCP4_PACKET_TYPE_PXE10] > 0) {
+ //
+ // DHCP with PXE10
+ //
+ Private->SelectedOffer = Private->OfferIndex[DHCP4_PACKET_TYPE_PXE10][0] + 1;
+
+ } else if (Private->ServerCount[DHCP4_PACKET_TYPE_WFM11A] > 0) {
+ //
+ // DHCP with WfM
+ //
+ Private->SelectedOffer = Private->OfferIndex[DHCP4_PACKET_TYPE_WFM11A][0] + 1;
+
+ } else if ((Private->ProxyIndex[DHCP4_PACKET_TYPE_PXE10] > 0) &&
+ (Private->ServerCount[DHCP4_PACKET_TYPE_DHCP_ONLY] > 0)
+ ) {
+ //
+ // DHCP only and proxy DHCP with PXE10
+ //
+ Private->SelectedOffer = Private->OfferIndex[DHCP4_PACKET_TYPE_DHCP_ONLY][0] + 1;
+ Private->ProxyOfferType = DHCP4_PACKET_TYPE_PXE10;
+
+ } else if ((Private->ProxyIndex[DHCP4_PACKET_TYPE_WFM11A] > 0) &&
+ (Private->ServerCount[DHCP4_PACKET_TYPE_DHCP_ONLY] > 0)
+ ) {
+ //
+ // DHCP only and proxy DHCP with WfM
+ //
+ Private->SelectedOffer = Private->OfferIndex[DHCP4_PACKET_TYPE_DHCP_ONLY][0] + 1;
+ Private->ProxyOfferType = DHCP4_PACKET_TYPE_WFM11A;
+
+ } else if (Private->ServerCount[DHCP4_PACKET_TYPE_BINL] > 0) {
+ //
+ // DHCP with BINL
+ //
+ Private->SelectedOffer = Private->OfferIndex[DHCP4_PACKET_TYPE_BINL][0] + 1;
+
+ } else if ((Private->ProxyIndex[DHCP4_PACKET_TYPE_BINL] > 0) &&
+ (Private->ServerCount[DHCP4_PACKET_TYPE_DHCP_ONLY] > 0)
+ ) {
+ //
+ // DHCP only and proxy DHCP with BINL
+ //
+ Private->SelectedOffer = Private->OfferIndex[DHCP4_PACKET_TYPE_DHCP_ONLY][0] + 1;
+ Private->ProxyOfferType = DHCP4_PACKET_TYPE_BINL;
+
+ } else {
+ //
+ // Try offers with bootfile
+ //
+ for (Index = 0; Index < Private->ServerCount[DHCP4_PACKET_TYPE_DHCP_ONLY]; Index++) {
+ //
+ // Select the first DHCP only offer with bootfile
+ //
+ OfferIndex = Private->OfferIndex[DHCP4_PACKET_TYPE_DHCP_ONLY][Index];
+ if (Private->Dhcp4Offers[OfferIndex].Dhcp4Option[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] != NULL) {
+ Private->SelectedOffer = OfferIndex + 1;
+ break;
+ }
+ }
+
+ if (Private->SelectedOffer == 0) {
+ //
+ // Select the Bootp reply with bootfile if any
+ //
+ Private->SelectedOffer = Private->BootpIndex;
+ }
+ }
+ } else {
+ //
+ // Try the offers in the received order.
+ //
+ GotProxyOffer = FALSE;
+ for (Index = 0; Index < DHCP4_PACKET_TYPE_MAX; Index++) {
+
+ GotProxyOffer = (BOOLEAN) (Private->ProxyIndex[Index] > 0);
+ if (GotProxyOffer) {
+ break;
+ }
+ }
+
+ for (Index = 0; Index < Private->NumOffers; Index++) {
+
+ Offer = &Private->Dhcp4Offers[Index].Packet.Offer;
+
+ if (IS_PROXY_DHCP_OFFER (Offer)) {
+ //
+ // Skip proxy offers
+ //
+ continue;
+ }
+
+ if ((Private->Dhcp4Offers[Index].OfferType == DHCP4_PACKET_TYPE_DHCP_ONLY) &&
+ ((!GotProxyOffer) && (Private->Dhcp4Offers[Index].Dhcp4Option[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] == NULL))) {
+ //
+ // DHCP only offer but no proxy offer received and no bootfile option in this offer
+ //
+ continue;
+ }
+
+ Private->SelectedOffer = Index + 1;
+ break;
+ }
+ }
+}
+
+
+/**
+ GC_NOTO: Add function description
+
+ @param This GC_NOTO: add argument description
+ @param Context GC_NOTO: add argument description
+ @param CurrentState GC_NOTO: add argument description
+ @param Dhcp4Event GC_NOTO: add argument description
+ @param Packet GC_NOTO: add argument description
+ @param NewPacket GC_NOTO: add argument description
+
+ @retval EFI_SUCCESS GC_NOTO: Add description for return value
+ @retval EFI_ABORTED GC_NOTO: Add description for return value
+
+**/
+EFI_STATUS
+PxeBcDhcpCallBack (
+ IN EFI_DHCP4_PROTOCOL * This,
+ IN VOID *Context,
+ IN EFI_DHCP4_STATE CurrentState,
+ IN EFI_DHCP4_EVENT Dhcp4Event,
+ IN EFI_DHCP4_PACKET * Packet OPTIONAL,
+ OUT EFI_DHCP4_PACKET **NewPacket OPTIONAL
+ )
+{
+ PXEBC_PRIVATE_DATA *Private;
+ EFI_PXE_BASE_CODE_MODE *Mode;
+ EFI_PXE_BASE_CODE_CALLBACK_PROTOCOL *Callback;
+ EFI_DHCP4_PACKET_OPTION *MaxMsgSize;
+ UINT16 Value;
+ EFI_STATUS Status;
+ BOOLEAN Received;
+
+ if ((Dhcp4Event != Dhcp4RcvdOffer) &&
+ (Dhcp4Event != Dhcp4SelectOffer) &&
+ (Dhcp4Event != Dhcp4SendDiscover) &&
+ (Dhcp4Event != Dhcp4RcvdAck)) {
+ return EFI_SUCCESS;
+ }
+
+ Private = (PXEBC_PRIVATE_DATA *) Context;
+ Mode = Private->PxeBc.Mode;
+ Callback = Private->PxeBcCallback;
+
+ //
+ // Override the Maximum DHCP Message Size.
+ //
+ MaxMsgSize = PxeBcParseExtendOptions (
+ Packet->Dhcp4.Option,
+ GET_OPTION_BUFFER_LEN (Packet),
+ PXEBC_DHCP4_TAG_MAXMSG
+ );
+ if (MaxMsgSize != NULL) {
+ Value = HTONS (PXEBC_DHCP4_MAX_PACKET_SIZE);
+ NetCopyMem (MaxMsgSize->Data, &Value, sizeof (Value));
+ }
+
+ if ((Dhcp4Event != Dhcp4SelectOffer) && (Callback != NULL)) {
+ Received = (BOOLEAN) ((Dhcp4Event == Dhcp4RcvdOffer) || (Dhcp4Event == Dhcp4RcvdAck));
+ Status = Callback->Callback (
+ Callback,
+ Private->Function,
+ Received,
+ Packet->Length,
+ (EFI_PXE_BASE_CODE_PACKET *) &Packet->Dhcp4
+ );
+ if (Status != EFI_PXE_BASE_CODE_CALLBACK_STATUS_CONTINUE) {
+ return EFI_ABORTED;
+ }
+ }
+
+ Status = EFI_SUCCESS;
+
+ switch (Dhcp4Event) {
+
+ case Dhcp4SendDiscover:
+ //
+ // Cache the dhcp discover packet, of which some information will be used later.
+ //
+ NetCopyMem (Mode->DhcpDiscover.Raw, &Packet->Dhcp4, Packet->Length);
+
+ break;
+
+ case Dhcp4RcvdOffer:
+ Status = EFI_NOT_READY;
+ if (Private->NumOffers < PXEBC_MAX_OFFER_NUM) {
+ //
+ // Cache the dhcp offers in Private->Dhcp4Offers[]
+ //
+ PxeBcCacheDhcpOffer (Private, Packet);
+ }
+
+ break;
+
+ case Dhcp4SelectOffer:
+ //
+ // Select an offer, if succeeded, Private->SelectedOffer points to
+ // the index of the selected one.
+ //
+ PxeBcSelectOffer (Private);
+
+ if (Private->SelectedOffer == 0) {
+ Status = EFI_ABORTED;
+ } else {
+ *NewPacket = &Private->Dhcp4Offers[Private->SelectedOffer - 1].Packet.Offer;
+ }
+
+ break;
+
+ case Dhcp4RcvdAck:
+ //
+ // Cache Ack
+ //
+ ASSERT (Private->SelectedOffer != 0);
+
+ PxeBcCopyEfiDhcp4Packet (&Private->Dhcp4Ack.Packet.Ack, Packet);
+ break;
+ }
+
+ return Status;
+}
+
+
+/**
+ GC_NOTO: Add function description
+
+ @param Private GC_NOTO: add argument description
+ @param OptList GC_NOTO: add argument description
+ @param IsDhcpDiscover GC_NOTO: add argument description
+
+ @return GC_NOTO: add return values
+
+**/
+UINT32
+PxeBcBuildDhcpOptions (
+ IN PXEBC_PRIVATE_DATA *Private,
+ IN EFI_DHCP4_PACKET_OPTION **OptList,
+ IN BOOLEAN IsDhcpDiscover
+ )
+{
+ UINT32 Index;
+ PXEBC_DHCP4_OPTION_ENTRY OptEnt;
+ UINT16 Value;
+ CHAR8 *SystemSerialNumber;
+
+ Index = 0;
+ OptList[0] = (EFI_DHCP4_PACKET_OPTION *) Private->OptionBuffer;
+
+ if (!IsDhcpDiscover) {
+ //
+ // Append message type.
+ //
+ OptList[Index]->OpCode = PXEBC_DHCP4_TAG_MSG_TYPE;
+ OptList[Index]->Length = 1;
+ OptEnt.Mesg = (PXEBC_DHCP4_OPTION_MESG *) OptList[Index]->Data;
+ OptEnt.Mesg->Type = PXEBC_DHCP4_MSG_TYPE_REQUEST;
+ Index++;
+ OptList[Index] = GET_NEXT_DHCP_OPTION (OptList[Index - 1]);
+
+ //
+ // Append max message size.
+ //
+ OptList[Index]->OpCode = PXEBC_DHCP4_TAG_MAXMSG;
+ OptList[Index]->Length = sizeof (PXEBC_DHCP4_OPTION_MAX_MESG_SIZE);
+ OptEnt.MaxMesgSize = (PXEBC_DHCP4_OPTION_MAX_MESG_SIZE *) OptList[Index]->Data;
+ Value = NTOHS (PXEBC_DHCP4_MAX_PACKET_SIZE);
+ NetCopyMem (&OptEnt.MaxMesgSize->Size, &Value, sizeof (UINT16));
+ Index++;
+ OptList[Index] = GET_NEXT_DHCP_OPTION (OptList[Index - 1]);
+ }
+ //
+ // Parameter request list option.
+ //
+ OptList[Index]->OpCode = PXEBC_DHCP4_TAG_PARA_LIST;
+ OptList[Index]->Length = 35;
+ OptEnt.Para = (PXEBC_DHCP4_OPTION_PARA *) OptList[Index]->Data;
+ OptEnt.Para->ParaList[0] = PXEBC_DHCP4_TAG_NETMASK;
+ OptEnt.Para->ParaList[1] = PXEBC_DHCP4_TAG_TIME_OFFSET;
+ OptEnt.Para->ParaList[2] = PXEBC_DHCP4_TAG_ROUTER;
+ OptEnt.Para->ParaList[3] = PXEBC_DHCP4_TAG_TIME_SERVER;
+ OptEnt.Para->ParaList[4] = PXEBC_DHCP4_TAG_NAME_SERVER;
+ OptEnt.Para->ParaList[5] = PXEBC_DHCP4_TAG_DNS_SERVER;
+ OptEnt.Para->ParaList[6] = PXEBC_DHCP4_TAG_HOSTNAME;
+ OptEnt.Para->ParaList[7] = PXEBC_DHCP4_TAG_BOOTFILE_LEN;
+ OptEnt.Para->ParaList[8] = PXEBC_DHCP4_TAG_DOMAINNAME;
+ OptEnt.Para->ParaList[9] = PXEBC_DHCP4_TAG_ROOTPATH;
+ OptEnt.Para->ParaList[10] = PXEBC_DHCP4_TAG_EXTEND_PATH;
+ OptEnt.Para->ParaList[11] = PXEBC_DHCP4_TAG_EMTU;
+ OptEnt.Para->ParaList[12] = PXEBC_DHCP4_TAG_TTL;
+ OptEnt.Para->ParaList[13] = PXEBC_DHCP4_TAG_BROADCAST;
+ OptEnt.Para->ParaList[14] = PXEBC_DHCP4_TAG_NIS_DOMAIN;
+ OptEnt.Para->ParaList[15] = PXEBC_DHCP4_TAG_NIS_SERVER;
+ OptEnt.Para->ParaList[16] = PXEBC_DHCP4_TAG_NTP_SERVER;
+ OptEnt.Para->ParaList[17] = PXEBC_DHCP4_TAG_VENDOR;
+ OptEnt.Para->ParaList[18] = PXEBC_DHCP4_TAG_REQUEST_IP;
+ OptEnt.Para->ParaList[19] = PXEBC_DHCP4_TAG_LEASE;
+ OptEnt.Para->ParaList[20] = PXEBC_DHCP4_TAG_SERVER_ID;
+ OptEnt.Para->ParaList[21] = PXEBC_DHCP4_TAG_T1;
+ OptEnt.Para->ParaList[22] = PXEBC_DHCP4_TAG_T2;
+ OptEnt.Para->ParaList[23] = PXEBC_DHCP4_TAG_CLASS_ID;
+ OptEnt.Para->ParaList[24] = PXEBC_DHCP4_TAG_TFTP;
+ OptEnt.Para->ParaList[25] = PXEBC_DHCP4_TAG_BOOTFILE;
+ OptEnt.Para->ParaList[26] = PXEBC_PXE_DHCP4_TAG_UUID;
+ OptEnt.Para->ParaList[27] = 0x80;
+ OptEnt.Para->ParaList[28] = 0x81;
+ OptEnt.Para->ParaList[29] = 0x82;
+ OptEnt.Para->ParaList[30] = 0x83;
+ OptEnt.Para->ParaList[31] = 0x84;
+ OptEnt.Para->ParaList[32] = 0x85;
+ OptEnt.Para->ParaList[33] = 0x86;
+ OptEnt.Para->ParaList[34] = 0x87;
+ Index++;
+ OptList[Index] = GET_NEXT_DHCP_OPTION (OptList[Index - 1]);
+
+ //
+ // Append UUID/Guid-based client identifier option
+ //
+ OptList[Index]->OpCode = PXEBC_PXE_DHCP4_TAG_UUID;
+ OptList[Index]->Length = sizeof (PXEBC_DHCP4_OPTION_UUID);
+ OptEnt.Uuid = (PXEBC_DHCP4_OPTION_UUID *) OptList[Index]->Data;
+ OptEnt.Uuid->Type = 0;
+ Index++;
+ OptList[Index] = GET_NEXT_DHCP_OPTION (OptList[Index - 1]);
+
+ if (EFI_ERROR (GetSmbiosSystemGuidAndSerialNumber ((EFI_GUID *) OptEnt.Uuid->Guid, &SystemSerialNumber))) {
+ //
+ // GUID not yet set - send all 0xff's to show programable (via SetVariable)
+ // SetMem(DHCPV4_OPTIONS_BUFFER.DhcpPlatformId.Guid, sizeof(EFI_GUID), 0xff);
+ // GUID not yet set - send all 0's to show not programable
+ //
+ ZeroMem (OptEnt.Uuid->Guid, sizeof (EFI_GUID));
+ }
+
+ //
+ // Append client network device interface option
+ //
+ OptList[Index]->OpCode = PXEBC_PXE_DHCP4_TAG_UNDI;
+ OptList[Index]->Length = sizeof (PXEBC_DHCP4_OPTION_UNDI);
+ OptEnt.Undi = (PXEBC_DHCP4_OPTION_UNDI *) OptList[Index]->Data;
+ OptEnt.Undi->Type = Private->Nii->Type;
+ OptEnt.Undi->MajorVer = Private->Nii->MajorVer;
+ OptEnt.Undi->MinorVer = Private->Nii->MinorVer;
+
+ Index++;
+ OptList[Index] = GET_NEXT_DHCP_OPTION (OptList[Index - 1]);
+
+ //
+ // Append client system architecture option
+ //
+ OptList[Index]->OpCode = PXEBC_PXE_DHCP4_TAG_ARCH;
+ OptList[Index]->Length = sizeof (PXEBC_DHCP4_OPTION_ARCH);
+ OptEnt.Arch = (PXEBC_DHCP4_OPTION_ARCH *) OptList[Index]->Data;
+ Value = HTONS (SYS_ARCH);
+ NetCopyMem (&OptEnt.Arch->Type, &Value, sizeof (UINT16));
+ Index++;
+ OptList[Index] = GET_NEXT_DHCP_OPTION (OptList[Index - 1]);
+
+ //
+ // Append client system architecture option
+ //
+ OptList[Index]->OpCode = PXEBC_DHCP4_TAG_CLASS_ID;
+ OptList[Index]->Length = sizeof (PXEBC_DHCP4_OPTION_CLID);
+ OptEnt.Clid = (PXEBC_DHCP4_OPTION_CLID *) OptList[Index]->Data;
+ NetCopyMem (OptEnt.Clid, DEFAULT_CLASS_ID_DATA, sizeof (PXEBC_DHCP4_OPTION_CLID));
+ CvtNum (SYS_ARCH, OptEnt.Clid->ArchitectureType, sizeof (OptEnt.Clid->ArchitectureType));
+ NetCopyMem (OptEnt.Clid->InterfaceName, Private->Nii->StringId, sizeof (OptEnt.Clid->InterfaceName));
+ CvtNum (Private->Nii->MajorVer, OptEnt.Clid->UndiMajor, sizeof (OptEnt.Clid->UndiMajor));
+ CvtNum (Private->Nii->MinorVer, OptEnt.Clid->UndiMinor, sizeof (OptEnt.Clid->UndiMinor));
+ Index++;
+
+ return Index;
+}
+
+
+/**
+ GC_NOTO: Add function description
+
+ @param Private GC_NOTO: add argument description
+ @param Type GC_NOTO: add argument description
+ @param Layer GC_NOTO: add argument description
+ @param UseBis GC_NOTO: add argument description
+ @param DestIp GC_NOTO: add argument description
+ @param IpCount GC_NOTO: add argument description
+ @param SrvList GC_NOTO: add argument description
+ @param IsDiscv GC_NOTO: add argument description
+ @param Reply GC_NOTO: add argument description
+
+ @retval EFI_OUT_OF_RESOURCES GC_NOTO: Add description for return value
+
+**/
+EFI_STATUS
+PxeBcDiscvBootService (
+ IN PXEBC_PRIVATE_DATA * Private,
+ IN UINT16 Type,
+ IN UINT16 *Layer,
+ IN BOOLEAN UseBis,
+ IN EFI_IP_ADDRESS * DestIp,
+ IN UINT16 IpCount,
+ IN EFI_PXE_BASE_CODE_SRVLIST * SrvList,
+ IN BOOLEAN IsDiscv,
+ OUT EFI_DHCP4_PACKET * Reply OPTIONAL
+ )
+{
+ EFI_PXE_BASE_CODE_UDP_PORT Sport;
+ EFI_PXE_BASE_CODE_MODE *Mode;
+ EFI_DHCP4_PROTOCOL *Dhcp4;
+ EFI_DHCP4_TRANSMIT_RECEIVE_TOKEN Token;
+ BOOLEAN IsBCast;
+ EFI_STATUS Status;
+ UINT16 RepIndex;
+ UINT16 SrvIndex;
+ UINT16 TryIndex;
+ EFI_DHCP4_LISTEN_POINT ListenPoint;
+ EFI_DHCP4_PACKET *Response;
+ EFI_DHCP4_PACKET_OPTION *OptList[PXEBC_DHCP4_MAX_OPTION_NUM];
+ UINT32 OptCount;
+ EFI_DHCP4_PACKET_OPTION *PxeOpt;
+ PXEBC_OPTION_BOOT_ITEM *PxeBootItem;
+ UINT8 VendorOptLen;
+
+ Mode = Private->PxeBc.Mode;
+ Dhcp4 = Private->Dhcp4;
+ Status = EFI_SUCCESS;
+
+ ZeroMem (&Token, sizeof (EFI_DHCP4_TRANSMIT_RECEIVE_TOKEN));
+
+ if (DestIp == NULL) {
+ Sport = PXEBC_DHCP4_S_PORT;
+ IsBCast = TRUE;
+ } else {
+ Sport = PXEBC_BS_DISCOVER_PORT;
+ IsBCast = FALSE;
+ }
+
+ if (!UseBis && Layer != NULL) {
+ *Layer &= EFI_PXE_BASE_CODE_BOOT_LAYER_MASK;
+ }
+
+ OptCount = PxeBcBuildDhcpOptions (Private, OptList, FALSE);
+
+ if (IsDiscv) {
+ //
+ // Add vendor option of PXE_BOOT_ITEM
+ //
+ VendorOptLen = (sizeof (EFI_DHCP4_PACKET_OPTION) - 1) * 2 + sizeof (PXEBC_OPTION_BOOT_ITEM) + 1;
+ OptList[OptCount] = NetAllocatePool (VendorOptLen);
+ if (OptList[OptCount] == NULL) {
+ return EFI_OUT_OF_RESOURCES;
+ }
+
+ OptList[OptCount]->OpCode = PXEBC_DHCP4_TAG_VENDOR;
+ OptList[OptCount]->Length = (UINT8) (VendorOptLen - 2);
+ PxeOpt = (EFI_DHCP4_PACKET_OPTION *) OptList[OptCount]->Data;
+ PxeOpt->OpCode = PXEBC_VENDOR_TAG_BOOT_ITEM;
+ PxeOpt->Length = sizeof (PXEBC_OPTION_BOOT_ITEM);
+ PxeBootItem = (PXEBC_OPTION_BOOT_ITEM *) PxeOpt->Data;
+ PxeBootItem->Type = HTONS (Type);
+ PxeBootItem->Layer = HTONS (*Layer);
+ PxeOpt->Data[PxeOpt->Length] = PXEBC_DHCP4_TAG_EOP;
+
+ OptCount++;
+ }
+
+ Status = Dhcp4->Build (Dhcp4, &Private->SeedPacket, 0, NULL, OptCount, OptList, &Token.Packet);
+
+ if (IsDiscv) {
+ NetFreePool (OptList[OptCount - 1]);
+ }
+
+ if (EFI_ERROR (Status)) {
+ return Status;
+ }
+
+ Token.Packet->Dhcp4.Header.Xid = NET_RANDOM (NetRandomInitSeed ());
+ Token.Packet->Dhcp4.Header.Reserved = (UINT16) ((IsBCast) ? 0xf000 : 0x0);
+ NetCopyMem (&Token.Packet->Dhcp4.Header.ClientAddr, &Private->StationIp, sizeof (EFI_IPv4_ADDRESS));
+
+ Token.RemotePort = Sport;
+
+ if (DestIp == NULL) {
+ NetSetMem (&Token.RemoteAddress, sizeof (EFI_IPv4_ADDRESS), 0xff);
+ } else {
+ NetCopyMem (&Token.RemoteAddress, DestIp, sizeof (EFI_IPv4_ADDRESS));
+ }
+
+ NetCopyMem (&Token.GatewayAddress, &Private->GatewayIp, sizeof (EFI_IPv4_ADDRESS));
+
+ if (!IsBCast) {
+ Token.ListenPointCount = 1;
+ Token.ListenPoints = &ListenPoint;
+ Token.ListenPoints[0].ListenPort = PXEBC_BS_DISCOVER_PORT;
+ NetCopyMem (&Token.ListenPoints[0].ListenAddress, &Private->StationIp, sizeof(EFI_IPv4_ADDRESS));
+ NetCopyMem (&Token.ListenPoints[0].SubnetMask, &Private->SubnetMask, sizeof(EFI_IPv4_ADDRESS));
+ }
+ //
+ // Send Pxe Discover
+ //
+ for (TryIndex = 1; TryIndex <= PXEBC_BOOT_REQUEST_RETRIES; TryIndex++) {
+
+ Token.TimeoutValue = PXEBC_BOOT_REQUEST_TIMEOUT * TryIndex;
+
+ Status = Dhcp4->TransmitReceive (Dhcp4, &Token);
+
+ if (Token.Status != EFI_TIMEOUT) {
+ break;
+ }
+ }
+
+ if (!EFI_ERROR (Status)) {
+ //
+ // Find Pxe Reply
+ //
+ RepIndex = 0;
+ SrvIndex = 0;
+ Response = Token.ResponseList;
+
+ while (RepIndex < Token.ResponseCount) {
+
+ while (SrvIndex < IpCount) {
+
+ if (SrvList[SrvIndex].AcceptAnyResponse) {
+ break;
+ }
+
+ if ((SrvList[SrvIndex].Type == Type) && EFI_IP4_EQUAL (&(Response->Dhcp4.Header.ServerAddr), &(Private->ServerIp))) {
+ break;
+ }
+
+ SrvIndex++;
+ }
+
+ if ((IpCount != SrvIndex) || (IpCount == 0)) {
+ break;
+ }
+
+ SrvIndex = 0;
+ RepIndex++;
+
+ Response = (EFI_DHCP4_PACKET *) ((UINT8 *) Response + Response->Size);
+ }
+
+ if (RepIndex < Token.ResponseCount) {
+
+ if (Reply != NULL) {
+ PxeBcCopyEfiDhcp4Packet (Reply, Response);
+ }
+
+ if (IsDiscv) {
+ NetCopyMem (&(Mode->PxeDiscover), &(Token.Packet->Dhcp4), Token.Packet->Length);
+ Mode->PxeDiscoverValid = TRUE;
+
+ NetCopyMem (Mode->PxeReply.Raw, &Response->Dhcp4, Response->Length);
+ Mode->PxeReplyReceived = TRUE;
+ }
+ } else {
+ Status = EFI_NOT_FOUND;
+ }
+
+ //
+ // free the responselist
+ //
+ NetFreePool (Token.ResponseList);
+ }
+ //
+ // Free the dhcp packet
+ //
+ NetFreePool (Token.Packet);
+
+ return Status;
+}
+
+
+/**
+ GC_NOTO: Add function description
+
+ @param Buffer GC_NOTO: add argument description
+ @param Length GC_NOTO: add argument description
+ @param OptTag GC_NOTO: add argument description
+
+ @return GC_NOTO: add return values
+
+**/
+EFI_DHCP4_PACKET_OPTION *
+PxeBcParseExtendOptions (
+ IN UINT8 *Buffer,
+ IN UINT32 Length,
+ IN UINT8 OptTag
+ )
+{
+ EFI_DHCP4_PACKET_OPTION *Option;
+ UINT32 Offset;
+
+ Option = (EFI_DHCP4_PACKET_OPTION *) Buffer;
+ Offset = 0;
+
+ while (Offset < Length && Option->OpCode != PXEBC_DHCP4_TAG_EOP) {
+
+ if (Option->OpCode == OptTag) {
+
+ return Option;
+ }
+
+ if (Option->OpCode == PXEBC_DHCP4_TAG_PAD) {
+ Offset++;
+ } else {
+ Offset += Option->Length + 2;
+ }
+
+ Option = (EFI_DHCP4_PACKET_OPTION *) (Buffer + Offset);
+ }
+
+ return NULL;
+}
+
+
+/**
+ This function is to parse and check vendor options.
+
+ @param Dhcp4Option Pointer to dhcp options
+ @param VendorOption Pointer to vendor options
+
+ @return TRUE : Valid vendor options
+ @return FALSE : Invalid vendor options
+
+**/
+BOOLEAN
+PxeBcParseVendorOptions (
+ IN EFI_DHCP4_PACKET_OPTION *Dhcp4Option,
+ IN PXEBC_VENDOR_OPTION *VendorOption
+ )
+{
+ UINT32 *BitMap;
+ UINT8 VendorOptionLen;
+ EFI_DHCP4_PACKET_OPTION *PxeOption;
+ UINT8 Offset;
+
+ BitMap = VendorOption->BitMap;
+ VendorOptionLen = Dhcp4Option->Length;
+ PxeOption = (EFI_DHCP4_PACKET_OPTION *) &Dhcp4Option->Data[0];
+ Offset = 0;
+
+ while ((Offset < VendorOptionLen) && (PxeOption->OpCode != PXEBC_DHCP4_TAG_EOP)) {
+ //
+ // Parse every Vendor Option and set its BitMap
+ //
+ switch (PxeOption->OpCode) {
+
+ case PXEBC_VENDOR_TAG_MTFTP_IP:
+
+ NetCopyMem (&VendorOption->MtftpIp, PxeOption->Data, sizeof (EFI_IPv4_ADDRESS));
+ break;
+
+ case PXEBC_VENDOR_TAG_MTFTP_CPORT:
+
+ NetCopyMem (&VendorOption->MtftpCPort, PxeOption->Data, sizeof (VendorOption->MtftpCPort));
+ break;
+
+ case PXEBC_VENDOR_TAG_MTFTP_SPORT:
+
+ NetCopyMem (&VendorOption->MtftpSPort, PxeOption->Data, sizeof (VendorOption->MtftpSPort));
+ break;
+
+ case PXEBC_VENDOR_TAG_MTFTP_TIMEOUT:
+
+ VendorOption->MtftpTimeout = *PxeOption->Data;
+ break;
+
+ case PXEBC_VENDOR_TAG_MTFTP_DELAY:
+
+ VendorOption->MtftpDelay = *PxeOption->Data;
+ break;
+
+ case PXEBC_VENDOR_TAG_DISCOVER_CTRL:
+
+ VendorOption->DiscoverCtrl = *PxeOption->Data;
+ break;
+
+ case PXEBC_VENDOR_TAG_DISCOVER_MCAST:
+
+ NetCopyMem (&VendorOption->DiscoverMcastIp, PxeOption->Data, sizeof (EFI_IPv4_ADDRESS));
+ break;
+
+ case PXEBC_VENDOR_TAG_BOOT_SERVERS:
+
+ VendorOption->BootSvrLen = PxeOption->Length;
+ VendorOption->BootSvr = (PXEBC_BOOT_SVR_ENTRY *) PxeOption->Data;
+ break;
+
+ case PXEBC_VENDOR_TAG_BOOT_MENU:
+
+ VendorOption->BootMenuLen = PxeOption->Length;
+ VendorOption->BootMenu = (PXEBC_BOOT_MENU_ENTRY *) PxeOption->Data;
+ break;
+
+ case PXEBC_VENDOR_TAG_MENU_PROMPT:
+
+ VendorOption->MenuPromptLen = PxeOption->Length;
+ VendorOption->MenuPrompt = (PXEBC_MENU_PROMPT *) PxeOption->Data;
+ break;
+
+ case PXEBC_VENDOR_TAG_MCAST_ALLOC:
+
+ NetCopyMem (&VendorOption->McastIpBase, PxeOption->Data, sizeof (EFI_IPv4_ADDRESS));
+ NetCopyMem (&VendorOption->McastIpBlock, PxeOption->Data + 4, sizeof (VendorOption->McastIpBlock));
+ NetCopyMem (&VendorOption->McastIpRange, PxeOption->Data + 6, sizeof (VendorOption->McastIpRange));
+ break;
+
+ case PXEBC_VENDOR_TAG_CREDENTIAL_TYPES:
+
+ VendorOption->CredTypeLen = PxeOption->Length;
+ VendorOption->CredType = (UINT32 *) PxeOption->Data;
+ break;
+
+ case PXEBC_VENDOR_TAG_BOOT_ITEM:
+
+ NetCopyMem (&VendorOption->BootSrvType, PxeOption->Data, sizeof (VendorOption->BootSrvType));
+ NetCopyMem (&VendorOption->BootSrvLayer, PxeOption->Data + 2, sizeof (VendorOption->BootSrvLayer));
+ break;
+ }
+
+ SET_VENDOR_OPTION_BIT_MAP (BitMap, PxeOption->OpCode);
+
+ if (PxeOption->OpCode == PXEBC_DHCP4_TAG_PAD) {
+ Offset++;
+ } else {
+ Offset = (UINT8) (Offset + PxeOption->Length + 2);
+ }
+
+ PxeOption = (EFI_DHCP4_PACKET_OPTION *) (Dhcp4Option->Data + Offset);
+ }
+
+ //
+ // FixMe, return falas if invalid of any vendor option
+ //
+
+ return TRUE;
+}
+
+
+/**
+ GC_NOTO: Add function description
+
+ @param Str GC_NOTO: add argument description
+ @param Len GC_NOTO: add argument description
+
+ @return GC_NOTO: add return values
+
+**/
+VOID
+PxeBcDisplayBootItem (
+ IN UINT8 *Str,
+ IN UINT8 Len
+ )
+{
+ UINT8 Tmp;
+
+ Len = (UINT8) MIN (70, Len);
+ Tmp = Str[Len];
+ Str[Len] = 0;
+ AsciiPrint ("%a \n", Str);
+ Str[Len] = Tmp;
+}
+
+
+/**
+ GC_NOTO: Add function description
+
+ @param Private GC_NOTO: add argument description
+
+ @retval EFI_SUCCESS GC_NOTO: Add description for return value
+ @retval EFI_TIMEOUT GC_NOTO: Add description for return value
+
+**/
+EFI_STATUS
+PxeBcSelectBootPrompt (
+ IN PXEBC_PRIVATE_DATA *Private
+ )
+{
+ PXEBC_CACHED_DHCP4_PACKET *Packet;
+ PXEBC_VENDOR_OPTION *VendorOpt;
+ EFI_EVENT TimeoutEvent;
+ EFI_EVENT DescendEvent;
+ EFI_INPUT_KEY InputKey;
+ EFI_STATUS Status;
+ UINT8 Timeout;
+ UINT8 *Prompt;
+ UINT8 PromptLen;
+ INT32 SecCol;
+ INT32 SecRow;
+
+ TimeoutEvent = NULL;
+ DescendEvent = NULL;
+
+ if (Private->PxeBc.Mode->ProxyOfferReceived) {
+
+ Packet = &Private->ProxyOffer;
+ } else {
+
+ Packet = &Private->Dhcp4Ack;
+ }
+
+ if (Packet->OfferType != DHCP4_PACKET_TYPE_PXE10) {
+ return EFI_NOT_FOUND;
+ }
+
+ VendorOpt = &Packet->PxeVendorOption;
+
+ if (!IS_VALID_BOOT_PROMPT (VendorOpt->BitMap)) {
+ return EFI_SUCCESS;
+ }
+
+ Timeout = VendorOpt->MenuPrompt->Timeout;
+ Prompt = VendorOpt->MenuPrompt->Prompt;
+ PromptLen = (UINT8) (VendorOpt->MenuPromptLen - 1);
+
+ if (Timeout == 0) {
+ return EFI_SUCCESS;
+ }
+
+ if (Timeout == 255) {
+ return EFI_TIMEOUT;
+ }
+
+ Status = gBS->CreateEvent (
+ EVT_TIMER,
+ TPL_CALLBACK,
+ NULL,
+ NULL,
+ &TimeoutEvent
+ );
+
+ if (EFI_ERROR (Status)) {
+ return Status;
+ }
+
+ Status = gBS->SetTimer (
+ TimeoutEvent,
+ TimerRelative,
+ Timeout * TICKS_PER_SECOND
+ );
+
+ if (EFI_ERROR (Status)) {
+ goto ON_EXIT;
+ }
+
+ Status = gBS->CreateEvent (
+ EVT_TIMER,
+ TPL_CALLBACK,
+ NULL,
+ NULL,
+ &DescendEvent
+ );
+
+ if (EFI_ERROR (Status)) {
+ goto ON_EXIT;
+ }
+
+ Status = gBS->SetTimer (
+ DescendEvent,
+ TimerPeriodic,
+ TICKS_PER_SECOND
+ );
+
+ if (EFI_ERROR (Status)) {
+ goto ON_EXIT;
+ }
+
+ SecCol = gST->ConOut->Mode->CursorColumn;
+ SecRow = gST->ConOut->Mode->CursorRow;
+
+ PxeBcDisplayBootItem (Prompt, PromptLen);
+
+ gST->ConOut->SetCursorPosition (gST->ConOut, SecCol + PromptLen, SecRow);
+ AsciiPrint ("(%d) ", Timeout--);
+
+ while (EFI_ERROR (gBS->CheckEvent (TimeoutEvent))) {
+
+ if (!EFI_ERROR (gBS->CheckEvent (DescendEvent))) {
+ gST->ConOut->SetCursorPosition (gST->ConOut, SecCol + PromptLen, SecRow);
+ AsciiPrint ("(%d) ", Timeout--);
+ }
+
+ if (gST->ConIn->ReadKeyStroke (gST->ConIn, &InputKey) == EFI_NOT_READY) {
+
+ gBS->Stall (10 * TICKS_PER_MS);
+ continue;
+ }
+
+ if (InputKey.ScanCode == 0) {
+
+ switch (InputKey.UnicodeChar) {
+ case CTRL ('c'):
+ Status = EFI_ABORTED;
+ break;
+
+ case CTRL ('m'):
+ case 'm':
+ case 'M':
+ Status = EFI_TIMEOUT;
+ break;
+
+ default:
+ continue;
+ }
+ } else {
+
+ switch (InputKey.ScanCode) {
+ case SCAN_F8:
+ Status = EFI_TIMEOUT;
+ break;
+
+ case SCAN_ESC:
+ Status = EFI_ABORTED;
+ break;
+
+ default:
+ continue;
+ }
+ }
+
+ break;
+ }
+
+ gST->ConOut->SetCursorPosition (gST->ConOut, 0 , SecRow + 1);
+
+ON_EXIT:
+
+ if (DescendEvent != NULL) {
+ gBS->CloseEvent (DescendEvent);
+ }
+
+ if (TimeoutEvent != NULL) {
+ gBS->CloseEvent (TimeoutEvent);
+ }
+
+ return Status;
+}
+
+
+/**
+ GC_NOTO: Add function description
+
+ @param Private GC_NOTO: add argument description
+ @param Type GC_NOTO: add argument description
+
+ @retval EFI_ABORTED GC_NOTO: Add description for return value
+ @retval EFI_SUCCESS GC_NOTO: Add description for return value
+
+**/
+EFI_STATUS
+PxeBcSelectBootMenu (
+ IN PXEBC_PRIVATE_DATA *Private,
+ OUT UINT16 *Type,
+ IN BOOLEAN UseDefaultItem
+ )
+{
+ PXEBC_CACHED_DHCP4_PACKET *Packet;
+ PXEBC_VENDOR_OPTION *VendorOpt;
+ EFI_INPUT_KEY InputKey;
+ UINT8 MenuSize;
+ UINT8 MenuNum;
+ INT32 TopRow;
+ UINT16 Select;
+ UINT16 LastSelect;
+ UINT8 Index;
+ BOOLEAN Finish;
+ CHAR8 Blank[70];
+ PXEBC_BOOT_MENU_ENTRY *MenuItem;
+ PXEBC_BOOT_MENU_ENTRY *MenuArray[PXEBC_MAX_MENU_NUM];
+
+ Finish = FALSE;
+ Select = 1;
+ Index = 0;
+ *Type = 0;
+
+ if (Private->PxeBc.Mode->ProxyOfferReceived) {
+
+ Packet = &Private->ProxyOffer;
+ } else {
+
+ Packet = &Private->Dhcp4Ack;
+ }
+
+ ASSERT (Packet->OfferType == DHCP4_PACKET_TYPE_PXE10);
+
+ VendorOpt = &Packet->PxeVendorOption;
+
+ if (!IS_VALID_BOOT_MENU (VendorOpt->BitMap)) {
+ return EFI_SUCCESS;
+ }
+
+ SetMem (Blank, sizeof(Blank), ' ');
+
+ MenuSize = VendorOpt->BootMenuLen;
+ MenuItem = VendorOpt->BootMenu;
+
+ while (MenuSize > 0) {
+ MenuArray[Index] = MenuItem;
+ MenuSize = (UINT8) (MenuSize - (MenuItem->DescLen + 3));
+ MenuItem = (PXEBC_BOOT_MENU_ENTRY *) ((UINT8 *) MenuItem + MenuItem->DescLen + 3);
+ Index++;
+ }
+
+ if (UseDefaultItem) {
+ *Type = NTOHS (MenuArray[0]->Type);
+ return EFI_SUCCESS;
+ }
+
+ MenuNum = Index;
+
+ for (Index = 0; Index < MenuNum; Index++) {
+ PxeBcDisplayBootItem (MenuArray[Index]->DescStr, MenuArray[Index]->DescLen);
+ }
+
+ TopRow = gST->ConOut->Mode->CursorRow - MenuNum;
+
+ do {
+ //
+ // highlight selected row
+ //
+ gST->ConOut->SetAttribute (gST->ConOut, EFI_TEXT_ATTR (EFI_BLACK, EFI_LIGHTGRAY));
+ gST->ConOut->SetCursorPosition (gST->ConOut, 0, TopRow + Select);
+ Blank[MenuArray[Select]->DescLen] = 0;
+ AsciiPrint ("%a\r", Blank);
+ PxeBcDisplayBootItem (MenuArray[Select]->DescStr, MenuArray[Select]->DescLen);
+ gST->ConOut->SetCursorPosition (gST->ConOut, 0, TopRow + MenuNum);
+ LastSelect = Select;
+
+ while (gST->ConIn->ReadKeyStroke (gST->ConIn, &InputKey) == EFI_NOT_READY) {
+ gBS->Stall (10 * TICKS_PER_MS);
+ }
+
+ if (!InputKey.ScanCode) {
+ switch (InputKey.UnicodeChar) {
+ case CTRL ('c'):
+ InputKey.ScanCode = SCAN_ESC;
+ break;
+
+ case CTRL ('j'): /* linefeed */
+ case CTRL ('m'): /* return */
+ Finish = TRUE;
+ break;
+
+ case CTRL ('i'): /* tab */
+ case ' ':
+ case 'd':
+ case 'D':
+ InputKey.ScanCode = SCAN_DOWN;
+ break;
+
+ case CTRL ('h'): /* backspace */
+ case 'u':
+ case 'U':
+ InputKey.ScanCode = SCAN_UP;
+ break;
+
+ default:
+ InputKey.ScanCode = 0;
+ }
+ }
+
+ switch (InputKey.ScanCode) {
+ case SCAN_LEFT:
+ case SCAN_UP:
+ if (Select) {
+ --Select;
+ }
+
+ break;
+
+ case SCAN_DOWN:
+ case SCAN_RIGHT:
+ if (++Select == MenuNum) {
+ --Select;
+ }
+
+ break;
+
+ case SCAN_PAGE_UP:
+ case SCAN_HOME:
+ Select = 0;
+ break;
+
+ case SCAN_PAGE_DOWN:
+ case SCAN_END:
+ Select = (UINT16) (MenuNum - 1);
+ break;
+
+ case SCAN_ESC:
+ return EFI_ABORTED;
+ }
+
+ /* unhighlight last selected row */
+ gST->ConOut->SetAttribute (gST->ConOut, EFI_TEXT_ATTR (EFI_LIGHTGRAY, EFI_BLACK));
+ gST->ConOut->SetCursorPosition (gST->ConOut, 0, TopRow + LastSelect);
+ Blank[MenuArray[LastSelect]->DescLen] = 0;
+ AsciiPrint ("%a\r", Blank);
+ PxeBcDisplayBootItem (MenuArray[LastSelect]->DescStr, MenuArray[LastSelect]->DescLen);
+ gST->ConOut->SetCursorPosition (gST->ConOut, 0, TopRow + MenuNum);
+ } while (!Finish);
+
+ //
+ // Swap the byte order
+ //
+ *Type = NTOHS (MenuArray[Select]->Type);
+
+ return EFI_SUCCESS;
+}
+
|