[mirror_edk2.git] / NetworkPkg / UefiPxeBcDxe / PxeBcDhcp6.c

/** @file\r
  Functions implementation related with DHCPv6 for UefiPxeBc Driver.\r
\r
  (C) Copyright 2014 Hewlett-Packard Development Company, L.P.<BR>\r
  Copyright (c) 2009 - 2018, Intel Corporation. All rights reserved.<BR>\r
\r
  SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#include "PxeBcImpl.h"\r
\r
//\r
// Well-known multi-cast address defined in section-24.1 of rfc-3315\r
//\r
//   ALL_DHCP_Relay_Agents_and_Servers address: FF02::1:2\r
//\r
EFI_IPv6_ADDRESS  mAllDhcpRelayAndServersAddress = {\r
  { 0xFF, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 2 }\r
};\r
\r
/**\r
  Parse out a DHCPv6 option by OptTag, and find the position in buffer.\r
\r
  @param[in]  Buffer        The pointer to the option buffer.\r
  @param[in]  Length        Length of the option buffer.\r
  @param[in]  OptTag        The required option tag.\r
\r
  @retval     NULL          Failed to parse the required option.\r
  @retval     Others        The position of the required option in buffer.\r
\r
**/\r
EFI_DHCP6_PACKET_OPTION *\r
PxeBcParseDhcp6Options (\r
  IN UINT8   *Buffer,\r
  IN UINT32  Length,\r
  IN UINT16  OptTag\r
  )\r
{\r
  EFI_DHCP6_PACKET_OPTION  *Option;\r
  UINT32                   Offset;\r
\r
  Option = (EFI_DHCP6_PACKET_OPTION *)Buffer;\r
  Offset = 0;\r
\r
  //\r
  // OpLen and OpCode here are both stored in network order.\r
  //\r
  while (Offset < Length) {\r
    if (NTOHS (Option->OpCode) == OptTag) {\r
      return Option;\r
    }\r
\r
    Offset += (NTOHS (Option->OpLen) + 4);\r
    Option  = (EFI_DHCP6_PACKET_OPTION *)(Buffer + Offset);\r
  }\r
\r
  return NULL;\r
}\r
\r
/**\r
  Build the options buffer for the DHCPv6 request packet.\r
\r
  @param[in]  Private             The pointer to PxeBc private data.\r
  @param[out] OptList             The pointer to the option pointer array.\r
  @param[in]  Buffer              The pointer to the buffer to contain the option list.\r
\r
  @return     Index               The count of the built-in options.\r
\r
**/\r
UINT32\r
PxeBcBuildDhcp6Options (\r
  IN  PXEBC_PRIVATE_DATA       *Private,\r
  OUT EFI_DHCP6_PACKET_OPTION  **OptList,\r
  IN  UINT8                    *Buffer\r
  )\r
{\r
  PXEBC_DHCP6_OPTION_ENTRY  OptEnt;\r
  UINT32                    Index;\r
  UINT16                    Value;\r
\r
  Index      = 0;\r
  OptList[0] = (EFI_DHCP6_PACKET_OPTION *)Buffer;\r
\r
  //\r
  // Append client option request option\r
  //\r
  OptList[Index]->OpCode = HTONS (DHCP6_OPT_ORO);\r
  OptList[Index]->OpLen  = HTONS (8);\r
  OptEnt.Oro             = (PXEBC_DHCP6_OPTION_ORO *)OptList[Index]->Data;\r
  OptEnt.Oro->OpCode[0]  = HTONS (DHCP6_OPT_BOOT_FILE_URL);\r
  OptEnt.Oro->OpCode[1]  = HTONS (DHCP6_OPT_BOOT_FILE_PARAM);\r
  OptEnt.Oro->OpCode[2]  = HTONS (DHCP6_OPT_DNS_SERVERS);\r
  OptEnt.Oro->OpCode[3]  = HTONS (DHCP6_OPT_VENDOR_CLASS);\r
  Index++;\r
  OptList[Index] = GET_NEXT_DHCP6_OPTION (OptList[Index - 1]);\r
\r
  //\r
  // Append client network device interface option\r
  //\r
  OptList[Index]->OpCode = HTONS (DHCP6_OPT_UNDI);\r
  OptList[Index]->OpLen  = HTONS ((UINT16)3);\r
  OptEnt.Undi            = (PXEBC_DHCP6_OPTION_UNDI *)OptList[Index]->Data;\r
\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_DHCP6_OPTION (OptList[Index - 1]);\r
\r
  //\r
  // Append client system architecture option\r
  //\r
  OptList[Index]->OpCode = HTONS (DHCP6_OPT_ARCH);\r
  OptList[Index]->OpLen  = HTONS ((UINT16)sizeof (PXEBC_DHCP6_OPTION_ARCH));\r
  OptEnt.Arch            = (PXEBC_DHCP6_OPTION_ARCH *)OptList[Index]->Data;\r
  Value                  = HTONS (EFI_PXE_CLIENT_SYSTEM_ARCHITECTURE);\r
  CopyMem (&OptEnt.Arch->Type, &Value, sizeof (UINT16));\r
  Index++;\r
  OptList[Index] = GET_NEXT_DHCP6_OPTION (OptList[Index - 1]);\r
\r
  //\r
  // Append vendor class option to store the PXE class identifier.\r
  //\r
  OptList[Index]->OpCode       = HTONS (DHCP6_OPT_VENDOR_CLASS);\r
  OptList[Index]->OpLen        = HTONS ((UINT16)sizeof (PXEBC_DHCP6_OPTION_VENDOR_CLASS));\r
  OptEnt.VendorClass           = (PXEBC_DHCP6_OPTION_VENDOR_CLASS *)OptList[Index]->Data;\r
  OptEnt.VendorClass->Vendor   = HTONL (PXEBC_DHCP6_ENTERPRISE_NUM);\r
  OptEnt.VendorClass->ClassLen = HTONS ((UINT16)sizeof (PXEBC_CLASS_ID));\r
  CopyMem (\r
    &OptEnt.VendorClass->ClassId,\r
    DEFAULT_CLASS_ID_DATA,\r
    sizeof (PXEBC_CLASS_ID)\r
    );\r
  PxeBcUintnToAscDecWithFormat (\r
    EFI_PXE_CLIENT_SYSTEM_ARCHITECTURE,\r
    OptEnt.VendorClass->ClassId.ArchitectureType,\r
    sizeof (OptEnt.VendorClass->ClassId.ArchitectureType)\r
    );\r
\r
  if (Private->Nii != NULL) {\r
    CopyMem (\r
      OptEnt.VendorClass->ClassId.InterfaceName,\r
      Private->Nii->StringId,\r
      sizeof (OptEnt.VendorClass->ClassId.InterfaceName)\r
      );\r
    PxeBcUintnToAscDecWithFormat (\r
      Private->Nii->MajorVer,\r
      OptEnt.VendorClass->ClassId.UndiMajor,\r
      sizeof (OptEnt.VendorClass->ClassId.UndiMajor)\r
      );\r
    PxeBcUintnToAscDecWithFormat (\r
      Private->Nii->MinorVer,\r
      OptEnt.VendorClass->ClassId.UndiMinor,\r
      sizeof (OptEnt.VendorClass->ClassId.UndiMinor)\r
      );\r
  }\r
\r
  Index++;\r
\r
  return Index;\r
}\r
\r
/**\r
  Cache the DHCPv6 packet.\r
\r
  @param[in]  Dst          The pointer to the cache buffer for DHCPv6 packet.\r
  @param[in]  Src          The pointer to the DHCPv6 packet to be cached.\r
\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
EFI_STATUS\r
PxeBcCacheDhcp6Packet (\r
  IN EFI_DHCP6_PACKET  *Dst,\r
  IN EFI_DHCP6_PACKET  *Src\r
  )\r
{\r
  if (Dst->Size < Src->Length) {\r
    return EFI_BUFFER_TOO_SMALL;\r
  }\r
\r
  CopyMem (&Dst->Dhcp6, &Src->Dhcp6, Src->Length);\r
  Dst->Length = Src->Length;\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Retrieve the boot server address using the EFI_DNS6_PROTOCOL.\r
\r
  @param[in]  Private             Pointer to PxeBc private data.\r
  @param[in]  HostName            Pointer to buffer containing hostname.\r
  @param[out] IpAddress           On output, pointer to buffer containing IPv6 address.\r
\r
  @retval EFI_SUCCESS             Operation succeeded.\r
  @retval EFI_OUT_OF_RESOURCES    Failed to allocate needed resources.\r
  @retval EFI_DEVICE_ERROR        An unexpected network error occurred.\r
  @retval Others                  Other errors as indicated.\r
\r
**/\r
EFI_STATUS\r
PxeBcDns6 (\r
  IN PXEBC_PRIVATE_DATA  *Private,\r
  IN     CHAR16          *HostName,\r
  OUT EFI_IPv6_ADDRESS   *IpAddress\r
  )\r
{\r
  EFI_STATUS                 Status;\r
  EFI_DNS6_PROTOCOL          *Dns6;\r
  EFI_DNS6_CONFIG_DATA       Dns6ConfigData;\r
  EFI_DNS6_COMPLETION_TOKEN  Token;\r
  EFI_HANDLE                 Dns6Handle;\r
  EFI_IPv6_ADDRESS           *DnsServerList;\r
  BOOLEAN                    IsDone;\r
\r
  Dns6          = NULL;\r
  Dns6Handle    = NULL;\r
  DnsServerList = Private->DnsServer;\r
  ZeroMem (&Token, sizeof (EFI_DNS6_COMPLETION_TOKEN));\r
\r
  //\r
  // Create a DNSv6 child instance and get the protocol.\r
  //\r
  Status = NetLibCreateServiceChild (\r
             Private->Controller,\r
             Private->Image,\r
             &gEfiDns6ServiceBindingProtocolGuid,\r
             &Dns6Handle\r
             );\r
  if (EFI_ERROR (Status)) {\r
    goto Exit;\r
  }\r
\r
  Status = gBS->OpenProtocol (\r
                  Dns6Handle,\r
                  &gEfiDns6ProtocolGuid,\r
                  (VOID **)&Dns6,\r
                  Private->Image,\r
                  Private->Controller,\r
                  EFI_OPEN_PROTOCOL_BY_DRIVER\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    goto Exit;\r
  }\r
\r
  //\r
  // Configure DNS6 instance for the DNS server address and protocol.\r
  //\r
  ZeroMem (&Dns6ConfigData, sizeof (EFI_DNS6_CONFIG_DATA));\r
  Dns6ConfigData.DnsServerCount = 1;\r
  Dns6ConfigData.DnsServerList  = DnsServerList;\r
  Dns6ConfigData.EnableDnsCache = TRUE;\r
  Dns6ConfigData.Protocol       = EFI_IP_PROTO_UDP;\r
  IP6_COPY_ADDRESS (&Dns6ConfigData.StationIp, &Private->TmpStationIp.v6);\r
  Status = Dns6->Configure (\r
                   Dns6,\r
                   &Dns6ConfigData\r
                   );\r
  if (EFI_ERROR (Status)) {\r
    goto Exit;\r
  }\r
\r
  Token.Status = EFI_NOT_READY;\r
  IsDone       = FALSE;\r
  //\r
  // Create event to set the  IsDone flag when name resolution is finished.\r
  //\r
  Status = gBS->CreateEvent (\r
                  EVT_NOTIFY_SIGNAL,\r
                  TPL_NOTIFY,\r
                  PxeBcCommonNotify,\r
                  &IsDone,\r
                  &Token.Event\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    goto Exit;\r
  }\r
\r
  //\r
  // Start asynchronous name resolution.\r
  //\r
  Status = Dns6->HostNameToIp (Dns6, HostName, &Token);\r
  if (EFI_ERROR (Status)) {\r
    goto Exit;\r
  }\r
\r
  while (!IsDone) {\r
    Dns6->Poll (Dns6);\r
  }\r
\r
  //\r
  // Name resolution is done, check result.\r
  //\r
  Status = Token.Status;\r
  if (!EFI_ERROR (Status)) {\r
    if (Token.RspData.H2AData == NULL) {\r
      Status = EFI_DEVICE_ERROR;\r
      goto Exit;\r
    }\r
\r
    if ((Token.RspData.H2AData->IpCount == 0) || (Token.RspData.H2AData->IpList == NULL)) {\r
      Status = EFI_DEVICE_ERROR;\r
      goto Exit;\r
    }\r
\r
    //\r
    // We just return the first IPv6 address from DNS protocol.\r
    //\r
    IP6_COPY_ADDRESS (IpAddress, Token.RspData.H2AData->IpList);\r
    Status = EFI_SUCCESS;\r
  }\r
\r
Exit:\r
  FreePool (HostName);\r
\r
  if (Token.Event != NULL) {\r
    gBS->CloseEvent (Token.Event);\r
  }\r
\r
  if (Token.RspData.H2AData != NULL) {\r
    if (Token.RspData.H2AData->IpList != NULL) {\r
      FreePool (Token.RspData.H2AData->IpList);\r
    }\r
\r
    FreePool (Token.RspData.H2AData);\r
  }\r
\r
  if (Dns6 != NULL) {\r
    Dns6->Configure (Dns6, NULL);\r
\r
    gBS->CloseProtocol (\r
           Dns6Handle,\r
           &gEfiDns6ProtocolGuid,\r
           Private->Image,\r
           Private->Controller\r
           );\r
  }\r
\r
  if (Dns6Handle != NULL) {\r
    NetLibDestroyServiceChild (\r
      Private->Controller,\r
      Private->Image,\r
      &gEfiDns6ServiceBindingProtocolGuid,\r
      Dns6Handle\r
      );\r
  }\r
\r
  if (DnsServerList != NULL) {\r
    FreePool (DnsServerList);\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
  Parse the Boot File URL option.\r
\r
  @param[in]      Private      Pointer to PxeBc private data.\r
  @param[out]     FileName     The pointer to the boot file name.\r
  @param[in, out] SrvAddr      The pointer to the boot server address.\r
  @param[in]      BootFile     The pointer to the boot file URL option data.\r
  @param[in]      Length       The length of the boot file URL option data.\r
\r
  @retval EFI_ABORTED     User cancel operation.\r
  @retval EFI_SUCCESS     Selected the boot menu successfully.\r
  @retval EFI_NOT_READY   Read the input key from the keyboard has not finish.\r
\r
**/\r
EFI_STATUS\r
PxeBcExtractBootFileUrl (\r
  IN PXEBC_PRIVATE_DATA    *Private,\r
  OUT UINT8                **FileName,\r
  IN OUT EFI_IPv6_ADDRESS  *SrvAddr,\r
  IN     CHAR8             *BootFile,\r
  IN     UINT16            Length\r
  )\r
{\r
  UINT16      PrefixLen;\r
  CHAR8       *BootFileNamePtr;\r
  CHAR8       *BootFileName;\r
  UINT16      BootFileNameLen;\r
  CHAR8       *TmpStr;\r
  CHAR8       TmpChar;\r
  CHAR8       *ServerAddressOption;\r
  CHAR8       *ServerAddress;\r
  CHAR8       *ModeStr;\r
  CHAR16      *HostName;\r
  BOOLEAN     IpExpressedUrl;\r
  UINTN       Len;\r
  EFI_STATUS  Status;\r
\r
  IpExpressedUrl = TRUE;\r
  //\r
  // The format of the Boot File URL option is:\r
  //\r
  //  0                   1                   2                   3\r
  //  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1\r
  // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\r
  // |       OPT_BOOTFILE_URL        |            option-len         |\r
  // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\r
  // |                                                               |\r
  // .                  bootfile-url  (variable length)              .\r
  // |                                                               |\r
  // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\r
  //\r
\r
  //\r
  // Based upon RFC 5970 and UEFI 2.6, bootfile-url format can be\r
  // tftp://[SERVER_ADDRESS]/BOOTFILE_NAME or tftp://domain_name/BOOTFILE_NAME\r
  // As an example where the BOOTFILE_NAME is the EFI loader and\r
  // SERVER_ADDRESS is the ASCII encoding of an IPV6 address.\r
  //\r
  PrefixLen = (UINT16)AsciiStrLen (PXEBC_DHCP6_BOOT_FILE_URL_PREFIX);\r
\r
  if ((Length <= PrefixLen) ||\r
      (CompareMem (BootFile, PXEBC_DHCP6_BOOT_FILE_URL_PREFIX, PrefixLen) != 0))\r
  {\r
    return EFI_NOT_FOUND;\r
  }\r
\r
  BootFile = BootFile + PrefixLen;\r
  Length   = (UINT16)(Length - PrefixLen);\r
\r
  TmpStr = (CHAR8 *)AllocateZeroPool (Length + 1);\r
  if (TmpStr == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  CopyMem (TmpStr, BootFile, Length);\r
  TmpStr[Length] = '\0';\r
\r
  //\r
  // Get the part of SERVER_ADDRESS string.\r
  //\r
  ServerAddressOption = TmpStr;\r
  if (*ServerAddressOption == PXEBC_ADDR_START_DELIMITER) {\r
    ServerAddressOption++;\r
    ServerAddress = ServerAddressOption;\r
    while (*ServerAddress != '\0' && *ServerAddress != PXEBC_ADDR_END_DELIMITER) {\r
      ServerAddress++;\r
    }\r
\r
    if (*ServerAddress != PXEBC_ADDR_END_DELIMITER) {\r
      FreePool (TmpStr);\r
      return EFI_INVALID_PARAMETER;\r
    }\r
\r
    *ServerAddress = '\0';\r
\r
    //\r
    // Convert the string of server address to Ipv6 address format and store it.\r
    //\r
    Status = NetLibAsciiStrToIp6 (ServerAddressOption, SrvAddr);\r
    if (EFI_ERROR (Status)) {\r
      FreePool (TmpStr);\r
      return Status;\r
    }\r
  } else {\r
    IpExpressedUrl = FALSE;\r
    ServerAddress  = ServerAddressOption;\r
    while (*ServerAddress != '\0' && *ServerAddress != PXEBC_TFTP_URL_SEPARATOR) {\r
      ServerAddress++;\r
    }\r
\r
    if (*ServerAddress != PXEBC_TFTP_URL_SEPARATOR) {\r
      FreePool (TmpStr);\r
      return EFI_INVALID_PARAMETER;\r
    }\r
\r
    *ServerAddress = '\0';\r
\r
    Len      = AsciiStrSize (ServerAddressOption);\r
    HostName = AllocateZeroPool (Len * sizeof (CHAR16));\r
    if (HostName == NULL) {\r
      FreePool (TmpStr);\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
\r
    AsciiStrToUnicodeStrS (\r
      ServerAddressOption,\r
      HostName,\r
      Len\r
      );\r
\r
    //\r
    // Perform DNS resolution.\r
    //\r
    Status = PxeBcDns6 (Private, HostName, SrvAddr);\r
    if (EFI_ERROR (Status)) {\r
      FreePool (TmpStr);\r
      return Status;\r
    }\r
  }\r
\r
  //\r
  // Get the part of BOOTFILE_NAME string.\r
  //\r
  BootFileNamePtr = (CHAR8 *)((UINTN)ServerAddress + 1);\r
  if (IpExpressedUrl) {\r
    if (*BootFileNamePtr != PXEBC_TFTP_URL_SEPARATOR) {\r
      FreePool (TmpStr);\r
      return EFI_INVALID_PARAMETER;\r
    }\r
\r
    ++BootFileNamePtr;\r
  }\r
\r
  BootFileNameLen = (UINT16)(Length - (UINT16)((UINTN)BootFileNamePtr - (UINTN)TmpStr) + 1);\r
  if ((BootFileNameLen != 0) || (FileName != NULL)) {\r
    //\r
    // Remove trailing mode=octet if present and ignore.  All other modes are\r
    // invalid for netboot6, so reject them.\r
    //\r
    ModeStr = AsciiStrStr (BootFileNamePtr, ";mode=octet");\r
    if ((ModeStr != NULL) && (*(ModeStr + AsciiStrLen (";mode=octet")) == '\0')) {\r
      *ModeStr = '\0';\r
    } else if (AsciiStrStr (BootFileNamePtr, ";mode=") != NULL) {\r
      FreePool (TmpStr);\r
      return EFI_INVALID_PARAMETER;\r
    }\r
\r
    //\r
    // Extract boot file name from URL.\r
    //\r
    BootFileName = (CHAR8 *)AllocateZeroPool (BootFileNameLen);\r
    if (BootFileName == NULL) {\r
      FreePool (TmpStr);\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
\r
    *FileName = (UINT8 *)BootFileName;\r
\r
    //\r
    // Decode percent-encoding in boot file name.\r
    //\r
    while (*BootFileNamePtr != '\0') {\r
      if (*BootFileNamePtr == '%') {\r
        TmpChar               = *(BootFileNamePtr+ 3);\r
        *(BootFileNamePtr+ 3) = '\0';\r
        *BootFileName         = (UINT8)AsciiStrHexToUintn ((CHAR8 *)(BootFileNamePtr + 1));\r
        BootFileName++;\r
        *(BootFileNamePtr+ 3) = TmpChar;\r
        BootFileNamePtr      += 3;\r
      } else {\r
        *BootFileName = *BootFileNamePtr;\r
        BootFileName++;\r
        BootFileNamePtr++;\r
      }\r
    }\r
\r
    *BootFileName = '\0';\r
  }\r
\r
  FreePool (TmpStr);\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Parse the Boot File Parameter option.\r
\r
  @param[in]  BootFilePara      The pointer to boot file parameter option data.\r
  @param[out] BootFileSize      The pointer to the parsed boot file size.\r
\r
  @retval EFI_SUCCESS     Successfully obtained the boot file size from parameter option.\r
  @retval EFI_NOT_FOUND   Failed to extract the boot file size from parameter option.\r
\r
**/\r
EFI_STATUS\r
PxeBcExtractBootFileParam (\r
  IN  CHAR8   *BootFilePara,\r
  OUT UINT16  *BootFileSize\r
  )\r
{\r
  UINT16  Length;\r
  UINT8   Index;\r
  UINT8   Digit;\r
  UINT32  Size;\r
\r
  CopyMem (&Length, BootFilePara, sizeof (UINT16));\r
  Length = NTOHS (Length);\r
\r
  //\r
  // The BootFile Size should be 1~5 byte ASCII strings\r
  //\r
  if ((Length < 1) || (Length > 5)) {\r
    return EFI_NOT_FOUND;\r
  }\r
\r
  //\r
  // Extract the value of BootFile Size.\r
  //\r
  BootFilePara = BootFilePara + sizeof (UINT16);\r
  Size         = 0;\r
  for (Index = 0; Index < Length; Index++) {\r
    if (EFI_ERROR (PxeBcUniHexToUint8 (&Digit, *(BootFilePara + Index)))) {\r
      return EFI_NOT_FOUND;\r
    }\r
\r
    Size = (Size + Digit) * 10;\r
  }\r
\r
  Size = Size / 10;\r
  if (Size > PXEBC_DHCP6_MAX_BOOT_FILE_SIZE) {\r
    return EFI_NOT_FOUND;\r
  }\r
\r
  *BootFileSize = (UINT16)Size;\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Parse the cached DHCPv6 packet, including all the options.\r
\r
  @param[in]  Cache6           The pointer to a cached DHCPv6 packet.\r
\r
  @retval     EFI_SUCCESS      Parsed the DHCPv6 packet successfully.\r
  @retval     EFI_DEVICE_ERROR Failed to parse and invalid the packet.\r
\r
**/\r
EFI_STATUS\r
PxeBcParseDhcp6Packet (\r
  IN PXEBC_DHCP6_PACKET_CACHE  *Cache6\r
  )\r
{\r
  EFI_DHCP6_PACKET         *Offer;\r
  EFI_DHCP6_PACKET_OPTION  **Options;\r
  EFI_DHCP6_PACKET_OPTION  *Option;\r
  PXEBC_OFFER_TYPE         OfferType;\r
  BOOLEAN                  IsProxyOffer;\r
  BOOLEAN                  IsPxeOffer;\r
  UINT32                   Offset;\r
  UINT32                   Length;\r
  UINT32                   EnterpriseNum;\r
\r
  IsProxyOffer = TRUE;\r
  IsPxeOffer   = FALSE;\r
  Offer        = &Cache6->Packet.Offer;\r
  Options      = Cache6->OptList;\r
\r
  ZeroMem (Cache6->OptList, sizeof (Cache6->OptList));\r
\r
  Option = (EFI_DHCP6_PACKET_OPTION *)(Offer->Dhcp6.Option);\r
  Offset = 0;\r
  Length = GET_DHCP6_OPTION_SIZE (Offer);\r
\r
  //\r
  // OpLen and OpCode here are both stored in network order, since they are from original packet.\r
  //\r
  while (Offset < Length) {\r
    if (NTOHS (Option->OpCode) == DHCP6_OPT_IA_NA) {\r
      Options[PXEBC_DHCP6_IDX_IA_NA] = Option;\r
    } else if (NTOHS (Option->OpCode) == DHCP6_OPT_BOOT_FILE_URL) {\r
      //\r
      // The server sends this option to inform the client about an URL to a boot file.\r
      //\r
      Options[PXEBC_DHCP6_IDX_BOOT_FILE_URL] = Option;\r
    } else if (NTOHS (Option->OpCode) == DHCP6_OPT_BOOT_FILE_PARAM) {\r
      Options[PXEBC_DHCP6_IDX_BOOT_FILE_PARAM] = Option;\r
    } else if (NTOHS (Option->OpCode) == DHCP6_OPT_VENDOR_CLASS) {\r
      Options[PXEBC_DHCP6_IDX_VENDOR_CLASS] = Option;\r
    } else if (NTOHS (Option->OpCode) == DHCP6_OPT_DNS_SERVERS) {\r
      Options[PXEBC_DHCP6_IDX_DNS_SERVER] = Option;\r
    }\r
\r
    Offset += (NTOHS (Option->OpLen) + 4);\r
    Option  = (EFI_DHCP6_PACKET_OPTION *)(Offer->Dhcp6.Option + Offset);\r
  }\r
\r
  //\r
  // The offer with assigned client address is NOT a proxy offer.\r
  // An ia_na option, embedded with valid ia_addr option and a status_code of success.\r
  //\r
  Option = Options[PXEBC_DHCP6_IDX_IA_NA];\r
  if (Option != NULL) {\r
    Option = PxeBcParseDhcp6Options (\r
               Option->Data + 12,\r
               NTOHS (Option->OpLen),\r
               DHCP6_OPT_STATUS_CODE\r
               );\r
    if (((Option != NULL) && (Option->Data[0] == 0)) || (Option == NULL)) {\r
      IsProxyOffer = FALSE;\r
    }\r
  }\r
\r
  //\r
  // The offer with "PXEClient" is a pxe offer.\r
  //\r
  Option        = Options[PXEBC_DHCP6_IDX_VENDOR_CLASS];\r
  EnterpriseNum = HTONL (PXEBC_DHCP6_ENTERPRISE_NUM);\r
\r
  if ((Option != NULL) &&\r
      (NTOHS (Option->OpLen) >= 13) &&\r
      (CompareMem (Option->Data, &EnterpriseNum, sizeof (UINT32)) == 0) &&\r
      (CompareMem (&Option->Data[6], DEFAULT_CLASS_ID_DATA, 9) == 0))\r
  {\r
    IsPxeOffer = TRUE;\r
  }\r
\r
  //\r
  // Determine offer type of the dhcp6 packet.\r
  //\r
  if (IsPxeOffer) {\r
    //\r
    // It's a binl offer only with PXEClient.\r
    //\r
    OfferType = IsProxyOffer ? PxeOfferTypeProxyBinl : PxeOfferTypeDhcpBinl;\r
  } else {\r
    //\r
    // It's a dhcp only offer, which is a pure dhcp6 offer packet.\r
    //\r
    OfferType = PxeOfferTypeDhcpOnly;\r
  }\r
\r
  Cache6->OfferType = OfferType;\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Cache the DHCPv6 ack packet, and parse it on demand.\r
\r
  @param[in]  Private             The pointer to PxeBc private data.\r
  @param[in]  Ack                 The pointer to the DHCPv6 ack packet.\r
  @param[in]  Verified            If TRUE, parse the ACK packet and store info into mode data.\r
\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
EFI_STATUS\r
PxeBcCopyDhcp6Ack (\r
  IN PXEBC_PRIVATE_DATA  *Private,\r
  IN EFI_DHCP6_PACKET    *Ack,\r
  IN BOOLEAN             Verified\r
  )\r
{\r
  EFI_PXE_BASE_CODE_MODE  *Mode;\r
  EFI_STATUS              Status;\r
\r
  Mode = Private->PxeBc.Mode;\r
\r
  Status = PxeBcCacheDhcp6Packet (&Private->DhcpAck.Dhcp6.Packet.Ack, Ack);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  if (Verified) {\r
    //\r
    // Parse the ack packet and store it into mode data if needed.\r
    //\r
    PxeBcParseDhcp6Packet (&Private->DhcpAck.Dhcp6);\r
    CopyMem (&Mode->DhcpAck.Dhcpv6, &Ack->Dhcp6, Ack->Length);\r
    Mode->DhcpAckReceived = TRUE;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Cache the DHCPv6 proxy offer packet according to the received order.\r
\r
  @param[in]  Private               The pointer to PxeBc private data.\r
  @param[in]  OfferIndex            The received order of offer packets.\r
\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
EFI_STATUS\r
PxeBcCopyDhcp6Proxy (\r
  IN PXEBC_PRIVATE_DATA  *Private,\r
  IN UINT32              OfferIndex\r
  )\r
{\r
  EFI_PXE_BASE_CODE_MODE  *Mode;\r
  EFI_DHCP6_PACKET        *Offer;\r
  EFI_STATUS              Status;\r
\r
  ASSERT (OfferIndex < Private->OfferNum);\r
  ASSERT (OfferIndex < PXEBC_OFFER_MAX_NUM);\r
\r
  Mode  = Private->PxeBc.Mode;\r
  Offer = &Private->OfferBuffer[OfferIndex].Dhcp6.Packet.Offer;\r
\r
  //\r
  // Cache the proxy offer packet and parse it.\r
  //\r
  Status = PxeBcCacheDhcp6Packet (&Private->ProxyOffer.Dhcp6.Packet.Offer, Offer);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  PxeBcParseDhcp6Packet (&Private->ProxyOffer.Dhcp6);\r
\r
  //\r
  // Store this packet into mode data.\r
  //\r
  CopyMem (&Mode->ProxyOffer.Dhcpv6, &Offer->Dhcp6, Offer->Length);\r
  Mode->ProxyOfferReceived = TRUE;\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Seek the address of the first byte of the option header.\r
\r
  @param[in]  Buf           The pointer to the buffer.\r
  @param[in]  SeekLen       The length to seek.\r
  @param[in]  OptType       The option type.\r
\r
  @retval     NULL          If it failed to seek the option.\r
  @retval     others        The position to the option.\r
\r
**/\r
UINT8 *\r
PxeBcDhcp6SeekOption (\r
  IN UINT8   *Buf,\r
  IN UINT32  SeekLen,\r
  IN UINT16  OptType\r
  )\r
{\r
  UINT8   *Cursor;\r
  UINT8   *Option;\r
  UINT16  DataLen;\r
  UINT16  OpCode;\r
\r
  Option = NULL;\r
  Cursor = Buf;\r
\r
  while (Cursor < Buf + SeekLen) {\r
    OpCode = ReadUnaligned16 ((UINT16 *)Cursor);\r
    if (OpCode == HTONS (OptType)) {\r
      Option = Cursor;\r
      break;\r
    }\r
\r
    DataLen = NTOHS (ReadUnaligned16 ((UINT16 *)(Cursor + 2)));\r
    Cursor += (DataLen + 4);\r
  }\r
\r
  return Option;\r
}\r
\r
/**\r
  Build and send out the request packet for the bootfile, and parse the reply.\r
\r
  @param[in]  Private               The pointer to PxeBc private data.\r
  @param[in]  Index                 PxeBc option boot item type.\r
\r
  @retval     EFI_SUCCESS           Successfully discovered the boot file.\r
  @retval     EFI_OUT_OF_RESOURCES  Failed to allocate resources.\r
  @retval     EFI_NOT_FOUND         Can't get the PXE reply packet.\r
  @retval     Others                Failed to discover the boot file.\r
\r
**/\r
EFI_STATUS\r
PxeBcRequestBootService (\r
  IN  PXEBC_PRIVATE_DATA  *Private,\r
  IN  UINT32              Index\r
  )\r
{\r
  EFI_PXE_BASE_CODE_UDP_PORT       SrcPort;\r
  EFI_PXE_BASE_CODE_UDP_PORT       DestPort;\r
  EFI_PXE_BASE_CODE_PROTOCOL       *PxeBc;\r
  EFI_PXE_BASE_CODE_DHCPV6_PACKET  *Discover;\r
  UINTN                            DiscoverLen;\r
  EFI_DHCP6_PACKET                 *Request;\r
  UINTN                            RequestLen;\r
  EFI_DHCP6_PACKET                 *Reply;\r
  UINT8                            *RequestOpt;\r
  UINT8                            *DiscoverOpt;\r
  UINTN                            ReadSize;\r
  UINT16                           OpFlags;\r
  UINT16                           OpCode;\r
  UINT16                           OpLen;\r
  EFI_STATUS                       Status;\r
  EFI_DHCP6_PACKET                 *IndexOffer;\r
  UINT8                            *Option;\r
\r
  PxeBc      = &Private->PxeBc;\r
  Request    = Private->Dhcp6Request;\r
  IndexOffer = &Private->OfferBuffer[Index].Dhcp6.Packet.Offer;\r
  SrcPort    = PXEBC_BS_DISCOVER_PORT;\r
  DestPort   = PXEBC_BS_DISCOVER_PORT;\r
  OpFlags    = 0;\r
\r
  if (Request == NULL) {\r
    return EFI_DEVICE_ERROR;\r
  }\r
\r
  Discover = AllocateZeroPool (sizeof (EFI_PXE_BASE_CODE_DHCPV6_PACKET));\r
  if (Discover == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  //\r
  // Build the request packet by the cached request packet before.\r
  //\r
  Discover->TransactionId = IndexOffer->Dhcp6.Header.TransactionId;\r
  Discover->MessageType   = Request->Dhcp6.Header.MessageType;\r
  RequestOpt              = Request->Dhcp6.Option;\r
  DiscoverOpt             = Discover->DhcpOptions;\r
  DiscoverLen             = sizeof (EFI_DHCP6_HEADER);\r
  RequestLen              = DiscoverLen;\r
\r
  //\r
  // Find Server ID Option from ProxyOffer.\r
  //\r
  if (Private->OfferBuffer[Index].Dhcp6.OfferType == PxeOfferTypeProxyBinl) {\r
    Option = PxeBcDhcp6SeekOption (\r
               IndexOffer->Dhcp6.Option,\r
               IndexOffer->Length - 4,\r
               DHCP6_OPT_SERVER_ID\r
               );\r
    if (Option == NULL) {\r
      return EFI_NOT_FOUND;\r
    }\r
\r
    //\r
    // Add Server ID Option.\r
    //\r
    OpLen = NTOHS (((EFI_DHCP6_PACKET_OPTION *)Option)->OpLen);\r
    CopyMem (DiscoverOpt, Option, OpLen + 4);\r
    DiscoverOpt += (OpLen + 4);\r
    DiscoverLen += (OpLen + 4);\r
  }\r
\r
  while (RequestLen < Request->Length) {\r
    OpCode = NTOHS (((EFI_DHCP6_PACKET_OPTION *)RequestOpt)->OpCode);\r
    OpLen  = NTOHS (((EFI_DHCP6_PACKET_OPTION *)RequestOpt)->OpLen);\r
    if ((OpCode != EFI_DHCP6_IA_TYPE_NA) &&\r
        (OpCode != EFI_DHCP6_IA_TYPE_TA) &&\r
        (OpCode != DHCP6_OPT_SERVER_ID)\r
        )\r
    {\r
      //\r
      // Copy all the options except IA option and Server ID\r
      //\r
      CopyMem (DiscoverOpt, RequestOpt, OpLen + 4);\r
      DiscoverOpt += (OpLen + 4);\r
      DiscoverLen += (OpLen + 4);\r
    }\r
\r
    RequestOpt += (OpLen + 4);\r
    RequestLen += (OpLen + 4);\r
  }\r
\r
  //\r
  // Update Elapsed option in the package\r
  //\r
  Option = PxeBcDhcp6SeekOption (\r
             Discover->DhcpOptions,\r
             (UINT32)(RequestLen - 4),\r
             DHCP6_OPT_ELAPSED_TIME\r
             );\r
  if (Option != NULL) {\r
    CalcElapsedTime (Private);\r
    WriteUnaligned16 ((UINT16 *)(Option + 4), HTONS ((UINT16)Private->ElapsedTime));\r
  }\r
\r
  Status = PxeBc->UdpWrite (\r
                    PxeBc,\r
                    OpFlags,\r
                    &Private->ServerIp,\r
                    &DestPort,\r
                    NULL,\r
                    &Private->StationIp,\r
                    &SrcPort,\r
                    NULL,\r
                    NULL,\r
                    &DiscoverLen,\r
                    (VOID *)Discover\r
                    );\r
\r
  if (EFI_ERROR (Status)) {\r
    goto ON_ERROR;\r
  }\r
\r
  //\r
  // Cache the right PXE reply packet here, set valid flag later.\r
  // Especially for PXE discover packet, store it into mode data here.\r
  //\r
  Reply    = &Private->ProxyOffer.Dhcp6.Packet.Offer;\r
  ReadSize = (UINTN)Reply->Size;\r
\r
  //\r
  // Start Udp6Read instance\r
  //\r
  Status = Private->Udp6Read->Configure (Private->Udp6Read, &Private->Udp6CfgData);\r
  if (EFI_ERROR (Status)) {\r
    goto ON_ERROR;\r
  }\r
\r
  Status = PxeBc->UdpRead (\r
                    PxeBc,\r
                    EFI_PXE_BASE_CODE_UDP_OPFLAGS_ANY_SRC_IP | EFI_PXE_BASE_CODE_UDP_OPFLAGS_ANY_DEST_IP,\r
                    NULL,\r
                    &SrcPort,\r
                    &Private->ServerIp,\r
                    &DestPort,\r
                    NULL,\r
                    NULL,\r
                    &ReadSize,\r
                    (VOID *)&Reply->Dhcp6\r
                    );\r
  //\r
  // Stop Udp6Read instance\r
  //\r
  Private->Udp6Read->Configure (Private->Udp6Read, NULL);\r
\r
  if (EFI_ERROR (Status)) {\r
    goto ON_ERROR;\r
  }\r
\r
  //\r
  // Update length\r
  //\r
  Reply->Length = (UINT32)ReadSize;\r
\r
  return EFI_SUCCESS;\r
\r
ON_ERROR:\r
  if (Discover != NULL) {\r
    FreePool (Discover);\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
  Retry to request bootfile name by the BINL offer.\r
\r
  @param[in]  Private              The pointer to PxeBc private data.\r
  @param[in]  Index                The received order of offer packets.\r
\r
  @retval     EFI_SUCCESS          Successfully retried a request for the bootfile name.\r
  @retval     EFI_DEVICE_ERROR     Failed to retry the bootfile name.\r
\r
**/\r
EFI_STATUS\r
PxeBcRetryDhcp6Binl (\r
  IN PXEBC_PRIVATE_DATA  *Private,\r
  IN UINT32              Index\r
  )\r
{\r
  EFI_PXE_BASE_CODE_MODE    *Mode;\r
  PXEBC_DHCP6_PACKET_CACHE  *Offer;\r
  PXEBC_DHCP6_PACKET_CACHE  *Cache6;\r
  EFI_STATUS                Status;\r
\r
  ASSERT (Index < PXEBC_OFFER_MAX_NUM);\r
  ASSERT (\r
    Private->OfferBuffer[Index].Dhcp6.OfferType == PxeOfferTypeDhcpBinl ||\r
    Private->OfferBuffer[Index].Dhcp6.OfferType == PxeOfferTypeProxyBinl\r
    );\r
\r
  Mode                  = Private->PxeBc.Mode;\r
  Private->IsDoDiscover = FALSE;\r
  Offer                 = &Private->OfferBuffer[Index].Dhcp6;\r
  if (Offer->OptList[PXEBC_DHCP6_IDX_BOOT_FILE_URL] == NULL) {\r
    //\r
    // There is no BootFileUrl option in dhcp6 offer, so use servers multi-cast address instead.\r
    //\r
    CopyMem (\r
      &Private->ServerIp.v6,\r
      &mAllDhcpRelayAndServersAddress,\r
      sizeof (EFI_IPv6_ADDRESS)\r
      );\r
  } else {\r
    ASSERT (Offer->OptList[PXEBC_DHCP6_IDX_BOOT_FILE_URL] != NULL);\r
    //\r
    // Parse out the next server address from the last offer, and store it\r
    //\r
    Status = PxeBcExtractBootFileUrl (\r
               Private,\r
               &Private->BootFileName,\r
               &Private->ServerIp.v6,\r
               (CHAR8 *)(Offer->OptList[PXEBC_DHCP6_IDX_BOOT_FILE_URL]->Data),\r
               NTOHS (Offer->OptList[PXEBC_DHCP6_IDX_BOOT_FILE_URL]->OpLen)\r
               );\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
  }\r
\r
  //\r
  // Retry Dhcp6Binl again for the bootfile, and the reply cached into Private->ProxyOffer.\r
  //\r
  Status = PxeBcRequestBootService (Private, Index);\r
\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  Cache6 = &Private->ProxyOffer.Dhcp6;\r
  Status = PxeBcParseDhcp6Packet (Cache6);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  if ((Cache6->OfferType != PxeOfferTypeProxyPxe10) &&\r
      (Cache6->OfferType != PxeOfferTypeProxyWfm11a) &&\r
      (Cache6->OptList[PXEBC_DHCP6_IDX_BOOT_FILE_URL] == NULL))\r
  {\r
    //\r
    // This BINL ack doesn't have discovery option set or multicast option set\r
    // or bootfile name specified.\r
    //\r
    return EFI_DEVICE_ERROR;\r
  }\r
\r
  Mode->ProxyOfferReceived = TRUE;\r
  CopyMem (\r
    &Mode->ProxyOffer.Dhcpv6,\r
    &Cache6->Packet.Offer.Dhcp6,\r
    Cache6->Packet.Offer.Length\r
    );\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Cache all the received DHCPv6 offers, and set OfferIndex and OfferCount.\r
\r
  @param[in]  Private               The pointer to PXEBC_PRIVATE_DATA.\r
  @param[in]  RcvdOffer             The pointer to the received offer packet.\r
\r
  @retval     EFI_SUCCESS      Cache and parse the packet successfully.\r
  @retval     Others           Operation failed.\r
**/\r
EFI_STATUS\r
PxeBcCacheDhcp6Offer (\r
  IN PXEBC_PRIVATE_DATA  *Private,\r
  IN EFI_DHCP6_PACKET    *RcvdOffer\r
  )\r
{\r
  PXEBC_DHCP6_PACKET_CACHE  *Cache6;\r
  EFI_DHCP6_PACKET          *Offer;\r
  PXEBC_OFFER_TYPE          OfferType;\r
  EFI_STATUS                Status;\r
\r
  Cache6 = &Private->OfferBuffer[Private->OfferNum].Dhcp6;\r
  Offer  = &Cache6->Packet.Offer;\r
\r
  //\r
  // Cache the content of DHCPv6 packet firstly.\r
  //\r
  Status = PxeBcCacheDhcp6Packet (Offer, RcvdOffer);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  //\r
  // Validate the DHCPv6 packet, and parse the options and offer type.\r
  //\r
  if (EFI_ERROR (PxeBcParseDhcp6Packet (Cache6))) {\r
    return EFI_ABORTED;\r
  }\r
\r
  //\r
  // Determine whether cache the current offer by type, and record OfferIndex and OfferCount.\r
  //\r
  OfferType = Cache6->OfferType;\r
  ASSERT (OfferType < PxeOfferTypeMax);\r
  ASSERT (Private->OfferCount[OfferType] < PXEBC_OFFER_MAX_NUM);\r
\r
  if (IS_PROXY_OFFER (OfferType)) {\r
    //\r
    // It's a proxy offer without yiaddr, including PXE10, WFM11a or BINL offer.\r
    //\r
    Private->IsProxyRecved = TRUE;\r
\r
    if (OfferType == PxeOfferTypeProxyBinl) {\r
      //\r
      // Cache all proxy BINL offers.\r
      //\r
      Private->OfferIndex[OfferType][Private->OfferCount[OfferType]] = Private->OfferNum;\r
      Private->OfferCount[OfferType]++;\r
    } else if (((OfferType == PxeOfferTypeProxyPxe10) || (OfferType == PxeOfferTypeProxyWfm11a)) &&\r
               (Private->OfferCount[OfferType] < 1))\r
    {\r
      //\r
      // Only cache the first PXE10/WFM11a offer, and discard the others.\r
      //\r
      Private->OfferIndex[OfferType][0] = Private->OfferNum;\r
      Private->OfferCount[OfferType]    = 1;\r
    } else {\r
      return EFI_ABORTED;\r
    }\r
  } else {\r
    //\r
    // It's a DHCPv6 offer with yiaddr, and cache them all.\r
    //\r
    Private->OfferIndex[OfferType][Private->OfferCount[OfferType]] = Private->OfferNum;\r
    Private->OfferCount[OfferType]++;\r
  }\r
\r
  Private->OfferNum++;\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Select an DHCPv6 offer, and record SelectIndex and SelectProxyType.\r
\r
  @param[in]  Private             The pointer to PXEBC_PRIVATE_DATA.\r
\r
**/\r
VOID\r
PxeBcSelectDhcp6Offer (\r
  IN PXEBC_PRIVATE_DATA  *Private\r
  )\r
{\r
  UINT32            Index;\r
  UINT32            OfferIndex;\r
  PXEBC_OFFER_TYPE  OfferType;\r
\r
  Private->SelectIndex = 0;\r
\r
  if (Private->IsOfferSorted) {\r
    //\r
    // Select offer by default policy.\r
    //\r
    if (Private->OfferCount[PxeOfferTypeDhcpPxe10] > 0) {\r
      //\r
      // 1. DhcpPxe10 offer\r
      //\r
      Private->SelectIndex = Private->OfferIndex[PxeOfferTypeDhcpPxe10][0] + 1;\r
    } else if (Private->OfferCount[PxeOfferTypeDhcpWfm11a] > 0) {\r
      //\r
      // 2. DhcpWfm11a offer\r
      //\r
      Private->SelectIndex = Private->OfferIndex[PxeOfferTypeDhcpWfm11a][0] + 1;\r
    } else if ((Private->OfferCount[PxeOfferTypeDhcpOnly] > 0) &&\r
               (Private->OfferCount[PxeOfferTypeProxyPxe10] > 0))\r
    {\r
      //\r
      // 3. DhcpOnly offer and ProxyPxe10 offer.\r
      //\r
      Private->SelectIndex     = Private->OfferIndex[PxeOfferTypeDhcpOnly][0] + 1;\r
      Private->SelectProxyType = PxeOfferTypeProxyPxe10;\r
    } else if ((Private->OfferCount[PxeOfferTypeDhcpOnly] > 0) &&\r
               (Private->OfferCount[PxeOfferTypeProxyWfm11a] > 0))\r
    {\r
      //\r
      // 4. DhcpOnly offer and ProxyWfm11a offer.\r
      //\r
      Private->SelectIndex     = Private->OfferIndex[PxeOfferTypeDhcpOnly][0] + 1;\r
      Private->SelectProxyType = PxeOfferTypeProxyWfm11a;\r
    } else if (Private->OfferCount[PxeOfferTypeDhcpBinl] > 0) {\r
      //\r
      // 5. DhcpBinl offer.\r
      //\r
      Private->SelectIndex = Private->OfferIndex[PxeOfferTypeDhcpBinl][0] + 1;\r
    } else if ((Private->OfferCount[PxeOfferTypeDhcpOnly] > 0) &&\r
               (Private->OfferCount[PxeOfferTypeProxyBinl] > 0))\r
    {\r
      //\r
      // 6. DhcpOnly offer and ProxyBinl offer.\r
      //\r
      Private->SelectIndex     = Private->OfferIndex[PxeOfferTypeDhcpOnly][0] + 1;\r
      Private->SelectProxyType = PxeOfferTypeProxyBinl;\r
    } else {\r
      //\r
      // 7. DhcpOnly offer with bootfilename.\r
      //\r
      for (Index = 0; Index < Private->OfferCount[PxeOfferTypeDhcpOnly]; Index++) {\r
        OfferIndex = Private->OfferIndex[PxeOfferTypeDhcpOnly][Index];\r
        if (Private->OfferBuffer[OfferIndex].Dhcp6.OptList[PXEBC_DHCP6_IDX_BOOT_FILE_URL] != NULL) {\r
          Private->SelectIndex = OfferIndex + 1;\r
          break;\r
        }\r
      }\r
    }\r
  } else {\r
    //\r
    // Select offer by received order.\r
    //\r
    for (Index = 0; Index < Private->OfferNum; Index++) {\r
      OfferType = Private->OfferBuffer[Index].Dhcp6.OfferType;\r
\r
      if (IS_PROXY_OFFER (OfferType)) {\r
        //\r
        // Skip proxy offers\r
        //\r
        continue;\r
      }\r
\r
      if (!Private->IsProxyRecved &&\r
          (OfferType == PxeOfferTypeDhcpOnly) &&\r
          (Private->OfferBuffer[Index].Dhcp6.OptList[PXEBC_DHCP6_IDX_BOOT_FILE_URL] == NULL))\r
      {\r
        //\r
        // Skip if DhcpOnly offer without any other proxy offers or bootfilename.\r
        //\r
        continue;\r
      }\r
\r
      Private->SelectIndex = Index + 1;\r
      break;\r
    }\r
  }\r
}\r
\r
/**\r
  Handle the DHCPv6 offer packet.\r
\r
  @param[in]  Private             The pointer to PXEBC_PRIVATE_DATA.\r
\r
  @retval     EFI_SUCCESS           Handled the DHCPv6 offer packet successfully.\r
  @retval     EFI_NO_RESPONSE       No response to the following request packet.\r
  @retval     EFI_OUT_OF_RESOURCES  Failed to allocate resources.\r
  @retval     EFI_BUFFER_TOO_SMALL  Can't cache the offer pacet.\r
\r
**/\r
EFI_STATUS\r
PxeBcHandleDhcp6Offer (\r
  IN PXEBC_PRIVATE_DATA  *Private\r
  )\r
{\r
  PXEBC_DHCP6_PACKET_CACHE  *Cache6;\r
  EFI_STATUS                Status;\r
  PXEBC_OFFER_TYPE          OfferType;\r
  UINT32                    ProxyIndex;\r
  UINT32                    SelectIndex;\r
  UINT32                    Index;\r
\r
  ASSERT (Private->SelectIndex > 0);\r
  SelectIndex = (UINT32)(Private->SelectIndex - 1);\r
  ASSERT (SelectIndex < PXEBC_OFFER_MAX_NUM);\r
  Cache6 = &Private->OfferBuffer[SelectIndex].Dhcp6;\r
  Status = EFI_SUCCESS;\r
\r
  //\r
  // First try to cache DNS server address if DHCP6 offer provides.\r
  //\r
  if (Cache6->OptList[PXEBC_DHCP6_IDX_DNS_SERVER] != NULL) {\r
    Private->DnsServer = AllocateZeroPool (NTOHS (Cache6->OptList[PXEBC_DHCP6_IDX_DNS_SERVER]->OpLen));\r
    if (Private->DnsServer == NULL) {\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
\r
    CopyMem (Private->DnsServer, Cache6->OptList[PXEBC_DHCP6_IDX_DNS_SERVER]->Data, sizeof (EFI_IPv6_ADDRESS));\r
  }\r
\r
  if (Cache6->OfferType == PxeOfferTypeDhcpBinl) {\r
    //\r
    // DhcpBinl offer is selected, so need try to request bootfilename by this offer.\r
    //\r
    if (EFI_ERROR (PxeBcRetryDhcp6Binl (Private, SelectIndex))) {\r
      Status = EFI_NO_RESPONSE;\r
    }\r
  } else if (Cache6->OfferType == PxeOfferTypeDhcpOnly) {\r
    if (Private->IsProxyRecved) {\r
      //\r
      // DhcpOnly offer is selected, so need try to request bootfilename.\r
      //\r
      ProxyIndex = 0;\r
      if (Private->IsOfferSorted) {\r
        //\r
        // The proxy offer should be determined if select by default policy.\r
        // IsOfferSorted means all offers are labeled by OfferIndex.\r
        //\r
        ASSERT (Private->OfferCount[Private->SelectProxyType] > 0);\r
\r
        if (Private->SelectProxyType == PxeOfferTypeProxyBinl) {\r
          //\r
          // Try all the cached ProxyBinl offer one by one to request bootfilename.\r
          //\r
          for (Index = 0; Index < Private->OfferCount[Private->SelectProxyType]; Index++) {\r
            ProxyIndex = Private->OfferIndex[Private->SelectProxyType][Index];\r
            if (!EFI_ERROR (PxeBcRetryDhcp6Binl (Private, ProxyIndex))) {\r
              break;\r
            }\r
          }\r
\r
          if (Index == Private->OfferCount[Private->SelectProxyType]) {\r
            Status = EFI_NO_RESPONSE;\r
          }\r
        } else {\r
          //\r
          // For other proxy offers (pxe10 or wfm11a), only one is buffered.\r
          //\r
          ProxyIndex = Private->OfferIndex[Private->SelectProxyType][0];\r
        }\r
      } else {\r
        //\r
        // The proxy offer should not be determined if select by received order.\r
        //\r
        Status = EFI_NO_RESPONSE;\r
\r
        for (Index = 0; Index < Private->OfferNum; Index++) {\r
          OfferType = Private->OfferBuffer[Index].Dhcp6.OfferType;\r
\r
          if (!IS_PROXY_OFFER (OfferType)) {\r
            //\r
            // Skip non proxy dhcp offers.\r
            //\r
            continue;\r
          }\r
\r
          if (OfferType == PxeOfferTypeProxyBinl) {\r
            //\r
            // Try all the cached ProxyBinl offer one by one to request bootfilename.\r
            //\r
            if (EFI_ERROR (PxeBcRetryDhcp6Binl (Private, Index))) {\r
              continue;\r
            }\r
          }\r
\r
          Private->SelectProxyType = OfferType;\r
          ProxyIndex               = Index;\r
          Status                   = EFI_SUCCESS;\r
          break;\r
        }\r
      }\r
\r
      if (!EFI_ERROR (Status) && (Private->SelectProxyType != PxeOfferTypeProxyBinl)) {\r
        //\r
        // Success to try to request by a ProxyPxe10 or ProxyWfm11a offer, copy and parse it.\r
        //\r
        Status = PxeBcCopyDhcp6Proxy (Private, ProxyIndex);\r
      }\r
    } else {\r
      //\r
      //  Otherwise, the bootfilename must be included in DhcpOnly offer.\r
      //\r
      ASSERT (Cache6->OptList[PXEBC_DHCP6_IDX_BOOT_FILE_URL] != NULL);\r
    }\r
  }\r
\r
  if (!EFI_ERROR (Status)) {\r
    //\r
    // All PXE boot information is ready by now.\r
    //\r
    Status                                 = PxeBcCopyDhcp6Ack (Private, &Private->DhcpAck.Dhcp6.Packet.Ack, TRUE);\r
    Private->PxeBc.Mode->DhcpDiscoverValid = TRUE;\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
  Unregister the address by Ip6Config protocol.\r
\r
  @param[in]  Private             The pointer to PXEBC_PRIVATE_DATA.\r
\r
**/\r
VOID\r
PxeBcUnregisterIp6Address (\r
  IN PXEBC_PRIVATE_DATA  *Private\r
  )\r
{\r
  if (Private->Ip6Policy != PXEBC_IP6_POLICY_MAX) {\r
    //\r
    // PXE driver change the policy of IP6 driver, it's a chance to recover.\r
    // Keep the point and there is no enough requirements to do recovery.\r
    //\r
  }\r
}\r
\r
/**\r
  Check whether IP driver could route the message which will be sent to ServerIp address.\r
\r
  This function will check the IP6 route table every 1 seconds until specified timeout is expired, if a valid\r
  route is found in IP6 route table, the address will be filed in GatewayAddr and return.\r
\r
  @param[in]  Private             The pointer to PXEBC_PRIVATE_DATA.\r
  @param[in]  TimeOutInSecond     Timeout value in seconds.\r
  @param[out] GatewayAddr         Pointer to store the gateway IP address.\r
\r
  @retval     EFI_SUCCESS         Found a valid gateway address successfully.\r
  @retval     EFI_TIMEOUT         The operation is time out.\r
  @retval     Other               Unexpected error happened.\r
\r
**/\r
EFI_STATUS\r
PxeBcCheckRouteTable (\r
  IN  PXEBC_PRIVATE_DATA  *Private,\r
  IN  UINTN               TimeOutInSecond,\r
  OUT EFI_IPv6_ADDRESS    *GatewayAddr\r
  )\r
{\r
  EFI_STATUS         Status;\r
  EFI_IP6_PROTOCOL   *Ip6;\r
  EFI_IP6_MODE_DATA  Ip6ModeData;\r
  UINTN              Index;\r
  EFI_EVENT          TimeOutEvt;\r
  UINTN              RetryCount;\r
  BOOLEAN            GatewayIsFound;\r
\r
  ASSERT (GatewayAddr != NULL);\r
  ASSERT (Private != NULL);\r
\r
  Ip6            = Private->Ip6;\r
  GatewayIsFound = FALSE;\r
  RetryCount     = 0;\r
  TimeOutEvt     = NULL;\r
  ZeroMem (GatewayAddr, sizeof (EFI_IPv6_ADDRESS));\r
\r
  while (TRUE) {\r
    Status = Ip6->GetModeData (Ip6, &Ip6ModeData, NULL, NULL);\r
    if (EFI_ERROR (Status)) {\r
      goto ON_EXIT;\r
    }\r
\r
    //\r
    // Find out the gateway address which can route the message which send to ServerIp.\r
    //\r
    for (Index = 0; Index < Ip6ModeData.RouteCount; Index++) {\r
      if (NetIp6IsNetEqual (&Private->ServerIp.v6, &Ip6ModeData.RouteTable[Index].Destination, Ip6ModeData.RouteTable[Index].PrefixLength)) {\r
        IP6_COPY_ADDRESS (GatewayAddr, &Ip6ModeData.RouteTable[Index].Gateway);\r
        GatewayIsFound = TRUE;\r
        break;\r
      }\r
    }\r
\r
    if (Ip6ModeData.AddressList != NULL) {\r
      FreePool (Ip6ModeData.AddressList);\r
    }\r
\r
    if (Ip6ModeData.GroupTable != NULL) {\r
      FreePool (Ip6ModeData.GroupTable);\r
    }\r
\r
    if (Ip6ModeData.RouteTable != NULL) {\r
      FreePool (Ip6ModeData.RouteTable);\r
    }\r
\r
    if (Ip6ModeData.NeighborCache != NULL) {\r
      FreePool (Ip6ModeData.NeighborCache);\r
    }\r
\r
    if (Ip6ModeData.PrefixTable != NULL) {\r
      FreePool (Ip6ModeData.PrefixTable);\r
    }\r
\r
    if (Ip6ModeData.IcmpTypeList != NULL) {\r
      FreePool (Ip6ModeData.IcmpTypeList);\r
    }\r
\r
    if (GatewayIsFound || (RetryCount == TimeOutInSecond)) {\r
      break;\r
    }\r
\r
    RetryCount++;\r
\r
    //\r
    // Delay 1 second then recheck it again.\r
    //\r
    if (TimeOutEvt == NULL) {\r
      Status = gBS->CreateEvent (\r
                      EVT_TIMER,\r
                      TPL_CALLBACK,\r
                      NULL,\r
                      NULL,\r
                      &TimeOutEvt\r
                      );\r
      if (EFI_ERROR (Status)) {\r
        goto ON_EXIT;\r
      }\r
    }\r
\r
    Status = gBS->SetTimer (TimeOutEvt, TimerRelative, TICKS_PER_SECOND);\r
    if (EFI_ERROR (Status)) {\r
      goto ON_EXIT;\r
    }\r
\r
    while (EFI_ERROR (gBS->CheckEvent (TimeOutEvt))) {\r
      Ip6->Poll (Ip6);\r
    }\r
  }\r
\r
ON_EXIT:\r
  if (TimeOutEvt != NULL) {\r
    gBS->CloseEvent (TimeOutEvt);\r
  }\r
\r
  if (GatewayIsFound) {\r
    Status = EFI_SUCCESS;\r
  } else if (RetryCount == TimeOutInSecond) {\r
    Status = EFI_TIMEOUT;\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
  Register the ready station address and gateway by Ip6Config protocol.\r
\r
  @param[in]  Private             The pointer to PXEBC_PRIVATE_DATA.\r
  @param[in]  Address             The pointer to the ready address.\r
\r
  @retval     EFI_SUCCESS         Registered the address successfully.\r
  @retval     Others              Failed to register the address.\r
\r
**/\r
EFI_STATUS\r
PxeBcRegisterIp6Address (\r
  IN PXEBC_PRIVATE_DATA  *Private,\r
  IN EFI_IPv6_ADDRESS    *Address\r
  )\r
{\r
  EFI_IP6_PROTOCOL               *Ip6;\r
  EFI_IP6_CONFIG_PROTOCOL        *Ip6Cfg;\r
  EFI_IP6_CONFIG_POLICY          Policy;\r
  EFI_IP6_CONFIG_MANUAL_ADDRESS  CfgAddr;\r
  EFI_IPv6_ADDRESS               GatewayAddr;\r
  UINTN                          DataSize;\r
  EFI_EVENT                      MappedEvt;\r
  EFI_STATUS                     Status;\r
  BOOLEAN                        NoGateway;\r
  EFI_IPv6_ADDRESS               *Ip6Addr;\r
  UINTN                          Index;\r
\r
  Status    = EFI_SUCCESS;\r
  MappedEvt = NULL;\r
  Ip6Addr   = NULL;\r
  DataSize  = sizeof (EFI_IP6_CONFIG_POLICY);\r
  Ip6Cfg    = Private->Ip6Cfg;\r
  Ip6       = Private->Ip6;\r
  NoGateway = FALSE;\r
\r
  ZeroMem (&CfgAddr, sizeof (EFI_IP6_CONFIG_MANUAL_ADDRESS));\r
  CopyMem (&CfgAddr.Address, Address, sizeof (EFI_IPv6_ADDRESS));\r
\r
  Status = Ip6->Configure (Ip6, &Private->Ip6CfgData);\r
  if (EFI_ERROR (Status)) {\r
    goto ON_EXIT;\r
  }\r
\r
  //\r
  // Retrieve the gateway address from IP6 route table.\r
  //\r
  Status = PxeBcCheckRouteTable (Private, PXEBC_IP6_ROUTE_TABLE_TIMEOUT, &GatewayAddr);\r
  if (EFI_ERROR (Status)) {\r
    NoGateway = TRUE;\r
  }\r
\r
  //\r
  // There is no channel between IP6 and PXE driver about address setting,\r
  // so it has to set the new address by Ip6ConfigProtocol manually.\r
  //\r
  Policy = Ip6ConfigPolicyManual;\r
  Status = Ip6Cfg->SetData (\r
                     Ip6Cfg,\r
                     Ip6ConfigDataTypePolicy,\r
                     sizeof (EFI_IP6_CONFIG_POLICY),\r
                     &Policy\r
                     );\r
  if (EFI_ERROR (Status)) {\r
    //\r
    // There is no need to recover later.\r
    //\r
    Private->Ip6Policy = PXEBC_IP6_POLICY_MAX;\r
    goto ON_EXIT;\r
  }\r
\r
  //\r
  // Create a notify event to set address flag when DAD if IP6 driver succeeded.\r
  //\r
  Status = gBS->CreateEvent (\r
                  EVT_NOTIFY_SIGNAL,\r
                  TPL_NOTIFY,\r
                  PxeBcCommonNotify,\r
                  &Private->IsAddressOk,\r
                  &MappedEvt\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    goto ON_EXIT;\r
  }\r
\r
  Private->IsAddressOk = FALSE;\r
  Status               = Ip6Cfg->RegisterDataNotify (\r
                                   Ip6Cfg,\r
                                   Ip6ConfigDataTypeManualAddress,\r
                                   MappedEvt\r
                                   );\r
  if (EFI_ERROR (Status)) {\r
    goto ON_EXIT;\r
  }\r
\r
  Status = Ip6Cfg->SetData (\r
                     Ip6Cfg,\r
                     Ip6ConfigDataTypeManualAddress,\r
                     sizeof (EFI_IP6_CONFIG_MANUAL_ADDRESS),\r
                     &CfgAddr\r
                     );\r
  if (EFI_ERROR (Status) && (Status != EFI_NOT_READY)) {\r
    goto ON_EXIT;\r
  } else if (Status == EFI_NOT_READY) {\r
    //\r
    // Poll the network until the asynchronous process is finished.\r
    //\r
    while (!Private->IsAddressOk) {\r
      Ip6->Poll (Ip6);\r
    }\r
\r
    //\r
    // Check whether the IP6 address setting is successed.\r
    //\r
    DataSize = 0;\r
    Status   = Ip6Cfg->GetData (\r
                         Ip6Cfg,\r
                         Ip6ConfigDataTypeManualAddress,\r
                         &DataSize,\r
                         NULL\r
                         );\r
    if ((Status != EFI_BUFFER_TOO_SMALL) || (DataSize == 0)) {\r
      Status = EFI_DEVICE_ERROR;\r
      goto ON_EXIT;\r
    }\r
\r
    Ip6Addr = AllocatePool (DataSize);\r
    if (Ip6Addr == NULL) {\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
\r
    Status = Ip6Cfg->GetData (\r
                       Ip6Cfg,\r
                       Ip6ConfigDataTypeManualAddress,\r
                       &DataSize,\r
                       (VOID *)Ip6Addr\r
                       );\r
    if (EFI_ERROR (Status)) {\r
      Status = EFI_DEVICE_ERROR;\r
      goto ON_EXIT;\r
    }\r
\r
    for (Index = 0; Index < DataSize / sizeof (EFI_IPv6_ADDRESS); Index++) {\r
      if (CompareMem (Ip6Addr + Index, Address, sizeof (EFI_IPv6_ADDRESS)) == 0) {\r
        break;\r
      }\r
    }\r
\r
    if (Index == DataSize / sizeof (EFI_IPv6_ADDRESS)) {\r
      Status = EFI_ABORTED;\r
      goto ON_EXIT;\r
    }\r
  }\r
\r
  //\r
  // Set the default gateway address back if needed.\r
  //\r
  if (!NoGateway && !NetIp6IsUnspecifiedAddr (&GatewayAddr)) {\r
    Status = Ip6Cfg->SetData (\r
                       Ip6Cfg,\r
                       Ip6ConfigDataTypeGateway,\r
                       sizeof (EFI_IPv6_ADDRESS),\r
                       &GatewayAddr\r
                       );\r
    if (EFI_ERROR (Status)) {\r
      goto ON_EXIT;\r
    }\r
  }\r
\r
ON_EXIT:\r
  if (MappedEvt != NULL) {\r
    Ip6Cfg->UnregisterDataNotify (\r
              Ip6Cfg,\r
              Ip6ConfigDataTypeManualAddress,\r
              MappedEvt\r
              );\r
    gBS->CloseEvent (MappedEvt);\r
  }\r
\r
  if (Ip6Addr != NULL) {\r
    FreePool (Ip6Addr);\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
  Set the IP6 policy to Automatic.\r
\r
  @param[in]  Private             The pointer to PXEBC_PRIVATE_DATA.\r
\r
  @retval     EFI_SUCCESS         Switch the IP policy successfully.\r
  @retval     Others              Unexpected error happened.\r
\r
**/\r
EFI_STATUS\r
PxeBcSetIp6Policy (\r
  IN PXEBC_PRIVATE_DATA  *Private\r
  )\r
{\r
  EFI_IP6_CONFIG_POLICY    Policy;\r
  EFI_STATUS               Status;\r
  EFI_IP6_CONFIG_PROTOCOL  *Ip6Cfg;\r
  UINTN                    DataSize;\r
\r
  Ip6Cfg   = Private->Ip6Cfg;\r
  DataSize = sizeof (EFI_IP6_CONFIG_POLICY);\r
\r
  //\r
  // Get and store the current policy of IP6 driver.\r
  //\r
  Status = Ip6Cfg->GetData (\r
                     Ip6Cfg,\r
                     Ip6ConfigDataTypePolicy,\r
                     &DataSize,\r
                     &Private->Ip6Policy\r
                     );\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  if (Private->Ip6Policy == Ip6ConfigPolicyManual) {\r
    Policy = Ip6ConfigPolicyAutomatic;\r
    Status = Ip6Cfg->SetData (\r
                       Ip6Cfg,\r
                       Ip6ConfigDataTypePolicy,\r
                       sizeof (EFI_IP6_CONFIG_POLICY),\r
                       &Policy\r
                       );\r
    if (EFI_ERROR (Status)) {\r
      //\r
      // There is no need to recover later.\r
      //\r
      Private->Ip6Policy = PXEBC_IP6_POLICY_MAX;\r
    }\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
  This function will register the station IP address and flush IP instance to start using the new IP address.\r
\r
  @param[in]  Private             The pointer to PXEBC_PRIVATE_DATA.\r
\r
  @retval     EFI_SUCCESS         The new IP address has been configured successfully.\r
  @retval     Others              Failed to configure the address.\r
\r
**/\r
EFI_STATUS\r
PxeBcSetIp6Address (\r
  IN  PXEBC_PRIVATE_DATA  *Private\r
  )\r
{\r
  EFI_STATUS          Status;\r
  EFI_DHCP6_PROTOCOL  *Dhcp6;\r
\r
  Dhcp6 = Private->Dhcp6;\r
\r
  CopyMem (&Private->StationIp.v6, &Private->TmpStationIp.v6, sizeof (EFI_IPv6_ADDRESS));\r
  CopyMem (&Private->PxeBc.Mode->StationIp.v6, &Private->StationIp.v6, sizeof (EFI_IPv6_ADDRESS));\r
\r
  Status = PxeBcRegisterIp6Address (Private, &Private->StationIp.v6);\r
  if (EFI_ERROR (Status)) {\r
    Dhcp6->Stop (Dhcp6);\r
    return Status;\r
  }\r
\r
  Status = PxeBcFlushStationIp (Private, &Private->StationIp, NULL);\r
  if (EFI_ERROR (Status)) {\r
    PxeBcUnregisterIp6Address (Private);\r
    Dhcp6->Stop (Dhcp6);\r
    return Status;\r
  }\r
\r
  AsciiPrint ("\n  Station IP address is ");\r
  PxeBcShowIp6Addr (&Private->StationIp.v6);\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  EFI_DHCP6_CALLBACK is provided by the consumer of the EFI DHCPv6 Protocol driver\r
  to intercept events that occurred in the configuration process.\r
\r
  @param[in]  This              The pointer to the EFI DHCPv6 Protocol.\r
  @param[in]  Context           The pointer to the context set by EFI_DHCP6_PROTOCOL.Configure().\r
  @param[in]  CurrentState      The current operational state of the EFI DHCPv Protocol driver.\r
  @param[in]  Dhcp6Event        The event that occurs in the current state, which usually means a\r
                                state transition.\r
  @param[in]  Packet            The DHCPv6 packet that is going to be sent or was already received.\r
  @param[out] NewPacket         The packet that is used to replace the Packet above.\r
\r
  @retval EFI_SUCCESS           Told the EFI DHCPv6 Protocol driver to continue the DHCP process.\r
  @retval EFI_NOT_READY         Only used in the Dhcp6Selecting state. The EFI DHCPv6 Protocol\r
                                driver will continue to wait for more packets.\r
  @retval EFI_ABORTED           Told the EFI DHCPv6 Protocol driver to abort the current process.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
PxeBcDhcp6CallBack (\r
  IN  EFI_DHCP6_PROTOCOL  *This,\r
  IN  VOID                *Context,\r
  IN  EFI_DHCP6_STATE     CurrentState,\r
  IN  EFI_DHCP6_EVENT     Dhcp6Event,\r
  IN  EFI_DHCP6_PACKET    *Packet,\r
  OUT EFI_DHCP6_PACKET    **NewPacket     OPTIONAL\r
  )\r
{\r
  PXEBC_PRIVATE_DATA                   *Private;\r
  EFI_PXE_BASE_CODE_MODE               *Mode;\r
  EFI_PXE_BASE_CODE_CALLBACK_PROTOCOL  *Callback;\r
  EFI_DHCP6_PACKET                     *SelectAd;\r
  EFI_STATUS                           Status;\r
  BOOLEAN                              Received;\r
\r
  if ((Dhcp6Event != Dhcp6RcvdAdvertise) &&\r
      (Dhcp6Event != Dhcp6SelectAdvertise) &&\r
      (Dhcp6Event != Dhcp6SendSolicit) &&\r
      (Dhcp6Event != Dhcp6SendRequest) &&\r
      (Dhcp6Event != Dhcp6RcvdReply))\r
  {\r
    return EFI_SUCCESS;\r
  }\r
\r
  ASSERT (Packet != NULL);\r
\r
  Private  = (PXEBC_PRIVATE_DATA *)Context;\r
  Mode     = Private->PxeBc.Mode;\r
  Callback = Private->PxeBcCallback;\r
\r
  //\r
  // Callback to user when any traffic occurred if has.\r
  //\r
  if ((Dhcp6Event != Dhcp6SelectAdvertise) && (Callback != NULL)) {\r
    Received = (BOOLEAN)(Dhcp6Event == Dhcp6RcvdAdvertise || Dhcp6Event == Dhcp6RcvdReply);\r
    Status   = Callback->Callback (\r
                           Callback,\r
                           Private->Function,\r
                           Received,\r
                           Packet->Length,\r
                           (EFI_PXE_BASE_CODE_PACKET *)&Packet->Dhcp6\r
                           );\r
    if (Status != EFI_PXE_BASE_CODE_CALLBACK_STATUS_CONTINUE) {\r
      return EFI_ABORTED;\r
    }\r
  }\r
\r
  Status = EFI_SUCCESS;\r
\r
  switch (Dhcp6Event) {\r
    case Dhcp6SendSolicit:\r
      if (Packet->Length > PXEBC_DHCP6_PACKET_MAX_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
      //\r
      // Record the first Solicate msg time\r
      //\r
      if (Private->SolicitTimes == 0) {\r
        CalcElapsedTime (Private);\r
        Private->SolicitTimes++;\r
      }\r
\r
      //\r
      // Cache the dhcp discover packet to mode data directly.\r
      //\r
      CopyMem (&Mode->DhcpDiscover.Dhcpv4, &Packet->Dhcp6, Packet->Length);\r
      break;\r
\r
    case Dhcp6RcvdAdvertise:\r
      Status = EFI_NOT_READY;\r
      if (Packet->Length > PXEBC_DHCP6_PACKET_MAX_SIZE) {\r
        //\r
        // Ignore the incoming packets which exceed the maximum length.\r
        //\r
        break;\r
      }\r
\r
      if (Private->OfferNum < PXEBC_OFFER_MAX_NUM) {\r
        //\r
        // Cache the dhcp offers to OfferBuffer[] for select later, and record\r
        // the OfferIndex and OfferCount.\r
        //\r
        PxeBcCacheDhcp6Offer (Private, Packet);\r
      }\r
\r
      break;\r
\r
    case Dhcp6SendRequest:\r
      if (Packet->Length > PXEBC_DHCP6_PACKET_MAX_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
      //\r
      // Store the request packet as seed packet for discover.\r
      //\r
      if (Private->Dhcp6Request != NULL) {\r
        FreePool (Private->Dhcp6Request);\r
      }\r
\r
      Private->Dhcp6Request = AllocateZeroPool (Packet->Size);\r
      if (Private->Dhcp6Request != NULL) {\r
        CopyMem (Private->Dhcp6Request, Packet, Packet->Size);\r
      }\r
\r
      break;\r
\r
    case Dhcp6SelectAdvertise:\r
      //\r
      // Select offer by the default policy or by order, and record the SelectIndex\r
      // and SelectProxyType.\r
      //\r
      PxeBcSelectDhcp6Offer (Private);\r
\r
      if (Private->SelectIndex == 0) {\r
        Status = EFI_ABORTED;\r
      } else {\r
        ASSERT (NewPacket != NULL);\r
        SelectAd   = &Private->OfferBuffer[Private->SelectIndex - 1].Dhcp6.Packet.Offer;\r
        *NewPacket = AllocateZeroPool (SelectAd->Size);\r
        ASSERT (*NewPacket != NULL);\r
        if (*NewPacket == NULL) {\r
          return EFI_ABORTED;\r
        }\r
\r
        CopyMem (*NewPacket, SelectAd, SelectAd->Size);\r
      }\r
\r
      break;\r
\r
    case Dhcp6RcvdReply:\r
      //\r
      // Cache the dhcp ack to Private->Dhcp6Ack, but it's not the final ack in mode data\r
      // without verification.\r
      //\r
      ASSERT (Private->SelectIndex != 0);\r
      Status = PxeBcCopyDhcp6Ack (Private, Packet, FALSE);\r
      if (EFI_ERROR (Status)) {\r
        Status = EFI_ABORTED;\r
      }\r
\r
      break;\r
\r
    default:\r
      ASSERT (0);\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
  Build and send out the request packet for the bootfile, and parse the reply.\r
\r
  @param[in]  Private               The pointer to PxeBc private data.\r
  @param[in]  Type                  PxeBc option boot item type.\r
  @param[in]  Layer                 The pointer to option boot item layer.\r
  @param[in]  UseBis                Use BIS or not.\r
  @param[in]  DestIp                The pointer to the server address.\r
\r
  @retval     EFI_SUCCESS           Successfully discovered the boot file.\r
  @retval     EFI_OUT_OF_RESOURCES  Failed to allocate resources.\r
  @retval     EFI_NOT_FOUND         Can't get the PXE reply packet.\r
  @retval     Others                Failed to discover the boot file.\r
\r
**/\r
EFI_STATUS\r
PxeBcDhcp6Discover (\r
  IN  PXEBC_PRIVATE_DATA  *Private,\r
  IN  UINT16              Type,\r
  IN  UINT16              *Layer,\r
  IN  BOOLEAN             UseBis,\r
  IN  EFI_IP_ADDRESS      *DestIp\r
  )\r
{\r
  EFI_PXE_BASE_CODE_UDP_PORT       SrcPort;\r
  EFI_PXE_BASE_CODE_UDP_PORT       DestPort;\r
  EFI_PXE_BASE_CODE_MODE           *Mode;\r
  EFI_PXE_BASE_CODE_PROTOCOL       *PxeBc;\r
  EFI_PXE_BASE_CODE_DHCPV6_PACKET  *Discover;\r
  UINTN                            DiscoverLen;\r
  EFI_DHCP6_PACKET                 *Request;\r
  UINTN                            RequestLen;\r
  EFI_DHCP6_PACKET                 *Reply;\r
  UINT8                            *RequestOpt;\r
  UINT8                            *DiscoverOpt;\r
  UINTN                            ReadSize;\r
  UINT16                           OpCode;\r
  UINT16                           OpLen;\r
  UINT32                           Xid;\r
  EFI_STATUS                       Status;\r
\r
  PxeBc    = &Private->PxeBc;\r
  Mode     = PxeBc->Mode;\r
  Request  = Private->Dhcp6Request;\r
  SrcPort  = PXEBC_BS_DISCOVER_PORT;\r
  DestPort = PXEBC_BS_DISCOVER_PORT;\r
\r
  if (!UseBis && (Layer != NULL)) {\r
    *Layer &= EFI_PXE_BASE_CODE_BOOT_LAYER_MASK;\r
  }\r
\r
  if (Request == NULL) {\r
    return EFI_DEVICE_ERROR;\r
  }\r
\r
  Discover = AllocateZeroPool (sizeof (EFI_PXE_BASE_CODE_DHCPV6_PACKET));\r
  if (Discover == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  //\r
  // Build the discover packet by the cached request packet before.\r
  //\r
  Xid                     = NET_RANDOM (NetRandomInitSeed ());\r
  Discover->TransactionId = HTONL (Xid);\r
  Discover->MessageType   = Request->Dhcp6.Header.MessageType;\r
  RequestOpt              = Request->Dhcp6.Option;\r
  DiscoverOpt             = Discover->DhcpOptions;\r
  DiscoverLen             = sizeof (EFI_DHCP6_HEADER);\r
  RequestLen              = DiscoverLen;\r
\r
  while (RequestLen < Request->Length) {\r
    OpCode = NTOHS (((EFI_DHCP6_PACKET_OPTION *)RequestOpt)->OpCode);\r
    OpLen  = NTOHS (((EFI_DHCP6_PACKET_OPTION *)RequestOpt)->OpLen);\r
    if ((OpCode != EFI_DHCP6_IA_TYPE_NA) &&\r
        (OpCode != EFI_DHCP6_IA_TYPE_TA))\r
    {\r
      //\r
      // Copy all the options except IA option.\r
      //\r
      CopyMem (DiscoverOpt, RequestOpt, OpLen + 4);\r
      DiscoverOpt += (OpLen + 4);\r
      DiscoverLen += (OpLen + 4);\r
    }\r
\r
    RequestOpt += (OpLen + 4);\r
    RequestLen += (OpLen + 4);\r
  }\r
\r
  Status = PxeBc->UdpWrite (\r
                    PxeBc,\r
                    0,\r
                    &Private->ServerIp,\r
                    &DestPort,\r
                    NULL,\r
                    &Private->StationIp,\r
                    &SrcPort,\r
                    NULL,\r
                    NULL,\r
                    &DiscoverLen,\r
                    (VOID *)Discover\r
                    );\r
  if (EFI_ERROR (Status)) {\r
    goto ON_ERROR;\r
  }\r
\r
  //\r
  // Cache the right PXE reply packet here, set valid flag later.\r
  // Especially for PXE discover packet, store it into mode data here.\r
  //\r
  if (Private->IsDoDiscover) {\r
    CopyMem (&Mode->PxeDiscover.Dhcpv6, Discover, DiscoverLen);\r
    Reply = &Private->PxeReply.Dhcp6.Packet.Ack;\r
  } else {\r
    Reply = &Private->ProxyOffer.Dhcp6.Packet.Offer;\r
  }\r
\r
  ReadSize = (UINTN)Reply->Size;\r
\r
  //\r
  // Start Udp6Read instance\r
  //\r
  Status = Private->Udp6Read->Configure (Private->Udp6Read, &Private->Udp6CfgData);\r
  if (EFI_ERROR (Status)) {\r
    goto ON_ERROR;\r
  }\r
\r
  Status = PxeBc->UdpRead (\r
                    PxeBc,\r
                    EFI_PXE_BASE_CODE_UDP_OPFLAGS_ANY_DEST_IP,\r
                    NULL,\r
                    &SrcPort,\r
                    &Private->ServerIp,\r
                    &DestPort,\r
                    NULL,\r
                    NULL,\r
                    &ReadSize,\r
                    (VOID *)&Reply->Dhcp6\r
                    );\r
  //\r
  // Stop Udp6Read instance\r
  //\r
  Private->Udp6Read->Configure (Private->Udp6Read, NULL);\r
  if (EFI_ERROR (Status)) {\r
    goto ON_ERROR;\r
  }\r
\r
  return EFI_SUCCESS;\r
\r
ON_ERROR:\r
  if (Discover != NULL) {\r
    FreePool (Discover);\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
  Start the DHCPv6 S.A.R.R. process to acquire the IPv6 address and other PXE boot information.\r
\r
  @param[in]  Private           The pointer to PxeBc private data.\r
  @param[in]  Dhcp6             The pointer to the EFI_DHCP6_PROTOCOL\r
\r
  @retval EFI_SUCCESS           The S.A.R.R. process successfully finished.\r
  @retval Others                Failed to finish the S.A.R.R. process.\r
\r
**/\r
EFI_STATUS\r
PxeBcDhcp6Sarr (\r
  IN PXEBC_PRIVATE_DATA  *Private,\r
  IN EFI_DHCP6_PROTOCOL  *Dhcp6\r
  )\r
{\r
  EFI_PXE_BASE_CODE_MODE                    *PxeMode;\r
  EFI_DHCP6_CONFIG_DATA                     Config;\r
  EFI_DHCP6_MODE_DATA                       Mode;\r
  EFI_DHCP6_RETRANSMISSION                  *Retransmit;\r
  EFI_DHCP6_PACKET_OPTION                   *OptList[PXEBC_DHCP6_OPTION_MAX_NUM];\r
  UINT8                                     Buffer[PXEBC_DHCP6_OPTION_MAX_SIZE];\r
  UINT32                                    OptCount;\r
  EFI_STATUS                                Status;\r
  EFI_IP6_CONFIG_PROTOCOL                   *Ip6Cfg;\r
  EFI_STATUS                                TimerStatus;\r
  EFI_EVENT                                 Timer;\r
  UINT64                                    GetMappingTimeOut;\r
  UINTN                                     DataSize;\r
  EFI_IP6_CONFIG_DUP_ADDR_DETECT_TRANSMITS  DadXmits;\r
\r
  Status  = EFI_SUCCESS;\r
  PxeMode = Private->PxeBc.Mode;\r
  Ip6Cfg  = Private->Ip6Cfg;\r
  Timer   = NULL;\r
\r
  //\r
  // Build option list for the request packet.\r
  //\r
  OptCount = PxeBcBuildDhcp6Options (Private, OptList, Buffer);\r
  ASSERT (OptCount > 0);\r
\r
  Retransmit = AllocateZeroPool (sizeof (EFI_DHCP6_RETRANSMISSION));\r
  if (Retransmit == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  ZeroMem (&Mode, sizeof (EFI_DHCP6_MODE_DATA));\r
  ZeroMem (&Config, sizeof (EFI_DHCP6_CONFIG_DATA));\r
\r
  Config.OptionCount           = OptCount;\r
  Config.OptionList            = OptList;\r
  Config.Dhcp6Callback         = PxeBcDhcp6CallBack;\r
  Config.CallbackContext       = Private;\r
  Config.IaInfoEvent           = NULL;\r
  Config.RapidCommit           = FALSE;\r
  Config.ReconfigureAccept     = FALSE;\r
  Config.IaDescriptor.IaId     = Private->IaId;\r
  Config.IaDescriptor.Type     = EFI_DHCP6_IA_TYPE_NA;\r
  Config.SolicitRetransmission = Retransmit;\r
  Retransmit->Irt              = 4;\r
  Retransmit->Mrc              = 4;\r
  Retransmit->Mrt              = 32;\r
  Retransmit->Mrd              = 60;\r
\r
  //\r
  // Configure the DHCPv6 instance for PXE boot.\r
  //\r
  Status = Dhcp6->Configure (Dhcp6, &Config);\r
  FreePool (Retransmit);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  //\r
  // Initialize the record fields for DHCPv6 offer in private data.\r
  //\r
  Private->IsProxyRecved = FALSE;\r
  Private->OfferNum      = 0;\r
  Private->SelectIndex   = 0;\r
  ZeroMem (Private->OfferCount, sizeof (Private->OfferCount));\r
  ZeroMem (Private->OfferIndex, sizeof (Private->OfferIndex));\r
\r
  //\r
  // Start DHCPv6 S.A.R.R. process to acquire IPv6 address.\r
  //\r
  Status = Dhcp6->Start (Dhcp6);\r
  if (Status == EFI_NO_MAPPING) {\r
    //\r
    // IP6 Linklocal address is not available for use, so stop current Dhcp process\r
    // and wait for duplicate address detection to finish.\r
    //\r
    Dhcp6->Stop (Dhcp6);\r
\r
    //\r
    // Get Duplicate Address Detection Transmits count.\r
    //\r
    DataSize = sizeof (EFI_IP6_CONFIG_DUP_ADDR_DETECT_TRANSMITS);\r
    Status   = Ip6Cfg->GetData (\r
                         Ip6Cfg,\r
                         Ip6ConfigDataTypeDupAddrDetectTransmits,\r
                         &DataSize,\r
                         &DadXmits\r
                         );\r
    if (EFI_ERROR (Status)) {\r
      Dhcp6->Configure (Dhcp6, NULL);\r
      return Status;\r
    }\r
\r
    Status = gBS->CreateEvent (EVT_TIMER, TPL_CALLBACK, NULL, NULL, &Timer);\r
    if (EFI_ERROR (Status)) {\r
      Dhcp6->Configure (Dhcp6, NULL);\r
      return Status;\r
    }\r
\r
    GetMappingTimeOut = TICKS_PER_SECOND * DadXmits.DupAddrDetectTransmits + PXEBC_DAD_ADDITIONAL_DELAY;\r
    Status            = gBS->SetTimer (Timer, TimerRelative, GetMappingTimeOut);\r
    if (EFI_ERROR (Status)) {\r
      gBS->CloseEvent (Timer);\r
      Dhcp6->Configure (Dhcp6, NULL);\r
      return Status;\r
    }\r
\r
    do {\r
      TimerStatus = gBS->CheckEvent (Timer);\r
      if (!EFI_ERROR (TimerStatus)) {\r
        Status = Dhcp6->Start (Dhcp6);\r
      }\r
    } while (TimerStatus == EFI_NOT_READY);\r
\r
    gBS->CloseEvent (Timer);\r
  }\r
\r
  if (EFI_ERROR (Status)) {\r
    if (Status == EFI_ICMP_ERROR) {\r
      PxeMode->IcmpErrorReceived = TRUE;\r
    }\r
\r
    Dhcp6->Configure (Dhcp6, NULL);\r
    return Status;\r
  }\r
\r
  //\r
  // Get the acquired IPv6 address and store them.\r
  //\r
  Status = Dhcp6->GetModeData (Dhcp6, &Mode, NULL);\r
  if (EFI_ERROR (Status)) {\r
    Dhcp6->Stop (Dhcp6);\r
    return Status;\r
  }\r
\r
  ASSERT ((Mode.Ia != NULL) && (Mode.Ia->State == Dhcp6Bound));\r
  //\r
  // DHCP6 doesn't have an option to specify the router address on the subnet, the only way to get the\r
  // router address in IP6 is the router discovery mechanism (the RS and RA, which only be handled when\r
  // the IP policy is Automatic). So we just hold the station IP address here and leave the IP policy as\r
  // Automatic, until we get the server IP address. This could let IP6 driver finish the router discovery\r
  // to find a valid router address.\r
  //\r
  CopyMem (&Private->TmpStationIp.v6, &Mode.Ia->IaAddress[0].IpAddress, sizeof (EFI_IPv6_ADDRESS));\r
  if (Mode.ClientId != NULL) {\r
    FreePool (Mode.ClientId);\r
  }\r
\r
  if (Mode.Ia != NULL) {\r
    FreePool (Mode.Ia);\r
  }\r
\r
  //\r
  // Check the selected offer whether BINL retry is needed.\r
  //\r
  Status = PxeBcHandleDhcp6Offer (Private);\r
  if (EFI_ERROR (Status)) {\r
    Dhcp6->Stop (Dhcp6);\r
    return Status;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r