Mtftp6Impl.c

Go to the documentation of this file.

 
#include "Mtftp6Impl.h"
 
EFI_MTFTP6_PROTOCOL  gMtftp6ProtocolTemplate = {
  EfiMtftp6GetModeData,
  EfiMtftp6Configure,
  EfiMtftp6GetInfo,
  EfiMtftp6ParseOptions,
  EfiMtftp6ReadFile,
  EfiMtftp6WriteFile,
  EfiMtftp6ReadDirectory,
  EfiMtftp6Poll
};
 
EFI_STATUS
EFIAPI
EfiMtftp6GetModeData (
  IN  EFI_MTFTP6_PROTOCOL   *This,
  OUT EFI_MTFTP6_MODE_DATA  *ModeData
  )
{
  MTFTP6_INSTANCE  *Instance;
  EFI_TPL          OldTpl;
 
  if ((This == NULL) || (ModeData == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  OldTpl   = gBS->RaiseTPL (TPL_CALLBACK);
  Instance = MTFTP6_INSTANCE_FROM_THIS (This);
 
  //
  // Copy back the configure data if the instance already configured.
  //
  if (Instance->Config != NULL) {
    CopyMem (
      &ModeData->ConfigData,
      Instance->Config,
      sizeof (EFI_MTFTP6_CONFIG_DATA)
      );
  } else {
    ZeroMem (
      &ModeData->ConfigData,
      sizeof (EFI_MTFTP6_CONFIG_DATA)
      );
  }
 
  //
  // Set the current support options in mode data.
  //
  ModeData->SupportedOptionCount = MTFTP6_SUPPORTED_OPTIONS_NUM;
  ModeData->SupportedOptions     = (UINT8 **)mMtftp6SupportedOptions;
 
  gBS->RestoreTPL (OldTpl);
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
EfiMtftp6Configure (
  IN EFI_MTFTP6_PROTOCOL     *This,
  IN EFI_MTFTP6_CONFIG_DATA  *MtftpConfigData     OPTIONAL
  )
{
  MTFTP6_SERVICE        *Service;
  MTFTP6_INSTANCE       *Instance;
  EFI_UDP6_PROTOCOL     *Udp6;
  EFI_UDP6_CONFIG_DATA  Udp6Cfg;
  EFI_STATUS            Status;
  EFI_TPL               OldTpl;
 
  if (This == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  if ((MtftpConfigData != NULL) && !NetIp6IsValidUnicast (&MtftpConfigData->ServerIp)) {
    return EFI_INVALID_PARAMETER;
  }
 
  OldTpl   = gBS->RaiseTPL (TPL_CALLBACK);
  Instance = MTFTP6_INSTANCE_FROM_THIS (This);
  Service  = Instance->Service;
  Status   = EFI_SUCCESS;
 
  if (MtftpConfigData == NULL) {
    //
    // Configure the instance as NULL to abort the current session.
    //
    Mtftp6OperationClean (Instance, EFI_ABORTED);
    FreePool (Instance->Config);
    Instance->Config = NULL;
  } else {
    //
    // It's not allowed to configure one instance twice without configure null.
    //
    if (Instance->Config != NULL) {
      Status = EFI_ACCESS_DENIED;
      goto ON_EXIT;
    }
 
    //
    // Allocate the configure buffer of the instance and store the user's data.
    //
    Instance->Config = AllocateZeroPool (sizeof (EFI_MTFTP6_CONFIG_DATA));
 
    if (Instance->Config == NULL) {
      Status = EFI_OUT_OF_RESOURCES;
      goto ON_EXIT;
    }
 
    CopyMem (Instance->Config, MtftpConfigData, sizeof (EFI_MTFTP6_CONFIG_DATA));
 
    //
    // Don't configure the udpio here because each operation might override
    // the configuration, so delay udpio configuration in each operation.
    //
    if (Instance->UdpIo == NULL) {
      Instance->UdpIo = UdpIoCreateIo (
                          Service->Controller,
                          Service->Image,
                          Mtftp6ConfigDummyUdpIo,
                          UDP_IO_UDP6_VERSION,
                          NULL
                          );
      if (Instance->UdpIo != NULL) {
        Status = gBS->OpenProtocol (
                        Instance->UdpIo->UdpHandle,
                        &gEfiUdp6ProtocolGuid,
                        (VOID **)&Udp6,
                        Service->Image,
                        Instance->Handle,
                        EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
                        );
        if (EFI_ERROR (Status)) {
          goto ON_EXIT;
        }
      }
    }
 
    if (Instance->UdpIo == NULL) {
      Status = EFI_OUT_OF_RESOURCES;
      goto ON_EXIT;
    }
 
    //
    // Continue to configure the downside Udp6 instance by user's data.
    //
    ZeroMem (&Udp6Cfg, sizeof (EFI_UDP6_CONFIG_DATA));
 
    Udp6Cfg.AcceptPromiscuous  = FALSE;
    Udp6Cfg.AcceptAnyPort      = FALSE;
    Udp6Cfg.AllowDuplicatePort = FALSE;
    Udp6Cfg.TrafficClass       = 0;
    Udp6Cfg.HopLimit           = 128;
    Udp6Cfg.ReceiveTimeout     = 0;
    Udp6Cfg.TransmitTimeout    = 0;
    Udp6Cfg.StationPort        = Instance->Config->LocalPort;
    Udp6Cfg.RemotePort         = Instance->Config->InitialServerPort;
 
    CopyMem (
      &Udp6Cfg.StationAddress,
      &Instance->Config->StationIp,
      sizeof (EFI_IPv6_ADDRESS)
      );
 
    CopyMem (
      &Udp6Cfg.RemoteAddress,
      &Instance->Config->ServerIp,
      sizeof (EFI_IPv6_ADDRESS)
      );
 
    Udp6   = Instance->UdpIo->Protocol.Udp6;
    Status = Udp6->Configure (Udp6, &Udp6Cfg);
 
    if (EFI_ERROR (Status)) {
      goto ON_EXIT;
    }
  }
 
ON_EXIT:
  if (EFI_ERROR (Status)) {
    if (Instance->Config != NULL) {
      FreePool (Instance->Config);
      Instance->Config = NULL;
    }
 
    if (Instance->UdpIo != NULL) {
      UdpIoFreeIo (Instance->UdpIo);
      Instance->UdpIo = NULL;
    }
  }
 
  gBS->RestoreTPL (OldTpl);
  return Status;
}
 
EFI_STATUS
EFIAPI
EfiMtftp6GetInfo (
  IN  EFI_MTFTP6_PROTOCOL       *This,
  IN  EFI_MTFTP6_OVERRIDE_DATA  *OverrideData         OPTIONAL,
  IN  UINT8                     *Filename,
  IN  UINT8                     *ModeStr              OPTIONAL,
  IN  UINT8                     OptionCount,
  IN  EFI_MTFTP6_OPTION         *OptionList           OPTIONAL,
  OUT UINT32                    *PacketLength,
  OUT EFI_MTFTP6_PACKET         **Packet              OPTIONAL
  )
{
  EFI_STATUS              Status;
  EFI_MTFTP6_TOKEN        Token;
  MTFTP6_GETINFO_CONTEXT  Context;
 
  if ((This == NULL) ||
      (Filename == NULL) ||
      (PacketLength == NULL) ||
      ((OptionCount != 0) && (OptionList == NULL)) ||
      ((OverrideData != NULL) && !NetIp6IsValidUnicast (&OverrideData->ServerIp))
      )
  {
    return EFI_INVALID_PARAMETER;
  }
 
  if (Packet != NULL) {
    *Packet = NULL;
  }
 
  *PacketLength = 0;
 
  Context.Packet    = Packet;
  Context.PacketLen = PacketLength;
  Context.Status    = EFI_SUCCESS;
 
  //
  // Fill fields of the Token for GetInfo 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         = &Context;
  Token.CheckPacket     = Mtftp6CheckPacket;
  Token.TimeoutCallback = NULL;
  Token.PacketNeeded    = NULL;
 
  //
  // Start the GetInfo operation by issue the Token.
  //
  Status = Mtftp6OperationStart (This, &Token, EFI_MTFTP6_OPCODE_RRQ);
 
  if (Status == EFI_ABORTED) {
    //
    // Return the status if failed to issue.
    //
    return Context.Status;
  }
 
  return Status;
}
 
EFI_STATUS
EFIAPI
EfiMtftp6ParseOptions (
  IN     EFI_MTFTP6_PROTOCOL  *This,
  IN     UINT32               PacketLen,
  IN     EFI_MTFTP6_PACKET    *Packet,
  OUT    UINT32               *OptionCount,
  OUT    EFI_MTFTP6_OPTION    **OptionList          OPTIONAL
  )
{
  if (This == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  return Mtftp6ParseStart (Packet, PacketLen, OptionCount, OptionList);
}
 
EFI_STATUS
EFIAPI
EfiMtftp6ReadFile (
  IN EFI_MTFTP6_PROTOCOL  *This,
  IN EFI_MTFTP6_TOKEN     *Token
  )
{
  return Mtftp6OperationStart (This, Token, EFI_MTFTP6_OPCODE_RRQ);
}
 
EFI_STATUS
EFIAPI
EfiMtftp6WriteFile (
  IN EFI_MTFTP6_PROTOCOL  *This,
  IN EFI_MTFTP6_TOKEN     *Token
  )
{
  return Mtftp6OperationStart (This, Token, EFI_MTFTP6_OPCODE_WRQ);
}
 
EFI_STATUS
EFIAPI
EfiMtftp6ReadDirectory (
  IN EFI_MTFTP6_PROTOCOL  *This,
  IN EFI_MTFTP6_TOKEN     *Token
  )
{
  return Mtftp6OperationStart (This, Token, EFI_MTFTP6_OPCODE_DIR);
}
 
EFI_STATUS
EFIAPI
EfiMtftp6Poll (
  IN EFI_MTFTP6_PROTOCOL  *This
  )
{
  MTFTP6_INSTANCE    *Instance;
  EFI_UDP6_PROTOCOL  *Udp6;
 
  if (This == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  Instance = MTFTP6_INSTANCE_FROM_THIS (This);
 
  //
  // Check the instance whether configured or in destroy.
  //
  if (Instance->Config == NULL) {
    return EFI_NOT_STARTED;
  }
 
  Udp6 = Instance->UdpIo->Protocol.Udp6;
 
  return Udp6->Poll (Udp6);
}