Mtftp4Impl.c

Go to the documentation of this file.

 
#include "Mtftp4Impl.h"
 
VOID
Mtftp4CleanOperation (
  IN OUT MTFTP4_PROTOCOL  *Instance,
  IN     EFI_STATUS       Result
  )
{
  LIST_ENTRY          *Entry;
  LIST_ENTRY          *Next;
  MTFTP4_BLOCK_RANGE  *Block;
  EFI_MTFTP4_TOKEN    *Token;
 
  //
  // Free various resources.
  //
  Token = Instance->Token;
 
  if (Token != NULL) {
    Token->Status = Result;
 
    if (Token->Event != NULL) {
      gBS->SignalEvent (Token->Event);
    }
 
    Instance->Token = NULL;
  }
 
  ASSERT (Instance->UnicastPort != NULL);
  UdpIoCleanIo (Instance->UnicastPort);
 
  if (Instance->LastPacket != NULL) {
    NetbufFree (Instance->LastPacket);
    Instance->LastPacket = NULL;
  }
 
  if (Instance->McastUdpPort != NULL) {
    gBS->CloseProtocol (
           Instance->McastUdpPort->UdpHandle,
           &gEfiUdp4ProtocolGuid,
           gMtftp4DriverBinding.DriverBindingHandle,
           Instance->Handle
           );
    UdpIoFreeIo (Instance->McastUdpPort);
    Instance->McastUdpPort = NULL;
  }
 
  NET_LIST_FOR_EACH_SAFE (Entry, Next, &Instance->Blocks) {
    Block = NET_LIST_USER_STRUCT (Entry, MTFTP4_BLOCK_RANGE, Link);
    RemoveEntryList (Entry);
    FreePool (Block);
  }
 
  ZeroMem (&Instance->RequestOption, sizeof (MTFTP4_OPTION));
 
  Instance->Operation = 0;
 
  Instance->BlkSize       = MTFTP4_DEFAULT_BLKSIZE;
  Instance->WindowSize    = 1;
  Instance->TotalBlock    = 0;
  Instance->AckedBlock    = 0;
  Instance->LastBlock     = 0;
  Instance->ServerIp      = 0;
  Instance->ListeningPort = 0;
  Instance->ConnectedPort = 0;
  Instance->Gateway       = 0;
  Instance->PacketToLive  = 0;
  Instance->MaxRetry      = 0;
  Instance->CurRetry      = 0;
  Instance->Timeout       = 0;
  Instance->McastIp       = 0;
  Instance->McastPort     = 0;
  Instance->Master        = TRUE;
}
 
EFI_STATUS
EFIAPI
Mtftp4GetInfoCheckPacket (
  IN EFI_MTFTP4_PROTOCOL  *This,
  IN EFI_MTFTP4_TOKEN     *Token,
  IN UINT16               PacketLen,
  IN EFI_MTFTP4_PACKET    *Packet
  )
{
  MTFTP4_GETINFO_STATE     *State;
  EFI_STATUS               Status;
  UINT16                   OpCode;
  EFI_MTFTP4_ERROR_HEADER  *ErrorHeader;
 
  State  = (MTFTP4_GETINFO_STATE *)Token->Context;
  OpCode = NTOHS (Packet->OpCode);
 
  //
  // Set the GetInfo's return status according to the OpCode.
  //
  switch (OpCode) {
    case EFI_MTFTP4_OPCODE_ERROR:
      ErrorHeader = (EFI_MTFTP4_ERROR_HEADER *)Packet;
      if (ErrorHeader->ErrorCode == EFI_MTFTP4_ERRORCODE_FILE_NOT_FOUND) {
        DEBUG ((DEBUG_ERROR, "TFTP error code 1 (File Not Found)\n"));
      } else {
        DEBUG ((DEBUG_ERROR, "TFTP error code %d\n", ErrorHeader->ErrorCode));
      }
 
      State->Status = EFI_TFTP_ERROR;
      break;
 
    case EFI_MTFTP4_OPCODE_OACK:
      State->Status = EFI_SUCCESS;
      break;
 
    default:
      State->Status = EFI_PROTOCOL_ERROR;
  }
 
  //
  // Allocate buffer then copy the packet over. Use gBS->AllocatePool
  // in case AllocatePool will implements something tricky.
  //
  Status = gBS->AllocatePool (EfiBootServicesData, PacketLen, (VOID **)State->Packet);
 
  if (EFI_ERROR (Status)) {
    State->Status = EFI_OUT_OF_RESOURCES;
    return EFI_ABORTED;
  }
 
  *(State->PacketLen) = PacketLen;
  CopyMem (*(State->Packet), Packet, PacketLen);
 
  return EFI_ABORTED;
}
 
