/**
Validate whether the options received in the server's OACK packet is valid.
The options are valid only if:
1. The server doesn't include options not requested by us.
2. The server can only use smaller blksize than that is requested.
3. The server can only use the same timeout as requested.
4. The server doesn't change its multicast channel.
@param[in] Instance The pointer to the Mtftp6 instance.
@param[in] ReplyInfo The pointer to options information in reply packet.
@param[in] RequestInfo The pointer to requested options info.
@retval TRUE If the option in the OACK is valid.
@retval FALSE If the option is invalid.
**/
BOOLEAN
Mtftp6RrqOackValid (
IN MTFTP6_INSTANCE *Instance,
IN MTFTP6_EXT_OPTION_INFO *ReplyInfo,
IN MTFTP6_EXT_OPTION_INFO *RequestInfo
)
{
//
// It is invalid for server to return options we don't request
//
if ((ReplyInfo->BitMap & ~RequestInfo->BitMap) != 0) {
return FALSE;
}
//
// Server can only specify a smaller block size to be used and
// return the timeout matches that requested.
//
if ((((ReplyInfo->BitMap & MTFTP6_OPT_BLKSIZE_BIT) != 0) && (ReplyInfo->BlkSize > RequestInfo->BlkSize)) ||
(((ReplyInfo->BitMap & MTFTP6_OPT_TIMEOUT_BIT) != 0) && (ReplyInfo->Timeout != RequestInfo->Timeout))
) {
return FALSE;
}
//
// The server can send ",,master" to client to change its master
// setting. But if it use the specific multicast channel, it can't
// change the setting.
//
if (((ReplyInfo->BitMap & MTFTP6_OPT_MCAST_BIT) != 0) && !NetIp6IsUnspecifiedAddr (&Instance->McastIp)) {
if (!NetIp6IsUnspecifiedAddr (&ReplyInfo->McastIp) && CompareMem (
&ReplyInfo->McastIp,
&Instance->McastIp,
sizeof (EFI_IPv6_ADDRESS)
) != 0) {
return FALSE;
}
if ((ReplyInfo->McastPort != 0) && (ReplyInfo->McastPort != Instance->McastPort)) {
return FALSE;
}
}
return TRUE;
}
/**
Process the OACK packet for Rrq.
@param[in] Instance The pointer to the Mtftp6 instance.
@param[in] Packet The pointer to the received packet.
@param[in] Len The length of the packet.
@param[out] UdpPacket The net buf of received packet.
@param[out] IsCompleted If TRUE, the download has been completed.
Otherwise, the download has not been completed.
@retval EFI_DEVICE_ERROR Failed to create/start a multicast Udp6 child.
@retval EFI_TFTP_ERROR An error happened during the process.
@retval EFI_SUCCESS The OACK packet successfully processed.
**/
EFI_STATUS
Mtftp6RrqHandleOack (
IN MTFTP6_INSTANCE *Instance,
IN EFI_MTFTP6_PACKET *Packet,
IN UINT32 Len,
OUT NET_BUF **UdpPacket,
OUT BOOLEAN *IsCompleted
)
{
EFI_MTFTP6_OPTION *Options;
UINT32 Count;
MTFTP6_EXT_OPTION_INFO ExtInfo;
EFI_STATUS Status;
INTN Expected;
*IsCompleted = FALSE;
//
// If already started the master download, don't change the
// setting. Master download always succeeds.
//
Expected = Mtftp6GetNextBlockNum (&Instance->BlkList);
ASSERT (Expected != -1);
if (Instance->IsMaster && Expected != 1) {
return EFI_SUCCESS;
}
ZeroMem (&ExtInfo, sizeof (MTFTP6_EXT_OPTION_INFO));
//
// Parse the options in the packet.
//
Status = Mtftp6ParseStart (Packet, Len, &Count, &Options);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Parse the extensive options in the packet.
//
Status = Mtftp6ParseExtensionOption (Options, Count, FALSE, &ExtInfo);
if (EFI_ERROR (Status) || !Mtftp6RrqOackValid (Instance, &ExtInfo, &Instance->ExtInfo)) {
//
// Don't send an ERROR packet if the error is EFI_OUT_OF_RESOURCES.
//
if (Status != EFI_OUT_OF_RESOURCES) {
//
// Free the received packet before send new packet in ReceiveNotify,
// since the udpio might need to be reconfigured.
//
NetbufFree (*UdpPacket);
*UdpPacket = NULL;
//
// Send the Mtftp6 error message if invalid packet.
//
Mtftp6SendError (
Instance,
EFI_MTFTP6_ERRORCODE_ILLEGAL_OPERATION,
(UINT8 *) "Mal-formated OACK packet"
);
}
return EFI_TFTP_ERROR;
}
if ((ExtInfo.BitMap & MTFTP6_OPT_MCAST_BIT) != 0) {
//
// Save the multicast info. Always update the Master, only update the
// multicast IP address, block size, timeoute at the first time. If IP
// address is updated, create a UDP child to receive the multicast.
//
Instance->IsMaster = ExtInfo.IsMaster;
if (NetIp6IsUnspecifiedAddr (&Instance->McastIp)) {
if (NetIp6IsUnspecifiedAddr (&ExtInfo.McastIp) || ExtInfo.McastPort == 0) {
//
// Free the received packet before send new packet in ReceiveNotify,
// since the udpio might need to be reconfigured.
//
NetbufFree (*UdpPacket);
*UdpPacket = NULL;
//
// Send the Mtftp6 error message if invalid multi-cast setting.
//
Mtftp6SendError (
Instance,
EFI_MTFTP6_ERRORCODE_ILLEGAL_OPERATION,
(UINT8 *) "Illegal multicast setting"
);
return EFI_TFTP_ERROR;
}
//
// Create a UDP child then start receive the multicast from it.
//
CopyMem (
&Instance->McastIp,
&ExtInfo.McastIp,
sizeof (EFI_IP_ADDRESS)
);
Instance->McastPort = ExtInfo.McastPort;
Instance->McastUdpIo = UdpIoCreateIo (
Instance->Service->Controller,
Instance->Service->Image,
Mtftp6RrqConfigMcastUdpIo,
UDP_IO_UDP6_VERSION,
Instance
);
if (Instance->McastUdpIo == NULL) {
return EFI_DEVICE_ERROR;
}
Status = UdpIoRecvDatagram (
Instance->McastUdpIo,
Mtftp6RrqInput,
Instance,
0
);
if (EFI_ERROR (Status)) {
//
// Free the received packet before send new packet in ReceiveNotify,
// since the udpio might need to be reconfigured.
//
NetbufFree (*UdpPacket);
*UdpPacket = NULL;
//
// Send the Mtftp6 error message if failed to create Udp6Io to receive.
//
Mtftp6SendError (
Instance,
EFI_MTFTP6_ERRORCODE_ACCESS_VIOLATION,
(UINT8 *) "Failed to create socket to receive multicast packet"
);
return Status;
}
//
// Update the parameters used.
//
if (ExtInfo.BlkSize != 0) {
Instance->BlkSize = ExtInfo.BlkSize;
}
if (ExtInfo.Timeout != 0) {
Instance->Timeout = ExtInfo.Timeout;
}
}
} else {
Instance->IsMaster = TRUE;
if (ExtInfo.BlkSize != 0) {
Instance->BlkSize = ExtInfo.BlkSize;
}
if (ExtInfo.Timeout != 0) {
Instance->Timeout = ExtInfo.Timeout;
}
}
//
// Free the received packet before send new packet in ReceiveNotify,
// since the udpio might need to be reconfigured.
//
NetbufFree (*UdpPacket);
*UdpPacket = NULL;
//
// Send an ACK to (Expected - 1) which is 0 for unicast download,
// or tell the server we want to receive the Expected block.
//
return Mtftp6RrqSendAck (Instance, (UINT16) (Expected - 1));
}
/**
Configure the Pcb using CfgData.
@param[in] Sk Pointer to the socket of this TCP instance.
@param[in] CfgData Pointer to the TCP configuration data.
@retval EFI_SUCCESS The operation completed successfully.
@retval EFI_INVALID_PARAMETER A same access point has been configured in
another TCP instance.
@retval EFI_OUT_OF_RESOURCES Failed due to resource limits.
**/
EFI_STATUS
TcpConfigurePcb (
IN SOCKET *Sk,
IN TCP_CONFIG_DATA *CfgData
)
{
IP_IO_IP_CONFIG_DATA IpCfgData;
EFI_STATUS Status;
EFI_TCP4_OPTION *Option;
TCP_PROTO_DATA *TcpProto;
TCP_CB *Tcb;
TCP_ACCESS_POINT *TcpAp;
ASSERT ((CfgData != NULL) && (Sk != NULL) && (Sk->SockHandle != NULL));
TcpProto = (TCP_PROTO_DATA *) Sk->ProtoReserved;
Tcb = TcpProto->TcpPcb;
ASSERT (Tcb != NULL);
if (Sk->IpVersion == IP_VERSION_4) {
//
// Add Ip for send pkt to the peer
//
CopyMem (&IpCfgData.Ip4CfgData, &mIp4IoDefaultIpConfigData, sizeof (EFI_IP4_CONFIG_DATA));
IpCfgData.Ip4CfgData.DefaultProtocol = EFI_IP_PROTO_TCP;
IpCfgData.Ip4CfgData.TypeOfService = CfgData->Tcp4CfgData.TypeOfService;
IpCfgData.Ip4CfgData.TimeToLive = CfgData->Tcp4CfgData.TimeToLive;
IpCfgData.Ip4CfgData.UseDefaultAddress = CfgData->Tcp4CfgData.AccessPoint.UseDefaultAddress;
IP4_COPY_ADDRESS (
&IpCfgData.Ip4CfgData.SubnetMask,
&CfgData->Tcp4CfgData.AccessPoint.SubnetMask
);
IpCfgData.Ip4CfgData.ReceiveTimeout = (UINT32) (-1);
IP4_COPY_ADDRESS (
&IpCfgData.Ip4CfgData.StationAddress,
&CfgData->Tcp4CfgData.AccessPoint.StationAddress
);
} else {
ASSERT (Sk->IpVersion == IP_VERSION_6);
CopyMem (&IpCfgData.Ip6CfgData, &mIp6IoDefaultIpConfigData, sizeof (EFI_IP6_CONFIG_DATA));
IpCfgData.Ip6CfgData.DefaultProtocol = EFI_IP_PROTO_TCP;
IpCfgData.Ip6CfgData.TrafficClass = CfgData->Tcp6CfgData.TrafficClass;
IpCfgData.Ip6CfgData.HopLimit = CfgData->Tcp6CfgData.HopLimit;
IpCfgData.Ip6CfgData.ReceiveTimeout = (UINT32) (-1);
IP6_COPY_ADDRESS (
&IpCfgData.Ip6CfgData.StationAddress,
&CfgData->Tcp6CfgData.AccessPoint.StationAddress
);
IP6_COPY_ADDRESS (
&IpCfgData.Ip6CfgData.DestinationAddress,
&CfgData->Tcp6CfgData.AccessPoint.RemoteAddress
);
}
//
// Configure the IP instance this Tcb consumes.
//
Status = IpIoConfigIp (Tcb->IpInfo, &IpCfgData);
if (EFI_ERROR (Status)) {
goto OnExit;
}
if (Sk->IpVersion == IP_VERSION_4) {
//
// Get the default address information if the instance is configured to use default address.
//
IP4_COPY_ADDRESS (
&CfgData->Tcp4CfgData.AccessPoint.StationAddress,
&IpCfgData.Ip4CfgData.StationAddress
);
IP4_COPY_ADDRESS (
&CfgData->Tcp4CfgData.AccessPoint.SubnetMask,
&IpCfgData.Ip4CfgData.SubnetMask
);
TcpAp = (TCP_ACCESS_POINT *) &CfgData->Tcp4CfgData.AccessPoint;
} else {
IP6_COPY_ADDRESS (
&CfgData->Tcp6CfgData.AccessPoint.StationAddress,
&IpCfgData.Ip6CfgData.StationAddress
);
TcpAp = (TCP_ACCESS_POINT *) &CfgData->Tcp6CfgData.AccessPoint;
}
//
// check if we can bind this endpoint in CfgData
//
Status = TcpBind (TcpAp, Sk->IpVersion);
if (EFI_ERROR (Status)) {
DEBUG (
(EFI_D_ERROR,
"TcpConfigurePcb: Bind endpoint failed with %r\n",
Status)
);
goto OnExit;
}
//
// Initalize the operating information in this Tcb
//
ASSERT (Tcb->State == TCP_CLOSED &&
IsListEmpty (&Tcb->SndQue) &&
IsListEmpty (&Tcb->RcvQue));
TCP_SET_FLG (Tcb->CtrlFlag, TCP_CTRL_NO_KEEPALIVE);
Tcb->State = TCP_CLOSED;
Tcb->SndMss = 536;
Tcb->RcvMss = TcpGetRcvMss (Sk);
Tcb->SRtt = 0;
Tcb->Rto = 3 * TCP_TICK_HZ;
Tcb->CWnd = Tcb->SndMss;
Tcb->Ssthresh = 0xffffffff;
Tcb->CongestState = TCP_CONGEST_OPEN;
Tcb->KeepAliveIdle = TCP_KEEPALIVE_IDLE_MIN;
Tcb->KeepAlivePeriod = TCP_KEEPALIVE_PERIOD;
Tcb->MaxKeepAlive = TCP_MAX_KEEPALIVE;
Tcb->MaxRexmit = TCP_MAX_LOSS;
Tcb->FinWait2Timeout = TCP_FIN_WAIT2_TIME;
Tcb->TimeWaitTimeout = TCP_TIME_WAIT_TIME;
Tcb->ConnectTimeout = TCP_CONNECT_TIME;
if (Sk->IpVersion == IP_VERSION_4) {
//
// initialize Tcb in the light of CfgData
//
Tcb->Ttl = CfgData->Tcp4CfgData.TimeToLive;
Tcb->Tos = CfgData->Tcp4CfgData.TypeOfService;
Tcb->UseDefaultAddr = CfgData->Tcp4CfgData.AccessPoint.UseDefaultAddress;
CopyMem (&Tcb->LocalEnd.Ip, &CfgData->Tcp4CfgData.AccessPoint.StationAddress, sizeof (IP4_ADDR));
Tcb->LocalEnd.Port = HTONS (CfgData->Tcp4CfgData.AccessPoint.StationPort);
IP4_COPY_ADDRESS (&Tcb->SubnetMask, &CfgData->Tcp4CfgData.AccessPoint.SubnetMask);
CopyMem (&Tcb->RemoteEnd.Ip, &CfgData->Tcp4CfgData.AccessPoint.RemoteAddress, sizeof (IP4_ADDR));
Tcb->RemoteEnd.Port = HTONS (CfgData->Tcp4CfgData.AccessPoint.RemotePort);
Option = CfgData->Tcp4CfgData.ControlOption;
} else {
Tcb->Ttl = CfgData->Tcp6CfgData.HopLimit;
Tcb->Tos = CfgData->Tcp6CfgData.TrafficClass;
IP6_COPY_ADDRESS (&Tcb->LocalEnd.Ip, &CfgData->Tcp6CfgData.AccessPoint.StationAddress);
Tcb->LocalEnd.Port = HTONS (CfgData->Tcp6CfgData.AccessPoint.StationPort);
IP6_COPY_ADDRESS (&Tcb->RemoteEnd.Ip, &CfgData->Tcp6CfgData.AccessPoint.RemoteAddress);
Tcb->RemoteEnd.Port = HTONS (CfgData->Tcp6CfgData.AccessPoint.RemotePort);
//
// Type EFI_TCP4_OPTION and EFI_TCP6_OPTION are the same.
//
Option = (EFI_TCP4_OPTION *) CfgData->Tcp6CfgData.ControlOption;
}
if (Option != NULL) {
SET_RCV_BUFFSIZE (
Sk,
(UINT32) (TCP_COMP_VAL (
TCP_RCV_BUF_SIZE_MIN,
TCP_RCV_BUF_SIZE,
TCP_RCV_BUF_SIZE,
Option->ReceiveBufferSize
)
)
);
SET_SND_BUFFSIZE (
Sk,
(UINT32) (TCP_COMP_VAL (
TCP_SND_BUF_SIZE_MIN,
TCP_SND_BUF_SIZE,
TCP_SND_BUF_SIZE,
Option->SendBufferSize
)
)
);
SET_BACKLOG (
Sk,
(UINT32) (TCP_COMP_VAL (
TCP_BACKLOG_MIN,
TCP_BACKLOG,
TCP_BACKLOG,
Option->MaxSynBackLog
)
)
);
Tcb->MaxRexmit = (UINT16) TCP_COMP_VAL (
TCP_MAX_LOSS_MIN,
TCP_MAX_LOSS,
TCP_MAX_LOSS,
Option->DataRetries
);
Tcb->FinWait2Timeout = TCP_COMP_VAL (
TCP_FIN_WAIT2_TIME,
TCP_FIN_WAIT2_TIME_MAX,
TCP_FIN_WAIT2_TIME,
(UINT32) (Option->FinTimeout * TCP_TICK_HZ)
);
if (Option->TimeWaitTimeout != 0) {
Tcb->TimeWaitTimeout = TCP_COMP_VAL (
TCP_TIME_WAIT_TIME,
TCP_TIME_WAIT_TIME_MAX,
TCP_TIME_WAIT_TIME,
(UINT32) (Option->TimeWaitTimeout * TCP_TICK_HZ)
);
} else {
Tcb->TimeWaitTimeout = 0;
}
if (Option->KeepAliveProbes != 0) {
TCP_CLEAR_FLG (Tcb->CtrlFlag, TCP_CTRL_NO_KEEPALIVE);
Tcb->MaxKeepAlive = (UINT8) TCP_COMP_VAL (
TCP_MAX_KEEPALIVE_MIN,
TCP_MAX_KEEPALIVE,
TCP_MAX_KEEPALIVE,
Option->KeepAliveProbes
);
Tcb->KeepAliveIdle = TCP_COMP_VAL (
TCP_KEEPALIVE_IDLE_MIN,
TCP_KEEPALIVE_IDLE_MAX,
TCP_KEEPALIVE_IDLE_MIN,
(UINT32) (Option->KeepAliveTime * TCP_TICK_HZ)
);
Tcb->KeepAlivePeriod = TCP_COMP_VAL (
TCP_KEEPALIVE_PERIOD_MIN,
TCP_KEEPALIVE_PERIOD,
TCP_KEEPALIVE_PERIOD,
(UINT32) (Option->KeepAliveInterval * TCP_TICK_HZ)
);
}
Tcb->ConnectTimeout = TCP_COMP_VAL (
TCP_CONNECT_TIME_MIN,
TCP_CONNECT_TIME,
TCP_CONNECT_TIME,
(UINT32) (Option->ConnectionTimeout * TCP_TICK_HZ)
);
if (!Option->EnableNagle) {
TCP_SET_FLG (Tcb->CtrlFlag, TCP_CTRL_NO_NAGLE);
}
if (!Option->EnableTimeStamp) {
TCP_SET_FLG (Tcb->CtrlFlag, TCP_CTRL_NO_TS);
}
if (!Option->EnableWindowScaling) {
TCP_SET_FLG (Tcb->CtrlFlag, TCP_CTRL_NO_WS);
}
}
//
// The socket is bound, the <SrcIp, SrcPort, DstIp, DstPort> is
// determined, construct the IP device path and install it.
//
Status = TcpInstallDevicePath (Sk);
if (EFI_ERROR (Status)) {
goto OnExit;
}
//
// update state of Tcb and socket
//
if (((Sk->IpVersion == IP_VERSION_4) && !CfgData->Tcp4CfgData.AccessPoint.ActiveFlag) ||
((Sk->IpVersion == IP_VERSION_6) && !CfgData->Tcp6CfgData.AccessPoint.ActiveFlag)
) {
TcpSetState (Tcb, TCP_LISTEN);
SockSetState (Sk, SO_LISTENING);
Sk->ConfigureState = SO_CONFIGURED_PASSIVE;
} else {
Sk->ConfigureState = SO_CONFIGURED_ACTIVE;
}
if (Sk->IpVersion == IP_VERSION_6) {
Tcb->Tick = TCP6_REFRESH_NEIGHBOR_TICK;
if (NetIp6IsUnspecifiedAddr (&Tcb->RemoteEnd.Ip.v6)) {
Tcb->RemoteIpZero = TRUE;
}
}
TcpInsertTcb (Tcb);
OnExit:
return Status;
}
