Update ipsecconfig and ping6 due to ShellLib update.
[mirror_edk2.git] / NetworkPkg / Application / Ping6 / Ping6.c
1 /** @file
2 The implementation for Ping6 application.
3
4 Copyright (c) 2009 - 2010, 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 <Library/ShellLib.h>
17 #include <Library/BaseMemoryLib.h>
18 #include <Library/BaseLib.h>
19 #include <Library/MemoryAllocationLib.h>
20 #include <Library/DebugLib.h>
21 #include <Library/UefiBootServicesTableLib.h>
22 #include <Library/HiiLib.h>
23 #include <Library/NetLib.h>
24
25 #include <Protocol/Cpu.h>
26 #include <Protocol/ServiceBinding.h>
27 #include <Protocol/Ip6.h>
28 #include <Protocol/Ip6Config.h>
29
30 #include "Ping6.h"
31
32 SHELL_PARAM_ITEM Ping6ParamList[] = {
33 {
34 L"-l",
35 TypeValue
36 },
37 {
38 L"-n",
39 TypeValue
40 },
41 {
42 L"-s",
43 TypeValue
44 },
45 {
46 L"-?",
47 TypeFlag
48 },
49 {
50 NULL,
51 TypeMax
52 },
53 };
54
55 //
56 // Global Variables in Ping6 application.
57 //
58 EFI_HII_HANDLE mHiiHandle;
59 CONST CHAR16 *mIp6DstString;
60 CONST CHAR16 *mIp6SrcString;
61 EFI_GUID mEfiPing6Guid = EFI_PING6_GUID;
62 UINT32 mFrequency = 0;
63 /**
64 Get and caculate the frequency in tick/ms.
65 The result is saved in the globle variable mFrequency
66
67 @retval EFI_SUCCESS Caculated the frequency successfully.
68 @retval Others Failed to caculate the frequency.
69
70 **/
71 EFI_STATUS
72 Ping6GetFrequency (
73 VOID
74 )
75 {
76 EFI_STATUS Status;
77 EFI_CPU_ARCH_PROTOCOL *Cpu;
78 UINT64 CurrentTick;
79 UINT32 TimerPeriod;
80
81 Status = gBS->LocateProtocol (&gEfiCpuArchProtocolGuid, NULL, (VOID **) &Cpu);
82
83 if (EFI_ERROR (Status)) {
84 return Status;
85 }
86
87 Status = Cpu->GetTimerValue (Cpu, 0, &CurrentTick, (UINT64 *) &TimerPeriod);
88
89 if (EFI_ERROR (Status)) {
90 //
91 // For NT32 Simulator only. 358049 is a similar value to keep timer granularity.
92 // Set the timer period by ourselves.
93 //
94 TimerPeriod = NTTIMERPERIOD;
95 }
96 //
97 // The timer period is in femtosecond (1 femtosecond is 1e-15 second).
98 // So 1e+12 is divided by timer period to produce the freq in tick/ms.
99 //
100 mFrequency = (UINT32) DivU64x32 (1000000000000ULL, TimerPeriod);
101
102 return EFI_SUCCESS;
103 }
104
105 /**
106 Get and caculate the duration in ms.
107
108 @param[in] Begin The start point of time.
109 @param[in] End The end point of time.
110
111 @return The duration in ms.
112
113 **/
114 UINT32
115 Ping6CalculateTick (
116 IN UINT64 Begin,
117 IN UINT64 End
118 )
119 {
120 ASSERT (End > Begin);
121 return (UINT32) DivU64x32 (End - Begin, mFrequency);
122 }
123
124 /**
125 Destroy IPING6_ICMP6_TX_INFO, and recollect the memory.
126
127 @param[in] TxInfo The pointer to PING6_ICMP6_TX_INFO.
128
129 **/
130 VOID
131 Ping6DestroyTxInfo (
132 IN PING6_ICMP6_TX_INFO *TxInfo
133 )
134 {
135 EFI_IP6_TRANSMIT_DATA *TxData;
136 EFI_IP6_FRAGMENT_DATA *FragData;
137 UINTN Index;
138
139 ASSERT (TxInfo != NULL);
140
141 if (TxInfo->Token != NULL) {
142
143 if (TxInfo->Token->Event != NULL) {
144 gBS->CloseEvent (TxInfo->Token->Event);
145 }
146
147 TxData = TxInfo->Token->Packet.TxData;
148 if (TxData != NULL) {
149
150 if (TxData->OverrideData != NULL) {
151 FreePool (TxData->OverrideData);
152 }
153
154 if (TxData->ExtHdrs != NULL) {
155 FreePool (TxData->ExtHdrs);
156 }
157
158 for (Index = 0; Index < TxData->FragmentCount; Index++) {
159 FragData = TxData->FragmentTable[Index].FragmentBuffer;
160 if (FragData != NULL) {
161 FreePool (FragData);
162 }
163 }
164 }
165
166 FreePool (TxInfo->Token);
167 }
168
169 FreePool (TxInfo);
170 }
171
172 /**
173 Match the request, and reply with SequenceNum/TimeStamp.
174
175 @param[in] Private The pointer to PING6_PRIVATE_DATA.
176 @param[in] Packet The pointer to ICMP6_ECHO_REQUEST_REPLY.
177
178 @retval EFI_SUCCESS The match is successful.
179 @retval EFI_NOT_FOUND The reply can't be matched with any request.
180
181 **/
182 EFI_STATUS
183 Ping6MatchEchoReply (
184 IN PING6_PRIVATE_DATA *Private,
185 IN ICMP6_ECHO_REQUEST_REPLY *Packet
186 )
187 {
188 PING6_ICMP6_TX_INFO *TxInfo;
189 LIST_ENTRY *Entry;
190 LIST_ENTRY *NextEntry;
191
192 NET_LIST_FOR_EACH_SAFE (Entry, NextEntry, &Private->TxList) {
193 TxInfo = BASE_CR (Entry, PING6_ICMP6_TX_INFO, Link);
194
195 if ((TxInfo->SequenceNum == Packet->SequenceNum) && (TxInfo->TimeStamp == Packet->TimeStamp)) {
196 Private->RxCount++;
197 RemoveEntryList (&TxInfo->Link);
198 Ping6DestroyTxInfo (TxInfo);
199 return EFI_SUCCESS;
200 }
201 }
202
203 return EFI_NOT_FOUND;
204 }
205
206 /**
207 The original intention is to send a request.
208 Currently, the application retransmits an icmp6 echo request packet
209 per second in sendnumber times that is specified by the user.
210 Because nothing can be done here, all things move to the timer rountine.
211
212 @param[in] Event A EFI_EVENT type event.
213 @param[in] Context The pointer to Context.
214
215 **/
216 VOID
217 EFIAPI
218 Ping6OnEchoRequestSent (
219 IN EFI_EVENT Event,
220 IN VOID *Context
221 )
222 {
223 }
224
225 /**
226 receive reply, match and print reply infomation.
227
228 @param[in] Event A EFI_EVENT type event.
229 @param[in] Context The pointer to context.
230
231 **/
232 VOID
233 EFIAPI
234 Ping6OnEchoReplyReceived (
235 IN EFI_EVENT Event,
236 IN VOID *Context
237 )
238 {
239 EFI_STATUS Status;
240 PING6_PRIVATE_DATA *Private;
241 EFI_IP6_COMPLETION_TOKEN *RxToken;
242 EFI_IP6_RECEIVE_DATA *RxData;
243 ICMP6_ECHO_REQUEST_REPLY *Reply;
244 UINT32 PayLoad;
245 UINT32 Rtt;
246 CHAR8 Near;
247
248 Private = (PING6_PRIVATE_DATA *) Context;
249
250 if (Private->Status == EFI_ABORTED) {
251 return;
252 }
253
254 RxToken = &Private->RxToken;
255 RxData = RxToken->Packet.RxData;
256 Reply = RxData->FragmentTable[0].FragmentBuffer;
257 PayLoad = RxData->DataLength;
258
259 if (RxData->Header->NextHeader != IP6_ICMP) {
260 goto ON_EXIT;
261 }
262
263 if (!IP6_IS_MULTICAST (&Private->DstAddress) &&
264 !EFI_IP6_EQUAL (&RxData->Header->SourceAddress, &Private->DstAddress)) {
265 goto ON_EXIT;
266 }
267
268 if ((Reply->Type != ICMP_V6_ECHO_REPLY) || (Reply->Code != 0)) {
269 goto ON_EXIT;
270 }
271
272 if (PayLoad != Private->BufferSize) {
273 goto ON_EXIT;
274 }
275 //
276 // Check whether the reply matches the sent request before.
277 //
278 Status = Ping6MatchEchoReply (Private, Reply);
279 if (EFI_ERROR(Status)) {
280 goto ON_EXIT;
281 }
282 //
283 // Display statistics on this icmp6 echo reply packet.
284 //
285 Rtt = Ping6CalculateTick (Reply->TimeStamp, ReadTime ());
286 if (Rtt != 0) {
287 Near = (CHAR8) '=';
288 } else {
289 Near = (CHAR8) '<';
290 }
291
292 Private->RttSum += Rtt;
293 Private->RttMin = Private->RttMin > Rtt ? Rtt : Private->RttMin;
294 Private->RttMax = Private->RttMax < Rtt ? Rtt : Private->RttMax;
295
296 ShellPrintHiiEx (
297 -1,
298 -1,
299 NULL,
300 STRING_TOKEN (STR_PING6_REPLY_INFO),
301 mHiiHandle,
302 PayLoad,
303 mIp6DstString,
304 Reply->SequenceNum,
305 RxData->Header->HopLimit,
306 Near,
307 Rtt
308 );
309
310 ON_EXIT:
311
312 if (Private->RxCount < Private->SendNum) {
313 //
314 // Continue to receive icmp6 echo reply packets.
315 //
316 RxToken->Status = EFI_ABORTED;
317
318 Status = Private->Ip6->Receive (Private->Ip6, RxToken);
319
320 if (EFI_ERROR (Status)) {
321 Private->Status = EFI_ABORTED;
322 }
323 } else {
324 //
325 // All reply have already been received from the dest host.
326 //
327 Private->Status = EFI_SUCCESS;
328 }
329 //
330 // Singal to recycle the each rxdata here, not at the end of process.
331 //
332 gBS->SignalEvent (RxData->RecycleSignal);
333 }
334
335 /**
336 Initial EFI_IP6_COMPLETION_TOKEN.
337
338 @param[in] Private The pointer of PING6_PRIVATE_DATA.
339 @param[in] TimeStamp The TimeStamp of request.
340 @param[in] SequenceNum The SequenceNum of request.
341
342 @return The pointer of EFI_IP6_COMPLETION_TOKEN.
343
344 **/
345 EFI_IP6_COMPLETION_TOKEN *
346 Ping6GenerateToken (
347 IN PING6_PRIVATE_DATA *Private,
348 IN UINT64 TimeStamp,
349 IN UINT16 SequenceNum
350 )
351 {
352 EFI_STATUS Status;
353 EFI_IP6_COMPLETION_TOKEN *Token;
354 EFI_IP6_TRANSMIT_DATA *TxData;
355 ICMP6_ECHO_REQUEST_REPLY *Request;
356
357 Request = AllocateZeroPool (Private->BufferSize);
358
359 if (Request == NULL) {
360 return NULL;
361 }
362 //
363 // Assembly icmp6 echo request packet.
364 //
365 Request->Type = ICMP_V6_ECHO_REQUEST;
366 Request->Code = 0;
367 Request->SequenceNum = SequenceNum;
368 Request->TimeStamp = TimeStamp;
369 Request->Identifier = 0;
370 //
371 // Leave check sum to ip6 layer, since it has no idea of source address
372 // selection.
373 //
374 Request->Checksum = 0;
375
376 TxData = AllocateZeroPool (sizeof (EFI_IP6_TRANSMIT_DATA));
377
378 if (TxData == NULL) {
379 FreePool (Request);
380 return NULL;
381 }
382 //
383 // Assembly ipv6 token for transmit.
384 //
385 TxData->OverrideData = 0;
386 TxData->ExtHdrsLength = 0;
387 TxData->ExtHdrs = NULL;
388 TxData->DataLength = Private->BufferSize;
389 TxData->FragmentCount = 1;
390 TxData->FragmentTable[0].FragmentBuffer = (VOID *) Request;
391 TxData->FragmentTable[0].FragmentLength = Private->BufferSize;
392
393 Token = AllocateZeroPool (sizeof (EFI_IP6_COMPLETION_TOKEN));
394
395 if (Token == NULL) {
396 FreePool (Request);
397 FreePool (TxData);
398 return NULL;
399 }
400
401 Token->Status = EFI_ABORTED;
402 Token->Packet.TxData = TxData;
403
404 Status = gBS->CreateEvent (
405 EVT_NOTIFY_SIGNAL,
406 TPL_CALLBACK,
407 Ping6OnEchoRequestSent,
408 Private,
409 &Token->Event
410 );
411
412 if (EFI_ERROR (Status)) {
413 FreePool (Request);
414 FreePool (TxData);
415 FreePool (Token);
416 return NULL;
417 }
418
419 return Token;
420 }
421
422 /**
423 Transmit the EFI_IP6_COMPLETION_TOKEN.
424
425 @param[in] Private The pointer of PING6_PRIVATE_DATA.
426
427 @retval EFI_SUCCESS Transmitted successfully.
428 @retval EFI_OUT_OF_RESOURCES No memory is available on the platform.
429 @retval others Transmitted unsuccessfully.
430
431 **/
432 EFI_STATUS
433 Ping6SendEchoRequest (
434 IN PING6_PRIVATE_DATA *Private
435 )
436 {
437 EFI_STATUS Status;
438 PING6_ICMP6_TX_INFO *TxInfo;
439
440 TxInfo = AllocateZeroPool (sizeof (PING6_ICMP6_TX_INFO));
441
442 if (TxInfo == NULL) {
443 return EFI_OUT_OF_RESOURCES;
444 }
445
446 TxInfo->TimeStamp = ReadTime ();
447 TxInfo->SequenceNum = (UINT16) (Private->TxCount + 1);
448
449 TxInfo->Token = Ping6GenerateToken (
450 Private,
451 TxInfo->TimeStamp,
452 TxInfo->SequenceNum
453 );
454
455 if (TxInfo->Token == NULL) {
456 Ping6DestroyTxInfo (TxInfo);
457 return EFI_OUT_OF_RESOURCES;
458 }
459
460 Status = Private->Ip6->Transmit (Private->Ip6, TxInfo->Token);
461
462 if (EFI_ERROR (Status)) {
463 Ping6DestroyTxInfo (TxInfo);
464 return Status;
465 }
466
467 InsertTailList (&Private->TxList, &TxInfo->Link);
468 Private->TxCount++;
469
470 return EFI_SUCCESS;
471 }
472
473 /**
474 Place a completion token into the receive packet queue to receive the echo reply.
475
476 @param[in] Private The pointer of PING6_PRIVATE_DATA.
477
478 @retval EFI_SUCCESS Put the token into the receive packet queue successfully.
479 @retval others Put the token into the receive packet queue unsuccessfully.
480
481 **/
482 EFI_STATUS
483 Ping6ReceiveEchoReply (
484 IN PING6_PRIVATE_DATA *Private
485 )
486 {
487 EFI_STATUS Status;
488
489 ZeroMem (&Private->RxToken, sizeof (EFI_IP6_COMPLETION_TOKEN));
490
491 Status = gBS->CreateEvent (
492 EVT_NOTIFY_SIGNAL,
493 TPL_CALLBACK,
494 Ping6OnEchoReplyReceived,
495 Private,
496 &Private->RxToken.Event
497 );
498
499 if (EFI_ERROR (Status)) {
500 return Status;
501 }
502
503 Private->RxToken.Status = EFI_NOT_READY;
504
505 return Private->Ip6->Receive (Private->Ip6, &Private->RxToken);
506 }
507
508 /**
509 Remove the timeout request from the list.
510
511 @param[in] Event A EFI_EVENT type event.
512 @param[in] Context The pointer to Context.
513
514 **/
515 VOID
516 EFIAPI
517 Ping6OnTimerRoutine (
518 IN EFI_EVENT Event,
519 IN VOID *Context
520 )
521 {
522 EFI_STATUS Status;
523 PING6_PRIVATE_DATA *Private;
524 PING6_ICMP6_TX_INFO *TxInfo;
525 LIST_ENTRY *Entry;
526 LIST_ENTRY *NextEntry;
527 UINT32 Time;
528
529 Private = (PING6_PRIVATE_DATA *) Context;
530
531 //
532 // Retransmit icmp6 echo request packets per second in sendnumber times.
533 //
534 if (Private->TxCount < Private->SendNum) {
535
536 Status = Ping6SendEchoRequest (Private);
537 if (Private->TxCount != 0){
538 if (EFI_ERROR (Status)) {
539 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_PING6_SEND_REQUEST), mHiiHandle, Private->TxCount + 1);
540 }
541 }
542 }
543 //
544 // Check whether any icmp6 echo request in the list timeout.
545 //
546 NET_LIST_FOR_EACH_SAFE (Entry, NextEntry, &Private->TxList) {
547 TxInfo = BASE_CR (Entry, PING6_ICMP6_TX_INFO, Link);
548 Time = Ping6CalculateTick (TxInfo->TimeStamp, ReadTime ());
549
550 //
551 // Remove the timeout echo request from txlist.
552 //
553 if (Time > PING6_DEFAULT_TIMEOUT) {
554
555 if (EFI_ERROR (TxInfo->Token->Status)) {
556 Private->Ip6->Cancel (Private->Ip6, TxInfo->Token);
557 }
558 //
559 // Remove the timeout icmp6 echo request from list.
560 //
561 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_PING6_TIMEOUT), mHiiHandle, TxInfo->SequenceNum);
562
563 RemoveEntryList (&TxInfo->Link);
564 Ping6DestroyTxInfo (TxInfo);
565
566 if (IsListEmpty (&Private->TxList) && (Private->TxCount == Private->SendNum)) {
567 //
568 // All the left icmp6 echo request in the list timeout.
569 //
570 Private->Status = EFI_TIMEOUT;
571 }
572 }
573 }
574 }
575
576 /**
577 Create a valid IP6 instance.
578
579 @param[in] Private The pointer of PING6_PRIVATE_DATA.
580
581 @retval EFI_SUCCESS Create a valid IP6 instance successfully.
582 @retval EFI_ABORTED Locate handle with ip6 service binding protocol unsuccessfully.
583 @retval EFI_INVALID_PARAMETER The source address is unspecified when the destination address is a link -ocal address.
584 @retval EFI_OUT_OF_RESOURCES No memory is available on the platform.
585 @retval EFI_NOT_FOUND The source address is not found.
586 **/
587 EFI_STATUS
588 Ping6CreateIp6Instance (
589 IN PING6_PRIVATE_DATA *Private
590 )
591 {
592 EFI_STATUS Status;
593 UINTN HandleIndex;
594 UINTN HandleNum;
595 EFI_HANDLE *HandleBuffer;
596 EFI_SERVICE_BINDING_PROTOCOL *Ip6Sb;
597 EFI_IP6_CONFIG_PROTOCOL *Ip6Cfg;
598 EFI_IP6_CONFIG_DATA Ip6Config;
599 EFI_IP6_CONFIG_INTERFACE_INFO *IfInfo;
600 UINTN IfInfoSize;
601 EFI_IPv6_ADDRESS *Addr;
602 UINTN AddrIndex;
603
604 HandleBuffer = NULL;
605 Ip6Sb = NULL;
606 IfInfo = NULL;
607 IfInfoSize = 0;
608
609 //
610 // Locate all the handles with ip6 service binding protocol.
611 //
612 Status = gBS->LocateHandleBuffer (
613 ByProtocol,
614 &gEfiIp6ServiceBindingProtocolGuid,
615 NULL,
616 &HandleNum,
617 &HandleBuffer
618 );
619 if (EFI_ERROR (Status) || (HandleNum == 0)) {
620 return EFI_ABORTED;
621 }
622 //
623 // Source address is required when pinging a link-local address on multi-
624 // interfaces host.
625 //
626 if (NetIp6IsLinkLocalAddr (&Private->DstAddress) &&
627 NetIp6IsUnspecifiedAddr (&Private->SrcAddress) &&
628 (HandleNum > 1)) {
629 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_PING6_INVALID_SOURCE), mHiiHandle);
630 Status = EFI_INVALID_PARAMETER;
631 goto ON_ERROR;
632 }
633 //
634 // For each ip6 protocol, check interface addresses list.
635 //
636 for (HandleIndex = 0; HandleIndex < HandleNum; HandleIndex++) {
637
638 Ip6Sb = NULL;
639 IfInfo = NULL;
640 IfInfoSize = 0;
641
642 Status = gBS->HandleProtocol (
643 HandleBuffer[HandleIndex],
644 &gEfiIp6ServiceBindingProtocolGuid,
645 (VOID **) &Ip6Sb
646 );
647 if (EFI_ERROR (Status)) {
648 goto ON_ERROR;
649 }
650
651 if (NetIp6IsUnspecifiedAddr (&Private->SrcAddress)) {
652 //
653 // No need to match interface address.
654 //
655 break;
656 } else {
657 //
658 // Ip6config protocol and ip6 service binding protocol are installed
659 // on the same handle.
660 //
661 Status = gBS->HandleProtocol (
662 HandleBuffer[HandleIndex],
663 &gEfiIp6ConfigProtocolGuid,
664 (VOID **) &Ip6Cfg
665 );
666
667 if (EFI_ERROR (Status)) {
668 goto ON_ERROR;
669 }
670 //
671 // Get the interface information size.
672 //
673 Status = Ip6Cfg->GetData (
674 Ip6Cfg,
675 Ip6ConfigDataTypeInterfaceInfo,
676 &IfInfoSize,
677 NULL
678 );
679
680 if (Status != EFI_BUFFER_TOO_SMALL) {
681 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_PING6_IP6CFG_GETDATA), mHiiHandle, Status);
682 goto ON_ERROR;
683 }
684
685 IfInfo = AllocateZeroPool (IfInfoSize);
686
687 if (IfInfo == NULL) {
688 Status = EFI_OUT_OF_RESOURCES;
689 goto ON_ERROR;
690 }
691 //
692 // Get the interface info.
693 //
694 Status = Ip6Cfg->GetData (
695 Ip6Cfg,
696 Ip6ConfigDataTypeInterfaceInfo,
697 &IfInfoSize,
698 IfInfo
699 );
700
701 if (EFI_ERROR (Status)) {
702 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_PING6_IP6CFG_GETDATA), mHiiHandle, Status);
703 goto ON_ERROR;
704 }
705 //
706 // Check whether the source address is one of the interface addresses.
707 //
708 for (AddrIndex = 0; AddrIndex < IfInfo->AddressInfoCount; AddrIndex++) {
709
710 Addr = &(IfInfo->AddressInfo[AddrIndex].Address);
711 if (EFI_IP6_EQUAL (&Private->SrcAddress, Addr)) {
712 //
713 // Match a certain interface address.
714 //
715 break;
716 }
717 }
718
719 if (AddrIndex < IfInfo->AddressInfoCount) {
720 //
721 // Found a nic handle with right interface address.
722 //
723 break;
724 }
725 }
726
727 FreePool (IfInfo);
728 IfInfo = NULL;
729 }
730 //
731 // No exact interface address matched.
732 //
733
734 if (HandleIndex == HandleNum) {
735 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_PING6_SOURCE_NOT_FOUND), mHiiHandle, mIp6SrcString);
736 Status = EFI_NOT_FOUND;
737 goto ON_ERROR;
738 }
739
740 Private->NicHandle = HandleBuffer[HandleIndex];
741
742 ASSERT (Ip6Sb != NULL);
743 Status = Ip6Sb->CreateChild (Ip6Sb, &Private->Ip6ChildHandle);
744
745 if (EFI_ERROR (Status)) {
746 goto ON_ERROR;
747 }
748
749 Status = gBS->OpenProtocol (
750 Private->Ip6ChildHandle,
751 &gEfiIp6ProtocolGuid,
752 (VOID **) &Private->Ip6,
753 Private->ImageHandle,
754 Private->Ip6ChildHandle,
755 EFI_OPEN_PROTOCOL_GET_PROTOCOL
756 );
757 if (EFI_ERROR (Status)) {
758 goto ON_ERROR;
759 }
760
761 ZeroMem (&Ip6Config, sizeof (EFI_IP6_CONFIG_DATA));
762
763 //
764 // Configure the ip6 instance for icmp6 packet exchange.
765 //
766 Ip6Config.DefaultProtocol = 58;
767 Ip6Config.AcceptAnyProtocol = FALSE;
768 Ip6Config.AcceptIcmpErrors = TRUE;
769 Ip6Config.AcceptPromiscuous = FALSE;
770 Ip6Config.TrafficClass = 0;
771 Ip6Config.HopLimit = 128;
772 Ip6Config.FlowLabel = 0;
773 Ip6Config.ReceiveTimeout = 0;
774 Ip6Config.TransmitTimeout = 0;
775
776 IP6_COPY_ADDRESS (&Ip6Config.StationAddress, &Private->SrcAddress);
777
778 IP6_COPY_ADDRESS (&Ip6Config.DestinationAddress, &Private->DstAddress);
779
780 Status = Private->Ip6->Configure (Private->Ip6, &Ip6Config);
781
782 if (EFI_ERROR (Status)) {
783 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_PING6_IP6_CONFIG), mHiiHandle, Status);
784 goto ON_ERROR;
785 }
786
787 return EFI_SUCCESS;
788
789 ON_ERROR:
790 if (HandleBuffer != NULL) {
791 FreePool (HandleBuffer);
792 }
793
794 if (IfInfo != NULL) {
795 FreePool (IfInfo);
796 }
797
798 if ((Ip6Sb != NULL) && (Private->Ip6ChildHandle != NULL)) {
799 Ip6Sb->DestroyChild (Ip6Sb, Private->Ip6ChildHandle);
800 }
801
802 return Status;
803 }
804
805 /**
806 Destory the IP6 instance.
807
808 @param[in] Private The pointer of PING6_PRIVATE_DATA.
809
810 **/
811 VOID
812 Ping6DestoryIp6Instance (
813 IN PING6_PRIVATE_DATA *Private
814 )
815 {
816 EFI_STATUS Status;
817 EFI_SERVICE_BINDING_PROTOCOL *Ip6Sb;
818
819 gBS->CloseProtocol (
820 Private->Ip6ChildHandle,
821 &gEfiIp6ProtocolGuid,
822 Private->ImageHandle,
823 Private->Ip6ChildHandle
824 );
825
826 Status = gBS->HandleProtocol (
827 Private->NicHandle,
828 &gEfiIp6ServiceBindingProtocolGuid,
829 (VOID **) &Ip6Sb
830 );
831
832 if (!EFI_ERROR(Status)) {
833 Ip6Sb->DestroyChild (Ip6Sb, Private->Ip6ChildHandle);
834 }
835 }
836
837 /**
838 The Ping6 Process.
839
840 @param[in] ImageHandle The firmware allocated handle for the UEFI image.
841 @param[in] SendNumber The send request count.
842 @param[in] BufferSize The send buffer size.
843 @param[in] SrcAddress The source IPv6 address.
844 @param[in] DstAddress The destination IPv6 address.
845
846 @retval EFI_SUCCESS The ping6 processed successfullly.
847 @retval others The ping6 processed unsuccessfully.
848
849 **/
850 EFI_STATUS
851 Ping6 (
852 IN EFI_HANDLE ImageHandle,
853 IN UINT32 SendNumber,
854 IN UINT32 BufferSize,
855 IN EFI_IPv6_ADDRESS *SrcAddress,
856 IN EFI_IPv6_ADDRESS *DstAddress
857 )
858 {
859 EFI_STATUS Status;
860 EFI_INPUT_KEY Key;
861 PING6_PRIVATE_DATA *Private;
862 PING6_ICMP6_TX_INFO *TxInfo;
863 LIST_ENTRY *Entry;
864 LIST_ENTRY *NextEntry;
865
866 Private = AllocateZeroPool (sizeof (PING6_PRIVATE_DATA));
867
868 ASSERT (Private != NULL);
869
870 Private->ImageHandle = ImageHandle;
871 Private->SendNum = SendNumber;
872 Private->BufferSize = BufferSize;
873 Private->RttMin = 0xFFFF;
874 Private->Status = EFI_NOT_READY;
875
876 InitializeListHead (&Private->TxList);
877
878 IP6_COPY_ADDRESS (&Private->SrcAddress, SrcAddress);
879 IP6_COPY_ADDRESS (&Private->DstAddress, DstAddress);
880
881 //
882 // Open and configure a ip6 instance for ping6.
883 //
884 Status = Ping6CreateIp6Instance (Private);
885
886 if (EFI_ERROR (Status)) {
887 goto ON_EXIT;
888 }
889 //
890 // Print the command line itself.
891 //
892 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_PING6_START), mHiiHandle, mIp6DstString, Private->BufferSize);
893 //
894 // Create a ipv6 token to receive the first icmp6 echo reply packet.
895 //
896 Status = Ping6ReceiveEchoReply (Private);
897
898 if (EFI_ERROR (Status)) {
899 goto ON_EXIT;
900 }
901 //
902 // Create and start timer to send icmp6 echo request packet per second.
903 //
904 Status = gBS->CreateEvent (
905 EVT_TIMER | EVT_NOTIFY_SIGNAL,
906 TPL_CALLBACK,
907 Ping6OnTimerRoutine,
908 Private,
909 &Private->Timer
910 );
911
912 if (EFI_ERROR (Status)) {
913 goto ON_EXIT;
914 }
915 //
916 // Create a ipv6 token to send the first icmp6 echo request packet.
917 //
918 Status = Ping6SendEchoRequest (Private);
919 //
920 // EFI_NOT_READY for IPsec is enable and IKE is not established.
921 //
922 if (EFI_ERROR (Status) && (Status != EFI_NOT_READY)) {
923 if(Status == EFI_NOT_FOUND) {
924 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_PING6_NOSOURCE_INDOMAIN), mHiiHandle, mIp6DstString);
925 }
926
927 goto ON_EXIT;
928 }
929
930 Status = gBS->SetTimer (
931 Private->Timer,
932 TimerPeriodic,
933 PING6_ONE_SECOND
934 );
935
936 if (EFI_ERROR (Status)) {
937 goto ON_EXIT;
938 }
939 //
940 // Control the ping6 process by two factors:
941 // 1. Hot key
942 // 2. Private->Status
943 // 2.1. success means all icmp6 echo request packets get reply packets.
944 // 2.2. timeout means the last icmp6 echo reply request timeout to get reply.
945 // 2.3. noready means ping6 process is on-the-go.
946 //
947 while (Private->Status == EFI_NOT_READY) {
948 Private->Ip6->Poll (Private->Ip6);
949
950 //
951 // Terminate the ping6 process by 'esc' or 'ctl-c'.
952 //
953 Status = gST->ConIn->ReadKeyStroke (gST->ConIn, &Key);
954
955 if (!EFI_ERROR(Status)) {
956 if ((Key.UnicodeChar == 0x1b) || (Key.UnicodeChar == 0x03) ||
957 ((Key.UnicodeChar == 0) && (Key.ScanCode == SCAN_ESC))) {
958 goto ON_STAT;
959 }
960 }
961 }
962
963 ON_STAT:
964 //
965 // Display the statistics in all.
966 //
967 gBS->SetTimer (Private->Timer, TimerCancel, 0);
968
969 if (Private->TxCount != 0) {
970 ShellPrintHiiEx (
971 -1,
972 -1,
973 NULL,
974 STRING_TOKEN (STR_PING6_STAT),
975 mHiiHandle,
976 Private->TxCount,
977 Private->RxCount,
978 (100 * (Private->TxCount - Private->RxCount)) / Private->TxCount,
979 Private->RttSum
980 );
981 }
982
983 if (Private->RxCount != 0) {
984 ShellPrintHiiEx (
985 -1,
986 -1,
987 NULL,
988 STRING_TOKEN (STR_PING6_RTT),
989 mHiiHandle,
990 Private->RttMin,
991 Private->RttMax,
992 Private->RttSum / Private->RxCount
993 );
994 }
995
996 ON_EXIT:
997
998 if (Private != NULL) {
999 Private->Status = EFI_ABORTED;
1000
1001 NET_LIST_FOR_EACH_SAFE (Entry, NextEntry, &Private->TxList) {
1002 TxInfo = BASE_CR (Entry, PING6_ICMP6_TX_INFO, Link);
1003
1004 Status = Private->Ip6->Cancel (Private->Ip6, TxInfo->Token);
1005
1006 RemoveEntryList (&TxInfo->Link);
1007 Ping6DestroyTxInfo (TxInfo);
1008 }
1009
1010 if (Private->Timer != NULL) {
1011 gBS->CloseEvent (Private->Timer);
1012 }
1013
1014 if (Private->Ip6 != NULL) {
1015 Status = Private->Ip6->Cancel (Private->Ip6, &Private->RxToken);
1016 }
1017
1018 if (Private->RxToken.Event != NULL) {
1019 gBS->CloseEvent (Private->RxToken.Event);
1020 }
1021
1022 if (Private->Ip6ChildHandle != NULL) {
1023 Ping6DestoryIp6Instance (Private);
1024 }
1025
1026 FreePool (Private);
1027 }
1028
1029 return Status;
1030 }
1031
1032 /**
1033 This is the declaration of an EFI image entry point. This entry point is
1034 the same for UEFI Applications, UEFI OS Loaders, and UEFI Drivers, including
1035 both device drivers and bus drivers.
1036
1037 The entry point for the Ping6 application that parses the command line input and calls the Ping6 process.
1038
1039 @param[in] ImageHandle The firmware allocated handle for the UEFI image.
1040 @param[in] SystemTable A pointer to the EFI System Table.
1041
1042 @retval EFI_SUCCESS The operation completed successfully.
1043 @retval EFI_INVALID_PARAMETETR Input parameters combination is invalid.
1044 @retval Others Some errors occur.
1045
1046 **/
1047 EFI_STATUS
1048 EFIAPI
1049 InitializePing6 (
1050 IN EFI_HANDLE ImageHandle,
1051 IN EFI_SYSTEM_TABLE *SystemTable
1052 )
1053 {
1054 EFI_STATUS Status;
1055 EFI_IPv6_ADDRESS DstAddress;
1056 EFI_IPv6_ADDRESS SrcAddress;
1057 UINT64 BufferSize;
1058 UINTN SendNumber;
1059 LIST_ENTRY *ParamPackage;
1060 CONST CHAR16 *ValueStr;
1061 CONST CHAR16 *ValueStrPtr;
1062 UINTN NonOptionCount;
1063
1064 //
1065 // Register our string package with HII and return the handle to it.
1066 //
1067 mHiiHandle = HiiAddPackages (&gEfiCallerIdGuid, ImageHandle, Ping6Strings, NULL);
1068 ASSERT (mHiiHandle != NULL);
1069
1070 Status = ShellCommandLineParseEx (Ping6ParamList, &ParamPackage, NULL, TRUE, FALSE);
1071 if (EFI_ERROR(Status)) {
1072 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_PING6_INVALID_INPUT), mHiiHandle);
1073 goto ON_EXIT;
1074 }
1075
1076 if (ShellCommandLineGetFlag (ParamPackage, L"-?")) {
1077 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_PING6_HELP), mHiiHandle);
1078 goto ON_EXIT;
1079 }
1080
1081 SendNumber = 10;
1082 BufferSize = 16;
1083
1084 //
1085 // Parse the paramter of count number.
1086 //
1087 ValueStr = ShellCommandLineGetValue (ParamPackage, L"-n");
1088 ValueStrPtr = ValueStr;
1089 if (ValueStr != NULL) {
1090 SendNumber = ShellStrToUintn (ValueStrPtr);
1091
1092 //
1093 // ShellStrToUintn will return 0 when input is 0 or an invalid input string.
1094 //
1095 if ((SendNumber == 0) || (SendNumber > PING6_MAX_SEND_NUMBER)) {
1096 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_PING6_INVALID_SEND_NUMBER), mHiiHandle, ValueStr);
1097 Status = EFI_INVALID_PARAMETER;
1098 goto ON_EXIT;
1099 }
1100 }
1101 //
1102 // Parse the paramter of buffer size.
1103 //
1104 ValueStr = ShellCommandLineGetValue (ParamPackage, L"-l");
1105 ValueStrPtr = ValueStr;
1106 if (ValueStr != NULL) {
1107 BufferSize = ShellStrToUintn (ValueStrPtr);
1108
1109 //
1110 // ShellStrToUintn will return 0 when input is 0 or an invalid input string.
1111 //
1112 if ((BufferSize < 16) || (BufferSize > PING6_MAX_BUFFER_SIZE)) {
1113 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_PING6_INVALID_BUFFER_SIZE), mHiiHandle, ValueStr);
1114 Status = EFI_INVALID_PARAMETER;
1115 goto ON_EXIT;
1116 }
1117 }
1118
1119 ZeroMem (&SrcAddress, sizeof (EFI_IPv6_ADDRESS));
1120 ZeroMem (&DstAddress, sizeof (EFI_IPv6_ADDRESS));
1121
1122 //
1123 // Parse the paramter of source ip address.
1124 //
1125 ValueStr = ShellCommandLineGetValue (ParamPackage, L"-s");
1126 ValueStrPtr = ValueStr;
1127 if (ValueStr != NULL) {
1128 mIp6SrcString = ValueStr;
1129 Status = NetLibStrToIp6 (ValueStrPtr, &SrcAddress);
1130 if (EFI_ERROR (Status)) {
1131 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_PING6_INVALID_IP), mHiiHandle, ValueStr);
1132 Status = EFI_INVALID_PARAMETER;
1133 goto ON_EXIT;
1134 }
1135 }
1136 //
1137 // Parse the paramter of destination ip address.
1138 //
1139 NonOptionCount = ShellCommandLineGetCount(ParamPackage);
1140 ValueStr = ShellCommandLineGetRawValue (ParamPackage, (UINT32)(NonOptionCount-1));
1141 if (NonOptionCount != 2) {
1142 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_PING6_INVALID_INPUT), mHiiHandle);
1143 Status = EFI_INVALID_PARAMETER;
1144 goto ON_EXIT;
1145 }
1146 ValueStrPtr = ValueStr;
1147 if (ValueStr != NULL) {
1148 mIp6DstString = ValueStr;
1149 Status = NetLibStrToIp6 (ValueStrPtr, &DstAddress);
1150 if (EFI_ERROR (Status)) {
1151 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_PING6_INVALID_IP), mHiiHandle, ValueStr);
1152 Status = EFI_INVALID_PARAMETER;
1153 goto ON_EXIT;
1154 }
1155 }
1156 //
1157 // Get frequency to calculate the time from ticks.
1158 //
1159 Status = Ping6GetFrequency ();
1160
1161 if (EFI_ERROR(Status)) {
1162 goto ON_EXIT;
1163 }
1164 //
1165 // Enter into ping6 process.
1166 //
1167 Status = Ping6 (
1168 ImageHandle,
1169 (UINT32)SendNumber,
1170 (UINT32)BufferSize,
1171 &SrcAddress,
1172 &DstAddress
1173 );
1174
1175 ON_EXIT:
1176 ShellCommandLineFreeVarList (ParamPackage);
1177 HiiRemovePackages (mHiiHandle);
1178 return Status;
1179 }