BOOLEAN
Mtftp4OverrideValid (
  IN MTFTP4_PROTOCOL           *Instance,
  IN EFI_MTFTP4_OVERRIDE_DATA  *Override
  )
{
  EFI_MTFTP4_CONFIG_DATA  *Config;
  IP4_ADDR                Ip;
  IP4_ADDR                Netmask;
  IP4_ADDR                Gateway;
 
  CopyMem (&Ip, &Override->ServerIp, sizeof (IP4_ADDR));
  if (IP4_IS_UNSPECIFIED (NTOHL (Ip)) || IP4_IS_LOCAL_BROADCAST (NTOHL (Ip))) {
    return FALSE;
  }
 
  Config = &Instance->Config;
 
  CopyMem (&Gateway, &Override->GatewayIp, sizeof (IP4_ADDR));
  Gateway = NTOHL (Gateway);
 
  if (!Config->UseDefaultSetting && (Gateway != 0)) {
    CopyMem (&Netmask, &Config->SubnetMask, sizeof (IP4_ADDR));
    CopyMem (&Ip, &Config->StationIp, sizeof (IP4_ADDR));
 
    Netmask = NTOHL (Netmask);
    Ip      = NTOHL (Ip);
 
    if (((Netmask != 0) && !NetIp4IsUnicast (Gateway, Netmask)) || !IP4_NET_EQUAL (Gateway, Ip, Netmask)) {
      return FALSE;
    }
  }
 
  return TRUE;
}
 
BOOLEAN
Mtftp4GetMapping (
  IN MTFTP4_PROTOCOL       *Instance,
  IN UDP_IO                *UdpIo,
  IN EFI_UDP4_CONFIG_DATA  *UdpCfgData
  )
{
  MTFTP4_SERVICE     *Service;
  EFI_IP4_MODE_DATA  Ip4Mode;
  EFI_UDP4_PROTOCOL  *Udp;
  EFI_STATUS         Status;
 
  ASSERT (Instance->Config.UseDefaultSetting);
 
  Service = Instance->Service;
  Udp     = UdpIo->Protocol.Udp4;
 
  Status = gBS->SetTimer (
                  Service->TimerToGetMap,
                  TimerRelative,
                  MTFTP4_TIME_TO_GETMAP * TICKS_PER_SECOND
                  );
  if (EFI_ERROR (Status)) {
    return FALSE;
  }
 
  while (EFI_ERROR (gBS->CheckEvent (Service->TimerToGetMap))) {
    Udp->Poll (Udp);
 
    if (!EFI_ERROR (Udp->GetModeData (Udp, NULL, &Ip4Mode, NULL, NULL)) &&
        Ip4Mode.IsConfigured)
    {
      Udp->Configure (Udp, NULL);
      return (BOOLEAN)(Udp->Configure (Udp, UdpCfgData) == EFI_SUCCESS);
    }
  }
 
  return FALSE;
}
 
