ShellPkg/Library/UefiShellNetwork1CommandsLib/Ping.c

   1 /** @file
   2   The implementation for Ping shell command.
   3
   4   (C) Copyright 2015 Hewlett-Packard Development Company, L.P.<BR>
   5   Copyright (c) 2009 - 2015, Intel Corporation. All rights reserved.<BR>
   6
   7   This program and the accompanying materials
   8   are licensed and made available under the terms and conditions of the BSD License
   9   which accompanies this distribution.  The full text of the license may be found at
  10   http://opensource.org/licenses/bsd-license.php.
  11
  12   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  13   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  14
  15 **/
  16
  17 #include "UefiShellNetwork1CommandsLib.h"
  18
  19 #define PING_IP4_COPY_ADDRESS(Dest, Src) (CopyMem ((Dest), (Src), sizeof (EFI_IPv4_ADDRESS)))
  20
  21 UINT64          CurrentTick = 0;
  22
  23 //
  24 // Function templates to match the IPv4 and IPv6 commands that we use.
  25 //
  26 typedef
  27 EFI_STATUS
  28 (EFIAPI *PING_IPX_POLL)(
  29   IN VOID          *This
  30   );
  31
  32 typedef
  33 EFI_STATUS
  34 (EFIAPI *PING_IPX_TRANSMIT)(
  35   IN VOID          *This,
  36   IN VOID          *Token
  37   );
  38
  39 typedef
  40 EFI_STATUS
  41 (EFIAPI *PING_IPX_RECEIVE)(
  42   IN VOID          *This,
  43   IN VOID          *Token
  44   );
  45
  46 typedef
  47 EFI_STATUS
  48 (EFIAPI *PING_IPX_CANCEL)(
  49   IN VOID          *This,
  50   IN VOID          *Token OPTIONAL
  51   );
  52
  53 ///
  54 /// A set of pointers to either IPv6 or IPv4 functions.
  55 /// Unknown which one to the ping command.
  56 ///
  57 typedef struct {
  58   PING_IPX_TRANSMIT             Transmit;
  59   PING_IPX_RECEIVE              Receive;
  60   PING_IPX_CANCEL               Cancel;
  61   PING_IPX_POLL                 Poll;
  62 }PING_IPX_PROTOCOL;
  63
  64
  65 typedef union {
  66   VOID                  *RxData;
  67   VOID                  *TxData;
  68 } PING_PACKET;
  69
  70 //
  71 // PING_IPX_COMPLETION_TOKEN
  72 // structures are used for both transmit and receive operations.
  73 // This version is IP-unaware.
  74 //
  75 typedef struct {
  76   EFI_EVENT               Event;
  77   EFI_STATUS              Status;
  78   PING_PACKET             Packet;
  79 } PING_IPX_COMPLETION_TOKEN;
  80
  81 #pragma pack(1)
  82 typedef struct _ICMPX_ECHO_REQUEST_REPLY {
  83   UINT8                       Type;
  84   UINT8                       Code;
  85   UINT16                      Checksum;
  86   UINT16                      Identifier;
  87   UINT16                      SequenceNum;
  88   UINT64                      TimeStamp;
  89   UINT8                       Data[1];
  90 } ICMPX_ECHO_REQUEST_REPLY;
  91 #pragma pack()
  92
  93 typedef struct _PING_ICMP_TX_INFO {
  94   LIST_ENTRY                Link;
  95   UINT16                    SequenceNum;
  96   UINT64                    TimeStamp;
  97   PING_IPX_COMPLETION_TOKEN *Token;
  98 } PING_ICMPX_TX_INFO;
  99
 100 #define DEFAULT_TIMEOUT       5000
 101 #define MAX_SEND_NUMBER       10000
 102 #define MAX_BUFFER_SIZE       32768
 103 #define DEFAULT_TIMER_PERIOD  358049
 104 #define ONE_SECOND            10000000
 105 #define PING_IP_CHOICE_IP4    1
 106 #define PING_IP_CHOICE_IP6    2
 107 #define DEFAULT_SEND_COUNT    10
 108 #define DEFAULT_BUFFER_SIZE   16
 109 #define ICMP_V4_ECHO_REQUEST  0x8
 110 #define ICMP_V4_ECHO_REPLY    0x0
 111
 112 #define PING_PRIVATE_DATA_SIGNATURE  SIGNATURE_32 ('P', 'i', 'n', 'g')
 113 typedef struct _PING_PRIVATE_DATA {
 114   UINT32                      Signature;
 115   EFI_HANDLE                  NicHandle;
 116   EFI_HANDLE                  IpChildHandle;
 117   EFI_EVENT                   Timer;
 118
 119   EFI_STATUS                  Status;
 120   LIST_ENTRY                  TxList;
 121   UINT16                      RxCount;
 122   UINT16                      TxCount;
 123   UINT64                      RttSum;
 124   UINT64                      RttMin;
 125   UINT64                      RttMax;
 126   UINT32                      SequenceNum;
 127
 128   UINT32                      SendNum;
 129   UINT32                      BufferSize;
 130   UINT32                      IpChoice;
 131
 132   PING_IPX_PROTOCOL           ProtocolPointers;
 133   VOID                        *IpProtocol;
 134   UINT8                       SrcAddress[MAX(sizeof(EFI_IPv6_ADDRESS)        , sizeof(EFI_IPv4_ADDRESS)          )];
 135   UINT8                       DstAddress[MAX(sizeof(EFI_IPv6_ADDRESS)        , sizeof(EFI_IPv4_ADDRESS)          )];
 136   PING_IPX_COMPLETION_TOKEN   RxToken;
 137 } PING_PRIVATE_DATA;
 138
 139 /**
 140   Calculate the internet checksum (see RFC 1071).
 141
 142   @param[in] Packet  Buffer which contains the data to be checksummed.
 143   @param[in] Length  Length to be checksummed.
 144
 145   @retval Checksum     Returns the 16 bit ones complement of
 146                        ones complement sum of 16 bit words
 147 **/
 148 UINT16
 149 EFIAPI
 150 NetChecksum (
 151   IN UINT8   *Buffer,
 152   IN UINT32  Length
 153   )
 154 {
 155   UINT32  Sum;
 156   UINT8   Odd;
 157   UINT16  *Packet;
 158
 159   Packet  = (UINT16 *) Buffer;
 160
 161   Sum     = 0;
 162   Odd     = (UINT8) (Length & 1);
 163   Length >>= 1;
 164   while ((Length--) != 0) {
 165     Sum += *Packet++;
 166   }
 167
 168   if (Odd != 0) {
 169     Sum += *(UINT8 *) Packet;
 170   }
 171
 172   Sum = (Sum & 0xffff) + (Sum >> 16);
 173
 174   //
 175   // in case above carried
 176   //
 177   Sum += Sum >> 16;
 178
 179   return (UINT16) Sum;
 180 }
 181
 182 /**
 183   Reads and returns the current value of register.
 184   In IA64, the register is the Interval Timer Vector (ITV).
 185   In X86(IA32/X64), the register is the Time Stamp Counter (TSC)
 186
 187   @return The current value of the register.
 188
 189 **/
 190
 191 STATIC CONST SHELL_PARAM_ITEM    PingParamList[] = {
 192   {
 193     L"-l",
 194     TypeValue
 195   },
 196   {
 197     L"-n",
 198     TypeValue
 199   },
 200   {
 201     L"-_s",
 202     TypeValue
 203   },
 204   {
 205     L"-_ip6",
 206     TypeFlag
 207   },
 208   {
 209     NULL,
 210     TypeMax
 211   },
 212 };
 213
 214 //
 215 // Global Variables in Ping command.
 216 //
 217 STATIC CONST CHAR16      *mDstString;
 218 STATIC CONST CHAR16      *mSrcString;
 219 STATIC UINT64            mFrequency = 0;
 220 EFI_CPU_ARCH_PROTOCOL    *gCpu = NULL;
 221
 222 /**
 223   Read the current time.
 224
 225   @retval the current tick value.
 226 **/
 227 UINT64
 228 EFIAPI
 229 ReadTime (
 230   VOID
 231   )
 232 {
 233   UINT64                 TimerPeriod;
 234   EFI_STATUS             Status;
 235
 236   ASSERT (gCpu != NULL);
 237
 238   Status = gCpu->GetTimerValue (gCpu, 0, &CurrentTick, &TimerPeriod);
 239   if (EFI_ERROR (Status)) {
 240     //
 241     // The WinntGetTimerValue will return EFI_UNSUPPORTED. Set the
 242     // TimerPeriod by ourselves.
 243     //
 244     CurrentTick += 1000000;
 245   }
 246
 247   return CurrentTick;
 248 }
 249
 250
 251 /**
 252   Get and calculate the frequency in ticks/ms.
 253   The result is saved in the global variable mFrequency
 254
 255   @retval EFI_SUCCESS    Calculated the frequency successfully.
 256   @retval Others         Failed to calculate the frequency.
 257
 258 **/
 259 EFI_STATUS
 260 EFIAPI
 261 GetFrequency (
 262   VOID
 263   )
 264 {
 265   EFI_STATUS               Status;
 266   UINT64                   CurrentTick;
 267   UINT64                   TimerPeriod;
 268
 269   Status = gBS->LocateProtocol (&gEfiCpuArchProtocolGuid, NULL, (VOID **) &gCpu);
 270   if (EFI_ERROR (Status)) {
 271     return Status;
 272   }
 273
 274   Status = gCpu->GetTimerValue (gCpu, 0, &CurrentTick, &TimerPeriod);
 275
 276   if (EFI_ERROR (Status)) {
 277     TimerPeriod = DEFAULT_TIMER_PERIOD;
 278   }
 279
 280   //
 281   // The timer period is in femtosecond (1 femtosecond is 1e-15 second).
 282   // So 1e+12 is divided by timer period to produce the freq in ticks/ms.
 283   //
 284   mFrequency = DivU64x64Remainder (1000000000000ULL, TimerPeriod, NULL);
 285
 286   return EFI_SUCCESS;
 287 }
 288
 289 /**
 290   Calculate a duration in ms.
 291
 292   @param[in]  Begin     The start point of time.
 293   @param[in]  End       The end point of time.
 294
 295   @return               The duration in ms.
 296   @retval 0             The parameters were not valid.
 297 **/
 298 UINT64
 299 EFIAPI
 300 CalculateTick (
 301   IN UINT64    Begin,
 302   IN UINT64    End
 303   )
 304 {
 305   if (End <= Begin) {
 306     return (0);
 307   }
 308   return DivU64x64Remainder (End - Begin, mFrequency, NULL);
 309 }
 310
 311 /**
 312   Destroy PING_ICMPX_TX_INFO, and recollect the memory.
 313
 314   @param[in]    TxInfo    The pointer to PING_ICMPX_TX_INFO.
 315   @param[in]    IpChoice  Whether the token is IPv4 or IPv6
 316 **/
 317 VOID
 318 EFIAPI
 319 PingDestroyTxInfo (
 320   IN PING_ICMPX_TX_INFO    *TxInfo,
 321   IN UINT32                IpChoice
 322   )
 323 {
 324   EFI_IP6_TRANSMIT_DATA    *Ip6TxData;
 325   EFI_IP4_TRANSMIT_DATA    *Ip4TxData;
 326   EFI_IP6_FRAGMENT_DATA    *FragData;
 327   UINTN                    Index;
 328
 329   if (TxInfo == NULL) {
 330     return;
 331   }
 332
 333   if (TxInfo->Token != NULL) {
 334
 335     if (TxInfo->Token->Event != NULL) {
 336       gBS->CloseEvent (TxInfo->Token->Event);
 337     }
 338
 339     if (TxInfo->Token->Packet.TxData != NULL) {
 340       if (IpChoice == PING_IP_CHOICE_IP6) {
 341         Ip6TxData = TxInfo->Token->Packet.TxData;
 342
 343         if (Ip6TxData->OverrideData != NULL) {
 344           FreePool (Ip6TxData->OverrideData);
 345         }
 346
 347         if (Ip6TxData->ExtHdrs != NULL) {
 348           FreePool (Ip6TxData->ExtHdrs);
 349         }
 350
 351         for (Index = 0; Index < Ip6TxData->FragmentCount; Index++) {
 352           FragData = Ip6TxData->FragmentTable[Index].FragmentBuffer;
 353           if (FragData != NULL) {
 354             FreePool (FragData);
 355           }
 356         }
 357       } else {
 358         Ip4TxData = TxInfo->Token->Packet.TxData;
 359
 360         if (Ip4TxData->OverrideData != NULL) {
 361           FreePool (Ip4TxData->OverrideData);
 362         }
 363
 364         for (Index = 0; Index < Ip4TxData->FragmentCount; Index++) {
 365           FragData = Ip4TxData->FragmentTable[Index].FragmentBuffer;
 366           if (FragData != NULL) {
 367             FreePool (FragData);
 368           }
 369         }
 370       }
 371     }
 372
 373     FreePool (TxInfo->Token);
 374   }
 375
 376   FreePool (TxInfo);
 377 }
 378
 379 /**
 380   Match the request, and reply with SequenceNum/TimeStamp.
 381
 382   @param[in]    Private    The pointer to PING_PRIVATE_DATA.
 383   @param[in]    Packet     The pointer to ICMPX_ECHO_REQUEST_REPLY.
 384
 385   @retval EFI_SUCCESS      The match is successful.
 386   @retval EFI_NOT_FOUND    The reply can't be matched with any request.
 387
 388 **/
 389 EFI_STATUS
 390 EFIAPI
 391 Ping6MatchEchoReply (
 392   IN PING_PRIVATE_DATA           *Private,
 393   IN ICMPX_ECHO_REQUEST_REPLY    *Packet
 394   )
 395 {
 396   PING_ICMPX_TX_INFO     *TxInfo;
 397   LIST_ENTRY             *Entry;
 398   LIST_ENTRY             *NextEntry;
 399
 400   NET_LIST_FOR_EACH_SAFE (Entry, NextEntry, &Private->TxList) {
 401     TxInfo = BASE_CR (Entry, PING_ICMPX_TX_INFO, Link);
 402
 403     if ((TxInfo->SequenceNum == Packet->SequenceNum) && (TxInfo->TimeStamp == Packet->TimeStamp)) {
 404       Private->RxCount++;
 405       RemoveEntryList (&TxInfo->Link);
 406       PingDestroyTxInfo (TxInfo, Private->IpChoice);
 407       return EFI_SUCCESS;
 408     }
 409   }
 410
 411   return EFI_NOT_FOUND;
 412 }
 413
 414 /**
 415   The original intention is to send a request.
 416   Currently, the application retransmits an icmp6 echo request packet
 417   per second in sendnumber times that is specified by the user.
 418   Because nothing can be done here, all things move to the timer rountine.
 419
 420   @param[in]    Event      A EFI_EVENT type event.
 421   @param[in]    Context    The pointer to Context.
 422
 423 **/
 424 VOID
 425 EFIAPI
 426 Ping6OnEchoRequestSent (
 427   IN EFI_EVENT    Event,
 428   IN VOID         *Context
 429   )
 430 {
 431 }
 432
 433 /**
 434   receive reply, match and print reply infomation.
 435
 436   @param[in]    Event      A EFI_EVENT type event.
 437   @param[in]    Context    The pointer to context.
 438
 439 **/
 440 VOID
 441 EFIAPI
 442 Ping6OnEchoReplyReceived (
 443   IN EFI_EVENT    Event,
 444   IN VOID         *Context
 445   )
 446 {
 447   EFI_STATUS                  Status;
 448   PING_PRIVATE_DATA           *Private;
 449   ICMPX_ECHO_REQUEST_REPLY    *Reply;
 450   UINT32                      PayLoad;
 451   UINT64                      Rtt;
 452   CHAR8                       Near;
 453
 454   Private = (PING_PRIVATE_DATA *) Context;
 455
 456   if (Private == NULL || Private->Status == EFI_ABORTED || Private->Signature != PING_PRIVATE_DATA_SIGNATURE) {
 457     return;
 458   }
 459
 460   if (Private->RxToken.Packet.RxData == NULL) {
 461     return;
 462   }
 463
 464   if (Private->IpChoice == PING_IP_CHOICE_IP6) {
 465     Reply   = ((EFI_IP6_RECEIVE_DATA*)Private->RxToken.Packet.RxData)->FragmentTable[0].FragmentBuffer;
 466     PayLoad = ((EFI_IP6_RECEIVE_DATA*)Private->RxToken.Packet.RxData)->DataLength;
 467     if (((EFI_IP6_RECEIVE_DATA*)Private->RxToken.Packet.RxData)->Header->NextHeader != IP6_ICMP) {
 468       goto ON_EXIT;
 469     }
 470     if (!IP6_IS_MULTICAST ((EFI_IPv6_ADDRESS*)&Private->DstAddress) &&
 471         !EFI_IP6_EQUAL (&((EFI_IP6_RECEIVE_DATA*)Private->RxToken.Packet.RxData)->Header->SourceAddress, (EFI_IPv6_ADDRESS*)&Private->DstAddress)) {
 472       goto ON_EXIT;
 473     }
 474
 475     if ((Reply->Type != ICMP_V6_ECHO_REPLY) || (Reply->Code != 0)) {
 476       goto ON_EXIT;
 477     }
 478   } else {
 479     Reply   = ((EFI_IP4_RECEIVE_DATA*)Private->RxToken.Packet.RxData)->FragmentTable[0].FragmentBuffer;
 480     PayLoad = ((EFI_IP4_RECEIVE_DATA*)Private->RxToken.Packet.RxData)->DataLength;
 481     if (!IP4_IS_MULTICAST (EFI_IP4(*(EFI_IPv4_ADDRESS*)Private->DstAddress)) &&
 482         !EFI_IP4_EQUAL (&((EFI_IP4_RECEIVE_DATA*)Private->RxToken.Packet.RxData)->Header->SourceAddress, (EFI_IPv4_ADDRESS*)&Private->DstAddress)) {
 483       goto ON_EXIT;
 484     }
 485
 486     if ((Reply->Type != ICMP_V4_ECHO_REPLY) || (Reply->Code != 0)) {
 487       goto ON_EXIT;
 488     }
 489   }
 490
 491
 492   if (PayLoad != Private->BufferSize) {
 493     goto ON_EXIT;
 494   }
 495   //
 496   // Check whether the reply matches the sent request before.
 497   //
 498   Status = Ping6MatchEchoReply (Private, Reply);
 499   if (EFI_ERROR(Status)) {
 500     goto ON_EXIT;
 501   }
 502   //
 503   // Display statistics on this icmp6 echo reply packet.
 504   //
 505   Rtt  = CalculateTick (Reply->TimeStamp, ReadTime ());
 506   if (Rtt != 0) {
 507     Near = (CHAR8) '=';
 508   } else {
 509     Near = (CHAR8) '<';
 510   }
 511
 512   Private->RttSum += Rtt;
 513   Private->RttMin  = Private->RttMin > Rtt ? Rtt : Private->RttMin;
 514   Private->RttMax  = Private->RttMax < Rtt ? Rtt : Private->RttMax;
 515
 516   ShellPrintHiiEx (
 517     -1,
 518     -1,
 519     NULL,
 520     STRING_TOKEN (STR_PING_REPLY_INFO),
 521     gShellNetwork1HiiHandle,
 522     PayLoad,
 523     mDstString,
 524     Reply->SequenceNum,
 525     Private->IpChoice == PING_IP_CHOICE_IP6?((EFI_IP6_RECEIVE_DATA*)Private->RxToken.Packet.RxData)->Header->HopLimit:0,
 526     Near,
 527     Rtt
 528     );
 529
 530 ON_EXIT:
 531
 532   if (Private->RxCount < Private->SendNum) {
 533     //
 534     // Continue to receive icmp echo reply packets.
 535     //
 536     Private->RxToken.Status = EFI_ABORTED;
 537
 538     Status = Private->ProtocolPointers.Receive (Private->IpProtocol, &Private->RxToken);
 539
 540     if (EFI_ERROR (Status)) {
 541       Private->Status = EFI_ABORTED;
 542     }
 543   } else {
 544     //
 545     // All reply have already been received from the dest host.
 546     //
 547     Private->Status = EFI_SUCCESS;
 548   }
 549   //
 550   // Singal to recycle the each rxdata here, not at the end of process.
 551   //
 552   gBS->SignalEvent (Private->IpChoice == PING_IP_CHOICE_IP6?((EFI_IP6_RECEIVE_DATA*)Private->RxToken.Packet.RxData)->RecycleSignal:((EFI_IP4_RECEIVE_DATA*)Private->RxToken.Packet.RxData)->RecycleSignal);
 553 }
 554
 555 /**
 556   Create a PING_IPX_COMPLETION_TOKEN.
 557
 558   @param[in]    Private        The pointer of PING_PRIVATE_DATA.
 559   @param[in]    TimeStamp      The TimeStamp of request.
 560   @param[in]    SequenceNum    The SequenceNum of request.
 561
 562   @return The pointer of PING_IPX_COMPLETION_TOKEN.
 563
 564 **/
 565 PING_IPX_COMPLETION_TOKEN *
 566 EFIAPI
 567 PingGenerateToken (
 568   IN PING_PRIVATE_DATA    *Private,
 569   IN UINT64                TimeStamp,
 570   IN UINT16                SequenceNum
 571   )
 572 {
 573   EFI_STATUS                  Status;
 574   PING_IPX_COMPLETION_TOKEN   *Token;
 575   VOID                        *TxData;
 576   ICMPX_ECHO_REQUEST_REPLY    *Request;
 577   UINT16                        HeadSum;
 578   UINT16                        TempChecksum;
 579
 580   Request = AllocateZeroPool (Private->BufferSize);
 581   if (Request == NULL) {
 582     return NULL;
 583   }
 584   TxData = AllocateZeroPool (Private->IpChoice==PING_IP_CHOICE_IP6?sizeof (EFI_IP6_TRANSMIT_DATA):sizeof (EFI_IP4_TRANSMIT_DATA));
 585   if (TxData == NULL) {
 586     FreePool (Request);
 587     return NULL;
 588   }
 589   Token = AllocateZeroPool (sizeof (PING_IPX_COMPLETION_TOKEN));
 590   if (Token == NULL) {
 591     FreePool (Request);
 592     FreePool (TxData);
 593     return NULL;
 594   }
 595
 596   //
 597   // Assembly echo request packet.
 598   //
 599   Request->Type        = (UINT8)(Private->IpChoice==PING_IP_CHOICE_IP6?ICMP_V6_ECHO_REQUEST:ICMP_V4_ECHO_REQUEST);
 600   Request->Code        = 0;
 601   Request->SequenceNum = SequenceNum;
 602   Request->TimeStamp   = TimeStamp;
 603   Request->Identifier  = 0;
 604   Request->Checksum    = 0;
 605
 606   //
 607   // Assembly token for transmit.
 608   //
 609   if (Private->IpChoice==PING_IP_CHOICE_IP6) {
 610     ((EFI_IP6_TRANSMIT_DATA*)TxData)->ExtHdrsLength                   = 0;
 611     ((EFI_IP6_TRANSMIT_DATA*)TxData)->ExtHdrs                         = NULL;
 612     ((EFI_IP6_TRANSMIT_DATA*)TxData)->OverrideData                    = 0;
 613     ((EFI_IP6_TRANSMIT_DATA*)TxData)->DataLength                      = Private->BufferSize;
 614     ((EFI_IP6_TRANSMIT_DATA*)TxData)->FragmentCount                   = 1;
 615     ((EFI_IP6_TRANSMIT_DATA*)TxData)->FragmentTable[0].FragmentBuffer = (VOID *) Request;
 616     ((EFI_IP6_TRANSMIT_DATA*)TxData)->FragmentTable[0].FragmentLength = Private->BufferSize;
 617   } else {
 618     ((EFI_IP4_TRANSMIT_DATA*)TxData)->OptionsLength                   = 0;
 619     ((EFI_IP4_TRANSMIT_DATA*)TxData)->OptionsBuffer                   = NULL;
 620     ((EFI_IP4_TRANSMIT_DATA*)TxData)->OverrideData                    = 0;
 621     ((EFI_IP4_TRANSMIT_DATA*)TxData)->TotalDataLength                 = Private->BufferSize;
 622     ((EFI_IP4_TRANSMIT_DATA*)TxData)->FragmentCount                   = 1;
 623     ((EFI_IP4_TRANSMIT_DATA*)TxData)->FragmentTable[0].FragmentBuffer = (VOID *) Request;
 624     ((EFI_IP4_TRANSMIT_DATA*)TxData)->FragmentTable[0].FragmentLength = Private->BufferSize;
 625     ((EFI_IP4_TRANSMIT_DATA*)TxData)->DestinationAddress.Addr[0]      = Private->DstAddress[0];
 626     ((EFI_IP4_TRANSMIT_DATA*)TxData)->DestinationAddress.Addr[1]      = Private->DstAddress[1];
 627     ((EFI_IP4_TRANSMIT_DATA*)TxData)->DestinationAddress.Addr[2]      = Private->DstAddress[2];
 628     ((EFI_IP4_TRANSMIT_DATA*)TxData)->DestinationAddress.Addr[3]      = Private->DstAddress[3];
 629
 630     HeadSum = NetChecksum ((UINT8 *) Request, Private->BufferSize);
 631     TempChecksum = NetChecksum ((UINT8 *) &Request->TimeStamp, sizeof (UINT64));
 632     Request->Checksum = (UINT16)(~NetAddChecksum (HeadSum, TempChecksum));
 633   }
 634
 635
 636   Token->Status         = EFI_ABORTED;
 637   Token->Packet.TxData  = TxData;
 638
 639   Status = gBS->CreateEvent (
 640                   EVT_NOTIFY_SIGNAL,
 641                   TPL_CALLBACK,
 642                   Ping6OnEchoRequestSent,
 643                   Private,
 644                   &Token->Event
 645                   );
 646
 647   if (EFI_ERROR (Status)) {
 648     FreePool (Request);
 649     FreePool (TxData);
 650     FreePool (Token);
 651     return NULL;
 652   }
 653
 654   return Token;
 655 }
 656
 657 /**
 658   Transmit the PING_IPX_COMPLETION_TOKEN.
 659
 660   @param[in]    Private    The pointer of PING_PRIVATE_DATA.
 661
 662   @retval EFI_SUCCESS             Transmitted successfully.
 663   @retval EFI_OUT_OF_RESOURCES    No memory is available on the platform.
 664   @retval others                  Transmitted unsuccessfully.
 665
 666 **/
 667 EFI_STATUS
 668 EFIAPI
 669 PingSendEchoRequest (
 670   IN PING_PRIVATE_DATA    *Private
 671   )
 672 {
 673   EFI_STATUS             Status;
 674   PING_ICMPX_TX_INFO     *TxInfo;
 675
 676   TxInfo = AllocateZeroPool (sizeof (PING_ICMPX_TX_INFO));
 677
 678   if (TxInfo == NULL) {
 679     return EFI_OUT_OF_RESOURCES;
 680   }
 681
 682   TxInfo->TimeStamp   = ReadTime ();
 683   TxInfo->SequenceNum = (UINT16) (Private->TxCount + 1);
 684   TxInfo->Token       = PingGenerateToken (
 685                           Private,
 686                           TxInfo->TimeStamp,
 687                           TxInfo->SequenceNum
 688                           );
 689
 690   if (TxInfo->Token == NULL) {
 691     PingDestroyTxInfo (TxInfo, Private->IpChoice);
 692     return EFI_OUT_OF_RESOURCES;
 693   }
 694
 695   ASSERT(Private->ProtocolPointers.Transmit != NULL);
 696   Status = Private->ProtocolPointers.Transmit (Private->IpProtocol, TxInfo->Token);
 697
 698   if (EFI_ERROR (Status)) {
 699     PingDestroyTxInfo (TxInfo, Private->IpChoice);
 700     return Status;
 701   }
 702
 703   InsertTailList (&Private->TxList, &TxInfo->Link);
 704   Private->TxCount++;
 705
 706   return EFI_SUCCESS;
 707 }
 708
 709 /**
 710   Place a completion token into the receive packet queue to receive the echo reply.
 711
 712   @param[in]    Private    The pointer of PING_PRIVATE_DATA.
 713
 714   @retval EFI_SUCCESS      Put the token into the receive packet queue successfully.
 715   @retval others           Put the token into the receive packet queue unsuccessfully.
 716
 717 **/
 718 EFI_STATUS
 719 EFIAPI
 720 Ping6ReceiveEchoReply (
 721   IN PING_PRIVATE_DATA    *Private
 722   )
 723 {
 724   EFI_STATUS    Status;
 725
 726   ZeroMem (&Private->RxToken, sizeof (PING_IPX_COMPLETION_TOKEN));
 727
 728   Status = gBS->CreateEvent (
 729                   EVT_NOTIFY_SIGNAL,
 730                   TPL_CALLBACK,
 731                   Ping6OnEchoReplyReceived,
 732                   Private,
 733                   &Private->RxToken.Event
 734                   );
 735
 736   if (EFI_ERROR (Status)) {
 737     return Status;
 738   }
 739
 740   Private->RxToken.Status = EFI_NOT_READY;
 741
 742   return (Private->ProtocolPointers.Receive (Private->IpProtocol, &Private->RxToken));
 743 }
 744
 745 /**
 746   Remove the timeout request from the list.
 747
 748   @param[in]    Event    A EFI_EVENT type event.
 749   @param[in]    Context  The pointer to Context.
 750
 751 **/
 752 VOID
 753 EFIAPI
 754 Ping6OnTimerRoutine (
 755   IN EFI_EVENT    Event,
 756   IN VOID         *Context
 757   )
 758 {
 759   EFI_STATUS             Status;
 760   PING_PRIVATE_DATA      *Private;
 761   PING_ICMPX_TX_INFO     *TxInfo;
 762   LIST_ENTRY             *Entry;
 763   LIST_ENTRY             *NextEntry;
 764   UINT64                 Time;
 765
 766   Private = (PING_PRIVATE_DATA *) Context;
 767   if (Private->Signature != PING_PRIVATE_DATA_SIGNATURE) {
 768     Private->Status = EFI_NOT_FOUND;
 769     return;
 770   }
 771
 772   //
 773   // Retransmit icmp6 echo request packets per second in sendnumber times.
 774   //
 775   if (Private->TxCount < Private->SendNum) {
 776
 777     Status = PingSendEchoRequest (Private);
 778     if (Private->TxCount != 0){
 779       if (EFI_ERROR (Status)) {
 780         ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_PING_SEND_REQUEST), gShellNetwork1HiiHandle, Private->TxCount + 1);
 781       }
 782     }
 783   }
 784   //
 785   // Check whether any icmp6 echo request in the list timeout.
 786   //
 787   NET_LIST_FOR_EACH_SAFE (Entry, NextEntry, &Private->TxList) {
 788     TxInfo = BASE_CR (Entry, PING_ICMPX_TX_INFO, Link);
 789     Time   = CalculateTick (TxInfo->TimeStamp, ReadTime ());
 790
 791     //
 792     // Remove the timeout echo request from txlist.
 793     //
 794     if (Time > DEFAULT_TIMEOUT) {
 795
 796       if (EFI_ERROR (TxInfo->Token->Status)) {
 797         Private->ProtocolPointers.Cancel (Private->IpProtocol, TxInfo->Token);
 798       }
 799       //
 800       // Remove the timeout icmp6 echo request from list.
 801       //
 802       ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_PING_TIMEOUT), gShellNetwork1HiiHandle, TxInfo->SequenceNum);
 803
 804       RemoveEntryList (&TxInfo->Link);
 805       PingDestroyTxInfo (TxInfo, Private->IpChoice);
 806
 807       if (IsListEmpty (&Private->TxList) && (Private->TxCount == Private->SendNum)) {
 808         //
 809         // All the left icmp6 echo request in the list timeout.
 810         //
 811         Private->Status = EFI_TIMEOUT;
 812       }
 813     }
 814   }
 815 }
 816
 817 /**
 818   Determine if a IP4 address is Link Local.
 819
 820   169.254.1.0 through 169.254.254.255 is link local.
 821
 822   @param[in] Address  The address to test.
 823
 824   @retval TRUE      It is.
 825   @retval FALSE     It is not.
 826 **/
 827 BOOLEAN
 828 EFIAPI
 829 PingNetIp4IsLinkLocalAddr (
 830   IN CONST EFI_IPv4_ADDRESS *Address
 831   )
 832 {
 833   return ((BOOLEAN)(Address->Addr[0] == 169 && Address->Addr[1] == 254 && Address->Addr[2] >= 1 && Address->Addr[2] <= 254));
 834 }
 835
 836 /**
 837   Determine if a IP4 address is unspecified.
 838
 839   @param[in] Address  The address to test.
 840
 841   @retval TRUE      It is.
 842   @retval FALSE     It is not.
 843 **/
 844 BOOLEAN
 845 EFIAPI
 846 PingNetIp4IsUnspecifiedAddr (
 847   IN CONST EFI_IPv4_ADDRESS *Address
 848   )
 849 {
 850   return  ((BOOLEAN)((ReadUnaligned32 ((UINT32*)&Address->Addr[0])) == 0x00000000));
 851 }
 852
 853 /**
 854   Create a valid IP instance.
 855
 856   @param[in]    Private    The pointer of PING_PRIVATE_DATA.
 857
 858   @retval EFI_SUCCESS              Create a valid IPx instance successfully.
 859   @retval EFI_ABORTED              Locate handle with ipx service binding protocol unsuccessfully.
 860   @retval EFI_INVALID_PARAMETER    The source address is unspecified when the destination address is a link-local address.
 861   @retval EFI_OUT_OF_RESOURCES     No memory is available on the platform.
 862   @retval EFI_NOT_FOUND            The source address is not found.
 863 **/
 864 EFI_STATUS
 865 EFIAPI
 866 PingCreateIpInstance (
 867   IN  PING_PRIVATE_DATA    *Private
 868   )
 869 {
 870   EFI_STATUS                       Status;
 871   UINTN                            HandleIndex;
 872   UINTN                            HandleNum;
 873   EFI_HANDLE                       *HandleBuffer;
 874   EFI_SERVICE_BINDING_PROTOCOL     *EfiSb;
 875   VOID                             *IpXCfg;
 876   EFI_IP6_CONFIG_DATA              Ip6Config;
 877   EFI_IP4_CONFIG_DATA              Ip4Config;
 878   VOID                             *IpXInterfaceInfo;
 879   UINTN                            IfInfoSize;
 880   EFI_IPv6_ADDRESS                 *Addr;
 881   UINTN                            AddrIndex;
 882
 883   HandleBuffer      = NULL;
 884   EfiSb             = NULL;
 885   IpXInterfaceInfo  = NULL;
 886   IfInfoSize        = 0;
 887
 888   //
 889   // Locate all the handles with ip6 service binding protocol.
 890   //
 891   Status = gBS->LocateHandleBuffer (
 892                   ByProtocol,
 893                   Private->IpChoice == PING_IP_CHOICE_IP6?&gEfiIp6ServiceBindingProtocolGuid:&gEfiIp4ServiceBindingProtocolGuid,
 894                   NULL,
 895                   &HandleNum,
 896                   &HandleBuffer
 897                   );
 898   if (EFI_ERROR (Status) || (HandleNum == 0) || (HandleBuffer == NULL)) {
 899     return EFI_ABORTED;
 900   }
 901   //
 902   // Source address is required when pinging a link-local address on multi-
 903   // interfaces host.
 904   //
 905   if (Private->IpChoice == PING_IP_CHOICE_IP6) {
 906     if (NetIp6IsLinkLocalAddr ((EFI_IPv6_ADDRESS*)&Private->DstAddress) &&
 907         NetIp6IsUnspecifiedAddr ((EFI_IPv6_ADDRESS*)&Private->SrcAddress) &&
 908         (HandleNum > 1)) {
 909       ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellNetwork1HiiHandle, L"ping", mSrcString);
 910       Status = EFI_INVALID_PARAMETER;
 911       goto ON_ERROR;
 912     }
 913   } else {
 914     ASSERT(Private->IpChoice == PING_IP_CHOICE_IP4);
 915     if (PingNetIp4IsLinkLocalAddr ((EFI_IPv4_ADDRESS*)&Private->DstAddress) &&
 916         PingNetIp4IsUnspecifiedAddr ((EFI_IPv4_ADDRESS*)&Private->SrcAddress) &&
 917         (HandleNum > 1)) {
 918       ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellNetwork1HiiHandle, L"ping", mSrcString);
 919       Status = EFI_INVALID_PARAMETER;
 920       goto ON_ERROR;
 921     }
 922   }
 923   //
 924   // For each ip6 protocol, check interface addresses list.
 925   //
 926   for (HandleIndex = 0; HandleIndex < HandleNum; HandleIndex++) {
 927
 928     EfiSb             = NULL;
 929     IpXInterfaceInfo  = NULL;
 930     IfInfoSize        = 0;
 931
 932     Status = gBS->HandleProtocol (
 933                     HandleBuffer[HandleIndex],
 934                     Private->IpChoice == PING_IP_CHOICE_IP6?&gEfiIp6ServiceBindingProtocolGuid:&gEfiIp4ServiceBindingProtocolGuid,
 935                     (VOID **) &EfiSb
 936                     );
 937     if (EFI_ERROR (Status)) {
 938       goto ON_ERROR;
 939     }
 940
 941     if (Private->IpChoice == PING_IP_CHOICE_IP6?NetIp6IsUnspecifiedAddr ((EFI_IPv6_ADDRESS*)&Private->SrcAddress):PingNetIp4IsUnspecifiedAddr ((EFI_IPv4_ADDRESS*)&Private->SrcAddress)) {
 942       //
 943       // No need to match interface address.
 944       //
 945       break;
 946     } else {
 947       //
 948       // Ip6config protocol and ip6 service binding protocol are installed
 949       // on the same handle.
 950       //
 951       Status = gBS->HandleProtocol (
 952                       HandleBuffer[HandleIndex],
 953                       Private->IpChoice == PING_IP_CHOICE_IP6?&gEfiIp6ConfigProtocolGuid:&gEfiIp4Config2ProtocolGuid,
 954                       (VOID **) &IpXCfg
 955                       );
 956
 957       if (EFI_ERROR (Status)) {
 958         goto ON_ERROR;
 959       }
 960       //
 961       // Get the interface information size.
 962       //
 963       if (Private->IpChoice == PING_IP_CHOICE_IP6) {
 964         Status = ((EFI_IP6_CONFIG_PROTOCOL*)IpXCfg)->GetData (
 965                            IpXCfg,
 966                            Ip6ConfigDataTypeInterfaceInfo,
 967                            &IfInfoSize,
 968                            NULL
 969                            );
 970       } else {
 971         Status = ((EFI_IP4_CONFIG2_PROTOCOL*)IpXCfg)->GetData (
 972                            IpXCfg,
 973                            Ip4Config2DataTypeInterfaceInfo,
 974                            &IfInfoSize,
 975                            NULL
 976                            );
 977       }
 978
 979       //
 980       // Skip the ones not in current use.
 981       //
 982       if (Status == EFI_NOT_STARTED) {
 983         continue;
 984       }
 985
 986       if (Status != EFI_BUFFER_TOO_SMALL) {
 987         ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_PING_GETDATA), gShellNetwork1HiiHandle, Status);
 988         goto ON_ERROR;
 989       }
 990
 991       IpXInterfaceInfo = AllocateZeroPool (IfInfoSize);
 992
 993       if (IpXInterfaceInfo == NULL) {
 994         Status = EFI_OUT_OF_RESOURCES;
 995         goto ON_ERROR;
 996       }
 997       //
 998       // Get the interface info.
 999       //
