mirror of https://github.com/acidanthera/audk.git
431 lines
11 KiB
C
431 lines
11 KiB
C
/** @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;
|
|
}
|