EFI_STATUS
Mtftp4ConfigUnicastPort (
  IN UDP_IO           *UdpIo,
  IN MTFTP4_PROTOCOL  *Instance
  )
{
  EFI_MTFTP4_CONFIG_DATA  *Config;
  EFI_UDP4_CONFIG_DATA    UdpConfig;
  EFI_STATUS              Status;
  IP4_ADDR                Ip;
 
  Config = &Instance->Config;
 
  UdpConfig.AcceptBroadcast    = FALSE;
  UdpConfig.AcceptPromiscuous  = FALSE;
  UdpConfig.AcceptAnyPort      = FALSE;
  UdpConfig.AllowDuplicatePort = FALSE;
  UdpConfig.TypeOfService      = 0;
  UdpConfig.TimeToLive         = 64;
  UdpConfig.DoNotFragment      = FALSE;
  UdpConfig.ReceiveTimeout     = 0;
  UdpConfig.TransmitTimeout    = 0;
  UdpConfig.UseDefaultAddress  = Config->UseDefaultSetting;
  IP4_COPY_ADDRESS (&UdpConfig.StationAddress, &Config->StationIp);
  IP4_COPY_ADDRESS (&UdpConfig.SubnetMask, &Config->SubnetMask);
  UdpConfig.StationPort = Config->LocalPort;
  UdpConfig.RemotePort  = 0;
 
  Ip = HTONL (Instance->ServerIp);
  IP4_COPY_ADDRESS (&UdpConfig.RemoteAddress, &Ip);
 
  Status = UdpIo->Protocol.Udp4->Configure (UdpIo->Protocol.Udp4, &UdpConfig);
 
  if ((Status == EFI_NO_MAPPING) && Mtftp4GetMapping (Instance, UdpIo, &UdpConfig)) {
    return EFI_SUCCESS;
  }
 
  if (!Config->UseDefaultSetting && !EFI_IP4_EQUAL (&mZeroIp4Addr, &Config->GatewayIp)) {
    //
    // The station IP address is manually configured and the Gateway IP is not 0.
    // Add the default route for this UDP instance.
    //
    Status = UdpIo->Protocol.Udp4->Routes (
                                     UdpIo->Protocol.Udp4,
                                     FALSE,
                                     &mZeroIp4Addr,
                                     &mZeroIp4Addr,
                                     &Config->GatewayIp
                                     );
    if (EFI_ERROR (Status)) {
      UdpIo->Protocol.Udp4->Configure (UdpIo->Protocol.Udp4, NULL);
    }
  }
 
  return Status;
}
 
