From cbf316f20726bb31b7c37424601643790dbd02d9 Mon Sep 17 00:00:00 2001 From: vanjeff Date: Mon, 23 Jul 2007 09:17:39 +0000 Subject: 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 +++++++ 3 files changed, 1244 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 (limited to 'MdeModulePkg/Include') 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 -- cgit v1.2.3