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 - 2018, 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 }