EFI_STATUS
Mtftp4Start (
  IN EFI_MTFTP4_PROTOCOL  *This,
  IN EFI_MTFTP4_TOKEN     *Token,
  IN UINT16               Operation
  )
{
  MTFTP4_PROTOCOL           *Instance;
  EFI_MTFTP4_OVERRIDE_DATA  *Override;
  EFI_MTFTP4_CONFIG_DATA    *Config;
  EFI_TPL                   OldTpl;
  EFI_STATUS                Status;
  EFI_STATUS                TokenStatus;
 
  //
  // Validate the parameters
  //
  if ((This == NULL) || (Token == NULL) || (Token->Filename == NULL) ||
      ((Token->OptionCount != 0) && (Token->OptionList == NULL)))
  {
    return EFI_INVALID_PARAMETER;
  }
 
  //
  // User must provide at least one method to collect the data for download.
  //
  if (((Operation == EFI_MTFTP4_OPCODE_RRQ) || (Operation == EFI_MTFTP4_OPCODE_DIR)) &&
      ((Token->Buffer == NULL) && (Token->CheckPacket == NULL)))
  {
    return EFI_INVALID_PARAMETER;
  }
 
  //
  // User must provide at least one method to provide the data for upload.
  //
  if ((Operation == EFI_MTFTP4_OPCODE_WRQ) &&
      ((Token->Buffer == NULL) && (Token->PacketNeeded == NULL)))
  {
    return EFI_INVALID_PARAMETER;
  }
 
  Instance = MTFTP4_PROTOCOL_FROM_THIS (This);
 
  Status      = EFI_SUCCESS;
  TokenStatus = EFI_SUCCESS;
 
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  if (Instance->State != MTFTP4_STATE_CONFIGED) {
    Status = EFI_NOT_STARTED;
  }
 
  if (Instance->Operation != 0) {
    Status = EFI_ACCESS_DENIED;
  }
 
  if ((Token->OverrideData != NULL) && !Mtftp4OverrideValid (Instance, Token->OverrideData)) {
    Status = EFI_INVALID_PARAMETER;
  }
 
  if (EFI_ERROR (Status)) {
    gBS->RestoreTPL (OldTpl);
    return Status;
  }
 
  //
  // Set the Operation now to prevent the application start other
  // operations.
  //
  Instance->Operation = Operation;
  Override            = Token->OverrideData;
 
  if (Token->OptionCount != 0) {
    Status = Mtftp4ParseOption (
               Token->OptionList,
               Token->OptionCount,
               TRUE,
               Instance->Operation,
               &Instance->RequestOption
               );
 
    if (EFI_ERROR (Status)) {
      TokenStatus = EFI_DEVICE_ERROR;
      goto ON_ERROR;
    }
  }
 
  //
  // Set the operation parameters from the configuration or override data.
  //
  Config               = &Instance->Config;
  Instance->Token      = Token;
  Instance->BlkSize    = MTFTP4_DEFAULT_BLKSIZE;
  Instance->WindowSize = MTFTP4_DEFAULT_WINDOWSIZE;
 
  CopyMem (&Instance->ServerIp, &Config->ServerIp, sizeof (IP4_ADDR));
  Instance->ServerIp = NTOHL (Instance->ServerIp);
 
  Instance->ListeningPort = Config->InitialServerPort;
  Instance->ConnectedPort = 0;
 
  CopyMem (&Instance->Gateway, &Config->GatewayIp, sizeof (IP4_ADDR));
  Instance->Gateway = NTOHL (Instance->Gateway);
 
  Instance->MaxRetry = Config->TryCount;
  Instance->Timeout  = Config->TimeoutValue;
  Instance->Master   = TRUE;
 
  if (Override != NULL) {
    CopyMem (&Instance->ServerIp, &Override->ServerIp, sizeof (IP4_ADDR));
    CopyMem (&Instance->Gateway, &Override->GatewayIp, sizeof (IP4_ADDR));
 
    Instance->ServerIp = NTOHL (Instance->ServerIp);
    Instance->Gateway  = NTOHL (Instance->Gateway);
 
    Instance->ListeningPort = Override->ServerPort;
    Instance->MaxRetry      = Override->TryCount;
    Instance->Timeout       = Override->TimeoutValue;
  }
 
  if (Instance->ListeningPort == 0) {
    Instance->ListeningPort = MTFTP4_DEFAULT_SERVER_PORT;
  }
 
  if (Instance->MaxRetry == 0) {
    Instance->MaxRetry = MTFTP4_DEFAULT_RETRY;
  }
 
  if (Instance->Timeout == 0) {
    Instance->Timeout = MTFTP4_DEFAULT_TIMEOUT;
  }
 
  //
  // Config the unicast UDP child to send initial request
  //
  Status = Mtftp4ConfigUnicastPort (Instance->UnicastPort, Instance);
  if (EFI_ERROR (Status)) {
    TokenStatus = EFI_DEVICE_ERROR;
    goto ON_ERROR;
  }
 
  //
  // Set initial status.
  //
  Token->Status = EFI_NOT_READY;
 
  //
  // Build and send an initial requests
  //
  if (Operation == EFI_MTFTP4_OPCODE_WRQ) {
    Status = Mtftp4WrqStart (Instance, Operation);
  } else {
    Status = Mtftp4RrqStart (Instance, Operation);
  }
 
  if (EFI_ERROR (Status)) {
    TokenStatus = EFI_DEVICE_ERROR;
    goto ON_ERROR;
  }
 
  gBS->RestoreTPL (OldTpl);
 
  if (Token->Event != NULL) {
    return EFI_SUCCESS;
  }
 
  //
  // Return immediately for asynchronous operation or poll the
  // instance for synchronous operation.
  //
  while (Token->Status == EFI_NOT_READY) {
    This->Poll (This);
  }
 
  return Token->Status;
 
ON_ERROR:
  Mtftp4CleanOperation (Instance, TokenStatus);
  gBS->RestoreTPL (OldTpl);
 
  return Status;
}
 
