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