Mtftp6Option.c

Go to the documentation of this file.

 
#include "Mtftp6Impl.h"
 
CHAR8  *mMtftp6SupportedOptions[MTFTP6_SUPPORTED_OPTIONS_NUM] = {
  "blksize",
  "windowsize",
  "timeout",
  "tsize",
  "multicast"
};
 
EFI_STATUS
Mtftp6ParseMcastOption (
  IN UINT8                   *Str,
  IN MTFTP6_EXT_OPTION_INFO  *ExtInfo
  )
{
  EFI_STATUS  Status;
  UINT32      Num;
  CHAR8       *Ip6Str;
  CHAR8       *TempStr;
 
  //
  // The multicast option is formatted like "addr,port,mc"
  // The server can also omit the ip and port, use ",,1"
  //
  if (*Str == ',') {
    ZeroMem (&ExtInfo->McastIp, sizeof (EFI_IPv6_ADDRESS));
  } else {
    Ip6Str = (CHAR8 *)AllocateCopyPool (AsciiStrSize ((CHAR8 *)Str), Str);
    if (Ip6Str == NULL) {
      return EFI_OUT_OF_RESOURCES;
    }
 
    //
    // The IPv6 address locates before comma in the input Str.
    //
    TempStr = Ip6Str;
    while ((*TempStr != '\0') && (*TempStr != ',')) {
      TempStr++;
    }
 
    *TempStr = '\0';
 
    Status = NetLibAsciiStrToIp6 (Ip6Str, &ExtInfo->McastIp);
    FreePool (Ip6Str);
 
    if (EFI_ERROR (Status)) {
      return Status;
    }
 
    while ((*Str != '\0') && (*Str != ',')) {
      Str++;
    }
  }
 
  if (*Str != ',') {
    return EFI_INVALID_PARAMETER;
  }
 
  Str++;
 
  //
  // Convert the port setting. the server can send us a port number or
  // empty string. such as the port in ",,1"
  //
  if (*Str == ',') {
    ExtInfo->McastPort = 0;
  } else {
    Num = (UINT32)AsciiStrDecimalToUintn ((CHAR8 *)Str);
 
    if (Num > 65535) {
      return EFI_INVALID_PARAMETER;
    }
 
    ExtInfo->McastPort = (UINT16)Num;
 
    while (NET_IS_DIGIT (*Str)) {
      Str++;
    }
  }
 
  if (*Str != ',') {
    return EFI_INVALID_PARAMETER;
  }
 
  Str++;
 
  //
  // Check the master/slave setting, 1 for master, 0 for slave.
  //
  Num = (UINT32)AsciiStrDecimalToUintn ((CHAR8 *)Str);
 
  if ((Num != 0) && (Num != 1)) {
    return EFI_INVALID_PARAMETER;
  }
 
  ExtInfo->IsMaster = (BOOLEAN)(Num == 1);
 
  while (NET_IS_DIGIT (*Str)) {
    Str++;
  }
 
  if (*Str != '\0') {
    return EFI_INVALID_PARAMETER;
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
Mtftp6ParseExtensionOption (
  IN EFI_MTFTP6_OPTION       *Options,
  IN UINT32                  Count,
  IN BOOLEAN                 IsRequest,
  IN UINT16                  Operation,
  IN MTFTP6_EXT_OPTION_INFO  *ExtInfo
  )
{
  EFI_STATUS         Status;
  EFI_MTFTP6_OPTION  *Opt;
  UINT32             Index;
  UINT32             Value;
 
  ExtInfo->BitMap = 0;
 
  for (Index = 0; Index < Count; Index++) {
    Opt = Options + Index;
 
    if ((Opt->OptionStr == NULL) || (Opt->ValueStr == NULL)) {
      return EFI_INVALID_PARAMETER;
    }
 
    if (AsciiStriCmp ((CHAR8 *)Opt->OptionStr, "blksize") == 0) {
      //
      // block size option, valid value is between [8, 65464]
      //
      Value = (UINT32)AsciiStrDecimalToUintn ((CHAR8 *)Opt->ValueStr);
 
      if ((Value < 8) || (Value > 65464)) {
        return EFI_INVALID_PARAMETER;
      }
 
      ExtInfo->BlkSize = (UINT16)Value;
      ExtInfo->BitMap |= MTFTP6_OPT_BLKSIZE_BIT;
    } else if (AsciiStriCmp ((CHAR8 *)Opt->OptionStr, "timeout") == 0) {
      //
      // timeout option, valid value is between [1, 255]
      //
      Value = (UINT32)AsciiStrDecimalToUintn ((CHAR8 *)Opt->ValueStr);
 
      if ((Value < 1) || (Value > 255)) {
        return EFI_INVALID_PARAMETER;
      }
 
      ExtInfo->Timeout = (UINT8)Value;
      ExtInfo->BitMap |= MTFTP6_OPT_TIMEOUT_BIT;
    } else if (AsciiStriCmp ((CHAR8 *)Opt->OptionStr, "tsize") == 0) {
      //
      // tsize option, the biggest transfer supported is 4GB with block size option
      //
      ExtInfo->Tsize   = (UINT32)AsciiStrDecimalToUintn ((CHAR8 *)Opt->ValueStr);
      ExtInfo->BitMap |= MTFTP6_OPT_TSIZE_BIT;
    } else if (AsciiStriCmp ((CHAR8 *)Opt->OptionStr, "multicast") == 0) {
      //
      // Multicast option, if it is a request, the value must be a zero string,
      // otherwise, it must be like "addr,port,mc" string, mc indicates master.
      //
      if (!IsRequest) {
        Status = Mtftp6ParseMcastOption (Opt->ValueStr, ExtInfo);
 
        if (EFI_ERROR (Status)) {
          return Status;
        }
      } else if (*(Opt->ValueStr) != '\0') {
        return EFI_INVALID_PARAMETER;
      }
 
      ExtInfo->BitMap |= MTFTP6_OPT_MCAST_BIT;
    } else if (AsciiStriCmp ((CHAR8 *)Opt->OptionStr, "windowsize") == 0) {
      if (Operation == EFI_MTFTP6_OPCODE_WRQ) {
        //
        // Currently, windowsize is not supported in the write operation.
        //
        return EFI_UNSUPPORTED;
      }
 
      Value = (UINT32)AsciiStrDecimalToUintn ((CHAR8 *)Opt->ValueStr);
 
      if ((Value < 1)) {
        return EFI_INVALID_PARAMETER;
      }
 
      ExtInfo->WindowSize = (UINT16)Value;
      ExtInfo->BitMap    |= MTFTP6_OPT_WINDOWSIZE_BIT;
    } else if (IsRequest) {
      //
      // If it's a request, unsupported; else if it's a reply, ignore.
      //
      return EFI_UNSUPPORTED;
    }
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
Mtftp6ParsePacketOption (
  IN     EFI_MTFTP6_PACKET  *Packet,
  IN     UINT32             PacketLen,
  IN OUT UINT32             *Count,
  IN     EFI_MTFTP6_OPTION  *Options          OPTIONAL
  )
{
  UINT8  *Cur;
  UINT8  *Last;
  UINT8  Num;
  UINT8  *Name;
  UINT8  *Value;
 
  Num  = 0;
  Cur  = (UINT8 *)Packet + MTFTP6_OPCODE_LEN;
  Last = (UINT8 *)Packet + PacketLen - 1;
 
  //
  // process option name and value pairs.
  // The last byte is always zero.
  //
  while (Cur < Last) {
    Name = Cur;
 
    while (*Cur != 0) {
      Cur++;
    }
 
    if (Cur == Last) {
      return EFI_PROTOCOL_ERROR;
    }
 
    Value = ++Cur;
 
    while (*Cur != 0) {
      Cur++;
    }
 
    Num++;
 
    if ((Options != NULL) && (Num <= *Count)) {
      Options[Num - 1].OptionStr = Name;
      Options[Num - 1].ValueStr  = Value;
    }
 
    Cur++;
  }
 
  //
  // Return buffer too small if the buffer passed-in isn't enough.
  //
  if ((*Count < Num) || (Options == NULL)) {
    *Count = Num;
    return EFI_BUFFER_TOO_SMALL;
  }
 
  *Count = Num;
  return EFI_SUCCESS;
}
 
EFI_STATUS
Mtftp6ParseStart (
  IN     EFI_MTFTP6_PACKET  *Packet,
  IN     UINT32             PacketLen,
  IN OUT UINT32             *OptionCount,
  OUT EFI_MTFTP6_OPTION     **OptionList          OPTIONAL
  )
{
  EFI_STATUS  Status;
 
  if ((PacketLen == 0) || (Packet == NULL) || (OptionCount == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  *OptionCount = 0;
 
  if (OptionList != NULL) {
    *OptionList = NULL;
  }
 
  if (NTOHS (Packet->OpCode) != EFI_MTFTP6_OPCODE_OACK) {
    return EFI_INVALID_PARAMETER;
  }
 
  //
  // The last byte must be zero to terminate the options.
  //
  if (*((UINT8 *)Packet + PacketLen - 1) != 0) {
    return EFI_PROTOCOL_ERROR;
  }
 
  //
  // Parse packet with NULL buffer for the first time to get the number
  // of options in the packet.
  //
  Status = Mtftp6ParsePacketOption (Packet, PacketLen, OptionCount, NULL);
 
  if (Status != EFI_BUFFER_TOO_SMALL) {
    return Status;
  }
 
  //
  // Return not found if there is no option parsed.
  //
  if (*OptionCount == 0) {
    return EFI_NOT_FOUND;
  }
 
  //
  // Only need parse out the number of options.
  //
  if (OptionList == NULL) {
    return EFI_SUCCESS;
  }
 
  //
  // Allocate the buffer according to the option number parsed before.
  //
  *OptionList = AllocateZeroPool (*OptionCount * sizeof (EFI_MTFTP6_OPTION));
 
  if (*OptionList == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  //
  // Parse packet with allocated buffer for the second time to fill the pointer array
  // of the options in the packet.
  //
  Status = Mtftp6ParsePacketOption (Packet, PacketLen, OptionCount, *OptionList);
 
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  return EFI_SUCCESS;
}