From cbf316f20726bb31b7c37424601643790dbd02d9 Mon Sep 17 00:00:00 2001 From: vanjeff Date: Mon, 23 Jul 2007 09:17:39 +0000 Subject: [PATCH] 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 --- MdeModulePkg/Include/Library/IpIoLib.h | 255 +++ MdeModulePkg/Include/Library/NetLib.h | 812 ++++++++ MdeModulePkg/Include/Library/UdpIoLib.h | 177 ++ MdeModulePkg/Library/DxeIpIoLib/DxeIpIoLib.c | 1299 ++++++++++++ .../Library/DxeIpIoLib/DxeIpIoLib.inf | 65 + MdeModulePkg/Library/DxeNetLib/DxeNetLib.c | 1332 +++++++++++++ MdeModulePkg/Library/DxeNetLib/DxeNetLib.inf | 66 + MdeModulePkg/Library/DxeNetLib/Netbuffer.c | 1759 +++++++++++++++++ .../Library/DxeUdpIoLib/DxeUdpIoLib.c | 727 +++++++ .../Library/DxeUdpIoLib/DxeUdpIoLib.inf | 65 + MdeModulePkg/MdeModulePkg.dsc | 8 + 11 files changed, 6565 insertions(+) create mode 100644 MdeModulePkg/Include/Library/IpIoLib.h create mode 100644 MdeModulePkg/Include/Library/NetLib.h create mode 100644 MdeModulePkg/Include/Library/UdpIoLib.h create mode 100644 MdeModulePkg/Library/DxeIpIoLib/DxeIpIoLib.c create mode 100644 MdeModulePkg/Library/DxeIpIoLib/DxeIpIoLib.inf create mode 100644 MdeModulePkg/Library/DxeNetLib/DxeNetLib.c create mode 100644 MdeModulePkg/Library/DxeNetLib/DxeNetLib.inf create mode 100644 MdeModulePkg/Library/DxeNetLib/Netbuffer.c create mode 100644 MdeModulePkg/Library/DxeUdpIoLib/DxeUdpIoLib.c create mode 100644 MdeModulePkg/Library/DxeUdpIoLib/DxeUdpIoLib.inf 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 +#include +#include +#include + +// +// 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 +#include +#include +#include +#include + +#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 + +#include + +#include +#include + +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 + +#include + +#include +#include +#include +#include +#include + + +#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 + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + + +// +// 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 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 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 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 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 + +#include +#include +#include +#include +#include +#include + + +/** + 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 + +#include + +#include +#include +#include +#include +#include + +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