Mtftp4Option.c

Go to the documentation of this file.

 
#include "Mtftp4Impl.h"
 
CHAR8  *mMtftp4SupportedOptions[MTFTP4_SUPPORTED_OPTIONS] = {
  "blksize",
  "windowsize",
  "timeout",
  "tsize",
  "multicast"
};
 
BOOLEAN
NetStringEqualNoCase (
  IN UINT8  *Str1,
  IN UINT8  *Str2
  )
{
  UINT8  Ch1;
  UINT8  Ch2;
 
  ASSERT ((Str1 != NULL) && (Str2 != NULL));
 
  for ( ; (*Str1 != '\0') && (*Str2 != '\0'); Str1++, Str2++) {
    Ch1 = *Str1;
    Ch2 = *Str2;
 
    //
    // Convert them to lower case then compare two
    //
    if (('A' <= Ch1) && (Ch1 <= 'Z')) {
      Ch1 += 'a' - 'A';
    }
 
    if (('A' <= Ch2) && (Ch2 <= 'Z')) {
      Ch2 += 'a' - 'A';
    }
 
    if (Ch1 != Ch2) {
      return FALSE;
    }
  }
 
  return (BOOLEAN)(*Str1 == *Str2);
}
 
UINT32
NetStringToU32 (
  IN UINT8  *Str
  )
{
  UINT32  Num;
 
  ASSERT (Str != NULL);
 
  Num = 0;
 
  for ( ; NET_IS_DIGIT (*Str); Str++) {
    Num = Num * 10 + (*Str - '0');
  }
 
  return Num;
}
 
EFI_STATUS
NetStringToIp (
  IN     UINT8  *Str,
  OUT IP4_ADDR  *Ip
  )
{
  UINT32  Byte;
  UINT32  Addr;
  UINTN   Index;
 
  *Ip  = 0;
  Addr = 0;
 
  for (Index = 0; Index < 4; Index++) {
    if (!NET_IS_DIGIT (*Str)) {
      return EFI_INVALID_PARAMETER;
    }
 
    Byte = NetStringToU32 (Str);
 
    if (Byte > 255) {
      return EFI_INVALID_PARAMETER;
    }
 
    Addr = (Addr << 8) | Byte;
 
    //
    // Skip all the digitals and check whether the separator is the dot
    //
    while (NET_IS_DIGIT (*Str)) {
      Str++;
    }
 
    if ((Index < 3) && (*Str != '.')) {
      return EFI_INVALID_PARAMETER;
    }
 
    Str++;
  }
 
  *Ip = Addr;
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
Mtftp4FillOptions (
  IN     EFI_MTFTP4_PACKET  *Packet,
  IN     UINT32             PacketLen,
  IN OUT UINT32             *Count,
  OUT EFI_MTFTP4_OPTION     *Options          OPTIONAL
  )
{
  UINT8  *Cur;
  UINT8  *Last;
  UINT8  Num;
  UINT8  *Name;
  UINT8  *Value;
 
  Num  = 0;
  Cur  = (UINT8 *)Packet + MTFTP4_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_INVALID_PARAMETER;
    }
 
    Value = ++Cur;
 
    while (*Cur != 0) {
      Cur++;
    }
 
    Num++;
 
    if ((Options != NULL) && (Num <= *Count)) {
      Options[Num - 1].OptionStr = Name;
      Options[Num - 1].ValueStr  = Value;
    }
 
    Cur++;
  }
 
  if ((*Count < Num) || (Options == NULL)) {
    *Count = Num;
    return EFI_BUFFER_TOO_SMALL;
  }
 
  *Count = Num;
  return EFI_SUCCESS;
}
 
