ShellPkg/DynamicCommand: Fix bug that cannot start in boot
[mirror_edk2.git] / ShellPkg / DynamicCommand / TftpDynamicCommand / Tftp.c
1 /** @file
2 The implementation for the 'tftp' Shell command.
3
4 Copyright (c) 2015, ARM Ltd. All rights reserved.<BR>
5 Copyright (c) 2015 - 2017, Intel Corporation. All rights reserved. <BR>
6 (C) Copyright 2015 Hewlett Packard Enterprise Development LP<BR>
7
8 This program and the accompanying materials
9 are licensed and made available under the terms and conditions of the BSD License
10 which accompanies this distribution. The full text of the license may be found at
11 http://opensource.org/licenses/bsd-license.php.
12
13 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
14 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
15 **/
16
17 #include "Tftp.h"
18
19 #define IP4_CONFIG2_INTERFACE_INFO_NAME_LENGTH 32
20 EFI_HANDLE mTftpHiiHandle;
21
22 /*
23 Constant strings and definitions related to the message indicating the amount of
24 progress in the dowloading of a TFTP file.
25 */
26
27 // Frame for the progression slider
28 STATIC CONST CHAR16 mTftpProgressFrame[] = L"[ ]";
29
30 // Number of steps in the progression slider
31 #define TFTP_PROGRESS_SLIDER_STEPS ((sizeof (mTftpProgressFrame) / sizeof (CHAR16)) - 3)
32
33 // Size in number of characters plus one (final zero) of the message to
34 // indicate the progress of a TFTP download. The format is "[(progress slider:
35 // 40 characters)] (nb of KBytes downloaded so far: 7 characters) Kb". There
36 // are thus the number of characters in mTftpProgressFrame[] plus 11 characters
37 // (2 // spaces, "Kb" and seven characters for the number of KBytes).
38 #define TFTP_PROGRESS_MESSAGE_SIZE ((sizeof (mTftpProgressFrame) / sizeof (CHAR16)) + 12)
39
40 // String to delete the TFTP progress message to be able to update it :
41 // (TFTP_PROGRESS_MESSAGE_SIZE-1) '\b'
42 STATIC CONST CHAR16 mTftpProgressDelete[] = L"\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b";
43
44 /**
45 Check and convert the UINT16 option values of the 'tftp' command
46
47 @param[in] ValueStr Value as an Unicode encoded string
48 @param[out] Value UINT16 value
49
50 @return TRUE The value was returned.
51 @return FALSE A parsing error occured.
52 **/
53 STATIC
54 BOOLEAN
55 StringToUint16 (
56 IN CONST CHAR16 *ValueStr,
57 OUT UINT16 *Value
58 );
59
60 /**
61 Get the name of the NIC.
62
63 @param[in] ControllerHandle The network physical device handle.
64 @param[in] NicNumber The network physical device number.
65 @param[out] NicName Address where to store the NIC name.
66 The memory area has to be at least
67 IP4_CONFIG2_INTERFACE_INFO_NAME_LENGTH
68 double byte wide.
69
70 @return EFI_SUCCESS The name of the NIC was returned.
71 @return Others The creation of the child for the Managed
72 Network Service failed or the opening of
73 the Managed Network Protocol failed or
74 the operational parameters for the
75 Managed Network Protocol could not be
76 read.
77 **/
78 STATIC
79 EFI_STATUS
80 GetNicName (
81 IN EFI_HANDLE ControllerHandle,
82 IN UINTN NicNumber,
83 OUT CHAR16 *NicName
84 );
85
86 /**
87 Create a child for the service identified by its service binding protocol GUID
88 and get from the child the interface of the protocol identified by its GUID.
89
90 @param[in] ControllerHandle Controller handle.
91 @param[in] ServiceBindingProtocolGuid Service binding protocol GUID of the
92 service to be created.
93 @param[in] ProtocolGuid GUID of the protocol to be open.
94 @param[out] ChildHandle Address where the handler of the
95 created child is returned. NULL is
96 returned in case of error.
97 @param[out] Interface Address where a pointer to the
98 protocol interface is returned in
99 case of success.
100
101 @return EFI_SUCCESS The child was created and the protocol opened.
102 @return Others Either the creation of the child or the opening
103 of the protocol failed.
104 **/
105 STATIC
106 EFI_STATUS
107 CreateServiceChildAndOpenProtocol (
108 IN EFI_HANDLE ControllerHandle,
109 IN EFI_GUID *ServiceBindingProtocolGuid,
110 IN EFI_GUID *ProtocolGuid,
111 OUT EFI_HANDLE *ChildHandle,
112 OUT VOID **Interface
113 );
114
115 /**
116 Close the protocol identified by its GUID on the child handle of the service
117 identified by its service binding protocol GUID, then destroy the child
118 handle.
119
120 @param[in] ControllerHandle Controller handle.
121 @param[in] ServiceBindingProtocolGuid Service binding protocol GUID of the
122 service to be destroyed.
123 @param[in] ProtocolGuid GUID of the protocol to be closed.
124 @param[in] ChildHandle Handle of the child to be destroyed.
125
126 **/
127 STATIC
128 VOID
129 CloseProtocolAndDestroyServiceChild (
130 IN EFI_HANDLE ControllerHandle,
131 IN EFI_GUID *ServiceBindingProtocolGuid,
132 IN EFI_GUID *ProtocolGuid,
133 IN EFI_HANDLE ChildHandle
134 );
135
136 /**
137 Worker function that gets the size in numbers of bytes of a file from a TFTP
138 server before to download the file.
139
140 @param[in] Mtftp4 MTFTP4 protocol interface
141 @param[in] FilePath Path of the file, ASCII encoded
142 @param[out] FileSize Address where to store the file size in number of
143 bytes.
144
145 @retval EFI_SUCCESS The size of the file was returned.
146 @retval EFI_UNSUPPORTED The server does not support the "tsize" option.
147 @retval Others Error when retrieving the information from the server
148 (see EFI_MTFTP4_PROTOCOL.GetInfo() status codes)
149 or error when parsing the response of the server.
150 **/
151 STATIC
152 EFI_STATUS
153 GetFileSize (
154 IN EFI_MTFTP4_PROTOCOL *Mtftp4,
155 IN CONST CHAR8 *FilePath,
156 OUT UINTN *FileSize
157 );
158
159 /**
160 Worker function that download the data of a file from a TFTP server given
161 the path of the file and its size.
162
163 @param[in] Mtftp4 MTFTP4 protocol interface
164 @param[in] FilePath Path of the file, Unicode encoded
165 @param[in] AsciiFilePath Path of the file, ASCII encoded
166 @param[in] FileSize Size of the file in number of bytes
167 @param[in] BlockSize Value of the TFTP blksize option
168 @param[out] Data Address where to store the address of the buffer
169 where the data of the file were downloaded in
170 case of success.
171
172 @retval EFI_SUCCESS The file was downloaded.
173 @retval EFI_OUT_OF_RESOURCES A memory allocation failed.
174 @retval Others The downloading of the file from the server failed
175 (see EFI_MTFTP4_PROTOCOL.ReadFile() status codes).
176
177 **/
178 STATIC
179 EFI_STATUS
180 DownloadFile (
181 IN EFI_MTFTP4_PROTOCOL *Mtftp4,
182 IN CONST CHAR16 *FilePath,
183 IN CONST CHAR8 *AsciiFilePath,
184 IN UINTN FileSize,
185 IN UINT16 BlockSize,
186 OUT VOID **Data
187 );
188
189 /**
190 Update the progress of a file download
191 This procedure is called each time a new TFTP packet is received.
192
193 @param[in] This MTFTP4 protocol interface
194 @param[in] Token Parameters for the download of the file
195 @param[in] PacketLen Length of the packet
196 @param[in] Packet Address of the packet
197
198 @retval EFI_SUCCESS All packets are accepted.
199
200 **/
201 STATIC
202 EFI_STATUS
203 EFIAPI
204 CheckPacket (
205 IN EFI_MTFTP4_PROTOCOL *This,
206 IN EFI_MTFTP4_TOKEN *Token,
207 IN UINT16 PacketLen,
208 IN EFI_MTFTP4_PACKET *Packet
209 );
210
211 EFI_MTFTP4_CONFIG_DATA DefaultMtftp4ConfigData = {
212 TRUE, // Use default setting
213 { { 0, 0, 0, 0 } }, // StationIp - Not relevant as UseDefaultSetting=TRUE
214 { { 0, 0, 0, 0 } }, // SubnetMask - Not relevant as UseDefaultSetting=TRUE
215 0, // LocalPort - Automatically assigned port number.
216 { { 0, 0, 0, 0 } }, // GatewayIp - Not relevant as UseDefaultSetting=TRUE
217 { { 0, 0, 0, 0 } }, // ServerIp - Not known yet
218 69, // InitialServerPort - Standard TFTP server port
219 6, // TryCount - Max number of retransmissions.
220 4 // TimeoutValue - Retransmission timeout in seconds.
221 };
222
223 STATIC CONST SHELL_PARAM_ITEM ParamList[] = {
224 {L"-i", TypeValue},
225 {L"-l", TypeValue},
226 {L"-r", TypeValue},
227 {L"-c", TypeValue},
228 {L"-t", TypeValue},
229 {L"-s", TypeValue},
230 {NULL , TypeMax}
231 };
232
233 ///
234 /// The default block size (512) of tftp is defined in the RFC1350.
235 ///
236 #define MTFTP_DEFAULT_BLKSIZE 512
237 ///
238 /// The valid range of block size option is defined in the RFC2348.
239 ///
240 #define MTFTP_MIN_BLKSIZE 8
241 #define MTFTP_MAX_BLKSIZE 65464
242
243
244 /**
245 Function for 'tftp' command.
246
247 @param[in] ImageHandle Handle to the Image (NULL if Internal).
248 @param[in] SystemTable Pointer to the System Table (NULL if Internal).
249
250 @return SHELL_SUCCESS The 'tftp' command completed successfully.
251 @return SHELL_ABORTED The Shell Library initialization failed.
252 @return SHELL_INVALID_PARAMETER At least one of the command's arguments is
253 not valid.
254 @return SHELL_OUT_OF_RESOURCES A memory allocation failed.
255 @return SHELL_NOT_FOUND Network Interface Card not found or server
256 error or file error.
257
258 **/
259 SHELL_STATUS
260 RunTftp (
261 IN EFI_HANDLE ImageHandle,
262 IN EFI_SYSTEM_TABLE *SystemTable
263 )
264 {
265 SHELL_STATUS ShellStatus;
266 EFI_STATUS Status;
267 LIST_ENTRY *CheckPackage;
268 CHAR16 *ProblemParam;
269 UINTN ParamCount;
270 CONST CHAR16 *UserNicName;
271 BOOLEAN NicFound;
272 CONST CHAR16 *ValueStr;
273 CONST CHAR16 *RemoteFilePath;
274 CHAR8 *AsciiRemoteFilePath;
275 UINTN FilePathSize;
276 CONST CHAR16 *Walker;
277 CONST CHAR16 *LocalFilePath;
278 EFI_MTFTP4_CONFIG_DATA Mtftp4ConfigData;
279 EFI_HANDLE *Handles;
280 UINTN HandleCount;
281 UINTN NicNumber;
282 CHAR16 NicName[IP4_CONFIG2_INTERFACE_INFO_NAME_LENGTH];
283 EFI_HANDLE ControllerHandle;
284 EFI_HANDLE Mtftp4ChildHandle;
285 EFI_MTFTP4_PROTOCOL *Mtftp4;
286 UINTN FileSize;
287 UINTN DataSize;
288 VOID *Data;
289 SHELL_FILE_HANDLE FileHandle;
290 UINT16 BlockSize;
291
292 ShellStatus = SHELL_INVALID_PARAMETER;
293 ProblemParam = NULL;
294 NicFound = FALSE;
295 AsciiRemoteFilePath = NULL;
296 Handles = NULL;
297 FileSize = 0;
298 DataSize = 0;
299 BlockSize = MTFTP_DEFAULT_BLKSIZE;
300
301 //
302 // Initialize the Shell library (we must be in non-auto-init...)
303 //
304 Status = ShellInitialize ();
305 if (EFI_ERROR (Status)) {
306 ASSERT_EFI_ERROR (Status);
307 return SHELL_ABORTED;
308 }
309
310 //
311 // Parse the command line.
312 //
313 Status = ShellCommandLineParse (ParamList, &CheckPackage, &ProblemParam, TRUE);
314 if (EFI_ERROR (Status)) {
315 if ((Status == EFI_VOLUME_CORRUPTED) &&
316 (ProblemParam != NULL) ) {
317 ShellPrintHiiEx (
318 -1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), mTftpHiiHandle,
319 L"tftp", ProblemParam
320 );
321 FreePool (ProblemParam);
322 } else {
323 ASSERT (FALSE);
324 }
325 goto Error;
326 }
327
328 //
329 // Check the number of parameters
330 //
331 ParamCount = ShellCommandLineGetCount (CheckPackage);
332 if (ParamCount > 4) {
333 ShellPrintHiiEx (
334 -1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY),
335 mTftpHiiHandle, L"tftp"
336 );
337 goto Error;
338 }
339 if (ParamCount < 3) {
340 ShellPrintHiiEx (
341 -1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW),
342 mTftpHiiHandle, L"tftp"
343 );
344 goto Error;
345 }
346
347 CopyMem (&Mtftp4ConfigData, &DefaultMtftp4ConfigData, sizeof (EFI_MTFTP4_CONFIG_DATA));
348
349 //
350 // Check the host IPv4 address
351 //
352 ValueStr = ShellCommandLineGetRawValue (CheckPackage, 1);
353 Status = NetLibStrToIp4 (ValueStr, &Mtftp4ConfigData.ServerIp);
354 if (EFI_ERROR (Status)) {
355 ShellPrintHiiEx (
356 -1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV),
357 mTftpHiiHandle, L"tftp", ValueStr
358 );
359 goto Error;
360 }
361
362 RemoteFilePath = ShellCommandLineGetRawValue (CheckPackage, 2);
363 ASSERT(RemoteFilePath != NULL);
364 FilePathSize = StrLen (RemoteFilePath) + 1;
365 AsciiRemoteFilePath = AllocatePool (FilePathSize);
366 if (AsciiRemoteFilePath == NULL) {
367 ShellStatus = SHELL_OUT_OF_RESOURCES;
368 goto Error;
369 }
370 UnicodeStrToAsciiStrS (RemoteFilePath, AsciiRemoteFilePath, FilePathSize);
371
372 if (ParamCount == 4) {
373 LocalFilePath = ShellCommandLineGetRawValue (CheckPackage, 3);
374 } else {
375 Walker = RemoteFilePath + StrLen (RemoteFilePath);
376 while ((--Walker) >= RemoteFilePath) {
377 if ((*Walker == L'\\') ||
378 (*Walker == L'/' ) ) {
379 break;
380 }
381 }
382 LocalFilePath = Walker + 1;
383 }
384
385 //
386 // Get the name of the Network Interface Card to be used if any.
387 //
388 UserNicName = ShellCommandLineGetValue (CheckPackage, L"-i");
389
390 ValueStr = ShellCommandLineGetValue (CheckPackage, L"-l");
391 if (ValueStr != NULL) {
392 if (!StringToUint16 (ValueStr, &Mtftp4ConfigData.LocalPort)) {
393 goto Error;
394 }
395 }
396
397 ValueStr = ShellCommandLineGetValue (CheckPackage, L"-r");
398 if (ValueStr != NULL) {
399 if (!StringToUint16 (ValueStr, &Mtftp4ConfigData.InitialServerPort)) {
400 goto Error;
401 }
402 }
403
404 ValueStr = ShellCommandLineGetValue (CheckPackage, L"-c");
405 if (ValueStr != NULL) {
406 if (!StringToUint16 (ValueStr, &Mtftp4ConfigData.TryCount)) {
407 goto Error;
408 }
409 }
410
411 ValueStr = ShellCommandLineGetValue (CheckPackage, L"-t");
412 if (ValueStr != NULL) {
413 if (!StringToUint16 (ValueStr, &Mtftp4ConfigData.TimeoutValue)) {
414 goto Error;
415 }
416 if (Mtftp4ConfigData.TimeoutValue == 0) {
417 ShellPrintHiiEx (
418 -1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV),
419 mTftpHiiHandle, L"tftp", ValueStr
420 );
421 goto Error;
422 }
423 }
424
425 ValueStr = ShellCommandLineGetValue (CheckPackage, L"-s");
426 if (ValueStr != NULL) {
427 if (!StringToUint16 (ValueStr, &BlockSize)) {
428 goto Error;
429 }
430 if (BlockSize < MTFTP_MIN_BLKSIZE || BlockSize > MTFTP_MAX_BLKSIZE) {
431 ShellPrintHiiEx (
432 -1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV),
433 mTftpHiiHandle, L"tftp", ValueStr
434 );
435 goto Error;
436 }
437 }
438
439 //
440 // Locate all MTFTP4 Service Binding protocols
441 //
442 ShellStatus = SHELL_NOT_FOUND;
443 Status = gBS->LocateHandleBuffer (
444 ByProtocol,
445 &gEfiManagedNetworkServiceBindingProtocolGuid,
446 NULL,
447 &HandleCount,
448 &Handles
449 );
450 if (EFI_ERROR (Status) || (HandleCount == 0)) {
451 ShellPrintHiiEx (
452 -1, -1, NULL, STRING_TOKEN (STR_TFTP_ERR_NO_NIC),
453 mTftpHiiHandle
454 );
455 goto Error;
456 }
457
458 for (NicNumber = 0;
459 (NicNumber < HandleCount) && (ShellStatus != SHELL_SUCCESS);
460 NicNumber++) {
461 ControllerHandle = Handles[NicNumber];
462 Data = NULL;
463
464 Status = GetNicName (ControllerHandle, NicNumber, NicName);
465 if (EFI_ERROR (Status)) {
466 ShellPrintHiiEx (
467 -1, -1, NULL, STRING_TOKEN (STR_TFTP_ERR_NIC_NAME),
468 mTftpHiiHandle, NicNumber, Status
469 );
470 continue;
471 }
472
473 if (UserNicName != NULL) {
474 if (StrCmp (NicName, UserNicName) != 0) {
475 continue;
476 }
477 NicFound = TRUE;
478 }
479
480 Status = CreateServiceChildAndOpenProtocol (
481 ControllerHandle,
482 &gEfiMtftp4ServiceBindingProtocolGuid,
483 &gEfiMtftp4ProtocolGuid,
484 &Mtftp4ChildHandle,
485 (VOID**)&Mtftp4
486 );
487 if (EFI_ERROR (Status)) {
488 ShellPrintHiiEx (
489 -1, -1, NULL, STRING_TOKEN (STR_TFTP_ERR_OPEN_PROTOCOL),
490 mTftpHiiHandle, NicName, Status
491 );
492 continue;
493 }
494
495 Status = Mtftp4->Configure (Mtftp4, &Mtftp4ConfigData);
496 if (EFI_ERROR (Status)) {
497 ShellPrintHiiEx (
498 -1, -1, NULL, STRING_TOKEN (STR_TFTP_ERR_CONFIGURE),
499 mTftpHiiHandle, NicName, Status
500 );
501 goto NextHandle;
502 }
503
504 Status = GetFileSize (Mtftp4, AsciiRemoteFilePath, &FileSize);
505 if (EFI_ERROR (Status)) {
506 ShellPrintHiiEx (
507 -1, -1, NULL, STRING_TOKEN (STR_TFTP_ERR_FILE_SIZE),
508 mTftpHiiHandle, RemoteFilePath, NicName, Status
509 );
510 goto NextHandle;
511 }
512
513 Status = DownloadFile (Mtftp4, RemoteFilePath, AsciiRemoteFilePath, FileSize, BlockSize, &Data);
514 if (EFI_ERROR (Status)) {
515 ShellPrintHiiEx (
516 -1, -1, NULL, STRING_TOKEN (STR_TFTP_ERR_DOWNLOAD),
517 mTftpHiiHandle, RemoteFilePath, NicName, Status
518 );
519 goto NextHandle;
520 }
521
522 if (!EFI_ERROR (ShellFileExists (LocalFilePath))) {
523 ShellDeleteFileByName (LocalFilePath);
524 }
525
526 Status = ShellOpenFileByName (
527 LocalFilePath,
528 &FileHandle,
529 EFI_FILE_MODE_CREATE |
530 EFI_FILE_MODE_WRITE |
531 EFI_FILE_MODE_READ,
532 0
533 );
534 if (EFI_ERROR (Status)) {
535 ShellPrintHiiEx (
536 -1, -1, NULL, STRING_TOKEN (STR_GEN_FILE_OPEN_FAIL),
537 mTftpHiiHandle, L"tftp", LocalFilePath
538 );
539 goto NextHandle;
540 }
541
542 DataSize = FileSize;
543 Status = ShellWriteFile (FileHandle, &FileSize, Data);
544 if (!EFI_ERROR (Status)) {
545 ShellStatus = SHELL_SUCCESS;
546 } else {
547 ShellPrintHiiEx (
548 -1, -1, NULL, STRING_TOKEN (STR_TFTP_ERR_WRITE),
549 mTftpHiiHandle, LocalFilePath, Status
550 );
551 }
552 ShellCloseFile (&FileHandle);
553
554 NextHandle:
555
556 if (Data != NULL) {
557 gBS->FreePages ((EFI_PHYSICAL_ADDRESS)(UINTN)Data, EFI_SIZE_TO_PAGES (DataSize));
558 }
559
560 CloseProtocolAndDestroyServiceChild (
561 ControllerHandle,
562 &gEfiMtftp4ServiceBindingProtocolGuid,
563 &gEfiMtftp4ProtocolGuid,
564 Mtftp4ChildHandle
565 );
566 }
567
568 if ((UserNicName != NULL) && (!NicFound)) {
569 ShellPrintHiiEx (
570 -1, -1, NULL, STRING_TOKEN (STR_TFTP_ERR_NIC_NOT_FOUND),
571 mTftpHiiHandle, UserNicName
572 );
573 }
574
575 Error:
576
577 ShellCommandLineFreeVarList (CheckPackage);
578 if (AsciiRemoteFilePath != NULL) {
579 FreePool (AsciiRemoteFilePath);
580 }
581 if (Handles != NULL) {
582 FreePool (Handles);
583 }
584
585 return ShellStatus;
586 }
587
588 /**
589 Check and convert the UINT16 option values of the 'tftp' command
590
591 @param[in] ValueStr Value as an Unicode encoded string
592 @param[out] Value UINT16 value
593
594 @return TRUE The value was returned.
595 @return FALSE A parsing error occured.
596 **/
597 STATIC
598 BOOLEAN
599 StringToUint16 (
600 IN CONST CHAR16 *ValueStr,
601 OUT UINT16 *Value
602 )
603 {
604 UINTN Val;
605
606 Val = ShellStrToUintn (ValueStr);
607 if (Val > MAX_UINT16) {
608 ShellPrintHiiEx (
609 -1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV),
610 mTftpHiiHandle, L"tftp", ValueStr
611 );
612 return FALSE;
613 }
614
615 *Value = (UINT16)Val;
616 return TRUE;
617 }
618
619 /**
620 Get the name of the NIC.
621
622 @param[in] ControllerHandle The network physical device handle.
623 @param[in] NicNumber The network physical device number.
624 @param[out] NicName Address where to store the NIC name.
625 The memory area has to be at least
626 IP4_CONFIG2_INTERFACE_INFO_NAME_LENGTH
627 double byte wide.
628
629 @return EFI_SUCCESS The name of the NIC was returned.
630 @return Others The creation of the child for the Managed
631 Network Service failed or the opening of
632 the Managed Network Protocol failed or
633 the operational parameters for the
634 Managed Network Protocol could not be
635 read.
636 **/
637 STATIC
638 EFI_STATUS
639 GetNicName (
640 IN EFI_HANDLE ControllerHandle,
641 IN UINTN NicNumber,
642 OUT CHAR16 *NicName
643 )
644 {
645 EFI_STATUS Status;
646 EFI_HANDLE MnpHandle;
647 EFI_MANAGED_NETWORK_PROTOCOL *Mnp;
648 EFI_SIMPLE_NETWORK_MODE SnpMode;
649
650 Status = CreateServiceChildAndOpenProtocol (
651 ControllerHandle,
652 &gEfiManagedNetworkServiceBindingProtocolGuid,
653 &gEfiManagedNetworkProtocolGuid,
654 &MnpHandle,
655 (VOID**)&Mnp
656 );
657 if (EFI_ERROR (Status)) {
658 goto Error;
659 }
660
661 Status = Mnp->GetModeData (Mnp, NULL, &SnpMode);
662 if (EFI_ERROR (Status) && (Status != EFI_NOT_STARTED)) {
663 goto Error;
664 }
665
666 UnicodeSPrint (
667 NicName,
668 IP4_CONFIG2_INTERFACE_INFO_NAME_LENGTH,
669 SnpMode.IfType == NET_IFTYPE_ETHERNET ?
670 L"eth%d" :
671 L"unk%d" ,
672 NicNumber
673 );
674
675 Status = EFI_SUCCESS;
676
677 Error:
678
679 if (MnpHandle != NULL) {
680 CloseProtocolAndDestroyServiceChild (
681 ControllerHandle,
682 &gEfiManagedNetworkServiceBindingProtocolGuid,
683 &gEfiManagedNetworkProtocolGuid,
684 MnpHandle
685 );
686 }
687
688 return Status;
689 }
690
691 /**
692 Create a child for the service identified by its service binding protocol GUID
693 and get from the child the interface of the protocol identified by its GUID.
694
695 @param[in] ControllerHandle Controller handle.
696 @param[in] ServiceBindingProtocolGuid Service binding protocol GUID of the
697 service to be created.
698 @param[in] ProtocolGuid GUID of the protocol to be open.
699 @param[out] ChildHandle Address where the handler of the
700 created child is returned. NULL is
701 returned in case of error.
702 @param[out] Interface Address where a pointer to the
703 protocol interface is returned in
704 case of success.
705
706 @return EFI_SUCCESS The child was created and the protocol opened.
707 @return Others Either the creation of the child or the opening
708 of the protocol failed.
709 **/
710 STATIC
711 EFI_STATUS
712 CreateServiceChildAndOpenProtocol (
713 IN EFI_HANDLE ControllerHandle,
714 IN EFI_GUID *ServiceBindingProtocolGuid,
715 IN EFI_GUID *ProtocolGuid,
716 OUT EFI_HANDLE *ChildHandle,
717 OUT VOID **Interface
718 )
719 {
720 EFI_STATUS Status;
721
722 *ChildHandle = NULL;
723 Status = NetLibCreateServiceChild (
724 ControllerHandle,
725 gImageHandle,
726 ServiceBindingProtocolGuid,
727 ChildHandle
728 );
729 if (!EFI_ERROR (Status)) {
730 Status = gBS->OpenProtocol (
731 *ChildHandle,
732 ProtocolGuid,
733 Interface,
734 gImageHandle,
735 ControllerHandle,
736 EFI_OPEN_PROTOCOL_GET_PROTOCOL
737 );
738 if (EFI_ERROR (Status)) {
739 NetLibDestroyServiceChild (
740 ControllerHandle,
741 gImageHandle,
742 ServiceBindingProtocolGuid,
743 *ChildHandle
744 );
745 *ChildHandle = NULL;
746 }
747 }
748
749 return Status;
750 }
751
752 /**
753 Close the protocol identified by its GUID on the child handle of the service
754 identified by its service binding protocol GUID, then destroy the child
755 handle.
756
757 @param[in] ControllerHandle Controller handle.
758 @param[in] ServiceBindingProtocolGuid Service binding protocol GUID of the
759 service to be destroyed.
760 @param[in] ProtocolGuid GUID of the protocol to be closed.
761 @param[in] ChildHandle Handle of the child to be destroyed.
762
763 **/
764 STATIC
765 VOID
766 CloseProtocolAndDestroyServiceChild (
767 IN EFI_HANDLE ControllerHandle,
768 IN EFI_GUID *ServiceBindingProtocolGuid,
769 IN EFI_GUID *ProtocolGuid,
770 IN EFI_HANDLE ChildHandle
771 )
772 {
773 gBS->CloseProtocol (
774 ChildHandle,
775 ProtocolGuid,
776 gImageHandle,
777 ControllerHandle
778 );
779
780 NetLibDestroyServiceChild (
781 ControllerHandle,
782 gImageHandle,
783 ServiceBindingProtocolGuid,
784 ChildHandle
785 );
786 }
787
788 /**
789 Worker function that gets the size in numbers of bytes of a file from a TFTP
790 server before to download the file.
791
792 @param[in] Mtftp4 MTFTP4 protocol interface
793 @param[in] FilePath Path of the file, ASCII encoded
794 @param[out] FileSize Address where to store the file size in number of
795 bytes.
796
797 @retval EFI_SUCCESS The size of the file was returned.
798 @retval EFI_UNSUPPORTED The server does not support the "tsize" option.
799 @retval Others Error when retrieving the information from the server
800 (see EFI_MTFTP4_PROTOCOL.GetInfo() status codes)
801 or error when parsing the response of the server.
802 **/
803 STATIC
804 EFI_STATUS
805 GetFileSize (
806 IN EFI_MTFTP4_PROTOCOL *Mtftp4,
807 IN CONST CHAR8 *FilePath,
808 OUT UINTN *FileSize
809 )
810 {
811 EFI_STATUS Status;
812 EFI_MTFTP4_OPTION ReqOpt[1];
813 EFI_MTFTP4_PACKET *Packet;
814 UINT32 PktLen;
815 EFI_MTFTP4_OPTION *TableOfOptions;
816 EFI_MTFTP4_OPTION *Option;
817 UINT32 OptCnt;
818 UINT8 OptBuf[128];
819
820 ReqOpt[0].OptionStr = (UINT8*)"tsize";
821 OptBuf[0] = '0';
822 OptBuf[1] = 0;
823 ReqOpt[0].ValueStr = OptBuf;
824
825 Status = Mtftp4->GetInfo (
826 Mtftp4,
827 NULL,
828 (UINT8*)FilePath,
829 NULL,
830 1,
831 ReqOpt,
832 &PktLen,
833 &Packet
834 );
835
836 if (EFI_ERROR (Status)) {
837 goto Error;
838 }
839
840 Status = Mtftp4->ParseOptions (
841 Mtftp4,
842 PktLen,
843 Packet,
844 (UINT32 *) &OptCnt,
845 &TableOfOptions
846 );
847 if (EFI_ERROR (Status)) {
848 goto Error;
849 }
850
851 Option = TableOfOptions;
852 while (OptCnt != 0) {
853 if (AsciiStrnCmp ((CHAR8 *)Option->OptionStr, "tsize", 5) == 0) {
854 *FileSize = AsciiStrDecimalToUintn ((CHAR8 *)Option->ValueStr);
855 break;
856 }
857 OptCnt--;
858 Option++;
859 }
860 FreePool (TableOfOptions);
861
862 if (OptCnt == 0) {
863 Status = EFI_UNSUPPORTED;
864 }
865
866 Error :
867
868 return Status;
869 }
870
871 /**
872 Worker function that download the data of a file from a TFTP server given
873 the path of the file and its size.
874
875 @param[in] Mtftp4 MTFTP4 protocol interface
876 @param[in] FilePath Path of the file, Unicode encoded
877 @param[in] AsciiFilePath Path of the file, ASCII encoded
878 @param[in] FileSize Size of the file in number of bytes
879 @param[in] BlockSize Value of the TFTP blksize option
880 @param[out] Data Address where to store the address of the buffer
881 where the data of the file were downloaded in
882 case of success.
883
884 @retval EFI_SUCCESS The file was downloaded.
885 @retval EFI_OUT_OF_RESOURCES A memory allocation failed.
886 @retval Others The downloading of the file from the server failed
887 (see EFI_MTFTP4_PROTOCOL.ReadFile() status codes).
888
889 **/
890 STATIC
891 EFI_STATUS
892 DownloadFile (
893 IN EFI_MTFTP4_PROTOCOL *Mtftp4,
894 IN CONST CHAR16 *FilePath,
895 IN CONST CHAR8 *AsciiFilePath,
896 IN UINTN FileSize,
897 IN UINT16 BlockSize,
898 OUT VOID **Data
899 )
900 {
901 EFI_STATUS Status;
902 EFI_PHYSICAL_ADDRESS PagesAddress;
903 VOID *Buffer;
904 DOWNLOAD_CONTEXT *TftpContext;
905 EFI_MTFTP4_TOKEN Mtftp4Token;
906 EFI_MTFTP4_OPTION ReqOpt;
907 UINT8 OptBuf[10];
908
909 // Downloaded file can be large. BS.AllocatePages() is more faster
910 // than AllocatePool() and avoid fragmentation.
911 // The downloaded file could be an EFI application. Marking the
912 // allocated page as EfiBootServicesCode would allow to execute a
913 // potential downloaded EFI application.
914 Status = gBS->AllocatePages (
915 AllocateAnyPages,
916 EfiBootServicesCode,
917 EFI_SIZE_TO_PAGES (FileSize),
918 &PagesAddress
919 );
920 if (EFI_ERROR (Status)) {
921 return Status;
922 }
923
924 Buffer = (VOID*)(UINTN)PagesAddress;
925 TftpContext = AllocatePool (sizeof (DOWNLOAD_CONTEXT));
926 if (TftpContext == NULL) {
927 Status = EFI_OUT_OF_RESOURCES;
928 goto Error;
929 }
930 TftpContext->FileSize = FileSize;
931 TftpContext->DownloadedNbOfBytes = 0;
932 TftpContext->LastReportedNbOfBytes = 0;
933
934 ZeroMem (&Mtftp4Token, sizeof (EFI_MTFTP4_TOKEN));
935 Mtftp4Token.Filename = (UINT8*)AsciiFilePath;
936 Mtftp4Token.BufferSize = FileSize;
937 Mtftp4Token.Buffer = Buffer;
938 Mtftp4Token.CheckPacket = CheckPacket;
939 Mtftp4Token.Context = (VOID*)TftpContext;
940 if (BlockSize != MTFTP_DEFAULT_BLKSIZE) {
941 ReqOpt.OptionStr = (UINT8 *) "blksize";
942 AsciiSPrint ((CHAR8 *)OptBuf, sizeof (OptBuf), "%d", BlockSize);
943 ReqOpt.ValueStr = OptBuf;
944
945 Mtftp4Token.OptionCount = 1;
946 Mtftp4Token.OptionList = &ReqOpt;
947 }
948
949 ShellPrintHiiEx (
950 -1, -1, NULL, STRING_TOKEN (STR_TFTP_DOWNLOADING),
951 mTftpHiiHandle, FilePath
952 );
953
954 Status = Mtftp4->ReadFile (Mtftp4, &Mtftp4Token);
955 ShellPrintHiiEx (
956 -1, -1, NULL, STRING_TOKEN (STR_GEN_CRLF),
957 mTftpHiiHandle
958 );
959
960 Error :
961
962 if (TftpContext == NULL) {
963 FreePool (TftpContext);
964 }
965
966 if (EFI_ERROR (Status)) {
967 gBS->FreePages (PagesAddress, EFI_SIZE_TO_PAGES (FileSize));
968 return Status;
969 }
970
971 *Data = Buffer;
972
973 return EFI_SUCCESS;
974 }
975
976 /**
977 Update the progress of a file download
978 This procedure is called each time a new TFTP packet is received.
979
980 @param[in] This MTFTP4 protocol interface
981 @param[in] Token Parameters for the download of the file
982 @param[in] PacketLen Length of the packet
983 @param[in] Packet Address of the packet
984
985 @retval EFI_SUCCESS All packets are accepted.
986
987 **/
988 STATIC
989 EFI_STATUS
990 EFIAPI
991 CheckPacket (
992 IN EFI_MTFTP4_PROTOCOL *This,
993 IN EFI_MTFTP4_TOKEN *Token,
994 IN UINT16 PacketLen,
995 IN EFI_MTFTP4_PACKET *Packet
996 )
997 {
998 DOWNLOAD_CONTEXT *Context;
999 CHAR16 Progress[TFTP_PROGRESS_MESSAGE_SIZE];
1000 UINTN NbOfKb;
1001 UINTN Index;
1002 UINTN LastStep;
1003 UINTN Step;
1004 EFI_STATUS Status;
1005
1006 if ((NTOHS (Packet->OpCode)) != EFI_MTFTP4_OPCODE_DATA) {
1007 return EFI_SUCCESS;
1008 }
1009
1010 Context = (DOWNLOAD_CONTEXT*)Token->Context;
1011 if (Context->DownloadedNbOfBytes == 0) {
1012 ShellPrintEx (-1, -1, L"%s 0 Kb", mTftpProgressFrame);
1013 }
1014
1015 //
1016 // The data in the packet are prepended with two UINT16 :
1017 // . OpCode = EFI_MTFTP4_OPCODE_DATA
1018 // . Block = the number of this block of data
1019 //
1020 Context->DownloadedNbOfBytes += PacketLen - sizeof (Packet->OpCode)
1021 - sizeof (Packet->Data.Block);
1022 NbOfKb = Context->DownloadedNbOfBytes / 1024;
1023
1024 Progress[0] = L'\0';
1025 LastStep = (Context->LastReportedNbOfBytes * TFTP_PROGRESS_SLIDER_STEPS) / Context->FileSize;
1026 Step = (Context->DownloadedNbOfBytes * TFTP_PROGRESS_SLIDER_STEPS) / Context->FileSize;
1027
1028 if (Step <= LastStep) {
1029 return EFI_SUCCESS;
1030 }
1031
1032 ShellPrintEx (-1, -1, L"%s", mTftpProgressDelete);
1033
1034 Status = StrCpyS (Progress, TFTP_PROGRESS_MESSAGE_SIZE, mTftpProgressFrame);
1035 if (EFI_ERROR(Status)) {
1036 return Status;
1037 }
1038 for (Index = 1; Index < Step; Index++) {
1039 Progress[Index] = L'=';
1040 }
1041 Progress[Step] = L'>';
1042
1043 UnicodeSPrint (
1044 Progress + (sizeof (mTftpProgressFrame) / sizeof (CHAR16)) - 1,
1045 sizeof (Progress) - sizeof (mTftpProgressFrame),
1046 L" %7d Kb",
1047 NbOfKb
1048 );
1049 Context->LastReportedNbOfBytes = Context->DownloadedNbOfBytes;
1050
1051 ShellPrintEx (-1, -1, L"%s", Progress);
1052
1053 return EFI_SUCCESS;
1054 }
1055
1056 /**
1057 Retrive HII package list from ImageHandle and publish to HII database.
1058
1059 @param ImageHandle The image handle of the process.
1060
1061 @return HII handle.
1062 **/
1063 EFI_HANDLE
1064 InitializeHiiPackage (
1065 EFI_HANDLE ImageHandle
1066 )
1067 {
1068 EFI_STATUS Status;
1069 EFI_HII_PACKAGE_LIST_HEADER *PackageList;
1070 EFI_HANDLE HiiHandle;
1071
1072 //
1073 // Retrieve HII package list from ImageHandle
1074 //
1075 Status = gBS->OpenProtocol (
1076 ImageHandle,
1077 &gEfiHiiPackageListProtocolGuid,
1078 (VOID **)&PackageList,
1079 ImageHandle,
1080 NULL,
1081 EFI_OPEN_PROTOCOL_GET_PROTOCOL
1082 );
1083 ASSERT_EFI_ERROR (Status);
1084 if (EFI_ERROR (Status)) {
1085 return NULL;
1086 }
1087
1088 //
1089 // Publish HII package list to HII Database.
1090 //
1091 Status = gHiiDatabase->NewPackageList (
1092 gHiiDatabase,
1093 PackageList,
1094 NULL,
1095 &HiiHandle
1096 );
1097 ASSERT_EFI_ERROR (Status);
1098 if (EFI_ERROR (Status)) {
1099 return NULL;
1100 }
1101 return HiiHandle;
1102 }