NetLibGetMacString (
IN EFI_HANDLE SnpHandle,
IN EFI_HANDLE ImageHandle,
- IN OUT CONST CHAR16 **MacString
+ IN OUT CHAR16 **MacString
);
EFI_HANDLE
case ICMP_CODE_UNREACH_PROTOCOL:\r
case ICMP_CODE_UNREACH_PORT:\r
case ICMP_CODE_UNREACH_SRCFAIL:\r
- IcmpErr = ICMP_ERR_UNREACH_NET + Code;\r
+ IcmpErr = (ICMP_ERROR) (ICMP_ERR_UNREACH_NET + Code);\r
\r
break;\r
\r
return EFI_ABORTED;\r
}\r
\r
- IcmpErr = Code + ICMP_ERR_TIMXCEED_INTRANS;\r
+ IcmpErr = (ICMP_ERROR) (Code + ICMP_ERR_TIMXCEED_INTRANS);\r
\r
break;\r
\r
\r
if (EFI_SUCCESS == Status) {\r
\r
- IpIo->PktRcvdNotify (EFI_SUCCESS, 0, &Session, Pkt, IpIo->RcvdContext);\r
+ IpIo->PktRcvdNotify (EFI_SUCCESS, (ICMP_ERROR) 0, &Session, Pkt, IpIo->RcvdContext);\r
} else {\r
//\r
// Status is EFI_ICMP_ERROR\r
IpIo->Controller,\r
IpIo->Image,\r
&IpInfo->ChildHandle,\r
- &IpInfo->Ip\r
+ (VOID **) &IpInfo->Ip\r
);\r
if (EFI_ERROR (Status)) {\r
goto ReleaseIpInfo;\r
Status = gBS->HandleProtocol (
DeviceHandleBuffer[Index],
&gEfiDriverBindingProtocolGuid,
- &DriverBinding
+ (VOID **) &DriverBinding
);
if (EFI_ERROR (Status)) {
&gEfiDriverBindingProtocolGuid,
DriverBinding
);
-#if (EFI_SPECIFICATION_VERSION >= 0x00020000)
- Status = gBS->HandleProtocol (
- DeviceHandleBuffer[Index],
- &gEfiComponentName2ProtocolGuid,
- &ComponentName
- );
- if (!EFI_ERROR (Status)) {
- gBS->UninstallProtocolInterface (
- ImageHandle,
- &gEfiComponentName2ProtocolGuid,
- ComponentName
- );
- }
-#else
Status = gBS->HandleProtocol (
DeviceHandleBuffer[Index],
&gEfiComponentNameProtocolGuid,
- &ComponentName
+ (VOID **) &ComponentName
);
if (!EFI_ERROR (Status)) {
gBS->UninstallProtocolInterface (
ComponentName
);
}
-#endif
Status = gBS->HandleProtocol (
DeviceHandleBuffer[Index],
&gEfiDriverConfigurationProtocolGuid,
- &DriverConfiguration
+ (VOID **) &DriverConfiguration
);
if (!EFI_ERROR (Status)) {
Status = gBS->HandleProtocol (
DeviceHandleBuffer[Index],
&gEfiDriverDiagnosticsProtocolGuid,
- &DriverDiagnostics
+ (VOID **) &DriverDiagnostics
);
if (!EFI_ERROR (Status)) {
NetLibGetMacString (
IN EFI_HANDLE SnpHandle,
IN EFI_HANDLE ImageHandle,
- IN OUT CONST CHAR16 **MacString
+ IN OUT CHAR16 **MacString
)
{
EFI_STATUS Status;
// Convert the mac address into a unicode string.
//
for (Index = 0; Index < Mode->HwAddressSize; Index++) {
- MacAddress[Index * 2] = NibbleToHexChar (Mode->CurrentAddress.Addr[Index] >> 4);
+ MacAddress[Index * 2] = NibbleToHexChar ((UINT8) (Mode->CurrentAddress.Addr[Index] >> 4));
MacAddress[Index * 2 + 1] = NibbleToHexChar (Mode->CurrentAddress.Addr[Index]);
}
//\r
// Get the recycled transmit buffer status.\r
//\r
- Snp->GetStatus (Snp, NULL, &TxBuf);\r
+ Snp->GetStatus (Snp, NULL, (VOID **) &TxBuf);\r
\r
if (!EFI_ERROR (gBS->CheckEvent (TimeoutEvent))) {\r
Status = EFI_TIMEOUT;\r
//\r
Len = 0;\r
Len += (UINT32) AsciiSPrint (\r
- Buf,\r
+ (CHAR8 *) Buf,\r
BufLen,\r
"<%d> %a %d %d:%d:%d ",\r
Pri,\r
Len--;\r
\r
Len += (UINT32) AsciiSPrint (\r
- Buf + Len,\r
+ (CHAR8 *) (Buf + Len),\r
BufLen - Len,\r
"Tiano %a: %a (Line: %d File: %a)",\r
Module,\r
}\r
\r
VA_START (Marker, Format);\r
- AsciiVSPrint (Buf, NET_DEBUG_MSG_LEN, Format, Marker);\r
+ AsciiVSPrint ((CHAR8 *) Buf, NET_DEBUG_MSG_LEN, (CHAR8 *) Format, Marker);\r
VA_END (Marker);\r
\r
return Buf;\r
// The checksum starts with an odd byte, swap\r
// the checksum before added to total checksum\r
//\r
- BlockSum = NET_SWAP_SHORT (BlockSum);\r
+ BlockSum = (UINT16) NET_SWAP_SHORT (BlockSum);\r
}\r
\r
TotalSum = NetAddChecksum (BlockSum, TotalSum);\r
Status = gBS->OpenProtocol (\r
UdpIo->UdpHandle,\r
&gEfiUdp4ProtocolGuid,\r
- &UdpIo->Udp,\r
+ (VOID **) &UdpIo->Udp,\r
Image,\r
Controller,\r
EFI_OPEN_PROTOCOL_BY_DRIVER\r
[LibraryClasses.IPF]\r
IoLib|$(WORKSPACE)/MdePkg/Library/BaseIoLibIntrinsic/BaseIoLibIntrinsic.inf\r
\r
-[LibraryClasses.EBC]\r
-\r
+[LibraryClasses.EBC.DXE_RUNTIME_DRIVER]\r
+ IoLib|$(WORKSPACE)/IntelFrameworkPkg/Library/DxeIoLibCpuIo/DxeIoLibCpuIo.inf\r
\r
[LibraryClasses.common.PEI_CORE]\r
PeiCoreEntryPoint|$(WORKSPACE)/MdePkg/Library/PeiCoreEntryPoint/PeiCoreEntryPoint.inf\r
}\r
\r
if (NicAddr != NULL) {\r
- *NicAddr = Instance->NicAddr;\r
+ CopyMem (NicAddr, &Instance->NicAddr, sizeof (NIC_ADDR));\r
}\r
\r
return EFI_SUCCESS;\r
goto ON_EXIT;\r
}\r
\r
- Instance->NicConfig->NicAddr = Instance->NicAddr;\r
+ CopyMem (&Instance->NicConfig->NicAddr, &Instance->NicAddr, sizeof (NIC_ADDR));\r
Instance->NicConfig->Source = IP4_CONFIG_SOURCE_DHCP;\r
Instance->NicConfig->Perment = Perment;\r
\r
DHCP_TAG_PARA_LIST = 55,
DHCP_TAG_NETMASK = 1,
- DHCP_TAG_ROUTER = 3,
+ DHCP_TAG_ROUTER = 3
};
//
} IP4_CONFIG_DHCP4_OPTION;
#pragma pack()
-typedef struct _IP4_CONFIG_INSTANCE {
+struct _IP4_CONFIG_INSTANCE {
UINT32 Signature;
EFI_HANDLE Controller;
EFI_HANDLE Image;
Status = gBS->OpenProtocol (\r
ControllerHandle,\r
&gEfiIp4ConfigProtocolGuid,\r
- &Ip4Config,\r
+ (VOID **) &Ip4Config,\r
This->DriverBindingHandle,\r
ControllerHandle,\r
EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
\r
Instance->NicAddr.Type = (UINT16) SnpMode.IfType;\r
Instance->NicAddr.Len = (UINT8) SnpMode.HwAddressSize;\r
- Instance->NicAddr.MacAddr = SnpMode.CurrentAddress;\r
+ CopyMem (&Instance->NicAddr.MacAddr, &SnpMode.CurrentAddress, sizeof (EFI_MAC_ADDRESS));\r
\r
//\r
// Add it to the global list, and compose the name\r
//\r
// Verify the checksum, variable size and count\r
//\r
- CheckSum = ~NetblockChecksum ((UINT8 *) Variable, (UINT32)Size);\r
+ CheckSum = (UINT16) (~NetblockChecksum ((UINT8 *) Variable, (UINT32)Size));\r
\r
if ((CheckSum != 0) || (Size != Variable->Len)) {\r
goto REMOVE_VARIABLE;\r
\r
ASSERT (Next + Len == (UINT8 *) NewVar + TotalLen);\r
\r
- NewVar->CheckSum = ~NetblockChecksum ((UINT8 *) NewVar, TotalLen);\r
+ NewVar->CheckSum = (UINT16) (~NetblockChecksum ((UINT8 *) NewVar, TotalLen));\r
return NewVar;\r
}\r
//\r
// Copy the MNP Protocol interfaces from the template.\r
//\r
- Instance->ManagedNetwork = mMnpProtocolTemplate;\r
+ CopyMem (&Instance->ManagedNetwork, &mMnpProtocolTemplate, sizeof (EFI_MANAGED_NETWORK_PROTOCOL));\r
\r
//\r
// Copy the default config data.\r
//\r
- Instance->ConfigData = mMnpDefaultConfigData;\r
+ CopyMem (&Instance->ConfigData, &mMnpDefaultConfigData, sizeof (EFI_MANAGED_NETWORK_CONFIG_DATA));\r
\r
//\r
// Initialize the lists.\r
//\r
// Save the new configuration data.\r
//\r
- *OldConfigData = *NewConfigData;\r
+ CopyMem (OldConfigData, NewConfigData, sizeof (EFI_MANAGED_NETWORK_CONFIG_DATA));\r
\r
Instance->Configured = (BOOLEAN) (ConfigData != NULL);\r
\r
Status = MnpStart (\r
MnpServiceData,\r
IsConfigUpdate,\r
- !NewConfigData->DisableBackgroundPolling\r
+ (BOOLEAN) !NewConfigData->DisableBackgroundPolling\r
);\r
} else {\r
//\r
NET_LIST_FOR_EACH (Entry, &MnpServiceData->GroupAddressList) {\r
\r
GroupAddress = NET_LIST_USER_STRUCT (Entry, MNP_GROUP_ADDRESS, AddrEntry);\r
- *(MCastFilter + Index) = GroupAddress->Address;\r
+ CopyMem (MCastFilter + Index, &GroupAddress->Address, sizeof (EFI_MAC_ADDRESS));\r
Index++;\r
\r
ASSERT (Index <= MCastFilterCnt);\r
return EFI_OUT_OF_RESOURCES;\r
}\r
\r
- GroupAddress->Address = *MacAddress;\r
+ CopyMem (&GroupAddress->Address, MacAddress, sizeof (EFI_MAC_ADDRESS));\r
GroupAddress->RefCnt = 0;\r
NetListInsertTail (\r
&MnpServiceData->GroupAddressList,\r
)\r
{\r
MNP_SERVICE_DATA *MnpServiceData;\r
- EFI_SIMPLE_NETWORK_MODE *SnpMode;\r
EFI_MANAGED_NETWORK_TRANSMIT_DATA *TxData;\r
UINT32 Index;\r
UINT32 TotalLength;\r
MnpServiceData = Instance->MnpServiceData;\r
NET_CHECK_SIGNATURE (MnpServiceData, MNP_SERVICE_DATA_SIGNATURE);\r
\r
- SnpMode = MnpServiceData->Snp->Mode;\r
TxData = Token->Packet.TxData;\r
\r
if ((Token->Event == NULL) || (TxData == NULL) || (TxData->FragmentCount == 0)) {\r
//\r
// Get the recycled transmit buffer status.\r
//\r
- Snp->GetStatus (Snp, NULL, &TxBuf);\r
+ Snp->GetStatus (Snp, NULL, (VOID **) &TxBuf);\r
\r
if (!EFI_ERROR (gBS->CheckEvent (MnpServiceData->TxTimeoutEvent))) {\r
\r
//\r
// Fill the RxData in RxDataWrap,\r
//\r
- RxDataWrap->RxData = *RxData;\r
+ CopyMem (&RxDataWrap->RxData, RxData, sizeof (EFI_MANAGED_NETWORK_RECEIVE_DATA));\r
\r
//\r
// Create the recycle event.\r
//\r
// Wrap the RxData.\r
//\r
- RxDataWrap = MnpWrapRxData (Instance, &RxData);\r
+ CopyMem (&RxDataWrap, MnpWrapRxData (Instance, &RxData), sizeof (MNP_RXDATA_WRAP));\r
if (RxDataWrap == NULL) {\r
continue;\r
}\r
//\r
// Copy the instance configuration data.\r
//\r
- *MnpConfigData = Instance->ConfigData;\r
+ CopyMem (MnpConfigData, &Instance->ConfigData, sizeof (EFI_MANAGED_NETWORK_CONFIG_DATA));\r
}\r
\r
if (SnpModeData != NULL) {\r
// Copy the underlayer Snp mode data.\r
//\r
Snp = Instance->MnpServiceData->Snp;\r
- *SnpModeData = *(Snp->Mode);\r
+ CopyMem (SnpModeData, Snp->Mode, sizeof (EFI_SIMPLE_NETWORK_MODE));\r
}\r
\r
if (!Instance->Configured) {\r
MacAddress->Addr[0] = 0x01;\r
MacAddress->Addr[1] = 0x00;\r
MacAddress->Addr[2] = 0x5E;\r
- MacAddress->Addr[3] = IpAddress->v4.Addr[1] & 0x7F;\r
+ MacAddress->Addr[3] = (UINT8) (IpAddress->v4.Addr[1] & 0x7F);\r
MacAddress->Addr[4] = IpAddress->v4.Addr[2];\r
MacAddress->Addr[5] = IpAddress->v4.Addr[3];\r
\r
// Resolve Warning 4 unreferenced parameter problem\r
//\r
ExtendedVerification = 0;\r
+ DEBUG ((EFI_D_WARN, "ExtendedVerification = %d is not implemented!\n", ExtendedVerification));\r
\r
if (this == NULL) {\r
return EFI_INVALID_PARAMETER;\r
\r
TcpRsvData = (TCP_RSV_DATA *) RcvBufEntry->ProtoData;\r
\r
- *IsUrg = ((TcpRsvData->UrgLen > 0) ? TRUE : FALSE);\r
+ *IsUrg = (BOOLEAN) ((TcpRsvData->UrgLen > 0) ? TRUE : FALSE);\r
\r
if (*IsUrg && TcpRsvData->UrgLen < RcvBufEntry->TotalSize) {\r
\r
\r
TcpRsvData = (TCP_RSV_DATA *) RcvBufEntry->ProtoData;\r
\r
- Urg = ((TcpRsvData->UrgLen > 0) ? TRUE : FALSE);\r
+ Urg = (BOOLEAN) ((TcpRsvData->UrgLen > 0) ? TRUE : FALSE);\r
\r
if (*IsUrg != Urg) {\r
break;\r
for (Index = 0; (Index < RxData->FragmentCount) && (RcvdBytes > 0); Index++) {\r
\r
Fragment = &RxData->FragmentTable[Index];\r
- CopyBytes = NET_MIN (Fragment->FragmentLength, RcvdBytes);\r
+ CopyBytes = NET_MIN ((UINT32) (Fragment->FragmentLength), RcvdBytes);\r
\r
NetbufQueCopy (\r
Sock->RcvBuffer.DataQueue,\r
TokenRcvdBytes = SockTcpDataToRcv (\r
&Sock->RcvBuffer,\r
&IsUrg,\r
- RxData->DataLength\r
+ (UINT32) RxData->DataLength\r
);\r
\r
//\r
//\r
SndData = NetbufFromExt (\r
(NET_FRAGMENT *) TxData->FragmentTable,\r
- TxData->FragmentCount,\r
+ (UINT32) TxData->FragmentCount,\r
0,\r
0,\r
SockFreeFoo,\r
SndToken = (SOCK_IO_TOKEN *) SockToken->Token;\r
TxData = SndToken->Packet.TxData;\r
\r
- DataLen = TxData->DataLength;\r
+ DataLen = (UINT32) TxData->DataLength;\r
Status = SockProcessTcpSndData (Sock, TxData);\r
\r
if (EFI_ERROR (Status)) {\r
goto Exit;\r
}\r
\r
- DataLen = TxData->DataLength;\r
+ DataLen = (UINT32) TxData->DataLength;\r
\r
//\r
// process this sending token now or buffer it only?\r
//
// the socket structure representing a network service access point
//
-typedef struct _SOCKET {
+struct _SOCKET {
//
// socket description information
EFI_TCP4_PROTOCOL TcpProtocol;
EFI_UDP4_PROTOCOL UdpProtocol;
} NetProtocol;
-} SOCKET;
+};
//
// the token structure buffered in socket layer
}\r
\r
if (Mode->Tcp4State) {\r
- *(Mode->Tcp4State) = Tcb->State;\r
+ *(Mode->Tcp4State) = (EFI_TCP4_CONNECTION_STATE) Tcb->State;\r
}\r
\r
if (Mode->Tcp4ConfigData) {\r
Option->KeepAliveTime = Tcb->KeepAliveIdle / TCP_TICK_HZ;\r
Option->KeepAliveInterval = Tcb->KeepAlivePeriod / TCP_TICK_HZ;\r
\r
- Option->EnableNagle = !TCP_FLG_ON (Tcb->CtrlFlag, TCP_CTRL_NO_NAGLE);\r
- Option->EnableTimeStamp = !TCP_FLG_ON (Tcb->CtrlFlag, TCP_CTRL_NO_TS);\r
- Option->EnableWindowScaling = !TCP_FLG_ON (Tcb->CtrlFlag, TCP_CTRL_NO_WS);\r
+ Option->EnableNagle = (BOOLEAN) (!TCP_FLG_ON (Tcb->CtrlFlag, TCP_CTRL_NO_NAGLE));\r
+ Option->EnableTimeStamp = (BOOLEAN) (!TCP_FLG_ON (Tcb->CtrlFlag, TCP_CTRL_NO_TS));\r
+ Option->EnableWindowScaling = (BOOLEAN) (!TCP_FLG_ON (Tcb->CtrlFlag, TCP_CTRL_NO_WS))\r
+;\r
\r
Option->EnableSelectiveAck = FALSE;\r
Option->EnablePathMtuDiscovery = FALSE;\r
IN EFI_TCP4_CONFIG_DATA *CfgData\r
)\r
{\r
- IP_IO *IpIo;\r
EFI_IP4_CONFIG_DATA IpCfgData;\r
EFI_STATUS Status;\r
EFI_TCP4_OPTION *Option;\r
\r
TcpProto = (TCP4_PROTO_DATA *) Sk->ProtoReserved;\r
Tcb = TcpProto->TcpPcb;\r
- IpIo = TcpProto->TcpService->IpIo;\r
\r
ASSERT (Tcb != NULL);\r
\r
//\r
// Add Ip for send pkt to the peer\r
//\r
- IpCfgData = mIpIoDefaultIpConfigData;\r
+ CopyMem (&IpCfgData, &mIpIoDefaultIpConfigData, sizeof (EFI_IP4_CONFIG_DATA));\r
IpCfgData.DefaultProtocol = EFI_IP_PROTO_TCP;\r
IpCfgData.UseDefaultAddress = CfgData->AccessPoint.UseDefaultAddress;\r
IpCfgData.StationAddress = CfgData->AccessPoint.StationAddress;\r
if (Option != NULL) {\r
SET_RCV_BUFFSIZE (\r
Sk,\r
- TCP_COMP_VAL (TCP_RCV_BUF_SIZE_MIN,\r
- TCP_RCV_BUF_SIZE,\r
- TCP_RCV_BUF_SIZE,\r
- Option->ReceiveBufferSize)\r
+ (UINT32) (TCP_COMP_VAL (\r
+ TCP_RCV_BUF_SIZE_MIN,\r
+ TCP_RCV_BUF_SIZE,\r
+ TCP_RCV_BUF_SIZE,\r
+ Option->ReceiveBufferSize\r
+ )\r
+ )\r
);\r
SET_SND_BUFFSIZE (\r
Sk,\r
- TCP_COMP_VAL (TCP_SND_BUF_SIZE_MIN,\r
- TCP_SND_BUF_SIZE,\r
- TCP_SND_BUF_SIZE,\r
- Option->SendBufferSize)\r
+ (UINT32) (TCP_COMP_VAL (\r
+ TCP_SND_BUF_SIZE_MIN,\r
+ TCP_SND_BUF_SIZE,\r
+ TCP_SND_BUF_SIZE,\r
+ Option->SendBufferSize\r
+ )\r
+ )\r
);\r
\r
SET_BACKLOG (\r
Sk,\r
- TCP_COMP_VAL (TCP_BACKLOG_MIN,\r
- TCP_BACKLOG,\r
- TCP_BACKLOG,\r
- Option->MaxSynBackLog)\r
+ (UINT32) (TCP_COMP_VAL (\r
+ TCP_BACKLOG_MIN,\r
+ TCP_BACKLOG,\r
+ TCP_BACKLOG,\r
+ Option->MaxSynBackLog\r
+ )\r
+ )\r
);\r
\r
Tcb->MaxRexmit = (UINT16) TCP_COMP_VAL (\r
TCP_FIN_WAIT2_TIME,\r
TCP_FIN_WAIT2_TIME_MAX,\r
TCP_FIN_WAIT2_TIME,\r
- Option->FinTimeout * TCP_TICK_HZ\r
+ (UINT32) (Option->FinTimeout * TCP_TICK_HZ)\r
);\r
\r
if (Option->TimeWaitTimeout != 0) {\r
TCP_TIME_WAIT_TIME,\r
TCP_TIME_WAIT_TIME_MAX,\r
TCP_TIME_WAIT_TIME,\r
- Option->TimeWaitTimeout * TCP_TICK_HZ\r
+ (UINT32) (Option->TimeWaitTimeout * TCP_TICK_HZ)\r
);\r
} else {\r
Tcb->TimeWaitTimeout = 0;\r
TCP_KEEPALIVE_IDLE_MIN,\r
TCP_KEEPALIVE_IDLE_MAX,\r
TCP_KEEPALIVE_IDLE_MIN,\r
- Option->KeepAliveTime * TCP_TICK_HZ\r
+ (UINT32) (Option->KeepAliveTime * TCP_TICK_HZ)\r
);\r
Tcb->KeepAlivePeriod = TCP_COMP_VAL (\r
TCP_KEEPALIVE_PERIOD_MIN,\r
TCP_KEEPALIVE_PERIOD,\r
TCP_KEEPALIVE_PERIOD,\r
- Option->KeepAliveInterval * TCP_TICK_HZ\r
+ (UINT32) (Option->KeepAliveInterval * TCP_TICK_HZ)\r
);\r
}\r
\r
TCP_CONNECT_TIME_MIN,\r
TCP_CONNECT_TIME,\r
TCP_CONNECT_TIME,\r
- Option->ConnectionTimeout * TCP_TICK_HZ\r
+ (UINT32) (Option->ConnectionTimeout * TCP_TICK_HZ)\r
);\r
\r
if (Option->EnableNagle == FALSE) {\r
\r
SOCK_INIT_DATA mTcp4DefaultSockData = {\r
SOCK_STREAM,\r
- 0,\r
+ (SOCK_STATE) 0,\r
NULL,\r
TCP_BACKLOG,\r
TCP_SND_BUF_SIZE,\r
//\r
Seed = NetRandomInitSeed ();\r
mTcpGlobalIss = NET_RANDOM (Seed) % mTcpGlobalIss;\r
- mTcp4RandomPort = TCP4_PORT_KNOWN +\r
- (UINT16) (NET_RANDOM(Seed) % TCP4_PORT_KNOWN);\r
+ mTcp4RandomPort = (UINT16) ( TCP4_PORT_KNOWN +\r
+ (UINT16) (NET_RANDOM(Seed) % TCP4_PORT_KNOWN));\r
\r
return Status;\r
}\r
//\r
NetZeroMem (&OpenData, sizeof (IP_IO_OPEN_DATA));\r
\r
- OpenData.IpConfigData = mIpIoDefaultIpConfigData;\r
+ CopyMem (&OpenData.IpConfigData, &mIpIoDefaultIpConfigData, sizeof (EFI_IP4_CONFIG_DATA));\r
OpenData.IpConfigData.DefaultProtocol = EFI_IP_PROTO_TCP;\r
\r
OpenData.PktRcvdNotify = Tcp4RxCallback;\r
UINT32 Len;\r
\r
for (Index = 0, Len = 0; Index < FragmentCount; Index++) {\r
- Len = Len + FragmentTable[Index].FragmentLength;\r
+ Len = Len + (UINT32) FragmentTable[Index].FragmentLength;\r
}\r
\r
if (DataLen != Len) {\r
}\r
\r
Status = Tcp4ChkDataBuf (\r
- Token->Packet.TxData->DataLength,\r
- Token->Packet.TxData->FragmentCount,\r
+ (UINT32) Token->Packet.TxData->DataLength,\r
+ (UINT32) Token->Packet.TxData->FragmentCount,\r
Token->Packet.TxData->FragmentTable\r
);\r
if (EFI_ERROR (Status)) {\r
}\r
\r
Status = Tcp4ChkDataBuf (\r
- Token->Packet.RxData->DataLength,\r
- Token->Packet.RxData->FragmentCount,\r
+ (UINT32) Token->Packet.RxData->DataLength,\r
+ (UINT32) Token->Packet.RxData->FragmentCount,\r
Token->Packet.RxData->FragmentTable\r
);\r
if (EFI_ERROR (Status)) {\r
}\r
\r
if (TCP_FLG_ON (Opt->Flag, TCP_OPTION_RCVD_MSS)) {\r
- Tcb->SndMss = NET_MAX (64, Opt->Mss);\r
+ Tcb->SndMss = (UINT16) NET_MAX (64, Opt->Mss);\r
\r
RcvMss = TcpGetRcvMss (Tcb->Sk);\r
if (Tcb->SndMss > RcvMss) {\r
HTONS ((UINT16) Nbuf->TotalSize)\r
);\r
\r
- return ~Checksum;\r
+ return (UINT16) ~Checksum;\r
}\r
\r
\r
IN TCP_CB *Tcb\r
)\r
{\r
+ UINT32 TcpOld;\r
\r
switch (Tcb->State) {\r
case TCP_CLOSED:\r
break;\r
\r
case TCP_ESTABLISHED:\r
- if (TcpRcvWinNow (Tcb) > TcpRcvWinOld (Tcb)) {\r
+ TcpOld = TcpRcvWinOld (Tcb);\r
+ if (TcpRcvWinNow (Tcb) > TcpOld) {\r
\r
- if (TcpRcvWinOld (Tcb) < Tcb->RcvMss) {\r
+ if (TcpOld < Tcb->RcvMss) {\r
\r
TCP4_DEBUG_TRACE (("TcpOnAppConsume: send a window"\r
" update for a window closed Tcb(%x)\n", Tcb));\r
IN NET_BUF *Nbuf\r
)\r
{\r
- char *Data;\r
+ UINT8 *Data;\r
UINT16 Len;\r
\r
ASSERT (Tcb && Nbuf && !Nbuf->Tcp);\r
IN NET_BUF *Nbuf\r
)\r
{\r
- char *Data;\r
+ UINT8 *Data;\r
UINT16 Len;\r
\r
ASSERT (Tcb && Nbuf && !Nbuf->Tcp);\r
return -1;\r
}\r
\r
- Option->WndScale = NET_MIN (14, Head[Cur + 2]);\r
+ Option->WndScale = (UINT8) NET_MIN (14, Head[Cur + 2]);\r
TCP_SET_FLG (Option->Flag, TCP_OPTION_RCVD_WS);\r
\r
Cur += TCP_OPTION_WS_LEN;\r
return -1;\r
}\r
\r
- Cur = Cur + Len;\r
+ Cur = (UINT8) (Cur + Len);\r
break;\r
}\r
\r
TCP_OPTION_MAX_WIN = 0xffff, // max window size in TCP header
TCP_OPTION_RCVD_MSS = 0x01,
TCP_OPTION_RCVD_WS = 0x02,
- TCP_OPTION_RCVD_TS = 0x04,
+ TCP_OPTION_RCVD_TS = 0x04
};
UINT8
IN TCP_CB *Tcb\r
)\r
{\r
+ UINT32 TcpNow;\r
+\r
+ TcpNow = TcpRcvWinNow (Tcb);\r
//\r
// Generally, TCP should send a delayed ACK unless:\r
// 1. ACK at least every other FULL sized segment received,\r
//\r
if (TCP_FLG_ON (Tcb->CtrlFlag, TCP_CTRL_ACK_NOW) ||\r
(Tcb->DelayedAck >= 1) ||\r
- (TcpRcvWinNow (Tcb) > TcpRcvWinOld (Tcb))\r
+ (TcpNow > TcpRcvWinOld (Tcb))\r
) {\r
TcpSendAck (Tcb);\r
return;\r
TCP_CLOSING,
TCP_TIME_WAIT,
TCP_CLOSE_WAIT,
- TCP_LAST_ACK,
+ TCP_LAST_ACK
};
//
TCP_FLG_PSH = 0x08,
TCP_FLG_ACK = 0x10,
TCP_FLG_URG = 0x20,
- TCP_FLG_FLAG = 0x3F, // mask for all the flags
+ TCP_FLG_FLAG = 0x3F // mask for all the flags
};
enum {
TCP_KEEPALIVE_IDLE_MAX = TCP_TICK_HZ *60 *60 *4,
TCP_KEEPALIVE_PERIOD_MIN= TCP_TICK_HZ *30,
TCP_FIN_WAIT2_TIME_MAX = 4 *TCP_TICK_HZ,
- TCP_TIME_WAIT_TIME_MAX = 60 *TCP_TICK_HZ,
+ TCP_TIME_WAIT_TIME_MAX = 60 *TCP_TICK_HZ
};
typedef struct _TCP_SEG {
//
// tcp control block, it includes various states
//
-typedef struct _TCP_CB {
+struct _TCP_CB {
NET_LIST_ENTRY List;
TCP_CB *Parent;
// pointer reference to Ip used to send pkt
//
IP_IO_IP_INFO *IpInfo;
-} TCP_CB;
+};
extern NET_LIST_ENTRY mTcpRunQue;
extern NET_LIST_ENTRY mTcpListenQue;
(((Pb)->Port == 0) || ((Pb)->Port == (Pa)->Port)))
#define TCP_TIMER_ON(Flag, Timer) ((Flag) & (1 << (Timer)))
-#define TCP_SET_TIMER(Flag, Timer) ((Flag) |= (1 << (Timer)))
-#define TCP_CLEAR_TIMER(Flag, Timer) ((Flag) &= ~(1 << (Timer)))
+#define TCP_SET_TIMER(Flag, Timer) ((Flag) = (UINT16) ((Flag) | (1 << (Timer))))
+#define TCP_CLEAR_TIMER(Flag, Timer) ((Flag) = (UINT16) ((Flag) & (~(1 << (Timer)))))
#define TCP_TIME_LT(Ta, Tb) ((INT32) ((Ta) - (Tb)) < 0)
#define TCP_TIME_LEQ(Ta, Tb) ((INT32) ((Ta) - (Tb)) <= 0)
//\r
// Set the OpenData used to open the IpIo.\r
//\r
- OpenData.IpConfigData = mIpIoDefaultIpConfigData;\r
+ CopyMem (&OpenData.IpConfigData, &mIpIoDefaultIpConfigData, sizeof (EFI_IP4_CONFIG_DATA));\r
OpenData.IpConfigData.AcceptBroadcast = TRUE;\r
OpenData.RcvdContext = (VOID *) Udp4Service;\r
OpenData.SndContext = NULL;\r
// Save the pointer to the UDP4_SERVICE_DATA, and initialize other members.\r
//\r
Instance->Udp4Service = Udp4Service;\r
- Instance->Udp4Proto = mUdp4Protocol;\r
+ CopyMem (&Instance->Udp4Proto, &mUdp4Protocol, sizeof (EFI_UDP4_PROTOCOL));\r
Instance->IcmpError = EFI_SUCCESS;\r
Instance->Configured = FALSE;\r
Instance->IsNoMapping = FALSE;\r
IN EFI_IP4_CONFIG_DATA *Ip4ConfigData\r
)\r
{\r
- *Ip4ConfigData = mIpIoDefaultIpConfigData;\r
+ CopyMem (Ip4ConfigData, &mIpIoDefaultIpConfigData, sizeof (EFI_IP4_CONFIG_DATA));\r
+\r
Ip4ConfigData->DefaultProtocol = EFI_IP_PROTO_UDP;\r
Ip4ConfigData->AcceptBroadcast = Udp4ConfigData->AcceptBroadcast;\r
Ip4ConfigData->AcceptPromiscuous = Udp4ConfigData->AcceptPromiscuous;\r
\r
NetListInit (&Wrap->Link);\r
\r
- Wrap->RxData = *RxData;\r
+ CopyMem (&Wrap->RxData, RxData, sizeof (EFI_UDP4_RECEIVE_DATA));\r
\r
//\r
// Create the Recycle event.\r
//\r
// Wrap the RxData and put this Wrap into the instances RcvdDgramQue.\r
//\r
- Wrap = Udp4WrapRxData (Instance, Packet, RxData);\r
+ CopyMem (&Wrap, Udp4WrapRxData (Instance, Packet, RxData), sizeof (UDP4_RXDATA_WRAP));\r
if (Wrap == NULL) {\r
continue;\r
}\r
//\r
// Set the Udp4ConfigData.\r
//\r
- *Udp4ConfigData = Instance->ConfigData;\r
+ CopyMem (Udp4ConfigData, &Instance->ConfigData, sizeof (EFI_UDP4_CONFIG_DATA));\r
}\r
\r
Ip = Instance->IpInfo->Ip;\r
//\r
// Save the configuration data.\r
//\r
- Instance->ConfigData = *UdpConfigData;\r
+ CopyMem (&Instance->ConfigData, UdpConfigData, sizeof (EFI_UDP4_CONFIG_DATA));\r
Instance->ConfigData.StationAddress = Ip4ConfigData.StationAddress;\r
Instance->ConfigData.SubnetMask = Ip4ConfigData.SubnetMask;\r
\r