1000       if (Private->IpChoice == PING_IP_CHOICE_IP6) {
1001         Status = ((EFI_IP6_CONFIG_PROTOCOL*)IpXCfg)->GetData (
1002                            IpXCfg,
1003                            Ip6ConfigDataTypeInterfaceInfo,
1004                            &IfInfoSize,
1005                            IpXInterfaceInfo
1006                            );
1007       } else {
1008         Status = ((EFI_IP4_CONFIG2_PROTOCOL*)IpXCfg)->GetData (
1009                            IpXCfg,
1010                            Ip4Config2DataTypeInterfaceInfo,
1011                            &IfInfoSize,
1012                            IpXInterfaceInfo
1013                            );
1014       }
1015
1016       if (EFI_ERROR (Status)) {
1017         ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_PING_GETDATA), gShellNetwork1HiiHandle, Status);
1018         goto ON_ERROR;
1019       }
1020       //
1021       // Check whether the source address is one of the interface addresses.
1022       //
1023       if (Private->IpChoice == PING_IP_CHOICE_IP6) {
1024         for (AddrIndex = 0; AddrIndex < ((EFI_IP6_CONFIG_INTERFACE_INFO*)IpXInterfaceInfo)->AddressInfoCount; AddrIndex++) {
1025
1026           Addr = &(((EFI_IP6_CONFIG_INTERFACE_INFO*)IpXInterfaceInfo)->AddressInfo[AddrIndex].Address);
1027           if (EFI_IP6_EQUAL (&Private->SrcAddress, Addr)) {
1028             //
1029             // Match a certain interface address.
1030             //
1031             break;
1032           }
1033         }
1034
1035         if (AddrIndex < ((EFI_IP6_CONFIG_INTERFACE_INFO*)IpXInterfaceInfo)->AddressInfoCount) {
1036           //
1037           // Found a nic handle with right interface address.
1038           //
1039           break;
1040         }
1041       } else {
1042         //
1043         // IP4 address check
1044         //
1045         if (EFI_IP4_EQUAL (&Private->SrcAddress, &((EFI_IP4_CONFIG2_INTERFACE_INFO*)IpXInterfaceInfo)->StationAddress)) {
1046           //
1047           // Match a certain interface address.
1048           //
1049           break;
1050         }
1051       }
1052     }
1053
1054     FreePool (IpXInterfaceInfo);
1055     IpXInterfaceInfo = NULL;
1056   }
1057   //
1058   // No exact interface address matched.
1059   //
1060
1061   if (HandleIndex == HandleNum) {
1062     ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_PING_CONFIGD_NIC_NF), gShellNetwork1HiiHandle, L"ping");
1063     Status = EFI_NOT_FOUND;
1064     goto ON_ERROR;
1065   }
1066
1067   Private->NicHandle = HandleBuffer[HandleIndex];
1068
1069   ASSERT (EfiSb != NULL);
1070   Status = EfiSb->CreateChild (EfiSb, &Private->IpChildHandle);
1071
1072   if (EFI_ERROR (Status)) {
1073     goto ON_ERROR;
1074   }
1075   if (Private->IpChoice == PING_IP_CHOICE_IP6) {
1076     Status = gBS->OpenProtocol (
1077                     Private->IpChildHandle,
1078                     &gEfiIp6ProtocolGuid,
1079                     &Private->IpProtocol,
1080                     gImageHandle,
1081                     Private->IpChildHandle,
1082                     EFI_OPEN_PROTOCOL_GET_PROTOCOL
1083                     );
1084     if (EFI_ERROR (Status)) {
1085       goto ON_ERROR;
1086     }
1087
1088
1089     ZeroMem (&Ip6Config, sizeof (EFI_IP6_CONFIG_DATA));
1090
1091     //
1092     // Configure the ip6 instance for icmp6 packet exchange.
1093     //
1094     Ip6Config.DefaultProtocol   = 58;
1095     Ip6Config.AcceptAnyProtocol = FALSE;
1096     Ip6Config.AcceptIcmpErrors  = TRUE;
1097     Ip6Config.AcceptPromiscuous = FALSE;
1098     Ip6Config.TrafficClass      = 0;
1099     Ip6Config.HopLimit          = 128;
1100     Ip6Config.FlowLabel         = 0;
1101     Ip6Config.ReceiveTimeout    = 0;
1102     Ip6Config.TransmitTimeout   = 0;
1103
1104     IP6_COPY_ADDRESS (&Ip6Config.StationAddress,     &Private->SrcAddress);
1105     IP6_COPY_ADDRESS (&Ip6Config.DestinationAddress, &Private->DstAddress);
1106
1107     Status = ((EFI_IP6_PROTOCOL*)(Private->IpProtocol))->Configure (Private->IpProtocol, &Ip6Config);
1108
1109     if (EFI_ERROR (Status)) {
1110       ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_PING_CONFIG), gShellNetwork1HiiHandle, Status);
1111       goto ON_ERROR;
1112     }
1113
1114     Private->ProtocolPointers.Transmit  = (PING_IPX_TRANSMIT )((EFI_IP6_PROTOCOL*)Private->IpProtocol)->Transmit;
1115     Private->ProtocolPointers.Receive   = (PING_IPX_RECEIVE  )((EFI_IP6_PROTOCOL*)Private->IpProtocol)->Receive;
1116     Private->ProtocolPointers.Cancel    = (PING_IPX_CANCEL   )((EFI_IP6_PROTOCOL*)Private->IpProtocol)->Cancel;
1117     Private->ProtocolPointers.Poll      = (PING_IPX_POLL     )((EFI_IP6_PROTOCOL*)Private->IpProtocol)->Poll;
1118   } else {
1119     Status = gBS->OpenProtocol (
1120                     Private->IpChildHandle,
1121                     &gEfiIp4ProtocolGuid,
1122                     &Private->IpProtocol,
1123                     gImageHandle,
1124                     Private->IpChildHandle,
1125                     EFI_OPEN_PROTOCOL_GET_PROTOCOL
1126                     );
1127     if (EFI_ERROR (Status)) {
1128       goto ON_ERROR;
1129     }
1130
1131
1132     ZeroMem (&Ip4Config, sizeof (EFI_IP4_CONFIG_DATA));
1133
1134     //
1135     // Configure the ip4 instance for icmp4 packet exchange.
1136     //
1137     Ip4Config.DefaultProtocol   = 1;
1138     Ip4Config.AcceptAnyProtocol = FALSE;
1139     Ip4Config.AcceptBroadcast   = FALSE;
1140     Ip4Config.AcceptIcmpErrors  = TRUE;
1141     Ip4Config.AcceptPromiscuous = FALSE;
1142     Ip4Config.DoNotFragment     = FALSE;
1143     Ip4Config.RawData           = FALSE;
1144     Ip4Config.ReceiveTimeout    = 0;
1145     Ip4Config.TransmitTimeout   = 0;
1146     Ip4Config.UseDefaultAddress = TRUE;
1147     Ip4Config.TimeToLive        = 128;
1148     Ip4Config.TypeOfService     = 0;
1149
1150     Status = ((EFI_IP4_PROTOCOL*)(Private->IpProtocol))->Configure (Private->IpProtocol, &Ip4Config);
1151
1152     if (EFI_ERROR (Status)) {
1153       ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_PING_CONFIG), gShellNetwork1HiiHandle, Status);
1154       goto ON_ERROR;
1155     }
1156
1157     Private->ProtocolPointers.Transmit  = (PING_IPX_TRANSMIT )((EFI_IP4_PROTOCOL*)Private->IpProtocol)->Transmit;
1158     Private->ProtocolPointers.Receive   = (PING_IPX_RECEIVE  )((EFI_IP4_PROTOCOL*)Private->IpProtocol)->Receive;
1159     Private->ProtocolPointers.Cancel    = (PING_IPX_CANCEL   )((EFI_IP4_PROTOCOL*)Private->IpProtocol)->Cancel;
1160     Private->ProtocolPointers.Poll      = (PING_IPX_POLL     )((EFI_IP4_PROTOCOL*)Private->IpProtocol)->Poll;
1161   }
1162
1163   if (HandleBuffer != NULL) {
1164     FreePool (HandleBuffer);
1165   }
1166
1167   return EFI_SUCCESS;
1168
1169 ON_ERROR:
1170   if (HandleBuffer != NULL) {
1171     FreePool (HandleBuffer);
1172   }
1173
1174   if (IpXInterfaceInfo != NULL) {
1175     FreePool (IpXInterfaceInfo);
1176   }
1177
1178   if ((EfiSb != NULL) && (Private->IpChildHandle != NULL)) {
1179     EfiSb->DestroyChild (EfiSb, Private->IpChildHandle);
1180   }
1181
1182   return Status;
1183 }
1184
1185 /**
1186   Destroy the IP instance.
1187
1188   @param[in]    Private    The pointer of PING_PRIVATE_DATA.
1189
1190 **/
1191 VOID
1192 EFIAPI
1193 Ping6DestroyIp6Instance (
1194   IN PING_PRIVATE_DATA    *Private
1195   )
1196 {
1197   EFI_STATUS                      Status;
1198   EFI_SERVICE_BINDING_PROTOCOL    *IpSb;
1199
1200   gBS->CloseProtocol (
1201          Private->IpChildHandle,
1202          Private->IpChoice == PING_IP_CHOICE_IP6?&gEfiIp6ProtocolGuid:&gEfiIp4ProtocolGuid,
1203          gImageHandle,
1204          Private->IpChildHandle
1205          );
1206
1207   Status = gBS->HandleProtocol (
1208                   Private->NicHandle,
1209                   Private->IpChoice == PING_IP_CHOICE_IP6?&gEfiIp6ServiceBindingProtocolGuid:&gEfiIp4ServiceBindingProtocolGuid,
1210                   (VOID **) &IpSb
1211                   );
1212
1213   if (!EFI_ERROR(Status)) {
1214     IpSb->DestroyChild (IpSb, Private->IpChildHandle);
1215   }
1216 }
1217
1218 /**
1219   The Ping Process.
1220
1221   @param[in]   SendNumber     The send request count.
1222   @param[in]   BufferSize     The send buffer size.
1223   @param[in]   SrcAddress     The source address.
1224   @param[in]   DstAddress     The destination address.
1225   @param[in]   IpChoice       The choice between IPv4 and IPv6.
1226
1227   @retval SHELL_SUCCESS  The ping processed successfullly.
1228   @retval others         The ping processed unsuccessfully.
1229 **/
1230 SHELL_STATUS
1231 EFIAPI
1232 ShellPing (
1233   IN UINT32              SendNumber,
1234   IN UINT32              BufferSize,
1235   IN EFI_IPv6_ADDRESS    *SrcAddress,
1236   IN EFI_IPv6_ADDRESS    *DstAddress,
1237   IN UINT32              IpChoice
1238   )
1239 {
1240   EFI_STATUS             Status;
1241   PING_PRIVATE_DATA      *Private;
1242   PING_ICMPX_TX_INFO     *TxInfo;
1243   LIST_ENTRY             *Entry;
1244   LIST_ENTRY             *NextEntry;
1245   SHELL_STATUS           ShellStatus;
1246
1247   ShellStatus = SHELL_SUCCESS;
1248   Private     = AllocateZeroPool (sizeof (PING_PRIVATE_DATA));
1249
1250   if (Private == NULL) {
1251     return (SHELL_OUT_OF_RESOURCES);
1252   }
1253
1254   Private->IpChoice    = IpChoice;
1255   Private->Signature   = PING_PRIVATE_DATA_SIGNATURE;
1256   Private->SendNum     = SendNumber;
1257   Private->BufferSize  = BufferSize;
1258   Private->RttMin      = ~((UINT64 )(0x0));
1259   Private->Status      = EFI_NOT_READY;
1260
1261   CopyMem(&Private->SrcAddress, SrcAddress, sizeof(Private->SrcAddress));
1262   CopyMem(&Private->DstAddress, DstAddress, sizeof(Private->DstAddress));
1263
1264   InitializeListHead (&Private->TxList);
1265
1266   //
1267   // Open and configure a ip instance for us.
1268   //
1269   Status = PingCreateIpInstance (Private);
1270
1271   if (EFI_ERROR (Status)) {
1272     ShellStatus = SHELL_ACCESS_DENIED;
1273     goto ON_EXIT;
1274   }
1275   //
1276   // Print the command line itself.
1277   //
1278   ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_PING_START), gShellNetwork1HiiHandle, mDstString, Private->BufferSize);
1279   //
1280   // Create a ipv6 token to receive the first icmp6 echo reply packet.
1281   //
1282   Status = Ping6ReceiveEchoReply (Private);
1283
1284   if (EFI_ERROR (Status)) {
1285     ShellStatus = SHELL_ACCESS_DENIED;
1286     goto ON_EXIT;
1287   }
1288   //
1289   // Create and start timer to send icmp6 echo request packet per second.
1290   //
1291   Status = gBS->CreateEvent (
1292                   EVT_TIMER | EVT_NOTIFY_SIGNAL,
1293                   TPL_CALLBACK,
1294                   Ping6OnTimerRoutine,
1295                   Private,
1296                   &Private->Timer
1297                   );
1298
1299   if (EFI_ERROR (Status)) {
1300     ShellStatus = SHELL_ACCESS_DENIED;
1301     goto ON_EXIT;
1302   }
1303   //
1304   // Create a ipv6 token to send the first icmp6 echo request packet.
1305   //
1306   Status = PingSendEchoRequest (Private);
1307   //
1308   // EFI_NOT_READY for IPsec is enable and IKE is not established.
1309   //
1310   if (EFI_ERROR (Status) && (Status != EFI_NOT_READY)) {
1311     ShellStatus = SHELL_ACCESS_DENIED;
1312     if(Status == EFI_NOT_FOUND) {
1313       ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_PING_NOSOURCE_INDO), gShellNetwork1HiiHandle, mDstString);
1314     } else if (Status == RETURN_NO_MAPPING) {
1315       ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_PING_NOROUTE_FOUND), gShellNetwork1HiiHandle, mDstString, mSrcString);
1316     } else {
1317       ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_PING_NETWORK_ERROR), gShellNetwork1HiiHandle, L"ping", Status);
1318     }
1319
1320     goto ON_EXIT;
1321   }
1322
1323   Status = gBS->SetTimer (
1324                   Private->Timer,
1325                   TimerPeriodic,
1326                   ONE_SECOND
1327                   );
1328
1329   if (EFI_ERROR (Status)) {
1330     ShellStatus = SHELL_ACCESS_DENIED;
1331     goto ON_EXIT;
1332   }
1333   //
1334   // Control the ping6 process by two factors:
1335   // 1. Hot key
1336   // 2. Private->Status
1337   //   2.1. success means all icmp6 echo request packets get reply packets.
1338   //   2.2. timeout means the last icmp6 echo reply request timeout to get reply.
1339   //   2.3. noready means ping6 process is on-the-go.
1340   //
1341   while (Private->Status == EFI_NOT_READY) {
1342     Status = Private->ProtocolPointers.Poll (Private->IpProtocol);
1343     if (ShellGetExecutionBreakFlag()) {
1344       Private->Status = EFI_ABORTED;
1345       goto ON_STAT;
1346     }
1347   }
1348
1349 ON_STAT:
1350   //
1351   // Display the statistics in all.
1352   //
1353   gBS->SetTimer (Private->Timer, TimerCancel, 0);
1354
1355   if (Private->TxCount != 0) {
1356     ShellPrintHiiEx (
1357       -1,
1358       -1,
1359       NULL,
1360       STRING_TOKEN (STR_PING_STAT),
1361       gShellNetwork1HiiHandle,
1362       Private->TxCount,
1363       Private->RxCount,
1364       (100 * (Private->TxCount - Private->RxCount)) / Private->TxCount,
1365       Private->RttSum
1366       );
1367   }
1368
1369   if (Private->RxCount != 0) {
1370     ShellPrintHiiEx (
1371       -1,
1372       -1,
1373       NULL,
1374       STRING_TOKEN (STR_PING_RTT),
1375       gShellNetwork1HiiHandle,
1376       Private->RttMin,
1377       Private->RttMax,
1378       DivU64x64Remainder (Private->RttSum, Private->RxCount, NULL)
1379       );
1380   }
1381
1382 ON_EXIT:
1383
1384   if (Private != NULL) {
1385
1386     NET_LIST_FOR_EACH_SAFE (Entry, NextEntry, &Private->TxList) {
1387       TxInfo = BASE_CR (Entry, PING_ICMPX_TX_INFO, Link);
1388
1389       if (Private->IpProtocol != NULL && Private->ProtocolPointers.Cancel != NULL) {
1390         Status = Private->ProtocolPointers.Cancel (Private->IpProtocol, TxInfo->Token);
1391       }
1392
1393       RemoveEntryList (&TxInfo->Link);
1394       PingDestroyTxInfo (TxInfo, Private->IpChoice);
1395     }
1396
1397     if (Private->Timer != NULL) {
1398       gBS->CloseEvent (Private->Timer);
1399     }
1400
1401     if (Private->IpProtocol != NULL && Private->ProtocolPointers.Cancel != NULL) {
1402       Status = Private->ProtocolPointers.Cancel (Private->IpProtocol, &Private->RxToken);
1403     }
1404
1405     if (Private->RxToken.Event != NULL) {
1406       gBS->CloseEvent (Private->RxToken.Event);
1407     }
1408
1409     if (Private->IpChildHandle != NULL) {
1410       Ping6DestroyIp6Instance (Private);
1411     }
1412
1413     FreePool (Private);
1414   }
1415
1416   return ShellStatus;
1417 }
1418
1419 /**
1420   Function for 'ping' command.
1421
1422   @param[in] ImageHandle  Handle to the Image (NULL if Internal).
1423   @param[in] SystemTable  Pointer to the System Table (NULL if Internal).
1424
1425   @retval SHELL_SUCCESS  The ping processed successfullly.
1426   @retval others         The ping processed unsuccessfully.
1427
1428 **/
1429 SHELL_STATUS
1430 EFIAPI
1431 ShellCommandRunPing (
1432   IN EFI_HANDLE        ImageHandle,
1433   IN EFI_SYSTEM_TABLE  *SystemTable
1434   )
1435 {
1436   EFI_STATUS          Status;
1437   SHELL_STATUS        ShellStatus;
1438   EFI_IPv6_ADDRESS    DstAddress;
1439   EFI_IPv6_ADDRESS    SrcAddress;
1440   UINT64              BufferSize;
1441   UINTN               SendNumber;
1442   LIST_ENTRY          *ParamPackage;
1443   CONST CHAR16        *ValueStr;
1444   UINTN               NonOptionCount;
1445   UINT32              IpChoice;
1446   CHAR16              *ProblemParam;
1447
1448   //
1449   // we use IPv6 buffers to hold items...
1450   // make sure this is enough space!
1451   //
1452   ASSERT(sizeof(EFI_IPv4_ADDRESS        ) <= sizeof(EFI_IPv6_ADDRESS         ));
1453   ASSERT(sizeof(EFI_IP4_COMPLETION_TOKEN) <= sizeof(EFI_IP6_COMPLETION_TOKEN ));
1454
1455   IpChoice = PING_IP_CHOICE_IP4;
1456
1457   ShellStatus = SHELL_SUCCESS;
1458   ProblemParam = NULL;
1459
1460   Status = ShellCommandLineParseEx (PingParamList, &ParamPackage, &ProblemParam, TRUE, FALSE);
1461   if (EFI_ERROR(Status)) {
1462     ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellNetwork1HiiHandle, L"ping", ProblemParam);
1463     ShellStatus = SHELL_INVALID_PARAMETER;
1464     goto ON_EXIT;
1465   }
1466
1467   if (ShellCommandLineGetFlag (ParamPackage, L"-_ip6")) {
1468     IpChoice = PING_IP_CHOICE_IP6;
1469   }
1470
1471   //
1472   // Parse the paramter of count number.
1473   //
1474   ValueStr = ShellCommandLineGetValue (ParamPackage, L"-n");
1475   if (ValueStr != NULL) {
1476     SendNumber = ShellStrToUintn (ValueStr);
1477
1478     //
1479     // ShellStrToUintn will return 0 when input is 0 or an invalid input string.
1480     //
1481     if ((SendNumber == 0) || (SendNumber > MAX_SEND_NUMBER)) {
1482       ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellNetwork1HiiHandle, L"ping", ValueStr);
1483       ShellStatus = SHELL_INVALID_PARAMETER;
1484       goto ON_EXIT;
1485     }
1486   } else {
1487     SendNumber = DEFAULT_SEND_COUNT;
1488   }
1489   //
1490   // Parse the paramter of buffer size.
1491   //
1492   ValueStr = ShellCommandLineGetValue (ParamPackage, L"-l");
1493   if (ValueStr != NULL) {
1494     BufferSize = ShellStrToUintn (ValueStr);
1495
1496     //
1497     // ShellStrToUintn will return 0 when input is 0 or an invalid input string.
1498     //
1499     if ((BufferSize < 16) || (BufferSize > MAX_BUFFER_SIZE)) {
1500       ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellNetwork1HiiHandle, L"ping", ValueStr);
1501       ShellStatus = SHELL_INVALID_PARAMETER;
1502       goto ON_EXIT;
1503     }
1504   } else {
1505     BufferSize = DEFAULT_BUFFER_SIZE;
1506   }
1507
1508   ZeroMem (&SrcAddress, sizeof (EFI_IPv6_ADDRESS));
1509   ZeroMem (&DstAddress, sizeof (EFI_IPv6_ADDRESS));
1510
1511   //
1512   // Parse the paramter of source ip address.
1513   //
1514   ValueStr = ShellCommandLineGetValue (ParamPackage, L"-_s");
1515   if (ValueStr != NULL) {
1516     mSrcString = ValueStr;
1517     if (IpChoice == PING_IP_CHOICE_IP6) {
1518       Status = NetLibStrToIp6 (ValueStr, &SrcAddress);
1519     } else {
1520       Status = NetLibStrToIp4 (ValueStr, (EFI_IPv4_ADDRESS*)&SrcAddress);
1521     }
1522     if (EFI_ERROR (Status)) {
1523       ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellNetwork1HiiHandle, L"ping", ValueStr);
1524       ShellStatus = SHELL_INVALID_PARAMETER;
1525       goto ON_EXIT;
1526     }
1527   }
1528   //
1529   // Parse the paramter of destination ip address.
1530   //
1531   NonOptionCount = ShellCommandLineGetCount(ParamPackage);
1532   if (NonOptionCount < 2) {
1533     ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW), gShellNetwork1HiiHandle, L"ping");
1534     ShellStatus = SHELL_INVALID_PARAMETER;
1535     goto ON_EXIT;
1536   }
1537   if (NonOptionCount > 2) {
1538     ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellNetwork1HiiHandle, L"ping");
1539     ShellStatus = SHELL_INVALID_PARAMETER;
1540     goto ON_EXIT;
1541   }
1542   ValueStr = ShellCommandLineGetRawValue (ParamPackage, 1);
1543   if (ValueStr != NULL) {
1544     mDstString = ValueStr;
1545     if (IpChoice == PING_IP_CHOICE_IP6) {
1546       Status = NetLibStrToIp6 (ValueStr, &DstAddress);
1547     } else {
1548       Status = NetLibStrToIp4 (ValueStr, (EFI_IPv4_ADDRESS*)&DstAddress);
1549     }
1550     if (EFI_ERROR (Status)) {
1551       ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellNetwork1HiiHandle, L"ping", ValueStr);
1552       ShellStatus = SHELL_INVALID_PARAMETER;
1553       goto ON_EXIT;
1554     }
1555   }
1556   //
1557   // Get frequency to calculate the time from ticks.
1558   //
1559   Status = GetFrequency ();
1560
1561   if (EFI_ERROR(Status)) {
1562     goto ON_EXIT;
1563   }
1564   //
1565   // Enter into ping process.
1566   //
1567   ShellStatus = ShellPing (
1568              (UINT32)SendNumber,
1569              (UINT32)BufferSize,
1570              &SrcAddress,
1571              &DstAddress,
1572              IpChoice
1573              );
1574
1575 ON_EXIT:
1576   ShellCommandLineFreeVarList (ParamPackage);
1577   return ShellStatus;
1578 }