// ModeSense6 command is defined in [SCSI2Spec-Page151]\r
//\r
ModeSenseCmd.OpCode = USB_SCSI_MODE_SENSE6_OPCODE;\r
- ModeSenseCmd.Lun = USB_BOOT_LUN (UsbMass->Lun);\r
+ ModeSenseCmd.Lun = (UINT8) USB_BOOT_LUN (UsbMass->Lun);\r
ModeSenseCmd.PageCode = 0x3F;\r
ModeSenseCmd.AllocateLen = (UINT8) sizeof (USB_SCSI_MODE_SENSE6_PARA_HEADER);\r
\r
// devices support this command, so have a try here.\r
//\r
if (!EFI_ERROR (Status)) {\r
- Media->ReadOnly = (ModeParaHeader.DevicePara & 0x80) ? TRUE : FALSE;\r
+ Media->ReadOnly = (BOOLEAN) ((ModeParaHeader.DevicePara & 0x80) ? TRUE : FALSE);\r
}\r
\r
return Status;\r
OUT BOOLEAN *Notify OPTIONAL\r
)\r
{\r
- ICMP_ERROR_INFO IcmpErrMap[] = {\r
- { EFI_NETWORK_UNREACHABLE, FALSE, TRUE }, // ICMP_ERR_UNREACH_NET\r
- { EFI_HOST_UNREACHABLE, FALSE, TRUE }, // ICMP_ERR_UNREACH_HOST\r
- { EFI_PROTOCOL_UNREACHABLE, TRUE, TRUE }, // ICMP_ERR_UNREACH_PROTOCOL\r
- { EFI_PORT_UNREACHABLE, TRUE, TRUE }, // ICMP_ERR_UNREACH_PORT\r
- { EFI_ICMP_ERROR, TRUE, TRUE }, // ICMP_ERR_MSGSIZE\r
- { EFI_ICMP_ERROR, FALSE, TRUE }, // ICMP_ERR_UNREACH_SRCFAIL\r
- { EFI_HOST_UNREACHABLE, FALSE, TRUE }, // ICMP_ERR_TIMXCEED_INTRANS\r
- { EFI_HOST_UNREACHABLE, FALSE, TRUE }, // ICMP_ERR_TIMEXCEED_REASS\r
- { EFI_ICMP_ERROR, FALSE, FALSE }, // ICMP_ERR_QUENCH\r
- { EFI_ICMP_ERROR, FALSE, TRUE } // ICMP_ERR_PARAMPROB\r
- };\r
+ ICMP_ERROR_INFO IcmpErrMap[10];\r
+\r
+ IcmpErrMap[0].Error = EFI_NETWORK_UNREACHABLE;\r
+ IcmpErrMap[0].IsHard = FALSE;\r
+ IcmpErrMap[0].Notify = TRUE;\r
+\r
+ IcmpErrMap[1].Error = EFI_HOST_UNREACHABLE;\r
+ IcmpErrMap[1].IsHard = FALSE;\r
+ IcmpErrMap[1].Notify = TRUE;\r
+\r
+ IcmpErrMap[2].Error = EFI_PROTOCOL_UNREACHABLE;\r
+ IcmpErrMap[2].IsHard = TRUE;\r
+ IcmpErrMap[2].Notify = TRUE;\r
+\r
+ IcmpErrMap[3].Error = EFI_PORT_UNREACHABLE;\r
+ IcmpErrMap[3].IsHard = TRUE;\r
+ IcmpErrMap[3].Notify = TRUE;\r
+\r
+ IcmpErrMap[4].Error = EFI_ICMP_ERROR;\r
+ IcmpErrMap[4].IsHard = TRUE;\r
+ IcmpErrMap[4].Notify = TRUE;\r
+\r
+ IcmpErrMap[5].Error = EFI_ICMP_ERROR;\r
+ IcmpErrMap[5].IsHard = FALSE;\r
+ IcmpErrMap[5].Notify = TRUE;\r
+\r
+ IcmpErrMap[6].Error = EFI_HOST_UNREACHABLE;\r
+ IcmpErrMap[6].IsHard = FALSE;\r
+ IcmpErrMap[6].Notify = TRUE;\r
+\r
+ IcmpErrMap[7].Error = EFI_HOST_UNREACHABLE;\r
+ IcmpErrMap[7].IsHard = FALSE;\r
+ IcmpErrMap[7].Notify = TRUE;\r
+\r
+ IcmpErrMap[8].Error = EFI_ICMP_ERROR;\r
+ IcmpErrMap[8].IsHard = FALSE;\r
+ IcmpErrMap[8].Notify = FALSE;\r
+\r
+ IcmpErrMap[9].Error = EFI_ICMP_ERROR;\r
+ IcmpErrMap[9].IsHard = FALSE;\r
+ IcmpErrMap[9].Notify = TRUE;\r
\r
ASSERT ((IcmpError >= ICMP_ERR_UNREACH_NET) && (IcmpError <= ICMP_ERR_PARAMPROB));\r
\r
#/** @file\r
-# Component name for module NetLib\r
+# Component name for module DxeIpIoLib\r
#\r
# FIX ME!\r
-# Copyright (c) 2006, Intel Corporation. \r
+# Copyright (c) 2006, Intel Corporation.\r
#\r
# All rights reserved. This program and the accompanying materials\r
# are licensed and made available under the terms and conditions of the BSD License\r
\r
[Defines]\r
INF_VERSION = 0x00010005\r
- BASE_NAME = NetIpIoDxe\r
+ BASE_NAME = DxeIpIoLib\r
FILE_GUID = A302F877-8625-425c-B1EC-7487B62C4FDA\r
MODULE_TYPE = DXE_DRIVER\r
VERSION_STRING = 1.0\r
#/** @file\r
-# Component name for module NetLib\r
+# Component name for module DxeNetLib\r
#\r
# FIX ME!\r
-# Copyright (c) 2006, Intel Corporation. \r
+# Copyright (c) 2006, Intel Corporation.\r
#\r
# All rights reserved. This program and the accompanying materials\r
# are licensed and made available under the terms and conditions of the BSD License\r
\r
[Defines]\r
INF_VERSION = 0x00010005\r
- BASE_NAME = NetLibDxe\r
+ BASE_NAME = DxeNetLib\r
FILE_GUID = db6dcef3-9f4e-4340-9351-fc35aa8a5888\r
MODULE_TYPE = DXE_DRIVER\r
VERSION_STRING = 1.0\r
UdpIo->UdpHandle\r
);\r
\r
- NetListRemoveEntry (&UdpIo->Link);\r
+ if (!IsListEmpty(&UdpIo->Link)) {\r
+ NetListRemoveEntry (&UdpIo->Link);\r
+ }\r
+\r
NetFreePool (UdpIo);\r
return EFI_SUCCESS;\r
}\r
#/** @file\r
-# Component name for module NetLib\r
+# Component name for module DxeUpdIoLib\r
#\r
# FIX ME!\r
-# Copyright (c) 2006, Intel Corporation. \r
+# Copyright (c) 2006, Intel Corporation.\r
#\r
# All rights reserved. This program and the accompanying materials\r
# are licensed and made available under the terms and conditions of the BSD License\r
\r
[Defines]\r
INF_VERSION = 0x00010005\r
- BASE_NAME = DxeUpdIoDxe\r
+ BASE_NAME = DxeUpdIoLib\r
FILE_GUID = 7E615AA1-41EE-49d4-B7E9-1D7A60AA5C8D\r
MODULE_TYPE = DXE_DRIVER\r
VERSION_STRING = 1.0\r
Instance->Signature = ARP_INSTANCE_DATA_SIGNATURE;\r
Instance->ArpService = ArpService;\r
\r
- CopyMem (&Instance->ArpProto, &mEfiArpProtocolTemplate, sizeof (ARP_SERVICE_DATA));\r
+ CopyMem (&Instance->ArpProto, &mEfiArpProtocolTemplate, sizeof (Instance->ArpProto));\r
\r
Instance->Configured = FALSE;\r
Instance->Destroyed = FALSE;\r
}\r
}\r
\r
- NetListRemoveEntry (&CacheEntry->List);\r
+ if (!IsListEmpty (&CacheEntry->List)) {\r
+ NetListRemoveEntry (&CacheEntry->List);\r
+ }\r
\r
//\r
// Fill the addresses into the CacheEntry.\r
//\r
// Save the configuration.\r
//\r
- CopyMem (OldConfigData, ConfigData, sizeof (EFI_ARP_CONFIG_DATA));\r
+ CopyMem (OldConfigData, ConfigData, sizeof (*OldConfigData));\r
\r
OldConfigData->StationAddress = NetAllocatePool (OldConfigData->SwAddressLength);\r
if (OldConfigData->StationAddress == NULL) {\r
Dhcp4ServiceBindingDestroyChild\r
};\r
\r
-//@MT: EFI_DRIVER_ENTRY_POINT (Dhcp4DriverEntryPoint)\r
\r
EFI_STATUS\r
EFIAPI\r
\r
DhcpSb->HwLen = (UINT8) DhcpSb->UdpIo->SnpMode.HwAddressSize;\r
DhcpSb->HwType = DhcpSb->UdpIo->SnpMode.IfType;\r
- CopyMem (&DhcpSb->Mac, &DhcpSb->UdpIo->SnpMode.CurrentAddress, sizeof (EFI_MAC_ADDRESS));\r
+ CopyMem (&DhcpSb->Mac, &DhcpSb->UdpIo->SnpMode.CurrentAddress, sizeof (DhcpSb->Mac));\r
\r
*Service = DhcpSb;\r
return EFI_SUCCESS;\r
)\r
{\r
Instance->Signature = DHCP_PROTOCOL_SIGNATURE;\r
- CopyMem (&Instance->Dhcp4Protocol, &mDhcp4ProtocolTemplate, sizeof (EFI_DHCP4_PROTOCOL));\r
+ CopyMem (&Instance->Dhcp4Protocol, &mDhcp4ProtocolTemplate, sizeof (Instance->Dhcp4Protocol));\r
NetListInit (&Instance->Link);\r
Instance->Handle = NULL;\r
Instance->Service = DhcpSb;\r
// Caller can use GetModeData to retrieve current DHCP states\r
// no matter whether it is the active child or not.\r
//\r
- Dhcp4ModeData->State = DhcpSb->DhcpState;\r
- CopyMem (&Dhcp4ModeData->ConfigData, &DhcpSb->ActiveConfig, sizeof (EFI_DHCP4_CONFIG_DATA));\r
- CopyMem (&Dhcp4ModeData->ClientMacAddress, &DhcpSb->Mac, sizeof (EFI_MAC_ADDRESS));\r
+ Dhcp4ModeData->State = (EFI_DHCP4_STATE) DhcpSb->DhcpState;\r
+ CopyMem (&Dhcp4ModeData->ConfigData, &DhcpSb->ActiveConfig, sizeof (Dhcp4ModeData->ConfigData));\r
+ CopyMem (&Dhcp4ModeData->ClientMacAddress, &DhcpSb->Mac, sizeof (Dhcp4ModeData->ClientMacAddress));\r
\r
Ip = HTONL (DhcpSb->ClientAddr);\r
NetCopyMem (&Dhcp4ModeData->ClientAddress, &Ip, sizeof (EFI_IPv4_ADDRESS));\r
INTN Len;\r
UINT32 Index;\r
\r
- CopyMem (Dst, Src, sizeof (EFI_DHCP4_CONFIG_DATA));\r
+ CopyMem (Dst, Src, sizeof (Dst));\r
Dst->DiscoverTimeout = NULL;\r
Dst->RequestTimeout = NULL;\r
Dst->OptionList = NULL;\r
)\r
{\r
EFI_DHCP4_CONFIG_DATA *Config;\r
- DHCP_PROTOCOL *Instance;\r
\r
- Instance = DhcpSb->ActiveChild;\r
Config = &DhcpSb->ActiveConfig;\r
\r
DhcpSb->ServiceState = DHCP_UNCONFIGED;\r
//
DHCP_UNCONFIGED = 0,
DHCP_CONFIGED,
- DHCP_DESTORY,
+ DHCP_DESTORY
};
-typedef struct _DHCP_PROTOCOL {
+struct _DHCP_PROTOCOL {
UINT32 Signature;
EFI_DHCP4_PROTOCOL Dhcp4Protocol;
NET_LIST_ENTRY Link;
// DHCP driver is specical in that it is a singleton. Although it
// has a service binding, there can be only one active child.
//
-typedef struct _DHCP_SERVICE {
+struct _DHCP_SERVICE {
UINT32 Signature;
EFI_SERVICE_BINDING_PROTOCOL ServiceBinding;
Status = Config->Dhcp4Callback (\r
&DhcpSb->ActiveChild->Dhcp4Protocol,\r
Config->CallbackContext,\r
- DhcpSb->DhcpState,\r
+ (EFI_DHCP4_STATE) DhcpSb->DhcpState,\r
Event,\r
Packet,\r
NewPacket\r
}\r
\r
DhcpSb->Selected = Packet;\r
- CopyMem (DhcpSb->Para, Para, sizeof (DHCP_PARAMETER));\r
+ CopyMem (DhcpSb->Para, Para, sizeof (*DhcpSb->Para));\r
\r
Status = DhcpLeaseAcquired (DhcpSb);\r
\r
Len = sizeof (EFI_DHCP4_PACKET) + 128 + DhcpSb->UserOptionLen;\r
\r
if (Msg != NULL) {\r
- Len += (UINT32)AsciiStrLen (Msg);\r
+ Len += (UINT32)AsciiStrLen ((CHAR8 *) Msg);\r
}\r
\r
Packet = NetAllocatePool (Len);\r
// Append the user's message if it isn't NULL\r
//\r
if (Msg != NULL) {\r
- Len = NET_MIN ((UINT32) AsciiStrLen (Msg), 255);\r
+ Len = NET_MIN ((UINT32) AsciiStrLen ((CHAR8 *) Msg), 255);\r
Buf = DhcpAppendOption (Buf, DHCP_TAG_MESSAGE, (UINT16) Len, Msg);\r
}\r
\r
//
DHCP_NOTIFY_COMPLETION = 1,
DHCP_NOTIFY_RENEWREBIND,
- DHCP_NOTIFY_ALL,
+ DHCP_NOTIFY_ALL
};
#define DHCP_IS_BOOTP(Parameter) (((Parameter) == NULL) || ((Parameter)->DhcpType == 0))
\r
if ((Overload == DHCP_OVERLOAD_FILENAME) || (Overload == DHCP_OVERLOAD_BOTH)) {\r
Status = DhcpIterateBufferOptions (\r
- Packet->Dhcp4.Header.BootFileName,\r
+ (UINT8 *) Packet->Dhcp4.Header.BootFileName,\r
128,\r
Check,\r
Context,\r
\r
if ((Overload == DHCP_OVERLOAD_SVRNAME) || (Overload == DHCP_OVERLOAD_BOTH)) {\r
Status = DhcpIterateBufferOptions (\r
- Packet->Dhcp4.Header.ServerName,\r
+ (UINT8 *) Packet->Dhcp4.Header.ServerName,\r
64,\r
Check,\r
Context,\r
DHCP_OPTION_COUNT *OpCount;\r
\r
OpCount = (DHCP_OPTION_COUNT *) Context;\r
- OpCount[Tag].Offset = OpCount[Tag].Offset + Len;\r
+ OpCount[Tag].Offset = (UINT16) (OpCount[Tag].Offset + Len);\r
\r
return EFI_SUCCESS;\r
}\r
\r
NetCopyMem (Buf + OptCount[Tag].Offset, Data, Len);\r
\r
- OptCount[Tag].Offset = OptCount[Tag].Offset + Len;\r
- Options[Index].Len = Options[Index].Len + Len;\r
+ OptCount[Tag].Offset = (UINT16) (OptCount[Tag].Offset + Len);\r
+ Options[Index].Len = (UINT16) (Options[Index].Len + Len);\r
return EFI_SUCCESS;\r
}\r
\r
if (OptCount[Index].Offset != 0) {\r
OptCount[Index].Index = (UINT8) OptNum;\r
\r
- TotalLen = TotalLen + OptCount[Index].Offset;\r
- OptCount[Index].Offset = TotalLen - OptCount[Index].Offset;\r
+ TotalLen = (UINT16) (TotalLen + OptCount[Index].Offset);\r
+ OptCount[Index].Offset = (UINT16) (TotalLen - OptCount[Index].Offset);\r
\r
OptNum++;\r
}\r
goto ON_EXIT;\r
}\r
\r
- CopyMem (*Para, &Parameter, sizeof (DHCP_PARAMETER));\r
+ CopyMem (*Para, &Parameter, sizeof (**Para));\r
}\r
\r
ON_EXIT:\r
\r
Packet->Size = Len;\r
Packet->Length = 0;\r
- CopyMem (&Packet->Dhcp4.Header, &SeedPacket->Dhcp4.Header, sizeof (EFI_DHCP4_HEADER));\r
+ CopyMem (&Packet->Dhcp4.Header, &SeedPacket->Dhcp4.Header, sizeof (Packet->Dhcp4.Header));\r
Packet->Dhcp4.Magik = DHCP_OPTION_MAGIC;\r
Buf = Packet->Dhcp4.Option;\r
\r
DHCP_TAG_T1 = 58, // Renewal (T1) Time Value
DHCP_TAG_T2 = 59, // Rebinding (T2) Time Value
DHCP_TAG_VENDOR_CLASS = 60, // Vendor class identifier
- DHCP_TAG_CLIENT_ID = 61, // Client-identifier
+ DHCP_TAG_CLIENT_ID = 61 // Client-identifier
};
enum {
//
DHCP_OVERLOAD_FILENAME = 1,
DHCP_OVERLOAD_SVRNAME = 2,
- DHCP_OVERLOAD_BOTH = 3,
+ DHCP_OVERLOAD_BOTH = 3
};
//
}\r
\r
if (NicAddr != NULL) {\r
- CopyMem (NicAddr, &Instance->NicAddr, sizeof (NIC_ADDR));\r
+ CopyMem (NicAddr, &Instance->NicAddr, sizeof (*NicAddr));\r
}\r
\r
return EFI_SUCCESS;\r
goto ON_EXIT;\r
}\r
\r
- CopyMem (&Instance->NicConfig->NicAddr, &Instance->NicAddr, sizeof (NIC_ADDR));\r
+ CopyMem (&Instance->NicConfig->NicAddr, &Instance->NicAddr, sizeof (Instance->NicConfig->NicAddr));\r
Instance->NicConfig->Source = IP4_CONFIG_SOURCE_DHCP;\r
Instance->NicConfig->Perment = Perment;\r
\r
\r
Instance->NicAddr.Type = (UINT16) SnpMode.IfType;\r
Instance->NicAddr.Len = (UINT8) SnpMode.HwAddressSize;\r
- CopyMem (&Instance->NicAddr.MacAddr, &SnpMode.CurrentAddress, sizeof (EFI_MAC_ADDRESS));\r
+ CopyMem (&Instance->NicAddr.MacAddr, &SnpMode.CurrentAddress, sizeof (Instance->NicAddr.MacAddr));\r
\r
//\r
// Add it to the global list, and compose the name\r
//
IP4_HEAD_DF_MASK = 0x4000,
IP4_HEAD_MF_MASK = 0x2000,
- IP4_HEAD_OFFSET_MASK = 0x1fff,
+ IP4_HEAD_OFFSET_MASK = 0x1fff
};
#define IP4_ALLZERO_ADDRESS 0x00000000u
Icmp = (IP4_ICMP_QUERY_HEAD *) NetbufGetByte (Data, 0, NULL);\r
Icmp->Head.Type = ICMP_ECHO_REPLY;\r
Icmp->Head.Checksum = 0;\r
- Icmp->Head.Checksum = ~NetblockChecksum ((UINT8 *) Icmp, Data->TotalSize);\r
+ Icmp->Head.Checksum = (UINT16) (~NetblockChecksum ((UINT8 *) Icmp, Data->TotalSize));\r
\r
ReplyHead.Tos = 0;\r
ReplyHead.Fragment = 0;\r
goto DROP;\r
}\r
\r
- Checksum = ~NetbufChecksum (Packet);\r
+ Checksum = (UINT16) (~NetbufChecksum (Packet));\r
if ((Icmp.Checksum != 0) && (Checksum != 0)) {\r
goto DROP;\r
}\r
//
ICMP_INVALID_MESSAGE = 0,
ICMP_ERROR_MESSAGE = 1,
- ICMP_QUERY_MESSAGE = 2,
+ ICMP_QUERY_MESSAGE = 2
};
typedef struct {
Token->CallBack = CallBack;\r
Token->Packet = Packet;\r
Token->Context = Context;\r
- CopyMem (&Token->DstMac, &mZeroMacAddress, sizeof (EFI_MAC_ADDRESS));\r
- CopyMem (&Token->SrcMac, &Interface->Mac, sizeof (EFI_MAC_ADDRESS));\r
+ CopyMem (&Token->DstMac, &mZeroMacAddress, sizeof (Token->DstMac));\r
+ CopyMem (&Token->SrcMac, &Interface->Mac, sizeof (Token->SrcMac));\r
\r
MnpToken = &(Token->MnpToken);\r
MnpToken->Status = EFI_NOT_READY;\r
}\r
\r
ArpQue->Ip = DestIp;\r
- CopyMem (&ArpQue->Mac, &mZeroMacAddress, sizeof (EFI_MAC_ADDRESS));\r
+ CopyMem (&ArpQue->Mac, &mZeroMacAddress, sizeof (ArpQue->Mac));\r
\r
return ArpQue;\r
}\r
return NULL;\r
}\r
\r
- CopyMem (&Interface->Mac, &SnpMode.CurrentAddress, sizeof (EFI_MAC_ADDRESS));\r
- CopyMem (&Interface->BroadcastMac, &SnpMode.BroadcastAddress, sizeof (EFI_MAC_ADDRESS));\r
+ CopyMem (&Interface->Mac, &SnpMode.CurrentAddress, sizeof (Interface->Mac));\r
+ CopyMem (&Interface->BroadcastMac, &SnpMode.BroadcastAddress, sizeof (Interface->BroadcastMac));\r
Interface->HwaddrLen = SnpMode.HwAddressSize;\r
\r
NetListInit (&Interface->IpInstances);\r
NetListRemoveEntry (Entry);\r
\r
Token = NET_LIST_USER_STRUCT (Entry, IP4_LINK_TX_TOKEN, Link);\r
- CopyMem (&Token->DstMac, &ArpQue->Mac, sizeof (EFI_MAC_ADDRESS));\r
+ CopyMem (&Token->DstMac, &ArpQue->Mac, sizeof (Token->DstMac));\r
\r
Status = Interface->Mnp->Transmit (Interface->Mnp, &Token->MnpToken);\r
\r
// all the broadcasts.\r
//\r
if (NextHop == IP4_ALLONE_ADDRESS) {\r
- CopyMem (&Token->DstMac, &Interface->BroadcastMac, sizeof (EFI_MAC_ADDRESS));\r
+ CopyMem (&Token->DstMac, &Interface->BroadcastMac, sizeof (Token->DstMac));\r
goto SEND_NOW;\r
\r
} else if (IP4_IS_MULTICAST (NextHop)) {\r
IP4_FRAME_RX_SIGNATURE = EFI_SIGNATURE_32 ('I', 'P', 'F', 'R'),
IP4_FRAME_TX_SIGNATURE = EFI_SIGNATURE_32 ('I', 'P', 'F', 'T'),
IP4_FRAME_ARP_SIGNATURE = EFI_SIGNATURE_32 ('I', 'P', 'F', 'A'),
- IP4_INTERFACE_SIGNATURE = EFI_SIGNATURE_32 ('I', 'P', 'I', 'F'),
+ IP4_INTERFACE_SIGNATURE = EFI_SIGNATURE_32 ('I', 'P', 'I', 'F')
};
//
// Notice the special cases that DHCP can configure the interface
// with 0.0.0.0/0.0.0.0.
//
-typedef struct _IP4_INTERFACE {
+struct _IP4_INTERFACE {
UINT32 Signature;
NET_LIST_ENTRY Link;
INTN RefCnt;
//
NET_LIST_ENTRY IpInstances;
BOOLEAN PromiscRecv;
-} IP4_INTERFACE;
+};
IP4_INTERFACE *
Ip4CreateInterface (
Igmp->MaxRespTime = 0;\r
Igmp->Checksum = 0;\r
Igmp->Group = HTONL (Group);\r
- Igmp->Checksum = ~NetblockChecksum ((UINT8 *) Igmp, sizeof (IGMP_HEAD));\r
+ Igmp->Checksum = (UINT16) (~NetblockChecksum ((UINT8 *) Igmp, sizeof (IGMP_HEAD)));\r
\r
Head.Tos = 0;\r
Head.Protocol = IP4_PROTO_IGMP;\r
IGMP_LEAVE_GROUP = 0x17,
IGMP_V1ROUTER_PRESENT = 400,
- IGMP_UNSOLICIATED_REPORT = 10,
+ IGMP_UNSOLICIATED_REPORT = 10
};
EFI_STATUS
// IsConfigured is "whether the station address has been configured"\r
//\r
Ip4ModeData->IsStarted = (BOOLEAN)(IpInstance->State == IP4_STATE_CONFIGED);\r
- CopyMem (&Ip4ModeData->ConfigData, &IpInstance->ConfigData, sizeof (EFI_IP4_CONFIG_DATA));\r
+ CopyMem (&Ip4ModeData->ConfigData, &IpInstance->ConfigData, sizeof (Ip4ModeData->ConfigData));\r
Ip4ModeData->IsConfigured = FALSE;\r
\r
Ip4ModeData->GroupCount = IpInstance->GroupCount;\r
}\r
\r
if (MnpConfigData != NULL) {\r
- CopyMem (MnpConfigData, &IpSb->MnpConfigData, sizeof (EFI_MANAGED_NETWORK_CONFIG_DATA));\r
+ CopyMem (MnpConfigData, &IpSb->MnpConfigData, sizeof (*MnpConfigData));\r
}\r
\r
if (SnpModeData != NULL) {\r
- CopyMem (SnpModeData, &IpSb->SnpMode, sizeof (EFI_SIMPLE_NETWORK_MODE));\r
+ CopyMem (SnpModeData, &IpSb->SnpMode, sizeof (*SnpModeData));\r
}\r
\r
NET_RESTORE_TPL (OldTpl);\r
// recover the original configuration if failed to set the configure.\r
//\r
if (EFI_ERROR (Status) && Reconfig) {\r
- IpSb->MnpConfigData.EnablePromiscuousReceive = !PromiscReceive;\r
+ IpSb->MnpConfigData.EnablePromiscuousReceive = (BOOLEAN) !PromiscReceive;\r
}\r
\r
return Status;\r
NetZeroMem (IpInstance, sizeof (IP4_PROTOCOL));\r
\r
IpInstance->Signature = IP4_PROTOCOL_SIGNATURE;\r
- CopyMem (&IpInstance->Ip4Proto, &mEfiIp4ProtocolTemplete, sizeof (EFI_IP4_PROTOCOL));\r
+ CopyMem (&IpInstance->Ip4Proto, &mEfiIp4ProtocolTemplete, sizeof (IpInstance->Ip4Proto));\r
IpInstance->State = IP4_STATE_UNCONFIGED;\r
IpInstance->Service = IpSb;\r
\r
return EFI_DEVICE_ERROR;\r
}\r
\r
- CopyMem (&IpInstance->ConfigData, Config, sizeof (EFI_IP4_CONFIG_DATA));\r
+ CopyMem (&IpInstance->ConfigData, Config, sizeof (IpInstance->ConfigData));\r
return EFI_SUCCESS;\r
}\r
\r
IpInstance->Interface = IpIf;\r
NetListInsertTail (&IpIf->IpInstances, &IpInstance->AddrLink);\r
\r
- CopyMem (&IpInstance->ConfigData, Config, sizeof (EFI_IP4_CONFIG_DATA));\r
+ CopyMem (&IpInstance->ConfigData, Config, sizeof (IpInstance->ConfigData));\r
IpInstance->State = IP4_STATE_CONFIGED;\r
\r
//\r
)\r
{\r
IP4_PROTOCOL *IpInstance;\r
- EFI_IP4_CONFIG_DATA *Config;\r
EFI_STATUS Status;\r
EFI_TPL OldTpl;\r
\r
goto ON_EXIT;\r
}\r
\r
- Config = &IpInstance->ConfigData;\r
-\r
//\r
// Current Udp implementation creates an IP child for each Udp child.\r
// It initates a asynchronous receive immediately no matter whether\r
#include <Library/BaseMemoryLib.h>
#include <Library/MemoryAllocationLib.h>
-#include "IP4Common.h"
-#include "IP4Driver.h"
-#include "IP4If.h"
+#include "Ip4Common.h"
+#include "Ip4Driver.h"
+#include "Ip4If.h"
#include "Ip4Icmp.h"
-#include "IP4Option.h"
+#include "Ip4Option.h"
#include "Ip4Igmp.h"
-#include "IP4Route.h"
-#include "IP4Input.h"
-#include "IP4Output.h"
+#include "Ip4Route.h"
+#include "Ip4Input.h"
+#include "Ip4Output.h"
enum {
IP4_PROTOCOL_SIGNATURE = EFI_SIGNATURE_32 ('I', 'P', '4', 'P'),
IP4_SERVICE_UNSTARTED = 0,
IP4_SERVICE_STARTED,
IP4_SERVICE_CONFIGED,
- IP4_SERVICE_DESTORY,
+ IP4_SERVICE_DESTORY
};
//
EFI_IP4_RECEIVE_DATA RxData;
} IP4_RXDATA_WRAP;
-typedef struct _IP4_PROTOCOL {
+struct _IP4_PROTOCOL {
UINT32 Signature;
EFI_IP4_PROTOCOL Ip4Proto;
EFI_IP4_CONFIG_DATA ConfigData;
-} IP4_PROTOCOL;
+};
-typedef struct _IP4_SERVICE {
+struct _IP4_SERVICE {
UINT32 Signature;
EFI_SERVICE_BINDING_PROTOCOL ServiceBinding;
INTN State;
// NIC this IP4_SERVICE works on.
//
CHAR16 *MacString;
-} IP4_SERVICE;
+};
#define IP4_INSTANCE_FROM_PROTOCOL(Ip4) \
CR ((Ip4), IP4_PROTOCOL, Ip4Proto, IP4_PROTOCOL_SIGNATURE)
}\r
\r
NewPacket->Ip = Assemble->Head;\r
- CopyMem (IP4_GET_CLIP_INFO (NewPacket), Assemble->Info, sizeof (IP4_CLIP_INFO));\r
+ CopyMem (IP4_GET_CLIP_INFO (NewPacket), Assemble->Info, sizeof (*IP4_GET_CLIP_INFO (NewPacket)));\r
return NewPacket;\r
}\r
\r
//\r
// Some OS may send IP packets without checksum.\r
//\r
- Checksum = ~NetblockChecksum ((UINT8 *) Head, HeadLen);\r
+ Checksum = (UINT16) (~NetblockChecksum ((UINT8 *) Head, HeadLen));\r
\r
if ((Head->Checksum != 0) && (Checksum != 0)) {\r
goto RESTART;\r
IP4_ASSEMLE_HASH_SIZE = 31,
IP4_FRAGMENT_LIFE = 120,
- IP4_MAX_PACKET_SIZE = 65535,
+ IP4_MAX_PACKET_SIZE = 65535
};
//
UINT32 Cur;\r
UINT32 Len;\r
UINT32 Point;\r
- UINT8 IcmpType;\r
- UINT8 IcmpCode;\r
- UINT32 IcmpPoint;\r
+ volatile UINT8 IcmpType;\r
+ volatile UINT8 IcmpCode;\r
+ volatile UINT32 IcmpPoint;\r
\r
IcmpType = ICMP_PARAMETER_PROBLEM;\r
IcmpCode = 0;\r
IP4_OPTION_SSRR = 137, // Strict source and record routing, 10001001
IP4_OPTION_RR = 7, // Record routing, 00000111
- IP4_OPTION_COPY_MASK = 0x80,
+ IP4_OPTION_COPY_MASK = 0x80
};
BOOLEAN
PacketHead->Protocol = Head->Protocol;\r
PacketHead->Src = HTONL (Head->Src);\r
PacketHead->Dst = HTONL (Head->Dst);\r
- PacketHead->Checksum = ~NetblockChecksum ((UINT8 *) PacketHead, HeadLen);\r
+ PacketHead->Checksum = (UINT16) (~NetblockChecksum ((UINT8 *) PacketHead, HeadLen));\r
\r
Packet->Ip = PacketHead;\r
return EFI_SUCCESS;\r
IN IP4_PROTOCOL *IpInstance\r
)\r
{\r
- IP4_SERVICE *IpSb;\r
NET_LIST_ENTRY *Entry;\r
IP4_ROUTE_TABLE *RtTable;\r
IP4_ROUTE_ENTRY *RtEntry;\r
UINT32 Count;\r
INT32 Index;\r
\r
- IpSb = IpInstance->Service;\r
RtTable = IpInstance->RouteTable;\r
\r
if (IpInstance->EfiRouteTable != NULL) {\r
IP4_DIRECT_ROUTE = 0x00000001,
IP4_ROUTE_CACHE_HASH = 31,
- IP4_ROUTE_CACHE_MAX = 64, // Max NO. of cache entry per hash bucket
+ IP4_ROUTE_CACHE_MAX = 64 // Max NO. of cache entry per hash bucket
};
#define IP4_ROUTE_CACHE_HASH(Dst, Src) (((Dst) ^ (Src)) % IP4_ROUTE_CACHE_HASH)
//
typedef struct _IP4_ROUTE_TABLE IP4_ROUTE_TABLE;
-typedef struct _IP4_ROUTE_TABLE {
+struct _IP4_ROUTE_TABLE {
INTN RefCnt;
UINT32 TotalNum;
NET_LIST_ENTRY RouteArea[IP4_MASK_NUM];
//\r
// Copy the MNP Protocol interfaces from the template.\r
//\r
- CopyMem (&Instance->ManagedNetwork, &mMnpProtocolTemplate, sizeof (EFI_MANAGED_NETWORK_PROTOCOL));\r
+ CopyMem (&Instance->ManagedNetwork, &mMnpProtocolTemplate, sizeof (Instance->ManagedNetwork));\r
\r
//\r
// Copy the default config data.\r
//\r
- CopyMem (&Instance->ConfigData, &mMnpDefaultConfigData, sizeof (EFI_MANAGED_NETWORK_CONFIG_DATA));\r
+ CopyMem (&Instance->ConfigData, &mMnpDefaultConfigData, sizeof (Instance->ConfigData));\r
\r
//\r
// Initialize the lists.\r
//\r
// Save the new configuration data.\r
//\r
- CopyMem (OldConfigData, NewConfigData, sizeof (EFI_MANAGED_NETWORK_CONFIG_DATA));\r
+ CopyMem (OldConfigData, NewConfigData, sizeof (*OldConfigData));\r
\r
Instance->Configured = (BOOLEAN) (ConfigData != NULL);\r
\r
NET_LIST_FOR_EACH (Entry, &MnpServiceData->GroupAddressList) {\r
\r
GroupAddress = NET_LIST_USER_STRUCT (Entry, MNP_GROUP_ADDRESS, AddrEntry);\r
- CopyMem (MCastFilter + Index, &GroupAddress->Address, sizeof (EFI_MAC_ADDRESS));\r
+ CopyMem (MCastFilter + Index, &GroupAddress->Address, sizeof (*(MCastFilter + Index)));\r
Index++;\r
\r
ASSERT (Index <= MCastFilterCnt);\r
return EFI_OUT_OF_RESOURCES;\r
}\r
\r
- CopyMem (&GroupAddress->Address, MacAddress, sizeof (EFI_MAC_ADDRESS));\r
+ CopyMem (&GroupAddress->Address, MacAddress, sizeof (GroupAddress->Address));\r
GroupAddress->RefCnt = 0;\r
NetListInsertTail (\r
&MnpServiceData->GroupAddressList,\r
//\r
// Fill the RxData in RxDataWrap,\r
//\r
- CopyMem (&RxDataWrap->RxData, RxData, sizeof (EFI_MANAGED_NETWORK_RECEIVE_DATA));\r
+ CopyMem (&RxDataWrap->RxData, RxData, sizeof (RxDataWrap->RxData));\r
\r
//\r
// Create the recycle event.\r
//\r
// Wrap the RxData.\r
//\r
- CopyMem (&RxDataWrap, MnpWrapRxData (Instance, &RxData), sizeof (MNP_RXDATA_WRAP));\r
+ RxDataWrap = MnpWrapRxData (Instance, &RxData);\r
if (RxDataWrap == NULL) {\r
continue;\r
}\r
//\r
// Copy the instance configuration data.\r
//\r
- CopyMem (MnpConfigData, &Instance->ConfigData, sizeof (EFI_MANAGED_NETWORK_CONFIG_DATA));\r
+ CopyMem (MnpConfigData, &Instance->ConfigData, sizeof (*MnpConfigData));\r
}\r
\r
if (SnpModeData != NULL) {\r
// Copy the underlayer Snp mode data.\r
//\r
Snp = Instance->MnpServiceData->Snp;\r
- CopyMem (SnpModeData, Snp->Mode, sizeof (EFI_SIMPLE_NETWORK_MODE));\r
+ CopyMem (SnpModeData, Snp->Mode, sizeof (*SnpModeData));\r
}\r
\r
if (!Instance->Configured) {\r
Mtftp4ServiceBindingDestroyChild\r
};\r
\r
-//@MT: EFI_DRIVER_ENTRY_POINT (Mtftp4DriverEntryPoint)\r
-\r
EFI_STATUS\r
EFIAPI\r
Mtftp4DriverEntryPoint (\r
\r
Instance->Signature = MTFTP4_PROTOCOL_SIGNATURE;\r
NetListInit (&Instance->Link);\r
- CopyMem (&Instance->Mtftp4, &gMtftp4ProtocolTemplate, sizeof (EFI_MTFTP4_PROTOCOL));\r
+ CopyMem (&Instance->Mtftp4, &gMtftp4ProtocolTemplate, sizeof (Instance->Mtftp4));\r
Instance->State = MTFTP4_STATE_UNCONFIGED;\r
Instance->Indestory = FALSE;\r
Instance->Service = MtftpSb;\r
MTFTP4_STATE_UNCONFIGED = 0,
MTFTP4_STATE_CONFIGED,
- MTFTP4_STATE_DESTORY,
+ MTFTP4_STATE_DESTORY
};
-typedef struct _MTFTP4_SERVICE {
+struct _MTFTP4_SERVICE {
UINT32 Signature;
EFI_SERVICE_BINDING_PROTOCOL ServiceBinding;
EFI_STATUS Status;
} MTFTP4_GETINFO_STATE;
-typedef struct _MTFTP4_PROTOCOL {
+struct _MTFTP4_PROTOCOL {
UINT32 Signature;
NET_LIST_ENTRY Link;
EFI_MTFTP4_PROTOCOL Mtftp4;
MTFTP4_BLKSIZE_EXIST = 0x01,
MTFTP4_TIMEOUT_EXIST = 0x02,
MTFTP4_TSIZE_EXIST = 0x04,
- MTFTP4_MCAST_EXIST = 0x08,
+ MTFTP4_MCAST_EXIST = 0x08
};
typedef struct {
if (Range->End == Num) {\r
Range->End--;\r
} else {\r
- NewRange = Mtftp4AllocateRange (Num + 1, (UINT16) Range->End);\r
+ NewRange = Mtftp4AllocateRange ((UINT16) (Num + 1), (UINT16) Range->End);\r
\r
if (NewRange == NULL) {\r
return EFI_OUT_OF_RESOURCES;\r
UINT8 *Cur;\r
UINT32 Len;\r
UINTN Index;\r
+ UINT32 Len1;\r
+ UINT32 Len2;\r
\r
Token = Instance->Token;\r
Options = Token->OptionList;\r
//\r
// Compute the packet length\r
//\r
- Len = (UINT32) (AsciiStrLen (Token->Filename) + AsciiStrLen (Mode) + 4);\r
+ Len1 = (UINT32) AsciiStrLen ((CHAR8 *) Token->Filename);\r
+ Len2 = (UINT32) AsciiStrLen ((CHAR8 *) Mode);\r
+ Len = (Len1 + Len2 + 4);\r
\r
for (Index = 0; Index < Token->OptionCount; Index++) {\r
- Len += (UINT32) (AsciiStrLen (Options[Index].OptionStr) +\r
- AsciiStrLen (Options[Index].ValueStr) + 2);\r
+ Len1 = (UINT32) AsciiStrLen ((CHAR8 *) Options[Index].OptionStr);\r
+ Len2 = (UINT32) AsciiStrLen ((CHAR8 *) Options[Index].ValueStr);\r
+ Len += Len1 + Len2 + 2;\r
}\r
\r
//\r
Packet = (EFI_MTFTP4_PACKET *) NetbufAllocSpace (Nbuf, Len, FALSE);\r
Packet->OpCode = HTONS (Instance->Operation);\r
Cur = Packet->Rrq.Filename;\r
- Cur = AsciiStrCpy (Cur, Token->Filename);\r
- Cur = AsciiStrCpy (Cur, Mode);\r
+ Cur = (UINT8 *) AsciiStrCpy ((CHAR8 *) Cur, (CHAR8 *) Token->Filename);\r
+ Cur = (UINT8 *) AsciiStrCpy ((CHAR8 *) Cur, (CHAR8 *) Mode);\r
\r
for (Index = 0; Index < Token->OptionCount; ++Index) {\r
- Cur = AsciiStrCpy (Cur, Options[Index].OptionStr);\r
- Cur = AsciiStrCpy (Cur, Options[Index].ValueStr);\r
+ Cur = (UINT8 *) AsciiStrCpy ((CHAR8 *) Cur, (CHAR8 *) Options[Index].OptionStr);\r
+ Cur = (UINT8 *) AsciiStrCpy ((CHAR8 *) Cur, (CHAR8 *) Options[Index].ValueStr);\r
}\r
\r
return Mtftp4SendPacket (Instance, Nbuf);\r
EFI_MTFTP4_PACKET *TftpError;\r
UINT32 Len;\r
\r
- Len = (UINT32) (AsciiStrLen (ErrInfo) + sizeof (EFI_MTFTP4_ERROR_HEADER));\r
+ Len = (UINT32) (AsciiStrLen ((CHAR8 *) ErrInfo) + sizeof (EFI_MTFTP4_ERROR_HEADER));\r
Packet = NetbufAlloc (Len);\r
\r
if (Packet == NULL) {\r
TftpError->OpCode = HTONS (EFI_MTFTP4_OPCODE_ERROR);\r
TftpError->Error.ErrorCode = HTONS (ErrCode);\r
\r
- AsciiStrCpy (TftpError->Error.ErrorMessage, ErrInfo);\r
+ AsciiStrCpy ((CHAR8 *) TftpError->Error.ErrorMessage, (CHAR8 *) ErrInfo);\r
\r
return Mtftp4SendPacket (Instance, Packet);\r
}\r
UDP_POINTS UdpPoint;\r
EFI_STATUS Status;\r
UINT16 OpCode;\r
+ UINT16 Value;\r
\r
//\r
// Save the packet for retransmission\r
// Send the requests to the listening port, other packets\r
// to the connected port\r
//\r
- OpCode = NTOHS (*((UINT16 *) NetbufGetByte (Packet, 0, NULL)));\r
+ Value = *((UINT16 *) NetbufGetByte (Packet, 0, NULL));\r
+ OpCode = NTOHS (Value);\r
\r
if ((OpCode == EFI_MTFTP4_OPCODE_RRQ) || (OpCode == EFI_MTFTP4_OPCODE_DIR) ||\r
(OpCode == EFI_MTFTP4_OPCODE_WRQ)) {\r
UDP_POINTS UdpPoint;\r
EFI_STATUS Status;\r
UINT16 OpCode;\r
+ UINT16 Value;\r
\r
ASSERT (Instance->LastPacket != NULL);\r
\r
//\r
// Set the requests to the listening port, other packets to the connected port\r
//\r
- OpCode = NTOHS (*(UINT16 *) NetbufGetByte (Instance->LastPacket, 0, NULL));\r
+ Value = *(UINT16 *) NetbufGetByte (Instance->LastPacket, 0, NULL);\r
+ OpCode = NTOHS (Value);\r
\r
if ((OpCode == EFI_MTFTP4_OPCODE_RRQ) || (OpCode == EFI_MTFTP4_OPCODE_DIR) ||\r
(OpCode == EFI_MTFTP4_OPCODE_WRQ)) {\r
// Get data from PacketNeeded\r
//\r
DataBuf = NULL;\r
- Status = Token->PacketNeeded (&Instance->Mtftp4, Token, &DataLen, &DataBuf);\r
+ Status = Token->PacketNeeded (&Instance->Mtftp4, Token, &DataLen, (VOID **) &DataBuf);\r
\r
if (EFI_ERROR (Status) || (DataLen > Instance->BlkSize)) {\r
if (DataBuf != NULL) {\r
)\r
{\r
UINT32 Sum;\r
+ UINT16 HeaderChecksum;\r
+ UINT16 MessageChecksum;\r
\r
- Sum = (UINT16)~IpChecksum (Header, HeaderLen) + (UINT16)~IpChecksum (Message, MessageLen);\r
+ HeaderChecksum = (UINT16)~IpChecksum (Header, HeaderLen);\r
+ MessageChecksum = (UINT16)~IpChecksum (Message, MessageLen);\r
+ Sum = HeaderChecksum + MessageChecksum;\r
\r
//\r
// in case above carried\r
Status = gBS->AllocatePool (\r
EfiBootServicesData,\r
BUFFER_ALLOCATE_SIZE,\r
- &Private->TransmitBufferPtr\r
+ (VOID **) &Private->TransmitBufferPtr\r
);\r
\r
if (!EFI_ERROR (Status)) {\r
Status = gBS->AllocatePool (\r
EfiBootServicesData,\r
BUFFER_ALLOCATE_SIZE,\r
- &Private->ReceiveBufferPtr\r
+ (VOID **) &Private->ReceiveBufferPtr\r
);\r
\r
if (!EFI_ERROR (Status)) {\r
Status = gBS->AllocatePool (\r
EfiBootServicesData,\r
256,\r
- &Private->TftpErrorBuffer\r
+ (VOID **) &Private->TftpErrorBuffer\r
);\r
\r
if (EFI_ERROR (Status)) {\r
return EFI_OUT_OF_RESOURCES;\r
}\r
\r
- Status = gBS->AllocatePool (EfiBootServicesData, 256, &Private->TftpAckBuffer);\r
+ Status = gBS->AllocatePool (EfiBootServicesData, 256, (VOID **) &Private->TftpAckBuffer);\r
\r
if (EFI_ERROR (Status)) {\r
gBS->FreePool (Private->TftpErrorBuffer);\r
//\r
// Lock the instance data\r
//\r
- EFI_PXE_BASE_CODE_MODE *PxebcMode;\r
EFI_SIMPLE_NETWORK_PROTOCOL *SnpPtr;\r
EFI_SIMPLE_NETWORK_MODE *SnpModePtr;\r
EFI_STATUS StatCode;\r
\r
EfiAcquireLock (&Private->Lock);\r
\r
- PxebcMode = Private->EfiBc.Mode;\r
SnpPtr = Private->SimpleNetwork;\r
SnpModePtr = SnpPtr->Mode;\r
\r
\r
if (SendGuidPtr != NULL) {\r
if (*SendGuidPtr) {\r
- if (PxeBcLibGetSmbiosSystemGuidAndSerialNumber (&TmpGuid, &SerialNumberPtr) != EFI_SUCCESS) {\r
+ if (PxeBcLibGetSmbiosSystemGuidAndSerialNumber (&TmpGuid, (CHAR8 **) &SerialNumberPtr) != EFI_SUCCESS) {\r
return EFI_INVALID_PARAMETER;\r
}\r
}\r
InitArpHeader ();\r
OptionsStrucInit ();\r
\r
- return EFI_SUCCESS;\r
+ return Status;\r
}\r
\r
/* eof - bc.c */\r
Status = gBS->AllocatePool (\r
EfiBootServicesData,\r
SnpMode->MediaHeaderSize + sizeof (ARP_PACKET),\r
- &Private->ArpBuffer\r
+ (VOID **) &Private->ArpBuffer\r
);\r
\r
if (EFI_ERROR (Status)) {\r
CopyMem (DHCPOpStart.DhcpClassIdentifier.Data.UndiMajor, "yyy", sizeof ("yyy"));\r
CopyMem (DHCPOpStart.DhcpClassIdentifier.Data.UndiMinor, "xxx", sizeof ("xxx"));\r
DHCPOpStart.End[0] = OP_END;\r
-};\r
+}\r
\r
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */\r
\r
} else if (!RxBufPtr->OpAdds.PktOptAdds[OP_DHCP_BOOTFILE_IX - 1] && RxBufPtr->u.Dhcpv4.file[0]) {\r
RxBufPtr->OpAdds.PktOptAdds[OP_DHCP_BOOTFILE_IX - 1] = (DHCPV4_OP_STRUCT *) (RxBufPtr->u.Dhcpv4.file - sizeof (DHCPV4_OP_HEADER));\r
\r
- RxBufPtr->OpAdds.PktOptAdds[OP_DHCP_BOOTFILE_IX - 1]->Header.Length = (UINT8) AsciiStrLen (RxBufPtr->u.Dhcpv4.file);\r
+ RxBufPtr->OpAdds.PktOptAdds[OP_DHCP_BOOTFILE_IX - 1]->Header.Length = (UINT8) AsciiStrLen ((CHAR8 *) RxBufPtr->u.Dhcpv4.file);\r
}\r
\r
LocalPtr.OpPtr = RxBufPtr->OpAdds.PktOptAdds[OP_DHCP_CLASS_IDENTIFIER_IX - 1];\r
{\r
EFI_PXE_BASE_CODE_MODE *PxebcMode;\r
EFI_STATUS Status;\r
- EFI_STATUS StatCode;\r
PXE_BASECODE_DEVICE *Private;\r
\r
//\r
// Lock the instance data and make sure started\r
//\r
- StatCode = EFI_SUCCESS;\r
\r
if (This == NULL) {\r
DEBUG ((DEBUG_ERROR, "BC *This pointer == NULL"));\r
//\r
u = Buffer;\r
u->ReqStr.OpCode = HTONS (Req);\r
- TotalLen = sizeof (Mode) + sizeof (u->ReqStr.OpCode) + (Len = 1 + AsciiStrLen (FilenamePtr));\r
+ TotalLen = sizeof (Mode) + sizeof (u->ReqStr.OpCode) + (Len = 1 + AsciiStrLen ((CHAR8 *) FilenamePtr));\r
\r
CopyMem (u->ReqStr.FileName, FilenamePtr, Len);\r
Ptr = (UINT8 *) (u->ReqStr.FileName + Len);\r
CopyMem (Ptr, BlockSizeOp, sizeof (BlockSizeOp));\r
UtoA10 (*PacketSizePtr, Ptr + sizeof (BlockSizeOp));\r
\r
- TotalLen += (Len = 1 + AsciiStrLen (Ptr + sizeof (BlockSizeOp)) + sizeof (BlockSizeOp));\r
+ TotalLen += (Len = 1 + AsciiStrLen ((CHAR8 *) (Ptr + sizeof (BlockSizeOp))) + sizeof (BlockSizeOp));\r
\r
Ptr += Len;\r
}\r
(UINT16) ReplyLen,\r
BufferSizePtr,\r
Offset,\r
- (INT8 *) &u,\r
+ (UINT8 *) &u,\r
ServerIpPtr,\r
&ServerReplyPort,\r
&Private->EfiBc.Mode->StationIp,\r
Status = gBS->AllocatePool (\r
EfiBootServicesData,\r
BUFFER_ALLOCATE_SIZE,\r
- &BufferPtrLocal\r
+ (VOID **) &BufferPtrLocal\r
);\r
\r
if (EFI_ERROR (Status) || BufferPtrLocal == NULL) {\r
if (gST->ConIn->ReadKeyStroke (gST->ConIn, &Key) == EFI_NOT_READY) {\r
UINT8 Buffer[512];\r
UINTN BufferSize;\r
- EFI_STATUS Status;\r
\r
BufferSize = sizeof Buffer;\r
\r
\r
if (Private->EfiBc.Mode->BisSupported && Private->EfiBc.Mode->BisDetected && Private->EfiBc.Mode->PxeBisReplyReceived) {\r
UINT64 CredentialLen;\r
- UINTN BlockSize;\r
UINT8 CredentialFilename[256];\r
UINT8 *op;\r
VOID *CredentialBuffer;\r
BOOLEAN NewMakeCallback;\r
EFI_STATUS Status;\r
EFI_STATUS TempStatus;\r
+\r
+ //\r
+ // The following line is only used for passing ICC build.\r
+ //\r
+ DEBUG ((EFI_D_INFO, "FilePath = %x\n", FilePath));\r
+\r
//\r
//\r
//\r
//\r
// Add Ip for send pkt to the peer\r
//\r
- CopyMem (&IpCfgData, &mIpIoDefaultIpConfigData, sizeof (EFI_IP4_CONFIG_DATA));\r
+ CopyMem (&IpCfgData, &mIpIoDefaultIpConfigData, sizeof (IpCfgData));\r
IpCfgData.DefaultProtocol = EFI_IP_PROTO_TCP;\r
IpCfgData.UseDefaultAddress = CfgData->AccessPoint.UseDefaultAddress;\r
IpCfgData.StationAddress = CfgData->AccessPoint.StationAddress;\r
//\r
NetZeroMem (&OpenData, sizeof (IP_IO_OPEN_DATA));\r
\r
- CopyMem (&OpenData.IpConfigData, &mIpIoDefaultIpConfigData, sizeof (EFI_IP4_CONFIG_DATA));\r
+ CopyMem (&OpenData.IpConfigData, &mIpIoDefaultIpConfigData, sizeof (OpenData.IpConfigData));\r
OpenData.IpConfigData.DefaultProtocol = EFI_IP_PROTO_TCP;\r
\r
OpenData.PktRcvdNotify = Tcp4RxCallback;\r
SOCKET *Sock;\r
EFI_STATUS Status;\r
IP4_ADDR Ip;\r
+ IP4_ADDR SubnetMask;\r
\r
if (NULL == This) {\r
return EFI_INVALID_PARAMETER;\r
if (!TcpConfigData->AccessPoint.UseDefaultAddress) {\r
\r
NetCopyMem (&Ip, &TcpConfigData->AccessPoint.StationAddress, sizeof (IP4_ADDR));\r
- if (!Ip4IsUnicast (NTOHL (Ip), 0) || !IP4_IS_VALID_NETMASK (NTOHL (Ip))) {\r
+ NetCopyMem (&SubnetMask, &TcpConfigData->AccessPoint.SubnetMask, sizeof (IP4_ADDR));\r
+ if (!Ip4IsUnicast (NTOHL (Ip), 0) || !IP4_IS_VALID_NETMASK (NTOHL (SubnetMask))) {\r
return EFI_INVALID_PARAMETER;\r
}\r
}\r
//\r
// Initialize the UDP random port.\r
//\r
- mUdp4RandomPort = ((UINT16) NetRandomInitSeed ()) % UDP4_PORT_KNOWN + UDP4_PORT_KNOWN;\r
+ mUdp4RandomPort = (UINT16) (((UINT16) NetRandomInitSeed ()) % UDP4_PORT_KNOWN + UDP4_PORT_KNOWN);\r
}\r
\r
return Status;\r
//\r
// Set the OpenData used to open the IpIo.\r
//\r
- CopyMem (&OpenData.IpConfigData, &mIpIoDefaultIpConfigData, sizeof (EFI_IP4_CONFIG_DATA));\r
+ CopyMem (&OpenData.IpConfigData, &mIpIoDefaultIpConfigData, sizeof (OpenData.IpConfigData));\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
- CopyMem (&Instance->Udp4Proto, &mUdp4Protocol, sizeof (EFI_UDP4_PROTOCOL));\r
+ CopyMem (&Instance->Udp4Proto, &mUdp4Protocol, sizeof (Instance->Udp4Proto));\r
Instance->IcmpError = EFI_SUCCESS;\r
Instance->Configured = FALSE;\r
Instance->IsNoMapping = FALSE;\r
IN EFI_IP4_CONFIG_DATA *Ip4ConfigData\r
)\r
{\r
- CopyMem (Ip4ConfigData, &mIpIoDefaultIpConfigData, sizeof (EFI_IP4_CONFIG_DATA));\r
+ CopyMem (Ip4ConfigData, &mIpIoDefaultIpConfigData, sizeof (*Ip4ConfigData));\r
\r
Ip4ConfigData->DefaultProtocol = EFI_IP_PROTO_UDP;\r
Ip4ConfigData->AcceptBroadcast = Udp4ConfigData->AcceptBroadcast;\r
\r
Checksum = NetAddChecksum (Checksum, HTONS ((UINT16) Packet->TotalSize));\r
\r
- return ~Checksum;\r
+ return (UINT16) ~Checksum;\r
}\r
\r
\r
\r
if ((McastIp != NULL) && (!EFI_IP4_EQUAL (*McastIp, (UINTN) Item->Key))) {\r
//\r
- // McastIp is not NULL and the multicast address contained in the Item \r
+ // McastIp is not NULL and the multicast address contained in the Item\r
// is not the same as McastIp.\r
//\r
return EFI_SUCCESS;\r
\r
NetListInit (&Wrap->Link);\r
\r
- CopyMem (&Wrap->RxData, RxData, sizeof (EFI_UDP4_RECEIVE_DATA));\r
+ CopyMem (&Wrap->RxData, RxData, sizeof (Wrap->RxData));\r
\r
//\r
// Create the Recycle event.\r
//\r
// Wrap the RxData and put this Wrap into the instances RcvdDgramQue.\r
//\r
- CopyMem (&Wrap, Udp4WrapRxData (Instance, Packet, RxData), sizeof (UDP4_RXDATA_WRAP));\r
+ CopyMem (&Wrap, Udp4WrapRxData (Instance, Packet, RxData), sizeof (Wrap));\r
if (Wrap == NULL) {\r
continue;\r
}\r
//\r
// Calculate the checksum.\r
//\r
- IcmpErrHdr->Head.Checksum = ~(NetbufChecksum (Packet));\r
+ IcmpErrHdr->Head.Checksum = (UINT16) ~(NetbufChecksum (Packet));\r
\r
//\r
// Fill the override data.\r
//\r
// Set the Udp4ConfigData.\r
//\r
- CopyMem (Udp4ConfigData, &Instance->ConfigData, sizeof (EFI_UDP4_CONFIG_DATA));\r
+ CopyMem (Udp4ConfigData, &Instance->ConfigData, sizeof (*Udp4ConfigData));\r
}\r
\r
Ip = Instance->IpInfo->Ip;\r
//\r
// Save the configuration data.\r
//\r
- CopyMem (&Instance->ConfigData, UdpConfigData, sizeof (EFI_UDP4_CONFIG_DATA));\r
+ CopyMem (&Instance->ConfigData, UdpConfigData, sizeof (Instance->ConfigData));\r
Instance->ConfigData.StationAddress = Ip4ConfigData.StationAddress;\r
Instance->ConfigData.SubnetMask = Ip4ConfigData.SubnetMask;\r
\r
if (JoinFlag) {\r
NetCopyMem (&McastIp, MulticastAddress, sizeof (IP4_ADDR));\r
\r
- if (IP4_IS_MULTICAST (NTOHL (McastIp))) {\r
+ if (!IP4_IS_MULTICAST (NTOHL (McastIp))) {\r
return EFI_INVALID_PARAMETER;\r
}\r
}\r