/** @file\r
+ Support for PxeBc dhcp functions.\r
\r
-Copyright (c) 2007, Intel Corporation\r
-All rights reserved. This program and the accompanying materials\r
+Copyright (c) 2013, Red Hat, Inc.\r
+Copyright (c) 2007 - 2018, Intel Corporation. All rights reserved.<BR>\r
+This program and the accompanying materials\r
are licensed and made available under the terms and conditions of the BSD License\r
which accompanies this distribution. The full text of the license may be found at\r
http://opensource.org/licenses/bsd-license.php\r
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
\r
-Module Name:\r
-\r
- PxeBcDhcp.c\r
-\r
-Abstract:\r
-\r
- Support for PxeBc dhcp functions\r
-\r
-\r
**/\r
\r
\r
// This is a map from the interested DHCP4 option tags' index to the tag value.\r
//\r
UINT8 mInterestedDhcp4Tags[PXEBC_DHCP4_TAG_INDEX_MAX] = {\r
- PXEBC_DHCP4_TAG_BOOTFILE_LEN,\r
- PXEBC_DHCP4_TAG_VENDOR,\r
- PXEBC_DHCP4_TAG_OVERLOAD,\r
- PXEBC_DHCP4_TAG_MSG_TYPE,\r
- PXEBC_DHCP4_TAG_SERVER_ID,\r
- PXEBC_DHCP4_TAG_CLASS_ID,\r
- PXEBC_DHCP4_TAG_BOOTFILE\r
+ DHCP4_TAG_BOOTFILE_LEN,\r
+ DHCP4_TAG_VENDOR,\r
+ DHCP4_TAG_OVERLOAD,\r
+ DHCP4_TAG_MSG_TYPE,\r
+ DHCP4_TAG_SERVER_ID,\r
+ DHCP4_TAG_VENDOR_CLASS_ID,\r
+ DHCP4_TAG_BOOTFILE\r
};\r
\r
\r
/**\r
- GC_NOTO: Add function description\r
+ This function initialize the DHCP4 message instance.\r
\r
- @param Seed GC_NOTO: add argument description\r
- @param Udp4 GC_NOTO: add argument description\r
+ This function will pad each item of dhcp4 message packet.\r
\r
- @return GC_NOTO: add return values\r
+ @param Seed Pointer to the message instance of the DHCP4 packet.\r
+ @param Udp4 Pointer to the EFI_UDP4_PROTOCOL instance.\r
\r
**/\r
VOID\r
CopyMem (Header->ClientHwAddr, &Mode.CurrentAddress, Header->HwAddrLen);\r
\r
Seed->Dhcp4.Magik = PXEBC_DHCP4_MAGIC;\r
- Seed->Dhcp4.Option[0] = PXEBC_DHCP4_TAG_EOP;\r
+ Seed->Dhcp4.Option[0] = DHCP4_TAG_EOP;\r
}\r
\r
\r
/**\r
- GC_NOTO: Add function description\r
+ Copy the DCHP4 packet from srouce to destination.\r
\r
- @param Dst GC_NOTO: add argument description\r
- @param Src GC_NOTO: add argument description\r
+ @param[in] Dst Pointer to the cache buffer for DHCPv4 packet.\r
+ @param[in] Src Pointer to the DHCPv4 packet to be cached.\r
\r
- @return GC_NOTO: add return values\r
+ @retval EFI_SUCCESS Packet is copied.\r
+ @retval EFI_BUFFER_TOO_SMALL Cache buffer is not big enough to hold the packet.\r
\r
**/\r
-VOID\r
+EFI_STATUS\r
PxeBcCopyEfiDhcp4Packet (\r
IN EFI_DHCP4_PACKET *Dst,\r
IN EFI_DHCP4_PACKET *Src\r
)\r
{\r
- ASSERT (Dst->Size >= Src->Length);\r
+ if (Dst->Size < Src->Length) {\r
+ return EFI_BUFFER_TOO_SMALL;\r
+ }\r
\r
CopyMem (&Dst->Dhcp4, &Src->Dhcp4, Src->Length);\r
Dst->Length = Src->Length;\r
+ return EFI_SUCCESS;\r
}\r
\r
\r
/**\r
- GC_NOTO: Add function description\r
+ Copy the dhcp4 packet to the PxeBc private data and parse the dhcp4 packet.\r
\r
- @param Private GC_NOTO: add argument description\r
- @param OfferIndex GC_NOTO: add argument description\r
+ @param Private Pointer to PxeBc private data.\r
+ @param OfferIndex Index of cached packets as complements of pxe mode data,\r
+ the index is maximum offer number.\r
\r
- @return GC_NOTO: add return values\r
+ @retval EFI_SUCCESS Cache and parse the packet successfully.\r
+ @retval EFI_BUFFER_TOO_SMALL Cache buffer is not big enough to hold the packet.\r
\r
**/\r
-VOID\r
+EFI_STATUS\r
PxeBcCopyProxyOffer (\r
IN PXEBC_PRIVATE_DATA *Private,\r
IN UINT32 OfferIndex\r
{\r
EFI_PXE_BASE_CODE_MODE *Mode;\r
EFI_DHCP4_PACKET *Offer;\r
+ EFI_STATUS Status;\r
\r
ASSERT (OfferIndex < Private->NumOffers);\r
+ ASSERT (OfferIndex < PXEBC_MAX_OFFER_NUM);\r
\r
Mode = Private->PxeBc.Mode;\r
Offer = &Private->Dhcp4Offers[OfferIndex].Packet.Offer;\r
\r
- PxeBcCopyEfiDhcp4Packet (&Private->ProxyOffer.Packet.Offer, Offer);\r
+ Status = PxeBcCopyEfiDhcp4Packet (&Private->ProxyOffer.Packet.Offer, Offer);\r
+ if (EFI_ERROR(Status)) {\r
+ return Status;\r
+ }\r
CopyMem (&Mode->ProxyOffer, &Offer->Dhcp4, Offer->Length);\r
Mode->ProxyOfferReceived = TRUE;\r
\r
PxeBcParseCachedDhcpPacket (&Private->ProxyOffer);\r
+ return EFI_SUCCESS;\r
}\r
\r
\r
/**\r
Parse the cached dhcp packet.\r
\r
- @param CachedPacket Pointer to cached dhcp packet\r
+ @param CachedPacket Pointer to cached dhcp packet.\r
\r
- @return TRUE : Success to parse and validation\r
- @return FALSE : Fail to parse or validation\r
+ @retval TRUE Succeed to parse and validation.\r
+ @retval FALSE Fail to parse or validation.\r
\r
**/\r
BOOLEAN\r
EFI_DHCP4_PACKET_OPTION *Option;\r
UINT8 OfferType;\r
UINTN Index;\r
+ UINT8 *Ptr8;\r
\r
CachedPacket->IsPxeOffer = FALSE;\r
ZeroMem (CachedPacket->Dhcp4Option, sizeof (CachedPacket->Dhcp4Option));\r
\r
//\r
// Parse interested dhcp options and store their pointers in CachedPacket->Dhcp4Option.\r
+ // First, try to parse DHCPv4 options from the DHCP optional parameters field.\r
//\r
for (Index = 0; Index < PXEBC_DHCP4_TAG_INDEX_MAX; Index++) {\r
Options[Index] = PxeBcParseExtendOptions (\r
- Offer->Dhcp4.Option,\r
- GET_OPTION_BUFFER_LEN (Offer),\r
- mInterestedDhcp4Tags[Index]\r
- );\r
+ Offer->Dhcp4.Option,\r
+ GET_OPTION_BUFFER_LEN (Offer),\r
+ mInterestedDhcp4Tags[Index]\r
+ );\r
+ }\r
+ //\r
+ // Second, Check if bootfilename and serverhostname is overloaded to carry DHCP options refers to rfc-2132.\r
+ // If yes, try to parse options from the BootFileName field, then ServerName field.\r
+ //\r
+ Option = Options[PXEBC_DHCP4_TAG_INDEX_OVERLOAD];\r
+ if (Option != NULL) {\r
+ if ((Option->Data[0] & PXEBC_DHCP4_OVERLOAD_FILE) != 0) {\r
+ for (Index = 0; Index < PXEBC_DHCP4_TAG_INDEX_MAX; Index++) {\r
+ if (Options[Index] == NULL) {\r
+ Options[Index] = PxeBcParseExtendOptions (\r
+ (UINT8 *) Offer->Dhcp4.Header.BootFileName,\r
+ sizeof (Offer->Dhcp4.Header.BootFileName),\r
+ mInterestedDhcp4Tags[Index]\r
+ );\r
+ }\r
+ }\r
+ }\r
+ if ((Option->Data[0] & PXEBC_DHCP4_OVERLOAD_SERVER_NAME) != 0) {\r
+ for (Index = 0; Index < PXEBC_DHCP4_TAG_INDEX_MAX; Index++) {\r
+ if (Options[Index] == NULL) {\r
+ Options[Index] = PxeBcParseExtendOptions (\r
+ (UINT8 *) Offer->Dhcp4.Header.ServerName,\r
+ sizeof (Offer->Dhcp4.Header.ServerName),\r
+ mInterestedDhcp4Tags[Index]\r
+ );\r
+ }\r
+ }\r
+ }\r
}\r
\r
//\r
}\r
}\r
\r
+\r
//\r
- // Check whether bootfilename/serverhostname overloaded (See details in dhcp spec).\r
- // If overloaded, parse this buffer as nested dhcp options, or just parse bootfilename/\r
- // serverhostname option.\r
+ // Parse PXE boot file name:\r
+ // According to PXE spec, boot file name should be read from DHCP option 67 (bootfile name) if present.\r
+ // Otherwise, read from boot file field in DHCP header.\r
//\r
- Option = Options[PXEBC_DHCP4_TAG_INDEX_OVERLOAD];\r
- if ((Option != NULL) && (Option->Data[0] & PXEBC_DHCP4_OVERLOAD_FILE)) {\r
-\r
- Options[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] = PxeBcParseExtendOptions (\r
- (UINT8 *) Offer->Dhcp4.Header.BootFileName,\r
- sizeof (Offer->Dhcp4.Header.BootFileName),\r
- PXEBC_DHCP4_TAG_BOOTFILE\r
- );\r
-\r
- } else if ((Options[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] == NULL) &&\r
- (Offer->Dhcp4.Header.BootFileName[0] != 0)) {\r
+ if (Options[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] != NULL) {\r
+ //\r
+ // RFC 2132, Section 9.5 does not strictly state Bootfile name (option 67) is null\r
+ // terminated string. So force to append null terminated character at the end of string.\r
+ //\r
+ Ptr8 = (UINT8*)&Options[PXEBC_DHCP4_TAG_INDEX_BOOTFILE]->Data[0];\r
+ Ptr8 += Options[PXEBC_DHCP4_TAG_INDEX_BOOTFILE]->Length;\r
+ if (*(Ptr8 - 1) != '\0') {\r
+ *Ptr8 = '\0';\r
+ }\r
+ } else if (Offer->Dhcp4.Header.BootFileName[0] != 0) {\r
//\r
// If the bootfile is not present and bootfilename is present in dhcp packet, just parse it.\r
- // And do not count dhcp option header, or else will destory the serverhostname.\r
+ // And do not count dhcp option header, or else will destroy the serverhostname.\r
//\r
- Options[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] = (EFI_DHCP4_PACKET_OPTION *) (&Offer->Dhcp4.Header.BootFileName[0] -\r
- EFI_FIELD_OFFSET (EFI_DHCP4_PACKET_OPTION, Data[0]));\r
-\r
+ // Make sure "BootFileName" is not overloaded.\r
+ //\r
+ if (Options[PXEBC_DHCP4_TAG_INDEX_OVERLOAD] == NULL ||\r
+ (Options[PXEBC_DHCP4_TAG_INDEX_OVERLOAD]->Data[0] & PXEBC_DHCP4_OVERLOAD_FILE) == 0) {\r
+ Options[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] = (EFI_DHCP4_PACKET_OPTION *) (&Offer->Dhcp4.Header.BootFileName[0] -\r
+ OFFSET_OF (EFI_DHCP4_PACKET_OPTION, Data[0]));\r
+ }\r
}\r
\r
//\r
\r
\r
/**\r
- GC_NOTO: Add function description\r
+ Offer dhcp service with a BINL dhcp offer.\r
\r
- @param Private GC_NOTO: add argument description\r
- @param Index GC_NOTO: add argument description\r
+ @param Private Pointer to PxeBc private data.\r
+ @param Index Index of cached packets as complements of pxe mode data,\r
+ the index is maximum offer number.\r
\r
- @return GC_NOTO: add return values\r
+ @retval TRUE Offer the service successfully under priority BINL.\r
+ @retval FALSE Boot Service failed, parse cached dhcp packet failed or this\r
+ BINL ack cannot find options set or bootfile name specified.\r
\r
**/\r
BOOLEAN\r
PXEBC_CACHED_DHCP4_PACKET *CachedPacket;\r
EFI_DHCP4_PACKET *Reply;\r
\r
+ ASSERT (Index < PXEBC_MAX_OFFER_NUM);\r
ASSERT (Private->Dhcp4Offers[Index].OfferType == DHCP4_PACKET_TYPE_BINL);\r
\r
Offer = &Private->Dhcp4Offers[Index].Packet.Offer;\r
- if (Offer->Dhcp4.Header.ServerAddr.Addr[0] == 0) {\r
- //\r
- // next server ip address is zero, use server id option instead.\r
- //\r
+\r
+ //\r
+ // Use siaddr(next server) in DHCPOFFER packet header, if zero, use option 54(server identifier)\r
+ // in DHCPOFFER packet.\r
+ // (It does not comply with PXE Spec, Ver2.1)\r
+ //\r
+ if (EFI_IP4_EQUAL (&Offer->Dhcp4.Header.ServerAddr.Addr, &mZeroIp4Addr)) {\r
CopyMem (\r
&ServerIp.Addr[0],\r
Private->Dhcp4Offers[Index].Dhcp4Option[PXEBC_DHCP4_TAG_INDEX_SERVER_ID]->Data,\r
sizeof (EFI_IPv4_ADDRESS)\r
);\r
} else {\r
- //\r
- // use next server ip address.\r
- //\r
- CopyMem (&ServerIp.Addr[0], &Offer->Dhcp4.Header.ServerAddr, sizeof (EFI_IPv4_ADDRESS));\r
+ CopyMem (\r
+ &ServerIp.Addr[0],\r
+ &Offer->Dhcp4.Header.ServerAddr,\r
+ sizeof (EFI_IPv4_ADDRESS)\r
+ );\r
+ }\r
+ if (ServerIp.Addr[0] == 0) {\r
+ return FALSE;\r
}\r
\r
CachedPacket = &Private->ProxyOffer;\r
\r
\r
/**\r
- GC_NOTO: Add function description\r
+ Offer dhcp service for each proxy with a BINL dhcp offer.\r
\r
- @param Private GC_NOTO: add argument description\r
- @param OfferIndex GC_NOTO: add argument description\r
+ @param Private Pointer to PxeBc private data\r
+ @param OfferIndex Pointer to the index of cached packets as complements of\r
+ pxe mode data, the index is maximum offer number.\r
\r
- @return GC_NOTO: add return values\r
+ @return If there is no service needed offer return FALSE, otherwise TRUE.\r
\r
**/\r
BOOLEAN\r
\r
\r
/**\r
- GC_NOTO: Add function description\r
+ This function is to check the selected proxy offer (include BINL dhcp offer and\r
+ DHCP_ONLY offer ) and set the flag and copy the DHCP packets to the Pxe base code\r
+ mode structure.\r
\r
- @param Private GC_NOTO: add argument description\r
+ @param Private Pointer to PxeBc private data.\r
\r
- @return GC_NOTO: add return values\r
+ @retval EFI_SUCCESS Operational successful.\r
+ @retval EFI_NO_RESPONSE Offer dhcp service failed.\r
+ @retval EFI_BUFFER_TOO_SMALL Failed to copy the packet to Pxe base code mode.\r
\r
**/\r
EFI_STATUS\r
if (!PxeBcTryBinl (Private, Private->SelectedOffer - 1)) {\r
Status = EFI_NO_RESPONSE;\r
}\r
- } else if ((SelectedOffer->OfferType == DHCP4_PACKET_TYPE_DHCP_ONLY) &&\r
- (Options[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] == NULL)) {\r
+ } else if (SelectedOffer->OfferType == DHCP4_PACKET_TYPE_DHCP_ONLY) {\r
//\r
- // The selected offer to finish the D.O.R.A. is a DHCP only offer and\r
- // bootfile name is not provided in this offer, we need try proxy offers\r
- // to get the bootfile name or the discovery info\r
+ // The selected offer to finish the D.O.R.A. is a DHCP only offer, we need\r
+ // try proxy offers if there are some, othewise the bootfile name must be\r
+ // set in this DHCP only offer.\r
//\r
- ProxyOfferIndex = Private->NumOffers;\r
-\r
- if (Private->SortOffers) {\r
+ if (Private->GotProxyOffer) {\r
//\r
- // Choose proxy offer from the type we stored during DHCP offer selection\r
+ // Get rid of the compiler warning.\r
//\r
- ASSERT (Private->ProxyIndex[Private->ProxyOfferType] > 0);\r
-\r
- if (Private->ProxyOfferType == DHCP4_PACKET_TYPE_BINL) {\r
+ ProxyOfferIndex = 0;\r
+ if (Private->SortOffers) {\r
//\r
- // We buffer all received BINL proxy offers, try them all one by one\r
+ // The offers are sorted before selecting, the proxy offer type must be\r
+ // already determined.\r
//\r
- if (!PxeBcTryBinlProxy (Private, &ProxyOfferIndex)) {\r
- Status = EFI_NO_RESPONSE;\r
+ ASSERT (Private->ProxyIndex[Private->ProxyOfferType] > 0);\r
+\r
+ if (Private->ProxyOfferType == DHCP4_PACKET_TYPE_BINL) {\r
+ //\r
+ // We buffer all received BINL proxy offers, try them all one by one\r
+ //\r
+ if (!PxeBcTryBinlProxy (Private, &ProxyOfferIndex)) {\r
+ Status = EFI_NO_RESPONSE;\r
+ }\r
+ } else {\r
+ //\r
+ // For other types, only one proxy offer is buffered.\r
+ //\r
+ ProxyOfferIndex = Private->ProxyIndex[Private->ProxyOfferType] - 1;\r
}\r
} else {\r
//\r
- // For other types, only one proxy offer is buffered.\r
+ // The proxy offer type is not determined, choose proxy offer in the\r
+ // received order.\r
//\r
- ProxyOfferIndex = Private->ProxyIndex[Private->ProxyOfferType] - 1;\r
- }\r
- } else {\r
- //\r
- // Choose proxy offer in the received order.\r
- //\r
- Status = EFI_NO_RESPONSE;\r
+ Status = EFI_NO_RESPONSE;\r
\r
- for (Index = 0; Index < Private->NumOffers; Index++) {\r
+ ASSERT (Private->NumOffers < PXEBC_MAX_OFFER_NUM);\r
+ for (Index = 0; Index < Private->NumOffers; Index++) {\r
\r
- Offer = &Private->Dhcp4Offers[Index].Packet.Offer;\r
- if (!IS_PROXY_DHCP_OFFER (Offer)) {\r
- //\r
- // Skip non proxy dhcp offers.\r
- //\r
- continue;\r
- }\r
-\r
- if (Private->Dhcp4Offers[Index].OfferType == DHCP4_PACKET_TYPE_BINL) {\r
- //\r
- // Try BINL\r
- //\r
- if (!PxeBcTryBinl (Private, Index)) {\r
+ Offer = &Private->Dhcp4Offers[Index].Packet.Offer;\r
+ if (!IS_PROXY_DHCP_OFFER (Offer)) {\r
//\r
- // Failed, skip to the next offer\r
+ // Skip non proxy dhcp offers.\r
//\r
continue;\r
}\r
- }\r
\r
- Status = EFI_SUCCESS;\r
- break;\r
+ if (Private->Dhcp4Offers[Index].OfferType == DHCP4_PACKET_TYPE_BINL) {\r
+ //\r
+ // Try BINL\r
+ //\r
+ if (!PxeBcTryBinl (Private, Index)) {\r
+ //\r
+ // Failed, skip to the next offer\r
+ //\r
+ continue;\r
+ }\r
+ }\r
+\r
+ Private->ProxyOfferType = Private->Dhcp4Offers[Index].OfferType;\r
+ ProxyOfferIndex = Index;\r
+ Status = EFI_SUCCESS;\r
+ break;\r
+ }\r
}\r
- }\r
\r
- if (!EFI_ERROR (Status) && (Private->ProxyOfferType != DHCP4_PACKET_TYPE_BINL)) {\r
+ if (!EFI_ERROR (Status) && (Private->ProxyOfferType != DHCP4_PACKET_TYPE_BINL)) {\r
+ //\r
+ // Copy the proxy offer to Mode and set the flag\r
+ //\r
+ Status = PxeBcCopyProxyOffer (Private, ProxyOfferIndex);\r
+ }\r
+ } else {\r
//\r
- // Copy the proxy offer to Mode and set the flag\r
+ // No proxy offer is received, the bootfile name MUST be set.\r
//\r
- PxeBcCopyProxyOffer (Private, ProxyOfferIndex);\r
+ ASSERT (Options[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] != NULL);\r
}\r
}\r
\r
// Other type of ACK is already cached. Bootp is special that we should\r
// use the bootp reply as the ACK and put it into the DHCP_ONLY buffer.\r
//\r
- PxeBcCopyEfiDhcp4Packet (&Private->Dhcp4Ack.Packet.Ack, Offer);\r
+ Status = PxeBcCopyEfiDhcp4Packet (&Private->Dhcp4Ack.Packet.Ack, Offer);\r
}\r
\r
PxeBcParseCachedDhcpPacket (&Private->Dhcp4Ack);\r
\r
\r
/**\r
- GC_NOTO: Add function description\r
+ Cache the Dhcp4 packet offer, Parse and validate each option of the packet.\r
\r
- @param Private GC_NOTO: add argument description\r
- @param RcvdOffer GC_NOTO: add argument description\r
+ @param Private Pointer to PxeBc private data.\r
+ @param RcvdOffer Pointer to the received Dhcp proxy offer packet.\r
\r
- @return GC_NOTO: add return values\r
+ @retval EFI_SUCCESS Cache and parse the packet successfully.\r
+ @retval Others Operation failed.\r
\r
**/\r
-VOID\r
+EFI_STATUS\r
PxeBcCacheDhcpOffer (\r
IN PXEBC_PRIVATE_DATA *Private,\r
IN EFI_DHCP4_PACKET *RcvdOffer\r
PXEBC_CACHED_DHCP4_PACKET *CachedOffer;\r
EFI_DHCP4_PACKET *Offer;\r
UINT8 OfferType;\r
+ EFI_STATUS Status;\r
\r
CachedOffer = &Private->Dhcp4Offers[Private->NumOffers];\r
Offer = &CachedOffer->Packet.Offer;\r
//\r
// Cache the orignal dhcp packet\r
//\r
- PxeBcCopyEfiDhcp4Packet (Offer, RcvdOffer);\r
+ Status = PxeBcCopyEfiDhcp4Packet (Offer, RcvdOffer);\r
+ if (EFI_ERROR(Status)) {\r
+ return Status;\r
+ }\r
\r
//\r
// Parse and validate the options (including dhcp option and vendor option)\r
//\r
if (!PxeBcParseCachedDhcpPacket (CachedOffer)) {\r
- return ;\r
+ return EFI_ABORTED;\r
}\r
\r
OfferType = CachedOffer->OfferType;\r
+ if (OfferType >= DHCP4_PACKET_TYPE_MAX) {\r
+ return EFI_ABORTED;\r
+ }\r
\r
if (OfferType == DHCP4_PACKET_TYPE_BOOTP) {\r
\r
//\r
// Only cache the first bootp offer, discard others.\r
//\r
- return ;\r
+ return EFI_ABORTED;\r
} else {\r
//\r
// Take as a dhcp only offer, but record index specifically.\r
//\r
// It's a proxy dhcp offer with no your address, including pxe10, wfm11a or binl offer.\r
//\r
+ Private->GotProxyOffer = TRUE;\r
+\r
if (OfferType == DHCP4_PACKET_TYPE_BINL) {\r
//\r
// Cache all binl offers.\r
//\r
// Only cache the first pxe10/wfm11a offers each, discard the others.\r
//\r
- return ;\r
+ return EFI_ABORTED;\r
} else {\r
//\r
// Record index of the proxy dhcp offer with type other than binl.\r
//\r
// It's a dhcp offer with your address.\r
//\r
+ ASSERT (Private->ServerCount[OfferType] < PXEBC_MAX_OFFER_NUM);\r
Private->OfferIndex[OfferType][Private->ServerCount[OfferType]] = Private->NumOffers;\r
Private->ServerCount[OfferType]++;\r
}\r
// Count the accepted offers.\r
//\r
Private->NumOffers++;\r
-}\r
\r
+ return EFI_SUCCESS;\r
+}\r
\r
/**\r
- GC_NOTO: Add function description\r
+ Switch the Ip4 policy to static.\r
\r
- @param Private GC_NOTO: add argument description\r
+ @param[in] Private The pointer to PXEBC_PRIVATE_DATA.\r
\r
- @return GC_NOTO: add return values\r
+ @retval EFI_SUCCESS The policy is already configured to static.\r
+ @retval Others Other error as indicated..\r
+\r
+**/\r
+EFI_STATUS\r
+PxeBcSetIp4Policy (\r
+ IN PXEBC_PRIVATE_DATA *Private\r
+ )\r
+{\r
+ EFI_STATUS Status;\r
+ EFI_IP4_CONFIG2_PROTOCOL *Ip4Config2;\r
+ EFI_IP4_CONFIG2_POLICY Policy;\r
+ UINTN DataSize;\r
+\r
+ Ip4Config2 = Private->Ip4Config2;\r
+ DataSize = sizeof (EFI_IP4_CONFIG2_POLICY);\r
+ Status = Ip4Config2->GetData (\r
+ Ip4Config2,\r
+ Ip4Config2DataTypePolicy,\r
+ &DataSize,\r
+ &Policy\r
+ );\r
+ if (EFI_ERROR (Status)) {\r
+ return Status;\r
+ }\r
+\r
+ if (Policy != Ip4Config2PolicyStatic) {\r
+ Policy = Ip4Config2PolicyStatic;\r
+ Status= Ip4Config2->SetData (\r
+ Ip4Config2,\r
+ Ip4Config2DataTypePolicy,\r
+ sizeof (EFI_IP4_CONFIG2_POLICY),\r
+ &Policy\r
+ );\r
+ if (EFI_ERROR (Status)) {\r
+ return Status;\r
+ }\r
+ }\r
+\r
+ return EFI_SUCCESS;\r
+}\r
+\r
+\r
+/**\r
+ Select the specified proxy offer, such as BINL, DHCP_ONLY and so on.\r
+ If the proxy does not exist, try offers with bootfile.\r
+\r
+ @param Private Pointer to PxeBc private data.\r
\r
**/\r
VOID\r
UINT32 Index;\r
UINT32 OfferIndex;\r
EFI_DHCP4_PACKET *Offer;\r
- BOOLEAN GotProxyOffer;\r
\r
Private->SelectedOffer = 0;\r
\r
//\r
// Try the offers in the received order.\r
//\r
- GotProxyOffer = FALSE;\r
- for (Index = 0; Index < DHCP4_PACKET_TYPE_MAX; Index++) {\r
-\r
- GotProxyOffer = (BOOLEAN) (Private->ProxyIndex[Index] > 0);\r
- if (GotProxyOffer) {\r
- break;\r
- }\r
- }\r
-\r
for (Index = 0; Index < Private->NumOffers; Index++) {\r
\r
Offer = &Private->Dhcp4Offers[Index].Packet.Offer;\r
}\r
\r
if ((Private->Dhcp4Offers[Index].OfferType == DHCP4_PACKET_TYPE_DHCP_ONLY) &&\r
- ((!GotProxyOffer) && (Private->Dhcp4Offers[Index].Dhcp4Option[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] == NULL))) {\r
+ ((!Private->GotProxyOffer) && (Private->Dhcp4Offers[Index].Dhcp4Option[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] == NULL))) {\r
//\r
// DHCP only offer but no proxy offer received and no bootfile option in this offer\r
//\r
\r
\r
/**\r
- GC_NOTO: Add function description\r
-\r
- @param This GC_NOTO: add argument description\r
- @param Context GC_NOTO: add argument description\r
- @param CurrentState GC_NOTO: add argument description\r
- @param Dhcp4Event GC_NOTO: add argument description\r
- @param Packet GC_NOTO: add argument description\r
- @param NewPacket GC_NOTO: add argument description\r
-\r
- @retval EFI_SUCCESS GC_NOTO: Add description for return value\r
- @retval EFI_ABORTED GC_NOTO: Add description for return value\r
+ Callback routine.\r
+\r
+ EFI_DHCP4_CALLBACK is provided by the consumer of the EFI DHCPv4 Protocol driver\r
+ to intercept events that occurred in the configuration process. This structure\r
+ provides advanced control of each state transition of the DHCP process. The\r
+ returned status code determines the behavior of the EFI DHCPv4 Protocol driver.\r
+ There are three possible returned values, which are described in the following\r
+ table.\r
+\r
+ @param This Pointer to the EFI DHCPv4 Protocol instance that is used to\r
+ configure this callback function.\r
+ @param Context Pointer to the context that is initialized by\r
+ EFI_DHCP4_PROTOCOL.Configure().\r
+ @param CurrentState The current operational state of the EFI DHCPv4 Protocol\r
+ driver.\r
+ @param Dhcp4Event The event that occurs in the current state, which usually means a\r
+ state transition.\r
+ @param Packet The DHCP packet that is going to be sent or already received.\r
+ @param NewPacket The packet that is used to replace the above Packet.\r
+\r
+ @retval EFI_SUCCESS Tells the EFI DHCPv4 Protocol driver to continue the DHCP process.\r
+ @retval EFI_NOT_READY Only used in the Dhcp4Selecting state. The EFI DHCPv4 Protocol\r
+ driver will continue to wait for more DHCPOFFER packets until the retry\r
+ timeout expires.\r
+ @retval EFI_ABORTED Tells the EFI DHCPv4 Protocol driver to abort the current process and\r
+ return to the Dhcp4Init or Dhcp4InitReboot state.\r
\r
**/\r
EFI_STATUS\r
+EFIAPI\r
PxeBcDhcpCallBack (\r
IN EFI_DHCP4_PROTOCOL * This,\r
IN VOID *Context,\r
UINT16 Value;\r
EFI_STATUS Status;\r
BOOLEAN Received;\r
- CHAR8 *SystemSerialNumber;\r
EFI_DHCP4_HEADER *DhcpHeader;\r
\r
if ((Dhcp4Event != Dhcp4RcvdOffer) &&\r
MaxMsgSize = PxeBcParseExtendOptions (\r
Packet->Dhcp4.Option,\r
GET_OPTION_BUFFER_LEN (Packet),\r
- PXEBC_DHCP4_TAG_MAXMSG\r
+ DHCP4_TAG_MAXMSG\r
);\r
if (MaxMsgSize != NULL) {\r
Value = HTONS (PXEBC_DHCP4_MAX_PACKET_SIZE);\r
\r
case Dhcp4SendDiscover:\r
case Dhcp4SendRequest:\r
+ if (Packet->Length > PXEBC_DHCP4_MAX_PACKET_SIZE) {\r
+ //\r
+ // If the to be sent packet exceeds the maximum length, abort the DHCP process.\r
+ //\r
+ Status = EFI_ABORTED;\r
+ break;\r
+ }\r
+\r
if (Mode->SendGUID) {\r
//\r
// send the system GUID instead of the MAC address as the hardware address\r
//\r
DhcpHeader = &Packet->Dhcp4.Header;\r
\r
- if (EFI_ERROR (GetSmbiosSystemGuidAndSerialNumber ((EFI_GUID *) DhcpHeader->ClientHwAddr, &SystemSerialNumber))) {\r
+ if (EFI_ERROR (NetLibGetSystemGuid ((EFI_GUID *) DhcpHeader->ClientHwAddr))) {\r
//\r
// GUID not yet set - send all 0xff's to show programable (via SetVariable)\r
// SetMem(DHCPV4_OPTIONS_BUFFER.DhcpPlatformId.Guid, sizeof(EFI_GUID), 0xff);\r
// GUID not yet set - send all 0's to show not programable\r
//\r
+ DEBUG ((EFI_D_WARN, "PXE: Failed to read system GUID from the smbios table!\n"));\r
ZeroMem (DhcpHeader->ClientHwAddr, sizeof (EFI_GUID));\r
}\r
\r
- DhcpHeader->HwAddrLen = sizeof (EFI_GUID);\r
+ DhcpHeader->HwAddrLen = (UINT8) sizeof (EFI_GUID);\r
}\r
\r
if (Dhcp4Event == Dhcp4SendDiscover) {\r
\r
case Dhcp4RcvdOffer:\r
Status = EFI_NOT_READY;\r
+ if (Packet->Length > PXEBC_DHCP4_MAX_PACKET_SIZE) {\r
+ //\r
+ // Ignore the incoming Offers which exceed the maximum length.\r
+ //\r
+ break;\r
+ }\r
+\r
if (Private->NumOffers < PXEBC_MAX_OFFER_NUM) {\r
//\r
// Cache the dhcp offers in Private->Dhcp4Offers[]\r
+ // If error happens, just ignore this packet and continue to wait more offer.\r
//\r
PxeBcCacheDhcpOffer (Private, Packet);\r
}\r
//\r
ASSERT (Private->SelectedOffer != 0);\r
\r
- PxeBcCopyEfiDhcp4Packet (&Private->Dhcp4Ack.Packet.Ack, Packet);\r
+ Status = PxeBcCopyEfiDhcp4Packet (&Private->Dhcp4Ack.Packet.Ack, Packet);\r
+ if (EFI_ERROR (Status)) {\r
+ return EFI_ABORTED;\r
+ }\r
break;\r
\r
default:\r
\r
\r
/**\r
- GC_NOTO: Add function description\r
+ Initialize the DHCP options and build the option list.\r
\r
- @param Private GC_NOTO: add argument description\r
- @param OptList GC_NOTO: add argument description\r
- @param IsDhcpDiscover GC_NOTO: add argument description\r
+ @param Private Pointer to PxeBc private data.\r
+ @param OptList Pointer to a DHCP option list.\r
\r
- @return GC_NOTO: add return values\r
+ @param IsDhcpDiscover Discover dhcp option or not.\r
+\r
+ @return The index item number of the option list.\r
\r
**/\r
UINT32\r
UINT32 Index;\r
PXEBC_DHCP4_OPTION_ENTRY OptEnt;\r
UINT16 Value;\r
- CHAR8 *SystemSerialNumber;\r
\r
Index = 0;\r
OptList[0] = (EFI_DHCP4_PACKET_OPTION *) Private->OptionBuffer;\r
//\r
// Append message type.\r
//\r
- OptList[Index]->OpCode = PXEBC_DHCP4_TAG_MSG_TYPE;\r
+ OptList[Index]->OpCode = DHCP4_TAG_MSG_TYPE;\r
OptList[Index]->Length = 1;\r
OptEnt.Mesg = (PXEBC_DHCP4_OPTION_MESG *) OptList[Index]->Data;\r
OptEnt.Mesg->Type = PXEBC_DHCP4_MSG_TYPE_REQUEST;\r
//\r
// Append max message size.\r
//\r
- OptList[Index]->OpCode = PXEBC_DHCP4_TAG_MAXMSG;\r
- OptList[Index]->Length = sizeof (PXEBC_DHCP4_OPTION_MAX_MESG_SIZE);\r
+ OptList[Index]->OpCode = DHCP4_TAG_MAXMSG;\r
+ OptList[Index]->Length = (UINT8) sizeof (PXEBC_DHCP4_OPTION_MAX_MESG_SIZE);\r
OptEnt.MaxMesgSize = (PXEBC_DHCP4_OPTION_MAX_MESG_SIZE *) OptList[Index]->Data;\r
Value = NTOHS (PXEBC_DHCP4_MAX_PACKET_SIZE);\r
CopyMem (&OptEnt.MaxMesgSize->Size, &Value, sizeof (UINT16));\r
//\r
// Parameter request list option.\r
//\r
- OptList[Index]->OpCode = PXEBC_DHCP4_TAG_PARA_LIST;\r
+ OptList[Index]->OpCode = DHCP4_TAG_PARA_LIST;\r
OptList[Index]->Length = 35;\r
OptEnt.Para = (PXEBC_DHCP4_OPTION_PARA *) OptList[Index]->Data;\r
- OptEnt.Para->ParaList[0] = PXEBC_DHCP4_TAG_NETMASK;\r
- OptEnt.Para->ParaList[1] = PXEBC_DHCP4_TAG_TIME_OFFSET;\r
- OptEnt.Para->ParaList[2] = PXEBC_DHCP4_TAG_ROUTER;\r
- OptEnt.Para->ParaList[3] = PXEBC_DHCP4_TAG_TIME_SERVER;\r
- OptEnt.Para->ParaList[4] = PXEBC_DHCP4_TAG_NAME_SERVER;\r
- OptEnt.Para->ParaList[5] = PXEBC_DHCP4_TAG_DNS_SERVER;\r
- OptEnt.Para->ParaList[6] = PXEBC_DHCP4_TAG_HOSTNAME;\r
- OptEnt.Para->ParaList[7] = PXEBC_DHCP4_TAG_BOOTFILE_LEN;\r
- OptEnt.Para->ParaList[8] = PXEBC_DHCP4_TAG_DOMAINNAME;\r
- OptEnt.Para->ParaList[9] = PXEBC_DHCP4_TAG_ROOTPATH;\r
- OptEnt.Para->ParaList[10] = PXEBC_DHCP4_TAG_EXTEND_PATH;\r
- OptEnt.Para->ParaList[11] = PXEBC_DHCP4_TAG_EMTU;\r
- OptEnt.Para->ParaList[12] = PXEBC_DHCP4_TAG_TTL;\r
- OptEnt.Para->ParaList[13] = PXEBC_DHCP4_TAG_BROADCAST;\r
- OptEnt.Para->ParaList[14] = PXEBC_DHCP4_TAG_NIS_DOMAIN;\r
- OptEnt.Para->ParaList[15] = PXEBC_DHCP4_TAG_NIS_SERVER;\r
- OptEnt.Para->ParaList[16] = PXEBC_DHCP4_TAG_NTP_SERVER;\r
- OptEnt.Para->ParaList[17] = PXEBC_DHCP4_TAG_VENDOR;\r
- OptEnt.Para->ParaList[18] = PXEBC_DHCP4_TAG_REQUEST_IP;\r
- OptEnt.Para->ParaList[19] = PXEBC_DHCP4_TAG_LEASE;\r
- OptEnt.Para->ParaList[20] = PXEBC_DHCP4_TAG_SERVER_ID;\r
- OptEnt.Para->ParaList[21] = PXEBC_DHCP4_TAG_T1;\r
- OptEnt.Para->ParaList[22] = PXEBC_DHCP4_TAG_T2;\r
- OptEnt.Para->ParaList[23] = PXEBC_DHCP4_TAG_CLASS_ID;\r
- OptEnt.Para->ParaList[24] = PXEBC_DHCP4_TAG_TFTP;\r
- OptEnt.Para->ParaList[25] = PXEBC_DHCP4_TAG_BOOTFILE;\r
- OptEnt.Para->ParaList[26] = PXEBC_PXE_DHCP4_TAG_UUID;\r
+ OptEnt.Para->ParaList[0] = DHCP4_TAG_NETMASK;\r
+ OptEnt.Para->ParaList[1] = DHCP4_TAG_TIME_OFFSET;\r
+ OptEnt.Para->ParaList[2] = DHCP4_TAG_ROUTER;\r
+ OptEnt.Para->ParaList[3] = DHCP4_TAG_TIME_SERVER;\r
+ OptEnt.Para->ParaList[4] = DHCP4_TAG_NAME_SERVER;\r
+ OptEnt.Para->ParaList[5] = DHCP4_TAG_DNS_SERVER;\r
+ OptEnt.Para->ParaList[6] = DHCP4_TAG_HOSTNAME;\r
+ OptEnt.Para->ParaList[7] = DHCP4_TAG_BOOTFILE_LEN;\r
+ OptEnt.Para->ParaList[8] = DHCP4_TAG_DOMAINNAME;\r
+ OptEnt.Para->ParaList[9] = DHCP4_TAG_ROOTPATH;\r
+ OptEnt.Para->ParaList[10] = DHCP4_TAG_EXTEND_PATH;\r
+ OptEnt.Para->ParaList[11] = DHCP4_TAG_EMTU;\r
+ OptEnt.Para->ParaList[12] = DHCP4_TAG_TTL;\r
+ OptEnt.Para->ParaList[13] = DHCP4_TAG_BROADCAST;\r
+ OptEnt.Para->ParaList[14] = DHCP4_TAG_NIS_DOMAIN;\r
+ OptEnt.Para->ParaList[15] = DHCP4_TAG_NIS_SERVER;\r
+ OptEnt.Para->ParaList[16] = DHCP4_TAG_NTP_SERVER;\r
+ OptEnt.Para->ParaList[17] = DHCP4_TAG_VENDOR;\r
+ OptEnt.Para->ParaList[18] = DHCP4_TAG_REQUEST_IP;\r
+ OptEnt.Para->ParaList[19] = DHCP4_TAG_LEASE;\r
+ OptEnt.Para->ParaList[20] = DHCP4_TAG_SERVER_ID;\r
+ OptEnt.Para->ParaList[21] = DHCP4_TAG_T1;\r
+ OptEnt.Para->ParaList[22] = DHCP4_TAG_T2;\r
+ OptEnt.Para->ParaList[23] = DHCP4_TAG_VENDOR_CLASS_ID;\r
+ OptEnt.Para->ParaList[24] = DHCP4_TAG_TFTP;\r
+ OptEnt.Para->ParaList[25] = DHCP4_TAG_BOOTFILE;\r
+ OptEnt.Para->ParaList[26] = DHCP4_TAG_UUID;\r
OptEnt.Para->ParaList[27] = 0x80;\r
OptEnt.Para->ParaList[28] = 0x81;\r
OptEnt.Para->ParaList[29] = 0x82;\r
//\r
// Append UUID/Guid-based client identifier option\r
//\r
- OptList[Index]->OpCode = PXEBC_PXE_DHCP4_TAG_UUID;\r
- OptList[Index]->Length = sizeof (PXEBC_DHCP4_OPTION_UUID);\r
+ OptList[Index]->OpCode = DHCP4_TAG_UUID;\r
+ OptList[Index]->Length = (UINT8) sizeof (PXEBC_DHCP4_OPTION_UUID);\r
OptEnt.Uuid = (PXEBC_DHCP4_OPTION_UUID *) OptList[Index]->Data;\r
OptEnt.Uuid->Type = 0;\r
Index++;\r
OptList[Index] = GET_NEXT_DHCP_OPTION (OptList[Index - 1]);\r
\r
- if (EFI_ERROR (GetSmbiosSystemGuidAndSerialNumber ((EFI_GUID *) OptEnt.Uuid->Guid, &SystemSerialNumber))) {\r
+ if (EFI_ERROR (NetLibGetSystemGuid ((EFI_GUID *) OptEnt.Uuid->Guid))) {\r
//\r
// GUID not yet set - send all 0xff's to show programable (via SetVariable)\r
// SetMem(DHCPV4_OPTIONS_BUFFER.DhcpPlatformId.Guid, sizeof(EFI_GUID), 0xff);\r
// GUID not yet set - send all 0's to show not programable\r
//\r
+ DEBUG ((EFI_D_WARN, "PXE: Failed to read system GUID from the smbios table!\n"));\r
ZeroMem (OptEnt.Uuid->Guid, sizeof (EFI_GUID));\r
}\r
\r
//\r
// Append client network device interface option\r
//\r
- OptList[Index]->OpCode = PXEBC_PXE_DHCP4_TAG_UNDI;\r
- OptList[Index]->Length = sizeof (PXEBC_DHCP4_OPTION_UNDI);\r
+ OptList[Index]->OpCode = DHCP4_TAG_UNDI;\r
+ OptList[Index]->Length = (UINT8) sizeof (PXEBC_DHCP4_OPTION_UNDI);\r
OptEnt.Undi = (PXEBC_DHCP4_OPTION_UNDI *) OptList[Index]->Data;\r
- OptEnt.Undi->Type = Private->Nii->Type;\r
- OptEnt.Undi->MajorVer = Private->Nii->MajorVer;\r
- OptEnt.Undi->MinorVer = Private->Nii->MinorVer;\r
+ if (Private->Nii != NULL) {\r
+ OptEnt.Undi->Type = Private->Nii->Type;\r
+ OptEnt.Undi->MajorVer = Private->Nii->MajorVer;\r
+ OptEnt.Undi->MinorVer = Private->Nii->MinorVer;\r
+ } else {\r
+ OptEnt.Undi->Type = DEFAULT_UNDI_TYPE;\r
+ OptEnt.Undi->MajorVer = DEFAULT_UNDI_MAJOR;\r
+ OptEnt.Undi->MinorVer = DEFAULT_UNDI_MINOR;\r
+ }\r
\r
Index++;\r
OptList[Index] = GET_NEXT_DHCP_OPTION (OptList[Index - 1]);\r
//\r
// Append client system architecture option\r
//\r
- OptList[Index]->OpCode = PXEBC_PXE_DHCP4_TAG_ARCH;\r
- OptList[Index]->Length = sizeof (PXEBC_DHCP4_OPTION_ARCH);\r
+ OptList[Index]->OpCode = DHCP4_TAG_ARCH;\r
+ OptList[Index]->Length = (UINT8) sizeof (PXEBC_DHCP4_OPTION_ARCH);\r
OptEnt.Arch = (PXEBC_DHCP4_OPTION_ARCH *) OptList[Index]->Data;\r
- Value = HTONS (SYS_ARCH);\r
+ Value = HTONS (EFI_PXE_CLIENT_SYSTEM_ARCHITECTURE);\r
CopyMem (&OptEnt.Arch->Type, &Value, sizeof (UINT16));\r
Index++;\r
OptList[Index] = GET_NEXT_DHCP_OPTION (OptList[Index - 1]);\r
//\r
// Append client system architecture option\r
//\r
- OptList[Index]->OpCode = PXEBC_DHCP4_TAG_CLASS_ID;\r
- OptList[Index]->Length = sizeof (PXEBC_DHCP4_OPTION_CLID);\r
+ OptList[Index]->OpCode = DHCP4_TAG_VENDOR_CLASS_ID;\r
+ OptList[Index]->Length = (UINT8) sizeof (PXEBC_DHCP4_OPTION_CLID);\r
OptEnt.Clid = (PXEBC_DHCP4_OPTION_CLID *) OptList[Index]->Data;\r
CopyMem (OptEnt.Clid, DEFAULT_CLASS_ID_DATA, sizeof (PXEBC_DHCP4_OPTION_CLID));\r
- CvtNum (SYS_ARCH, OptEnt.Clid->ArchitectureType, sizeof (OptEnt.Clid->ArchitectureType));\r
- CopyMem (OptEnt.Clid->InterfaceName, Private->Nii->StringId, sizeof (OptEnt.Clid->InterfaceName));\r
- CvtNum (Private->Nii->MajorVer, OptEnt.Clid->UndiMajor, sizeof (OptEnt.Clid->UndiMajor));\r
- CvtNum (Private->Nii->MinorVer, OptEnt.Clid->UndiMinor, sizeof (OptEnt.Clid->UndiMinor));\r
+ CvtNum (EFI_PXE_CLIENT_SYSTEM_ARCHITECTURE, OptEnt.Clid->ArchitectureType, sizeof (OptEnt.Clid->ArchitectureType));\r
+\r
+ if (Private->Nii != NULL) {\r
+ //\r
+ // If NII protocol exists, update DHCP option data\r
+ //\r
+ CopyMem (OptEnt.Clid->InterfaceName, Private->Nii->StringId, sizeof (OptEnt.Clid->InterfaceName));\r
+ CvtNum (Private->Nii->MajorVer, OptEnt.Clid->UndiMajor, sizeof (OptEnt.Clid->UndiMajor));\r
+ CvtNum (Private->Nii->MinorVer, OptEnt.Clid->UndiMinor, sizeof (OptEnt.Clid->UndiMinor));\r
+ }\r
+\r
Index++;\r
\r
return Index;\r
\r
\r
/**\r
- GC_NOTO: Add function description\r
-\r
- @param Private GC_NOTO: add argument description\r
- @param Type GC_NOTO: add argument description\r
- @param Layer GC_NOTO: add argument description\r
- @param UseBis GC_NOTO: add argument description\r
- @param DestIp GC_NOTO: add argument description\r
- @param IpCount GC_NOTO: add argument description\r
- @param SrvList GC_NOTO: add argument description\r
- @param IsDiscv GC_NOTO: add argument description\r
- @param Reply GC_NOTO: add argument description\r
-\r
- @retval EFI_OUT_OF_RESOURCES GC_NOTO: Add description for return value\r
+ Discover the boot of service and initialize the vendor option if exists.\r
+\r
+ @param Private Pointer to PxeBc private data.\r
+ @param Type PxeBc option boot item type\r
+ @param Layer PxeBc option boot item layer\r
+ @param UseBis Use BIS or not\r
+ @param DestIp Ip address for server\r
+ @param IpCount The total count of the server ip address\r
+ @param SrvList Server list\r
+ @param IsDiscv Discover the vendor or not\r
+ @param Reply The dhcp4 packet of Pxe reply\r
+\r
+ @retval EFI_SUCCESS Operation succeeds.\r
+ @retval EFI_OUT_OF_RESOURCES Allocate memory pool failed.\r
+ @retval EFI_NOT_FOUND There is no vendor option exists.\r
+ @retval EFI_TIMEOUT Send Pxe Discover time out.\r
\r
**/\r
EFI_STATUS\r
EFI_DHCP4_PACKET_OPTION *PxeOpt;\r
PXEBC_OPTION_BOOT_ITEM *PxeBootItem;\r
UINT8 VendorOptLen;\r
- CHAR8 *SystemSerialNumber;\r
EFI_DHCP4_HEADER *DhcpHeader;\r
-\r
+ UINT32 Xid;\r
\r
Mode = Private->PxeBc.Mode;\r
Dhcp4 = Private->Dhcp4;\r
OptCount = PxeBcBuildDhcpOptions (Private, OptList, FALSE);\r
\r
if (IsDiscv) {\r
+ ASSERT (Layer != NULL);\r
//\r
// Add vendor option of PXE_BOOT_ITEM\r
//\r
- VendorOptLen = (sizeof (EFI_DHCP4_PACKET_OPTION) - 1) * 2 + sizeof (PXEBC_OPTION_BOOT_ITEM) + 1;\r
+ VendorOptLen = (UINT8) ((sizeof (EFI_DHCP4_PACKET_OPTION) - 1) * 2 + sizeof (PXEBC_OPTION_BOOT_ITEM) + 1);\r
OptList[OptCount] = AllocatePool (VendorOptLen);\r
if (OptList[OptCount] == NULL) {\r
return EFI_OUT_OF_RESOURCES;\r
}\r
\r
- OptList[OptCount]->OpCode = PXEBC_DHCP4_TAG_VENDOR;\r
+ OptList[OptCount]->OpCode = DHCP4_TAG_VENDOR;\r
OptList[OptCount]->Length = (UINT8) (VendorOptLen - 2);\r
PxeOpt = (EFI_DHCP4_PACKET_OPTION *) OptList[OptCount]->Data;\r
PxeOpt->OpCode = PXEBC_VENDOR_TAG_BOOT_ITEM;\r
- PxeOpt->Length = sizeof (PXEBC_OPTION_BOOT_ITEM);\r
+ PxeOpt->Length = (UINT8) sizeof (PXEBC_OPTION_BOOT_ITEM);\r
PxeBootItem = (PXEBC_OPTION_BOOT_ITEM *) PxeOpt->Data;\r
PxeBootItem->Type = HTONS (Type);\r
PxeBootItem->Layer = HTONS (*Layer);\r
- PxeOpt->Data[PxeOpt->Length] = PXEBC_DHCP4_TAG_EOP;\r
+ PxeOpt->Data[PxeOpt->Length] = DHCP4_TAG_EOP;\r
\r
OptCount++;\r
}\r
Status = Dhcp4->Build (Dhcp4, &Private->SeedPacket, 0, NULL, OptCount, OptList, &Token.Packet);\r
\r
if (IsDiscv) {\r
- gBS->FreePool (OptList[OptCount - 1]);\r
+ FreePool (OptList[OptCount - 1]);\r
}\r
\r
if (EFI_ERROR (Status)) {\r
\r
DhcpHeader = &Token.Packet->Dhcp4.Header;\r
if (Mode->SendGUID) {\r
- if (EFI_ERROR (GetSmbiosSystemGuidAndSerialNumber ((EFI_GUID *) DhcpHeader->ClientHwAddr, &SystemSerialNumber))) {\r
+ if (EFI_ERROR (NetLibGetSystemGuid ((EFI_GUID *) DhcpHeader->ClientHwAddr))) {\r
//\r
// GUID not yet set - send all 0's to show not programable\r
//\r
+ DEBUG ((EFI_D_WARN, "PXE: Failed to read system GUID from the smbios table!\n"));\r
ZeroMem (DhcpHeader->ClientHwAddr, sizeof (EFI_GUID));\r
}\r
\r
- DhcpHeader->HwAddrLen = sizeof (EFI_GUID);\r
+ DhcpHeader->HwAddrLen = (UINT8) sizeof (EFI_GUID);\r
}\r
\r
- Token.Packet->Dhcp4.Header.Xid = NET_RANDOM (NetRandomInitSeed ());\r
- Token.Packet->Dhcp4.Header.Reserved = (UINT16) ((IsBCast) ? 0xf000 : 0x0);\r
+ Xid = NET_RANDOM (NetRandomInitSeed ());\r
+ Token.Packet->Dhcp4.Header.Xid = HTONL(Xid);\r
+ Token.Packet->Dhcp4.Header.Reserved = HTONS((UINT16) ((IsBCast) ? 0x8000 : 0));\r
CopyMem (&Token.Packet->Dhcp4.Header.ClientAddr, &Private->StationIp, sizeof (EFI_IPv4_ADDRESS));\r
\r
Token.RemotePort = Sport;\r
\r
- if (DestIp == NULL) {\r
+ if (IsBCast) {\r
SetMem (&Token.RemoteAddress, sizeof (EFI_IPv4_ADDRESS), 0xff);\r
} else {\r
CopyMem (&Token.RemoteAddress, DestIp, sizeof (EFI_IPv4_ADDRESS));\r
//\r
for (TryIndex = 1; TryIndex <= PXEBC_BOOT_REQUEST_RETRIES; TryIndex++) {\r
\r
- Token.TimeoutValue = PXEBC_BOOT_REQUEST_TIMEOUT * TryIndex;\r
+ Token.TimeoutValue = (UINT16) (PXEBC_BOOT_REQUEST_TIMEOUT * TryIndex);\r
+ Token.Packet->Dhcp4.Header.Seconds = (UINT16) (PXEBC_BOOT_REQUEST_TIMEOUT * (TryIndex - 1));\r
\r
Status = Dhcp4->TransmitReceive (Dhcp4, &Token);\r
\r
}\r
}\r
\r
+ if (TryIndex > PXEBC_BOOT_REQUEST_RETRIES) {\r
+ //\r
+ // No server response our PXE request\r
+ //\r
+ Status = EFI_TIMEOUT;\r
+ }\r
+\r
if (!EFI_ERROR (Status)) {\r
//\r
// Find Pxe Reply\r
Response = Token.ResponseList;\r
\r
while (RepIndex < Token.ResponseCount) {\r
+ if (Response->Length > PXEBC_DHCP4_MAX_PACKET_SIZE) {\r
+ SrvIndex = 0;\r
+ RepIndex++;\r
+ Response = (EFI_DHCP4_PACKET *) ((UINT8 *) Response + Response->Size);\r
+ continue;\r
+ }\r
\r
while (SrvIndex < IpCount) {\r
\r
\r
SrvIndex = 0;\r
RepIndex++;\r
-\r
Response = (EFI_DHCP4_PACKET *) ((UINT8 *) Response + Response->Size);\r
}\r
\r
if (RepIndex < Token.ResponseCount) {\r
\r
if (Reply != NULL) {\r
- PxeBcCopyEfiDhcp4Packet (Reply, Response);\r
+ Status = PxeBcCopyEfiDhcp4Packet (Reply, Response);\r
+ if (EFI_ERROR(Status)) {\r
+ goto ON_EXIT;\r
+ }\r
}\r
\r
if (IsDiscv) {\r
} else {\r
Status = EFI_NOT_FOUND;\r
}\r
+ }\r
\r
- //\r
- // free the responselist\r
- //\r
- gBS->FreePool (Token.ResponseList);\r
+ON_EXIT:\r
+ //\r
+ // free the responselist\r
+ //\r
+ if (Token.ResponseList != NULL) {\r
+ FreePool (Token.ResponseList);\r
}\r
//\r
// Free the dhcp packet\r
//\r
- gBS->FreePool (Token.Packet);\r
+ if (Token.Packet != NULL) {\r
+ FreePool (Token.Packet);\r
+ }\r
\r
return Status;\r
}\r
\r
\r
/**\r
- GC_NOTO: Add function description\r
+ Parse interested dhcp options.\r
\r
- @param Buffer GC_NOTO: add argument description\r
- @param Length GC_NOTO: add argument description\r
- @param OptTag GC_NOTO: add argument description\r
+ @param Buffer Pointer to the dhcp options packet.\r
+ @param Length The length of the dhcp options.\r
+ @param OptTag The option OpCode.\r
\r
- @return GC_NOTO: add return values\r
+ @return NULL if the buffer length is 0 and OpCode is not\r
+ DHCP4_TAG_EOP, or the pointer to the buffer.\r
\r
**/\r
EFI_DHCP4_PACKET_OPTION *\r
Option = (EFI_DHCP4_PACKET_OPTION *) Buffer;\r
Offset = 0;\r
\r
- while (Offset < Length && Option->OpCode != PXEBC_DHCP4_TAG_EOP) {\r
+ while (Offset < Length && Option->OpCode != DHCP4_TAG_EOP) {\r
\r
if (Option->OpCode == OptTag) {\r
\r
return Option;\r
}\r
\r
- if (Option->OpCode == PXEBC_DHCP4_TAG_PAD) {\r
+ if (Option->OpCode == DHCP4_TAG_PAD) {\r
Offset++;\r
} else {\r
Offset += Option->Length + 2;\r
@param Dhcp4Option Pointer to dhcp options\r
@param VendorOption Pointer to vendor options\r
\r
- @return TRUE : Valid vendor options\r
- @return FALSE : Invalid vendor options\r
+ @return TRUE if valid for vendor options, or FALSE.\r
\r
**/\r
BOOLEAN\r
PxeOption = (EFI_DHCP4_PACKET_OPTION *) &Dhcp4Option->Data[0];\r
Offset = 0;\r
\r
- while ((Offset < VendorOptionLen) && (PxeOption->OpCode != PXEBC_DHCP4_TAG_EOP)) {\r
+ while ((Offset < VendorOptionLen) && (PxeOption->OpCode != DHCP4_TAG_EOP)) {\r
//\r
// Parse every Vendor Option and set its BitMap\r
//\r
\r
SET_VENDOR_OPTION_BIT_MAP (BitMap, PxeOption->OpCode);\r
\r
- if (PxeOption->OpCode == PXEBC_DHCP4_TAG_PAD) {\r
+ if (PxeOption->OpCode == DHCP4_TAG_PAD) {\r
Offset++;\r
} else {\r
Offset = (UINT8) (Offset + PxeOption->Length + 2);\r
\r
\r
/**\r
- GC_NOTO: Add function description\r
+ This function display boot item detail.\r
\r
- @param Str GC_NOTO: add argument description\r
- @param Len GC_NOTO: add argument description\r
+ If the length of the boot item string over 70 Char, just display 70 Char.\r
\r
- @return GC_NOTO: add return values\r
+ @param Str Pointer to a string (boot item string).\r
+ @param Len The length of string.\r
\r
**/\r
VOID\r
\r
\r
/**\r
- GC_NOTO: Add function description\r
+ Choose the boot prompt.\r
\r
- @param Private GC_NOTO: add argument description\r
+ @param Private Pointer to PxeBc private data.\r
\r
- @retval EFI_SUCCESS GC_NOTO: Add description for return value\r
- @retval EFI_TIMEOUT GC_NOTO: Add description for return value\r
+ @retval EFI_SUCCESS Select boot prompt done.\r
+ @retval EFI_TIMEOUT Select boot prompt time out.\r
+ @retval EFI_NOT_FOUND The proxy offer is not Pxe10.\r
+ @retval EFI_ABORTED User cancel the operation.\r
+ @retval EFI_NOT_READY Read the input key from the keybroad has not finish.\r
\r
**/\r
EFI_STATUS\r
}\r
\r
VendorOpt = &Packet->PxeVendorOption;\r
+ //\r
+ // According to the PXE specification 2.1, Table 2-1 PXE DHCP Options (Full\r
+ // List), we must not consider a boot prompt or boot menu if all of the\r
+ // following hold:\r
+ // - the PXE_DISCOVERY_CONTROL PXE tag is present inside the Vendor Options\r
+ // (=43) DHCP tag, and\r
+ // - the PXE_DISCOVERY_CONTROL PXE tag has bit 3 set, and\r
+ // - a boot file name has been presented with DHCP option 67.\r
+ //\r
+ if (IS_DISABLE_PROMPT_MENU (VendorOpt->DiscoverCtrl) &&\r
+ Packet->Dhcp4Option[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] != NULL) {\r
+ return EFI_ABORTED;\r
+ }\r
\r
if (!IS_VALID_BOOT_PROMPT (VendorOpt->BitMap)) {\r
return EFI_SUCCESS;\r
Status = gBS->SetTimer (\r
TimeoutEvent,\r
TimerRelative,\r
- Timeout * TICKS_PER_SECOND\r
+ MultU64x32 (Timeout, TICKS_PER_SECOND)\r
);\r
\r
if (EFI_ERROR (Status)) {\r
\r
\r
/**\r
- GC_NOTO: Add function description\r
+ Select the boot menu.\r
\r
- @param Private GC_NOTO: add argument description\r
- @param Type GC_NOTO: add argument description\r
+ @param Private Pointer to PxeBc private data.\r
+ @param Type The type of the menu.\r
+ @param UseDefaultItem Use default item or not.\r
\r
- @retval EFI_ABORTED GC_NOTO: Add description for return value\r
- @retval EFI_SUCCESS GC_NOTO: Add description for return value\r
+ @retval EFI_ABORTED User cancel operation.\r
+ @retval EFI_SUCCESS Select the boot menu success.\r
+ @retval EFI_NOT_READY Read the input key from the keybroad has not finish.\r
\r
**/\r
EFI_STATUS\r
)\r
{\r
PXEBC_CACHED_DHCP4_PACKET *Packet;\r
- PXEBC_VENDOR_OPTION *VendorOpt;\r
+ PXEBC_VENDOR_OPTION *VendorOpt;\r
EFI_INPUT_KEY InputKey;\r
UINT8 MenuSize;\r
UINT8 MenuNum;\r
PXEBC_BOOT_MENU_ENTRY *MenuArray[PXEBC_MAX_MENU_NUM];\r
\r
Finish = FALSE;\r
- Select = 1;\r
+ Select = 0;\r
Index = 0;\r
*Type = 0;\r
\r
MenuSize = VendorOpt->BootMenuLen;\r
MenuItem = VendorOpt->BootMenu;\r
\r
+ if (MenuSize == 0) {\r
+ return EFI_NOT_READY;\r
+ }\r
+\r
while (MenuSize > 0) {\r
- MenuArray[Index] = MenuItem;\r
+ MenuArray[Index++] = MenuItem;\r
MenuSize = (UINT8) (MenuSize - (MenuItem->DescLen + 3));\r
MenuItem = (PXEBC_BOOT_MENU_ENTRY *) ((UINT8 *) MenuItem + MenuItem->DescLen + 3);\r
- Index++;\r
+ if (Index >= PXEBC_MAX_MENU_NUM) {\r
+ break;\r
+ }\r
}\r
\r
if (UseDefaultItem) {\r
- *Type = NTOHS (MenuArray[0]->Type);\r
+ *Type = MenuArray[0]->Type;\r
+ *Type = NTOHS (*Type);\r
return EFI_SUCCESS;\r
}\r
\r
TopRow = gST->ConOut->Mode->CursorRow - MenuNum;\r
\r
do {\r
+ ASSERT (Select < PXEBC_MAX_MENU_NUM);\r
//\r
// highlight selected row\r
//\r
gBS->Stall (10 * TICKS_PER_MS);\r
}\r
\r
- if (!InputKey.ScanCode) {\r
+ if (InputKey.ScanCode == 0) {\r
switch (InputKey.UnicodeChar) {\r
case CTRL ('c'):\r
InputKey.ScanCode = SCAN_ESC;\r
switch (InputKey.ScanCode) {\r
case SCAN_LEFT:\r
case SCAN_UP:\r
- if (Select) {\r
+ if (Select > 0) {\r
--Select;\r
}\r
\r
gST->ConOut->SetCursorPosition (gST->ConOut, 0, TopRow + MenuNum);\r
} while (!Finish);\r
\r
+ ASSERT (Select < PXEBC_MAX_MENU_NUM);\r
+\r
//\r
// Swap the byte order\r
//\r
- *Type = NTOHS (MenuArray[Select]->Type);\r
+ CopyMem (Type, &MenuArray[Select]->Type, sizeof (UINT16));\r
+ *Type = NTOHS (*Type);\r
\r
return EFI_SUCCESS;\r
}\r
projects / mirror_edk2.git / blobdiff