NetworkPkg/UefiPxeBcDxe/PxeBcSupport.c

   1 /** @file
   2   Support functions implementation for UefiPxeBc Driver.
   3
   4   Copyright (c) 2007 - 2017, Intel Corporation. All rights reserved.<BR>
   5
   6   This program and the accompanying materials
   7   are licensed and made available under the terms and conditions of the BSD License
   8   which accompanies this distribution.  The full text of the license may be found at
   9   http://opensource.org/licenses/bsd-license.php.
  10
  11   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  12   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  13
  14 **/
  15
  16 #include "PxeBcImpl.h"
  17
  18
  19 /**
  20   Flush the previous configration using the new station Ip address.
  21
  22   @param[in]   Private        The pointer to the PxeBc private data.
  23   @param[in]   StationIp      The pointer to the station Ip address.
  24   @param[in]   SubnetMask     The pointer to the subnet mask address for v4.
  25
  26   @retval EFI_SUCCESS         Successfully flushed the previous configuration.
  27   @retval Others              Failed to flush using the new station Ip.
  28
  29 **/
  30 EFI_STATUS
  31 PxeBcFlushStationIp (
  32   PXEBC_PRIVATE_DATA       *Private,
  33   EFI_IP_ADDRESS           *StationIp,
  34   EFI_IP_ADDRESS           *SubnetMask     OPTIONAL
  35   )
  36 {
  37   EFI_PXE_BASE_CODE_MODE   *Mode;
  38   EFI_STATUS               Status;
  39
  40   ASSERT (StationIp != NULL);
  41
  42   Mode   = Private->PxeBc.Mode;
  43   Status = EFI_SUCCESS;
  44
  45   if (Mode->UsingIpv6) {
  46
  47     CopyMem (&Private->Udp6CfgData.StationAddress, StationIp, sizeof (EFI_IPv6_ADDRESS));
  48     CopyMem (&Private->Ip6CfgData.StationAddress, StationIp, sizeof (EFI_IPv6_ADDRESS));
  49
  50     //
  51     // Reconfigure the Ip6 instance to capture background ICMP6 packets with new station Ip address.
  52     //
  53     Private->Ip6->Cancel (Private->Ip6, &Private->Icmp6Token);
  54     Private->Ip6->Configure (Private->Ip6, NULL);
  55
  56     Status = Private->Ip6->Configure (Private->Ip6, &Private->Ip6CfgData);
  57     if (EFI_ERROR (Status)) {
  58       goto ON_EXIT;
  59     }
  60
  61     Status = Private->Ip6->Receive (Private->Ip6, &Private->Icmp6Token);
  62   } else {
  63     ASSERT (SubnetMask != NULL);
  64     CopyMem (&Private->Udp4CfgData.StationAddress, StationIp, sizeof (EFI_IPv4_ADDRESS));
  65     CopyMem (&Private->Udp4CfgData.SubnetMask, SubnetMask, sizeof (EFI_IPv4_ADDRESS));
  66     CopyMem (&Private->Ip4CfgData.StationAddress, StationIp, sizeof (EFI_IPv4_ADDRESS));
  67     CopyMem (&Private->Ip4CfgData.SubnetMask, SubnetMask, sizeof (EFI_IPv4_ADDRESS));
  68
  69     //
  70     // Reconfigure the Ip4 instance to capture background ICMP packets with new station Ip address.
  71     //
  72     Private->Ip4->Cancel (Private->Ip4, &Private->IcmpToken);
  73     Private->Ip4->Configure (Private->Ip4, NULL);
  74
  75     Status = Private->Ip4->Configure (Private->Ip4, &Private->Ip4CfgData);
  76     if (EFI_ERROR (Status)) {
  77       goto ON_EXIT;
  78     }
  79
  80     Status = Private->Ip4->Receive (Private->Ip4, &Private->IcmpToken);
  81   }
  82
  83 ON_EXIT:
  84   return Status;
  85 }
  86
  87
  88 /**
  89   Notify the callback function when an event is triggered.
  90
  91   @param[in]  Event           The triggered event.
  92   @param[in]  Context         The opaque parameter to the function.
  93
  94 **/
  95 VOID
  96 EFIAPI
  97 PxeBcCommonNotify (
  98   IN EFI_EVENT           Event,
  99   IN VOID                *Context
 100   )
 101 {
 102   *((BOOLEAN *) Context) = TRUE;
 103 }
 104
 105
 106 /**
 107   Do arp resolution from arp cache in PxeBcMode.
 108
 109   @param  Mode           The pointer to EFI_PXE_BASE_CODE_MODE.
 110   @param  Ip4Addr        The Ip4 address for resolution.
 111   @param  MacAddress     The resoluted MAC address if the resolution is successful.
 112                          The value is undefined if the resolution fails.
 113
 114   @retval TRUE           Found an matched entry.
 115   @retval FALSE          Did not find a matched entry.
 116
 117 **/
 118 BOOLEAN
 119 PxeBcCheckArpCache (
 120   IN  EFI_PXE_BASE_CODE_MODE    *Mode,
 121   IN  EFI_IPv4_ADDRESS          *Ip4Addr,
 122   OUT EFI_MAC_ADDRESS           *MacAddress
 123   )
 124 {
 125   UINT32       Index;
 126
 127   ASSERT (!Mode->UsingIpv6);
 128
 129   //
 130   // Check whether the current Arp cache in mode data contains this information or not.
 131   //
 132   for (Index = 0; Index < Mode->ArpCacheEntries; Index++) {
 133     if (EFI_IP4_EQUAL (&Mode->ArpCache[Index].IpAddr.v4, Ip4Addr)) {
 134       CopyMem (
 135         MacAddress,
 136         &Mode->ArpCache[Index].MacAddr,
 137         sizeof (EFI_MAC_ADDRESS)
 138         );
 139       return TRUE;
 140     }
 141   }
 142
 143   return FALSE;
 144 }
 145
 146
 147 /**
 148   Update the arp cache periodically.
 149
 150   @param  Event              The pointer to EFI_PXE_BC_PROTOCOL.
 151   @param  Context            Context of the timer event.
 152
 153 **/
 154 VOID
 155 EFIAPI
 156 PxeBcArpCacheUpdate (
 157   IN EFI_EVENT            Event,
 158   IN VOID                 *Context
 159   )
 160 {
 161   PXEBC_PRIVATE_DATA      *Private;
 162   EFI_PXE_BASE_CODE_MODE  *Mode;
 163   EFI_ARP_FIND_DATA       *ArpEntry;
 164   UINT32                  EntryLength;
 165   UINT32                  EntryCount;
 166   UINT32                  Index;
 167   EFI_STATUS              Status;
 168
 169   Private = (PXEBC_PRIVATE_DATA *) Context;
 170   Mode    = Private->PxeBc.Mode;
 171
 172   ASSERT (!Mode->UsingIpv6);
 173
 174   //
 175   // Get the current Arp cache from Arp driver.
 176   //
 177   Status = Private->Arp->Find (
 178                            Private->Arp,
 179                            TRUE,
 180                            NULL,
 181                            &EntryLength,
 182                            &EntryCount,
 183                            &ArpEntry,
 184                            TRUE
 185                            );
 186   if (EFI_ERROR (Status)) {
 187     return;
 188   }
 189
 190   //
 191   // Update the Arp cache in mode data.
 192   //
 193   Mode->ArpCacheEntries = MIN (EntryCount, EFI_PXE_BASE_CODE_MAX_ARP_ENTRIES);
 194
 195   for (Index = 0; Index < Mode->ArpCacheEntries; Index++) {
 196     CopyMem (
 197       &Mode->ArpCache[Index].IpAddr,
 198       ArpEntry + 1,
 199       ArpEntry->SwAddressLength
 200       );
 201     CopyMem (
 202       &Mode->ArpCache[Index].MacAddr,
 203       (UINT8 *) (ArpEntry + 1) + ArpEntry->SwAddressLength,
 204       ArpEntry->HwAddressLength
 205       );
 206     ArpEntry = (EFI_ARP_FIND_DATA *) ((UINT8 *) ArpEntry + EntryLength);
 207   }
 208 }
 209
 210
 211 /**
 212   Notify function to handle the received ICMP message in DPC.
 213
 214   @param  Context               The PXEBC private data.
 215
 216 **/
 217 VOID
 218 EFIAPI
 219 PxeBcIcmpErrorDpcHandle (
 220   IN VOID                      *Context
 221   )
 222 {
 223   EFI_STATUS                   Status;
 224   EFI_IP4_RECEIVE_DATA         *RxData;
 225   EFI_IP4_PROTOCOL             *Ip4;
 226   PXEBC_PRIVATE_DATA           *Private;
 227   EFI_PXE_BASE_CODE_MODE       *Mode;
 228   UINT8                        Type;
 229   UINTN                        Index;
 230   UINT32                       CopiedLen;
 231   UINT8                        *IcmpError;
 232
 233   Private = (PXEBC_PRIVATE_DATA *) Context;
 234   Mode    = &Private->Mode;
 235   Status  = Private->IcmpToken.Status;
 236   RxData  = Private->IcmpToken.Packet.RxData;
 237   Ip4     = Private->Ip4;
 238
 239   ASSERT (!Mode->UsingIpv6);
 240
 241   if (Status == EFI_ABORTED) {
 242     //
 243     // It's triggered by user cancellation.
 244     //
 245     return;
 246   }
 247
 248   if (RxData == NULL) {
 249     goto ON_EXIT;
 250   }
 251
 252   if (Status != EFI_ICMP_ERROR) {
 253     //
 254     // The return status should be recognized as EFI_ICMP_ERROR.
 255     //
 256     gBS->SignalEvent (RxData->RecycleSignal);
 257     goto ON_EXIT;
 258   }
 259
 260   if (EFI_IP4 (RxData->Header->SourceAddress) != 0 &&
 261       (NTOHL (Mode->SubnetMask.Addr[0]) != 0) &&
 262       IP4_NET_EQUAL (NTOHL(Mode->StationIp.Addr[0]), EFI_NTOHL (RxData->Header->SourceAddress), NTOHL (Mode->SubnetMask.Addr[0])) &&
 263       !NetIp4IsUnicast (EFI_NTOHL (RxData->Header->SourceAddress), NTOHL (Mode->SubnetMask.Addr[0]))) {
 264     //
 265     // The source address of the received packet should be a valid unicast address.
 266     //
 267     gBS->SignalEvent (RxData->RecycleSignal);
 268     goto ON_EXIT;
 269   }
 270
 271   if (!EFI_IP4_EQUAL (&RxData->Header->DestinationAddress, &Mode->StationIp.v4)) {
 272     //
 273     // The destination address of the received packet should be equal to the host address.
 274     //
 275     gBS->SignalEvent (RxData->RecycleSignal);
 276     goto ON_EXIT;
 277   }
 278
 279   if (RxData->Header->Protocol != EFI_IP_PROTO_ICMP) {
 280     //
 281     // The protocol value in the header of the receveid packet should be EFI_IP_PROTO_ICMP.
 282     //
 283     gBS->SignalEvent (RxData->RecycleSignal);
 284     goto ON_EXIT;
 285   }
 286
 287   Type = *((UINT8 *) RxData->FragmentTable[0].FragmentBuffer);
 288
 289   if (Type != ICMP_DEST_UNREACHABLE &&
 290       Type != ICMP_SOURCE_QUENCH &&
 291       Type != ICMP_REDIRECT &&
 292       Type != ICMP_TIME_EXCEEDED &&
 293       Type != ICMP_PARAMETER_PROBLEM) {
 294     //
 295     // The type of the receveid ICMP message should be ICMP_ERROR_MESSAGE.
 296     //
 297     gBS->SignalEvent (RxData->RecycleSignal);
 298     goto ON_EXIT;
 299   }
 300
 301   //
 302   // Copy the right ICMP error message into mode data.
 303   //
 304   CopiedLen = 0;
 305   IcmpError = (UINT8 *) &Mode->IcmpError;
 306
 307   for (Index = 0; Index < RxData->FragmentCount; Index++) {
 308     CopiedLen += RxData->FragmentTable[Index].FragmentLength;
 309     if (CopiedLen <= sizeof (EFI_PXE_BASE_CODE_ICMP_ERROR)) {
 310       CopyMem (
 311         IcmpError,
 312         RxData->FragmentTable[Index].FragmentBuffer,
 313         RxData->FragmentTable[Index].FragmentLength
 314         );
 315     } else {
 316       CopyMem (
 317         IcmpError,
 318         RxData->FragmentTable[Index].FragmentBuffer,
 319         CopiedLen - sizeof (EFI_PXE_BASE_CODE_ICMP_ERROR)
 320         );
 321     }
 322     IcmpError += CopiedLen;
 323   }
 324
 325 ON_EXIT:
 326   Private->IcmpToken.Status = EFI_NOT_READY;
 327   Ip4->Receive (Ip4, &Private->IcmpToken);
 328 }
 329
 330
 331 /**
 332   Callback function to update the latest ICMP6 error message.
 333
 334   @param  Event                 The event signalled.
 335   @param  Context               The context passed in using the event notifier.
 336
 337 **/
 338 VOID
 339 EFIAPI
 340 PxeBcIcmpErrorUpdate (
 341   IN EFI_EVENT            Event,
 342   IN VOID                 *Context
 343   )
 344 {
 345   QueueDpc (TPL_CALLBACK, PxeBcIcmpErrorDpcHandle, Context);
 346 }
 347
 348
 349 /**
 350   Notify function to handle the received ICMP6 message in DPC.
 351
 352   @param  Context               The PXEBC private data.
 353
 354 **/
 355 VOID
 356 EFIAPI
 357 PxeBcIcmp6ErrorDpcHandle (
 358   IN VOID                 *Context
 359   )
 360 {
 361   PXEBC_PRIVATE_DATA      *Private;
 362   EFI_IP6_RECEIVE_DATA    *RxData;
 363   EFI_IP6_PROTOCOL        *Ip6;
 364   EFI_PXE_BASE_CODE_MODE  *Mode;
 365   EFI_STATUS              Status;
 366   UINTN                   Index;
 367   UINT8                   Type;
 368   UINT32                  CopiedLen;
 369   UINT8                   *Icmp6Error;
 370
 371   Private = (PXEBC_PRIVATE_DATA *) Context;
 372   Mode    = &Private->Mode;
 373   Status  = Private->Icmp6Token.Status;
 374   RxData  = Private->Icmp6Token.Packet.RxData;
 375   Ip6     = Private->Ip6;
 376
 377   ASSERT (Mode->UsingIpv6);
 378
 379   if (Status == EFI_ABORTED) {
 380     //
 381     // It's triggered by user cancellation.
 382     //
 383     return;
 384   }
 385
 386   if (RxData == NULL) {
 387     goto ON_EXIT;
 388   }
 389
 390   if (Status != EFI_ICMP_ERROR) {
 391     //
 392     // The return status should be recognized as EFI_ICMP_ERROR.
 393     //
 394     gBS->SignalEvent (RxData->RecycleSignal);
 395     goto ON_EXIT;
 396   }
 397
 398   if (!NetIp6IsValidUnicast (&RxData->Header->SourceAddress)) {
 399     //
 400     // The source address of the received packet should be a valid unicast address.
 401     //
 402     gBS->SignalEvent (RxData->RecycleSignal);
 403     goto ON_EXIT;
 404   }
 405
 406   if (!NetIp6IsUnspecifiedAddr (&Mode->StationIp.v6) &&
 407       !EFI_IP6_EQUAL (&RxData->Header->DestinationAddress, &Mode->StationIp.v6)) {
 408     //
 409     // The destination address of the received packet should be equal to the host address.
 410     //
 411     gBS->SignalEvent (RxData->RecycleSignal);
 412     goto ON_EXIT;
 413   }
 414
 415   if (RxData->Header->NextHeader != IP6_ICMP) {
 416     //
 417     // The nextheader in the header of the receveid packet should be IP6_ICMP.
 418     //
 419     gBS->SignalEvent (RxData->RecycleSignal);
 420     goto ON_EXIT;
 421   }
 422
 423   Type = *((UINT8 *) RxData->FragmentTable[0].FragmentBuffer);
 424
 425   if (Type != ICMP_V6_DEST_UNREACHABLE &&
 426       Type != ICMP_V6_PACKET_TOO_BIG &&
 427       Type != ICMP_V6_TIME_EXCEEDED &&
 428       Type != ICMP_V6_PARAMETER_PROBLEM) {
 429     //
 430     // The type of the receveid packet should be an ICMP6 error message.
 431     //
 432     gBS->SignalEvent (RxData->RecycleSignal);
 433     goto ON_EXIT;
 434   }
 435
 436   //
 437   // Copy the right ICMP6 error message into mode data.
 438   //
 439   CopiedLen  = 0;
 440   Icmp6Error = (UINT8 *) &Mode->IcmpError;
 441
 442   for (Index = 0; Index < RxData->FragmentCount; Index++) {
 443     CopiedLen += RxData->FragmentTable[Index].FragmentLength;
 444     if (CopiedLen <= sizeof (EFI_PXE_BASE_CODE_ICMP_ERROR)) {
 445       CopyMem (
 446         Icmp6Error,
 447         RxData->FragmentTable[Index].FragmentBuffer,
 448         RxData->FragmentTable[Index].FragmentLength
 449         );
 450     } else {
 451       CopyMem (
 452         Icmp6Error,
 453         RxData->FragmentTable[Index].FragmentBuffer,
 454         CopiedLen - sizeof (EFI_PXE_BASE_CODE_ICMP_ERROR)
 455         );
 456     }
 457     Icmp6Error += CopiedLen;
 458   }
 459
 460 ON_EXIT:
 461   Private->Icmp6Token.Status = EFI_NOT_READY;
 462   Ip6->Receive (Ip6, &Private->Icmp6Token);
 463 }
 464
 465
 466 /**
 467   Callback function to update the latest ICMP6 error message.
 468
 469   @param  Event                 The event signalled.
 470   @param  Context               The context passed in using the event notifier.
 471
 472 **/
 473 VOID
 474 EFIAPI
 475 PxeBcIcmp6ErrorUpdate (
 476   IN EFI_EVENT               Event,
 477   IN VOID                    *Context
 478   )
 479 {
 480   QueueDpc (TPL_CALLBACK, PxeBcIcmp6ErrorDpcHandle, Context);
 481 }
 482
 483
 484 /**
 485   This function is to configure a UDPv4 instance for UdpWrite.
 486
 487   @param[in]       Udp4                 The pointer to EFI_UDP4_PROTOCOL.
 488   @param[in]       StationIp            The pointer to the station address.
 489   @param[in]       SubnetMask           The pointer to the subnet mask.
 490   @param[in]       Gateway              The pointer to the gateway address.
 491   @param[in, out]  SrcPort              The pointer to the source port.
 492   @param[in]       DoNotFragment        If TRUE, fragment is not enabled.
 493                                         Otherwise, fragment is enabled.
 494   @param[in]       Ttl                  The time to live field of the IP header.
 495   @param[in]       ToS                  The type of service field of the IP header.
 496
 497   @retval          EFI_SUCCESS          Successfully configured this instance.
 498   @retval          Others               Failed to configure this instance.
 499
 500 **/
 501 EFI_STATUS
 502 PxeBcConfigUdp4Write (
 503   IN     EFI_UDP4_PROTOCOL  *Udp4,
 504   IN     EFI_IPv4_ADDRESS   *StationIp,
 505   IN     EFI_IPv4_ADDRESS   *SubnetMask,
 506   IN     EFI_IPv4_ADDRESS   *Gateway,
 507   IN OUT UINT16             *SrcPort,
 508   IN     BOOLEAN            DoNotFragment,
 509   IN     UINT8              Ttl,
 510   IN     UINT8              ToS
 511   )
 512 {
 513   EFI_UDP4_CONFIG_DATA  Udp4CfgData;
 514   EFI_STATUS            Status;
 515
 516   ZeroMem (&Udp4CfgData, sizeof (Udp4CfgData));
 517
 518   Udp4CfgData.TransmitTimeout    = PXEBC_DEFAULT_LIFETIME;
 519   Udp4CfgData.ReceiveTimeout     = PXEBC_DEFAULT_LIFETIME;
 520   Udp4CfgData.TypeOfService      = ToS;
 521   Udp4CfgData.TimeToLive         = Ttl;
 522   Udp4CfgData.AllowDuplicatePort = TRUE;
 523   Udp4CfgData.DoNotFragment      = DoNotFragment;
 524
 525   CopyMem (&Udp4CfgData.StationAddress, StationIp, sizeof (*StationIp));
 526   CopyMem (&Udp4CfgData.SubnetMask, SubnetMask, sizeof (*SubnetMask));
 527
 528   Udp4CfgData.StationPort = *SrcPort;
 529
 530   //
 531   // Reset the UDPv4 instance.
 532   //
 533   Udp4->Configure (Udp4, NULL);
 534
 535   Status = Udp4->Configure (Udp4, &Udp4CfgData);
 536   if (!EFI_ERROR (Status) && !EFI_IP4_EQUAL (Gateway, &mZeroIp4Addr)) {
 537     //
 538     // The basic configuration is OK, need to add the default route entry
 539     //
 540     Status = Udp4->Routes (Udp4, FALSE, &mZeroIp4Addr, &mZeroIp4Addr, Gateway);
 541     if (EFI_ERROR (Status)) {
 542       Udp4->Configure (Udp4, NULL);
 543     }
 544   }
 545
 546   if (!EFI_ERROR (Status) && *SrcPort == 0) {
 547     Udp4->GetModeData (Udp4, &Udp4CfgData, NULL, NULL, NULL);
 548     *SrcPort = Udp4CfgData.StationPort;
 549   }
 550
 551   return Status;
 552 }
 553
 554
 555 /**
 556   This function is to configure a UDPv6 instance for UdpWrite.
 557
 558   @param[in]       Udp6                 The pointer to EFI_UDP6_PROTOCOL.
 559   @param[in]       StationIp            The pointer to the station address.
 560   @param[in, out]  SrcPort              The pointer to the source port.
 561
 562   @retval          EFI_SUCCESS          Successfully configured this instance.
 563   @retval          Others               Failed to configure this instance.
 564
 565 **/
 566 EFI_STATUS
 567 PxeBcConfigUdp6Write (
 568   IN     EFI_UDP6_PROTOCOL  *Udp6,
 569   IN     EFI_IPv6_ADDRESS   *StationIp,
 570   IN OUT UINT16             *SrcPort
 571   )
 572 {
 573   EFI_UDP6_CONFIG_DATA  CfgData;
 574   EFI_STATUS            Status;
 575
 576   ZeroMem (&CfgData, sizeof (EFI_UDP6_CONFIG_DATA));
 577
 578   CfgData.ReceiveTimeout     = PXEBC_DEFAULT_LIFETIME;
 579   CfgData.TransmitTimeout    = PXEBC_DEFAULT_LIFETIME;
 580   CfgData.HopLimit           = PXEBC_DEFAULT_HOPLIMIT;
 581   CfgData.AllowDuplicatePort = TRUE;
 582   CfgData.StationPort        = *SrcPort;
 583
 584   CopyMem (&CfgData.StationAddress, StationIp, sizeof (EFI_IPv6_ADDRESS));
 585
 586   //
 587   // Reset the UDPv6 instance.
 588   //
 589   Udp6->Configure (Udp6, NULL);
 590
 591   Status = Udp6->Configure (Udp6, &CfgData);
 592   if (EFI_ERROR (Status)) {
 593     return Status;
 594   }
 595
 596   if (!EFI_ERROR (Status) && *SrcPort == 0) {
 597     Udp6->GetModeData (Udp6, &CfgData, NULL, NULL, NULL);
 598     *SrcPort = CfgData.StationPort;
 599   }
 600
 601   return Status;
 602 }
 603
 604
 605 /**
 606   This function is to configure a UDPv4 instance for UdpWrite.
 607
 608   @param[in]       Udp4                 The pointer to EFI_UDP4_PROTOCOL.
 609   @param[in]       Session              The pointer to the UDP4 session data.
 610   @param[in]       TimeoutEvent         The event for timeout.
 611   @param[in]       Gateway              The pointer to the gateway address.
 612   @param[in]       HeaderSize           An optional field which may be set to the length of a header
 613                                         at HeaderPtr to be prefixed to the data at BufferPtr.
 614   @param[in]       HeaderPtr            If HeaderSize is not NULL, a pointer to a header to be
 615                                         prefixed to the data at BufferPtr.
 616   @param[in]       BufferSize           A pointer to the size of the data at BufferPtr.
 617   @param[in]       BufferPtr            A pointer to the data to be written.
 618
 619   @retval          EFI_SUCCESS          Successfully send out data using Udp4Write.
 620   @retval          Others               Failed to send out data.
 621
 622 **/
 623 EFI_STATUS
 624 PxeBcUdp4Write (
 625   IN EFI_UDP4_PROTOCOL       *Udp4,
 626   IN EFI_UDP4_SESSION_DATA   *Session,
 627   IN EFI_EVENT               TimeoutEvent,
 628   IN EFI_IPv4_ADDRESS        *Gateway      OPTIONAL,
 629   IN UINTN                   *HeaderSize   OPTIONAL,
 630   IN VOID                    *HeaderPtr    OPTIONAL,
 631   IN UINTN                   *BufferSize,
 632   IN VOID                    *BufferPtr
 633   )
 634 {
 635   EFI_UDP4_COMPLETION_TOKEN Token;
 636   EFI_UDP4_TRANSMIT_DATA    *TxData;
 637   UINT32                    TxLength;
 638   UINT32                    FragCount;
 639   UINT32                    DataLength;
 640   BOOLEAN                   IsDone;
 641   EFI_STATUS                Status;
 642
 643   //
 644   // Arrange one fragment buffer for data, and another fragment buffer for header if has.
 645   //
 646   FragCount = (HeaderSize != NULL) ? 2 : 1;
 647   TxLength  = sizeof (EFI_UDP4_TRANSMIT_DATA) + (FragCount - 1) * sizeof (EFI_UDP4_FRAGMENT_DATA);
 648   TxData    = (EFI_UDP4_TRANSMIT_DATA *) AllocateZeroPool (TxLength);
 649   if (TxData == NULL) {
 650     return EFI_OUT_OF_RESOURCES;
 651   }
 652
 653   TxData->FragmentCount                               = FragCount;
 654   TxData->FragmentTable[FragCount - 1].FragmentLength = (UINT32) *BufferSize;
 655   TxData->FragmentTable[FragCount - 1].FragmentBuffer = BufferPtr;
 656   DataLength                                          = (UINT32) *BufferSize;
 657
 658   if (HeaderSize != NULL) {
 659     TxData->FragmentTable[0].FragmentLength = (UINT32) *HeaderSize;
 660     TxData->FragmentTable[0].FragmentBuffer = HeaderPtr;
 661     DataLength                             += (UINT32) *HeaderSize;
 662   }
 663
 664   if (Gateway != NULL) {
 665     TxData->GatewayAddress  = Gateway;
 666   }
 667
 668   TxData->UdpSessionData  = Session;
 669   TxData->DataLength      = DataLength;
 670   Token.Packet.TxData     = TxData;
 671   Token.Status            = EFI_NOT_READY;
 672   IsDone                  = FALSE;
 673
 674   Status = gBS->CreateEvent (
 675                   EVT_NOTIFY_SIGNAL,
 676                   TPL_NOTIFY,
 677                   PxeBcCommonNotify,
 678                   &IsDone,
 679                   &Token.Event
 680                   );
 681   if (EFI_ERROR (Status)) {
 682     goto ON_EXIT;
 683   }
 684
 685   Status = Udp4->Transmit (Udp4, &Token);
 686   if (EFI_ERROR (Status)) {
 687     goto ON_EXIT;
 688   }
 689
 690   //
 691   // Poll the UDPv6 read instance if no packet received and no timeout triggered.
 692   //
 693   while (!IsDone &&
 694          Token.Status == EFI_NOT_READY &&
 695          EFI_ERROR (gBS->CheckEvent (TimeoutEvent))) {
 696     Udp4->Poll (Udp4);
 697   }
 698
 699   Status = (Token.Status == EFI_NOT_READY) ? EFI_TIMEOUT : Token.Status;
 700
 701 ON_EXIT:
 702   if (Token.Event != NULL) {
 703     gBS->CloseEvent (Token.Event);
 704   }
 705   FreePool (TxData);
 706
 707   return Status;
 708 }
 709
 710
 711 /**
 712   This function is to configure a UDPv4 instance for UdpWrite.
 713
 714   @param[in]       Udp6                 The pointer to EFI_UDP6_PROTOCOL.
 715   @param[in]       Session              The pointer to the UDP6 session data.
 716   @param[in]       TimeoutEvent         The event for timeout.
 717   @param[in]       HeaderSize           An optional field which may be set to the length of a header
 718                                         at HeaderPtr to be prefixed to the data at BufferPtr.
 719   @param[in]       HeaderPtr            If HeaderSize is not NULL, a pointer to a header to be
 720                                         prefixed to the data at BufferPtr.
 721   @param[in]       BufferSize           A pointer to the size of the data at BufferPtr.
 722   @param[in]       BufferPtr            A pointer to the data to be written.
 723
 724   @retval          EFI_SUCCESS          Successfully sent out data using Udp6Write.
 725   @retval          Others               Failed to send out data.
 726
 727 **/
 728 EFI_STATUS
 729 PxeBcUdp6Write (
 730   IN EFI_UDP6_PROTOCOL       *Udp6,
 731   IN EFI_UDP6_SESSION_DATA   *Session,
 732   IN EFI_EVENT               TimeoutEvent,
 733   IN UINTN                   *HeaderSize   OPTIONAL,
 734   IN VOID                    *HeaderPtr    OPTIONAL,
 735   IN UINTN                   *BufferSize,
 736   IN VOID                    *BufferPtr
 737   )
 738 {
 739   EFI_UDP6_COMPLETION_TOKEN Token;
 740   EFI_UDP6_TRANSMIT_DATA    *TxData;
 741   UINT32                    TxLength;
 742   UINT32                    FragCount;
 743   UINT32                    DataLength;
 744   BOOLEAN                   IsDone;
 745   EFI_STATUS                Status;
 746
 747   //
 748   // Arrange one fragment buffer for data, and another fragment buffer for header if has.
 749   //
 750   FragCount = (HeaderSize != NULL) ? 2 : 1;
 751   TxLength  = sizeof (EFI_UDP6_TRANSMIT_DATA) + (FragCount - 1) * sizeof (EFI_UDP6_FRAGMENT_DATA);
 752   TxData    = (EFI_UDP6_TRANSMIT_DATA *) AllocateZeroPool (TxLength);
 753   if (TxData == NULL) {
 754     return EFI_OUT_OF_RESOURCES;
 755   }
 756
 757   TxData->FragmentCount                               = FragCount;
 758   TxData->FragmentTable[FragCount - 1].FragmentLength = (UINT32) *BufferSize;
 759   TxData->FragmentTable[FragCount - 1].FragmentBuffer = BufferPtr;
 760   DataLength                                          = (UINT32) *BufferSize;
 761
 762   if (HeaderSize != NULL) {
 763     TxData->FragmentTable[0].FragmentLength = (UINT32) *HeaderSize;
 764     TxData->FragmentTable[0].FragmentBuffer = HeaderPtr;
 765     DataLength                             += (UINT32) *HeaderSize;
 766   }
 767
 768   TxData->UdpSessionData  = Session;
 769   TxData->DataLength      = DataLength;
 770   Token.Packet.TxData     = TxData;
 771   Token.Status            = EFI_NOT_READY;
 772   IsDone                  = FALSE;
 773
 774   Status = gBS->CreateEvent (
 775                   EVT_NOTIFY_SIGNAL,
 776                   TPL_NOTIFY,
 777                   PxeBcCommonNotify,
 778                   &IsDone,
 779                   &Token.Event
 780                   );
 781   if (EFI_ERROR (Status)) {
 782     goto ON_EXIT;
 783   }
 784
 785   Status = Udp6->Transmit (Udp6, &Token);
 786   if (EFI_ERROR (Status)) {
 787     goto ON_EXIT;
 788   }
 789
 790   //
 791   // Poll the UDPv6 read instance if no packet received and no timeout triggered.
 792   //
 793   while (!IsDone &&
 794          Token.Status == EFI_NOT_READY &&
 795          EFI_ERROR (gBS->CheckEvent (TimeoutEvent))) {
 796     Udp6->Poll (Udp6);
 797   }
 798
 799   Status = (Token.Status == EFI_NOT_READY) ? EFI_TIMEOUT : Token.Status;
 800
 801 ON_EXIT:
 802   if (Token.Event != NULL) {
 803     gBS->CloseEvent (Token.Event);
 804   }
 805   FreePool (TxData);
 806
 807   return Status;
 808 }
 809
 810
 811 /**
 812   Check the received packet using the Ip filter.
 813
 814   @param[in]  Mode                The pointer to the mode data of PxeBc.
 815   @param[in]  Session             The pointer to the current UDPv4 session.
 816   @param[in]  OpFlags             Operation flag for UdpRead/UdpWrite.
 817
 818   @retval     TRUE                Passed the Ip filter successfully.
 819   @retval     FALSE               Failed to pass the Ip filter.
 820
 821 **/
 822 BOOLEAN
 823 PxeBcCheckByIpFilter (
 824   IN EFI_PXE_BASE_CODE_MODE    *Mode,
 825   IN VOID                      *Session,
 826   IN UINT16                    OpFlags
 827   )
 828 {
 829   EFI_IP_ADDRESS               DestinationIp;
 830   UINTN                        Index;
 831
 832   if ((OpFlags & EFI_PXE_BASE_CODE_UDP_OPFLAGS_USE_FILTER) == 0) {
 833     return TRUE;
 834   }
 835
 836   if ((Mode->IpFilter.Filters & EFI_PXE_BASE_CODE_IP_FILTER_PROMISCUOUS) != 0) {
 837     return TRUE;
 838   }
 839
 840   //
 841   // Convert the destination address in session data to host order.
 842   //
 843   if (Mode->UsingIpv6) {
 844     CopyMem (
 845       &DestinationIp,
 846       &((EFI_UDP6_SESSION_DATA *) Session)->DestinationAddress,
 847       sizeof (EFI_IPv6_ADDRESS)
 848       );
 849     NTOHLLL (&DestinationIp.v6);
 850   } else {
 851     ZeroMem (&DestinationIp, sizeof (EFI_IP_ADDRESS));
 852     CopyMem (
 853       &DestinationIp,
 854       &((EFI_UDP4_SESSION_DATA *) Session)->DestinationAddress,
 855       sizeof (EFI_IPv4_ADDRESS)
 856       );
 857     EFI_NTOHL (DestinationIp);
 858   }
 859
 860   if ((Mode->IpFilter.Filters & EFI_PXE_BASE_CODE_IP_FILTER_PROMISCUOUS_MULTICAST) != 0 &&
 861       (IP4_IS_MULTICAST (DestinationIp.Addr[0]) ||
 862        IP6_IS_MULTICAST (&DestinationIp))) {
 863     return TRUE;
 864   }
 865
 866   if ((Mode->IpFilter.Filters & EFI_PXE_BASE_CODE_IP_FILTER_BROADCAST) != 0 &&
 867       IP4_IS_LOCAL_BROADCAST (DestinationIp.Addr[0])) {
 868     ASSERT (!Mode->UsingIpv6);
 869     return TRUE;
 870   }
 871
 872   if ((Mode->IpFilter.Filters & EFI_PXE_BASE_CODE_IP_FILTER_STATION_IP) != 0 &&
 873       (EFI_IP4_EQUAL (&Mode->StationIp.v4, &DestinationIp) ||
 874        EFI_IP6_EQUAL (&Mode->StationIp.v6, &DestinationIp))) {
 875     //
 876     // Matched if the dest address is equal to the station address.
 877     //
 878     return TRUE;
 879   }
 880
 881   for (Index = 0; Index < Mode->IpFilter.IpCnt; Index++) {
 882     ASSERT (Index < EFI_PXE_BASE_CODE_MAX_IPCNT);
 883     if (EFI_IP4_EQUAL (&Mode->IpFilter.IpList[Index].v4, &DestinationIp) ||
 884         EFI_IP6_EQUAL (&Mode->IpFilter.IpList[Index].v6, &DestinationIp)) {
 885       //
 886       // Matched if the dest address is equal to any of address in the filter list.
 887       //
 888       return TRUE;
 889     }
 890   }
 891
 892   return FALSE;
 893 }
 894
 895
 896 /**
 897   Filter the received packet using the destination Ip.
 898
 899   @param[in]       Mode           The pointer to the mode data of PxeBc.
 900   @param[in]       Session        The pointer to the current UDPv4 session.
 901   @param[in, out]  DestIp         The pointer to the destination Ip address.
 902   @param[in]       OpFlags        Operation flag for UdpRead/UdpWrite.
 903
 904   @retval     TRUE                Passed the IPv4 filter successfully.
 905   @retval     FALSE               Failed to pass the IPv4 filter.
 906
 907 **/
 908 BOOLEAN
 909 PxeBcCheckByDestIp (
 910   IN     EFI_PXE_BASE_CODE_MODE    *Mode,
 911   IN     VOID                      *Session,
 912   IN OUT EFI_IP_ADDRESS            *DestIp,
 913   IN     UINT16                    OpFlags
 914   )
 915 {
 916   if ((OpFlags & EFI_PXE_BASE_CODE_UDP_OPFLAGS_ANY_DEST_IP) != 0) {
 917     //
 918     // Copy the destination address from the received packet if accept any.
 919     //
 920     if (DestIp != NULL) {
 921       if (Mode->UsingIpv6) {
 922         CopyMem (
 923           DestIp,
 924           &((EFI_UDP6_SESSION_DATA *)Session)->DestinationAddress,
 925           sizeof (EFI_IPv6_ADDRESS)
 926           );
 927       } else {
 928         ZeroMem (DestIp, sizeof (EFI_IP_ADDRESS));
 929         CopyMem (
 930           DestIp,
 931           &((EFI_UDP4_SESSION_DATA *)Session)->DestinationAddress,
 932           sizeof (EFI_IPv4_ADDRESS)
 933           );
 934       }
 935
 936     }
 937     return TRUE;
 938   } else if (DestIp != NULL &&
 939              (EFI_IP4_EQUAL (DestIp, &((EFI_UDP4_SESSION_DATA *)Session)->DestinationAddress) ||
 940               EFI_IP6_EQUAL (DestIp, &((EFI_UDP6_SESSION_DATA *)Session)->DestinationAddress))) {
 941     //
 942     // The destination address in the received packet is matched if present.
 943     //
 944     return TRUE;
 945   } else if (EFI_IP4_EQUAL (&Mode->StationIp, &((EFI_UDP4_SESSION_DATA *)Session)->DestinationAddress) ||
 946              EFI_IP6_EQUAL (&Mode->StationIp, &((EFI_UDP6_SESSION_DATA *)Session)->DestinationAddress)) {
 947     //
 948     // The destination address in the received packet is equal to the host address.
 949     //
 950     return TRUE;
 951   }
 952
 953   return FALSE;
 954 }
 955
 956
 957 /**
 958   Check the received packet using the destination port.
 959
 960   @param[in]       Mode           The pointer to the mode data of PxeBc.
 961   @param[in]       Session        The pointer to the current UDPv4 session.
 962   @param[in, out]  DestPort       The pointer to the destination port.
 963   @param[in]       OpFlags        Operation flag for UdpRead/UdpWrite.
 964
 965   @retval     TRUE                Passed the IPv4 filter successfully.
 966   @retval     FALSE               Failed to pass the IPv4 filter.
 967
 968 **/
 969 BOOLEAN
 970 PxeBcCheckByDestPort (
 971   IN     EFI_PXE_BASE_CODE_MODE    *Mode,
 972   IN     VOID                      *Session,
 973   IN OUT UINT16                    *DestPort,
 974   IN     UINT16                    OpFlags
 975   )
 976 {
 977   UINT16       Port;
 978
 979   if (Mode->UsingIpv6) {
 980     Port = ((EFI_UDP6_SESSION_DATA *) Session)->DestinationPort;
 981   } else {
 982     Port = ((EFI_UDP4_SESSION_DATA *) Session)->DestinationPort;
 983   }
 984
 985   if ((OpFlags & EFI_PXE_BASE_CODE_UDP_OPFLAGS_ANY_DEST_PORT) != 0) {
 986     //
 987     // Return the destination port in the received packet if accept any.
 988     //
 989     if (DestPort != NULL) {
 990       *DestPort = Port;
 991     }
 992     return TRUE;
 993   } else if (DestPort != NULL && *DestPort == Port) {
 994     //
 995     // The destination port in the received packet is matched if present.
 996     //
 997     return TRUE;
 998   }
 999
1000   return FALSE;
1001 }
1002
1003
1004 /**
1005   Filter the received packet using the source Ip.
1006
1007   @param[in]       Mode           The pointer to the mode data of PxeBc.
1008   @param[in]       Session        The pointer to the current UDPv4 session.
1009   @param[in, out]  SrcIp          The pointer to the source Ip address.
1010   @param[in]       OpFlags        Operation flag for UdpRead/UdpWrite.
1011
1012   @retval     TRUE                Passed the IPv4 filter successfully.
1013   @retval     FALSE               Failed to pass the IPv4 filter.
1014
1015 **/
1016 BOOLEAN
1017 PxeBcFilterBySrcIp (
1018   IN     EFI_PXE_BASE_CODE_MODE    *Mode,
1019   IN     VOID                      *Session,
1020   IN OUT EFI_IP_ADDRESS            *SrcIp,
1021   IN     UINT16                    OpFlags
1022   )
1023 {
1024   if ((OpFlags & EFI_PXE_BASE_CODE_UDP_OPFLAGS_ANY_SRC_IP) != 0) {
1025     //
1026     // Copy the source address from the received packet if accept any.
1027     //
1028     if (SrcIp != NULL) {
1029       if (Mode->UsingIpv6) {
1030         CopyMem (
1031           SrcIp,
1032           &((EFI_UDP6_SESSION_DATA *)Session)->SourceAddress,
1033           sizeof (EFI_IPv6_ADDRESS)
1034           );
1035       } else {
1036         ZeroMem (SrcIp, sizeof (EFI_IP_ADDRESS));
1037         CopyMem (
1038           SrcIp,
1039           &((EFI_UDP4_SESSION_DATA *)Session)->SourceAddress,
1040           sizeof (EFI_IPv4_ADDRESS)
1041           );
1042       }
1043
1044     }
1045     return TRUE;
1046   } else if (SrcIp != NULL &&
1047              (EFI_IP4_EQUAL (SrcIp, &((EFI_UDP4_SESSION_DATA *)Session)->SourceAddress) ||
1048               EFI_IP6_EQUAL (SrcIp, &((EFI_UDP6_SESSION_DATA *)Session)->SourceAddress))) {
1049     //
1050     // The source address in the received packet is matched if present.
1051     //
1052     return TRUE;
1053   }
1054
1055   return FALSE;
1056 }
1057
1058
1059 /**
1060   Filter the received packet using the source port.
1061
1062   @param[in]       Mode           The pointer to the mode data of PxeBc.
1063   @param[in]       Session        The pointer to the current UDPv4 session.
1064   @param[in, out]  SrcPort        The pointer to the source port.
1065   @param[in]       OpFlags        Operation flag for UdpRead/UdpWrite.
1066
1067   @retval     TRUE                Passed the IPv4 filter successfully.
1068   @retval     FALSE               Failed to pass the IPv4 filter.
1069
1070 **/
1071 BOOLEAN
1072 PxeBcFilterBySrcPort (
1073   IN     EFI_PXE_BASE_CODE_MODE    *Mode,
1074   IN     VOID                      *Session,
1075   IN OUT UINT16                    *SrcPort,
1076   IN     UINT16                    OpFlags
1077   )
1078 {
1079   UINT16       Port;
1080
1081   if (Mode->UsingIpv6) {
1082     Port = ((EFI_UDP6_SESSION_DATA *) Session)->SourcePort;
1083   } else {
1084     Port = ((EFI_UDP4_SESSION_DATA *) Session)->SourcePort;
1085   }
1086
1087   if ((OpFlags & EFI_PXE_BASE_CODE_UDP_OPFLAGS_ANY_SRC_PORT) != 0) {
1088     //
1089     // Return the source port in the received packet if accept any.
1090     //
1091     if (SrcPort != NULL) {
1092       *SrcPort = Port;
1093     }
1094     return TRUE;
1095   } else if (SrcPort != NULL && *SrcPort == Port) {
1096     //
1097     // The source port in the received packet is matched if present.
1098     //
1099     return TRUE;
1100   }
1101
1102   return FALSE;
1103 }
1104
1105
1106 /**
1107   This function is to receive packet using Udp4Read.
1108
1109   @param[in]       Udp4                 The pointer to EFI_UDP4_PROTOCOL.
1110   @param[in]       Token                The pointer to EFI_UDP4_COMPLETION_TOKEN.
1111   @param[in]       Mode                 The pointer to EFI_PXE_BASE_CODE_MODE.
1112   @param[in]       TimeoutEvent         The event for timeout.
1113   @param[in]       OpFlags              The UDP operation flags.
1114   @param[in]       IsDone               The pointer to the IsDone flag.
1115   @param[out]      IsMatched            The pointer to the IsMatched flag.
1116   @param[in, out]  DestIp               The pointer to the destination address.
1117   @param[in, out]  DestPort             The pointer to the destination port.
1118   @param[in, out]  SrcIp                The pointer to the source address.
1119   @param[in, out]  SrcPort              The pointer to the source port.
1120
1121   @retval          EFI_SUCCESS          Successfully read the data using Udp4.
1122   @retval          Others               Failed to send out data.
1123
1124 **/
1125 EFI_STATUS
1126 PxeBcUdp4Read (
1127   IN     EFI_UDP4_PROTOCOL            *Udp4,
1128   IN     EFI_UDP4_COMPLETION_TOKEN    *Token,
1129   IN     EFI_PXE_BASE_CODE_MODE       *Mode,
1130   IN     EFI_EVENT                    TimeoutEvent,
1131   IN     UINT16                       OpFlags,
1132   IN     BOOLEAN                      *IsDone,
1133      OUT BOOLEAN                      *IsMatched,
1134   IN OUT EFI_IP_ADDRESS               *DestIp      OPTIONAL,
1135   IN OUT EFI_PXE_BASE_CODE_UDP_PORT   *DestPort    OPTIONAL,
1136   IN OUT EFI_IP_ADDRESS               *SrcIp       OPTIONAL,
1137   IN OUT EFI_PXE_BASE_CODE_UDP_PORT   *SrcPort     OPTIONAL
1138   )
1139 {
1140   EFI_UDP4_RECEIVE_DATA     *RxData;
1141   EFI_UDP4_SESSION_DATA     *Session;
1142   EFI_STATUS                Status;
1143
1144   Token->Status = EFI_NOT_READY;
1145   *IsDone       = FALSE;
1146
1147   Status = Udp4->Receive (Udp4, Token);
1148   if (EFI_ERROR (Status)) {
1149     return Status;
1150   }
1151
1152   //
1153   // Poll the UDPv6 read instance if no packet received and no timeout triggered.
1154   //
1155   while (!(*IsDone) &&
1156          Token->Status == EFI_NOT_READY &&
1157          EFI_ERROR (gBS->CheckEvent (TimeoutEvent))) {
1158     //
1159     // Poll the token utill reply/ICMPv6 error message received or timeout.
1160     //
1161     Udp4->Poll (Udp4);
1162     if (Token->Status == EFI_ICMP_ERROR ||
1163         Token->Status == EFI_NETWORK_UNREACHABLE ||
1164         Token->Status == EFI_HOST_UNREACHABLE ||
1165         Token->Status == EFI_PROTOCOL_UNREACHABLE ||
1166         Token->Status == EFI_PORT_UNREACHABLE) {
1167       break;
1168     }
1169   }
1170
1171   Status = (Token->Status == EFI_NOT_READY) ? EFI_TIMEOUT : Token->Status;
1172
1173   if (!EFI_ERROR (Status)) {
1174     //
1175     // check whether this packet matches the filters
1176     //
1177     RxData    = Token->Packet.RxData;
1178     Session   = &RxData->UdpSession;
1179
1180     *IsMatched = PxeBcCheckByIpFilter (Mode, Session, OpFlags);
1181
1182     if (*IsMatched) {
1183       *IsMatched = PxeBcCheckByDestIp (Mode, Session, DestIp, OpFlags);
1184     }
1185
1186     if (*IsMatched) {
1187       *IsMatched = PxeBcCheckByDestPort (Mode, Session, DestPort, OpFlags);
1188     }
1189
1190     if (*IsMatched) {
1191       *IsMatched = PxeBcFilterBySrcIp (Mode, Session, SrcIp, OpFlags);
1192     }
1193
1194     if (*IsMatched) {
1195       *IsMatched = PxeBcFilterBySrcPort (Mode, Session, SrcPort, OpFlags);
1196     }
1197
1198     if (!(*IsMatched)) {
1199       //
1200       // Recycle the receiving buffer if not matched.
1201       //
1202       gBS->SignalEvent (RxData->RecycleSignal);
1203     }
1204   }
1205
1206   return Status;
1207 }
1208
1209
1210 /**
1211   This function is to receive packets using Udp6Read.
1212
1213   @param[in]       Udp6                 The pointer to EFI_UDP6_PROTOCOL.
1214   @param[in]       Token                The pointer to EFI_UDP6_COMPLETION_TOKEN.
1215   @param[in]       Mode                 The pointer to EFI_PXE_BASE_CODE_MODE.
1216   @param[in]       TimeoutEvent         The event for timeout.
1217   @param[in]       OpFlags              The UDP operation flags.
1218   @param[in]       IsDone               The pointer to the IsDone flag.
1219   @param[out]      IsMatched            The pointer to the IsMatched flag.
1220   @param[in, out]  DestIp               The pointer to the destination address.
1221   @param[in, out]  DestPort             The pointer to the destination port.
1222   @param[in, out]  SrcIp                The pointer to the source address.
1223   @param[in, out]  SrcPort              The pointer to the source port.
1224
1225   @retval          EFI_SUCCESS          Successfully read data using Udp6.
1226   @retval          Others               Failed to send out data.
1227
1228 **/
1229 EFI_STATUS
1230 PxeBcUdp6Read (
1231   IN     EFI_UDP6_PROTOCOL            *Udp6,
1232   IN     EFI_UDP6_COMPLETION_TOKEN    *Token,
1233   IN     EFI_PXE_BASE_CODE_MODE       *Mode,
1234   IN     EFI_EVENT                    TimeoutEvent,
1235   IN     UINT16                       OpFlags,
1236   IN     BOOLEAN                      *IsDone,
1237      OUT BOOLEAN                      *IsMatched,
1238   IN OUT EFI_IP_ADDRESS               *DestIp      OPTIONAL,
1239   IN OUT EFI_PXE_BASE_CODE_UDP_PORT   *DestPort    OPTIONAL,
1240   IN OUT EFI_IP_ADDRESS               *SrcIp       OPTIONAL,
1241   IN OUT EFI_PXE_BASE_CODE_UDP_PORT   *SrcPort     OPTIONAL
1242   )
1243 {
1244   EFI_UDP6_RECEIVE_DATA     *RxData;
1245   EFI_UDP6_SESSION_DATA     *Session;
1246   EFI_STATUS                Status;
1247
1248   Token->Status = EFI_NOT_READY;
1249   *IsDone       = FALSE;
1250
1251   Status = Udp6->Receive (Udp6, Token);
1252   if (EFI_ERROR (Status)) {
1253     return Status;
1254   }
1255
1256   //
1257   // Poll the UDPv6 read instance if no packet received and no timeout triggered.
1258   //
1259   while (!(*IsDone) &&
1260          Token->Status == EFI_NOT_READY &&
1261          EFI_ERROR (gBS->CheckEvent (TimeoutEvent))) {
1262     //
1263     // Poll the token utill reply/ICMPv6 error message received or timeout.
1264     //
1265     Udp6->Poll (Udp6);
1266     if (Token->Status == EFI_ICMP_ERROR ||
1267         Token->Status == EFI_NETWORK_UNREACHABLE ||
1268         Token->Status == EFI_HOST_UNREACHABLE ||
1269         Token->Status == EFI_PROTOCOL_UNREACHABLE ||
1270         Token->Status == EFI_PORT_UNREACHABLE) {
1271       break;
1272     }
1273   }
1274
1275   Status = (Token->Status == EFI_NOT_READY) ? EFI_TIMEOUT : Token->Status;
1276
1277   if (!EFI_ERROR (Status)) {
1278     //
1279     // check whether this packet matches the filters
1280     //
1281     RxData    = Token->Packet.RxData;
1282     Session   = &RxData->UdpSession;
1283
1284     *IsMatched = PxeBcCheckByIpFilter (Mode, Session, OpFlags);
1285
1286     if (*IsMatched) {
1287       *IsMatched = PxeBcCheckByDestIp (Mode, Session, DestIp, OpFlags);
1288     }
1289
1290     if (*IsMatched) {
1291       *IsMatched = PxeBcCheckByDestPort (Mode, Session, DestPort, OpFlags);
1292     }
1293
1294     if (*IsMatched) {
1295       *IsMatched = PxeBcFilterBySrcIp (Mode, Session, SrcIp, OpFlags);
1296     }
1297
1298     if (*IsMatched) {
1299       *IsMatched = PxeBcFilterBySrcPort (Mode, Session, SrcPort, OpFlags);
1300     }
1301
1302     if (!(*IsMatched)) {
1303       //
1304       // Recycle the receiving buffer if not matched.
1305       //
1306       gBS->SignalEvent (RxData->RecycleSignal);
1307     }
1308   }
1309
1310   return Status;
1311 }
1312
1313
1314 /**
1315   This function is to display the IPv4 address.
1316
1317   @param[in]  Ip        The pointer to the IPv4 address.
1318
1319 **/
1320 VOID
1321 PxeBcShowIp4Addr (
1322   IN EFI_IPv4_ADDRESS   *Ip
1323   )
1324 {
1325   UINTN                 Index;
1326
1327   for (Index = 0; Index < 4; Index++) {
1328     AsciiPrint ("%d", Ip->Addr[Index]);
1329     if (Index < 3) {
1330       AsciiPrint (".");
1331     }
1332   }
1333 }
1334
1335
1336 /**
1337   This function is to display the IPv6 address.
1338
1339   @param[in]  Ip        The pointer to the IPv6 address.
1340
1341 **/
1342 VOID
1343 PxeBcShowIp6Addr (
1344   IN EFI_IPv6_ADDRESS   *Ip
1345   )
1346 {
1347   UINTN                 Index;
1348
1349   for (Index = 0; Index < 16; Index++) {
1350
1351     if (Ip->Addr[Index] != 0) {
1352       AsciiPrint ("%x", Ip->Addr[Index]);
1353     }
1354     Index++;
1355     if (Index > 15) {
1356       return;
1357     }
1358     if (((Ip->Addr[Index] & 0xf0) == 0) && (Ip->Addr[Index - 1] != 0)) {
1359       AsciiPrint ("0");
1360     }
1361     AsciiPrint ("%x", Ip->Addr[Index]);
1362     if (Index < 15) {
1363       AsciiPrint (":");
1364     }
1365   }
1366 }
1367
1368
1369 /**
1370   This function is to convert UINTN to ASCII string with the required formatting.
1371
1372   @param[in]  Number         Numeric value to be converted.
1373   @param[in]  Buffer         The pointer to the buffer for ASCII string.
1374   @param[in]  Length         The length of the required format.
1375
1376 **/
1377 VOID
1378 PxeBcUintnToAscDecWithFormat (
1379   IN UINTN                       Number,
1380   IN UINT8                       *Buffer,
1381   IN INTN                        Length
1382   )
1383 {
1384   UINTN                          Remainder;
1385
1386   for (; Length > 0; Length--) {
1387     Remainder      = Number % 10;
1388     Number        /= 10;
1389     Buffer[Length - 1] = (UINT8) ('0' + Remainder);
1390   }
1391 }
1392
1393
1394 /**
1395   This function is to convert a UINTN to a ASCII string, and return the
1396   actual length of the buffer.
1397
1398   @param[in]  Number         Numeric value to be converted.
1399   @param[in]  Buffer         The pointer to the buffer for ASCII string.
1400   @param[in]  BufferSize     The maxsize of the buffer.
1401
1402   @return     Length         The actual length of the ASCII string.
1403
1404 **/
1405 UINTN
1406 PxeBcUintnToAscDec (
1407   IN UINTN               Number,
1408   IN UINT8               *Buffer,
1409   IN UINTN               BufferSize
1410   )
1411 {
1412   UINTN           Index;
1413   UINTN           Length;
1414   CHAR8           TempStr[64];
1415
1416   Index           = 63;
1417   TempStr[Index]  = 0;
1418
1419   do {
1420     Index--;
1421     TempStr[Index] = (CHAR8) ('0' + (Number % 10));
1422     Number         = (UINTN) (Number / 10);
1423   } while (Number != 0);
1424
1425   AsciiStrCpyS ((CHAR8 *) Buffer, BufferSize, &TempStr[Index]);
1426
1427   Length = AsciiStrLen ((CHAR8 *) Buffer);
1428
1429   return Length;
1430 }
1431
1432
1433 /**
1434   This function is to convert unicode hex number to a UINT8.
1435
1436   @param[out]  Digit                   The converted UINT8 for output.
1437   @param[in]   Char                    The unicode hex number to be converted.
1438
1439   @retval      EFI_SUCCESS             Successfully converted the unicode hex.
1440   @retval      EFI_INVALID_PARAMETER   Failed to convert the unicode hex.
1441
1442 **/
1443 EFI_STATUS
1444 PxeBcUniHexToUint8 (
1445   OUT UINT8                *Digit,
1446   IN  CHAR16               Char
1447   )
1448 {
1449   if ((Char >= L'0') && (Char <= L'9')) {
1450     *Digit = (UINT8) (Char - L'0');
1451     return EFI_SUCCESS;
1452   }
1453
1454   if ((Char >= L'A') && (Char <= L'F')) {
1455     *Digit = (UINT8) (Char - L'A' + 0x0A);
1456     return EFI_SUCCESS;
1457   }
1458
1459   if ((Char >= L'a') && (Char <= L'f')) {
1460     *Digit = (UINT8) (Char - L'a' + 0x0A);
1461     return EFI_SUCCESS;
1462   }
1463
1464   return EFI_INVALID_PARAMETER;
1465 }
1466
1467 /**
1468   Calculate the elapsed time.
1469
1470   @param[in]      Private      The pointer to PXE private data
1471
1472 **/
1473 VOID
1474 CalcElapsedTime (
1475   IN     PXEBC_PRIVATE_DATA     *Private
1476   )
1477 {
1478   EFI_TIME          Time;
1479   UINT64            CurrentStamp;
1480   UINT64            ElapsedTimeValue;
1481
1482   //
1483   // Generate a time stamp of the centiseconds from 1900/1/1, assume 30day/month.
1484   //
1485   ZeroMem (&Time, sizeof (EFI_TIME));
1486   gRT->GetTime (&Time, NULL);
1487   CurrentStamp = (UINT64)
1488     (
1489       ((((((Time.Year - 1900) * 360 +
1490        (Time.Month - 1)) * 30 +
1491        (Time.Day - 1)) * 24 + Time.Hour) * 60 +
1492        Time.Minute) * 60 + Time.Second) * 100
1493        + DivU64x32(Time.Nanosecond, 10000000)
1494     );
1495
1496   //
1497   // Sentinel value of 0 means that this is the first DHCP packet that we are
1498   // sending and that we need to initialize the value.  First DHCP Solicit
1499   // gets 0 elapsed-time.  Otherwise, calculate based on StartTime.
1500   //
1501   if (Private->ElapsedTime == 0) {
1502     Private->ElapsedTime = CurrentStamp;
1503   } else {
1504     ElapsedTimeValue = CurrentStamp - Private->ElapsedTime;
1505
1506     //
1507     // If elapsed time cannot fit in two bytes, set it to 0xffff.
1508     //
1509     if (ElapsedTimeValue > 0xffff) {
1510       ElapsedTimeValue = 0xffff;
1511     }
1512     //
1513     // Save the elapsed time
1514     //
1515     Private->ElapsedTime = ElapsedTimeValue;
1516   }
1517 }
1518