diff options
author | vanjeff <vanjeff@6f19259b-4bc3-4df7-8a09-765794883524> | 2007-07-23 09:17:39 +0000 |
---|---|---|
committer | vanjeff <vanjeff@6f19259b-4bc3-4df7-8a09-765794883524> | 2007-07-23 09:17:39 +0000 |
commit | cbf316f20726bb31b7c37424601643790dbd02d9 (patch) | |
tree | 8071829b997c64b5b2c904f6008879d97719a10e /MdeModulePkg | |
parent | da89d703c4d412fe87f07307bcb22dfe8b7b2f4b (diff) | |
download | edk2-platforms-cbf316f20726bb31b7c37424601643790dbd02d9.tar.xz |
1. Import NetLib, IpIoLib and UdpIoLib class definitions
2. Import DxeNetLib, DxeIpIoLib and DxeUdpIoLib libraries instances
2. Port Ip4Config module
git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@3405 6f19259b-4bc3-4df7-8a09-765794883524
Diffstat (limited to 'MdeModulePkg')
-rw-r--r-- | MdeModulePkg/Include/Library/IpIoLib.h | 255 | ||||
-rw-r--r-- | MdeModulePkg/Include/Library/NetLib.h | 812 | ||||
-rw-r--r-- | MdeModulePkg/Include/Library/UdpIoLib.h | 177 | ||||
-rw-r--r-- | MdeModulePkg/Library/DxeIpIoLib/DxeIpIoLib.c | 1299 | ||||
-rw-r--r-- | MdeModulePkg/Library/DxeIpIoLib/DxeIpIoLib.inf | 65 | ||||
-rw-r--r-- | MdeModulePkg/Library/DxeNetLib/DxeNetLib.c | 1332 | ||||
-rw-r--r-- | MdeModulePkg/Library/DxeNetLib/DxeNetLib.inf | 66 | ||||
-rw-r--r-- | MdeModulePkg/Library/DxeNetLib/Netbuffer.c | 1759 | ||||
-rw-r--r-- | MdeModulePkg/Library/DxeUdpIoLib/DxeUdpIoLib.c | 727 | ||||
-rw-r--r-- | MdeModulePkg/Library/DxeUdpIoLib/DxeUdpIoLib.inf | 65 | ||||
-rw-r--r-- | MdeModulePkg/MdeModulePkg.dsc | 8 |
11 files changed, 6565 insertions, 0 deletions
diff --git a/MdeModulePkg/Include/Library/IpIoLib.h b/MdeModulePkg/Include/Library/IpIoLib.h new file mode 100644 index 0000000000..15cfbf8f43 --- /dev/null +++ b/MdeModulePkg/Include/Library/IpIoLib.h @@ -0,0 +1,255 @@ +/** @file + +Copyright (c) 2005 - 2007, Intel Corporation +All rights reserved. This program and the accompanying materials +are licensed and made available under the terms and conditions of the BSD License +which accompanies this distribution. The full text of the license may be found at +http://opensource.org/licenses/bsd-license.php + +THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, +WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + +Module Name: + + IpIo.h + +Abstract: + + +**/ + +#ifndef _IP_IO_H_ +#define _IP_IO_H_ + +#include <PiDxe.h> +#include <Protocol/Ip4.h>
+#include <Library/IpIoLib.h>
+#include <Library/NetLib.h> + +//
+// type and code define for ICMP protocol error got
+// from IP
+//
+#define ICMP_TYPE_UNREACH 3
+#define ICMP_TYPE_TIMXCEED 11
+#define ICMP_TYPE_PARAMPROB 12
+#define ICMP_TYPE_SOURCEQUENCH 4
+
+#define ICMP_CODE_UNREACH_NET 0
+#define ICMP_CODE_UNREACH_HOST 1
+#define ICMP_CODE_UNREACH_PROTOCOL 2
+#define ICMP_CODE_UNREACH_PORT 3
+#define ICMP_CODE_UNREACH_NEEDFRAG 4
+#define ICMP_CODE_UNREACH_SRCFAIL 5
+#define ICMP_CODE_UNREACH_NET_UNKNOWN 6
+#define ICMP_CODE_UNREACH_HOST_UNKNOWN 7
+#define ICMP_CODE_UNREACH_ISOLATED 8
+#define ICMP_CODE_UNREACH_NET_PROHIB 9
+#define ICMP_CODE_UNREACH_HOST_PROHIB 10
+#define ICMP_CODE_UNREACH_TOSNET 11
+#define ICMP_CODE_UNREACH_TOSHOST 12
+
+//
+// this error will be delivered to the
+// listening transportation layer protocol
+// consuming IpIO
+//
+typedef enum {
+ ICMP_ERR_UNREACH_NET = 0,
+ ICMP_ERR_UNREACH_HOST,
+ ICMP_ERR_UNREACH_PROTOCOL,
+ ICMP_ERR_UNREACH_PORT,
+ ICMP_ERR_MSGSIZE,
+ ICMP_ERR_UNREACH_SRCFAIL,
+ ICMP_ERR_TIMXCEED_INTRANS,
+ ICMP_ERR_TIMXCEED_REASS,
+ ICMP_ERR_QUENCH,
+ ICMP_ERR_PARAMPROB
+} ICMP_ERROR;
+
+typedef struct _ICMP_ERROR_INFO {
+ EFI_STATUS Error;
+ BOOLEAN IsHard;
+ BOOLEAN Notify;
+} ICMP_ERROR_INFO;
+ +// +// Driver Consumed Protocol Prototypes +// +//@MT:#include EFI_PROTOCOL_CONSUMER (Ip4) +//@MT:#include EFI_PROTOCOL_CONSUMER (Udp4) + +#define EFI_IP4_HEADER_LEN(HdrPtr) ((HdrPtr)->HeaderLength << 2) + +extern EFI_IP4_CONFIG_DATA mIpIoDefaultIpConfigData; + +typedef struct _EFI_NET_SESSION_DATA { + IP4_ADDR Source; + IP4_ADDR Dest; + EFI_IP4_HEADER *IpHdr; +} EFI_NET_SESSION_DATA; + +typedef +VOID +(*PKT_RCVD_NOTIFY) ( + IN EFI_STATUS Status, // rcvd pkt result + IN ICMP_ERROR IcmpErr, // if Status == EFI_ICMP_ERROR, this + // field is valid for user + IN EFI_NET_SESSION_DATA *NetSession, // the communication point + IN NET_BUF *Pkt, // packet received + IN VOID *Context // the Context provided by user for recive data + ); + +typedef +VOID +(*PKT_SENT_NOTIFY) ( + IN EFI_STATUS Status, // sent pkt result + IN VOID *Context, // the context provided by user for sending data + IN VOID *Sender, // the sender to be notified + IN VOID *NotifyData // sent pkt related data to notify + ); + +typedef struct _IP_IO { + + // + // the node used to link this IpIo to the active IpIo list. + // + NET_LIST_ENTRY Entry; + + // the list used to maintain the IP instance for different sending purpose. + // + NET_LIST_ENTRY IpList; + + // + // the ip instance consumed by this IP IO + // + EFI_HANDLE Controller; + EFI_HANDLE Image; + EFI_HANDLE ChildHandle; + EFI_IP4_PROTOCOL *Ip; + BOOLEAN IsConfigured; + + // + // some ip config data can be changed + // + UINT8 Protocol; + + // + // token and event used to get data from IP + // + EFI_IP4_COMPLETION_TOKEN RcvToken; + + // + // list entry used to link the token passed to IP_IO + // + NET_LIST_ENTRY PendingSndList; + + // + // User interface used to get notify from IP_IO + // + VOID *RcvdContext; + VOID *SndContext; + PKT_RCVD_NOTIFY PktRcvdNotify; + PKT_SENT_NOTIFY PktSentNotify; +} IP_IO; + +typedef struct _IP_IO_OPEN_DATA { + EFI_IP4_CONFIG_DATA IpConfigData; + VOID *RcvdContext; + VOID *SndContext; + PKT_RCVD_NOTIFY PktRcvdNotify; + PKT_SENT_NOTIFY PktSentNotify; +} IP_IO_OPEN_DATA; + +typedef struct _IP_IO_SEND_ENTRY { + NET_LIST_ENTRY Entry; + IP_IO *IpIo; + VOID *Context; + VOID *NotifyData; + EFI_IP4_PROTOCOL *Ip; + NET_BUF *Pkt; + EFI_IP4_COMPLETION_TOKEN *SndToken; +} IP_IO_SEND_ENTRY; + +typedef struct _EFI_IP4_OVERRIDE_DATA IP_IO_OVERRIDE; + +typedef struct _IP_IO_IP_INFO { + IP4_ADDR Addr; + IP4_ADDR SubnetMask; + NET_LIST_ENTRY Entry; + EFI_HANDLE ChildHandle; + EFI_IP4_PROTOCOL *Ip; + EFI_IP4_COMPLETION_TOKEN DummyRcvToken; + INTN RefCnt; +} IP_IO_IP_INFO; + +IP_IO * +IpIoCreate ( + IN EFI_HANDLE Image, + IN EFI_HANDLE Controller + ); + +EFI_STATUS +IpIoDestroy ( + IN IP_IO *IpIo + ); + +EFI_STATUS +IpIoStop ( + IN IP_IO *IpIo + ); + +EFI_STATUS +IpIoOpen ( + IN IP_IO *IpIo, + IN IP_IO_OPEN_DATA *OpenData + ); + +EFI_STATUS +IpIoSend ( + IN IP_IO *IpIo, + IN NET_BUF *Pkt, + IN IP_IO_IP_INFO *Sender, + IN VOID *Context OPTIONAL, + IN VOID *NotifyData OPTIONAL, + IN IP4_ADDR Dest, + IN IP_IO_OVERRIDE *OverrideData + ); + +VOID +IpIoCancelTxToken ( + IN IP_IO *IpIo, + IN VOID *Packet + ); + +IP_IO_IP_INFO * +IpIoAddIp ( + IN IP_IO *IpIo + ); + +EFI_STATUS +IpIoConfigIp ( + IN IP_IO_IP_INFO *IpInfo, + IN OUT EFI_IP4_CONFIG_DATA *Ip4ConfigData OPTIONAL + ); + +VOID +IpIoRemoveIp ( + IN IP_IO *IpIo, + IN IP_IO_IP_INFO *IpInfo + ); + +IP_IO_IP_INFO * +IpIoFindSender ( + IN OUT IP_IO **IpIo, + IN IP4_ADDR Src + ); + +EFI_STATUS +IpIoGetIcmpErrStatus ( + IN ICMP_ERROR IcmpError, + OUT BOOLEAN *IsHard, OPTIONAL + OUT BOOLEAN *Notify OPTIONAL + ); + +#endif diff --git a/MdeModulePkg/Include/Library/NetLib.h b/MdeModulePkg/Include/Library/NetLib.h new file mode 100644 index 0000000000..215a2fb094 --- /dev/null +++ b/MdeModulePkg/Include/Library/NetLib.h @@ -0,0 +1,812 @@ +/** @file + +Copyright (c) 2005 - 2007, Intel Corporation +All rights reserved. This program and the accompanying materials +are licensed and made available under the terms and conditions of the BSD License +which accompanies this distribution. The full text of the license may be found at +http://opensource.org/licenses/bsd-license.php + +THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, +WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + +Module Name: + + NetLib.h + +Abstract: + + Library for the UEFI network stack. + + +**/ + +#ifndef _NET_LIB_H_ +#define _NET_LIB_H_ + +#include <PiDxe.h> +#include <Protocol/DriverBinding.h> +#include <Protocol/ComponentName.h> +#include <Protocol/DriverConfiguration.h> +#include <Protocol/DriverDiagnostics.h> + +#define EFI_NET_LITTLE_ENDIAN + +typedef UINT32 IP4_ADDR; +typedef UINT32 TCP_SEQNO; +typedef UINT16 TCP_PORTNO; + +enum { + NET_ETHER_ADDR_LEN = 6, + NET_IFTYPE_ETHERNET = 0x01, + + EFI_IP_PROTO_UDP = 0x11, + EFI_IP_PROTO_TCP = 0x06, + EFI_IP_PROTO_ICMP = 0x01, + + // + // The address classfication + // + IP4_ADDR_CLASSA = 1, + IP4_ADDR_CLASSB, + IP4_ADDR_CLASSC, + IP4_ADDR_CLASSD, + IP4_ADDR_CLASSE, + + IP4_MASK_NUM = 33, +}; + +#pragma pack(1) + +// +// Ethernet head definition +// +typedef struct { + UINT8 DstMac [NET_ETHER_ADDR_LEN]; + UINT8 SrcMac [NET_ETHER_ADDR_LEN]; + UINT16 EtherType; +} ETHER_HEAD; + + +// +// The EFI_IP4_HEADER is hard to use because the source and +// destination address are defined as EFI_IPv4_ADDRESS, which +// is a structure. Two structures can't be compared or masked +// directly. This is why there is an internal representation. +// +typedef struct { +#ifdef EFI_NET_LITTLE_ENDIAN + UINT8 HeadLen : 4; + UINT8 Ver : 4; +#else + UINT8 Ver : 4; + UINT8 HeadLen : 4; +#endif + UINT8 Tos; + UINT16 TotalLen; + UINT16 Id; + UINT16 Fragment; + UINT8 Ttl; + UINT8 Protocol; + UINT16 Checksum; + IP4_ADDR Src; + IP4_ADDR Dst; +} IP4_HEAD; + + +// +// ICMP head definition. ICMP message is categoried as either an error +// message or query message. Two message types have their own head format. +// +typedef struct { + UINT8 Type; + UINT8 Code; + UINT16 Checksum; +} IP4_ICMP_HEAD; + +typedef struct { + IP4_ICMP_HEAD Head; + UINT32 Fourth; // 4th filed of the head, it depends on Type. + IP4_HEAD IpHead; +} IP4_ICMP_ERROR_HEAD; + +typedef struct { + IP4_ICMP_HEAD Head; + UINT16 Id; + UINT16 Seq; +} IP4_ICMP_QUERY_HEAD; + + +// +// UDP header definition +// +typedef struct { + UINT16 SrcPort; + UINT16 DstPort; + UINT16 Length; + UINT16 Checksum; +} EFI_UDP4_HEADER; + + +// +// TCP header definition +// +typedef struct { + TCP_PORTNO SrcPort; + TCP_PORTNO DstPort; + TCP_SEQNO Seq; + TCP_SEQNO Ack; +#ifdef EFI_NET_LITTLE_ENDIAN + UINT8 Res : 4; + UINT8 HeadLen : 4; +#else + UINT8 HeadLen : 4; + UINT8 Res : 4; +#endif + UINT8 Flag; + UINT16 Wnd; + UINT16 Checksum; + UINT16 Urg; +} TCP_HEAD; + +#pragma pack() + +#define NET_MAC_EQUAL(pMac1, pMac2, Len) \ + (NetCompareMem ((pMac1), (pMac2), Len) == 0) + +#define NET_MAC_IS_MULTICAST(Mac, BMac, Len) \ + (((*((UINT8 *) Mac) & 0x01) == 0x01) && (!NET_MAC_EQUAL (Mac, BMac, Len))) + +#ifdef EFI_NET_LITTLE_ENDIAN +#define NTOHL(x) (UINT32)((((UINT32) (x) & 0xff) << 24) | \ + (((UINT32) (x) & 0xff00) << 8) | \ + (((UINT32) (x) & 0xff0000) >> 8) | \ + (((UINT32) (x) & 0xff000000) >> 24)) + +#define HTONL(x) NTOHL(x) + +#define NTOHS(x) (UINT16)((((UINT16) (x) & 0xff) << 8) | \ + (((UINT16) (x) & 0xff00) >> 8)) + +#define HTONS(x) NTOHS(x) +#else +#define NTOHL(x) (UINT32)(x) +#define HTONL(x) (UINT32)(x) +#define NTOHS(x) (UINT16)(x) +#define HTONS(x) (UINT16)(x) +#endif + +// +// Test the IP's attribute, All the IPs are in host byte order. +// +#define IP4_IS_MULTICAST(Ip) (((Ip) & 0xF0000000) == 0xE0000000) +#define IP4_IS_LOCAL_BROADCAST(Ip) ((Ip) == 0xFFFFFFFF) +#define IP4_NET_EQUAL(Ip1, Ip2, NetMask) (((Ip1) & (NetMask)) == ((Ip2) & (NetMask))) +#define IP4_IS_VALID_NETMASK(Ip) (NetGetMaskLength (Ip) != IP4_MASK_NUM) + +// +// Convert the EFI_IP4_ADDRESS to plain UINT32 IP4 address. +// +#define EFI_IP4(EfiIpAddr) (*(IP4_ADDR *) ((EfiIpAddr).Addr)) +#define EFI_NTOHL(EfiIp) (NTOHL (EFI_IP4 ((EfiIp)))) +#define EFI_IP_EQUAL(Ip1, Ip2) (EFI_IP4 (Ip1) == EFI_IP4 (Ip2)) + +INTN +NetGetMaskLength ( + IN IP4_ADDR Mask + ); + +INTN +NetGetIpClass ( + IN IP4_ADDR Addr + ); + +BOOLEAN +Ip4IsUnicast ( + IN IP4_ADDR Ip, + IN IP4_ADDR NetMask + ); + +extern IP4_ADDR mIp4AllMasks [IP4_MASK_NUM]; + +//@MT:#include EFI_PROTOCOL_CONSUMER (LoadedImage) +//@MT:#include EFI_PROTOCOL_CONSUMER (ServiceBinding) +//@MT:#include EFI_PROTOCOL_CONSUMER (SimpleNetwork) + +// +// Wrap functions to ease the impact of EFI library changes. +// +#define NetAllocateZeroPool AllocateZeroPool +#define NetAllocatePool AllocatePool +#define NetFreePool gBS->FreePool +#define NetCopyMem CopyMem +#define NetSetMem SetMem +#define NetZeroMem(Dest, Len) SetMem ((Dest), (Len), 0) +#define NetCompareMem CompareMem + +// +// Lock primitives: the stack implements its lock primitives according +// to the standard EFI enviornment. It will NOT consider multiprocessor. +// +#define NET_TPL_LOCK TPL_CALLBACK +#define NET_TPL_RECYCLE_LOCK (NET_TPL_LOCK + 1) +#define NET_TPL_EVENT TPL_CALLBACK +#define NET_TPL_RECYCLE (NET_TPL_LOCK + 1) +#define NET_TPL_SLOW_TIMER (TPL_CALLBACK - 1) +#define NET_TPL_FAST_TIMER NET_TPL_RECYCLE +#define NET_TPL_TIMER TPL_CALLBACK + +#define NET_LOCK EFI_LOCK +#define NET_LOCK_INIT(x) EfiInitializeLock (x, NET_TPL_LOCK) +#define NET_RECYCLE_LOCK_INIT(x) EfiInitializeLock (x, NET_TPL_RECYCLE_LOCK) +#define NET_TRYLOCK(x) EfiAcquireLockOrFail (x) +#define NET_UNLOCK(x) EfiReleaseLock (x) + +#define NET_RAISE_TPL(x) (gBS->RaiseTPL (x)) +#define NET_RESTORE_TPL(x) (gBS->RestoreTPL (x)) + +#define TICKS_PER_MS 10000U +#define TICKS_PER_SECOND 10000000U + +#define NET_MIN(a, b) ((a) < (b) ? (a) : (b)) +#define NET_MAX(a, b) ((a) > (b) ? (a) : (b)) +#define NET_RANDOM(Seed) (((Seed) * 1103515245L + 12345) % 4294967295L) + + +UINT32 +NetGetUint32 ( + IN UINT8 *Buf + ); + +VOID +NetPutUint32 ( + IN UINT8 *Buf, + IN UINT32 Data + ); + +UINT32 +NetRandomInitSeed ( + VOID + ); + + +// +// Double linked list entry functions, this extends the +// EFI list functions. +// +typedef LIST_ENTRY NET_LIST_ENTRY; + +#define NetListInit(Head) InitializeListHead(Head) +#define NetListInsertHead(Head, Entry) InsertHeadList((Head), (Entry)) +#define NetListInsertTail(Head, Entry) InsertTailList((Head), (Entry)) +#define NetListIsEmpty(List) IsListEmpty(List) + +#define NET_LIST_USER_STRUCT(Entry, Type, Field) \ + _CR(Entry, Type, Field) + +#define NET_LIST_USER_STRUCT_S(Entry, Type, Field, Sig) \ + CR(Entry, Type, Field, Sig) + +// +// Iterate through the doule linked list. It is NOT delete safe +// +#define NET_LIST_FOR_EACH(Entry, ListHead) \ + for(Entry = (ListHead)->ForwardLink; Entry != (ListHead); Entry = Entry->ForwardLink) + +// +// Iterate through the doule linked list. This is delete-safe. +// Don't touch NextEntry. Also, don't use this macro if list +// entries other than the Entry may be deleted when processing +// the current Entry. +// +#define NET_LIST_FOR_EACH_SAFE(Entry, NextEntry, ListHead) \ + for(Entry = (ListHead)->ForwardLink, NextEntry = Entry->ForwardLink; \ + Entry != (ListHead); \ + Entry = NextEntry, NextEntry = Entry->ForwardLink \ + ) + +// +// Make sure the list isn't empty before get the frist/last record. +// +#define NET_LIST_HEAD(ListHead, Type, Field) \ + NET_LIST_USER_STRUCT((ListHead)->ForwardLink, Type, Field) + +#define NET_LIST_TAIL(ListHead, Type, Field) \ + NET_LIST_USER_STRUCT((ListHead)->BackLink, Type, Field) + +#define NetListRemoveEntry(Entry) RemoveEntryList (Entry) + +NET_LIST_ENTRY* +NetListRemoveHead ( + NET_LIST_ENTRY *Head + ); + +NET_LIST_ENTRY* +NetListRemoveTail ( + NET_LIST_ENTRY *Head + ); + +VOID +NetListInsertAfter ( + IN NET_LIST_ENTRY *PrevEntry, + IN NET_LIST_ENTRY *NewEntry + ); + +VOID +NetListInsertBefore ( + IN NET_LIST_ENTRY *PostEntry, + IN NET_LIST_ENTRY *NewEntry + ); + + +// +// Object container: EFI network stack spec defines various kinds of +// tokens. The drivers can share code to manage those objects. +// +typedef struct { + NET_LIST_ENTRY Link; + VOID *Key; + VOID *Value; +} NET_MAP_ITEM; + +typedef struct { + NET_LIST_ENTRY Used; + NET_LIST_ENTRY Recycled; + UINTN Count; +} NET_MAP; + +#define NET_MAP_INCREAMENT 64 + +VOID +NetMapInit ( + IN NET_MAP *Map + ); + +VOID +NetMapClean ( + IN NET_MAP *Map + ); + +BOOLEAN +NetMapIsEmpty ( + IN NET_MAP *Map + ); + +UINTN +NetMapGetCount ( + IN NET_MAP *Map + ); + +EFI_STATUS +NetMapInsertHead ( + IN NET_MAP *Map, + IN VOID *Key, + IN VOID *Value OPTIONAL + ); + +EFI_STATUS +NetMapInsertTail ( + IN NET_MAP *Map, + IN VOID *Key, + IN VOID *Value OPTIONAL + ); + +NET_MAP_ITEM * +NetMapFindKey ( + IN NET_MAP *Map, + IN VOID *Key + ); + +VOID * +NetMapRemoveItem ( + IN NET_MAP *Map, + IN NET_MAP_ITEM *Item, + OUT VOID **Value OPTIONAL + ); + +VOID * +NetMapRemoveHead ( + IN NET_MAP *Map, + OUT VOID **Value OPTIONAL + ); + +VOID * +NetMapRemoveTail ( + IN NET_MAP *Map, + OUT VOID **Value OPTIONAL + ); + +typedef +EFI_STATUS +(*NET_MAP_CALLBACK) ( + IN NET_MAP *Map, + IN NET_MAP_ITEM *Item, + IN VOID *Arg + ); + +EFI_STATUS +NetMapIterate ( + IN NET_MAP *Map, + IN NET_MAP_CALLBACK CallBack, + IN VOID *Arg OPTIONAL + ); + + +// +// Helper functions to implement driver binding and service binding protocols. +// +EFI_STATUS +NetLibCreateServiceChild ( + IN EFI_HANDLE ControllerHandle, + IN EFI_HANDLE ImageHandle, + IN EFI_GUID *ServiceBindingGuid, + OUT EFI_HANDLE *ChildHandle + ); + +EFI_STATUS +NetLibDestroyServiceChild ( + IN EFI_HANDLE ControllerHandle, + IN EFI_HANDLE ImageHandle, + IN EFI_GUID *ServiceBindingGuid, + IN EFI_HANDLE ChildHandle + ); + +EFI_STATUS +NetLibGetMacString ( + IN EFI_HANDLE SnpHandle, + IN EFI_HANDLE ImageHandle, + IN OUT CONST CHAR16 **MacString + ); + +EFI_HANDLE +NetLibGetNicHandle ( + IN EFI_HANDLE Controller, + IN EFI_GUID *ProtocolGuid + ); + +typedef +EFI_STATUS +(EFIAPI *NET_LIB_DRIVER_UNLOAD) ( + IN EFI_HANDLE ImageHandle + ); + +EFI_STATUS +EFIAPI +NetLibDefaultUnload ( + IN EFI_HANDLE ImageHandle + ); + +EFI_STATUS +NetLibInstallAllDriverProtocolsWithUnload ( + IN EFI_HANDLE ImageHandle, + IN EFI_SYSTEM_TABLE *SystemTable, + IN EFI_DRIVER_BINDING_PROTOCOL *DriverBinding, + IN EFI_HANDLE DriverBindingHandle, + IN EFI_COMPONENT_NAME_PROTOCOL *ComponentName, OPTIONAL + IN EFI_DRIVER_CONFIGURATION_PROTOCOL *DriverConfiguration, OPTIONAL + IN EFI_DRIVER_DIAGNOSTICS_PROTOCOL *DriverDiagnostics, OPTIONAL + IN NET_LIB_DRIVER_UNLOAD CustomizedUnload + ); + +EFI_STATUS +NetLibInstallAllDriverProtocols ( + IN EFI_HANDLE ImageHandle, + IN EFI_SYSTEM_TABLE *SystemTable, + IN EFI_DRIVER_BINDING_PROTOCOL *DriverBinding, + IN EFI_HANDLE DriverBindingHandle, + IN EFI_COMPONENT_NAME_PROTOCOL *ComponentName, OPTIONAL + IN EFI_DRIVER_CONFIGURATION_PROTOCOL *DriverConfiguration, OPTIONAL + IN EFI_DRIVER_DIAGNOSTICS_PROTOCOL *DriverDiagnostics OPTIONAL + ); +
+enum { + // + //Various signatures + // + NET_BUF_SIGNATURE = EFI_SIGNATURE_32 ('n', 'b', 'u', 'f'), + NET_VECTOR_SIGNATURE = EFI_SIGNATURE_32 ('n', 'v', 'e', 'c'), + NET_QUE_SIGNATURE = EFI_SIGNATURE_32 ('n', 'b', 'q', 'u'), + + + NET_PROTO_DATA = 64, // Opaque buffer for protocols + NET_BUF_HEAD = 1, // Trim or allocate space from head + NET_BUF_TAIL = 0, // Trim or allocate space from tail + NET_VECTOR_OWN_FIRST = 0x01, // We allocated the 1st block in the vector +}; + +#define NET_CHECK_SIGNATURE(PData, SIGNATURE) \ + ASSERT (((PData) != NULL) && ((PData)->Signature == (SIGNATURE))) + +#define NET_SWAP_SHORT(Value) \ + ((((Value) & 0xff) << 8) | (((Value) >> 8) & 0xff)) + +// +// Single memory block in the vector. +// +typedef struct { + UINT32 Len; // The block's length + UINT8 *Bulk; // The block's Data +} NET_BLOCK; + +typedef VOID (*NET_VECTOR_EXT_FREE) (VOID *Arg); + +// +//NET_VECTOR contains several blocks to hold all packet's +//fragments and other house-keeping stuff for sharing. It +//doesn't specify the where actual packet fragment begins. +// +typedef struct { + UINT32 Signature; + INTN RefCnt; // Reference count to share NET_VECTOR. + NET_VECTOR_EXT_FREE Free; // external function to free NET_VECTOR + VOID *Arg; // opeque argument to Free + UINT32 Flag; // Flags, NET_VECTOR_OWN_FIRST + UINT32 Len; // Total length of the assocated BLOCKs + + UINT32 BlockNum; + NET_BLOCK Block[1]; +} NET_VECTOR; + +// +//NET_BLOCK_OP operate on the NET_BLOCK, It specifies +//where the actual fragment begins and where it ends +// +typedef struct { + UINT8 *BlockHead; // Block's head, or the smallest valid Head + UINT8 *BlockTail; // Block's tail. BlockTail-BlockHead=block length + UINT8 *Head; // 1st byte of the data in the block + UINT8 *Tail; // Tail of the data in the block, Tail-Head=Size + UINT32 Size; // The size of the data +} NET_BLOCK_OP; + + +// +//NET_BUF is the buffer manage structure used by the +//network stack. Every network packet may be fragmented, +//and contains multiple fragments. The Vector points to +//memory blocks used by the each fragment, and BlockOp +//specifies where each fragment begins and ends. +// +//It also contains a opaque area for protocol to store +//per-packet informations. Protocol must be caution not +//to overwrite the members after that. +// +typedef struct { + UINT32 Signature; + INTN RefCnt; + NET_LIST_ENTRY List; // The List this NET_BUF is on + + IP4_HEAD *Ip; // Network layer header, for fast access + TCP_HEAD *Tcp; // Transport layer header, for fast access + UINT8 ProtoData [NET_PROTO_DATA]; //Protocol specific data + + NET_VECTOR *Vector; // The vector containing the packet + + UINT32 BlockOpNum; // Total number of BlockOp in the buffer + UINT32 TotalSize; // Total size of the actual packet + NET_BLOCK_OP BlockOp[1]; // Specify the position of actual packet +} NET_BUF; + + +// +//A queue of NET_BUFs, It is just a thin extension of +//NET_BUF functions. +// +typedef struct { + UINT32 Signature; + INTN RefCnt; + NET_LIST_ENTRY List; // The List this buffer queue is on + + NET_LIST_ENTRY BufList; // list of queued buffers + UINT32 BufSize; // total length of DATA in the buffers + UINT32 BufNum; // total number of buffers on the chain +} NET_BUF_QUEUE; + +// +// Pseudo header for TCP and UDP checksum +// +#pragma pack(1) +typedef struct { + IP4_ADDR SrcIp; + IP4_ADDR DstIp; + UINT8 Reserved; + UINT8 Protocol; + UINT16 Len; +} NET_PSEUDO_HDR; +#pragma pack() + +// +// The fragment entry table used in network interfaces. This is +// the same as NET_BLOCK now. Use two different to distinguish +// the two in case that NET_BLOCK be enhanced later. +// +typedef struct { + UINT32 Len; + UINT8 *Bulk; +} NET_FRAGMENT; + +#define NET_GET_REF(PData) ((PData)->RefCnt++) +#define NET_PUT_REF(PData) ((PData)->RefCnt--) +#define NETBUF_FROM_PROTODATA(Info) _CR((Info), NET_BUF, ProtoData) + +#define NET_BUF_SHARED(Buf) \ + (((Buf)->RefCnt > 1) || ((Buf)->Vector->RefCnt > 1)) + +#define NET_VECTOR_SIZE(BlockNum) \ + (sizeof (NET_VECTOR) + ((BlockNum) - 1) * sizeof (NET_BLOCK)) + +#define NET_BUF_SIZE(BlockOpNum) \ + (sizeof (NET_BUF) + ((BlockOpNum) - 1) * sizeof (NET_BLOCK_OP)) + +#define NET_HEADSPACE(BlockOp) \ + (UINTN)((BlockOp)->Head - (BlockOp)->BlockHead) + +#define NET_TAILSPACE(BlockOp) \ + (UINTN)((BlockOp)->BlockTail - (BlockOp)->Tail) + +NET_BUF * +NetbufAlloc ( + IN UINT32 Len + ); + +VOID +NetbufFree ( + IN NET_BUF *Nbuf + ); + + +UINT8 * +NetbufGetByte ( + IN NET_BUF *Nbuf, + IN UINT32 Offset, + OUT UINT32 *Index OPTIONAL + ); + +NET_BUF * +NetbufClone ( + IN NET_BUF *Nbuf + ); + +NET_BUF * +NetbufDuplicate ( + IN NET_BUF *Nbuf, + IN NET_BUF *Duplicate OPTIONAL, + IN UINT32 HeadSpace + ); + +NET_BUF * +NetbufGetFragment ( + IN NET_BUF *Nbuf, + IN UINT32 Offset, + IN UINT32 Len, + IN UINT32 HeadSpace + ); + +VOID +NetbufReserve ( + IN NET_BUF *Nbuf, + IN UINT32 Len + ); + +UINT8 * +NetbufAllocSpace ( + IN NET_BUF *Nbuf, + IN UINT32 Len, + IN BOOLEAN FromHead + ); + +UINT32 +NetbufTrim ( + IN NET_BUF *Nbuf, + IN UINT32 Len, + IN BOOLEAN FromHead + ); + +UINT32 +NetbufCopy ( + IN NET_BUF *Nbuf, + IN UINT32 Offset, + IN UINT32 Len, + IN UINT8 *Dest + ); + +NET_BUF * +NetbufFromExt ( + IN NET_FRAGMENT *ExtFragment, + IN UINT32 ExtNum, + IN UINT32 HeadSpace, + IN UINT32 HeadLen, + IN NET_VECTOR_EXT_FREE ExtFree, + IN VOID *Arg OPTIONAL + ); + +EFI_STATUS +NetbufBuildExt ( + IN NET_BUF *Nbuf, + IN NET_FRAGMENT *ExtFragment, + IN UINT32 *ExtNum + ); + +NET_BUF * +NetbufFromBufList ( + IN NET_LIST_ENTRY *BufList, + IN UINT32 HeadSpace, + IN UINT32 HeaderLen, + IN NET_VECTOR_EXT_FREE ExtFree, + IN VOID *Arg OPTIONAL + ); + +VOID +NetbufFreeList ( + IN NET_LIST_ENTRY *Head + ); + +VOID +NetbufQueInit ( + IN NET_BUF_QUEUE *NbufQue + ); + +NET_BUF_QUEUE * +NetbufQueAlloc ( + VOID + ); + +VOID +NetbufQueFree ( + IN NET_BUF_QUEUE *NbufQue + ); + +NET_BUF * +NetbufQueRemove ( + IN NET_BUF_QUEUE *NbufQue + ); + +VOID +NetbufQueAppend ( + IN NET_BUF_QUEUE *NbufQue, + IN NET_BUF *Nbuf + ); + +UINT32 +NetbufQueCopy ( + IN NET_BUF_QUEUE *NbufQue, + IN UINT32 Offset, + IN UINT32 Len, + IN UINT8 *Dest + ); + +UINT32 +NetbufQueTrim ( + IN NET_BUF_QUEUE *NbufQue, + IN UINT32 Len + ); + +VOID +NetbufQueFlush ( + IN NET_BUF_QUEUE *NbufQue + ); + +UINT16 +NetblockChecksum ( + IN UINT8 *Bulk, + IN UINT32 Len + ); + +UINT16 +NetAddChecksum ( + IN UINT16 Checksum1, + IN UINT16 Checksum2 + ); + +UINT16 +NetbufChecksum ( + IN NET_BUF *Nbuf + ); + +UINT16 +NetPseudoHeadChecksum ( + IN IP4_ADDR Src, + IN IP4_ADDR Dst, + IN UINT8 Proto, + IN UINT16 Len + ); +#endif diff --git a/MdeModulePkg/Include/Library/UdpIoLib.h b/MdeModulePkg/Include/Library/UdpIoLib.h new file mode 100644 index 0000000000..3f49cc9209 --- /dev/null +++ b/MdeModulePkg/Include/Library/UdpIoLib.h @@ -0,0 +1,177 @@ +/** @file + +Copyright (c) 2006, Intel Corporation +All rights reserved. This program and the accompanying materials +are licensed and made available under the terms and conditions of the BSD License +which accompanies this distribution. The full text of the license may be found at +http://opensource.org/licenses/bsd-license.php + +THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, +WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + + +Module Name: + + Udp4Io.h + +Abstract: + + The helper routines to access UDP service. It is used by both + DHCP and MTFTP. + + +**/ + +#ifndef _UDP4IO_H_ +#define _UDP4IO_H_ + +#include <PiDxe.h>
+
+#include <Protocol/Udp4.h>
+
+#include <Library/UdpIoLib.h> +#include <Library/NetLib.h> + +typedef struct _UDP_IO_PORT UDP_IO_PORT; + +enum { + UDP_IO_RX_SIGNATURE = EFI_SIGNATURE_32 ('U', 'D', 'P', 'R'), + UDP_IO_TX_SIGNATURE = EFI_SIGNATURE_32 ('U', 'D', 'P', 'T'), + UDP_IO_SIGNATURE = EFI_SIGNATURE_32 ('U', 'D', 'P', 'I'), +}; + +typedef struct { + IP4_ADDR LocalAddr; + UINT16 LocalPort; + IP4_ADDR RemoteAddr; + UINT16 RemotePort; +} UDP_POINTS; + +// +// This prototype is used by both receive and transmission. +// When receiving Netbuf is allocated by UDP access point, and +// released by user. When transmitting, the NetBuf is from user, +// and provided to the callback as a reference. +// +typedef +VOID +(*UDP_IO_CALLBACK) ( + IN NET_BUF *Packet, + IN UDP_POINTS *Points, + IN EFI_STATUS IoStatus, + IN VOID *Context + ); + +// +// Each receive request is wrapped in an UDP_RX_TOKEN. Upon completion, +// the CallBack will be called. Only one receive request is send to UDP. +// HeadLen gives the length of the application's header. UDP_IO will +// make the application's header continous before delivery up. +// +typedef struct { + UINT32 Signature; + UDP_IO_PORT *UdpIo; + + UDP_IO_CALLBACK CallBack; + VOID *Context; + + UINT32 HeadLen; + EFI_UDP4_COMPLETION_TOKEN UdpToken; +} UDP_RX_TOKEN; + +// +// Each transmit request is wrapped in an UDP_TX_TOKEN. Upon completion, +// the CallBack will be called. There can be several transmit requests. +// +typedef struct { + UINT32 Signature; + NET_LIST_ENTRY Link; + UDP_IO_PORT *UdpIo; + + UDP_IO_CALLBACK CallBack; + NET_BUF *Packet; + VOID *Context; + + EFI_UDP4_SESSION_DATA UdpSession; + EFI_IPv4_ADDRESS Gateway; + + EFI_UDP4_COMPLETION_TOKEN UdpToken; + EFI_UDP4_TRANSMIT_DATA UdpTxData; +} UDP_TX_TOKEN; + +typedef struct _UDP_IO_PORT { + UINT32 Signature; + NET_LIST_ENTRY Link; + INTN RefCnt; + + // + // Handle used to create/destory UDP child + // + EFI_HANDLE Controller; + EFI_HANDLE Image; + EFI_HANDLE UdpHandle; + + EFI_UDP4_PROTOCOL *Udp; + EFI_UDP4_CONFIG_DATA UdpConfig; + EFI_SIMPLE_NETWORK_MODE SnpMode; + + NET_LIST_ENTRY SentDatagram; + UDP_RX_TOKEN *RecvRequest; +}; + +typedef +EFI_STATUS +(*UDP_IO_CONFIG) ( + IN UDP_IO_PORT *UdpIo, + IN VOID *Context + ); + +typedef +BOOLEAN +(*UDP_IO_TO_CANCEL) ( + IN UDP_TX_TOKEN *Token, + IN VOID *Context + ); + +UDP_IO_PORT * +UdpIoCreatePort ( + IN EFI_HANDLE Controller, + IN EFI_HANDLE ImageHandle, + IN UDP_IO_CONFIG Configure, + IN VOID *Context + ); + +EFI_STATUS +UdpIoFreePort ( + IN UDP_IO_PORT *UdpIo + ); + +VOID +UdpIoCleanPort ( + IN UDP_IO_PORT *UdpIo + ); + +EFI_STATUS +UdpIoSendDatagram ( + IN UDP_IO_PORT *UdpIo, + IN NET_BUF *Packet, + IN UDP_POINTS *EndPoint, OPTIONAL + IN IP4_ADDR Gateway, + IN UDP_IO_CALLBACK CallBack, + IN VOID *Context + ); + +VOID +UdpIoCancelSentDatagram ( + IN UDP_IO_PORT *UdpIo, + IN NET_BUF *Packet + ); + +EFI_STATUS +UdpIoRecvDatagram ( + IN UDP_IO_PORT *UdpIo, + IN UDP_IO_CALLBACK CallBack, + IN VOID *Context, + IN UINT32 HeadLen + ); +#endif diff --git a/MdeModulePkg/Library/DxeIpIoLib/DxeIpIoLib.c b/MdeModulePkg/Library/DxeIpIoLib/DxeIpIoLib.c new file mode 100644 index 0000000000..4a068eaf72 --- /dev/null +++ b/MdeModulePkg/Library/DxeIpIoLib/DxeIpIoLib.c @@ -0,0 +1,1299 @@ +/** @file
+
+Copyright (c) 2005 - 2007, Intel Corporation
+All rights reserved. This program and the accompanying materials
+are licensed and made available under the terms and conditions of the BSD License
+which accompanies this distribution. The full text of the license may be found at
+http://opensource.org/licenses/bsd-license.php
+
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+Module Name:
+
+ IpIo.c
+
+Abstract:
+
+ The implementation of the IpIo layer.
+
+
+**/
+
+#include <PiDxe.h>
+
+#include <Protocol/Udp4.h>
+
+#include <Library/IpIoLib.h>
+#include <Library/BaseLib.h>
+#include <Library/DebugLib.h>
+#include <Library/UefiBootServicesTableLib.h>
+#include <Library/MemoryAllocationLib.h>
+
+
+#define NET_PROTO_HDR(Buf, Type) ((Type *) ((Buf)->BlockOp[0].Head))
+#define ICMP_ERRLEN(IpHdr) \
+ (sizeof(IP4_ICMP_HEAD) + EFI_IP4_HEADER_LEN(IpHdr) + 8)
+
+NET_LIST_ENTRY mActiveIpIoList = {
+ &mActiveIpIoList,
+ &mActiveIpIoList
+};
+
+EFI_IP4_CONFIG_DATA mIpIoDefaultIpConfigData = {
+ EFI_IP_PROTO_UDP,
+ FALSE,
+ TRUE,
+ FALSE,
+ FALSE,
+ FALSE,
+ {0, 0, 0, 0},
+ {0, 0, 0, 0},
+ 0,
+ 255,
+ FALSE,
+ FALSE,
+ 0,
+ 0
+};
+
+STATIC
+VOID
+EFIAPI
+IpIoTransmitHandler (
+ IN EFI_EVENT Event,
+ IN VOID *Context
+ );
+
+
+/**
+ This function create an ip child ,open the IP protocol, return the opened
+ Ip protocol to Interface.
+
+ @param ControllerHandle The controller handle.
+ @param ImageHandle The image handle.
+ @param ChildHandle Pointer to the buffer to save the ip child handle.
+ @param Interface Pointer used to get the ip protocol interface.
+
+ @retval EFI_SUCCESS The ip child is created and the ip protocol
+ interface is retrieved.
+ @retval other The required operation failed.
+
+**/
+STATIC
+EFI_STATUS
+IpIoCreateIpChildOpenProtocol (
+ IN EFI_HANDLE ControllerHandle,
+ IN EFI_HANDLE ImageHandle,
+ IN EFI_HANDLE *ChildHandle,
+ OUT VOID **Interface
+ )
+{
+ EFI_STATUS Status;
+
+ //
+ // Create an ip child.
+ //
+ Status = NetLibCreateServiceChild (
+ ControllerHandle,
+ ImageHandle,
+ &gEfiIp4ServiceBindingProtocolGuid,
+ ChildHandle
+ );
+ if (EFI_ERROR (Status)) {
+ return Status;
+ }
+
+ //
+ // Open the ip protocol installed on the *ChildHandle.
+ //
+ Status = gBS->OpenProtocol (
+ *ChildHandle,
+ &gEfiIp4ProtocolGuid,
+ Interface,
+ ImageHandle,
+ ControllerHandle,
+ EFI_OPEN_PROTOCOL_BY_DRIVER
+ );
+ if (EFI_ERROR (Status)) {
+ //
+ // On failure, destroy the ip child.
+ //
+ NetLibDestroyServiceChild (
+ ControllerHandle,
+ ImageHandle,
+ &gEfiIp4ServiceBindingProtocolGuid,
+ *ChildHandle
+ );
+ }
+
+ return Status;
+}
+
+
+/**
+ This function close the previously openned ip protocol and destroy the ip child.
+
+ @param ControllerHandle The controller handle.
+ @param ImageHandle the image handle.
+ @param ChildHandle The child handle of the ip child.
+
+ @retval EFI_SUCCESS The ip protocol is closed and the relevant ip child
+ is destroyed.
+ @retval other The required operation failed.
+
+**/
+STATIC
+EFI_STATUS
+IpIoCloseProtocolDestroyIpChild (
+ IN EFI_HANDLE ControllerHandle,
+ IN EFI_HANDLE ImageHandle,
+ IN EFI_HANDLE ChildHandle
+ )
+{
+ EFI_STATUS Status;
+
+ //
+ // Close the previously openned ip protocol.
+ //
+ gBS->CloseProtocol (
+ ChildHandle,
+ &gEfiIp4ProtocolGuid,
+ ImageHandle,
+ ControllerHandle
+ );
+
+ //
+ // Destroy the ip child.
+ //
+ Status = NetLibDestroyServiceChild (
+ ControllerHandle,
+ ImageHandle,
+ &gEfiIp4ServiceBindingProtocolGuid,
+ ChildHandle
+ );
+
+ return Status;
+}
+
+
+/**
+ Handle ICMP packets.
+
+ @param IpIo Pointer to the IP_IO instance.
+ @param Pkt Pointer to the ICMP packet.
+ @param Session Pointer to the net session of this ICMP packet.
+
+ @retval EFI_SUCCESS The ICMP packet is handled successfully.
+ @retval EFI_ABORTED This type of ICMP packet is not supported.
+
+**/
+STATIC
+EFI_STATUS
+IpIoIcmpHandler (
+ IN IP_IO *IpIo,
+ IN NET_BUF *Pkt,
+ IN EFI_NET_SESSION_DATA *Session
+ )
+{
+ IP4_ICMP_ERROR_HEAD *IcmpHdr;
+ EFI_IP4_HEADER *IpHdr;
+ ICMP_ERROR IcmpErr;
+ UINT8 *PayLoadHdr;
+ UINT8 Type;
+ UINT8 Code;
+ UINT32 TrimBytes;
+
+ IcmpHdr = NET_PROTO_HDR (Pkt, IP4_ICMP_ERROR_HEAD);
+ IpHdr = (EFI_IP4_HEADER *) (&IcmpHdr->IpHead);
+
+ //
+ // Check the ICMP packet length.
+ //
+ if (Pkt->TotalSize < ICMP_ERRLEN (IpHdr)) {
+
+ return EFI_ABORTED;
+ }
+
+ Type = IcmpHdr->Head.Type;
+ Code = IcmpHdr->Head.Code;
+
+ //
+ // Analyze the ICMP Error in this ICMP pkt
+ //
+ switch (Type) {
+ case ICMP_TYPE_UNREACH:
+ switch (Code) {
+ case ICMP_CODE_UNREACH_NET:
+ case ICMP_CODE_UNREACH_HOST:
+ case ICMP_CODE_UNREACH_PROTOCOL:
+ case ICMP_CODE_UNREACH_PORT:
+ case ICMP_CODE_UNREACH_SRCFAIL:
+ IcmpErr = ICMP_ERR_UNREACH_NET + Code;
+
+ break;
+
+ case ICMP_CODE_UNREACH_NEEDFRAG:
+ IcmpErr = ICMP_ERR_MSGSIZE;
+
+ break;
+
+ case ICMP_CODE_UNREACH_NET_UNKNOWN:
+ case ICMP_CODE_UNREACH_NET_PROHIB:
+ case ICMP_CODE_UNREACH_TOSNET:
+ IcmpErr = ICMP_ERR_UNREACH_NET;
+
+ break;
+
+ case ICMP_CODE_UNREACH_HOST_UNKNOWN:
+ case ICMP_CODE_UNREACH_ISOLATED:
+ case ICMP_CODE_UNREACH_HOST_PROHIB:
+ case ICMP_CODE_UNREACH_TOSHOST:
+ IcmpErr = ICMP_ERR_UNREACH_HOST;
+
+ break;
+
+ default:
+ return EFI_ABORTED;
+
+ break;
+ }
+
+ break;
+
+ case ICMP_TYPE_TIMXCEED:
+ if (Code > 1) {
+ return EFI_ABORTED;
+ }
+
+ IcmpErr = Code + ICMP_ERR_TIMXCEED_INTRANS;
+
+ break;
+
+ case ICMP_TYPE_PARAMPROB:
+ if (Code > 1) {
+ return EFI_ABORTED;
+ }
+
+ IcmpErr = ICMP_ERR_PARAMPROB;
+
+ break;
+
+ case ICMP_TYPE_SOURCEQUENCH:
+ if (Code != 0) {
+ return EFI_ABORTED;
+ }
+
+ IcmpErr = ICMP_ERR_QUENCH;
+
+ break;
+
+ default:
+ return EFI_ABORTED;
+
+ break;
+ }
+
+ //
+ // Notify user the ICMP pkt only containing payload except
+ // IP and ICMP header
+ //
+ PayLoadHdr = (UINT8 *) ((UINT8 *) IpHdr + EFI_IP4_HEADER_LEN (IpHdr));
+ TrimBytes = (UINT32) (PayLoadHdr - (UINT8 *) IcmpHdr);
+
+ NetbufTrim (Pkt, TrimBytes, TRUE);
+
+ IpIo->PktRcvdNotify (EFI_ICMP_ERROR, IcmpErr, Session, Pkt, IpIo->RcvdContext);
+
+ return EFI_SUCCESS;
+}
+
+
+/**
+ Ext free function for net buffer. This function is
+ called when the net buffer is freed. It is used to
+ signal the recycle event to notify IP to recycle the
+ data buffer.
+
+ @param Event The event to be signaled.
+
+ @return None.
+
+**/
+STATIC
+VOID
+IpIoExtFree (
+ IN VOID *Event
+ )
+{
+ gBS->SignalEvent ((EFI_EVENT) Event);
+}
+
+
+/**
+ Create a send entry to wrap a packet before sending
+ out it through IP.
+
+ @param IpIo Pointer to the IP_IO instance.
+ @param Pkt Pointer to the packet.
+ @param Sender Pointer to the IP sender.
+ @param NotifyData Pointer to the notify data.
+ @param Dest Pointer to the destination IP address.
+ @param Override Pointer to the overriden IP_IO data.
+
+ @return Pointer to the data structure created to wrap the packet. If NULL,
+ @return resource limit occurred.
+
+**/
+STATIC
+IP_IO_SEND_ENTRY *
+IpIoCreateSndEntry (
+ IN IP_IO *IpIo,
+ IN NET_BUF *Pkt,
+ IN EFI_IP4_PROTOCOL *Sender,
+ IN VOID *Context OPTIONAL,
+ IN VOID *NotifyData OPTIONAL,
+ IN IP4_ADDR Dest,
+ IN IP_IO_OVERRIDE *Override
+ )
+{
+ IP_IO_SEND_ENTRY *SndEntry;
+ EFI_IP4_COMPLETION_TOKEN *SndToken;
+ EFI_IP4_TRANSMIT_DATA *TxData;
+ EFI_STATUS Status;
+ EFI_IP4_OVERRIDE_DATA *OverrideData;
+ UINT32 Index;
+
+ //
+ // Allocate resource for SndEntry
+ //
+ SndEntry = NetAllocatePool (sizeof (IP_IO_SEND_ENTRY));
+ if (NULL == SndEntry) {
+ return NULL;
+ }
+
+ //
+ // Allocate resource for SndToken
+ //
+ SndToken = NetAllocatePool (sizeof (EFI_IP4_COMPLETION_TOKEN));
+ if (NULL == SndToken) {
+ goto ReleaseSndEntry;
+ }
+
+ Status = gBS->CreateEvent (
+ EVT_NOTIFY_SIGNAL,
+ NET_TPL_EVENT,
+ IpIoTransmitHandler,
+ SndEntry,
+ &(SndToken->Event)
+ );
+ if (EFI_ERROR (Status)) {
+ goto ReleaseSndToken;
+ }
+
+ //
+ // Allocate resource for TxData
+ //
+ TxData = NetAllocatePool (
+ sizeof (EFI_IP4_TRANSMIT_DATA) +
+ sizeof (EFI_IP4_FRAGMENT_DATA) * (Pkt->BlockOpNum - 1)
+ );
+
+ if (NULL == TxData) {
+ goto ReleaseEvent;
+ }
+
+ //
+ // Allocate resource for OverrideData if needed
+ //
+ OverrideData = NULL;
+ if (NULL != Override) {
+
+ OverrideData = NetAllocatePool (sizeof (EFI_IP4_OVERRIDE_DATA));
+ if (NULL == OverrideData) {
+ goto ReleaseResource;
+ }
+ //
+ // Set the fields of OverrideData
+ //
+ *OverrideData = * (EFI_IP4_OVERRIDE_DATA *) Override;
+ }
+
+ //
+ // Set the fields of TxData
+ //
+ EFI_IP4 (TxData->DestinationAddress) = Dest;
+ TxData->OverrideData = OverrideData;
+ TxData->OptionsLength = 0;
+ TxData->OptionsBuffer = NULL;
+ TxData->TotalDataLength = Pkt->TotalSize;
+ TxData->FragmentCount = Pkt->BlockOpNum;
+
+ for (Index = 0; Index < Pkt->BlockOpNum; Index++) {
+
+ TxData->FragmentTable[Index].FragmentBuffer = Pkt->BlockOp[Index].Head;
+ TxData->FragmentTable[Index].FragmentLength = Pkt->BlockOp[Index].Size;
+ }
+
+ //
+ // Set the fields of SndToken
+ //
+ SndToken->Packet.TxData = TxData;
+
+ //
+ // Set the fields of SndEntry
+ //
+ SndEntry->IpIo = IpIo;
+ SndEntry->Ip = Sender;
+ SndEntry->Context = Context;
+ SndEntry->NotifyData = NotifyData;
+
+ SndEntry->Pkt = Pkt;
+ NET_GET_REF (Pkt);
+
+ SndEntry->SndToken = SndToken;
+
+ NetListInsertTail (&IpIo->PendingSndList, &SndEntry->Entry);
+
+ return SndEntry;
+
+ReleaseResource:
+ NetFreePool (TxData);
+
+ReleaseEvent:
+ gBS->CloseEvent (SndToken->Event);
+
+ReleaseSndToken:
+ NetFreePool (SndToken);
+
+ReleaseSndEntry:
+ NetFreePool (SndEntry);
+
+ return NULL;
+}
+
+
+/**
+ Destroy the SndEntry.
+
+ @param SndEntry Pointer to the send entry to be destroyed.
+
+ @return None.
+
+**/
+STATIC
+VOID
+IpIoDestroySndEntry (
+ IN IP_IO_SEND_ENTRY *SndEntry
+ )
+{
+ EFI_IP4_TRANSMIT_DATA *TxData;
+
+ TxData = SndEntry->SndToken->Packet.TxData;
+
+ if (NULL != TxData->OverrideData) {
+ NetFreePool (TxData->OverrideData);
+ }
+
+ NetFreePool (TxData);
+ NetbufFree (SndEntry->Pkt);
+ gBS->CloseEvent (SndEntry->SndToken->Event);
+
+ NetFreePool (SndEntry->SndToken);
+ NetListRemoveEntry (&SndEntry->Entry);
+
+ NetFreePool (SndEntry);
+}
+
+
+/**
+ Notify function for IP transmit token.
+
+ @param Event The event signaled.
+ @param Context The context passed in by the event notifier.
+
+ @return None.
+
+**/
+STATIC
+VOID
+EFIAPI
+IpIoTransmitHandler (
+ IN EFI_EVENT Event,
+ IN VOID *Context
+ )
+{
+ IP_IO *IpIo;
+ IP_IO_SEND_ENTRY *SndEntry;
+
+ SndEntry = (IP_IO_SEND_ENTRY *) Context;
+
+ IpIo = SndEntry->IpIo;
+
+ if (IpIo->PktSentNotify && SndEntry->NotifyData) {
+ IpIo->PktSentNotify (
+ SndEntry->SndToken->Status,
+ SndEntry->Context,
+ SndEntry->Ip,
+ SndEntry->NotifyData
+ );
+ }
+
+ IpIoDestroySndEntry (SndEntry);
+}
+
+
+/**
+ The dummy handler for the dummy IP receive token.
+
+ @param Evt The event signaled.
+ @param Context The context passed in by the event notifier.
+
+ @return None.
+
+**/
+STATIC
+VOID
+EFIAPI
+IpIoDummyHandler (
+ IN EFI_EVENT Event,
+ IN VOID *Context
+ )
+{
+ IP_IO_IP_INFO *IpInfo;
+ EFI_IP4_COMPLETION_TOKEN *DummyToken;
+
+ ASSERT (Event && Context);
+
+ IpInfo = (IP_IO_IP_INFO *) Context;
+ DummyToken = &(IpInfo->DummyRcvToken);
+
+ if (EFI_SUCCESS == DummyToken->Status) {
+ ASSERT (DummyToken->Packet.RxData);
+
+ gBS->SignalEvent (DummyToken->Packet.RxData->RecycleSignal);
+ }
+
+ IpInfo->Ip->Receive (IpInfo->Ip, DummyToken);
+}
+
+
+/**
+ Notify function for the IP receive token, used to process
+ the received IP packets.
+
+ @param Event The event signaled.
+ @param Context The context passed in by the event notifier.
+
+ @return None.
+
+**/
+STATIC
+VOID
+EFIAPI
+IpIoListenHandler (
+ IN EFI_EVENT Event,
+ IN VOID *Context
+ )
+{
+ IP_IO *IpIo;
+ EFI_STATUS Status;
+ EFI_IP4_RECEIVE_DATA *RxData;
+ EFI_IP4_PROTOCOL *Ip;
+ EFI_NET_SESSION_DATA Session;
+ NET_BUF *Pkt;
+
+ IpIo = (IP_IO *) Context;
+
+ Ip = IpIo->Ip;
+ Status = IpIo->RcvToken.Status;
+ RxData = IpIo->RcvToken.Packet.RxData;
+
+ if (((EFI_SUCCESS != Status) && (EFI_ICMP_ERROR != Status)) || (NULL == RxData)) {
+ //
+ // Only process the normal packets and the icmp error packets, if RxData is NULL
+ // with Status == EFI_SUCCESS or EFI_ICMP_ERROR, just resume the receive although
+ // this should be a bug of the low layer (IP).
+ //
+ goto Resume;
+ }
+
+ if (NULL == IpIo->PktRcvdNotify) {
+ goto CleanUp;
+ }
+
+ if ((EFI_IP4 (RxData->Header->SourceAddress) != 0) &&
+ !Ip4IsUnicast (EFI_NTOHL (RxData->Header->SourceAddress), 0)) {
+ //
+ // The source address is not zero and it's not a unicast IP address, discard it.
+ //
+ goto CleanUp;
+ }
+
+ //
+ // Create a netbuffer representing packet
+ //
+ Pkt = NetbufFromExt (
+ (NET_FRAGMENT *) RxData->FragmentTable,
+ RxData->FragmentCount,
+ 0,
+ 0,
+ IpIoExtFree,
+ RxData->RecycleSignal
+ );
+ if (NULL == Pkt) {
+ goto CleanUp;
+ }
+
+ //
+ // Create a net session
+ //
+ Session.Source = EFI_IP4 (RxData->Header->SourceAddress);
+ Session.Dest = EFI_IP4 (RxData->Header->DestinationAddress);
+ Session.IpHdr = RxData->Header;
+
+ if (EFI_SUCCESS == Status) {
+
+ IpIo->PktRcvdNotify (EFI_SUCCESS, 0, &Session, Pkt, IpIo->RcvdContext);
+ } else {
+ //
+ // Status is EFI_ICMP_ERROR
+ //
+ Status = IpIoIcmpHandler (IpIo, Pkt, &Session);
+ if (EFI_ERROR (Status)) {
+ NetbufFree (Pkt);
+ }
+ }
+
+ goto Resume;
+
+CleanUp:
+ gBS->SignalEvent (RxData->RecycleSignal);
+
+Resume:
+ Ip->Receive (Ip, &(IpIo->RcvToken));
+}
+
+
+/**
+ Create a new IP_IO instance.
+
+ @param Image The image handle of an IP_IO consumer protocol.
+ @param Controller The controller handle of an IP_IO consumer protocol
+ installed on.
+
+ @return Pointer to a newly created IP_IO instance.
+
+**/
+IP_IO *
+IpIoCreate (
+ IN EFI_HANDLE Image,
+ IN EFI_HANDLE Controller
+ )
+{
+ EFI_STATUS Status;
+ IP_IO *IpIo;
+
+ IpIo = NetAllocateZeroPool (sizeof (IP_IO));
+ if (NULL == IpIo) {
+ return NULL;
+ }
+
+ NetListInit (&(IpIo->PendingSndList));
+ NetListInit (&(IpIo->IpList));
+ IpIo->Controller = Controller;
+ IpIo->Image = Image;
+
+ Status = gBS->CreateEvent (
+ EVT_NOTIFY_SIGNAL,
+ NET_TPL_EVENT,
+ IpIoListenHandler,
+ IpIo,
+ &(IpIo->RcvToken.Event)
+ );
+ if (EFI_ERROR (Status)) {
+ goto ReleaseIpIo;
+ }
+
+ //
+ // Create an IP child and open IP protocol
+ //
+ Status = IpIoCreateIpChildOpenProtocol (
+ Controller,
+ Image,
+ &IpIo->ChildHandle,
+ (VOID **)&(IpIo->Ip)
+ );
+ if (EFI_ERROR (Status)) {
+ goto ReleaseIpIo;
+ }
+
+ return IpIo;
+
+ReleaseIpIo:
+
+ if (NULL != IpIo->RcvToken.Event) {
+ gBS->CloseEvent (IpIo->RcvToken.Event);
+ }
+
+ NetFreePool (IpIo);
+
+ return NULL;
+}
+
+
+/**
+ Open an IP_IO instance for use.
+
+ @param IpIo Pointer to an IP_IO instance that needs to open.
+ @param OpenData The configuration data for the IP_IO instance.
+
+ @retval EFI_SUCCESS The IP_IO instance opened with OpenData
+ successfully.
+ @retval other Error condition occurred.
+
+**/
+EFI_STATUS
+IpIoOpen (
+ IN IP_IO *IpIo,
+ IN IP_IO_OPEN_DATA *OpenData
+ )
+{
+ EFI_STATUS Status;
+ EFI_IP4_PROTOCOL *Ip;
+ EFI_IPv4_ADDRESS ZeroIp;
+
+ if (IpIo->IsConfigured) {
+ return EFI_ACCESS_DENIED;
+ }
+
+ Ip = IpIo->Ip;
+
+ //
+ // configure ip
+ //
+ Status = Ip->Configure (Ip, &OpenData->IpConfigData);
+ if (EFI_ERROR (Status)) {
+ return Status;
+ }
+
+ //
+ // bugbug: to delete the default route entry in this Ip, if it is:
+ // (0.0.0.0, 0.0.0.0, 0.0.0.0). Delete this statement if Ip modified
+ // its code
+ //
+ EFI_IP4 (ZeroIp) = 0;
+ Status = Ip->Routes (Ip, TRUE, &ZeroIp, &ZeroIp, &ZeroIp);
+
+ if (EFI_ERROR (Status) && (EFI_NOT_FOUND != Status)) {
+ return Status;
+ }
+
+ IpIo->PktRcvdNotify = OpenData->PktRcvdNotify;
+ IpIo->PktSentNotify = OpenData->PktSentNotify;
+
+ IpIo->RcvdContext = OpenData->RcvdContext;
+ IpIo->SndContext = OpenData->SndContext;
+
+ IpIo->Protocol = OpenData->IpConfigData.DefaultProtocol;
+
+ //
+ // start to listen incoming packet
+ //
+ Status = Ip->Receive (Ip, &(IpIo->RcvToken));
+ if (EFI_ERROR (Status)) {
+ Ip->Configure (Ip, NULL);
+ goto ErrorExit;
+ }
+
+ IpIo->IsConfigured = TRUE;
+ NetListInsertTail (&mActiveIpIoList, &IpIo->Entry);
+
+ErrorExit:
+
+ return Status;
+}
+
+
+/**
+ Stop an IP_IO instance.
+
+ @param IpIo Pointer to the IP_IO instance that needs to stop.
+
+ @retval EFI_SUCCESS The IP_IO instance stopped successfully.
+ @retval other Error condition occurred.
+
+**/
+EFI_STATUS
+IpIoStop (
+ IN IP_IO *IpIo
+ )
+{
+ EFI_STATUS Status;
+ EFI_IP4_PROTOCOL *Ip;
+ IP_IO_IP_INFO *IpInfo;
+
+ if (!IpIo->IsConfigured) {
+ return EFI_SUCCESS;
+ }
+
+ //
+ // Remove the IpIo from the active IpIo list.
+ //
+ NetListRemoveEntry (&IpIo->Entry);
+
+ Ip = IpIo->Ip;
+
+ //
+ // Configure NULL Ip
+ //
+ Status = Ip->Configure (Ip, NULL);
+ if (EFI_ERROR (Status)) {
+ return Status;
+ }
+
+ IpIo->IsConfigured = FALSE;
+
+ //
+ // Detroy the Ip List used by IpIo
+ //
+ while (!NetListIsEmpty (&(IpIo->IpList))) {
+ IpInfo = NET_LIST_HEAD (&(IpIo->IpList), IP_IO_IP_INFO, Entry);
+
+ IpIoRemoveIp (IpIo, IpInfo);
+ }
+
+ //
+ // All pending snd tokens should be flushed by reseting the IP instances.
+ //
+ ASSERT (NetListIsEmpty (&IpIo->PendingSndList));
+
+ //
+ // Close the receive event.
+ //
+ gBS->CloseEvent (IpIo->RcvToken.Event);
+
+ return EFI_SUCCESS;
+}
+
+
+/**
+ Destroy an IP_IO instance.
+
+ @param IpIo Pointer to the IP_IO instance that needs to
+ destroy.
+
+ @retval EFI_SUCCESS The IP_IO instance destroyed successfully.
+ @retval other Error condition occurred.
+
+**/
+EFI_STATUS
+IpIoDestroy (
+ IN IP_IO *IpIo
+ )
+{
+ //
+ // Stop the IpIo.
+ //
+ IpIoStop (IpIo);
+
+ //
+ // Close the IP protocol and destroy the child.
+ //
+ IpIoCloseProtocolDestroyIpChild (IpIo->Controller, IpIo->Image, IpIo->ChildHandle);
+
+ NetFreePool (IpIo);
+
+ return EFI_SUCCESS;
+}
+
+
+/**
+ Send out an IP packet.
+
+ @param IpIo Pointer to an IP_IO instance used for sending IP
+ packet.
+ @param Pkt Pointer to the IP packet to be sent.
+ @param Sender The IP protocol instance used for sending.
+ @param NotifyData
+ @param Dest The destination IP address to send this packet to.
+ @param OverrideData The data to override some configuration of the IP
+ instance used for sending.
+
+ @retval EFI_SUCCESS The operation is completed successfully.
+ @retval EFI_NOT_STARTED The IpIo is not configured.
+ @retval EFI_OUT_OF_RESOURCES Failed due to resource limit.
+
+**/
+EFI_STATUS
+IpIoSend (
+ IN IP_IO *IpIo,
+ IN NET_BUF *Pkt,
+ IN IP_IO_IP_INFO *Sender,
+ IN VOID *Context OPTIONAL,
+ IN VOID *NotifyData OPTIONAL,
+ IN IP4_ADDR Dest,
+ IN IP_IO_OVERRIDE *OverrideData
+ )
+{
+ EFI_STATUS Status;
+ EFI_IP4_PROTOCOL *Ip;
+ IP_IO_SEND_ENTRY *SndEntry;
+
+ if (!IpIo->IsConfigured) {
+ return EFI_NOT_STARTED;
+ }
+
+ Ip = (NULL == Sender) ? IpIo->Ip : Sender->Ip;
+
+ //
+ // create a new SndEntry
+ //
+ SndEntry = IpIoCreateSndEntry (IpIo, Pkt, Ip, Context, NotifyData, Dest, OverrideData);
+ if (NULL == SndEntry) {
+ return EFI_OUT_OF_RESOURCES;
+ }
+
+ //
+ // Send this Packet
+ //
+ Status = Ip->Transmit (Ip, SndEntry->SndToken);
+ if (EFI_ERROR (Status)) {
+ IpIoDestroySndEntry (SndEntry);
+ }
+
+ return Status;
+}
+
+
+/**
+ Cancel the IP transmit token which wraps this Packet.
+
+ @param IpIo Pointer to the IP_IO instance.
+ @param Packet Pointer to the packet to cancel.
+
+ @return N/A.
+
+**/
+VOID
+IpIoCancelTxToken (
+ IN IP_IO *IpIo,
+ IN VOID *Packet
+ )
+{
+ NET_LIST_ENTRY *Node;
+ IP_IO_SEND_ENTRY *SndEntry;
+ EFI_IP4_PROTOCOL *Ip;
+
+ ASSERT (IpIo && Packet);
+
+ NET_LIST_FOR_EACH (Node, &IpIo->PendingSndList) {
+
+ SndEntry = NET_LIST_USER_STRUCT (Node, IP_IO_SEND_ENTRY, Entry);
+
+ if (SndEntry->Pkt == Packet) {
+
+ Ip = SndEntry->Ip;
+ Ip->Cancel (Ip, SndEntry->SndToken);
+
+ //
+ // Abort the user token.
+ //
+ SndEntry->SndToken->Status = EFI_ABORTED;
+ IpIoTransmitHandler (NULL, SndEntry);
+
+ break;
+ }
+ }
+
+}
+
+
+/**
+ Add a new IP instance for sending data.
+
+ @param IpIo Pointer to a IP_IO instance to add a new IP
+ instance for sending purpose.
+
+ @return Pointer to the created IP_IO_IP_INFO structure, NULL is failed.
+
+**/
+IP_IO_IP_INFO *
+IpIoAddIp (
+ IN IP_IO *IpIo
+ )
+{
+ EFI_STATUS Status;
+ IP_IO_IP_INFO *IpInfo;
+
+ ASSERT (IpIo);
+
+ IpInfo = NetAllocatePool (sizeof (IP_IO_IP_INFO));
+ if (IpInfo == NULL) {
+ return IpInfo;
+ }
+
+ //
+ // Init this IpInfo, set the Addr and SubnetMask to 0 before we configure the IP
+ // instance.
+ //
+ NetListInit (&IpInfo->Entry);
+ IpInfo->ChildHandle = NULL;
+ IpInfo->Addr = 0;
+ IpInfo->SubnetMask = 0;
+ IpInfo->RefCnt = 1;
+
+ //
+ // Create the IP instance and open the Ip4 protocol.
+ //
+ Status = IpIoCreateIpChildOpenProtocol (
+ IpIo->Controller,
+ IpIo->Image,
+ &IpInfo->ChildHandle,
+ &IpInfo->Ip
+ );
+ if (EFI_ERROR (Status)) {
+ goto ReleaseIpInfo;
+ }
+
+ //
+ // Create the event for the DummyRcvToken.
+ //
+ Status = gBS->CreateEvent (
+ EVT_NOTIFY_SIGNAL,
+ NET_TPL_EVENT,
+ IpIoDummyHandler,
+ IpInfo,
+ &IpInfo->DummyRcvToken.Event
+ );
+ if (EFI_ERROR (Status)) {
+ goto ReleaseIpChild;
+ }
+
+ //
+ // Link this IpInfo into the IpIo.
+ //
+ NetListInsertTail (&IpIo->IpList, &IpInfo->Entry);
+
+ return IpInfo;
+
+ReleaseIpChild:
+
+ IpIoCloseProtocolDestroyIpChild (
+ IpIo->Controller,
+ IpIo->Image,
+ IpInfo->ChildHandle
+ );
+
+ReleaseIpInfo:
+
+ NetFreePool (IpInfo);
+
+ return NULL;
+}
+
+
+/**
+ Configure the IP instance of this IpInfo and start the receiving if Ip4ConfigData
+ is not NULL.
+
+ @param IpInfo Pointer to the IP_IO_IP_INFO instance.
+ @param Ip4ConfigData The IP4 configure data used to configure the ip
+ instance, if NULL the ip instance is reseted. If
+ UseDefaultAddress is set to TRUE, and the configure
+ operation succeeds, the default address information
+ is written back in this Ip4ConfigData.
+
+ @retval EFI_STATUS The status returned by IP4->Configure or
+ IP4->Receive.
+
+**/
+EFI_STATUS
+IpIoConfigIp (
+ IN IP_IO_IP_INFO *IpInfo,
+ IN OUT EFI_IP4_CONFIG_DATA *Ip4ConfigData OPTIONAL
+ )
+{
+ EFI_STATUS Status;
+ EFI_IP4_PROTOCOL *Ip;
+ EFI_IP4_MODE_DATA Ip4ModeData;
+
+ ASSERT (IpInfo);
+
+ if (IpInfo->RefCnt > 1) {
+ //
+ // This IP instance is shared, don't reconfigure it until it has only one
+ // consumer. Currently, only the tcp children cloned from their passive parent
+ // will share the same IP. So this cases only happens while Ip4ConfigData is NULL,
+ // let the last consumer clean the IP instance.
+ //
+ return EFI_SUCCESS;
+ }
+
+ Ip = IpInfo->Ip;
+
+ Status = Ip->Configure (Ip, Ip4ConfigData);
+ if (EFI_ERROR (Status)) {
+ goto OnExit;
+ }
+
+ if (Ip4ConfigData != NULL) {
+
+ if (Ip4ConfigData->UseDefaultAddress) {
+ Ip->GetModeData (Ip, &Ip4ModeData, NULL, NULL);
+
+ Ip4ConfigData->StationAddress = Ip4ModeData.ConfigData.StationAddress;
+ Ip4ConfigData->SubnetMask = Ip4ModeData.ConfigData.SubnetMask;
+ }
+
+ IpInfo->Addr = EFI_IP4 (Ip4ConfigData->StationAddress);
+ IpInfo->SubnetMask = EFI_IP4 (Ip4ConfigData->SubnetMask);
+
+ Status = Ip->Receive (Ip, &IpInfo->DummyRcvToken);
+ if (EFI_ERROR (Status)) {
+ Ip->Configure (Ip, NULL);
+ }
+ } else {
+
+ //
+ // The IP instance is reseted, set the stored Addr and SubnetMask to zero.
+ //
+ IpInfo->Addr = 0;
+ IpInfo->SubnetMask =0;
+ }
+
+OnExit:
+
+ return Status;
+}
+
+
+/**
+ Destroy an IP instance maintained in IpIo->IpList for
+ sending purpose.
+
+ @param IpIo Pointer to the IP_IO instance.
+ @param IpInfo Pointer to the IpInfo to be removed.
+
+ @return None.
+
+**/
+VOID
+IpIoRemoveIp (
+ IN IP_IO *IpIo,
+ IN IP_IO_IP_INFO *IpInfo
+ )
+{
+ ASSERT (IpInfo->RefCnt > 0);
+
+ NET_PUT_REF (IpInfo);
+
+ if (IpInfo->RefCnt > 0) {
+
+ return;
+ }
+
+ NetListRemoveEntry (&IpInfo->Entry);
+
+ IpInfo->Ip->Configure (IpInfo->Ip, NULL);
+
+ IpIoCloseProtocolDestroyIpChild (IpIo->Controller, IpIo->Image, IpInfo->ChildHandle);
+
+ gBS->CloseEvent (IpInfo->DummyRcvToken.Event);
+
+ NetFreePool (IpInfo);
+}
+
+
+/**
+ Find the first IP protocol maintained in IpIo whose local
+ address is the same with Src.
+
+ @param IpIo Pointer to the pointer of the IP_IO instance.
+ @param Src The local IP address.
+
+ @return Pointer to the IP protocol can be used for sending purpose and its local
+ @return address is the same with Src.
+
+**/
+IP_IO_IP_INFO *
+IpIoFindSender (
+ IN OUT IP_IO **IpIo,
+ IN IP4_ADDR Src
+ )
+{
+ NET_LIST_ENTRY *IpIoEntry;
+ IP_IO *IpIoPtr;
+ NET_LIST_ENTRY *IpInfoEntry;
+ IP_IO_IP_INFO *IpInfo;
+
+ NET_LIST_FOR_EACH (IpIoEntry, &mActiveIpIoList) {
+ IpIoPtr = NET_LIST_USER_STRUCT (IpIoEntry, IP_IO, Entry);
+
+ if ((*IpIo != NULL) && (*IpIo != IpIoPtr)) {
+ continue;
+ }
+
+ NET_LIST_FOR_EACH (IpInfoEntry, &IpIoPtr->IpList) {
+ IpInfo = NET_LIST_USER_STRUCT (IpInfoEntry, IP_IO_IP_INFO, Entry);
+
+ if (IpInfo->Addr == Src) {
+ *IpIo = IpIoPtr;
+ return IpInfo;
+ }
+ }
+ }
+
+ //
+ // No match.
+ //
+ return NULL;
+}
+
+
+/**
+ Get the ICMP error map information, the ErrorStatus will be returned.
+ The IsHard and Notify are optional. If they are not NULL, this rouine will
+ fill them.
+ We move IcmpErrMap[] to local variable to enable EBC build.
+
+ @param IcmpError IcmpError Type
+ @param IsHard Whether it is a hard error
+ @param Notify Whether it need to notify SockError
+
+ @return ICMP Error Status
+
+**/
+EFI_STATUS
+IpIoGetIcmpErrStatus (
+ IN ICMP_ERROR IcmpError,
+ OUT BOOLEAN *IsHard, OPTIONAL
+ OUT BOOLEAN *Notify OPTIONAL
+ )
+{
+ ICMP_ERROR_INFO IcmpErrMap[] = {
+ { EFI_NETWORK_UNREACHABLE, FALSE, TRUE }, // ICMP_ERR_UNREACH_NET
+ { EFI_HOST_UNREACHABLE, FALSE, TRUE }, // ICMP_ERR_UNREACH_HOST
+ { EFI_PROTOCOL_UNREACHABLE, TRUE, TRUE }, // ICMP_ERR_UNREACH_PROTOCOL
+ { EFI_PORT_UNREACHABLE, TRUE, TRUE }, // ICMP_ERR_UNREACH_PORT
+ { EFI_ICMP_ERROR, TRUE, TRUE }, // ICMP_ERR_MSGSIZE
+ { EFI_ICMP_ERROR, FALSE, TRUE }, // ICMP_ERR_UNREACH_SRCFAIL
+ { EFI_HOST_UNREACHABLE, FALSE, TRUE }, // ICMP_ERR_TIMXCEED_INTRANS
+ { EFI_HOST_UNREACHABLE, FALSE, TRUE }, // ICMP_ERR_TIMEXCEED_REASS
+ { EFI_ICMP_ERROR, FALSE, FALSE }, // ICMP_ERR_QUENCH
+ { EFI_ICMP_ERROR, FALSE, TRUE } // ICMP_ERR_PARAMPROB
+ };
+
+ ASSERT ((IcmpError >= ICMP_ERR_UNREACH_NET) && (IcmpError <= ICMP_ERR_PARAMPROB));
+
+ if (IsHard != NULL) {
+ *IsHard = IcmpErrMap[IcmpError].IsHard;
+ }
+
+ if (Notify != NULL) {
+ *Notify = IcmpErrMap[IcmpError].Notify;
+ }
+
+ return IcmpErrMap[IcmpError].Error;
+}
+
diff --git a/MdeModulePkg/Library/DxeIpIoLib/DxeIpIoLib.inf b/MdeModulePkg/Library/DxeIpIoLib/DxeIpIoLib.inf new file mode 100644 index 0000000000..9430d8abba --- /dev/null +++ b/MdeModulePkg/Library/DxeIpIoLib/DxeIpIoLib.inf @@ -0,0 +1,65 @@ +#/** @file
+# Component name for module NetLib
+#
+# FIX ME!
+# Copyright (c) 2006, Intel Corporation. All right reserved.
+#
+# All rights reserved. This program and the accompanying materials
+# are licensed and made available under the terms and conditions of the BSD License
+# which accompanies this distribution. The full text of the license may be found at
+# http://opensource.org/licenses/bsd-license.php
+#
+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+#
+#
+#**/
+
+[Defines]
+ INF_VERSION = 0x00010005
+ BASE_NAME = NetIpIoDxe
+ FILE_GUID = A302F877-8625-425c-B1EC-7487B62C4FDA
+ MODULE_TYPE = DXE_DRIVER
+ VERSION_STRING = 1.0
+ LIBRARY_CLASS = IpIoLib|DXE_CORE DXE_DRIVER DXE_RUNTIME_DRIVER DXE_SAL_DRIVER DXE_SMM_DRIVER UEFI_APPLICATION UEFI_DRIVER
+ EDK_RELEASE_VERSION = 0x00020000
+ EFI_SPECIFICATION_VERSION = 0x00020000
+
+
+#
+# The following information is for reference only and not required by the build tools.
+#
+# VALID_ARCHITECTURES = IA32 X64 IPF EBC
+#
+
+[Sources.common]
+ DxeIpIoLib.c
+
+[Packages]
+ MdePkg/MdePkg.dec
+ MdeModulePkg/MdeModulePkg.dec
+
+
+[LibraryClasses]
+ MemoryAllocationLib
+ UefiLib
+ BaseLib
+ UefiBootServicesTableLib
+ UefiRuntimeServicesTableLib
+ BaseMemoryLib
+ DebugLib
+ PrintLib
+
+
+[Protocols]
+ gEfiIp4ProtocolGuid # PROTOCOL ALWAYS_CONSUMED
+ gEfiDriverDiagnosticsProtocolGuid # PROTOCOL ALWAYS_CONSUMED
+ gEfiUdp4ServiceBindingProtocolGuid # PROTOCOL ALWAYS_CONSUMED
+ gEfiLoadedImageProtocolGuid # PROTOCOL ALWAYS_CONSUMED
+ gEfiIp4ServiceBindingProtocolGuid # PROTOCOL ALWAYS_CONSUMED
+ gEfiDriverConfigurationProtocolGuid # PROTOCOL ALWAYS_CONSUMED
+ gEfiSimpleNetworkProtocolGuid # PROTOCOL ALWAYS_CONSUMED
+ gEfiDriverBindingProtocolGuid # PROTOCOL ALWAYS_CONSUMED
+ gEfiUdp4ProtocolGuid # PROTOCOL ALWAYS_CONSUMED
+ gEfiComponentNameProtocolGuid # PROTOCOL ALWAYS_CONSUMED
+
diff --git a/MdeModulePkg/Library/DxeNetLib/DxeNetLib.c b/MdeModulePkg/Library/DxeNetLib/DxeNetLib.c new file mode 100644 index 0000000000..88dcf76a05 --- /dev/null +++ b/MdeModulePkg/Library/DxeNetLib/DxeNetLib.c @@ -0,0 +1,1332 @@ +/** @file + +Copyright (c) 2005 - 2007, Intel Corporation +All rights reserved. This program and the accompanying materials +are licensed and made available under the terms and conditions of the BSD License +which accompanies this distribution. The full text of the license may be found at +http://opensource.org/licenses/bsd-license.php + +THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, +WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + +Module Name: + + NetLib.c + +Abstract: + + + +**/ + +#include <PiDxe.h> + +#include <Protocol/ServiceBinding.h> +#include <Protocol/SimpleNetwork.h> +#include <Protocol/LoadedImage.h> + +#include <Library/NetLib.h> +#include <Library/BaseLib.h> +#include <Library/DebugLib.h> +#include <Library/BaseMemoryLib.h> +#include <Library/UefiBootServicesTableLib.h> +#include <Library/UefiRuntimeServicesTableLib.h> +#include <Library/UefiLib.h>
+#include <Library/MemoryAllocationLib.h> + + +// +// All the supported IP4 maskes in host byte order. +// +IP4_ADDR mIp4AllMasks[IP4_MASK_NUM] = { + 0x00000000, + 0x80000000, + 0xC0000000, + 0xE0000000, + 0xF0000000, + 0xF8000000, + 0xFC000000, + 0xFE000000, + + 0xFF000000, + 0xFF800000, + 0xFFC00000, + 0xFFE00000, + 0xFFF00000, + 0xFFF80000, + 0xFFFC0000, + 0xFFFE0000, + + 0xFFFF0000, + 0xFFFF8000, + 0xFFFFC000, + 0xFFFFE000, + 0xFFFFF000, + 0xFFFFF800, + 0xFFFFFC00, + 0xFFFFFE00, + + 0xFFFFFF00, + 0xFFFFFF80, + 0xFFFFFFC0, + 0xFFFFFFE0, + 0xFFFFFFF0, + 0xFFFFFFF8, + 0xFFFFFFFC, + 0xFFFFFFFE, + 0xFFFFFFFF, +}; + + +/**
+ Converts the low nibble of a byte to hex unicode character.
+
+ @param Nibble lower nibble of a byte.
+
+ @return Hex unicode character.
+
+**/
+CHAR16
+NibbleToHexChar (
+ IN UINT8 Nibble
+ )
+{
+ //
+ // Porting Guide:
+ // This library interface is simply obsolete.
+ // Include the source code to user code.
+ //
+
+ Nibble &= 0x0F;
+ if (Nibble <= 0x9) {
+ return (CHAR16)(Nibble + L'0');
+ }
+
+ return (CHAR16)(Nibble - 0xA + L'A');
+}
+
+/** + Return the length of the mask. If the mask is invalid, + return the invalid length 33, which is IP4_MASK_NUM. + NetMask is in the host byte order. + + @param NetMask The netmask to get the length from + + @return The length of the netmask, IP4_MASK_NUM if the mask isn't + @return supported. + +**/ +INTN +NetGetMaskLength ( + IN IP4_ADDR NetMask + ) +{ + INTN Index; + + for (Index = 0; Index < IP4_MASK_NUM; Index++) { + if (NetMask == mIp4AllMasks[Index]) { + break; + } + } + + return Index; +} + + + +/** + Return the class of the address, such as class a, b, c. + Addr is in host byte order. + + @param Addr The address to get the class from + + @return IP address class, such as IP4_ADDR_CLASSA + +**/ +INTN +NetGetIpClass ( + IN IP4_ADDR Addr + ) +{ + UINT8 ByteOne; + + ByteOne = (UINT8) (Addr >> 24); + + if ((ByteOne & 0x80) == 0) { + return IP4_ADDR_CLASSA; + + } else if ((ByteOne & 0xC0) == 0x80) { + return IP4_ADDR_CLASSB; + + } else if ((ByteOne & 0xE0) == 0xC0) { + return IP4_ADDR_CLASSC; + + } else if ((ByteOne & 0xF0) == 0xE0) { + return IP4_ADDR_CLASSD; + + } else { + return IP4_ADDR_CLASSE; + + } +} + + +/** + Check whether the IP is a valid unicast address according to + the netmask. If NetMask is zero, use the IP address's class to + get the default mask. + + @param Ip The IP to check againist + @param NetMask The mask of the IP + + @return TRUE if IP is a valid unicast address on the network, otherwise FALSE + +**/ +BOOLEAN +Ip4IsUnicast ( + IN IP4_ADDR Ip, + IN IP4_ADDR NetMask + ) +{ + INTN Class; + + Class = NetGetIpClass (Ip); + + if ((Ip == 0) || (Class >= IP4_ADDR_CLASSD)) { + return FALSE; + } + + if (NetMask == 0) { + NetMask = mIp4AllMasks[Class << 3]; + } + + if (((Ip &~NetMask) == ~NetMask) || ((Ip &~NetMask) == 0)) { + return FALSE; + } + + return TRUE; +} + + +/** + Initialize a random seed using current time. + + None + + @return The random seed initialized with current time. + +**/ +UINT32 +NetRandomInitSeed ( + VOID + ) +{ + EFI_TIME Time; + UINT32 Seed; + + gRT->GetTime (&Time, NULL); + Seed = (~Time.Hour << 24 | Time.Second << 16 | Time.Minute << 8 | Time.Day); + Seed ^= Time.Nanosecond; + Seed ^= Time.Year << 7; + + return Seed; +} + + +/** + Extract a UINT32 from a byte stream, then convert it to host + byte order. Use this function to avoid alignment error. + + @param Buf The buffer to extract the UINT32. + + @return The UINT32 extracted. + +**/ +UINT32 +NetGetUint32 ( + IN UINT8 *Buf + ) +{ + UINT32 Value; + + NetCopyMem (&Value, Buf, sizeof (UINT32)); + return NTOHL (Value); +} + + +/** + Put a UINT32 to the byte stream. Convert it from host byte order + to network byte order before putting. + + @param Buf The buffer to put the UINT32 + @param Data The data to put + + @return None + +**/ +VOID +NetPutUint32 ( + IN UINT8 *Buf, + IN UINT32 Data + ) +{ + Data = HTONL (Data); + NetCopyMem (Buf, &Data, sizeof (UINT32)); +} + + +/** + Remove the first entry on the list + + @param Head The list header + + @return The entry that is removed from the list, NULL if the list is empty. + +**/ +NET_LIST_ENTRY * +NetListRemoveHead ( + NET_LIST_ENTRY *Head + ) +{ + NET_LIST_ENTRY *First; + + ASSERT (Head != NULL); + + if (NetListIsEmpty (Head)) { + return NULL; + } + + First = Head->ForwardLink; + Head->ForwardLink = First->ForwardLink; + First->ForwardLink->BackLink = Head; + + DEBUG_CODE ( + First->ForwardLink = (LIST_ENTRY *) NULL; + First->BackLink = (LIST_ENTRY *) NULL; + ); + + return First; +} + + +/** + Remove the last entry on the list + + @param Head The list head + + @return The entry that is removed from the list, NULL if the list is empty. + +**/ +NET_LIST_ENTRY * +NetListRemoveTail ( + NET_LIST_ENTRY *Head + ) +{ + NET_LIST_ENTRY *Last; + + ASSERT (Head != NULL); + + if (NetListIsEmpty (Head)) { + return NULL; + } + + Last = Head->BackLink; + Head->BackLink = Last->BackLink; + Last->BackLink->ForwardLink = Head; + + DEBUG_CODE ( + Last->ForwardLink = (LIST_ENTRY *) NULL; + Last->BackLink = (LIST_ENTRY *) NULL; + ); + + return Last; +} + + +/** + Insert the NewEntry after the PrevEntry + + @param PrevEntry The previous entry to insert after + @param NewEntry The new entry to insert + + @return None + +**/ +VOID +NetListInsertAfter ( + IN NET_LIST_ENTRY *PrevEntry, + IN NET_LIST_ENTRY *NewEntry + ) +{ + NewEntry->BackLink = PrevEntry; + NewEntry->ForwardLink = PrevEntry->ForwardLink; + PrevEntry->ForwardLink->BackLink = NewEntry; + PrevEntry->ForwardLink = NewEntry; +} + + +/** + Insert the NewEntry before the PostEntry + + @param PostEntry The entry to insert before + @param NewEntry The new entry to insert + + @return None + +**/ +VOID +NetListInsertBefore ( + IN NET_LIST_ENTRY *PostEntry, + IN NET_LIST_ENTRY *NewEntry + ) +{ + NewEntry->ForwardLink = PostEntry; + NewEntry->BackLink = PostEntry->BackLink; + PostEntry->BackLink->ForwardLink = NewEntry; + PostEntry->BackLink = NewEntry; +} + + +/** + Initialize the netmap. Netmap is a reposity to keep the <Key, Value> pairs. + + @param Map The netmap to initialize + + @return None + +**/ +VOID +NetMapInit ( + IN NET_MAP *Map + ) +{ + ASSERT (Map != NULL); + + NetListInit (&Map->Used); + NetListInit (&Map->Recycled); + Map->Count = 0; +} + + +/** + To clean up the netmap, that is, release allocated memories. + + @param Map The netmap to clean up. + + @return None + +**/ +VOID +NetMapClean ( + IN NET_MAP *Map + ) +{ + NET_MAP_ITEM *Item; + NET_LIST_ENTRY *Entry; + NET_LIST_ENTRY *Next; + + ASSERT (Map != NULL); + + NET_LIST_FOR_EACH_SAFE (Entry, Next, &Map->Used) { + Item = NET_LIST_USER_STRUCT (Entry, NET_MAP_ITEM, Link); + + NetListRemoveEntry (&Item->Link); + Map->Count--; + + NetFreePool (Item); + } + + ASSERT ((Map->Count == 0) && NetListIsEmpty (&Map->Used)); + + NET_LIST_FOR_EACH_SAFE (Entry, Next, &Map->Recycled) { + Item = NET_LIST_USER_STRUCT (Entry, NET_MAP_ITEM, Link); + + NetListRemoveEntry (&Item->Link); + NetFreePool (Item); + } + + ASSERT (NetListIsEmpty (&Map->Recycled)); +} + + +/** + Test whether the netmap is empty + + @param Map The net map to test + + @return TRUE if the netmap is empty, otherwise FALSE. + +**/ +BOOLEAN +NetMapIsEmpty ( + IN NET_MAP *Map + ) +{ + ASSERT (Map != NULL); + return (BOOLEAN) (Map->Count == 0); +} + + +/** + Return the number of the <Key, Value> pairs in the netmap. + + @param Map The netmap to get the entry number + + @return The entry number in the netmap. + +**/ +UINTN +NetMapGetCount ( + IN NET_MAP *Map + ) +{ + return Map->Count; +} + + +/** + Allocate an item for the netmap. It will try to allocate + a batch of items and return one. + + @param Map The netmap to allocate item for + + @return The allocated item or NULL + +**/ +STATIC +NET_MAP_ITEM * +NetMapAllocItem ( + IN NET_MAP *Map + ) +{ + NET_MAP_ITEM *Item; + NET_LIST_ENTRY *Head; + UINTN Index; + + ASSERT (Map != NULL); + + Head = &Map->Recycled; + + if (NetListIsEmpty (Head)) { + for (Index = 0; Index < NET_MAP_INCREAMENT; Index++) { + Item = NetAllocatePool (sizeof (NET_MAP_ITEM)); + + if (Item == NULL) { + if (Index == 0) { + return NULL; + } + + break; + } + + NetListInsertHead (Head, &Item->Link); + } + } + + Item = NET_LIST_HEAD (Head, NET_MAP_ITEM, Link); + NetListRemoveHead (Head); + + return Item; +} + + +/** + Allocate an item to save the <Key, Value> pair to the head of the netmap. + + @param Map The netmap to insert into + @param Key The user's key + @param Value The user's value for the key + + @retval EFI_OUT_OF_RESOURCES Failed to allocate the memory for the item + @retval EFI_SUCCESS The item is inserted to the head + +**/ +EFI_STATUS +NetMapInsertHead ( + IN NET_MAP *Map, + IN VOID *Key, + IN VOID *Value OPTIONAL + ) +{ + NET_MAP_ITEM *Item; + + ASSERT (Map != NULL); + + Item = NetMapAllocItem (Map); + + if (Item == NULL) { + return EFI_OUT_OF_RESOURCES; + } + + Item->Key = Key; + Item->Value = Value; + NetListInsertHead (&Map->Used, &Item->Link); + + Map->Count++; + return EFI_SUCCESS; +} + + +/** + Allocate an item to save the <Key, Value> pair to the tail of the netmap. + + @param Map The netmap to insert into + @param Key The user's key + @param Value The user's value for the key + + @retval EFI_OUT_OF_RESOURCES Failed to allocate the memory for the item + @retval EFI_SUCCESS The item is inserted to the tail + +**/ +EFI_STATUS +NetMapInsertTail ( + IN NET_MAP *Map, + IN VOID *Key, + IN VOID *Value OPTIONAL + ) +{ + NET_MAP_ITEM *Item; + + ASSERT (Map != NULL); + + Item = NetMapAllocItem (Map); + + if (Item == NULL) { + return EFI_OUT_OF_RESOURCES; + } + + Item->Key = Key; + Item->Value = Value; + NetListInsertTail (&Map->Used, &Item->Link); + + Map->Count++; + + return EFI_SUCCESS; +} + + +/** + Check whther the item is in the Map + + @param Map The netmap to search within + @param Item The item to search + + @return TRUE if the item is in the netmap, otherwise FALSE. + +**/ +STATIC +BOOLEAN +NetItemInMap ( + IN NET_MAP *Map, + IN NET_MAP_ITEM *Item + ) +{ + NET_LIST_ENTRY *ListEntry; + + NET_LIST_FOR_EACH (ListEntry, &Map->Used) { + if (ListEntry == &Item->Link) { + return TRUE; + } + } + + return FALSE; +} + + +/** + Find the key in the netmap + + @param Map The netmap to search within + @param Key The key to search + + @return The point to the item contains the Key, or NULL if Key isn't in the map. + +**/ +NET_MAP_ITEM * +NetMapFindKey ( + IN NET_MAP *Map, + IN VOID *Key + ) +{ + NET_LIST_ENTRY *Entry; + NET_MAP_ITEM *Item; + + ASSERT (Map != NULL); + + NET_LIST_FOR_EACH (Entry, &Map->Used) { + Item = NET_LIST_USER_STRUCT (Entry, NET_MAP_ITEM, Link); + + if (Item->Key == Key) { + return Item; + } + } + + return NULL; +} + + +/** + Remove the item from the netmap + + @param Map The netmap to remove the item from + @param Item The item to remove + @param Value The variable to receive the value if not NULL + + @return The key of the removed item. + +**/ +VOID * +NetMapRemoveItem ( + IN NET_MAP *Map, + IN NET_MAP_ITEM *Item, + OUT VOID **Value OPTIONAL + ) +{ + ASSERT ((Map != NULL) && (Item != NULL)); + ASSERT (NetItemInMap (Map, Item)); + + NetListRemoveEntry (&Item->Link); + Map->Count--; + NetListInsertHead (&Map->Recycled, &Item->Link); + + if (Value != NULL) { + *Value = Item->Value; + } + + return Item->Key; +} + + +/** + Remove the first entry on the netmap + + @param Map The netmap to remove the head from + @param Value The variable to receive the value if not NULL + + @return The key of the item removed + +**/ +VOID * +NetMapRemoveHead ( + IN NET_MAP *Map, + OUT VOID **Value OPTIONAL + ) +{ + NET_MAP_ITEM *Item; + + // + // Often, it indicates a programming error to remove + // the first entry in an empty list + // + ASSERT (Map && !NetListIsEmpty (&Map->Used)); + + Item = NET_LIST_HEAD (&Map->Used, NET_MAP_ITEM, Link); + NetListRemoveEntry (&Item->Link); + Map->Count--; + NetListInsertHead (&Map->Recycled, &Item->Link); + + if (Value != NULL) { + *Value = Item->Value; + } + + return Item->Key; +} + + +/** + Remove the last entry on the netmap + + @param Map The netmap to remove the tail from + @param Value The variable to receive the value if not NULL + + @return The key of the item removed + +**/ +VOID * +NetMapRemoveTail ( + IN NET_MAP *Map, + OUT VOID **Value OPTIONAL + ) +{ + NET_MAP_ITEM *Item; + + // + // Often, it indicates a programming error to remove + // the last entry in an empty list + // + ASSERT (Map && !NetListIsEmpty (&Map->Used)); + + Item = NET_LIST_TAIL (&Map->Used, NET_MAP_ITEM, Link); + NetListRemoveEntry (&Item->Link); + Map->Count--; + NetListInsertHead (&Map->Recycled, &Item->Link); + + if (Value != NULL) { + *Value = Item->Value; + } + + return Item->Key; +} + + +/** + Iterate through the netmap and call CallBack for each item. It will + contiue the traverse if CallBack returns EFI_SUCCESS, otherwise, break + from the loop. It returns the CallBack's last return value. This + function is delete safe for the current item. + + @param Map The Map to iterate through + @param CallBack The callback function to call for each item. + @param Arg The opaque parameter to the callback + + @return It returns the CallBack's last return value. + +**/ +EFI_STATUS +NetMapIterate ( + IN NET_MAP *Map, + IN NET_MAP_CALLBACK CallBack, + IN VOID *Arg + ) +{ + + NET_LIST_ENTRY *Entry; + NET_LIST_ENTRY *Next; + NET_LIST_ENTRY *Head; + NET_MAP_ITEM *Item; + EFI_STATUS Result; + + ASSERT ((Map != NULL) && (CallBack != NULL)); + + Head = &Map->Used; + + if (NetListIsEmpty (Head)) { + return EFI_SUCCESS; + } + + NET_LIST_FOR_EACH_SAFE (Entry, Next, Head) { + Item = NET_LIST_USER_STRUCT (Entry, NET_MAP_ITEM, Link); + Result = CallBack (Map, Item, Arg); + + if (EFI_ERROR (Result)) { + return Result; + } + } + + return EFI_SUCCESS; +} + + +/** + This is the default unload handle for all the network drivers. + + @param ImageHandle The drivers' driver image. + + @retval EFI_SUCCESS The image is unloaded. + @retval Others Failed to unload the image. + +**/ +EFI_STATUS +EFIAPI +NetLibDefaultUnload ( + IN EFI_HANDLE ImageHandle + ) +{ + EFI_STATUS Status; + EFI_HANDLE *DeviceHandleBuffer; + UINTN DeviceHandleCount; + UINTN Index; + EFI_DRIVER_BINDING_PROTOCOL *DriverBinding; +#if (EFI_SPECIFICATION_VERSION >= 0x00020000) + EFI_COMPONENT_NAME2_PROTOCOL *ComponentName; +#else + EFI_COMPONENT_NAME_PROTOCOL *ComponentName; +#endif + EFI_DRIVER_CONFIGURATION_PROTOCOL *DriverConfiguration; + EFI_DRIVER_DIAGNOSTICS_PROTOCOL *DriverDiagnostics; + + // + // Get the list of all the handles in the handle database. + // If there is an error getting the list, then the unload + // operation fails. + // + Status = gBS->LocateHandleBuffer ( + AllHandles, + NULL, + NULL, + &DeviceHandleCount, + &DeviceHandleBuffer + ); + + if (EFI_ERROR (Status)) { + return Status; + } + + // + // Disconnect the driver specified by ImageHandle from all + // the devices in the handle database. + // + for (Index = 0; Index < DeviceHandleCount; Index++) { + Status = gBS->DisconnectController ( + DeviceHandleBuffer[Index], + ImageHandle, + NULL + ); + } + + // + // Uninstall all the protocols installed in the driver entry point + // + for (Index = 0; Index < DeviceHandleCount; Index++) { + Status = gBS->HandleProtocol ( + DeviceHandleBuffer[Index], + &gEfiDriverBindingProtocolGuid, + &DriverBinding + ); + + if (EFI_ERROR (Status)) { + continue; + } + + if (DriverBinding->ImageHandle != ImageHandle) { + continue; + } + + gBS->UninstallProtocolInterface ( + ImageHandle, + &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 + ); + if (!EFI_ERROR (Status)) { + gBS->UninstallProtocolInterface ( + ImageHandle, + &gEfiComponentNameProtocolGuid, + ComponentName + ); + } +#endif + + Status = gBS->HandleProtocol ( + DeviceHandleBuffer[Index], + &gEfiDriverConfigurationProtocolGuid, + &DriverConfiguration + ); + + if (!EFI_ERROR (Status)) { + gBS->UninstallProtocolInterface ( + ImageHandle, + &gEfiDriverConfigurationProtocolGuid, + DriverConfiguration + ); + } + + Status = gBS->HandleProtocol ( + DeviceHandleBuffer[Index], + &gEfiDriverDiagnosticsProtocolGuid, + &DriverDiagnostics + ); + + if (!EFI_ERROR (Status)) { + gBS->UninstallProtocolInterface ( + ImageHandle, + &gEfiDriverDiagnosticsProtocolGuid, + DriverDiagnostics + ); + } + } + + // + // Free the buffer containing the list of handles from the handle database + // + if (DeviceHandleBuffer != NULL) { + gBS->FreePool (DeviceHandleBuffer); + } + + return EFI_SUCCESS; +} + + + +/** + Create a child of the service that is identified by ServiceBindingGuid. + + @param Controller The controller which has the service installed. + @param Image The image handle used to open service. + @param ServiceBindingGuid The service's Guid. + @param ChildHandle The handle to receive the create child + + @retval EFI_SUCCESS The child is successfully created. + @retval Others Failed to create the child. + +**/ +EFI_STATUS +NetLibCreateServiceChild ( + IN EFI_HANDLE Controller, + IN EFI_HANDLE Image, + IN EFI_GUID *ServiceBindingGuid, + OUT EFI_HANDLE *ChildHandle + ) +{ + EFI_STATUS Status; + EFI_SERVICE_BINDING_PROTOCOL *Service; + + + ASSERT ((ServiceBindingGuid != NULL) && (ChildHandle != NULL)); + + // + // Get the ServiceBinding Protocol + // + Status = gBS->OpenProtocol ( + Controller, + ServiceBindingGuid, + (VOID **) &Service, + Image, + Controller, + EFI_OPEN_PROTOCOL_GET_PROTOCOL + ); + + if (EFI_ERROR (Status)) { + return Status; + } + + // + // Create a child + // + Status = Service->CreateChild (Service, ChildHandle); + return Status; +} + + +/** + Destory a child of the service that is identified by ServiceBindingGuid. + + @param Controller The controller which has the service installed. + @param Image The image handle used to open service. + @param ServiceBindingGuid The service's Guid. + @param ChildHandle The child to destory + + @retval EFI_SUCCESS The child is successfully destoried. + @retval Others Failed to destory the child. + +**/ +EFI_STATUS +NetLibDestroyServiceChild ( + IN EFI_HANDLE Controller, + IN EFI_HANDLE Image, + IN EFI_GUID *ServiceBindingGuid, + IN EFI_HANDLE ChildHandle + ) +{ + EFI_STATUS Status; + EFI_SERVICE_BINDING_PROTOCOL *Service; + + ASSERT (ServiceBindingGuid != NULL); + + // + // Get the ServiceBinding Protocol + // + Status = gBS->OpenProtocol ( + Controller, + ServiceBindingGuid, + (VOID **) &Service, + Image, + Controller, + EFI_OPEN_PROTOCOL_GET_PROTOCOL + ); + + if (EFI_ERROR (Status)) { + return Status; + } + + // + // destory the child + // + Status = Service->DestroyChild (Service, ChildHandle); + return Status; +} + + +/** + Convert the mac address of the simple network protocol installed on + SnpHandle to a unicode string. Callers are responsible for freeing the + string storage. + + @param SnpHandle The handle where the simple network protocol is + installed on. + @param ImageHandle The image handle used to act as the agent handle to + get the simple network protocol. + @param MacString The pointer to store the address of the string + representation of the mac address. + + @retval EFI_OUT_OF_RESOURCES There are not enough memory resource. + @retval other Failed to open the simple network protocol. + +**/ +EFI_STATUS +NetLibGetMacString ( + IN EFI_HANDLE SnpHandle, + IN EFI_HANDLE ImageHandle, + IN OUT CONST CHAR16 **MacString + ) +{ + EFI_STATUS Status; + EFI_SIMPLE_NETWORK_PROTOCOL *Snp; + EFI_SIMPLE_NETWORK_MODE *Mode; + CHAR16 *MacAddress; + UINTN Index; + + *MacString = NULL; + + // + // Get the Simple Network protocol from the SnpHandle. + // + Status = gBS->OpenProtocol ( + SnpHandle, + &gEfiSimpleNetworkProtocolGuid, + (VOID **) &Snp, + ImageHandle, + SnpHandle, + EFI_OPEN_PROTOCOL_GET_PROTOCOL + ); + if (EFI_ERROR (Status)) { + return Status; + } + + Mode = Snp->Mode; + + // + // It takes 2 unicode characters to represent a 1 byte binary buffer. + // Plus one unicode character for the null-terminator. + // + MacAddress = NetAllocatePool ((2 * Mode->HwAddressSize + 1) * sizeof (CHAR16)); + if (MacAddress == NULL) { + return EFI_OUT_OF_RESOURCES; + } + + // + // 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 + 1] = NibbleToHexChar (Mode->CurrentAddress.Addr[Index]); + } + + MacAddress[Mode->HwAddressSize * 2] = L'\0'; + + *MacString = MacAddress; + + return EFI_SUCCESS; +} + + +/** + Find the UNDI/SNP handle from controller and protocol GUID. + For example, IP will open a MNP child to transmit/receive + packets, when MNP is stopped, IP should also be stopped. IP + needs to find its own private data which is related the IP's + service binding instance that is install on UNDI/SNP handle. + Now, the controller is either a MNP or ARP child handle. But + IP opens these handle BY_DRIVER, use that info, we can get the + UNDI/SNP handle. + + @param Controller Then protocol handle to check + @param ProtocolGuid The protocol that is related with the handle. + + @return The UNDI/SNP handle or NULL. + +**/ +EFI_HANDLE +NetLibGetNicHandle ( + IN EFI_HANDLE Controller, + IN EFI_GUID *ProtocolGuid + ) +{ + EFI_OPEN_PROTOCOL_INFORMATION_ENTRY *OpenBuffer; + EFI_HANDLE Handle; + EFI_STATUS Status; + UINTN OpenCount; + UINTN Index; + + Status = gBS->OpenProtocolInformation ( + Controller, + ProtocolGuid, + &OpenBuffer, + &OpenCount + ); + + if (EFI_ERROR (Status)) { + return NULL; + } + + Handle = NULL; + + for (Index = 0; Index < OpenCount; Index++) { + if (OpenBuffer[Index].Attributes & EFI_OPEN_PROTOCOL_BY_DRIVER) { + Handle = OpenBuffer[Index].ControllerHandle; + break; + } + } + + gBS->FreePool (OpenBuffer); + return Handle; +} + +EFI_STATUS +NetLibInstallAllDriverProtocols ( + IN EFI_HANDLE ImageHandle, + IN EFI_SYSTEM_TABLE *SystemTable, + IN EFI_DRIVER_BINDING_PROTOCOL *DriverBinding, + IN EFI_HANDLE DriverBindingHandle, + IN EFI_COMPONENT_NAME_PROTOCOL *ComponentName, OPTIONAL + IN EFI_DRIVER_CONFIGURATION_PROTOCOL *DriverConfiguration, OPTIONAL + IN EFI_DRIVER_DIAGNOSTICS_PROTOCOL *DriverDiagnostics OPTIONAL + ) +/*++ + +Routine Description: + + Intialize a driver by installing the Driver Binding Protocol onto the + driver's DriverBindingHandle. This is typically the same as the driver's + ImageHandle, but it can be different if the driver produces multiple + DriverBinding Protocols. This function also initializes the EFI Driver + Library that initializes the global variables gST, gBS, gRT. + +Arguments: + + ImageHandle - The image handle of the driver + SystemTable - The EFI System Table that was passed to the driver's + entry point + DriverBinding - A Driver Binding Protocol instance that this driver + is producing. + DriverBindingHandle - The handle that DriverBinding is to be installe onto. + If this parameter is NULL, then a new handle is created. + ComponentName - A Component Name Protocol instance that this driver is + producing. + DriverConfiguration - A Driver Configuration Protocol instance that this + driver is producing. + DriverDiagnostics - A Driver Diagnostics Protocol instance that this + driver is producing. + +Returns: + + EFI_SUCCESS if all the protocols were installed onto DriverBindingHandle + Otherwise, then return status from gBS->InstallProtocolInterface() + +--*/ +{ + return NetLibInstallAllDriverProtocolsWithUnload ( + ImageHandle, + SystemTable, + DriverBinding, + DriverBindingHandle, + ComponentName, + DriverConfiguration, + DriverDiagnostics, + NetLibDefaultUnload + ); +} + +EFI_STATUS +NetLibInstallAllDriverProtocolsWithUnload ( + IN EFI_HANDLE ImageHandle, + IN EFI_SYSTEM_TABLE *SystemTable, + IN EFI_DRIVER_BINDING_PROTOCOL *DriverBinding, + IN EFI_HANDLE DriverBindingHandle, + IN EFI_COMPONENT_NAME_PROTOCOL *ComponentName, OPTIONAL + IN EFI_DRIVER_CONFIGURATION_PROTOCOL *DriverConfiguration, OPTIONAL + IN EFI_DRIVER_DIAGNOSTICS_PROTOCOL *DriverDiagnostics, OPTIONAL + IN NET_LIB_DRIVER_UNLOAD Unload + ) +/*++ + +Routine Description: + + Intialize a driver by installing the Driver Binding Protocol onto the + driver's DriverBindingHandle. This is typically the same as the driver's + ImageHandle, but it can be different if the driver produces multiple + DriverBinding Protocols. This function also initializes the EFI Driver + Library that initializes the global variables gST, gBS, gRT. + +Arguments: + + ImageHandle - The image handle of the driver + SystemTable - The EFI System Table that was passed to the driver's + entry point + DriverBinding - A Driver Binding Protocol instance that this driver + is producing. + DriverBindingHandle - The handle that DriverBinding is to be installe onto. + If this parameter is NULL, then a new handle is created. + ComponentName - A Component Name Protocol instance that this driver is + producing. + DriverConfiguration - A Driver Configuration Protocol instance that this + driver is producing. + DriverDiagnostics - A Driver Diagnostics Protocol instance that this + driver is producing. + Unload - The customized unload to install. + +Returns: + + EFI_SUCCESS if all the protocols were installed onto DriverBindingHandle + Otherwise, then return status from gBS->InstallProtocolInterface() + +--*/ +{ + EFI_STATUS Status; + EFI_LOADED_IMAGE_PROTOCOL *LoadedImage; + + Status = EfiLibInstallAllDriverProtocols ( + ImageHandle, + SystemTable, + DriverBinding, + DriverBindingHandle, + ComponentName, + DriverConfiguration, + DriverDiagnostics + ); + + if (EFI_ERROR (Status)) { + return Status; + } + + // + // Retrieve the Loaded Image Protocol from Image Handle + // + Status = gBS->OpenProtocol ( + ImageHandle, + &gEfiLoadedImageProtocolGuid, + (VOID **) &LoadedImage, + ImageHandle, + ImageHandle, + EFI_OPEN_PROTOCOL_GET_PROTOCOL + ); + + if (EFI_ERROR (Status)) { + return Status; + } + + // + // Fill in the Unload() service of the Loaded Image Protocol + // + LoadedImage->Unload = (Unload == NULL) ? NetLibDefaultUnload : Unload; + return EFI_SUCCESS; +} + diff --git a/MdeModulePkg/Library/DxeNetLib/DxeNetLib.inf b/MdeModulePkg/Library/DxeNetLib/DxeNetLib.inf new file mode 100644 index 0000000000..be9ff1b379 --- /dev/null +++ b/MdeModulePkg/Library/DxeNetLib/DxeNetLib.inf @@ -0,0 +1,66 @@ +#/** @file
+# Component name for module NetLib
+#
+# FIX ME!
+# Copyright (c) 2006, Intel Corporation. All right reserved.
+#
+# All rights reserved. This program and the accompanying materials
+# are licensed and made available under the terms and conditions of the BSD License
+# which accompanies this distribution. The full text of the license may be found at
+# http://opensource.org/licenses/bsd-license.php
+#
+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+#
+#
+#**/
+
+[Defines]
+ INF_VERSION = 0x00010005
+ BASE_NAME = NetLibDxe
+ FILE_GUID = db6dcef3-9f4e-4340-9351-fc35aa8a5888
+ MODULE_TYPE = DXE_DRIVER
+ VERSION_STRING = 1.0
+ LIBRARY_CLASS = NetLib|DXE_CORE DXE_DRIVER DXE_RUNTIME_DRIVER DXE_SAL_DRIVER DXE_SMM_DRIVER UEFI_APPLICATION UEFI_DRIVER
+ EDK_RELEASE_VERSION = 0x00020000
+ EFI_SPECIFICATION_VERSION = 0x00020000
+
+
+#
+# The following information is for reference only and not required by the build tools.
+#
+# VALID_ARCHITECTURES = IA32 X64 IPF EBC
+#
+
+[Sources.common]
+ DxeNetLib.c
+ NetBuffer.c
+
+[Packages]
+ MdePkg/MdePkg.dec
+ MdeModulePkg/MdeModulePkg.dec
+
+
+[LibraryClasses]
+ MemoryAllocationLib
+ UefiLib
+ BaseLib
+ UefiBootServicesTableLib
+ UefiRuntimeServicesTableLib
+ BaseMemoryLib
+ DebugLib
+ PrintLib
+
+
+[Protocols]
+ gEfiIp4ProtocolGuid # PROTOCOL ALWAYS_CONSUMED
+ gEfiDriverDiagnosticsProtocolGuid # PROTOCOL ALWAYS_CONSUMED
+ gEfiUdp4ServiceBindingProtocolGuid # PROTOCOL ALWAYS_CONSUMED
+ gEfiLoadedImageProtocolGuid # PROTOCOL ALWAYS_CONSUMED
+ gEfiIp4ServiceBindingProtocolGuid # PROTOCOL ALWAYS_CONSUMED
+ gEfiDriverConfigurationProtocolGuid # PROTOCOL ALWAYS_CONSUMED
+ gEfiSimpleNetworkProtocolGuid # PROTOCOL ALWAYS_CONSUMED
+ gEfiDriverBindingProtocolGuid # PROTOCOL ALWAYS_CONSUMED
+ gEfiUdp4ProtocolGuid # PROTOCOL ALWAYS_CONSUMED
+ gEfiComponentNameProtocolGuid # PROTOCOL ALWAYS_CONSUMED
+
diff --git a/MdeModulePkg/Library/DxeNetLib/Netbuffer.c b/MdeModulePkg/Library/DxeNetLib/Netbuffer.c new file mode 100644 index 0000000000..f32e31efbe --- /dev/null +++ b/MdeModulePkg/Library/DxeNetLib/Netbuffer.c @@ -0,0 +1,1759 @@ +/** @file
+
+Copyright (c) 2005 - 2006, Intel Corporation
+All rights reserved. This program and the accompanying materials
+are licensed and made available under the terms and conditions of the BSD License
+which accompanies this distribution. The full text of the license may be found at
+http://opensource.org/licenses/bsd-license.php
+
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+Module Name:
+
+ NetBuffer.c
+
+Abstract:
+
+
+
+**/
+
+#include <PiDxe.h> + +#include <Library/NetLib.h> +#include <Library/BaseLib.h> +#include <Library/DebugLib.h> +#include <Library/BaseMemoryLib.h> +#include <Library/UefiBootServicesTableLib.h> +#include <Library/MemoryAllocationLib.h>
+
+
+/**
+ Allocate and build up the sketch for a NET_BUF. The net buffer allocated
+ has the BlockOpNum's NET_BLOCK_OP, and its associated NET_VECTOR has the
+ BlockNum's NET_BLOCK.
+
+ @param BlockNum The number of NET_BLOCK in the Vector of net buffer
+ @param BlockOpNum The number of NET_BLOCK_OP in the net buffer
+
+ @retval * Pointer to the allocated NET_BUF. If NULL the
+ allocation failed due to resource limit.
+
+**/
+STATIC
+NET_BUF *
+NetbufAllocStruct (
+ IN UINT32 BlockNum,
+ IN UINT32 BlockOpNum
+ )
+{
+ NET_BUF *Nbuf;
+ NET_VECTOR *Vector;
+
+ ASSERT (BlockOpNum >= 1);
+
+ //
+ // Allocate three memory blocks.
+ //
+ Nbuf = NetAllocateZeroPool (NET_BUF_SIZE (BlockOpNum));
+
+ if (Nbuf == NULL) {
+ return NULL;
+ }
+
+ Nbuf->Signature = NET_BUF_SIGNATURE;
+ Nbuf->RefCnt = 1;
+ Nbuf->BlockOpNum = BlockOpNum;
+ NetListInit (&Nbuf->List);
+
+ if (BlockNum != 0) {
+ Vector = NetAllocateZeroPool (NET_VECTOR_SIZE (BlockNum));
+
+ if (Vector == NULL) {
+ goto FreeNbuf;
+ }
+
+ Vector->Signature = NET_VECTOR_SIGNATURE;
+ Vector->RefCnt = 1;
+ Vector->BlockNum = BlockNum;
+ Nbuf->Vector = Vector;
+ }
+
+ return Nbuf;
+
+FreeNbuf:
+
+ NetFreePool (Nbuf);
+ return NULL;
+}
+
+
+/**
+ Allocate a single block NET_BUF. Upon allocation, all the
+ free space is in the tail room.
+
+ @param Len The length of the block.
+
+ @retval * Pointer to the allocated NET_BUF. If NULL the
+ allocation failed due to resource limit.
+
+**/
+NET_BUF *
+NetbufAlloc (
+ IN UINT32 Len
+ )
+{
+ NET_BUF *Nbuf;
+ NET_VECTOR *Vector;
+ UINT8 *Bulk;
+
+ ASSERT (Len > 0);
+
+ Nbuf = NetbufAllocStruct (1, 1);
+
+ if (Nbuf == NULL) {
+ return NULL;
+ }
+
+ Bulk = NetAllocatePool (Len);
+
+ if (Bulk == NULL) {
+ goto FreeNBuf;
+ }
+
+ Vector = Nbuf->Vector;
+ Vector->Len = Len;
+
+ Vector->Block[0].Bulk = Bulk;
+ Vector->Block[0].Len = Len;
+
+ Nbuf->BlockOp[0].BlockHead = Bulk;
+ Nbuf->BlockOp[0].BlockTail = Bulk + Len;
+
+ Nbuf->BlockOp[0].Head = Bulk;
+ Nbuf->BlockOp[0].Tail = Bulk;
+ Nbuf->BlockOp[0].Size = 0;
+
+ return Nbuf;
+
+FreeNBuf:
+ NetFreePool (Nbuf);
+ return NULL;
+}
+
+
+/**
+ Free the vector
+
+ @param Vector Pointer to the NET_VECTOR to be freed.
+
+ @return None.
+
+**/
+STATIC
+VOID
+NetbufFreeVector (
+ IN NET_VECTOR *Vector
+ )
+{
+ UINT32 Index;
+
+ NET_CHECK_SIGNATURE (Vector, NET_VECTOR_SIGNATURE);
+ ASSERT (Vector->RefCnt > 0);
+
+ Vector->RefCnt--;
+
+ if (Vector->RefCnt > 0) {
+ return;
+ }
+
+ if (Vector->Free != NULL) {
+ //
+ // Call external free function to free the vector if it
+ // isn't NULL. If NET_VECTOR_OWN_FIRST is set, release the
+ // first block since it is allocated by us
+ //
+ if (Vector->Flag & NET_VECTOR_OWN_FIRST) {
+ NetFreePool (Vector->Block[0].Bulk);
+ }
+
+ Vector->Free (Vector->Arg);
+
+ } else {
+ //
+ // Free each memory block associated with the Vector
+ //
+ for (Index = 0; Index < Vector->BlockNum; Index++) {
+ NetFreePool (Vector->Block[Index].Bulk);
+ }
+ }
+
+ NetFreePool (Vector);
+}
+
+
+/**
+ Free the buffer and its associated NET_VECTOR.
+
+ @param Nbuf Pointer to the NET_BUF to be freed.
+
+ @return None.
+
+**/
+VOID
+NetbufFree (
+ IN NET_BUF *Nbuf
+ )
+{
+ NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);
+ ASSERT (Nbuf->RefCnt > 0);
+
+ Nbuf->RefCnt--;
+
+ if (Nbuf->RefCnt == 0) {
+ //
+ // Update Vector only when NBuf is to be released. That is,
+ // all the sharing of Nbuf increse Vector's RefCnt by one
+ //
+ NetbufFreeVector (Nbuf->Vector);
+ NetFreePool (Nbuf);
+ }
+}
+
+
+/**
+ Create a copy of NET_BUF that share the associated NET_DATA.
+
+ @param Nbuf Pointer to the net buffer to be cloned.
+
+ @retval * Pointer to the cloned net buffer.
+
+**/
+NET_BUF *
+NetbufClone (
+ IN NET_BUF *Nbuf
+ )
+{
+ NET_BUF *Clone;
+
+ NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);
+
+ Clone = NetAllocatePool (NET_BUF_SIZE (Nbuf->BlockOpNum));
+
+ if (Clone == NULL) {
+ return NULL;
+ }
+
+ Clone->Signature = NET_BUF_SIGNATURE;
+ Clone->RefCnt = 1;
+ NetListInit (&Clone->List);
+
+ Clone->Ip = Nbuf->Ip;
+ Clone->Tcp = Nbuf->Tcp;
+
+ NetCopyMem (Clone->ProtoData, Nbuf->ProtoData, NET_PROTO_DATA);
+
+ NET_GET_REF (Nbuf->Vector);
+
+ Clone->Vector = Nbuf->Vector;
+ Clone->BlockOpNum = Nbuf->BlockOpNum;
+ Clone->TotalSize = Nbuf->TotalSize;
+ NetCopyMem (Clone->BlockOp, Nbuf->BlockOp, sizeof (NET_BLOCK_OP) * Nbuf->BlockOpNum);
+
+ return Clone;
+}
+
+
+/**
+ Create a duplicated copy of Nbuf, data is copied. Also leave some
+ head space before the data.
+
+ @param Nbuf Pointer to the net buffer to be cloned.
+ @param Duplicate Pointer to the net buffer to duplicate to, if NULL
+ a new net buffer is allocated.
+ @param HeadSpace Length of the head space to reserve
+
+ @retval * Pointer to the duplicated net buffer.
+
+**/
+NET_BUF *
+NetbufDuplicate (
+ IN NET_BUF *Nbuf,
+ IN NET_BUF *Duplicate OPTIONAL,
+ IN UINT32 HeadSpace
+ )
+{
+ UINT8 *Dst;
+
+ NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);
+
+ if (Duplicate == NULL) {
+ Duplicate = NetbufAlloc (Nbuf->TotalSize + HeadSpace);
+ }
+
+ if (Duplicate == NULL) {
+ return NULL;
+ }
+
+ //
+ // Don't set the IP and TCP head point, since it is most
+ // like that they are pointing to the memory of Nbuf.
+ //
+ NetCopyMem (Duplicate->ProtoData, Nbuf->ProtoData, NET_PROTO_DATA);
+ NetbufReserve (Duplicate, HeadSpace);
+
+ Dst = NetbufAllocSpace (Duplicate, Nbuf->TotalSize, NET_BUF_TAIL);
+ NetbufCopy (Nbuf, 0, Nbuf->TotalSize, Dst);
+
+ return Duplicate;
+}
+
+
+/**
+ Free a list of net buffers.
+
+ @param Head Pointer to the head of linked net buffers.
+
+ @return None.
+
+**/
+VOID
+NetbufFreeList (
+ IN NET_LIST_ENTRY *Head
+ )
+{
+ NET_LIST_ENTRY *Entry;
+ NET_LIST_ENTRY *Next;
+ NET_BUF *Nbuf;
+
+ Entry = Head->ForwardLink;
+
+ NET_LIST_FOR_EACH_SAFE (Entry, Next, Head) {
+ Nbuf = NET_LIST_USER_STRUCT (Entry, NET_BUF, List);
+ NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);
+
+ NetListRemoveEntry (Entry);
+ NetbufFree (Nbuf);
+ }
+
+ ASSERT (NetListIsEmpty (Head));
+}
+
+
+/**
+ Get the position of some byte in the net buffer. This can be used
+ to, for example, retrieve the IP header in the packet. It also
+ returns the fragment that contains the byte which is used mainly by
+ the buffer implementation itself.
+
+ @param Nbuf Pointer to the net buffer.
+ @param Offset The index or offset of the byte
+ @param Index Index of the fragment that contains the block
+
+ @retval * Pointer to the nth byte of data in the net buffer.
+ If NULL, there is no such data in the net buffer.
+
+**/
+UINT8 *
+NetbufGetByte (
+ IN NET_BUF *Nbuf,
+ IN UINT32 Offset,
+ OUT UINT32 *Index OPTIONAL
+ )
+{
+ NET_BLOCK_OP *BlockOp;
+ UINT32 Loop;
+ UINT32 Len;
+
+ NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);
+
+ if (Offset >= Nbuf->TotalSize) {
+ return NULL;
+ }
+
+ BlockOp = Nbuf->BlockOp;
+ Len = 0;
+
+ for (Loop = 0; Loop < Nbuf->BlockOpNum; Loop++) {
+
+ if (Len + BlockOp[Loop].Size <= Offset) {
+ Len += BlockOp[Loop].Size;
+ continue;
+ }
+
+ if (Index != NULL) {
+ *Index = Loop;
+ }
+
+ return BlockOp[Loop].Head + (Offset - Len);
+ }
+
+ return NULL;
+}
+
+
+
+/**
+ Set the NET_BLOCK and corresponding NET_BLOCK_OP in
+ the buffer. All the pointers in NET_BLOCK and NET_BLOCK_OP
+ are set to the bulk's head and tail respectively. So, this
+ function alone can't be used by NetbufAlloc.
+
+ @param Nbuf Pointer to the net buffer.
+ @param Bulk Pointer to the data.
+ @param Len Length of the bulk data.
+ @param Index The data block index in the net buffer the bulk
+ data should belong to.
+
+ @return None.
+
+**/
+STATIC
+VOID
+NetbufSetBlock (
+ IN NET_BUF *Nbuf,
+ IN UINT8 *Bulk,
+ IN UINT32 Len,
+ IN UINT32 Index
+ )
+{
+ NET_BLOCK_OP *BlockOp;
+ NET_BLOCK *Block;
+
+ NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);
+ NET_CHECK_SIGNATURE (Nbuf->Vector, NET_VECTOR_SIGNATURE);
+ ASSERT (Index < Nbuf->BlockOpNum);
+
+ Block = &(Nbuf->Vector->Block[Index]);
+ BlockOp = &(Nbuf->BlockOp[Index]);
+ Block->Len = Len;
+ Block->Bulk = Bulk;
+ BlockOp->BlockHead = Bulk;
+ BlockOp->BlockTail = Bulk + Len;
+ BlockOp->Head = Bulk;
+ BlockOp->Tail = Bulk + Len;
+ BlockOp->Size = Len;
+}
+
+
+
+/**
+ Set the NET_BLOCK_OP in the buffer. The corresponding NET_BLOCK
+ structure is left untouched. Some times, there is no 1:1 relationship
+ between NET_BLOCK and NET_BLOCK_OP. For example, that in NetbufGetFragment.
+
+ @param Nbuf Pointer to the net buffer.
+ @param Bulk Pointer to the data.
+ @param Len Length of the bulk data.
+ @param Index The data block index in the net buffer the bulk
+ data should belong to.
+
+ @return None.
+
+**/
+STATIC
+VOID
+NetbufSetBlockOp (
+ IN NET_BUF *Nbuf,
+ IN UINT8 *Bulk,
+ IN UINT32 Len,
+ IN UINT32 Index
+ )
+{
+ NET_BLOCK_OP *BlockOp;
+
+ NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);
+ ASSERT (Index < Nbuf->BlockOpNum);
+
+ BlockOp = &(Nbuf->BlockOp[Index]);
+ BlockOp->BlockHead = Bulk;
+ BlockOp->BlockTail = Bulk + Len;
+ BlockOp->Head = Bulk;
+ BlockOp->Tail = Bulk + Len;
+ BlockOp->Size = Len;
+}
+
+
+/**
+ Helper function for NetbufClone. It is necessary because NetbufGetFragment
+ may allocate the first block to accomodate the HeadSpace and HeadLen. So, it
+ need to create a new NET_VECTOR. But, we want to avoid data copy by sharing
+ the old NET_VECTOR.
+
+ @param Arg Point to the old NET_VECTOR
+
+ @return NONE
+
+**/
+STATIC
+VOID
+NetbufGetFragmentFree (
+ IN VOID *Arg
+ )
+{
+ NET_VECTOR *Vector;
+
+ Vector = (NET_VECTOR *)Arg;
+ NetbufFreeVector (Vector);
+}
+
+
+
+/**
+ Create a NET_BUF structure which contains Len byte data of
+ Nbuf starting from Offset. A new NET_BUF structure will be
+ created but the associated data in NET_VECTOR is shared.
+ This function exists to do IP packet fragmentation.
+
+ @param Nbuf Pointer to the net buffer to be cloned.
+ @param Offset Starting point of the data to be included in new
+ buffer.
+ @param Len How many data to include in new data
+ @param HeadSpace How many bytes of head space to reserve for
+ protocol header
+
+ @retval * Pointer to the cloned net buffer.
+
+**/
+NET_BUF *
+NetbufGetFragment (
+ IN NET_BUF *Nbuf,
+ IN UINT32 Offset,
+ IN UINT32 Len,
+ IN UINT32 HeadSpace
+ )
+{
+ NET_BUF *Child;
+ NET_VECTOR *Vector;
+ NET_BLOCK_OP *BlockOp;
+ UINT32 CurBlockOp;
+ UINT32 BlockOpNum;
+ UINT8 *FirstBulk;
+ UINT32 Index;
+ UINT32 First;
+ UINT32 Last;
+ UINT32 FirstSkip;
+ UINT32 FirstLen;
+ UINT32 LastLen;
+ UINT32 Cur;
+
+ NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);
+
+ if ((Len == 0) || (Offset + Len > Nbuf->TotalSize)) {
+ return NULL;
+ }
+
+ //
+ // First find the first and last BlockOp that contains
+ // the valid data, and compute the offset of the first
+ // BlockOp and length of the last BlockOp
+ //
+ BlockOp = Nbuf->BlockOp;
+ Cur = 0;
+
+ for (Index = 0; Index < Nbuf->BlockOpNum; Index++) {
+ if (Offset < Cur + BlockOp[Index].Size) {
+ break;
+ }
+
+ Cur += BlockOp[Index].Size;
+ }
+
+ //
+ // First is the index of the first BlockOp, FirstSkip is
+ // the offset of the first byte in the first BlockOp.
+ //
+ First = Index;
+ FirstSkip = Offset - Cur;
+ FirstLen = BlockOp[Index].Size - FirstSkip;
+
+ //
+ //redundant assignment to make compiler happy.
+ //
+ Last = 0;
+ LastLen = 0;
+
+ if (Len > FirstLen) {
+ Cur += BlockOp[Index].Size;
+ Index++;
+
+ for (; Index < Nbuf->BlockOpNum; Index++) {
+ if (Offset + Len <= Cur + BlockOp[Index].Size) {
+ Last = Index;
+ LastLen = Offset + Len - Cur;
+ break;
+ }
+
+ Cur += BlockOp[Index].Size;
+ }
+
+ } else {
+ Last = First;
+ LastLen = Len;
+ FirstLen = Len;
+ }
+
+ BlockOpNum = Last - First + 1;
+ CurBlockOp = 0;
+
+ if (HeadSpace != 0) {
+ //
+ // Allocate an extra block to accomdate the head space.
+ //
+ BlockOpNum++;
+
+ Child = NetbufAllocStruct (1, BlockOpNum);
+
+ if (Child == NULL) {
+ return NULL;
+ }
+
+ FirstBulk = NetAllocatePool (HeadSpace);
+
+ if (FirstBulk == NULL) {
+ goto FreeChild;
+ }
+
+ Vector = Child->Vector;
+ Vector->Free = NetbufGetFragmentFree;
+ Vector->Arg = Nbuf->Vector;
+ Vector->Flag = NET_VECTOR_OWN_FIRST;
+ Vector->Len = HeadSpace;
+
+ //
+ //Reserve the head space in the first block
+ //
+ NetbufSetBlock (Child, FirstBulk, HeadSpace, 0);
+ Child->BlockOp[0].Head += HeadSpace;
+ Child->BlockOp[0].Size = 0;
+ CurBlockOp++;
+
+ }else {
+ Child = NetbufAllocStruct (0, BlockOpNum);
+
+ if (Child == NULL) {
+ return NULL;
+ }
+
+ Child->Vector = Nbuf->Vector;
+ }
+
+ NET_GET_REF (Nbuf->Vector);
+ Child->TotalSize = Len;
+
+ //
+ // Set all the BlockOp up, the first and last one are special
+ // and need special process.
+ //
+ NetbufSetBlockOp (
+ Child,
+ Nbuf->BlockOp[First].Head + FirstSkip,
+ FirstLen,
+ CurBlockOp++
+ );
+
+ for (Index = First + 1; Index <= Last - 1 ; Index++) {
+ NetbufSetBlockOp (
+ Child,
+ BlockOp[Index].Head,
+ BlockOp[Index].Size,
+ CurBlockOp++
+ );
+ }
+
+ if (First != Last) {
+ NetbufSetBlockOp (
+ Child,
+ BlockOp[Last].Head,
+ LastLen,
+ CurBlockOp
+ );
+ }
+
+ NetCopyMem (Child->ProtoData, Nbuf->ProtoData, NET_PROTO_DATA);
+ return Child;
+
+FreeChild:
+
+ NetFreePool (Child);
+ return NULL;
+}
+
+
+
+/**
+ Build a NET_BUF from external blocks.
+
+ @param ExtFragment Pointer to the data block.
+ @param ExtNum The number of the data block.
+ @param HeadSpace The head space to be reserved.
+ @param HeadLen The length of the protocol header, This function
+ will pull that number of data into a linear block.
+ @param ExtFree Pointer to the caller provided free function.
+ @param Arg The argument passed to ExtFree when ExtFree is
+ called.
+
+ @retval * Pointer to the net buffer built from the data
+ blocks.
+
+**/
+NET_BUF *
+NetbufFromExt (
+ IN NET_FRAGMENT *ExtFragment,
+ IN UINT32 ExtNum,
+ IN UINT32 HeadSpace,
+ IN UINT32 HeadLen,
+ IN NET_VECTOR_EXT_FREE ExtFree,
+ IN VOID *Arg OPTIONAL
+ )
+{
+ NET_BUF *Nbuf;
+ NET_VECTOR *Vector;
+ NET_FRAGMENT SavedFragment;
+ UINT32 SavedIndex;
+ UINT32 TotalLen;
+ UINT32 BlockNum;
+ UINT8 *FirstBlock;
+ UINT32 FirstBlockLen;
+ UINT8 *Header;
+ UINT32 CurBlock;
+ UINT32 Index;
+ UINT32 Len;
+ UINT32 Copied;
+
+ ASSERT ((ExtFragment != NULL) && (ExtNum > 0) && (ExtFree != NULL));
+
+ SavedFragment.Bulk = NULL;
+ SavedFragment.Len = 0;
+
+ FirstBlockLen = 0;
+ FirstBlock = NULL;
+ BlockNum = ExtNum;
+ Index = 0;
+ TotalLen = 0;
+ SavedIndex = 0;
+ Len = 0;
+ Copied = 0;
+
+ //
+ // No need to consolidate the header if the first block is
+ // longer than the header length or there is only one block.
+ //
+ if ((ExtFragment[0].Len >= HeadLen) || (ExtNum == 1)) {
+ HeadLen = 0;
+ }
+
+ //
+ // Allocate an extra block if we need to:
+ // 1. Allocate some header space
+ // 2. aggreate the packet header
+ //
+ if ((HeadSpace != 0) || (HeadLen != 0)) {
+ FirstBlockLen = HeadLen + HeadSpace;
+ FirstBlock = NetAllocatePool (FirstBlockLen);
+
+ if (FirstBlock == NULL) {
+ return NULL;
+ }
+
+ BlockNum++;
+ }
+
+ //
+ // Copy the header to the first block, reduce the NET_BLOCK
+ // to allocate by one for each block that is completely covered
+ // by the first bulk.
+ //
+ if (HeadLen != 0) {
+ Len = HeadLen;
+ Header = FirstBlock + HeadSpace;
+
+ for (Index = 0; Index < ExtNum; Index++) {
+ if (Len >= ExtFragment[Index].Len) {
+ NetCopyMem (Header, ExtFragment[Index].Bulk, ExtFragment[Index].Len);
+
+ Copied += ExtFragment[Index].Len;
+ Len -= ExtFragment[Index].Len;
+ Header += ExtFragment[Index].Len;
+ TotalLen += ExtFragment[Index].Len;
+ BlockNum--;
+
+ if (Len == 0) {
+ //
+ // Increament the index number to point to the next
+ // non-empty fragment.
+ //
+ Index++;
+ break;
+ }
+
+ } else {
+ NetCopyMem (Header, ExtFragment[Index].Bulk, Len);
+
+ Copied += Len;
+ TotalLen += Len;
+
+ //
+ // Adjust the block structure to exclude the data copied,
+ // So, the left-over block can be processed as other blocks.
+ // But it must be recovered later. (SavedIndex > 0) always
+ // holds since we don't aggreate the header if the first block
+ // is bigger enough that the header is continuous
+ //
+ SavedIndex = Index;
+ SavedFragment = ExtFragment[Index];
+ ExtFragment[Index].Bulk += Len;
+ ExtFragment[Index].Len -= Len;
+ break;
+ }
+ }
+ }
+
+ Nbuf = NetbufAllocStruct (BlockNum, BlockNum);
+
+ if (Nbuf == NULL) {
+ goto FreeFirstBlock;
+ }
+
+ Vector = Nbuf->Vector;
+ Vector->Free = ExtFree;
+ Vector->Arg = Arg;
+ Vector->Flag = (FirstBlockLen ? NET_VECTOR_OWN_FIRST : 0);
+
+ //
+ // Set the first block up which may contain
+ // some head space and aggregated header
+ //
+ CurBlock = 0;
+
+ if (FirstBlockLen != 0) {
+ NetbufSetBlock (Nbuf, FirstBlock, HeadSpace + Copied, 0);
+ Nbuf->BlockOp[0].Head += HeadSpace;
+ Nbuf->BlockOp[0].Size = Copied;
+
+ CurBlock++;
+ }
+
+ for (; Index < ExtNum; Index++) {
+ NetbufSetBlock (Nbuf, ExtFragment[Index].Bulk, ExtFragment[Index].Len, CurBlock);
+ TotalLen += ExtFragment[Index].Len;
+ CurBlock++;
+ }
+
+ Vector->Len = TotalLen + HeadSpace;
+ Nbuf->TotalSize = TotalLen;
+
+ if (SavedIndex) {
+ ExtFragment[SavedIndex] = SavedFragment;
+ }
+
+ return Nbuf;
+
+FreeFirstBlock:
+ NetFreePool (FirstBlock);
+ return NULL;
+}
+
+
+/**
+ Build a fragment table to contain the fragments in the
+ buffer. This is the opposite of the NetbufFromExt.
+
+ @param Nbuf Point to the net buffer
+ @param ExtFragment Pointer to the data block.
+ @param ExtNum The number of the data block.
+
+ @retval EFI_BUFFER_TOO_SMALL The number of non-empty block is bigger than ExtNum
+ @retval EFI_SUCCESS Fragment table built.
+
+**/
+EFI_STATUS
+NetbufBuildExt (
+ IN NET_BUF *Nbuf,
+ IN NET_FRAGMENT *ExtFragment,
+ IN UINT32 *ExtNum
+ )
+{
+ UINT32 Index;
+ UINT32 Current;
+
+ Current = 0;
+
+ for (Index = 0; (Index < Nbuf->BlockOpNum); Index++) {
+ if (Nbuf->BlockOp[Index].Size == 0) {
+ continue;
+ }
+
+ if (Current < *ExtNum) {
+ ExtFragment[Current].Bulk = Nbuf->BlockOp[Index].Head;
+ ExtFragment[Current].Len = Nbuf->BlockOp[Index].Size;
+ Current++;
+ } else {
+ return EFI_BUFFER_TOO_SMALL;
+ }
+ }
+
+ *ExtNum = Current;
+ return EFI_SUCCESS;
+}
+
+
+/**
+ Build a NET_BUF from a list of NET_BUF.
+
+ @param BufList A List of NET_BUF.
+ @param HeadSpace The head space to be reserved.
+ @param HeaderLen The length of the protocol header, This function
+ will pull that number of data into a linear block.
+ @param ExtFree Pointer to the caller provided free function.
+ @param Arg The argument passed to ExtFree when ExtFree is
+ called.
+
+ @retval * Pointer to the net buffer built from the data
+ blocks.
+
+**/
+NET_BUF *
+NetbufFromBufList (
+ IN NET_LIST_ENTRY *BufList,
+ IN UINT32 HeadSpace,
+ IN UINT32 HeaderLen,
+ IN NET_VECTOR_EXT_FREE ExtFree,
+ IN VOID *Arg OPTIONAL
+ )
+{
+ NET_FRAGMENT *Fragment;
+ UINT32 FragmentNum;
+ NET_LIST_ENTRY *Entry;
+ NET_BUF *Nbuf;
+ UINT32 Index;
+ UINT32 Current;
+
+ //
+ //Compute how many blocks are there
+ //
+ FragmentNum = 0;
+
+ NET_LIST_FOR_EACH (Entry, BufList) {
+ Nbuf = NET_LIST_USER_STRUCT (Entry, NET_BUF, List);
+ NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);
+ FragmentNum += Nbuf->BlockOpNum;
+ }
+
+ //
+ //Allocate and copy block points
+ //
+ Fragment = NetAllocatePool (sizeof (NET_FRAGMENT) * FragmentNum);
+
+ if (Fragment == NULL) {
+ return NULL;
+ }
+
+ Current = 0;
+
+ NET_LIST_FOR_EACH (Entry, BufList) {
+ Nbuf = NET_LIST_USER_STRUCT (Entry, NET_BUF, List);
+ NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);
+
+ for (Index = 0; Index < Nbuf->BlockOpNum; Index++) {
+ if (Nbuf->BlockOp[Index].Size) {
+ Fragment[Current].Bulk = Nbuf->BlockOp[Index].Head;
+ Fragment[Current].Len = Nbuf->BlockOp[Index].Size;
+ Current++;
+ }
+ }
+ }
+
+ Nbuf = NetbufFromExt (Fragment, Current, HeadSpace, HeaderLen, ExtFree, Arg);
+ NetFreePool (Fragment);
+
+ return Nbuf;
+}
+
+
+/**
+ Reserve some space in the header room of the buffer.
+ Upon allocation, all the space are in the tail room
+ of the buffer. Call this function to move some space
+ to the header room. This function is quite limited in
+ that it can only reserver space from the first block
+ of an empty NET_BUF not built from the external. But
+ it should be enough for the network stack.
+
+ @param Nbuf Pointer to the net buffer.
+ @param Len The length of buffer to be reserverd.
+
+ @return None.
+
+**/
+VOID
+NetbufReserve (
+ IN NET_BUF *Nbuf,
+ IN UINT32 Len
+ )
+{
+ NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);
+ NET_CHECK_SIGNATURE (Nbuf->Vector, NET_VECTOR_SIGNATURE);
+
+ ASSERT ((Nbuf->BlockOpNum == 1) && (Nbuf->TotalSize == 0));
+ ASSERT ((Nbuf->Vector->Free == NULL) && (Nbuf->Vector->Len >= Len));
+
+ Nbuf->BlockOp[0].Head += Len;
+ Nbuf->BlockOp[0].Tail += Len;
+
+ ASSERT (Nbuf->BlockOp[0].Tail <= Nbuf->BlockOp[0].BlockTail);
+}
+
+
+/**
+ Allocate some space from the header or tail of the buffer.
+
+ @param Nbuf Pointer to the net buffer.
+ @param Len The length of the buffer to be allocated.
+ @param FromHead The flag to indicate whether reserve the data from
+ head or tail. TRUE for from head, and FALSE for
+ from tail.
+
+ @retval * Pointer to the first byte of the allocated buffer.
+
+**/
+UINT8 *
+NetbufAllocSpace (
+ IN NET_BUF *Nbuf,
+ IN UINT32 Len,
+ IN BOOLEAN FromHead
+ )
+{
+ NET_BLOCK_OP *BlockOp;
+ UINT32 Index;
+ UINT8 *SavedTail;
+
+ NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);
+ NET_CHECK_SIGNATURE (Nbuf->Vector, NET_VECTOR_SIGNATURE);
+
+ ASSERT (Len > 0);
+
+ if (FromHead) {
+ //
+ // Allocate some space from head. If the buffer is empty,
+ // allocate from the first block. If it isn't, allocate
+ // from the first non-empty block, or the block before that.
+ //
+ if (Nbuf->TotalSize == 0) {
+ Index = 0;
+ } else {
+ NetbufGetByte (Nbuf, 0, &Index);
+
+ if ((NET_HEADSPACE(&(Nbuf->BlockOp[Index])) < Len) && (Index > 0)) {
+ Index--;
+ }
+ }
+
+ BlockOp = &(Nbuf->BlockOp[Index]);
+
+ if (NET_HEADSPACE (BlockOp) < Len) {
+ return NULL;
+ }
+
+ BlockOp->Head -= Len;
+ BlockOp->Size += Len;
+ Nbuf->TotalSize += Len;
+
+ return BlockOp->Head;
+
+ } else {
+ //
+ // Allocate some space from the tail. If the buffer is empty,
+ // allocate from the first block. If it isn't, allocate
+ // from the last non-empty block, or the block after that.
+ //
+ if (Nbuf->TotalSize == 0) {
+ Index = 0;
+ } else {
+ NetbufGetByte (Nbuf, Nbuf->TotalSize - 1, &Index);
+
+ if ((NET_TAILSPACE(&(Nbuf->BlockOp[Index])) < Len) &&
+ (Index < Nbuf->BlockOpNum - 1)) {
+
+ Index++;
+ }
+ }
+
+ BlockOp = &(Nbuf->BlockOp[Index]);
+
+ if (NET_TAILSPACE (BlockOp) < Len) {
+ return NULL;
+ }
+
+ SavedTail = BlockOp->Tail;
+
+ BlockOp->Tail += Len;
+ BlockOp->Size += Len;
+ Nbuf->TotalSize += Len;
+
+ return SavedTail;
+ }
+}
+
+
+/**
+ Trim a single NET_BLOCK.
+
+ @param BlockOp Pointer to the NET_BLOCK.
+ @param Len The length of the data to be trimmed.
+ @param FromHead The flag to indicate whether trim data from head or
+ tail. TRUE for from head, and FALSE for from tail.
+
+ @return None.
+
+**/
+STATIC
+VOID
+NetblockTrim (
+ IN NET_BLOCK_OP *BlockOp,
+ IN UINT32 Len,
+ IN BOOLEAN FromHead
+ )
+{
+ ASSERT (BlockOp && (BlockOp->Size >= Len));
+
+ BlockOp->Size -= Len;
+
+ if (FromHead) {
+ BlockOp->Head += Len;
+ } else {
+ BlockOp->Tail -= Len;
+ }
+}
+
+
+/**
+ Trim some data from the header or tail of the buffer.
+
+ @param Nbuf Pointer to the net buffer.
+ @param Len The length of the data to be trimmed.
+ @param FromHead The flag to indicate whether trim data from head or
+ tail. TRUE for from head, and FALSE for from tail.
+
+ @retval UINTN Length of the actually trimmed data.
+
+**/
+UINT32
+NetbufTrim (
+ IN NET_BUF *Nbuf,
+ IN UINT32 Len,
+ IN BOOLEAN FromHead
+ )
+{
+ NET_BLOCK_OP *BlockOp;
+ UINT32 Index;
+ UINT32 Trimmed;
+
+ NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);
+
+ if (Len > Nbuf->TotalSize) {
+ Len = Nbuf->TotalSize;
+ }
+
+ //
+ // If FromTail is true, iterate backward. That
+ // is, init Index to NBuf->BlockNum - 1, and
+ // decrease it by 1 during each loop. Otherwise,
+ // iterate forward. That is, init Index to 0, and
+ // increase it by 1 during each loop.
+ //
+ Trimmed = 0;
+ Nbuf->TotalSize -= Len;
+
+ Index = (FromHead ? 0 : Nbuf->BlockOpNum - 1);
+ BlockOp = Nbuf->BlockOp;
+
+ for (;;) {
+ if (BlockOp[Index].Size == 0) {
+ Index += (FromHead ? 1 : -1);
+ continue;
+ }
+
+ if (Len > BlockOp[Index].Size) {
+ Len -= BlockOp[Index].Size;
+ Trimmed += BlockOp[Index].Size;
+ NetblockTrim (&BlockOp[Index], BlockOp[Index].Size, FromHead);
+ } else {
+ Trimmed += Len;
+ NetblockTrim (&BlockOp[Index], Len, FromHead);
+ break;
+ }
+
+ Index += (FromHead ? 1 : -1);
+ }
+
+ return Trimmed;
+}
+
+
+/**
+ Copy the data from the specific offset to the destination.
+
+ @param Nbuf Pointer to the net buffer.
+ @param Offset The sequence number of the first byte to copy.
+ @param Len Length of the data to copy.
+ @param Dest The destination of the data to copy to.
+
+ @retval UINTN The length of the copied data.
+
+**/
+UINT32
+NetbufCopy (
+ IN NET_BUF *Nbuf,
+ IN UINT32 Offset,
+ IN UINT32 Len,
+ IN UINT8 *Dest
+ )
+{
+ NET_BLOCK_OP *BlockOp;
+ UINT32 Skip;
+ UINT32 Left;
+ UINT32 Copied;
+ UINT32 Index;
+ UINT32 Cur;
+
+ NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);
+ ASSERT (Dest);
+
+ if ((Len == 0) || (Nbuf->TotalSize <= Offset)) {
+ return 0;
+ }
+
+ if (Nbuf->TotalSize - Offset < Len) {
+ Len = Nbuf->TotalSize - Offset;
+ }
+
+ BlockOp = Nbuf->BlockOp;
+
+ //
+ // Skip to the offset. Don't make "Offset-By-One" error here.
+ // Cur + BLOCK.SIZE is the first sequence number of next block.
+ // So, (Offset < Cur + BLOCK.SIZE) means that the first byte
+ // is in the current block. if (Offset == Cur + BLOCK.SIZE), the
+ // first byte is the next block's first byte.
+ //
+ Cur = 0;
+
+ for (Index = 0; Index < Nbuf->BlockOpNum; Index++) {
+ if (BlockOp[Index].Size == 0) {
+ continue;
+ }
+
+ if (Offset < Cur + BlockOp[Index].Size) {
+ break;
+ }
+
+ Cur += BlockOp[Index].Size;
+ }
+
+ //
+ // Cur is the sequence number of the first byte in the block
+ // Offset - Cur is the number of bytes before first byte to
+ // to copy in the current block.
+ //
+ Skip = Offset - Cur;
+ Left = BlockOp[Index].Size - Skip;
+
+ if (Len <= Left) {
+ NetCopyMem (Dest, BlockOp[Index].Head + Skip, Len);
+ return Len;
+ }
+
+ NetCopyMem (Dest, BlockOp[Index].Head + Skip, Left);
+
+ Dest += Left;
+ Len -= Left;
+ Copied = Left;
+
+ Index++;
+
+ for (; Index < Nbuf->BlockOpNum; Index++) {
+ if (Len > BlockOp[Index].Size) {
+ Len -= BlockOp[Index].Size;
+ Copied += BlockOp[Index].Size;
+
+ NetCopyMem (Dest, BlockOp[Index].Head, BlockOp[Index].Size);
+ Dest += BlockOp[Index].Size;
+ } else {
+ Copied += Len;
+ NetCopyMem (Dest, BlockOp[Index].Head, Len);
+ break;
+ }
+ }
+
+ return Copied;
+}
+
+
+/**
+ Initiate the net buffer queue.
+
+ @param NbufQue Pointer to the net buffer queue to be initiated.
+
+ @return None.
+
+**/
+VOID
+NetbufQueInit (
+ IN NET_BUF_QUEUE *NbufQue
+ )
+{
+ NbufQue->Signature = NET_QUE_SIGNATURE;
+ NbufQue->RefCnt = 1;
+ NetListInit (&NbufQue->List);
+
+ NetListInit (&NbufQue->BufList);
+ NbufQue->BufSize = 0;
+ NbufQue->BufNum = 0;
+}
+
+
+/**
+ Allocate an initialized net buffer queue.
+
+ None.
+
+ @retval * Pointer to the allocated net buffer queue.
+
+**/
+NET_BUF_QUEUE *
+NetbufQueAlloc (
+ VOID
+ )
+{
+ NET_BUF_QUEUE *NbufQue;
+
+ NbufQue = NetAllocatePool (sizeof (NET_BUF_QUEUE));
+ if (NbufQue == NULL) {
+ return NULL;
+ }
+
+ NetbufQueInit (NbufQue);
+
+ return NbufQue;
+}
+
+
+/**
+ Free a net buffer queue.
+
+ @param NbufQue Poitner to the net buffer queue to be freed.
+
+ @return None.
+
+**/
+VOID
+NetbufQueFree (
+ IN NET_BUF_QUEUE *NbufQue
+ )
+{
+ NET_CHECK_SIGNATURE (NbufQue, NET_QUE_SIGNATURE);
+
+ NbufQue->RefCnt--;
+
+ if (NbufQue->RefCnt == 0) {
+ NetbufQueFlush (NbufQue);
+ NetFreePool (NbufQue);
+ }
+}
+
+
+/**
+ Append a buffer to the end of the queue.
+
+ @param NbufQue Pointer to the net buffer queue.
+ @param Nbuf Pointer to the net buffer to be appended.
+
+ @return None.
+
+**/
+VOID
+NetbufQueAppend (
+ IN NET_BUF_QUEUE *NbufQue,
+ IN NET_BUF *Nbuf
+ )
+{
+ NET_CHECK_SIGNATURE (NbufQue, NET_QUE_SIGNATURE);
+ NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);
+
+ NetListInsertTail (&NbufQue->BufList, &Nbuf->List);
+
+ NbufQue->BufSize += Nbuf->TotalSize;
+ NbufQue->BufNum++;
+}
+
+
+/**
+ Remove a net buffer from head in the specific queue.
+
+ @param NbufQue Pointer to the net buffer queue.
+
+ @retval * Pointer to the net buffer removed from the specific
+ queue.
+
+**/
+NET_BUF *
+NetbufQueRemove (
+ IN NET_BUF_QUEUE *NbufQue
+ )
+{
+ NET_BUF *First;
+
+ NET_CHECK_SIGNATURE (NbufQue, NET_QUE_SIGNATURE);
+
+ if (NbufQue->BufNum == 0) {
+ return NULL;
+ }
+
+ First = NET_LIST_USER_STRUCT (NbufQue->BufList.ForwardLink, NET_BUF, List);
+
+ NetListRemoveHead (&NbufQue->BufList);
+
+ NbufQue->BufSize -= First->TotalSize;
+ NbufQue->BufNum--;
+ return First;
+}
+
+
+/**
+ Copy some data from the buffer queue to the destination.
+
+ @param NbufQue Pointer to the net buffer queue.
+ @param Offset The sequence number of the first byte to copy.
+ @param Len Length of the data to copy.
+ @param Dest The destination of the data to copy to.
+
+ @retval UINTN The length of the copied data.
+
+**/
+UINT32
+NetbufQueCopy (
+ IN NET_BUF_QUEUE *NbufQue,
+ IN UINT32 Offset,
+ IN UINT32 Len,
+ IN UINT8 *Dest
+ )
+{
+ NET_LIST_ENTRY *Entry;
+ NET_BUF *Nbuf;
+ UINT32 Skip;
+ UINT32 Left;
+ UINT32 Cur;
+ UINT32 Copied;
+
+ NET_CHECK_SIGNATURE (NbufQue, NET_QUE_SIGNATURE);
+ ASSERT (Dest != NULL);
+
+ if ((Len == 0) || (NbufQue->BufSize <= Offset)) {
+ return 0;
+ }
+
+ if (NbufQue->BufSize - Offset < Len) {
+ Len = NbufQue->BufSize - Offset;
+ }
+
+ //
+ // skip to the Offset
+ //
+ Cur = 0;
+ Nbuf = NULL;
+
+ NET_LIST_FOR_EACH (Entry, &NbufQue->BufList) {
+ Nbuf = NET_LIST_USER_STRUCT (Entry, NET_BUF, List);
+
+ if (Offset < Cur + Nbuf->TotalSize) {
+ break;
+ }
+
+ Cur += Nbuf->TotalSize;
+ }
+
+ //
+ // Copy the data in the first buffer.
+ //
+ Skip = Offset - Cur;
+ Left = Nbuf->TotalSize - Skip;
+
+ if (Len < Left) {
+ return NetbufCopy (Nbuf, Skip, Len, Dest);
+ }
+
+ NetbufCopy (Nbuf, Skip, Left, Dest);
+ Dest += Left;
+ Len -= Left;
+ Copied = Left;
+
+ //
+ // Iterate over the others
+ //
+ Entry = Entry->ForwardLink;
+
+ while ((Len > 0) && (Entry != &NbufQue->BufList)) {
+ Nbuf = NET_LIST_USER_STRUCT (Entry, NET_BUF, List);
+
+ if (Len > Nbuf->TotalSize) {
+ Len -= Nbuf->TotalSize;
+ Copied += Nbuf->TotalSize;
+
+ NetbufCopy (Nbuf, 0, Nbuf->TotalSize, Dest);
+ Dest += Nbuf->TotalSize;
+
+ } else {
+ NetbufCopy (Nbuf, 0, Len, Dest);
+ Copied += Len;
+ break;
+ }
+
+ Entry = Entry->ForwardLink;
+ }
+
+ return Copied;
+}
+
+
+/**
+ Trim some data from the queue header, release the buffer if
+ whole buffer is trimmed.
+
+ @param NbufQue Pointer to the net buffer queue.
+ @param Len Length of the data to trim.
+
+ @retval UINTN The length of the data trimmed.
+
+**/
+UINT32
+NetbufQueTrim (
+ IN NET_BUF_QUEUE *NbufQue,
+ IN UINT32 Len
+ )
+{
+ NET_LIST_ENTRY *Entry;
+ NET_LIST_ENTRY *Next;
+ NET_BUF *Nbuf;
+ UINT32 Trimmed;
+
+ NET_CHECK_SIGNATURE (NbufQue, NET_QUE_SIGNATURE);
+
+ if (Len == 0) {
+ return 0;
+ }
+
+ if (Len > NbufQue->BufSize) {
+ Len = NbufQue->BufSize;
+ }
+
+ NbufQue->BufSize -= Len;
+ Trimmed = 0;
+
+ NET_LIST_FOR_EACH_SAFE (Entry, Next, &NbufQue->BufList) {
+ Nbuf = NET_LIST_USER_STRUCT (Entry, NET_BUF, List);
+
+ if (Len >= Nbuf->TotalSize) {
+ Trimmed += Nbuf->TotalSize;
+ Len -= Nbuf->TotalSize;
+
+ NetListRemoveEntry (Entry);
+ NetbufFree (Nbuf);
+
+ NbufQue->BufNum--;
+
+ if (Len == 0) {
+ break;
+ }
+
+ } else {
+ Trimmed += NetbufTrim (Nbuf, Len, NET_BUF_HEAD);
+ break;
+ }
+ }
+
+ return Trimmed;
+}
+
+
+/**
+ Flush the net buffer queue.
+
+ @param NbufQue Pointer to the queue to be flushed.
+
+ @return None.
+
+**/
+VOID
+NetbufQueFlush (
+ IN NET_BUF_QUEUE *NbufQue
+ )
+{
+ NET_CHECK_SIGNATURE (NbufQue, NET_QUE_SIGNATURE);
+
+ NetbufFreeList (&NbufQue->BufList);
+
+ NbufQue->BufNum = 0;
+ NbufQue->BufSize = 0;
+}
+
+
+/**
+ Compute checksum for a bulk of data.
+
+ @param Bulk Pointer to the data.
+ @param Len Length of the data, in bytes.
+
+ @retval UINT16 The computed checksum.
+
+**/
+UINT16
+NetblockChecksum (
+ IN UINT8 *Bulk,
+ IN UINT32 Len
+ )
+{
+ register UINT32 Sum;
+
+ Sum = 0;
+
+ while (Len > 1) {
+ Sum += *(UINT16 *) Bulk;
+ Bulk += 2;
+ Len -= 2;
+ }
+
+ //
+ // Add left-over byte, if any
+ //
+ if (Len > 0) {
+ Sum += *(UINT8 *) Bulk;
+ }
+
+ //
+ // Fold 32-bit sum to 16 bits
+ //
+ while (Sum >> 16) {
+ Sum = (Sum & 0xffff) + (Sum >> 16);
+
+ }
+
+ return (UINT16) Sum;
+}
+
+
+/**
+ Add two checksums.
+
+ @param Checksum1 The first checksum to be added.
+ @param Checksum2 The second checksum to be added.
+
+ @retval UINT16 The new checksum.
+
+**/
+UINT16
+NetAddChecksum (
+ IN UINT16 Checksum1,
+ IN UINT16 Checksum2
+ )
+{
+ UINT32 Sum;
+
+ Sum = Checksum1 + Checksum2;
+
+ //
+ // two UINT16 can only add up to a carry of 1.
+ //
+ if (Sum >> 16) {
+ Sum = (Sum & 0xffff) + 1;
+
+ }
+
+ return (UINT16) Sum;
+}
+
+
+/**
+ Compute the checksum for a NET_BUF.
+
+ @param Nbuf Pointer to the net buffer.
+
+ @retval UINT16 The computed checksum.
+
+**/
+UINT16
+NetbufChecksum (
+ IN NET_BUF *Nbuf
+ )
+{
+ NET_BLOCK_OP *BlockOp;
+ UINT32 Offset;
+ UINT16 TotalSum;
+ UINT16 BlockSum;
+ UINT32 Index;
+
+ NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);
+
+ TotalSum = 0;
+ Offset = 0;
+ BlockOp = Nbuf->BlockOp;
+
+ for (Index = 0; Index < Nbuf->BlockOpNum; Index++) {
+ if (BlockOp[Index].Size == 0) {
+ continue;
+ }
+
+ BlockSum = NetblockChecksum (BlockOp[Index].Head, BlockOp[Index].Size);
+
+ if (Offset & 0x01) {
+ //
+ // The checksum starts with an odd byte, swap
+ // the checksum before added to total checksum
+ //
+ BlockSum = NET_SWAP_SHORT (BlockSum);
+ }
+
+ TotalSum = NetAddChecksum (BlockSum, TotalSum);
+ Offset += BlockOp[Index].Size;
+ }
+
+ return TotalSum;
+}
+
+
+/**
+ Compute the checksum for TCP/UDP pseudo header.
+ Src, Dst are in network byte order. and Len is
+ in host byte order.
+
+ @param Src The source address of the packet.
+ @param Dst The destination address of the packet.
+ @param Proto The protocol type of the packet.
+ @param Len The length of the packet.
+
+ @retval UINT16 The computed checksum.
+
+**/
+UINT16
+NetPseudoHeadChecksum (
+ IN IP4_ADDR Src,
+ IN IP4_ADDR Dst,
+ IN UINT8 Proto,
+ IN UINT16 Len
+ )
+{
+ NET_PSEUDO_HDR Hdr;
+
+ //
+ // Zero the memory to relieve align problems
+ //
+ NetZeroMem (&Hdr, sizeof (Hdr));
+
+ Hdr.SrcIp = Src;
+ Hdr.DstIp = Dst;
+ Hdr.Protocol = Proto;
+ Hdr.Len = HTONS (Len);
+
+ return NetblockChecksum ((UINT8 *) &Hdr, sizeof (Hdr));
+}
diff --git a/MdeModulePkg/Library/DxeUdpIoLib/DxeUdpIoLib.c b/MdeModulePkg/Library/DxeUdpIoLib/DxeUdpIoLib.c new file mode 100644 index 0000000000..84bc295bb1 --- /dev/null +++ b/MdeModulePkg/Library/DxeUdpIoLib/DxeUdpIoLib.c @@ -0,0 +1,727 @@ +/** @file
+
+Copyright (c) 2006 - 2007, Intel Corporation
+All rights reserved. This program and the accompanying materials
+are licensed and made available under the terms and conditions of the BSD License
+which accompanies this distribution. The full text of the license may be found at
+http://opensource.org/licenses/bsd-license.php
+
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+
+Module Name:
+
+ Udp4Io.c
+
+Abstract:
+
+ Help functions to access UDP service, it is used by both the DHCP and MTFTP.
+
+
+**/
+
+#include <PiDxe.h>
+
+#include <Protocol/Udp4.h>
+
+#include <Library/UdpIoLib.h>
+#include <Library/BaseLib.h>
+#include <Library/DebugLib.h>
+#include <Library/UefiBootServicesTableLib.h>
+#include <Library/MemoryAllocationLib.h>
+
+STATIC
+VOID
+EFIAPI
+UdpIoOnDgramSent (
+ IN EFI_EVENT Event,
+ IN VOID *Context
+ );
+
+STATIC
+VOID
+EFIAPI
+UdpIoOnDgramRcvd (
+ IN EFI_EVENT Event,
+ IN VOID *Context
+ );
+
+
+/**
+ Wrap a transmit request into a UDP_TX_TOKEN.
+
+ @param UdpIo The UdpIo port to send packet to
+ @param Packet The user's packet
+ @param EndPoint The local and remote access point
+ @param Gateway The overrided next hop
+ @param CallBack The function to call when transmission completed.
+ @param Context The opaque parameter to the call back
+
+ @return The wrapped transmission request or NULL if failed to allocate resources.
+
+**/
+STATIC
+UDP_TX_TOKEN *
+UdpIoWrapTx (
+ IN UDP_IO_PORT *UdpIo,
+ IN NET_BUF *Packet,
+ IN UDP_POINTS *EndPoint, OPTIONAL
+ IN IP4_ADDR Gateway,
+ IN UDP_IO_CALLBACK CallBack,
+ IN VOID *Context
+ )
+{
+ UDP_TX_TOKEN *Token;
+ EFI_UDP4_COMPLETION_TOKEN *UdpToken;
+ EFI_UDP4_TRANSMIT_DATA *UdpTxData;
+ EFI_STATUS Status;
+ UINT32 Count;
+
+ Token = NetAllocatePool (sizeof (UDP_TX_TOKEN) +
+ sizeof (EFI_UDP4_FRAGMENT_DATA) * (Packet->BlockOpNum - 1));
+
+ if (Token == NULL) {
+ return NULL;
+ }
+
+ Token->Signature = UDP_IO_TX_SIGNATURE;
+ NetListInit (&Token->Link);
+
+ Token->UdpIo = UdpIo;
+ Token->CallBack = CallBack;
+ Token->Packet = Packet;
+ Token->Context = Context;
+
+ UdpToken = &(Token->UdpToken);
+ UdpToken->Status = EFI_NOT_READY;
+
+ Status = gBS->CreateEvent (
+ EVT_NOTIFY_SIGNAL,
+ TPL_CALLBACK,
+ UdpIoOnDgramSent,
+ Token,
+ &UdpToken->Event
+ );
+
+ if (EFI_ERROR (Status)) {
+ NetFreePool (Token);
+ return NULL;
+ }
+
+ UdpTxData = &Token->UdpTxData;
+ UdpToken->Packet.TxData = UdpTxData;
+
+ UdpTxData->UdpSessionData = NULL;
+ UdpTxData->GatewayAddress = NULL;
+
+ if (EndPoint != NULL) {
+ EFI_IP4 (Token->UdpSession.SourceAddress) = HTONL (EndPoint->LocalAddr);
+ EFI_IP4 (Token->UdpSession.DestinationAddress) = HTONL (EndPoint->RemoteAddr);
+ Token->UdpSession.SourcePort = EndPoint->LocalPort;
+ Token->UdpSession.DestinationPort = EndPoint->RemotePort;
+ UdpTxData->UdpSessionData = &Token->UdpSession;
+ }
+
+ if (Gateway != 0) {
+ EFI_IP4 (Token->Gateway) = HTONL (Gateway);
+ UdpTxData->GatewayAddress = &Token->Gateway;
+ }
+
+ UdpTxData->DataLength = Packet->TotalSize;
+ Count = Packet->BlockOpNum;
+ NetbufBuildExt (Packet, (NET_FRAGMENT *) UdpTxData->FragmentTable, &Count);
+ UdpTxData->FragmentCount = Count;
+
+ return Token;
+}
+
+
+/**
+ Free a UDP_TX_TOKEN. The event is closed and memory released.
+
+ @param Token The UDP_TX_TOKEN to release.
+
+ @return None
+
+**/
+VOID
+UdpIoFreeTxToken (
+ IN UDP_TX_TOKEN *Token
+ )
+{
+ gBS->CloseEvent (Token->UdpToken.Event);
+ NetFreePool (Token);
+}
+
+
+/**
+ Create a UDP_RX_TOKEN to wrap the request.
+
+ @param UdpIo The UdpIo to receive packets from
+ @param CallBack The function to call when receive finished.
+ @param Context The opaque parameter to the CallBack
+ @param HeadLen The head length to reserver for the packet.
+
+ @return The Wrapped request or NULL if failed to allocate resources.
+
+**/
+UDP_RX_TOKEN *
+UdpIoCreateRxToken (
+ IN UDP_IO_PORT *UdpIo,
+ IN UDP_IO_CALLBACK CallBack,
+ IN VOID *Context,
+ IN UINT32 HeadLen
+ )
+{
+ UDP_RX_TOKEN *Token;
+ EFI_STATUS Status;
+
+ Token = NetAllocatePool (sizeof (UDP_RX_TOKEN));
+
+ if (Token == NULL) {
+ return NULL;
+ }
+
+ Token->Signature = UDP_IO_RX_SIGNATURE;
+ Token->UdpIo = UdpIo;
+ Token->CallBack = CallBack;
+ Token->Context = Context;
+ Token->HeadLen = HeadLen;
+
+ Token->UdpToken.Status = EFI_NOT_READY;
+ Token->UdpToken.Packet.RxData = NULL;
+
+ Status = gBS->CreateEvent (
+ EVT_NOTIFY_SIGNAL,
+ TPL_CALLBACK,
+ UdpIoOnDgramRcvd,
+ Token,
+ &Token->UdpToken.Event
+ );
+
+ if (EFI_ERROR (Status)) {
+ NetFreePool (Token);
+ return NULL;
+ }
+
+ return Token;
+}
+
+
+/**
+ Free a receive request wrap.
+
+ @param Token The receive request to release.
+
+ @return None
+
+**/
+VOID
+UdpIoFreeRxToken (
+ IN UDP_RX_TOKEN *Token
+ )
+{
+ gBS->CloseEvent (Token->UdpToken.Event);
+ NetFreePool (Token);
+}
+
+
+/**
+ Create a UDP IO port to access the UDP service. It will
+ create and configure a UDP child.
+
+ @param Controller The controller that has the UDP service binding
+ protocol installed.
+ @param Image The image handle for the driver.
+ @param Configure The function to configure the created UDP child
+ @param Context The opaque parameter for the Configure funtion.
+
+ @return A point to just created UDP IO port or NULL if failed.
+
+**/
+UDP_IO_PORT *
+UdpIoCreatePort (
+ IN EFI_HANDLE Controller,
+ IN EFI_HANDLE Image,
+ IN UDP_IO_CONFIG Configure,
+ IN VOID *Context
+ )
+{
+ UDP_IO_PORT *UdpIo;
+ EFI_STATUS Status;
+
+ ASSERT (Configure != NULL);
+
+ UdpIo = NetAllocatePool (sizeof (UDP_IO_PORT));
+
+ if (UdpIo == NULL) {
+ return NULL;
+ }
+
+ UdpIo->Signature = UDP_IO_SIGNATURE;
+ NetListInit (&UdpIo->Link);
+ UdpIo->RefCnt = 1;
+
+ UdpIo->Controller = Controller;
+ UdpIo->Image = Image;
+
+ NetListInit (&UdpIo->SentDatagram);
+ UdpIo->RecvRequest = NULL;
+ UdpIo->UdpHandle = NULL;
+
+ //
+ // Create a UDP child then open and configure it
+ //
+ Status = NetLibCreateServiceChild (
+ Controller,
+ Image,
+ &gEfiUdp4ServiceBindingProtocolGuid,
+ &UdpIo->UdpHandle
+ );
+
+ if (EFI_ERROR (Status)) {
+ goto FREE_MEM;
+ }
+
+ Status = gBS->OpenProtocol (
+ UdpIo->UdpHandle,
+ &gEfiUdp4ProtocolGuid,
+ &UdpIo->Udp,
+ Image,
+ Controller,
+ EFI_OPEN_PROTOCOL_BY_DRIVER
+ );
+
+ if (EFI_ERROR (Status)) {
+ goto FREE_CHILD;
+ }
+
+ if (EFI_ERROR (Configure (UdpIo, Context))) {
+ goto CLOSE_PROTOCOL;
+ }
+
+ Status = UdpIo->Udp->GetModeData (UdpIo->Udp, NULL, NULL, NULL, &UdpIo->SnpMode);
+
+ if (EFI_ERROR (Status)) {
+ goto CLOSE_PROTOCOL;
+ }
+
+ return UdpIo;
+
+CLOSE_PROTOCOL:
+ gBS->CloseProtocol (UdpIo->UdpHandle, &gEfiUdp4ProtocolGuid, Image, Controller);
+
+FREE_CHILD:
+ NetLibDestroyServiceChild (
+ Controller,
+ Image,
+ &gEfiUdp4ServiceBindingProtocolGuid,
+ UdpIo->UdpHandle
+ );
+
+FREE_MEM:
+ NetFreePool (UdpIo);
+ return NULL;
+}
+
+
+/**
+ Cancel all the sent datagram that pass the selection of ToCancel.
+ If ToCancel is NULL, all the datagrams are cancelled.
+
+ @param UdpIo The UDP IO port to cancel packet
+ @param IoStatus The IoStatus to return to the packet owners.
+ @param ToCancel The select funtion to test whether to cancel this
+ packet or not.
+ @param Context The opaque parameter to the ToCancel.
+
+ @return None
+
+**/
+STATIC
+VOID
+UdpIoCancelDgrams (
+ IN UDP_IO_PORT *UdpIo,
+ IN EFI_STATUS IoStatus,
+ IN UDP_IO_TO_CANCEL ToCancel, OPTIONAL
+ IN VOID *Context
+ )
+{
+ NET_LIST_ENTRY *Entry;
+ NET_LIST_ENTRY *Next;
+ UDP_TX_TOKEN *Token;
+
+ NET_LIST_FOR_EACH_SAFE (Entry, Next, &UdpIo->SentDatagram) {
+ Token = NET_LIST_USER_STRUCT (Entry, UDP_TX_TOKEN, Link);
+
+ if ((ToCancel == NULL) || (ToCancel (Token, Context))) {
+ NetListRemoveEntry (Entry);
+ UdpIo->Udp->Cancel (UdpIo->Udp, &Token->UdpToken);
+ Token->CallBack (Token->Packet, NULL, IoStatus, Token->Context);
+ UdpIoFreeTxToken (Token);
+ }
+ }
+}
+
+
+/**
+ Free the UDP IO port and all its related resources including
+ all the transmitted packet.
+
+ @param UdpIo The UDP IO port to free.
+
+ @retval EFI_SUCCESS The UDP IO port is freed.
+
+**/
+EFI_STATUS
+UdpIoFreePort (
+ IN UDP_IO_PORT *UdpIo
+ )
+{
+ UDP_RX_TOKEN *RxToken;
+
+ //
+ // Cancel all the sent datagram and receive requests. The
+ // callbacks of transmit requests are executed to allow the
+ // caller to release the resource. The callback of receive
+ // request are NOT executed. This is because it is most
+ // likely that the current user of the UDP IO port is closing
+ // itself.
+ //
+ UdpIoCancelDgrams (UdpIo, EFI_ABORTED, NULL, NULL);
+
+ if ((RxToken = UdpIo->RecvRequest) != NULL) {
+ UdpIo->RecvRequest = NULL;
+ UdpIo->Udp->Cancel (UdpIo->Udp, &RxToken->UdpToken);
+ UdpIoFreeRxToken (RxToken);
+ }
+
+ //
+ // Close then destory the UDP child
+ //
+ gBS->CloseProtocol (
+ UdpIo->UdpHandle,
+ &gEfiUdp4ProtocolGuid,
+ UdpIo->Image,
+ UdpIo->Controller
+ );
+
+ NetLibDestroyServiceChild (
+ UdpIo->Controller,
+ UdpIo->Image,
+ &gEfiUdp4ServiceBindingProtocolGuid,
+ UdpIo->UdpHandle
+ );
+
+ NetListRemoveEntry (&UdpIo->Link);
+ NetFreePool (UdpIo);
+ return EFI_SUCCESS;
+}
+
+
+/**
+ Clean up the UDP IO port. It will release all the transmitted
+ datagrams and receive request. It will also configure NULL the
+ UDP child.
+
+ @param UdpIo UDP IO port to clean up.
+
+ @return None
+
+**/
+VOID
+UdpIoCleanPort (
+ IN UDP_IO_PORT *UdpIo
+ )
+{
+ UDP_RX_TOKEN *RxToken;
+
+ //
+ // Cancel all the sent datagram and receive requests.
+ //
+ UdpIoCancelDgrams (UdpIo, EFI_ABORTED, NULL, NULL);
+
+ if ((RxToken = UdpIo->RecvRequest) != NULL) {
+ UdpIo->RecvRequest = NULL;
+ UdpIo->Udp->Cancel (UdpIo->Udp, &RxToken->UdpToken);
+ UdpIoFreeRxToken (RxToken);
+ }
+
+ UdpIo->Udp->Configure (UdpIo->Udp, NULL);
+}
+
+
+/**
+ The callback function when the packet is sent by UDP.
+ It will remove the packet from the local list then call
+ the packet owner's callback function.
+
+ @param Event The event signalled.
+ @param Context The UDP TX Token.
+
+ @return None
+
+**/
+STATIC
+VOID
+EFIAPI
+UdpIoOnDgramSent (
+ IN EFI_EVENT Event,
+ IN VOID *Context
+ )
+{
+ UDP_TX_TOKEN *Token;
+
+ Token = (UDP_TX_TOKEN *) Context;
+ ASSERT (Token->Signature == UDP_IO_TX_SIGNATURE);
+
+ NetListRemoveEntry (&Token->Link);
+ Token->CallBack (Token->Packet, NULL, Token->UdpToken.Status, Token->Context);
+
+ UdpIoFreeTxToken (Token);
+}
+
+
+/**
+ Send a packet through the UDP IO port.
+
+ @param UdpIo The UDP IO Port to send the packet through
+ @param Packet The packet to send
+ @param EndPoint The local and remote access point
+ @param Gateway The gateway to use
+ @param CallBack The call back function to call when packet is
+ transmitted or failed.
+ @param Context The opque parameter to the CallBack
+
+ @retval EFI_OUT_OF_RESOURCES Failed to allocate resource for the packet
+ @retval EFI_SUCCESS The packet is successfully delivered to UDP for
+ transmission.
+
+**/
+EFI_STATUS
+UdpIoSendDatagram (
+ IN UDP_IO_PORT *UdpIo,
+ IN NET_BUF *Packet,
+ IN UDP_POINTS *EndPoint, OPTIONAL
+ IN IP4_ADDR Gateway,
+ IN UDP_IO_CALLBACK CallBack,
+ IN VOID *Context
+ )
+{
+ UDP_TX_TOKEN *Token;
+ EFI_STATUS Status;
+
+ Token = UdpIoWrapTx (UdpIo, Packet, EndPoint, Gateway, CallBack, Context);
+
+ if (Token == NULL) {
+ return EFI_OUT_OF_RESOURCES;
+ }
+
+ Status = UdpIo->Udp->Transmit (UdpIo->Udp, &Token->UdpToken);
+
+ if (EFI_ERROR (Status)) {
+ UdpIoFreeTxToken (Token);
+ return Status;
+ }
+
+ NetListInsertHead (&UdpIo->SentDatagram, &Token->Link);
+ return EFI_SUCCESS;
+}
+
+
+/**
+ The selection function to cancel a single sent datagram.
+
+ @param Token The UDP TX token to test againist.
+ @param Context The context
+
+ @return TRUE if the packet is to be cancelled, otherwise FALSE.
+
+**/
+STATIC
+BOOLEAN
+UdpIoCancelSingleDgram (
+ IN UDP_TX_TOKEN *Token,
+ IN VOID *Context
+ )
+{
+ NET_BUF *Packet;
+
+ Packet = (NET_BUF *) Context;
+
+ if (Token->Packet == Packet) {
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+
+/**
+ Cancel a single sent datagram.
+
+ @param UdpIo The UDP IO port to cancel the packet from
+ @param Packet The packet to cancel
+
+ @return None
+
+**/
+VOID
+UdpIoCancelSentDatagram (
+ IN UDP_IO_PORT *UdpIo,
+ IN NET_BUF *Packet
+ )
+{
+ UdpIoCancelDgrams (UdpIo, EFI_ABORTED, UdpIoCancelSingleDgram, Packet);
+}
+
+
+/**
+ Recycle the received UDP data.
+
+ @param Context The UDP_RX_TOKEN
+
+ @return None
+
+**/
+STATIC
+VOID
+UdpIoRecycleDgram (
+ IN VOID *Context
+ )
+{
+ UDP_RX_TOKEN *Token;
+
+ Token = (UDP_RX_TOKEN *) Context;
+ gBS->SignalEvent (Token->UdpToken.Packet.RxData->RecycleSignal);
+ UdpIoFreeRxToken (Token);
+}
+
+
+/**
+ The event handle for UDP receive request. It will build
+ a NET_BUF from the recieved UDP data, then deliver it
+ to the receiver.
+
+ @param Event The UDP receive request event
+ @param Context The UDP RX token.
+
+ @return None
+
+**/
+STATIC
+VOID
+EFIAPI
+UdpIoOnDgramRcvd (
+ IN EFI_EVENT Event,
+ IN VOID *Context
+ )
+{
+ EFI_UDP4_COMPLETION_TOKEN *UdpToken;
+ EFI_UDP4_RECEIVE_DATA *UdpRxData;
+ EFI_UDP4_SESSION_DATA *UdpSession;
+ UDP_RX_TOKEN *Token;
+ UDP_POINTS Points;
+ NET_BUF *Netbuf;
+
+ Token = (UDP_RX_TOKEN *) Context;
+
+ ASSERT ((Token->Signature == UDP_IO_RX_SIGNATURE) &&
+ (Token == Token->UdpIo->RecvRequest));
+
+ //
+ // Clear the receive request first in case that the caller
+ // wants to restart the receive in the callback.
+ //
+ Token->UdpIo->RecvRequest = NULL;
+
+ UdpToken = &Token->UdpToken;
+ UdpRxData = UdpToken->Packet.RxData;
+
+ if (EFI_ERROR (UdpToken->Status) || (UdpRxData == NULL)) {
+ Token->CallBack (NULL, NULL, UdpToken->Status, Token->Context);
+ UdpIoFreeRxToken (Token);
+
+ goto ON_EXIT;
+ }
+
+ //
+ // Build a NET_BUF from the UDP receive data, then deliver it up.
+ //
+ Netbuf = NetbufFromExt (
+ (NET_FRAGMENT *) UdpRxData->FragmentTable,
+ UdpRxData->FragmentCount,
+ 0,
+ (UINT32) Token->HeadLen,
+ UdpIoRecycleDgram,
+ Token
+ );
+
+ if (Netbuf == NULL) {
+ gBS->SignalEvent (UdpRxData->RecycleSignal);
+ Token->CallBack (NULL, NULL, EFI_OUT_OF_RESOURCES, Token->Context);
+
+ UdpIoFreeRxToken (Token);
+ goto ON_EXIT;
+ }
+
+ UdpSession = &UdpRxData->UdpSession;
+ Points.LocalAddr = EFI_NTOHL (UdpSession->DestinationAddress);
+ Points.LocalPort = UdpSession->DestinationPort;
+ Points.RemoteAddr = EFI_NTOHL (UdpSession->SourceAddress);
+ Points.RemotePort = UdpSession->SourcePort;
+
+ Token->CallBack (Netbuf, &Points, EFI_SUCCESS, Token->Context);
+
+ON_EXIT:
+ return;
+}
+
+
+/**
+ Issue a receive request to the UDP IO port.
+
+ @param UdpIo The UDP IO port to recieve the packet from.
+ @param CallBack The call back function to execute when receive
+ finished.
+ @param Context The opque context to the call back
+ @param HeadLen The lenght of the application's header
+
+ @retval EFI_ALREADY_STARTED There is already a pending receive request. Only
+ one receive request is supported.
+ @retval EFI_OUT_OF_RESOURCES Failed to allocate some resource.
+ @retval EFI_SUCCESS The receive request is issued successfully.
+
+**/
+EFI_STATUS
+UdpIoRecvDatagram (
+ IN UDP_IO_PORT *UdpIo,
+ IN UDP_IO_CALLBACK CallBack,
+ IN VOID *Context,
+ IN UINT32 HeadLen
+ )
+{
+ UDP_RX_TOKEN *Token;
+ EFI_STATUS Status;
+
+ if (UdpIo->RecvRequest != NULL) {
+ return EFI_ALREADY_STARTED;
+ }
+
+ Token = UdpIoCreateRxToken (UdpIo, CallBack, Context, HeadLen);
+
+ if (Token == NULL) {
+ return EFI_OUT_OF_RESOURCES;
+ }
+
+ Status = UdpIo->Udp->Receive (UdpIo->Udp, &Token->UdpToken);
+
+ if (EFI_ERROR (Status)) {
+ UdpIoFreeRxToken (Token);
+ return Status;
+ }
+
+ UdpIo->RecvRequest = Token;
+ return EFI_SUCCESS;
+}
diff --git a/MdeModulePkg/Library/DxeUdpIoLib/DxeUdpIoLib.inf b/MdeModulePkg/Library/DxeUdpIoLib/DxeUdpIoLib.inf new file mode 100644 index 0000000000..421eaa011a --- /dev/null +++ b/MdeModulePkg/Library/DxeUdpIoLib/DxeUdpIoLib.inf @@ -0,0 +1,65 @@ +#/** @file
+# Component name for module NetLib
+#
+# FIX ME!
+# Copyright (c) 2006, Intel Corporation. All right reserved.
+#
+# All rights reserved. This program and the accompanying materials
+# are licensed and made available under the terms and conditions of the BSD License
+# which accompanies this distribution. The full text of the license may be found at
+# http://opensource.org/licenses/bsd-license.php
+#
+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+#
+#
+#**/
+
+[Defines]
+ INF_VERSION = 0x00010005
+ BASE_NAME = DxeUpdIoDxe
+ FILE_GUID = 7E615AA1-41EE-49d4-B7E9-1D7A60AA5C8D
+ MODULE_TYPE = DXE_DRIVER
+ VERSION_STRING = 1.0
+ LIBRARY_CLASS = UdpIoLib|DXE_CORE DXE_DRIVER DXE_RUNTIME_DRIVER DXE_SAL_DRIVER DXE_SMM_DRIVER UEFI_APPLICATION UEFI_DRIVER
+ EDK_RELEASE_VERSION = 0x00020000
+ EFI_SPECIFICATION_VERSION = 0x00020000
+
+
+#
+# The following information is for reference only and not required by the build tools.
+#
+# VALID_ARCHITECTURES = IA32 X64 IPF EBC
+#
+
+[Sources.common]
+ DxeUdpIoLib.c
+
+[Packages]
+ MdePkg/MdePkg.dec
+ MdeModulePkg/MdeModulePkg.dec
+
+
+[LibraryClasses]
+ MemoryAllocationLib
+ UefiLib
+ BaseLib
+ UefiBootServicesTableLib
+ UefiRuntimeServicesTableLib
+ BaseMemoryLib
+ DebugLib
+ PrintLib
+
+
+[Protocols]
+ gEfiIp4ProtocolGuid # PROTOCOL ALWAYS_CONSUMED
+ gEfiDriverDiagnosticsProtocolGuid # PROTOCOL ALWAYS_CONSUMED
+ gEfiUdp4ServiceBindingProtocolGuid # PROTOCOL ALWAYS_CONSUMED
+ gEfiLoadedImageProtocolGuid # PROTOCOL ALWAYS_CONSUMED
+ gEfiIp4ServiceBindingProtocolGuid # PROTOCOL ALWAYS_CONSUMED
+ gEfiDriverConfigurationProtocolGuid # PROTOCOL ALWAYS_CONSUMED
+ gEfiSimpleNetworkProtocolGuid # PROTOCOL ALWAYS_CONSUMED
+ gEfiDriverBindingProtocolGuid # PROTOCOL ALWAYS_CONSUMED
+ gEfiUdp4ProtocolGuid # PROTOCOL ALWAYS_CONSUMED
+ gEfiComponentNameProtocolGuid # PROTOCOL ALWAYS_CONSUMED
+
diff --git a/MdeModulePkg/MdeModulePkg.dsc b/MdeModulePkg/MdeModulePkg.dsc index 73cb07a97c..b461ecc56b 100644 --- a/MdeModulePkg/MdeModulePkg.dsc +++ b/MdeModulePkg/MdeModulePkg.dsc @@ -127,6 +127,8 @@ ScsiLib|$(WORKSPACE)/MdePkg/Library/UefiScsiLib/UefiScsiLib.inf
FrameworkHiiLib|$(WORKSPACE)/IntelFrameworkPkg/Library/FrameworkHiiLib/HiiLib.inf
UsbLib|$(WORKSPACE)/MdePkg/Library/UefiUsbLib/UefiUsbLib.inf
+ NetLib|$(WORKSPACE)/MdeModulePkg/Library/DxeNetLib/DxeNetLib.inf
+ IpIoLib|$(WORKSPACE)/MdeModulePkg/Library/DxeIpIoLib/DxeIpIoLib.inf
[LibraryClasses.common.DXE_RUNTIME_DRIVER]
HobLib|$(WORKSPACE)/MdePkg/Library/DxeHobLib/DxeHobLib.inf
@@ -394,6 +396,12 @@ $(WORKSPACE)/MdeModulePkg/Library/PeiPerformanceLib/PeiPerformanceLib.inf
$(WORKSPACE)/MdeModulePkg/Library/EdkDxePrintLib/EdkDxePrintLib.inf
+ $(WORKSPACE)/MdeModulePkg/Library/DxeNetLib/DxeNetLib.inf
+ $(WORKSPACE)/MdeModulePkg/Library/DxeIpIoLib/DxeIpIoLib.inf
+ $(WORKSPACE)/MdeModulePkg/Library/DxeUdpIoLib/DxeUdpIoLib.inf
+
+ $(WORKSPACE)/MdeModulePkg/Universal/Network/Ip4ConfigDxe/Ip4ConfigDxe.inf
+
$(WORKSPACE)/MdeModulePkg/Application/HelloWorld/HelloWorld.inf
$(WORKSPACE)/MdeModulePkg/Bus/Pci/AtapiPassThruDxe/AtapiPassThru.inf
|