EFI_STATUS
Mtftp4ExtractOptions (
  IN     EFI_MTFTP4_PACKET  *Packet,
  IN     UINT32             PacketLen,
  OUT UINT32                *OptionCount,
  OUT EFI_MTFTP4_OPTION     **OptionList        OPTIONAL
  )
{
  EFI_STATUS  Status;
 
  *OptionCount = 0;
 
  if (OptionList != NULL) {
    *OptionList = NULL;
  }
 
  if (NTOHS (Packet->OpCode) != EFI_MTFTP4_OPCODE_OACK) {
    return EFI_INVALID_PARAMETER;
  }
 
  if (PacketLen == MTFTP4_OPCODE_LEN) {
    return EFI_SUCCESS;
  }
 
  //
  // The last byte must be zero to terminate the options
  //
  if (*((UINT8 *)Packet + PacketLen - 1) != 0) {
    return EFI_INVALID_PARAMETER;
  }
 
  //
  // Get the number of options
  //
  Status = Mtftp4FillOptions (Packet, PacketLen, OptionCount, NULL);
 
  if ((Status == EFI_SUCCESS) || (Status != EFI_BUFFER_TOO_SMALL)) {
    return Status;
  }
 
  //
  // Allocate memory for the options, then call Mtftp4FillOptions to
  // fill it if caller want that.
  //
  if (OptionList == NULL) {
    return EFI_SUCCESS;
  }
 
  *OptionList = AllocatePool (*OptionCount * sizeof (EFI_MTFTP4_OPTION));
 
  if (*OptionList == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  Mtftp4FillOptions (Packet, PacketLen, OptionCount, *OptionList);
  return EFI_SUCCESS;
}
 
EFI_STATUS
Mtftp4ExtractMcast (
  IN     UINT8          *Value,
  IN OUT MTFTP4_OPTION  *Option
  )
{
  EFI_STATUS  Status;
  UINT32      Num;
 
  //
  // The multicast option is formatted like "204.0.0.1,1857,1"
  // The server can also omit the ip and port, use ",,1"
  //
  if (*Value == ',') {
    Option->McastIp = 0;
  } else {
    Status = NetStringToIp (Value, &Option->McastIp);
 
    if (EFI_ERROR (Status)) {
      return Status;
    }
 
    while ((*Value != 0) && (*Value != ',')) {
      Value++;
    }
  }
 
  if (*Value != ',') {
    return EFI_INVALID_PARAMETER;
  }
 
  Value++;
 
  //
  // Convert the port setting. the server can send us a port number or
  // empty string. such as the port in ",,1"
  //
  if (*Value == ',') {
    Option->McastPort = 0;
  } else {
    Num = NetStringToU32 (Value);
 
    if (Num > 65535) {
      return EFI_INVALID_PARAMETER;
    }
 
    Option->McastPort = (UINT16)Num;
 
    while (NET_IS_DIGIT (*Value)) {
      Value++;
    }
  }
 
  if (*Value != ',') {
    return EFI_INVALID_PARAMETER;
  }
 
  Value++;
 
  //
  // Check the master/slave setting, 1 for master, 0 for slave.
  //
  Num = NetStringToU32 (Value);
 
  if ((Num != 0) && (Num != 1)) {
    return EFI_INVALID_PARAMETER;
  }
 
  Option->Master = (BOOLEAN)(Num == 1);
 
  while (NET_IS_DIGIT (*Value)) {
    Value++;
  }
 
  if (*Value != '\0') {
    return EFI_INVALID_PARAMETER;
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
Mtftp4ParseOption (
  IN     EFI_MTFTP4_OPTION  *Options,
  IN     UINT32             Count,
  IN     BOOLEAN            Request,
  IN     UINT16             Operation,
  OUT MTFTP4_OPTION         *MtftpOption
  )
{
  EFI_STATUS         Status;
  UINT32             Index;
  UINT32             Value;
  EFI_MTFTP4_OPTION  *This;
 
  MtftpOption->Exist = 0;
 
  for (Index = 0; Index < Count; Index++) {
    This = Options + Index;
 
    if ((This->OptionStr == NULL) || (This->ValueStr == NULL)) {
      return EFI_INVALID_PARAMETER;
    }
 
    if (NetStringEqualNoCase (This->OptionStr, (UINT8 *)"blksize")) {
      //
      // block size option, valid value is between [8, 65464]
      //
      Value = NetStringToU32 (This->ValueStr);
 
      if ((Value < 8) || (Value > 65464)) {
        return EFI_INVALID_PARAMETER;
      }
 
      MtftpOption->BlkSize = (UINT16)Value;
      MtftpOption->Exist  |= MTFTP4_BLKSIZE_EXIST;
    } else if (NetStringEqualNoCase (This->OptionStr, (UINT8 *)"timeout")) {
      //
      // timeout option, valid value is between [1, 255]
      //
      Value = NetStringToU32 (This->ValueStr);
 
      if ((Value < 1) || (Value > 255)) {
        return EFI_INVALID_PARAMETER;
      }
 
      MtftpOption->Timeout = (UINT8)Value;
    } else if (NetStringEqualNoCase (This->OptionStr, (UINT8 *)"tsize")) {
      //
      // tsize option, the biggest transfer supported is 4GB with block size option
      //
      MtftpOption->Tsize  = NetStringToU32 (This->ValueStr);
      MtftpOption->Exist |= MTFTP4_TSIZE_EXIST;
    } else if (NetStringEqualNoCase (This->OptionStr, (UINT8 *)"multicast")) {
      //
      // Multicast option, if it is a request, the value must be a zero
      // length string, otherwise, it is formatted like "204.0.0.1,1857,1\0"
      //
      if (Request) {
        if (*(This->ValueStr) != '\0') {
          return EFI_INVALID_PARAMETER;
        }
      } else {
        Status = Mtftp4ExtractMcast (This->ValueStr, MtftpOption);
 
        if (EFI_ERROR (Status)) {
          return Status;
        }
      }
 
      MtftpOption->Exist |= MTFTP4_MCAST_EXIST;
    } else if (NetStringEqualNoCase (This->OptionStr, (UINT8 *)"windowsize")) {
      if (Operation == EFI_MTFTP4_OPCODE_WRQ) {
        //
        // Currently, windowsize is not supported in the write operation.
        //
        return EFI_UNSUPPORTED;
      }
 
      Value = NetStringToU32 (This->ValueStr);
 
      if (Value < 1) {
        return EFI_INVALID_PARAMETER;
      }
 
      MtftpOption->WindowSize = (UINT16)Value;
      MtftpOption->Exist     |= MTFTP4_WINDOWSIZE_EXIST;
    } else if (Request) {
      //
      // Ignore the unsupported option if it is a reply, and return
      // EFI_UNSUPPORTED if it's a request according to the UEFI spec.
      //
      return EFI_UNSUPPORTED;
    }
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
Mtftp4ParseOptionOack (
  IN     EFI_MTFTP4_PACKET  *Packet,
  IN     UINT32             PacketLen,
  IN     UINT16             Operation,
  OUT MTFTP4_OPTION         *MtftpOption
  )
{
  EFI_MTFTP4_OPTION  *OptionList;
  EFI_STATUS         Status;
  UINT32             Count;
 
  MtftpOption->Exist = 0;
 
  Status = Mtftp4ExtractOptions (Packet, PacketLen, &Count, &OptionList);
 
  if (EFI_ERROR (Status) || (Count == 0)) {
    return Status;
  }
 
  ASSERT (OptionList != NULL);
 
  Status = Mtftp4ParseOption (OptionList, Count, FALSE, Operation, MtftpOption);
 
  FreePool (OptionList);
  return Status;
}