blob: 398514dd66591933c9e030b107946431fdb0e478 [file] [log] [blame]
/** @file
Mtftp6 option parse functions implementation.
Copyright (c) 2009 - 2018, Intel Corporation. All rights reserved.<BR>
SPDX-License-Identifier: BSD-2-Clause-Patent
**/
#include "Mtftp6Impl.h"
CHAR8 *mMtftp6SupportedOptions[MTFTP6_SUPPORTED_OPTIONS_NUM] = {
"blksize",
"windowsize",
"timeout",
"tsize",
"multicast"
};
/**
Parse the NULL terminated ASCII string of multicast option.
@param[in] Str The pointer to the Ascii string of multicast option.
@param[in] ExtInfo The pointer to the option information to be filled.
@retval EFI_SUCCESS Parse the multicast option successfully.
@retval EFI_INVALID_PARAMETER The string is malformatted.
@retval EFI_OUT_OF_RESOURCES Failed to perform the operation due to lack of
resources.
**/
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;
}
/**
Parse the MTFTP6 extension options.
@param[in] Options The pointer to the extension options list.
@param[in] Count The num of the extension options.
@param[in] IsRequest If FALSE, the extension options is included
by a request packet.
@param[in] Operation The current performed operation.
@param[in] ExtInfo The pointer to the option information to be filled.
@retval EFI_SUCCESS Parse the multicast option successfully.
@retval EFI_INVALID_PARAMETER There is one option is malformatted at least.
@retval EFI_UNSUPPORTED There is one option is not supported at least.
**/
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;
}
/**
Go through the packet to fill the options array with the start
addresses of each MTFTP option name/value pair.
@param[in] Packet The packet to be checked.
@param[in] PacketLen The length of the packet.
@param[in, out] Count The num of the Options on input.
The actual one on output.
@param[in] Options The option array to be filled.
It is optional.
@retval EFI_SUCCESS The packet has been parsed successfully.
@retval EFI_INVALID_PARAMETER The packet is malformatted.
@retval EFI_BUFFER_TOO_SMALL The Options array is too small.
@retval EFI_PROTOCOL_ERROR An unexpected MTFTPv6 packet was received.
**/
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;
}
/**
Go through the packet, generate option list array and fill it
by the result of parse options.
@param[in] Packet The packet to be checked.
@param[in] PacketLen The length of the packet.
@param[in, out] OptionCount The num of the Options on input.
The actual one on output.
@param[out] OptionList The option list array to be generated
and filled. It is optional.
@retval EFI_SUCCESS The packet has been parsed successfully.
@retval EFI_INVALID_PARAMETER The packet is malformatted.
@retval EFI_PROTOCOL_ERROR There is one option is malformatted at least.
@retval EFI_NOT_FOUND The packet has no options.
@retval EFI_OUT_OF_RESOURCES Failed to allocate memory for the array.
@retval EFI_BUFFER_TOO_SMALL The size of option list array is too small.
**/
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;
}