EFI_STATUS
EFIAPI
EfiMtftp4GetModeData (
  IN     EFI_MTFTP4_PROTOCOL  *This,
  OUT EFI_MTFTP4_MODE_DATA    *ModeData
  )
{
  MTFTP4_PROTOCOL  *Instance;
  EFI_TPL          OldTpl;
 
  if ((This == NULL) || (ModeData == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  Instance = MTFTP4_PROTOCOL_FROM_THIS (This);
  CopyMem (&ModeData->ConfigData, &Instance->Config, sizeof (Instance->Config));
  ModeData->SupportedOptionCount   = MTFTP4_SUPPORTED_OPTIONS;
  ModeData->SupportedOptoins       = (UINT8 **)mMtftp4SupportedOptions;
  ModeData->UnsupportedOptionCount = 0;
  ModeData->UnsupportedOptoins     = NULL;
 
  gBS->RestoreTPL (OldTpl);
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
EfiMtftp4Configure (
  IN EFI_MTFTP4_PROTOCOL     *This,
  IN EFI_MTFTP4_CONFIG_DATA  *ConfigData
  )
{
  MTFTP4_PROTOCOL  *Instance;
  EFI_TPL          OldTpl;
  IP4_ADDR         Ip;
  IP4_ADDR         Netmask;
  IP4_ADDR         Gateway;
  IP4_ADDR         ServerIp;
 
  if (This == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  Instance = MTFTP4_PROTOCOL_FROM_THIS (This);
 
  if (ConfigData == NULL) {
    //
    // Reset the operation if ConfigData is NULL
    //
    OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
    Mtftp4CleanOperation (Instance, EFI_ABORTED);
    ZeroMem (&Instance->Config, sizeof (EFI_MTFTP4_CONFIG_DATA));
    Instance->State = MTFTP4_STATE_UNCONFIGED;
 
    gBS->RestoreTPL (OldTpl);
  } else {
    //
    // Configure the parameters for new operation.
    //
    CopyMem (&Ip, &ConfigData->StationIp, sizeof (IP4_ADDR));
    CopyMem (&Netmask, &ConfigData->SubnetMask, sizeof (IP4_ADDR));
    CopyMem (&Gateway, &ConfigData->GatewayIp, sizeof (IP4_ADDR));
    CopyMem (&ServerIp, &ConfigData->ServerIp, sizeof (IP4_ADDR));
 
    Ip       = NTOHL (Ip);
    Netmask  = NTOHL (Netmask);
    Gateway  = NTOHL (Gateway);
    ServerIp = NTOHL (ServerIp);
 
    if ((ServerIp == 0) || IP4_IS_LOCAL_BROADCAST (ServerIp)) {
      return EFI_INVALID_PARAMETER;
    }
 
    if (!ConfigData->UseDefaultSetting &&
        ((!IP4_IS_VALID_NETMASK (Netmask) || ((Netmask != 0) && !NetIp4IsUnicast (Ip, Netmask)))))
    {
      return EFI_INVALID_PARAMETER;
    }
 
    if ((Gateway != 0) &&
        (((Netmask != 0xFFFFFFFF) && !IP4_NET_EQUAL (Gateway, Ip, Netmask)) || ((Netmask != 0) && !NetIp4IsUnicast (Gateway, Netmask))))
    {
      return EFI_INVALID_PARAMETER;
    }
 
    OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
    if ((Instance->State == MTFTP4_STATE_CONFIGED) && (Instance->Operation != 0)) {
      gBS->RestoreTPL (OldTpl);
      return EFI_ACCESS_DENIED;
    }
 
    CopyMem (&Instance->Config, ConfigData, sizeof (*ConfigData));
    Instance->State = MTFTP4_STATE_CONFIGED;
 
    gBS->RestoreTPL (OldTpl);
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
EfiMtftp4ParseOptions (
  IN     EFI_MTFTP4_PROTOCOL  *This,
  IN     UINT32               PacketLen,
  IN     EFI_MTFTP4_PACKET    *Packet,
  OUT UINT32                  *OptionCount,
  OUT EFI_MTFTP4_OPTION       **OptionList          OPTIONAL
  )
{
  EFI_STATUS  Status;
 
  if ((This == NULL) || (PacketLen < MTFTP4_OPCODE_LEN) ||
      (Packet == NULL) || (OptionCount == NULL))
  {
    return EFI_INVALID_PARAMETER;
  }
 
  Status = Mtftp4ExtractOptions (Packet, PacketLen, OptionCount, OptionList);
 
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  if (*OptionCount == 0) {
    return EFI_NOT_FOUND;
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
EfiMtftp4ReadFile (
  IN EFI_MTFTP4_PROTOCOL  *This,
  IN EFI_MTFTP4_TOKEN     *Token
  )
{
  return Mtftp4Start (This, Token, EFI_MTFTP4_OPCODE_RRQ);
}
 
EFI_STATUS
EFIAPI
EfiMtftp4WriteFile (
  IN EFI_MTFTP4_PROTOCOL  *This,
  IN EFI_MTFTP4_TOKEN     *Token
  )
{
  return Mtftp4Start (This, Token, EFI_MTFTP4_OPCODE_WRQ);
}
 
EFI_STATUS
EFIAPI
EfiMtftp4ReadDirectory (
  IN EFI_MTFTP4_PROTOCOL  *This,
  IN EFI_MTFTP4_TOKEN     *Token
  )
{
  return Mtftp4Start (This, Token, EFI_MTFTP4_OPCODE_DIR);
}
 
EFI_STATUS
EFIAPI
EfiMtftp4GetInfo (
  IN     EFI_MTFTP4_PROTOCOL       *This,
  IN     EFI_MTFTP4_OVERRIDE_DATA  *OverrideData        OPTIONAL,
  IN     UINT8                     *Filename,
  IN     UINT8                     *ModeStr             OPTIONAL,
  IN     UINT8                     OptionCount,
  IN     EFI_MTFTP4_OPTION         *OptionList          OPTIONAL,
  OUT UINT32                       *PacketLength,
  OUT EFI_MTFTP4_PACKET            **Packet             OPTIONAL
  )
{
  EFI_MTFTP4_TOKEN      Token;
  MTFTP4_GETINFO_STATE  State;
  EFI_STATUS            Status;
 
  if ((This == NULL) || (Filename == NULL) || (PacketLength == NULL) ||
      ((OptionCount != 0) && (OptionList == NULL)))
  {
    return EFI_INVALID_PARAMETER;
  }
 
  if (Packet != NULL) {
    *Packet = NULL;
  }
 
  *PacketLength   = 0;
  State.Packet    = Packet;
  State.PacketLen = PacketLength;
  State.Status    = EFI_SUCCESS;
 
  //
  // Fill in the Token to issue an synchronous ReadFile operation
  //
  Token.Status          = EFI_SUCCESS;
  Token.Event           = NULL;
  Token.OverrideData    = OverrideData;
  Token.Filename        = Filename;
  Token.ModeStr         = ModeStr;
  Token.OptionCount     = OptionCount;
  Token.OptionList      = OptionList;
  Token.BufferSize      = 0;
  Token.Buffer          = NULL;
  Token.Context         = &State;
  Token.CheckPacket     = Mtftp4GetInfoCheckPacket;
  Token.TimeoutCallback = NULL;
  Token.PacketNeeded    = NULL;
 
  Status = EfiMtftp4ReadFile (This, &Token);
 
  if (EFI_ABORTED == Status) {
    return State.Status;
  }
 
  return Status;
}
 
EFI_STATUS
EFIAPI
EfiMtftp4Poll (
  IN EFI_MTFTP4_PROTOCOL  *This
  )
{
  MTFTP4_PROTOCOL    *Instance;
  EFI_UDP4_PROTOCOL  *Udp;
  EFI_STATUS         Status;
 
  if (This == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  Instance = MTFTP4_PROTOCOL_FROM_THIS (This);
 
  if (Instance->State == MTFTP4_STATE_UNCONFIGED) {
    return EFI_NOT_STARTED;
  } else if (Instance->State == MTFTP4_STATE_DESTROY) {
    return EFI_DEVICE_ERROR;
  }
 
  Udp    = Instance->UnicastPort->Protocol.Udp4;
  Status = Udp->Poll (Udp);
  Mtftp4OnTimerTick (NULL, Instance->Service);
  return Status;
}
 
EFI_MTFTP4_PROTOCOL  gMtftp4ProtocolTemplate = {
  EfiMtftp4GetModeData,
  EfiMtftp4Configure,
  EfiMtftp4GetInfo,
  EfiMtftp4ParseOptions,
  EfiMtftp4ReadFile,
  EfiMtftp4WriteFile,
  EfiMtftp4ReadDirectory,
  EfiMtftp4Poll
};