//
// the node used to link this IpIo to the active IpIo list.
//
- NET_LIST_ENTRY Entry;
+ LIST_ENTRY Entry;
// the list used to maintain the IP instance for different sending purpose.
//
- NET_LIST_ENTRY IpList;
+ LIST_ENTRY IpList;
//
// the ip instance consumed by this IP IO
//
// list entry used to link the token passed to IP_IO
//
- NET_LIST_ENTRY PendingSndList;
+ LIST_ENTRY PendingSndList;
//
// User interface used to get notify from IP_IO
} IP_IO_OPEN_DATA;
typedef struct _IP_IO_SEND_ENTRY {
- NET_LIST_ENTRY Entry;
+ LIST_ENTRY Entry;
IP_IO *IpIo;
VOID *Context;
VOID *NotifyData;
typedef struct _IP_IO_IP_INFO {
IP4_ADDR Addr;
IP4_ADDR SubnetMask;
- NET_LIST_ENTRY Entry;
+ LIST_ENTRY Entry;
EFI_HANDLE ChildHandle;
EFI_IP4_PROTOCOL *Ip;
EFI_IP4_COMPLETION_TOKEN DummyRcvToken;
#include <Protocol/DriverDiagnostics.h>
#include <Protocol/Dpc.h>
-#define EFI_NET_LITTLE_ENDIAN
-
typedef UINT32 IP4_ADDR;
typedef UINT32 TCP_SEQNO;
typedef UINT16 TCP_PORTNO;
// 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;
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;
#pragma pack()
#define NET_MAC_EQUAL(pMac1, pMac2, Len) \
- (NetCompareMem ((pMac1), (pMac2), Len) == 0)
+ (CompareMem ((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) | \
(((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 EFI_IP4(EfiIpAddr) (*(IP4_ADDR *) ((EfiIpAddr).Addr))
#define EFI_NTOHL(EfiIp) (NTOHL (EFI_IP4 ((EfiIp))))
-#define EFI_IP4_EQUAL(Ip1, Ip2) (NetCompareMem ((Ip1), (Ip2), sizeof (EFI_IPv4_ADDRESS)) == 0)
+#define EFI_IP4_EQUAL(Ip1, Ip2) (CompareMem ((Ip1), (Ip2), sizeof (EFI_IPv4_ADDRESS)) == 0)
INTN
NetGetMaskLength (
#define NET_IS_LOWER_CASE_CHAR(Ch) (('a' <= (Ch)) && ((Ch) <= 'z'))
#define NET_IS_UPPER_CASE_CHAR(Ch) (('A' <= (Ch)) && ((Ch) <= 'Z'))
-//
-// 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_EVENT TPL_NOTIFY
-#define NET_TPL_RECYCLE TPL_NOTIFY
-#define NET_TPL_TIMER NET_TPL_LOCK
+//#define NET_TPL_LOCK TPL_CALLBACK
+//#define NET_TPL_EVENT TPL_NOTIFY
+//#define NET_TPL_RECYCLE TPL_NOTIFY
+//#define NET_TPL_TIMER NET_TPL_LOCK
-#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)
-#define NET_TRYLOCK(x) EfiAcquireLockOrFail (x)
-#define NET_UNLOCK(x) EfiReleaseLock (x)
+//#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)
+//#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 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
// Double linked list entry functions, this extends the
// EFI list functions.
//
-typedef LIST_ENTRY NET_LIST_ENTRY;
+//typedef LIST_ENTRY 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 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_TAIL(ListHead, Type, Field) \
NET_LIST_USER_STRUCT((ListHead)->BackLink, Type, Field)
-#define NetListRemoveEntry(Entry) RemoveEntryList (Entry)
+//#define NetListRemoveEntry(Entry) RemoveEntryList (Entry)
-NET_LIST_ENTRY*
+LIST_ENTRY*
NetListRemoveHead (
- NET_LIST_ENTRY *Head
+ LIST_ENTRY *Head
);
-NET_LIST_ENTRY*
+LIST_ENTRY*
NetListRemoveTail (
- NET_LIST_ENTRY *Head
+ LIST_ENTRY *Head
);
VOID
NetListInsertAfter (
- IN NET_LIST_ENTRY *PrevEntry,
- IN NET_LIST_ENTRY *NewEntry
+ IN LIST_ENTRY *PrevEntry,
+ IN LIST_ENTRY *NewEntry
);
VOID
NetListInsertBefore (
- IN NET_LIST_ENTRY *PostEntry,
- IN NET_LIST_ENTRY *NewEntry
+ IN LIST_ENTRY *PostEntry,
+ IN LIST_ENTRY *NewEntry
);
// tokens. The drivers can share code to manage those objects.
//
typedef struct {
- NET_LIST_ENTRY Link;
+ LIST_ENTRY Link;
VOID *Key;
VOID *Value;
} NET_MAP_ITEM;
typedef struct {
- NET_LIST_ENTRY Used;
- NET_LIST_ENTRY Recycled;
+ LIST_ENTRY Used;
+ LIST_ENTRY Recycled;
UINTN Count;
} NET_MAP;
typedef struct {
UINT32 Signature;
INTN RefCnt;
- NET_LIST_ENTRY List; // The List this NET_BUF is on
+ 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
typedef struct {
UINT32 Signature;
INTN RefCnt;
- NET_LIST_ENTRY List; // The List this buffer queue is on
+ LIST_ENTRY List; // The List this buffer queue is on
- NET_LIST_ENTRY BufList; // list of queued buffers
+ 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;
NET_BUF *
NetbufFromBufList (
- IN NET_LIST_ENTRY *BufList,
+ IN LIST_ENTRY *BufList,
IN UINT32 HeadSpace,
IN UINT32 HeaderLen,
IN NET_VECTOR_EXT_FREE ExtFree,
VOID
NetbufFreeList (
- IN NET_LIST_ENTRY *Head
+ IN LIST_ENTRY *Head
);
VOID
IN UINT16 Len
);
-//
-// The debug level definition. This value is also used as the
-// syslog's servity level. Don't change it.
-//
-enum {
- NETDEBUG_LEVEL_TRACE = 5,
- NETDEBUG_LEVEL_WARNING = 4,
- NETDEBUG_LEVEL_ERROR = 3,
-};
-
-#ifdef EFI_NETWORK_STACK_DEBUG
-
-//
-// The debug output expects the ASCII format string, Use %a to print ASCII
-// string, and %s to print UNICODE string. PrintArg must be enclosed in ().
-// For example: NET_DEBUG_TRACE ("Tcp", ("State transit to %a\n", Name));
-//
-#define NET_DEBUG_TRACE(Module, PrintArg) \
- NetDebugOutput ( \
- NETDEBUG_LEVEL_TRACE, \
- Module, \
- __FILE__, \
- __LINE__, \
- NetDebugASPrint PrintArg \
- )
-
-#define NET_DEBUG_WARNING(Module, PrintArg) \
- NetDebugOutput ( \
- NETDEBUG_LEVEL_WARNING, \
- Module, \
- __FILE__, \
- __LINE__, \
- NetDebugASPrint PrintArg \
- )
-
-#define NET_DEBUG_ERROR(Module, PrintArg) \
- NetDebugOutput ( \
- NETDEBUG_LEVEL_ERROR, \
- Module, \
- __FILE__, \
- __LINE__, \
- NetDebugASPrint PrintArg \
- )
-
-#else
-#define NET_DEBUG_TRACE(Module, PrintString)
-#define NET_DEBUG_WARNING(Module, PrintString)
-#define NET_DEBUG_ERROR(Module, PrintString)
-#endif
-
-UINT8 *
-NetDebugASPrint (
- UINT8 *Format,
- ...
- );
-
-EFI_STATUS
-NetDebugOutput (
- UINT32 Level,
- UINT8 *Module,
- UINT8 *File,
- UINT32 Line,
- UINT8 *Message
- );
-
-//
-// Network debug message is sent out as syslog.
-//
-enum {
- NET_SYSLOG_FACILITY = 16, // Syslog local facility local use
- NET_SYSLOG_PACKET_LEN = 512,
- NET_DEBUG_MSG_LEN = 470, // 512 - (ether+ip+udp head length)
- NET_SYSLOG_TX_TIMEOUT = 500 *1000 *10, // 500ms
-};
#endif
//
typedef struct {
UINT32 Signature;
- NET_LIST_ENTRY Link;
+ LIST_ENTRY Link;
UDP_IO_PORT *UdpIo;
UDP_IO_CALLBACK CallBack;
struct _UDP_IO_PORT {
UINT32 Signature;
- NET_LIST_ENTRY Link;
+ LIST_ENTRY Link;
INTN RefCnt;
//
EFI_UDP4_CONFIG_DATA UdpConfig;
EFI_SIMPLE_NETWORK_MODE SnpMode;
- NET_LIST_ENTRY SentDatagram;
+ LIST_ENTRY SentDatagram;
UDP_RX_TOKEN *RecvRequest;
};
#define ICMP_ERRLEN(IpHdr) \\r
(sizeof(IP4_ICMP_HEAD) + EFI_IP4_HEADER_LEN(IpHdr) + 8)\r
\r
-NET_LIST_ENTRY mActiveIpIoList = {\r
+LIST_ENTRY mActiveIpIoList = {\r
&mActiveIpIoList,\r
&mActiveIpIoList\r
};\r
//\r
// Allocate resource for SndEntry\r
//\r
- SndEntry = NetAllocatePool (sizeof (IP_IO_SEND_ENTRY));\r
+ SndEntry = AllocatePool (sizeof (IP_IO_SEND_ENTRY));\r
if (NULL == SndEntry) {\r
return NULL;\r
}\r
//\r
// Allocate resource for SndToken\r
//\r
- SndToken = NetAllocatePool (sizeof (EFI_IP4_COMPLETION_TOKEN));\r
+ SndToken = AllocatePool (sizeof (EFI_IP4_COMPLETION_TOKEN));\r
if (NULL == SndToken) {\r
goto ReleaseSndEntry;\r
}\r
\r
Status = gBS->CreateEvent (\r
EVT_NOTIFY_SIGNAL,\r
- NET_TPL_EVENT,\r
+ TPL_NOTIFY,\r
IpIoTransmitHandler,\r
SndEntry,\r
&(SndToken->Event)\r
//\r
// Allocate resource for TxData\r
//\r
- TxData = NetAllocatePool (\r
+ TxData = AllocatePool (\r
sizeof (EFI_IP4_TRANSMIT_DATA) +\r
sizeof (EFI_IP4_FRAGMENT_DATA) * (Pkt->BlockOpNum - 1)\r
);\r
OverrideData = NULL;\r
if (NULL != Override) {\r
\r
- OverrideData = NetAllocatePool (sizeof (EFI_IP4_OVERRIDE_DATA));\r
+ OverrideData = AllocatePool (sizeof (EFI_IP4_OVERRIDE_DATA));\r
if (NULL == OverrideData) {\r
goto ReleaseResource;\r
}\r
//\r
// Set the fields of TxData\r
//\r
- NetCopyMem (&TxData->DestinationAddress, &Dest, sizeof (EFI_IPv4_ADDRESS));\r
+ CopyMem (&TxData->DestinationAddress, &Dest, sizeof (EFI_IPv4_ADDRESS));\r
TxData->OverrideData = OverrideData;\r
TxData->OptionsLength = 0;\r
TxData->OptionsBuffer = NULL;\r
\r
SndEntry->SndToken = SndToken;\r
\r
- NetListInsertTail (&IpIo->PendingSndList, &SndEntry->Entry);\r
+ InsertTailList (&IpIo->PendingSndList, &SndEntry->Entry);\r
\r
return SndEntry;\r
\r
ReleaseResource:\r
- NetFreePool (TxData);\r
+ gBS->FreePool (TxData);\r
\r
ReleaseEvent:\r
gBS->CloseEvent (SndToken->Event);\r
\r
ReleaseSndToken:\r
- NetFreePool (SndToken);\r
+ gBS->FreePool (SndToken);\r
\r
ReleaseSndEntry:\r
- NetFreePool (SndEntry);\r
+ gBS->FreePool (SndEntry);\r
\r
return NULL;\r
}\r
TxData = SndEntry->SndToken->Packet.TxData;\r
\r
if (NULL != TxData->OverrideData) {\r
- NetFreePool (TxData->OverrideData);\r
+ gBS->FreePool (TxData->OverrideData);\r
}\r
\r
- NetFreePool (TxData);\r
+ gBS->FreePool (TxData);\r
NetbufFree (SndEntry->Pkt);\r
gBS->CloseEvent (SndEntry->SndToken->Event);\r
\r
- NetFreePool (SndEntry->SndToken);\r
- NetListRemoveEntry (&SndEntry->Entry);\r
+ gBS->FreePool (SndEntry->SndToken);\r
+ RemoveEntryList (&SndEntry->Entry);\r
\r
- NetFreePool (SndEntry);\r
+ gBS->FreePool (SndEntry);\r
}\r
\r
\r
EFI_STATUS Status;\r
IP_IO *IpIo;\r
\r
- IpIo = NetAllocateZeroPool (sizeof (IP_IO));\r
+ IpIo = AllocateZeroPool (sizeof (IP_IO));\r
if (NULL == IpIo) {\r
return NULL;\r
}\r
\r
- NetListInit (&(IpIo->PendingSndList));\r
- NetListInit (&(IpIo->IpList));\r
+ InitializeListHead (&(IpIo->PendingSndList));\r
+ InitializeListHead (&(IpIo->IpList));\r
IpIo->Controller = Controller;\r
IpIo->Image = Image;\r
\r
Status = gBS->CreateEvent (\r
EVT_NOTIFY_SIGNAL,\r
- NET_TPL_EVENT,\r
+ TPL_NOTIFY,\r
IpIoListenHandler,\r
IpIo,\r
&(IpIo->RcvToken.Event)\r
gBS->CloseEvent (IpIo->RcvToken.Event);\r
}\r
\r
- NetFreePool (IpIo);\r
+ gBS->FreePool (IpIo);\r
\r
return NULL;\r
}\r
}\r
\r
IpIo->IsConfigured = TRUE;\r
- NetListInsertTail (&mActiveIpIoList, &IpIo->Entry);\r
+ InsertTailList (&mActiveIpIoList, &IpIo->Entry);\r
\r
ErrorExit:\r
\r
//\r
// Remove the IpIo from the active IpIo list.\r
//\r
- NetListRemoveEntry (&IpIo->Entry);\r
+ RemoveEntryList (&IpIo->Entry);\r
\r
Ip = IpIo->Ip;\r
\r
// Detroy the Ip List used by IpIo\r
//\r
\r
- while (!NetListIsEmpty (&(IpIo->IpList))) {\r
+ while (!IsListEmpty (&(IpIo->IpList))) {\r
IpInfo = NET_LIST_HEAD (&(IpIo->IpList), IP_IO_IP_INFO, Entry);\r
\r
IpIoRemoveIp (IpIo, IpInfo);\r
//\r
// All pending snd tokens should be flushed by reseting the IP instances.\r
//\r
- ASSERT (NetListIsEmpty (&IpIo->PendingSndList));\r
+ ASSERT (IsListEmpty (&IpIo->PendingSndList));\r
\r
//\r
// Close the receive event.\r
//\r
IpIoCloseProtocolDestroyIpChild (IpIo->Controller, IpIo->Image, IpIo->ChildHandle);\r
\r
- NetFreePool (IpIo);\r
+ gBS->FreePool (IpIo);\r
\r
return EFI_SUCCESS;\r
}\r
IN VOID *Packet\r
)\r
{\r
- NET_LIST_ENTRY *Node;\r
+ LIST_ENTRY *Node;\r
IP_IO_SEND_ENTRY *SndEntry;\r
EFI_IP4_PROTOCOL *Ip;\r
\r
\r
ASSERT (IpIo);\r
\r
- IpInfo = NetAllocatePool (sizeof (IP_IO_IP_INFO));\r
+ IpInfo = AllocatePool (sizeof (IP_IO_IP_INFO));\r
if (IpInfo == NULL) {\r
return IpInfo;\r
}\r
// Init this IpInfo, set the Addr and SubnetMask to 0 before we configure the IP\r
// instance.\r
//\r
- NetListInit (&IpInfo->Entry);\r
+ InitializeListHead (&IpInfo->Entry);\r
IpInfo->ChildHandle = NULL;\r
IpInfo->Addr = 0;\r
IpInfo->SubnetMask = 0;\r
//\r
Status = gBS->CreateEvent (\r
EVT_NOTIFY_SIGNAL,\r
- NET_TPL_EVENT,\r
+ TPL_NOTIFY,\r
IpIoDummyHandler,\r
IpInfo,\r
&IpInfo->DummyRcvToken.Event\r
//\r
// Link this IpInfo into the IpIo.\r
//\r
- NetListInsertTail (&IpIo->IpList, &IpInfo->Entry);\r
+ InsertTailList (&IpIo->IpList, &IpInfo->Entry);\r
\r
return IpInfo;\r
\r
\r
ReleaseIpInfo:\r
\r
- NetFreePool (IpInfo);\r
+ gBS->FreePool (IpInfo);\r
\r
return NULL;\r
}\r
Ip4ConfigData->SubnetMask = Ip4ModeData.ConfigData.SubnetMask;\r
}\r
\r
- NetCopyMem (&IpInfo->Addr, &Ip4ConfigData->StationAddress, sizeof (IP4_ADDR));\r
- NetCopyMem (&IpInfo->SubnetMask, &Ip4ConfigData->SubnetMask, sizeof (IP4_ADDR));\r
+ CopyMem (&IpInfo->Addr, &Ip4ConfigData->StationAddress, sizeof (IP4_ADDR));\r
+ CopyMem (&IpInfo->SubnetMask, &Ip4ConfigData->SubnetMask, sizeof (IP4_ADDR));\r
\r
Status = Ip->Receive (Ip, &IpInfo->DummyRcvToken);\r
if (EFI_ERROR (Status)) {\r
return;\r
}\r
\r
- NetListRemoveEntry (&IpInfo->Entry);\r
+ RemoveEntryList (&IpInfo->Entry);\r
\r
IpInfo->Ip->Configure (IpInfo->Ip, NULL);\r
\r
\r
gBS->CloseEvent (IpInfo->DummyRcvToken.Event);\r
\r
- NetFreePool (IpInfo);\r
+ gBS->FreePool (IpInfo);\r
}\r
\r
\r
IN IP4_ADDR Src\r
)\r
{\r
- NET_LIST_ENTRY *IpIoEntry;\r
+ LIST_ENTRY *IpIoEntry;\r
IP_IO *IpIoPtr;\r
- NET_LIST_ENTRY *IpInfoEntry;\r
+ LIST_ENTRY *IpInfoEntry;\r
IP_IO_IP_INFO *IpInfo;\r
\r
NET_LIST_FOR_EACH (IpIoEntry, &mActiveIpIoList) {\r
{\r
UINT32 Value;\r
\r
- NetCopyMem (&Value, Buf, sizeof (UINT32));\r
+ CopyMem (&Value, Buf, sizeof (UINT32));\r
return NTOHL (Value);\r
}\r
\r
)\r
{\r
Data = HTONL (Data);\r
- NetCopyMem (Buf, &Data, sizeof (UINT32));\r
+ CopyMem (Buf, &Data, sizeof (UINT32));\r
}\r
\r
\r
@return The entry that is removed from the list, NULL if the list is empty.\r
\r
**/\r
-NET_LIST_ENTRY *\r
+LIST_ENTRY *\r
NetListRemoveHead (\r
- NET_LIST_ENTRY *Head\r
+ LIST_ENTRY *Head\r
)\r
{\r
- NET_LIST_ENTRY *First;\r
+ LIST_ENTRY *First;\r
\r
ASSERT (Head != NULL);\r
\r
- if (NetListIsEmpty (Head)) {\r
+ if (IsListEmpty (Head)) {\r
return NULL;\r
}\r
\r
First->ForwardLink->BackLink = Head;\r
\r
DEBUG_CODE (\r
- First->ForwardLink = (LIST_ENTRY *) NULL;\r
- First->BackLink = (LIST_ENTRY *) NULL;\r
+ First->ForwardLink = (LIST_ENTRY *) NULL;\r
+ First->BackLink = (LIST_ENTRY *) NULL;\r
);\r
\r
return First;\r
@return The entry that is removed from the list, NULL if the list is empty.\r
\r
**/\r
-NET_LIST_ENTRY *\r
+LIST_ENTRY *\r
NetListRemoveTail (\r
- NET_LIST_ENTRY *Head\r
+ LIST_ENTRY *Head\r
)\r
{\r
- NET_LIST_ENTRY *Last;\r
+ LIST_ENTRY *Last;\r
\r
ASSERT (Head != NULL);\r
\r
- if (NetListIsEmpty (Head)) {\r
+ if (IsListEmpty (Head)) {\r
return NULL;\r
}\r
\r
Last->BackLink->ForwardLink = Head;\r
\r
DEBUG_CODE (\r
- Last->ForwardLink = (LIST_ENTRY *) NULL;\r
- Last->BackLink = (LIST_ENTRY *) NULL;\r
+ Last->ForwardLink = (LIST_ENTRY *) NULL;\r
+ Last->BackLink = (LIST_ENTRY *) NULL;\r
);\r
\r
return Last;\r
**/\r
VOID\r
NetListInsertAfter (\r
- IN NET_LIST_ENTRY *PrevEntry,\r
- IN NET_LIST_ENTRY *NewEntry\r
+ IN LIST_ENTRY *PrevEntry,\r
+ IN LIST_ENTRY *NewEntry\r
)\r
{\r
NewEntry->BackLink = PrevEntry;\r
**/\r
VOID\r
NetListInsertBefore (\r
- IN NET_LIST_ENTRY *PostEntry,\r
- IN NET_LIST_ENTRY *NewEntry\r
+ IN LIST_ENTRY *PostEntry,\r
+ IN LIST_ENTRY *NewEntry\r
)\r
{\r
NewEntry->ForwardLink = PostEntry;\r
{\r
ASSERT (Map != NULL);\r
\r
- NetListInit (&Map->Used);\r
- NetListInit (&Map->Recycled);\r
+ InitializeListHead (&Map->Used);\r
+ InitializeListHead (&Map->Recycled);\r
Map->Count = 0;\r
}\r
\r
)\r
{\r
NET_MAP_ITEM *Item;\r
- NET_LIST_ENTRY *Entry;\r
- NET_LIST_ENTRY *Next;\r
+ LIST_ENTRY *Entry;\r
+ LIST_ENTRY *Next;\r
\r
ASSERT (Map != NULL);\r
\r
NET_LIST_FOR_EACH_SAFE (Entry, Next, &Map->Used) {\r
Item = NET_LIST_USER_STRUCT (Entry, NET_MAP_ITEM, Link);\r
\r
- NetListRemoveEntry (&Item->Link);\r
+ RemoveEntryList (&Item->Link);\r
Map->Count--;\r
\r
- NetFreePool (Item);\r
+ gBS->FreePool (Item);\r
}\r
\r
- ASSERT ((Map->Count == 0) && NetListIsEmpty (&Map->Used));\r
+ ASSERT ((Map->Count == 0) && IsListEmpty (&Map->Used));\r
\r
NET_LIST_FOR_EACH_SAFE (Entry, Next, &Map->Recycled) {\r
Item = NET_LIST_USER_STRUCT (Entry, NET_MAP_ITEM, Link);\r
\r
- NetListRemoveEntry (&Item->Link);\r
- NetFreePool (Item);\r
+ RemoveEntryList (&Item->Link);\r
+ gBS->FreePool (Item);\r
}\r
\r
- ASSERT (NetListIsEmpty (&Map->Recycled));\r
+ ASSERT (IsListEmpty (&Map->Recycled));\r
}\r
\r
\r
)\r
{\r
NET_MAP_ITEM *Item;\r
- NET_LIST_ENTRY *Head;\r
+ LIST_ENTRY *Head;\r
UINTN Index;\r
\r
ASSERT (Map != NULL);\r
\r
Head = &Map->Recycled;\r
\r
- if (NetListIsEmpty (Head)) {\r
+ if (IsListEmpty (Head)) {\r
for (Index = 0; Index < NET_MAP_INCREAMENT; Index++) {\r
- Item = NetAllocatePool (sizeof (NET_MAP_ITEM));\r
+ Item = AllocatePool (sizeof (NET_MAP_ITEM));\r
\r
if (Item == NULL) {\r
if (Index == 0) {\r
break;\r
}\r
\r
- NetListInsertHead (Head, &Item->Link);\r
+ InsertHeadList (Head, &Item->Link);\r
}\r
}\r
\r
\r
Item->Key = Key;\r
Item->Value = Value;\r
- NetListInsertHead (&Map->Used, &Item->Link);\r
+ InsertHeadList (&Map->Used, &Item->Link);\r
\r
Map->Count++;\r
return EFI_SUCCESS;\r
\r
Item->Key = Key;\r
Item->Value = Value;\r
- NetListInsertTail (&Map->Used, &Item->Link);\r
+ InsertTailList (&Map->Used, &Item->Link);\r
\r
Map->Count++;\r
\r
IN NET_MAP_ITEM *Item\r
)\r
{\r
- NET_LIST_ENTRY *ListEntry;\r
+ LIST_ENTRY *ListEntry;\r
\r
NET_LIST_FOR_EACH (ListEntry, &Map->Used) {\r
if (ListEntry == &Item->Link) {\r
IN VOID *Key\r
)\r
{\r
- NET_LIST_ENTRY *Entry;\r
+ LIST_ENTRY *Entry;\r
NET_MAP_ITEM *Item;\r
\r
ASSERT (Map != NULL);\r
ASSERT ((Map != NULL) && (Item != NULL));\r
ASSERT (NetItemInMap (Map, Item));\r
\r
- NetListRemoveEntry (&Item->Link);\r
+ RemoveEntryList (&Item->Link);\r
Map->Count--;\r
- NetListInsertHead (&Map->Recycled, &Item->Link);\r
+ InsertHeadList (&Map->Recycled, &Item->Link);\r
\r
if (Value != NULL) {\r
*Value = Item->Value;\r
// Often, it indicates a programming error to remove\r
// the first entry in an empty list\r
//\r
- ASSERT (Map && !NetListIsEmpty (&Map->Used));\r
+ ASSERT (Map && !IsListEmpty (&Map->Used));\r
\r
Item = NET_LIST_HEAD (&Map->Used, NET_MAP_ITEM, Link);\r
- NetListRemoveEntry (&Item->Link);\r
+ RemoveEntryList (&Item->Link);\r
Map->Count--;\r
- NetListInsertHead (&Map->Recycled, &Item->Link);\r
+ InsertHeadList (&Map->Recycled, &Item->Link);\r
\r
if (Value != NULL) {\r
*Value = Item->Value;\r
// Often, it indicates a programming error to remove\r
// the last entry in an empty list\r
//\r
- ASSERT (Map && !NetListIsEmpty (&Map->Used));\r
+ ASSERT (Map && !IsListEmpty (&Map->Used));\r
\r
Item = NET_LIST_TAIL (&Map->Used, NET_MAP_ITEM, Link);\r
- NetListRemoveEntry (&Item->Link);\r
+ RemoveEntryList (&Item->Link);\r
Map->Count--;\r
- NetListInsertHead (&Map->Recycled, &Item->Link);\r
+ InsertHeadList (&Map->Recycled, &Item->Link);\r
\r
if (Value != NULL) {\r
*Value = Item->Value;\r
)\r
{\r
\r
- NET_LIST_ENTRY *Entry;\r
- NET_LIST_ENTRY *Next;\r
- NET_LIST_ENTRY *Head;\r
+ LIST_ENTRY *Entry;\r
+ LIST_ENTRY *Next;\r
+ LIST_ENTRY *Head;\r
NET_MAP_ITEM *Item;\r
EFI_STATUS Result;\r
\r
\r
Head = &Map->Used;\r
\r
- if (NetListIsEmpty (Head)) {\r
+ if (IsListEmpty (Head)) {\r
return EFI_SUCCESS;\r
}\r
\r
// It takes 2 unicode characters to represent a 1 byte binary buffer.\r
// Plus one unicode character for the null-terminator.\r
//\r
- MacAddress = NetAllocatePool ((2 * Mode->HwAddressSize + 1) * sizeof (CHAR16));\r
+ MacAddress = AllocatePool ((2 * Mode->HwAddressSize + 1) * sizeof (CHAR16));\r
if (MacAddress == NULL) {\r
return EFI_OUT_OF_RESOURCES;\r
}\r
return TRUE;\r
}\r
\r
- ConfigInfo = NetAllocatePool (Len);\r
+ ConfigInfo = AllocatePool (Len);\r
if (ConfigInfo == NULL) {\r
return TRUE;\r
}\r
\r
ON_EXIT:\r
\r
- NetFreePool (ConfigInfo);\r
+ gBS->FreePool (ConfigInfo);\r
\r
return IsStatic;\r
}\r
Node->Header.SubType = MSG_IPv4_DP;\r
SetDevicePathNodeLength (&Node->Header, 19);\r
\r
- NetCopyMem (&Node->LocalIpAddress, &LocalIp, sizeof (EFI_IPv4_ADDRESS));\r
- NetCopyMem (&Node->RemoteIpAddress, &RemoteIp, sizeof (EFI_IPv4_ADDRESS));\r
+ CopyMem (&Node->LocalIpAddress, &LocalIp, sizeof (EFI_IPv4_ADDRESS));\r
+ CopyMem (&Node->RemoteIpAddress, &RemoteIp, sizeof (EFI_IPv4_ADDRESS));\r
\r
Node->LocalPort = LocalPort;\r
Node->RemotePort = RemotePort;\r
[Sources.common]\r
DxeNetLib.c\r
NetBuffer.c\r
- NetDebug.c\r
+\r
\r
[Packages]\r
MdePkg/MdePkg.dec\r
//\r
// Allocate three memory blocks.\r
//\r
- Nbuf = NetAllocateZeroPool (NET_BUF_SIZE (BlockOpNum));\r
+ Nbuf = AllocateZeroPool (NET_BUF_SIZE (BlockOpNum));\r
\r
if (Nbuf == NULL) {\r
return NULL;\r
Nbuf->Signature = NET_BUF_SIGNATURE;\r
Nbuf->RefCnt = 1;\r
Nbuf->BlockOpNum = BlockOpNum;\r
- NetListInit (&Nbuf->List);\r
+ InitializeListHead (&Nbuf->List);\r
\r
if (BlockNum != 0) {\r
- Vector = NetAllocateZeroPool (NET_VECTOR_SIZE (BlockNum));\r
+ Vector = AllocateZeroPool (NET_VECTOR_SIZE (BlockNum));\r
\r
if (Vector == NULL) {\r
goto FreeNbuf;\r
\r
FreeNbuf:\r
\r
- NetFreePool (Nbuf);\r
+ gBS->FreePool (Nbuf);\r
return NULL;\r
}\r
\r
return NULL;\r
}\r
\r
- Bulk = NetAllocatePool (Len);\r
+ Bulk = AllocatePool (Len);\r
\r
if (Bulk == NULL) {\r
goto FreeNBuf;\r
return Nbuf;\r
\r
FreeNBuf:\r
- NetFreePool (Nbuf);\r
+ gBS->FreePool (Nbuf);\r
return NULL;\r
}\r
\r
// first block since it is allocated by us\r
//\r
if (Vector->Flag & NET_VECTOR_OWN_FIRST) {\r
- NetFreePool (Vector->Block[0].Bulk);\r
+ gBS->FreePool (Vector->Block[0].Bulk);\r
}\r
\r
Vector->Free (Vector->Arg);\r
// Free each memory block associated with the Vector\r
//\r
for (Index = 0; Index < Vector->BlockNum; Index++) {\r
- NetFreePool (Vector->Block[Index].Bulk);\r
+ gBS->FreePool (Vector->Block[Index].Bulk);\r
}\r
}\r
\r
- NetFreePool (Vector);\r
+ gBS->FreePool (Vector);\r
}\r
\r
\r
// all the sharing of Nbuf increse Vector's RefCnt by one\r
//\r
NetbufFreeVector (Nbuf->Vector);\r
- NetFreePool (Nbuf);\r
+ gBS->FreePool (Nbuf);\r
}\r
}\r
\r
\r
NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);\r
\r
- Clone = NetAllocatePool (NET_BUF_SIZE (Nbuf->BlockOpNum));\r
+ Clone = AllocatePool (NET_BUF_SIZE (Nbuf->BlockOpNum));\r
\r
if (Clone == NULL) {\r
return NULL;\r
\r
Clone->Signature = NET_BUF_SIGNATURE;\r
Clone->RefCnt = 1;\r
- NetListInit (&Clone->List);\r
+ InitializeListHead (&Clone->List);\r
\r
Clone->Ip = Nbuf->Ip;\r
Clone->Tcp = Nbuf->Tcp;\r
\r
- NetCopyMem (Clone->ProtoData, Nbuf->ProtoData, NET_PROTO_DATA);\r
+ CopyMem (Clone->ProtoData, Nbuf->ProtoData, NET_PROTO_DATA);\r
\r
NET_GET_REF (Nbuf->Vector);\r
\r
Clone->Vector = Nbuf->Vector;\r
Clone->BlockOpNum = Nbuf->BlockOpNum;\r
Clone->TotalSize = Nbuf->TotalSize;\r
- NetCopyMem (Clone->BlockOp, Nbuf->BlockOp, sizeof (NET_BLOCK_OP) * Nbuf->BlockOpNum);\r
+ CopyMem (Clone->BlockOp, Nbuf->BlockOp, sizeof (NET_BLOCK_OP) * Nbuf->BlockOpNum);\r
\r
return Clone;\r
}\r
// Don't set the IP and TCP head point, since it is most\r
// like that they are pointing to the memory of Nbuf.\r
//\r
- NetCopyMem (Duplicate->ProtoData, Nbuf->ProtoData, NET_PROTO_DATA);\r
+ CopyMem (Duplicate->ProtoData, Nbuf->ProtoData, NET_PROTO_DATA);\r
NetbufReserve (Duplicate, HeadSpace);\r
\r
Dst = NetbufAllocSpace (Duplicate, Nbuf->TotalSize, NET_BUF_TAIL);\r
**/\r
VOID\r
NetbufFreeList (\r
- IN NET_LIST_ENTRY *Head\r
+ IN LIST_ENTRY *Head\r
)\r
{\r
- NET_LIST_ENTRY *Entry;\r
- NET_LIST_ENTRY *Next;\r
+ LIST_ENTRY *Entry;\r
+ LIST_ENTRY *Next;\r
NET_BUF *Nbuf;\r
\r
Entry = Head->ForwardLink;\r
Nbuf = NET_LIST_USER_STRUCT (Entry, NET_BUF, List);\r
NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);\r
\r
- NetListRemoveEntry (Entry);\r
+ RemoveEntryList (Entry);\r
NetbufFree (Nbuf);\r
}\r
\r
- ASSERT (NetListIsEmpty (Head));\r
+ ASSERT (IsListEmpty (Head));\r
}\r
\r
\r
return NULL;\r
}\r
\r
- FirstBulk = NetAllocatePool (HeadSpace);\r
+ FirstBulk = AllocatePool (HeadSpace);\r
\r
if (FirstBulk == NULL) {\r
goto FreeChild;\r
CurBlockOp++\r
);\r
\r
- for (Index = First + 1; Index <= Last - 1 ; Index++) {\r
+ for (Index = First + 1; Index < Last; Index++) {\r
NetbufSetBlockOp (\r
Child,\r
BlockOp[Index].Head,\r
);\r
}\r
\r
- NetCopyMem (Child->ProtoData, Nbuf->ProtoData, NET_PROTO_DATA);\r
+ CopyMem (Child->ProtoData, Nbuf->ProtoData, NET_PROTO_DATA);\r
return Child;\r
\r
FreeChild:\r
\r
- NetFreePool (Child);\r
+ gBS->FreePool (Child);\r
return NULL;\r
}\r
\r
//\r
if ((HeadSpace != 0) || (HeadLen != 0)) {\r
FirstBlockLen = HeadLen + HeadSpace;\r
- FirstBlock = NetAllocatePool (FirstBlockLen);\r
+ FirstBlock = AllocatePool (FirstBlockLen);\r
\r
if (FirstBlock == NULL) {\r
return NULL;\r
\r
for (Index = 0; Index < ExtNum; Index++) {\r
if (Len >= ExtFragment[Index].Len) {\r
- NetCopyMem (Header, ExtFragment[Index].Bulk, ExtFragment[Index].Len);\r
+ CopyMem (Header, ExtFragment[Index].Bulk, ExtFragment[Index].Len);\r
\r
Copied += ExtFragment[Index].Len;\r
Len -= ExtFragment[Index].Len;\r
}\r
\r
} else {\r
- NetCopyMem (Header, ExtFragment[Index].Bulk, Len);\r
+ CopyMem (Header, ExtFragment[Index].Bulk, Len);\r
\r
Copied += Len;\r
TotalLen += Len;\r
return Nbuf;\r
\r
FreeFirstBlock:\r
- NetFreePool (FirstBlock);\r
+ gBS->FreePool (FirstBlock);\r
return NULL;\r
}\r
\r
**/\r
NET_BUF *\r
NetbufFromBufList (\r
- IN NET_LIST_ENTRY *BufList,\r
+ IN LIST_ENTRY *BufList,\r
IN UINT32 HeadSpace,\r
IN UINT32 HeaderLen,\r
IN NET_VECTOR_EXT_FREE ExtFree,\r
{\r
NET_FRAGMENT *Fragment;\r
UINT32 FragmentNum;\r
- NET_LIST_ENTRY *Entry;\r
+ LIST_ENTRY *Entry;\r
NET_BUF *Nbuf;\r
UINT32 Index;\r
UINT32 Current;\r
//\r
//Allocate and copy block points\r
//\r
- Fragment = NetAllocatePool (sizeof (NET_FRAGMENT) * FragmentNum);\r
+ Fragment = AllocatePool (sizeof (NET_FRAGMENT) * FragmentNum);\r
\r
if (Fragment == NULL) {\r
return NULL;\r
}\r
\r
Nbuf = NetbufFromExt (Fragment, Current, HeadSpace, HeaderLen, ExtFree, Arg);\r
- NetFreePool (Fragment);\r
+ gBS->FreePool (Fragment);\r
\r
return Nbuf;\r
}\r
Left = BlockOp[Index].Size - Skip;\r
\r
if (Len <= Left) {\r
- NetCopyMem (Dest, BlockOp[Index].Head + Skip, Len);\r
+ CopyMem (Dest, BlockOp[Index].Head + Skip, Len);\r
return Len;\r
}\r
\r
- NetCopyMem (Dest, BlockOp[Index].Head + Skip, Left);\r
+ CopyMem (Dest, BlockOp[Index].Head + Skip, Left);\r
\r
Dest += Left;\r
Len -= Left;\r
Len -= BlockOp[Index].Size;\r
Copied += BlockOp[Index].Size;\r
\r
- NetCopyMem (Dest, BlockOp[Index].Head, BlockOp[Index].Size);\r
+ CopyMem (Dest, BlockOp[Index].Head, BlockOp[Index].Size);\r
Dest += BlockOp[Index].Size;\r
} else {\r
Copied += Len;\r
- NetCopyMem (Dest, BlockOp[Index].Head, Len);\r
+ CopyMem (Dest, BlockOp[Index].Head, Len);\r
break;\r
}\r
}\r
{\r
NbufQue->Signature = NET_QUE_SIGNATURE;\r
NbufQue->RefCnt = 1;\r
- NetListInit (&NbufQue->List);\r
+ InitializeListHead (&NbufQue->List);\r
\r
- NetListInit (&NbufQue->BufList);\r
+ InitializeListHead (&NbufQue->BufList);\r
NbufQue->BufSize = 0;\r
NbufQue->BufNum = 0;\r
}\r
{\r
NET_BUF_QUEUE *NbufQue;\r
\r
- NbufQue = NetAllocatePool (sizeof (NET_BUF_QUEUE));\r
+ NbufQue = AllocatePool (sizeof (NET_BUF_QUEUE));\r
if (NbufQue == NULL) {\r
return NULL;\r
}\r
\r
if (NbufQue->RefCnt == 0) {\r
NetbufQueFlush (NbufQue);\r
- NetFreePool (NbufQue);\r
+ gBS->FreePool (NbufQue);\r
}\r
}\r
\r
NET_CHECK_SIGNATURE (NbufQue, NET_QUE_SIGNATURE);\r
NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);\r
\r
- NetListInsertTail (&NbufQue->BufList, &Nbuf->List);\r
+ InsertTailList (&NbufQue->BufList, &Nbuf->List);\r
\r
NbufQue->BufSize += Nbuf->TotalSize;\r
NbufQue->BufNum++;\r
IN UINT8 *Dest\r
)\r
{\r
- NET_LIST_ENTRY *Entry;\r
+ LIST_ENTRY *Entry;\r
NET_BUF *Nbuf;\r
UINT32 Skip;\r
UINT32 Left;\r
IN UINT32 Len\r
)\r
{\r
- NET_LIST_ENTRY *Entry;\r
- NET_LIST_ENTRY *Next;\r
+ LIST_ENTRY *Entry;\r
+ LIST_ENTRY *Next;\r
NET_BUF *Nbuf;\r
UINT32 Trimmed;\r
\r
Trimmed += Nbuf->TotalSize;\r
Len -= Nbuf->TotalSize;\r
\r
- NetListRemoveEntry (Entry);\r
+ RemoveEntryList (Entry);\r
NetbufFree (Nbuf);\r
\r
NbufQue->BufNum--;\r
//\r
// Zero the memory to relieve align problems\r
//\r
- NetZeroMem (&Hdr, sizeof (Hdr));\r
+ ZeroMem (&Hdr, sizeof (Hdr));\r
\r
Hdr.SrcIp = Src;\r
Hdr.DstIp = Dst;\r
+++ /dev/null
-/** @file\r
-\r
-Copyright (c) 2005 - 2006, Intel Corporation\r
-All rights reserved. This program and the accompanying materials\r
-are licensed and made available under the terms and conditions of the BSD License\r
-which accompanies this distribution. The full text of the license may be found at\r
-http://opensource.org/licenses/bsd-license.php\r
-\r
-THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
-WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
-\r
-Module Name:\r
-\r
- NetDebug.c\r
-\r
-Abstract:\r
-\r
- Network debug facility. The debug information is wrapped in\r
- SYSLOG packets, then sent over SNP. This debug facility can't\r
- be used by SNP. Apply caution when used in MNP and non-network\r
- module because SNP is most likely not "thread safe". We assume\r
- that the SNP supports the EHTERNET.\r
-\r
-\r
-**/\r
-\r
-\r
-#include <PiDxe.h>\r
-\r
-#include <Protocol/SimpleNetwork.h>\r
-\r
-#include <Library/BaseLib.h>\r
-#include <Library/NetLib.h>\r
-#include <Library/UefiBootServicesTableLib.h>
-#include <Library/UefiRuntimeServicesTableLib.h>\r
-#include <Library/MemoryAllocationLib.h>\r
-#include <Library/BaseMemoryLib.h>\r
-#include <Library/PrintLib.h>\r
-\r
-\r
-//\r
-// Any error level digitally larger than mNetDebugLevelMax\r
-// will be silently discarded.\r
-//\r
-UINTN mNetDebugLevelMax = NETDEBUG_LEVEL_ERROR;\r
-UINT32 mSyslogPacketSeq = 0xDEADBEEF;\r
-\r
-//\r
-// You can change mSyslogDstMac mSyslogDstIp and mSyslogSrcIp\r
-// here to direct the syslog packets to the syslog deamon. The\r
-// default is broadcast to both the ethernet and IP.\r
-//\r
-UINT8 mSyslogDstMac [NET_ETHER_ADDR_LEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};\r
-UINT32 mSyslogDstIp = 0xffffffff;\r
-UINT32 mSyslogSrcIp = 0;\r
-\r
-CHAR8 *\r
-MonthName[] = {\r
- "Jan",\r
- "Feb",\r
- "Mar",\r
- "Apr",\r
- "May",\r
- "Jun",\r
- "Jul",\r
- "Aug",\r
- "Sep",\r
- "Oct",\r
- "Nov",\r
- "Dec"\r
-};\r
-\r
-\r
-/**\r
- Locate the handles that support SNP, then open one of them\r
- to send the syslog packets. The caller isn't required to close\r
- the SNP after use because the SNP is opened by HandleProtocol.\r
-\r
- None\r
-\r
- @return The point to SNP if one is properly openned. Otherwise NULL\r
-\r
-**/\r
-EFI_SIMPLE_NETWORK_PROTOCOL *\r
-SyslogLocateSnp (\r
- VOID\r
- )\r
-{\r
- EFI_SIMPLE_NETWORK_PROTOCOL *Snp;\r
- EFI_STATUS Status;\r
- EFI_HANDLE *Handles;\r
- UINTN HandleCount;\r
- UINTN Index;\r
-\r
- //\r
- // Locate the handles which has SNP installed.\r
- //\r
- Handles = NULL;\r
- Status = gBS->LocateHandleBuffer (\r
- ByProtocol,\r
- &gEfiSimpleNetworkProtocolGuid,\r
- NULL,\r
- &HandleCount,\r
- &Handles\r
- );\r
-\r
- if (EFI_ERROR (Status) || (HandleCount == 0)) {\r
- return NULL;\r
- }\r
-\r
- //\r
- // Try to open one of the ethernet SNP protocol to send packet\r
- //\r
- Snp = NULL;\r
-\r
- for (Index = 0; Index < HandleCount; Index++) {\r
- Status = gBS->HandleProtocol (\r
- Handles[Index],\r
- &gEfiSimpleNetworkProtocolGuid,\r
- (VOID **) &Snp\r
- );\r
-\r
- if ((Status == EFI_SUCCESS) && (Snp != NULL) &&\r
- (Snp->Mode->IfType == NET_IFTYPE_ETHERNET) &&\r
- (Snp->Mode->MaxPacketSize >= NET_SYSLOG_PACKET_LEN)) {\r
-\r
- break;\r
- }\r
-\r
- Snp = NULL;\r
- }\r
-\r
- gBS->FreePool (Handles);\r
- return Snp;\r
-}\r
-\r
-\r
-/**\r
- Transmit a syslog packet synchronously through SNP. The Packet\r
- already has the ethernet header prepended. This function should\r
- fill in the source MAC because it will try to locate a SNP each\r
- time it is called to avoid the problem if SNP is unloaded.\r
- This code snip is copied from MNP.\r
-\r
- @param Packet The Syslog packet\r
- @param Length The length of the packet\r
-\r
- @retval EFI_DEVICE_ERROR Failed to locate a usable SNP protocol\r
- @retval EFI_TIMEOUT Timeout happened to send the packet.\r
- @retval EFI_SUCCESS Packet is sent.\r
-\r
-**/\r
-EFI_STATUS\r
-SyslogSendPacket (\r
- IN UINT8 *Packet,\r
- IN UINT32 Length\r
- )\r
-{\r
- EFI_SIMPLE_NETWORK_PROTOCOL *Snp;\r
- ETHER_HEAD *Ether;\r
- EFI_STATUS Status;\r
- EFI_EVENT TimeoutEvent;\r
- UINT8 *TxBuf;\r
-\r
- Snp = SyslogLocateSnp ();\r
-\r
- if (Snp == NULL) {\r
- return EFI_DEVICE_ERROR;\r
- }\r
-\r
- Ether = (ETHER_HEAD *) Packet;\r
- CopyMem (Ether->SrcMac, Snp->Mode->CurrentAddress.Addr, NET_ETHER_ADDR_LEN);\r
-\r
- //\r
- // Start the timeout event.\r
- //\r
- Status = gBS->CreateEvent (\r
- EVT_TIMER,\r
- TPL_NOTIFY,\r
- NULL,\r
- NULL,\r
- &TimeoutEvent\r
- );\r
-\r
- if (EFI_ERROR (Status)) {\r
- return Status;\r
- }\r
-\r
- Status = gBS->SetTimer (TimeoutEvent, TimerRelative, NET_SYSLOG_TX_TIMEOUT);\r
-\r
- if (EFI_ERROR (Status)) {\r
- goto ON_EXIT;\r
- }\r
-\r
- for (;;) {\r
- //\r
- // Transmit the packet through SNP.\r
- //\r
- Status = Snp->Transmit (Snp, 0, Length, Packet, NULL, NULL, NULL);\r
-\r
- if ((Status != EFI_SUCCESS) && (Status != EFI_NOT_READY)) {\r
- Status = EFI_DEVICE_ERROR;\r
- break;\r
- }\r
-\r
- //\r
- // If Status is EFI_SUCCESS, the packet is put in the transmit queue.\r
- // if Status is EFI_NOT_READY, the transmit engine of the network\r
- // interface is busy. Both need to sync SNP.\r
- //\r
- TxBuf = NULL;\r
-\r
- do {\r
- //\r
- // Get the recycled transmit buffer status.\r
- //\r
- Snp->GetStatus (Snp, NULL, (VOID **) &TxBuf);\r
-\r
- if (!EFI_ERROR (gBS->CheckEvent (TimeoutEvent))) {\r
- Status = EFI_TIMEOUT;\r
- break;\r
- }\r
-\r
- } while (TxBuf == NULL);\r
-\r
- if ((Status == EFI_SUCCESS) || (Status == EFI_TIMEOUT)) {\r
- break;\r
- }\r
-\r
- //\r
- // Status is EFI_NOT_READY. Restart the timer event and\r
- // call Snp->Transmit again.\r
- //\r
- gBS->SetTimer (TimeoutEvent, TimerRelative, NET_SYSLOG_TX_TIMEOUT);\r
- }\r
-\r
- gBS->SetTimer (TimeoutEvent, TimerCancel, 0);\r
-\r
-ON_EXIT:\r
- gBS->CloseEvent (TimeoutEvent);\r
- return Status;\r
-}\r
-\r
-\r
-/**\r
- Compute checksum for a bulk of data. This code is copied from the\r
- Netbuffer library.\r
-\r
- @param Bulk Pointer to the data.\r
- @param Len Length of the data, in bytes.\r
-\r
- @retval UINT16 The computed checksum.\r
-\r
-**/\r
-UINT16\r
-SyslogChecksum (\r
- IN UINT8 *Bulk,\r
- IN UINT32 Len\r
- )\r
-{\r
- register UINT32 Sum;\r
-\r
- Sum = 0;\r
-\r
- while (Len > 1) {\r
- Sum += *(UINT16 *) Bulk;\r
- Bulk += 2;\r
- Len -= 2;\r
- }\r
-\r
- //\r
- // Add left-over byte, if any\r
- //\r
- if (Len > 0) {\r
- Sum += *(UINT8 *) Bulk;\r
- }\r
-\r
- //\r
- // Fold 32-bit sum to 16 bits\r
- //\r
- while (Sum >> 16) {\r
- Sum = (Sum & 0xffff) + (Sum >> 16);\r
- }\r
-\r
- return (UINT16) ~Sum;\r
-}\r
-\r
-\r
-/**\r
- Build a syslog packet, including the Ethernet/Ip/Udp headers\r
- and user's message.\r
-\r
- @param Buf The buffer to put the packet data\r
- @param BufLen The lenght of the Buf\r
- @param Level Syslog servity level\r
- @param Module The module that generates the log\r
- @param File The file that contains the current log\r
- @param Line The line of code in the File that contains the\r
- current log\r
- @param Message The log message\r
-\r
- @return The length of the syslog packet built.\r
-\r
-**/\r
-UINT32\r
-SyslogBuildPacket (\r
- UINT8 *Buf,\r
- UINT32 BufLen,\r
- UINT32 Level,\r
- UINT8 *Module,\r
- UINT8 *File,\r
- UINT32 Line,\r
- UINT8 *Message\r
- )\r
-{\r
- ETHER_HEAD *Ether;\r
- IP4_HEAD *Ip4;\r
- EFI_UDP4_HEADER *Udp4;\r
- EFI_TIME Time;\r
- UINT32 Pri;\r
- UINT32 Len;\r
-\r
- //\r
- // Fill in the Ethernet header. Leave alone the source MAC.\r
- // SyslogSendPacket will fill in the address for us.\r
- //\r
- Ether = (ETHER_HEAD *) Buf;\r
- CopyMem (Ether->DstMac, mSyslogDstMac, NET_ETHER_ADDR_LEN);\r
- ZeroMem (Ether->SrcMac, NET_ETHER_ADDR_LEN);\r
-\r
- Ether->EtherType = HTONS (0x0800); // IP protocol\r
-\r
- Buf += sizeof (ETHER_HEAD);\r
- BufLen -= sizeof (ETHER_HEAD);\r
-\r
- //\r
- // Fill in the IP header\r
- //\r
- Ip4 = (IP4_HEAD *) Buf;\r
- Ip4->HeadLen = 5;\r
- Ip4->Ver = 4;\r
- Ip4->Tos = 0;\r
- Ip4->TotalLen = 0;\r
- Ip4->Id = (UINT16) mSyslogPacketSeq;\r
- Ip4->Fragment = 0;\r
- Ip4->Ttl = 16;\r
- Ip4->Protocol = 0x11;\r
- Ip4->Checksum = 0;\r
- Ip4->Src = mSyslogSrcIp;\r
- Ip4->Dst = mSyslogDstIp;\r
-\r
- Buf += sizeof (IP4_HEAD);\r
- BufLen -= sizeof (IP4_HEAD);\r
-\r
- //\r
- // Fill in the UDP header, Udp checksum is optional. Leave it zero.\r
- //\r
- Udp4 = (EFI_UDP4_HEADER*) Buf;\r
- Udp4->SrcPort = HTONS (514);\r
- Udp4->DstPort = HTONS (514);\r
- Udp4->Length = 0;\r
- Udp4->Checksum = 0;\r
-\r
- Buf += sizeof (EFI_UDP4_HEADER);\r
- BufLen -= sizeof (EFI_UDP4_HEADER);\r
-\r
- //\r
- // Build the syslog message body with <PRI> Timestamp machine module Message\r
- //\r
- Pri = ((NET_SYSLOG_FACILITY & 31) << 3) | (Level & 7);\r
- gRT->GetTime (&Time, NULL);\r
-\r
- //\r
- // Use %a to format the ASCII strings, %s to format UNICODE strings\r
- //\r
- Len = 0;\r
- Len += (UINT32) AsciiSPrint (\r
- (CHAR8 *) Buf,\r
- BufLen,\r
- "<%d> %a %d %d:%d:%d ",\r
- Pri,\r
- MonthName [Time.Month-1],\r
- Time.Day,\r
- Time.Hour,\r
- Time.Minute,\r
- Time.Second\r
- );\r
- Len--;\r
-\r
- Len += (UINT32) AsciiSPrint (\r
- (CHAR8 *) (Buf + Len),\r
- BufLen - Len,\r
- "Tiano %a: %a (Line: %d File: %a)",\r
- Module,\r
- Message,\r
- Line,\r
- File\r
- );\r
- Len--;\r
-\r
- //\r
- // OK, patch the IP length/checksum and UDP length fields.\r
- //\r
- Len += sizeof (EFI_UDP4_HEADER);\r
- Udp4->Length = HTONS ((UINT16) Len);\r
-\r
- Len += sizeof (IP4_HEAD);\r
- Ip4->TotalLen = HTONS ((UINT16) Len);\r
- Ip4->Checksum = SyslogChecksum ((UINT8 *) Ip4, sizeof (IP4_HEAD));\r
-\r
- return Len + sizeof (ETHER_HEAD);\r
-}\r
-\r
-\r
-/**\r
- Allocate a buffer, then format the message to it. This is a\r
- help function for the NET_DEBUG_XXX macros. The PrintArg of\r
- these macros treats the variable length print parameters as a\r
- single parameter, and pass it to the NetDebugASPrint. For\r
- example, NET_DEBUG_TRACE ("Tcp", ("State transit to %a\n", Name))\r
- if extracted to:\r
- NetDebugOutput (\r
- NETDEBUG_LEVEL_TRACE,\r
- "Tcp",\r
- __FILE__,\r
- __LINE__,\r
- NetDebugASPrint ("State transit to %a\n", Name)\r
- )\r
- This is exactly what we want.\r
-\r
- @param Format The ASCII format string.\r
- @param ... The variable length parameter whose format is\r
- determined by the Format string.\r
-\r
- @return The buffer containing the formatted message, or NULL if failed to\r
- @return allocate memory.\r
-\r
-**/\r
-UINT8 *\r
-NetDebugASPrint (\r
- UINT8 *Format,\r
- ...\r
- )\r
-{\r
- VA_LIST Marker;\r
- UINT8 *Buf;\r
-\r
- Buf = AllocatePool (NET_DEBUG_MSG_LEN);\r
-\r
- if (Buf == NULL) {\r
- return NULL;\r
- }\r
-\r
- VA_START (Marker, Format);\r
- AsciiVSPrint ((CHAR8 *) Buf, NET_DEBUG_MSG_LEN, (CHAR8 *) Format, Marker);\r
- VA_END (Marker);\r
-\r
- return Buf;\r
-}\r
-\r
-\r
-/**\r
- Output a debug message to syslog. This function will locate a\r
- instance of SNP then send the message through it. Because it\r
- isn't open the SNP BY_DRIVER, apply caution when using it.\r
-\r
- @param Level The servity level of the message.\r
- @param Module The Moudle that generates the log.\r
- @param File The file that contains the log.\r
- @param Line The exact line that contains the log.\r
- @param Message The user message to log.\r
-\r
- @retval EFI_OUT_OF_RESOURCES Failed to allocate memory for the packet\r
- @retval EFI_SUCCESS The log is discard because that it is more verbose\r
- than the mNetDebugLevelMax. Or, it has been sent\r
- out.\r
-\r
-**/\r
-EFI_STATUS\r
-NetDebugOutput (\r
- UINT32 Level,\r
- UINT8 *Module,\r
- UINT8 *File,\r
- UINT32 Line,\r
- UINT8 *Message\r
- )\r
-{\r
- UINT8 *Packet;\r
- UINT32 Len;\r
- EFI_STATUS Status;\r
-\r
- //\r
- // Check whether the message should be sent out\r
- //\r
- if (Message == NULL) {\r
- return EFI_OUT_OF_RESOURCES;\r
- }\r
-\r
- if (Level > mNetDebugLevelMax) {\r
- Status = EFI_SUCCESS;\r
- goto ON_EXIT;\r
- }\r
-\r
- //\r
- // Allocate a maxium of 1024 bytes, the caller should ensure\r
- // that the message plus the ethernet/ip/udp header is shorter\r
- // than this\r
- //\r
- Packet = AllocatePool (NET_SYSLOG_PACKET_LEN);\r
-\r
- if (Packet == NULL) {\r
- Status = EFI_OUT_OF_RESOURCES;\r
- goto ON_EXIT;\r
- }\r
-\r
- //\r
- // Build the message: Ethernet header + IP header + Udp Header + user data\r
- //\r
- Len = SyslogBuildPacket (\r
- Packet,\r
- NET_SYSLOG_PACKET_LEN,\r
- Level,\r
- Module,\r
- File,\r
- Line,\r
- Message\r
- );\r
-\r
- mSyslogPacketSeq++;\r
- Status = SyslogSendPacket (Packet, Len);\r
- gBS->FreePool (Packet);\r
-\r
-ON_EXIT:\r
- gBS->FreePool (Message);\r
- return Status;\r
-}\r
UINT32 Count;\r
IP4_ADDR Ip;\r
\r
- Token = NetAllocatePool (sizeof (UDP_TX_TOKEN) +\r
+ Token = AllocatePool (sizeof (UDP_TX_TOKEN) +\r
sizeof (EFI_UDP4_FRAGMENT_DATA) * (Packet->BlockOpNum - 1));\r
\r
if (Token == NULL) {\r
}\r
\r
Token->Signature = UDP_IO_TX_SIGNATURE;\r
- NetListInit (&Token->Link);\r
+ InitializeListHead (&Token->Link);\r
\r
Token->UdpIo = UdpIo;\r
Token->CallBack = CallBack;\r
\r
Status = gBS->CreateEvent (\r
EVT_NOTIFY_SIGNAL,\r
- NET_TPL_EVENT,\r
+ TPL_NOTIFY,\r
UdpIoOnDgramSent,\r
Token,\r
&UdpToken->Event\r
);\r
\r
if (EFI_ERROR (Status)) {\r
- NetFreePool (Token);\r
+ gBS->FreePool (Token);\r
return NULL;\r
}\r
\r
\r
if (EndPoint != NULL) {\r
Ip = HTONL (EndPoint->LocalAddr);\r
- NetCopyMem (&Token->UdpSession.SourceAddress, &Ip, sizeof (EFI_IPv4_ADDRESS));\r
+ CopyMem (&Token->UdpSession.SourceAddress, &Ip, sizeof (EFI_IPv4_ADDRESS));\r
\r
Ip = HTONL (EndPoint->RemoteAddr);\r
- NetCopyMem (&Token->UdpSession.DestinationAddress, &Ip, sizeof (EFI_IPv4_ADDRESS));\r
+ CopyMem (&Token->UdpSession.DestinationAddress, &Ip, sizeof (EFI_IPv4_ADDRESS));\r
\r
Token->UdpSession.SourcePort = EndPoint->LocalPort;\r
Token->UdpSession.DestinationPort = EndPoint->RemotePort;\r
\r
if (Gateway != 0) {\r
Ip = HTONL (Gateway);\r
- NetCopyMem (&Token->Gateway, &Ip, sizeof (EFI_IPv4_ADDRESS));\r
+ CopyMem (&Token->Gateway, &Ip, sizeof (EFI_IPv4_ADDRESS));\r
\r
UdpTxData->GatewayAddress = &Token->Gateway;\r
}\r
)\r
{\r
gBS->CloseEvent (Token->UdpToken.Event);\r
- NetFreePool (Token);\r
+ gBS->FreePool (Token);\r
}\r
\r
\r
UDP_RX_TOKEN *Token;\r
EFI_STATUS Status;\r
\r
- Token = NetAllocatePool (sizeof (UDP_RX_TOKEN));\r
+ Token = AllocatePool (sizeof (UDP_RX_TOKEN));\r
\r
if (Token == NULL) {\r
return NULL;\r
\r
Status = gBS->CreateEvent (\r
EVT_NOTIFY_SIGNAL,\r
- NET_TPL_EVENT,\r
+ TPL_NOTIFY,\r
UdpIoOnDgramRcvd,\r
Token,\r
&Token->UdpToken.Event\r
);\r
\r
if (EFI_ERROR (Status)) {\r
- NetFreePool (Token);\r
+ gBS->FreePool (Token);\r
return NULL;\r
}\r
\r
)\r
{\r
gBS->CloseEvent (Token->UdpToken.Event);\r
- NetFreePool (Token);\r
+ gBS->FreePool (Token);\r
}\r
\r
\r
\r
ASSERT (Configure != NULL);\r
\r
- UdpIo = NetAllocatePool (sizeof (UDP_IO_PORT));\r
+ UdpIo = AllocatePool (sizeof (UDP_IO_PORT));\r
\r
if (UdpIo == NULL) {\r
return NULL;\r
}\r
\r
UdpIo->Signature = UDP_IO_SIGNATURE;\r
- NetListInit (&UdpIo->Link);\r
+ InitializeListHead (&UdpIo->Link);\r
UdpIo->RefCnt = 1;\r
\r
UdpIo->Controller = Controller;\r
UdpIo->Image = Image;\r
\r
- NetListInit (&UdpIo->SentDatagram);\r
+ InitializeListHead (&UdpIo->SentDatagram);\r
UdpIo->RecvRequest = NULL;\r
UdpIo->UdpHandle = NULL;\r
\r
);\r
\r
FREE_MEM:\r
- NetFreePool (UdpIo);\r
+ gBS->FreePool (UdpIo);\r
return NULL;\r
}\r
\r
IN VOID *Context\r
)\r
{\r
- NET_LIST_ENTRY *Entry;\r
- NET_LIST_ENTRY *Next;\r
+ LIST_ENTRY *Entry;\r
+ LIST_ENTRY *Next;\r
UDP_TX_TOKEN *Token;\r
\r
NET_LIST_FOR_EACH_SAFE (Entry, Next, &UdpIo->SentDatagram) {\r
);\r
\r
if (!IsListEmpty(&UdpIo->Link)) {\r
- NetListRemoveEntry (&UdpIo->Link);\r
+ RemoveEntryList (&UdpIo->Link);\r
}\r
\r
- NetFreePool (UdpIo);\r
+ gBS->FreePool (UdpIo);\r
return EFI_SUCCESS;\r
}\r
\r
Token = (UDP_TX_TOKEN *) Context;\r
ASSERT (Token->Signature == UDP_IO_TX_SIGNATURE);\r
\r
- NetListRemoveEntry (&Token->Link);\r
+ RemoveEntryList (&Token->Link);\r
Token->CallBack (Token->Packet, NULL, Token->UdpToken.Status, Token->Context);\r
\r
UdpIoFreeTxToken (Token);\r
// Insert the tx token into SendDatagram list before transmitting it. Remove\r
// it from the list if the returned status is not EFI_SUCCESS.\r
//\r
- NetListInsertHead (&UdpIo->SentDatagram, &Token->Link);\r
+ InsertHeadList (&UdpIo->SentDatagram, &Token->Link);\r
Status = UdpIo->Udp->Transmit (UdpIo->Udp, &Token->UdpToken);\r
if (EFI_ERROR (Status)) {\r
- NetListRemoveEntry (&Token->Link);\r
+ RemoveEntryList (&Token->Link);\r
UdpIoFreeTxToken (Token);\r
return Status;\r
}\r
Points.LocalPort = UdpSession->DestinationPort;\r
Points.RemotePort = UdpSession->SourcePort;\r
\r
- NetCopyMem (&Points.LocalAddr, &UdpSession->DestinationAddress, sizeof (IP4_ADDR));\r
- NetCopyMem (&Points.RemoteAddr, &UdpSession->SourceAddress, sizeof (IP4_ADDR));\r
+ CopyMem (&Points.LocalAddr, &UdpSession->DestinationAddress, sizeof (IP4_ADDR));\r
+ CopyMem (&Points.RemoteAddr, &UdpSession->SourceAddress, sizeof (IP4_ADDR));\r
Points.LocalAddr = NTOHL (Points.LocalAddr);\r
Points.RemoteAddr = NTOHL (Points.RemoteAddr);\r
\r
+++ /dev/null
-/** @file\r
-\r
-Copyright (c) 2006, Intel Corporation\r
-All rights reserved. This program and the accompanying materials\r
-are licensed and made available under the terms and conditions of the BSD License\r
-which accompanies this distribution. The full text of the license may be found at\r
-http://opensource.org/licenses/bsd-license.php\r
-\r
-THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
-WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
-\r
-Module Name:\r
-\r
- ArpDebug.h\r
-\r
-Abstract:\r
-\r
-\r
-**/\r
-\r
-#ifndef _ARP_DEBUG_H_\r
-#define _ARP_DEBUG_H_\r
-\r
-\r
-#define ARP_DEBUG_TRACE(PrintArg) NET_DEBUG_TRACE ("Arp", PrintArg)\r
-#define ARP_DEBUG_WARN(PrintArg) NET_DEBUG_WARNING ("Arp", PrintArg)\r
-#define ARP_DEBUG_ERROR(PrintArg) NET_DEBUG_ERROR ("Arp", PrintArg)\r
-\r
-#endif\r
-\r
/** @file\r
\r
-Copyright (c) 2006 - 2007, Intel Corporation \r
+Copyright (c) 2006 - 2007, Intel Corporation\r
All rights reserved. This program and the accompanying materials\r
are licensed and made available under the terms and conditions of the BSD License\r
which accompanies this distribution. The full text of the license may be found at\r
//\r
Status = gBS->CreateEvent (\r
EVT_NOTIFY_SIGNAL,\r
- NET_TPL_EVENT,\r
+ TPL_NOTIFY,\r
ArpOnFrameRcvd,\r
ArpService,\r
&ArpService->RxToken.Event\r
//\r
Status = gBS->CreateEvent (\r
EVT_NOTIFY_SIGNAL | EVT_TIMER,\r
- NET_TPL_TIMER,\r
+ TPL_CALLBACK,\r
ArpTimerHandler,\r
ArpService,\r
&ArpService->PeriodicTimer\r
//\r
// Init the lists.\r
//\r
- NetListInit (&ArpService->ChildrenList);\r
- NetListInit (&ArpService->PendingRequestTable);\r
- NetListInit (&ArpService->DeniedCacheTable);\r
- NetListInit (&ArpService->ResolvedCacheTable);\r
+ InitializeListHead (&ArpService->ChildrenList);\r
+ InitializeListHead (&ArpService->PendingRequestTable);\r
+ InitializeListHead (&ArpService->DeniedCacheTable);\r
+ InitializeListHead (&ArpService->ResolvedCacheTable);\r
\r
ERROR_EXIT:\r
\r
//\r
// Allocate a zero pool for ArpService.\r
//\r
- ArpService = NetAllocateZeroPool (sizeof(ARP_SERVICE_DATA));\r
+ ArpService = AllocateZeroPool (sizeof(ARP_SERVICE_DATA));\r
if (ArpService == NULL) {\r
return EFI_OUT_OF_RESOURCES;\r
}\r
// On error, clean the arp service context data, and free the memory allocated.\r
//\r
ArpCleanService (ArpService);\r
- NetFreePool (ArpService);\r
+ gBS->FreePool (ArpService);\r
\r
return Status;\r
}\r
EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
);\r
if (EFI_ERROR (Status)) {\r
- ARP_DEBUG_ERROR (("ArpDriverBindingStop: Open ArpSb failed, %r.\n", Status));\r
+ DEBUG ((EFI_D_ERROR, "ArpDriverBindingStop: Open ArpSb failed, %r.\n", Status));\r
return EFI_DEVICE_ERROR;\r
}\r
\r
//\r
ArpCleanService (ArpService);\r
\r
- NetFreePool (ArpService);\r
+ gBS->FreePool (ArpService);\r
} else {\r
\r
- while (!NetListIsEmpty (&ArpService->ChildrenList)) {\r
+ while (!IsListEmpty (&ArpService->ChildrenList)) {\r
Instance = NET_LIST_HEAD (&ArpService->ChildrenList, ARP_INSTANCE_DATA, List);\r
\r
ServiceBinding->DestroyChild (ServiceBinding, Instance->Handle);\r
}\r
\r
- ASSERT (NetListIsEmpty (&ArpService->PendingRequestTable));\r
- ASSERT (NetListIsEmpty (&ArpService->DeniedCacheTable));\r
- ASSERT (NetListIsEmpty (&ArpService->ResolvedCacheTable));\r
+ ASSERT (IsListEmpty (&ArpService->PendingRequestTable));\r
+ ASSERT (IsListEmpty (&ArpService->DeniedCacheTable));\r
+ ASSERT (IsListEmpty (&ArpService->ResolvedCacheTable));\r
}\r
\r
return EFI_SUCCESS;\r
//\r
// Allocate memory for the instance context data.\r
//\r
- Instance = NetAllocateZeroPool (sizeof(ARP_INSTANCE_DATA));\r
+ Instance = AllocateZeroPool (sizeof(ARP_INSTANCE_DATA));\r
if (Instance == NULL) {\r
- ARP_DEBUG_ERROR (("ArpSBCreateChild: Failed to allocate memory for Instance.\n"));\r
+ DEBUG ((EFI_D_ERROR, "ArpSBCreateChild: Failed to allocate memory for Instance.\n"));\r
\r
return EFI_OUT_OF_RESOURCES;\r
}\r
NULL\r
);\r
if (EFI_ERROR (Status)) {\r
- ARP_DEBUG_ERROR (("ArpSBCreateChild: faild to install ARP protocol, %r.\n", Status));\r
+ DEBUG ((EFI_D_ERROR, "ArpSBCreateChild: faild to install ARP protocol, %r.\n", Status));\r
\r
- NetFreePool (Instance);\r
+ gBS->FreePool (Instance);\r
return Status;\r
}\r
\r
goto ERROR;\r
}\r
\r
- OldTpl = NET_RAISE_TPL (NET_TPL_LOCK);\r
+ OldTpl = gBS->RaiseTPL (TPL_CALLBACK);\r
\r
//\r
// Insert the instance into children list managed by the arp service context data.\r
//\r
- NetListInsertTail (&ArpService->ChildrenList, &Instance->List);\r
+ InsertTailList (&ArpService->ChildrenList, &Instance->List);\r
ArpService->ChildrenNumber++;\r
\r
- NET_RESTORE_TPL (OldTpl);\r
+ gBS->RestoreTPL (OldTpl);\r
\r
ERROR:\r
\r
//\r
// Free the allocated memory.\r
//\r
- NetFreePool (Instance);\r
+ gBS->FreePool (Instance);\r
}\r
\r
return Status;\r
NULL\r
);\r
if (EFI_ERROR (Status)) {\r
- ARP_DEBUG_ERROR (("ArpSBDestroyChild: Failed to uninstall the arp protocol, %r.\n",\r
+ DEBUG ((EFI_D_ERROR, "ArpSBDestroyChild: Failed to uninstall the arp protocol, %r.\n",\r
Status));\r
\r
Instance->Destroyed = FALSE;\r
return Status;\r
}\r
\r
- OldTpl = NET_RAISE_TPL (NET_TPL_LOCK);\r
+ OldTpl = gBS->RaiseTPL (TPL_CALLBACK);\r
\r
if (Instance->Configured) {\r
//\r
//\r
// Remove this instance from the ChildrenList.\r
//\r
- NetListRemoveEntry (&Instance->List);\r
+ RemoveEntryList (&Instance->List);\r
ArpService->ChildrenNumber--;\r
\r
- NET_RESTORE_TPL (OldTpl);\r
+ gBS->RestoreTPL (OldTpl);\r
\r
- NetFreePool (Instance);\r
+ gBS->FreePool (Instance);\r
\r
return Status;\r
}\r
#include <Library/UefiBootServicesTableLib.h>\r
#include <Library/UefiLib.h>\r
\r
-#include "ArpDebug.h"\r
\r
//\r
// Global variables\r
ComponentName.c\r
ArpImpl.h\r
ArpImpl.c\r
- ArpDebug.h\r
ArpDriver.c\r
\r
\r
</LibraryClassDefinitions>\r
<SourceFiles>\r
<Filename>ArpDriver.c</Filename>\r
- <Filename>ArpDebug.h</Filename>\r
<Filename>ArpImpl.c</Filename>\r
<Filename>ArpImpl.h</Filename>\r
<Filename>ComponentName.c</Filename>\r
\r
\r
#include "ArpImpl.h"\r
-#include "ArpDebug.h"\r
\r
EFI_ARP_PROTOCOL mEfiArpProtocolTemplate = {\r
ArpConfigure,\r
Instance->Configured = FALSE;\r
Instance->Destroyed = FALSE;\r
\r
- NetListInit (&Instance->List);\r
+ InitializeListHead (&Instance->List);\r
}\r
\r
\r
ARP_HEAD *Head;\r
ARP_ADDRESS ArpAddress;\r
ARP_CACHE_ENTRY *CacheEntry;\r
- NET_LIST_ENTRY *Entry;\r
+ LIST_ENTRY *Entry;\r
ARP_INSTANCE_DATA *Instance;\r
EFI_ARP_CONFIG_DATA *ConfigData;\r
NET_ARP_ADDRESS SenderAddress[2];\r
// The protocol type is matched for the received arp packet.\r
//\r
ProtoMatched = TRUE;\r
- if (0 == NetCompareMem (\r
+ if (0 == CompareMem (\r
(VOID *)ArpAddress.TargetProtoAddr,\r
ConfigData->StationAddress,\r
ConfigData->SwAddressLength\r
}\r
\r
if (!IsListEmpty (&CacheEntry->List)) {\r
- NetListRemoveEntry (&CacheEntry->List);\r
+ RemoveEntryList (&CacheEntry->List);\r
}\r
\r
//\r
//\r
// Add this entry into the ResolvedCacheTable\r
//\r
- NetListInsertHead (&ArpService->ResolvedCacheTable, &CacheEntry->List);\r
+ InsertHeadList (&ArpService->ResolvedCacheTable, &CacheEntry->List);\r
}\r
\r
if (Head->OpCode == ARP_OPCODE_REQUEST) {\r
\r
DEBUG_CODE (\r
if (EFI_ERROR (Status)) {\r
- ARP_DEBUG_ERROR (("ArpOnFrameRcvd: ArpService->Mnp->Receive "\r
+ DEBUG ((EFI_D_ERROR, "ArpOnFrameRcvd: ArpService->Mnp->Receive "\r
"failed, %r\n.", Status));\r
}\r
);\r
\r
DEBUG_CODE (\r
if (EFI_ERROR (TxToken->Status)) {\r
- ARP_DEBUG_ERROR (("ArpOnFrameSent: TxToken->Status, %r.\n", TxToken->Status));\r
+ DEBUG ((EFI_D_ERROR, "ArpOnFrameSent: TxToken->Status, %r.\n", TxToken->Status));\r
}\r
);\r
\r
//\r
// Free the allocated memory and close the event.\r
//\r
- NetFreePool (TxData->FragmentTable[0].FragmentBuffer);\r
- NetFreePool (TxData);\r
+ gBS->FreePool (TxData->FragmentTable[0].FragmentBuffer);\r
+ gBS->FreePool (TxData);\r
gBS->CloseEvent (TxToken->Event);\r
- NetFreePool (TxToken);\r
+ gBS->FreePool (TxToken);\r
}\r
\r
/**\r
)\r
{\r
ARP_SERVICE_DATA *ArpService;\r
- NET_LIST_ENTRY *Entry;\r
- NET_LIST_ENTRY *NextEntry;\r
- NET_LIST_ENTRY *ContextEntry;\r
+ LIST_ENTRY *Entry;\r
+ LIST_ENTRY *NextEntry;\r
+ LIST_ENTRY *ContextEntry;\r
ARP_CACHE_ENTRY *CacheEntry;\r
USER_REQUEST_CONTEXT *RequestContext;\r
\r
// Abort this request.\r
//\r
ArpAddressResolved (CacheEntry, NULL, NULL);\r
- ASSERT (NetListIsEmpty (&CacheEntry->UserRequestList));\r
+ ASSERT (IsListEmpty (&CacheEntry->UserRequestList));\r
\r
- NetListRemoveEntry (&CacheEntry->List);\r
- NetFreePool (CacheEntry);\r
+ RemoveEntryList (&CacheEntry->List);\r
+ gBS->FreePool (CacheEntry);\r
} else {\r
//\r
// resend the ARP request.\r
//\r
- ASSERT (!NetListIsEmpty(&CacheEntry->UserRequestList));\r
+ ASSERT (!IsListEmpty(&CacheEntry->UserRequestList));\r
\r
ContextEntry = CacheEntry->UserRequestList.ForwardLink;\r
RequestContext = NET_LIST_USER_STRUCT (ContextEntry, USER_REQUEST_CONTEXT, List);\r
//\r
NET_LIST_FOR_EACH_SAFE (Entry, NextEntry, &ArpService->DeniedCacheTable) {\r
CacheEntry = NET_LIST_USER_STRUCT (Entry, ARP_CACHE_ENTRY, List);\r
- ASSERT (NetListIsEmpty (&CacheEntry->UserRequestList));\r
+ ASSERT (IsListEmpty (&CacheEntry->UserRequestList));\r
\r
if (CacheEntry->DefaultDecayTime == 0) {\r
//\r
//\r
// Time out, remove it.\r
//\r
- NetListRemoveEntry (&CacheEntry->List);\r
- NetFreePool (CacheEntry);\r
+ RemoveEntryList (&CacheEntry->List);\r
+ gBS->FreePool (CacheEntry);\r
} else {\r
//\r
// Update the DecayTime.\r
//\r
NET_LIST_FOR_EACH_SAFE (Entry, NextEntry, &ArpService->ResolvedCacheTable) {\r
CacheEntry = NET_LIST_USER_STRUCT (Entry, ARP_CACHE_ENTRY, List);\r
- ASSERT (NetListIsEmpty (&CacheEntry->UserRequestList));\r
+ ASSERT (IsListEmpty (&CacheEntry->UserRequestList));\r
\r
if (CacheEntry->DefaultDecayTime == 0) {\r
//\r
//\r
// Time out, remove it.\r
//\r
- NetListRemoveEntry (&CacheEntry->List);\r
- NetFreePool (CacheEntry);\r
+ RemoveEntryList (&CacheEntry->List);\r
+ gBS->FreePool (CacheEntry);\r
} else {\r
//\r
// Update the DecayTime.\r
}\r
\r
if ((AddressOne->AddressPtr != NULL) &&\r
- (NetCompareMem (\r
+ (CompareMem (\r
AddressOne->AddressPtr,\r
AddressTwo->AddressPtr,\r
AddressOne->Length\r
**/\r
ARP_CACHE_ENTRY *\r
ArpFindNextCacheEntryInTable (\r
- IN NET_LIST_ENTRY *CacheTable,\r
- IN NET_LIST_ENTRY *StartEntry,\r
+ IN LIST_ENTRY *CacheTable,\r
+ IN LIST_ENTRY *StartEntry,\r
IN FIND_OPTYPE FindOpType,\r
IN NET_ARP_ADDRESS *ProtocolAddress OPTIONAL,\r
IN NET_ARP_ADDRESS *HardwareAddress OPTIONAL\r
)\r
{\r
- NET_LIST_ENTRY *Entry;\r
+ LIST_ENTRY *Entry;\r
ARP_CACHE_ENTRY *CacheEntry;\r
\r
if (StartEntry == NULL) {\r
//\r
// Allocate memory for the cache entry.\r
//\r
- CacheEntry = NetAllocatePool (sizeof (ARP_CACHE_ENTRY));\r
+ CacheEntry = AllocatePool (sizeof (ARP_CACHE_ENTRY));\r
if (CacheEntry == NULL) {\r
return NULL;\r
}\r
//\r
// Init the lists.\r
//\r
- NetListInit (&CacheEntry->List);\r
- NetListInit (&CacheEntry->UserRequestList);\r
+ InitializeListHead (&CacheEntry->List);\r
+ InitializeListHead (&CacheEntry->UserRequestList);\r
\r
for (Index = 0; Index < 2; Index++) {\r
//\r
//\r
// Zero the hardware address first.\r
//\r
- NetZeroMem (CacheEntry->Addresses[Hardware].AddressPtr, ARP_MAX_HARDWARE_ADDRESS_LEN);\r
+ ZeroMem (CacheEntry->Addresses[Hardware].AddressPtr, ARP_MAX_HARDWARE_ADDRESS_LEN);\r
\r
if (Instance != NULL) {\r
//\r
IN EFI_EVENT UserEvent OPTIONAL\r
)\r
{\r
- NET_LIST_ENTRY *Entry;\r
- NET_LIST_ENTRY *NextEntry;\r
+ LIST_ENTRY *Entry;\r
+ LIST_ENTRY *NextEntry;\r
USER_REQUEST_CONTEXT *Context;\r
UINTN Count;\r
\r
//\r
// Copy the address to the user-provided buffer and notify the user.\r
//\r
- NetCopyMem (\r
+ CopyMem (\r
Context->UserHwAddrBuffer,\r
CacheEntry->Addresses[Hardware].AddressPtr,\r
CacheEntry->Addresses[Hardware].Length\r
//\r
// Remove this user request and free the context data.\r
//\r
- NetListRemoveEntry (&Context->List);\r
- NetFreePool (Context);\r
+ RemoveEntryList (&Context->List);\r
+ gBS->FreePool (Context);\r
\r
Count++;\r
}\r
//\r
// Copy it if the AddressPtr points to some buffer.\r
//\r
- NetCopyMem (\r
+ CopyMem (\r
CacheAddress->AddressPtr,\r
Address[Index]->AddressPtr,\r
CacheAddress->Length\r
//\r
// Zero the corresponding address buffer in the CacheEntry.\r
//\r
- NetZeroMem (CacheAddress->AddressPtr, CacheAddress->Length);\r
+ ZeroMem (CacheAddress->AddressPtr, CacheAddress->Length);\r
}\r
}\r
}\r
//\r
if ((OldConfigData->SwAddressType != ConfigData->SwAddressType) ||\r
(OldConfigData->SwAddressLength != ConfigData->SwAddressLength) ||\r
- (NetCompareMem (\r
+ (CompareMem (\r
OldConfigData->StationAddress,\r
ConfigData->StationAddress,\r
OldConfigData->SwAddressLength\r
//\r
\r
if (ConfigData->SwAddressType == IPv4_ETHER_PROTO_TYPE) {\r
- NetCopyMem (&Ip, ConfigData->StationAddress, sizeof (IP4_ADDR));\r
+ CopyMem (&Ip, ConfigData->StationAddress, sizeof (IP4_ADDR));\r
\r
if (!Ip4IsUnicast (NTOHL (Ip), 0)) {\r
//\r
//\r
CopyMem (OldConfigData, ConfigData, sizeof (*OldConfigData));\r
\r
- OldConfigData->StationAddress = NetAllocatePool (OldConfigData->SwAddressLength);\r
+ OldConfigData->StationAddress = AllocatePool (OldConfigData->SwAddressLength);\r
if (OldConfigData->StationAddress == NULL) {\r
- ARP_DEBUG_ERROR (("ArpConfigInstance: NetAllocatePool for the StationAddress "\r
+ DEBUG ((EFI_D_ERROR, "ArpConfigInstance: AllocatePool for the StationAddress "\r
"failed.\n"));\r
return EFI_OUT_OF_RESOURCES;\r
}\r
//\r
// Save the StationAddress.\r
//\r
- NetCopyMem (\r
+ CopyMem (\r
OldConfigData->StationAddress,\r
ConfigData->StationAddress,\r
OldConfigData->SwAddressLength\r
//\r
// Free the buffer previously allocated to hold the station address.\r
//\r
- NetFreePool (OldConfigData->StationAddress);\r
+ gBS->FreePool (OldConfigData->StationAddress);\r
}\r
\r
Instance->Configured = FALSE;\r
//\r
// Allocate memory for the TxToken.\r
//\r
- TxToken = NetAllocatePool (sizeof(EFI_MANAGED_NETWORK_COMPLETION_TOKEN));\r
+ TxToken = AllocatePool (sizeof(EFI_MANAGED_NETWORK_COMPLETION_TOKEN));\r
if (TxToken == NULL) {\r
- ARP_DEBUG_ERROR (("ArpSendFrame: Allocate memory for TxToken failed.\n"));\r
+ DEBUG ((EFI_D_ERROR, "ArpSendFrame: Allocate memory for TxToken failed.\n"));\r
return;\r
}\r
\r
//\r
Status = gBS->CreateEvent (\r
EVT_NOTIFY_SIGNAL,\r
- NET_TPL_EVENT,\r
+ TPL_NOTIFY,\r
ArpOnFrameSent,\r
(VOID *)TxToken,\r
&TxToken->Event\r
);\r
if (EFI_ERROR (Status)) {\r
- ARP_DEBUG_ERROR (("ArpSendFrame: CreateEvent failed for TxToken->Event.\n"));\r
+ DEBUG ((EFI_D_ERROR, "ArpSendFrame: CreateEvent failed for TxToken->Event.\n"));\r
goto CLEAN_EXIT;\r
}\r
\r
//\r
// Allocate memory for the TxData used in the TxToken.\r
//\r
- TxData = NetAllocatePool (sizeof(EFI_MANAGED_NETWORK_TRANSMIT_DATA));\r
+ TxData = AllocatePool (sizeof(EFI_MANAGED_NETWORK_TRANSMIT_DATA));\r
if (TxData == NULL) {\r
- ARP_DEBUG_ERROR (("ArpSendFrame: Allocate memory for TxData failed.\n"));\r
+ DEBUG ((EFI_D_ERROR, "ArpSendFrame: Allocate memory for TxData failed.\n"));\r
goto CLEAN_EXIT;\r
}\r
\r
//\r
// Allocate buffer for the arp frame.\r
//\r
- Packet = NetAllocatePool (TotalLength);\r
+ Packet = AllocatePool (TotalLength);\r
if (Packet == NULL) {\r
- ARP_DEBUG_ERROR (("ArpSendFrame: Allocate memory for Packet failed.\n"));\r
+ DEBUG ((EFI_D_ERROR, "ArpSendFrame: Allocate memory for Packet failed.\n"));\r
}\r
\r
TmpPtr = Packet;\r
// The destination MAC address.\r
//\r
if (ArpOpCode == ARP_OPCODE_REQUEST) {\r
- NetCopyMem (TmpPtr, &SnpMode->BroadcastAddress, SnpMode->HwAddressSize);\r
+ CopyMem (TmpPtr, &SnpMode->BroadcastAddress, SnpMode->HwAddressSize);\r
} else {\r
- NetCopyMem (\r
+ CopyMem (\r
TmpPtr,\r
CacheEntry->Addresses[Hardware].AddressPtr,\r
SnpMode->HwAddressSize\r
//\r
// The source MAC address.\r
//\r
- NetCopyMem (TmpPtr, &SnpMode->CurrentAddress, SnpMode->HwAddressSize);\r
+ CopyMem (TmpPtr, &SnpMode->CurrentAddress, SnpMode->HwAddressSize);\r
TmpPtr += SnpMode->HwAddressSize;\r
\r
//\r
//\r
// The sender hardware address.\r
//\r
- NetCopyMem (TmpPtr, &SnpMode->CurrentAddress, SnpMode->HwAddressSize);\r
+ CopyMem (TmpPtr, &SnpMode->CurrentAddress, SnpMode->HwAddressSize);\r
TmpPtr += SnpMode->HwAddressSize;\r
\r
//\r
// The sender protocol address.\r
//\r
- NetCopyMem (TmpPtr, ConfigData->StationAddress, ConfigData->SwAddressLength);\r
+ CopyMem (TmpPtr, ConfigData->StationAddress, ConfigData->SwAddressLength);\r
TmpPtr += ConfigData->SwAddressLength;\r
\r
//\r
// The target hardware address.\r
//\r
- NetCopyMem (\r
+ CopyMem (\r
TmpPtr,\r
CacheEntry->Addresses[Hardware].AddressPtr,\r
SnpMode->HwAddressSize\r
//\r
// The target protocol address.\r
//\r
- NetCopyMem (\r
+ CopyMem (\r
TmpPtr,\r
CacheEntry->Addresses[Protocol].AddressPtr,\r
ConfigData->SwAddressLength\r
//\r
Status = ArpService->Mnp->Transmit (ArpService->Mnp, TxToken);\r
if (EFI_ERROR (Status)) {\r
- ARP_DEBUG_ERROR (("Mnp->Transmit failed, %r.\n", Status));\r
+ DEBUG ((EFI_D_ERROR, "Mnp->Transmit failed, %r.\n", Status));\r
goto CLEAN_EXIT;\r
}\r
\r
CLEAN_EXIT:\r
\r
if (Packet != NULL) {\r
- NetFreePool (Packet);\r
+ gBS->FreePool (Packet);\r
}\r
\r
if (TxData != NULL) {\r
- NetFreePool (TxData);\r
+ gBS->FreePool (TxData);\r
}\r
\r
if (TxToken->Event != NULL) {\r
gBS->CloseEvent (TxToken->Event);\r
}\r
\r
- NetFreePool (TxToken);\r
+ gBS->FreePool (TxToken);\r
}\r
\r
\r
STATIC\r
UINTN\r
ArpDeleteCacheEntryInTable (\r
- IN NET_LIST_ENTRY *CacheTable,\r
+ IN LIST_ENTRY *CacheTable,\r
IN BOOLEAN BySwAddress,\r
IN UINT16 SwAddressType,\r
IN UINT8 *AddressBuffer OPTIONAL,\r
IN BOOLEAN Force\r
)\r
{\r
- NET_LIST_ENTRY *Entry;\r
- NET_LIST_ENTRY *NextEntry;\r
+ LIST_ENTRY *Entry;\r
+ LIST_ENTRY *NextEntry;\r
ARP_CACHE_ENTRY *CacheEntry;\r
UINTN Count;\r
\r
// Protocol address type matched. Check the address.\r
//\r
if ((AddressBuffer == NULL) ||\r
- (NetCompareMem (\r
+ (CompareMem (\r
AddressBuffer,\r
CacheEntry->Addresses[Protocol].AddressPtr,\r
CacheEntry->Addresses[Protocol].Length\r
}\r
} else {\r
if ((AddressBuffer == NULL) ||\r
- (NetCompareMem (\r
+ (CompareMem (\r
AddressBuffer,\r
CacheEntry->Addresses[Hardware].AddressPtr,\r
CacheEntry->Addresses[Hardware].Length\r
//\r
// Delete this entry.\r
//\r
- NetListRemoveEntry (&CacheEntry->List);\r
- ASSERT (NetListIsEmpty (&CacheEntry->UserRequestList));\r
- NetFreePool (CacheEntry);\r
+ RemoveEntryList (&CacheEntry->List);\r
+ ASSERT (IsListEmpty (&CacheEntry->UserRequestList));\r
+ gBS->FreePool (CacheEntry);\r
\r
Count++;\r
}\r
)\r
{\r
ARP_SERVICE_DATA *ArpService;\r
- NET_LIST_ENTRY *Entry;\r
- NET_LIST_ENTRY *NextEntry;\r
+ LIST_ENTRY *Entry;\r
+ LIST_ENTRY *NextEntry;\r
ARP_CACHE_ENTRY *CacheEntry;\r
UINTN Count;\r
\r
CacheEntry = NET_LIST_USER_STRUCT (Entry, ARP_CACHE_ENTRY, List);\r
\r
if ((TargetSwAddress == NULL) ||\r
- (NetCompareMem (\r
+ (CompareMem (\r
TargetSwAddress,\r
CacheEntry->Addresses[Protocol].AddressPtr,\r
CacheEntry->Addresses[Protocol].Length\r
//\r
Count += ArpAddressResolved (CacheEntry, Instance, UserEvent);\r
\r
- if (NetListIsEmpty (&CacheEntry->UserRequestList)) {\r
+ if (IsListEmpty (&CacheEntry->UserRequestList)) {\r
//\r
// No user requests any more, remove this request cache entry.\r
//\r
- NetListRemoveEntry (&CacheEntry->List);\r
- NetFreePool (CacheEntry);\r
+ RemoveEntryList (&CacheEntry->List);\r
+ gBS->FreePool (CacheEntry);\r
}\r
}\r
}\r
ARP_SERVICE_DATA *ArpService;\r
NET_ARP_ADDRESS MatchAddress;\r
FIND_OPTYPE FindOpType;\r
- NET_LIST_ENTRY *StartEntry;\r
+ LIST_ENTRY *StartEntry;\r
ARP_CACHE_ENTRY *CacheEntry;\r
NET_MAP FoundEntries;\r
UINT32 FoundCount;\r
EFI_ARP_FIND_DATA *FindData;\r
- NET_LIST_ENTRY *CacheTable;\r
+ LIST_ENTRY *CacheTable;\r
\r
ArpService = Instance->ArpService;\r
\r
//\r
// Allocate buffer to copy the found entries.\r
//\r
- FindData = NetAllocatePool (FoundCount * (*EntryLength));\r
+ FindData = AllocatePool (FoundCount * (*EntryLength));\r
if (FindData == NULL) {\r
- ARP_DEBUG_ERROR (("ArpFindCacheEntry: Failed to allocate memory.\n"));\r
+ DEBUG ((EFI_D_ERROR, "ArpFindCacheEntry: Failed to allocate memory.\n"));\r
Status = EFI_OUT_OF_RESOURCES;\r
goto CLEAN_EXIT;\r
}\r
//\r
// Copy the software address.\r
//\r
- NetCopyMem (\r
+ CopyMem (\r
FindData + 1,\r
CacheEntry->Addresses[Protocol].AddressPtr,\r
FindData->SwAddressLength\r
//\r
// Copy the hardware address.\r
//\r
- NetCopyMem (\r
+ CopyMem (\r
(UINT8 *)(FindData + 1) + FindData->SwAddressLength,\r
CacheEntry->Addresses[Hardware].AddressPtr,\r
FindData->HwAddressLength\r
#include <Library/BaseMemoryLib.h>\r
#include <Library/MemoryAllocationLib.h>\r
\r
-#include "ArpDebug.h"\r
\r
#define ARP_ETHER_PROTO_TYPE 0x0806\r
#define IPv4_ETHER_PROTO_TYPE 0x0800\r
ARP_SERVICE_DATA *ArpService;\r
EFI_HANDLE Handle;\r
EFI_ARP_PROTOCOL ArpProto;\r
- NET_LIST_ENTRY List;\r
+ LIST_ENTRY List;\r
EFI_ARP_CONFIG_DATA ConfigData;\r
BOOLEAN Configured;\r
BOOLEAN Destroyed;\r
EFI_SIMPLE_NETWORK_MODE SnpMode;\r
\r
UINTN ChildrenNumber;\r
- NET_LIST_ENTRY ChildrenList;\r
+ LIST_ENTRY ChildrenList;\r
\r
- NET_LIST_ENTRY PendingRequestTable;\r
- NET_LIST_ENTRY DeniedCacheTable;\r
- NET_LIST_ENTRY ResolvedCacheTable;\r
+ LIST_ENTRY PendingRequestTable;\r
+ LIST_ENTRY DeniedCacheTable;\r
+ LIST_ENTRY ResolvedCacheTable;\r
\r
EFI_EVENT PeriodicTimer;\r
};\r
\r
typedef struct _USER_REQUEST_CONTEXT {\r
- NET_LIST_ENTRY List;\r
+ LIST_ENTRY List;\r
ARP_INSTANCE_DATA *Instance;\r
EFI_EVENT UserRequestEvent;\r
VOID *UserHwAddrBuffer;\r
} ARP_ADDRESS_TYPE;\r
\r
typedef struct _ARP_CACHE_ENTRY {\r
- NET_LIST_ENTRY List;\r
+ LIST_ENTRY List;\r
\r
UINT32 RetryCount;\r
UINT32 DefaultDecayTime;\r
\r
NET_ARP_ADDRESS Addresses[2];\r
\r
- NET_LIST_ENTRY UserRequestList;\r
+ LIST_ENTRY UserRequestList;\r
} ARP_CACHE_ENTRY;\r
\r
EFI_STATUS\r
\r
ARP_CACHE_ENTRY *\r
ArpFindNextCacheEntryInTable (\r
- IN NET_LIST_ENTRY *CacheTable,\r
- IN NET_LIST_ENTRY *StartEntry,\r
+ IN LIST_ENTRY *CacheTable,\r
+ IN LIST_ENTRY *StartEntry,\r
IN FIND_OPTYPE FindOpType,\r
IN NET_ARP_ADDRESS *ProtocolAddress OPTIONAL,\r
IN NET_ARP_ADDRESS *HardwareAddress OPTIONAL\r
\r
Instance = ARP_INSTANCE_DATA_FROM_THIS (This);\r
\r
- OldTpl = NET_RAISE_TPL (NET_TPL_LOCK);\r
+ OldTpl = gBS->RaiseTPL (TPL_CALLBACK);\r
\r
//\r
// Configure this instance, the ConfigData has already passed the basic checks.\r
//\r
Status = ArpConfigureInstance (Instance, ConfigData);\r
\r
- NET_RESTORE_TPL (OldTpl);\r
+ gBS->RestoreTPL (OldTpl);\r
\r
return Status;\r
}\r
MatchAddress[Protocol].Length = Instance->ConfigData.SwAddressLength;\r
MatchAddress[Protocol].AddressPtr = TargetSwAddress;\r
\r
- OldTpl = NET_RAISE_TPL (NET_TPL_LOCK);\r
+ OldTpl = gBS->RaiseTPL (TPL_CALLBACK);\r
\r
//\r
// See whether the entry to add exists. Check the DeinedCacheTable first.\r
//\r
// Remove it from the Table.\r
//\r
- NetListRemoveEntry (&CacheEntry->List);\r
+ RemoveEntryList (&CacheEntry->List);\r
} else {\r
//\r
// It's a new entry, allocate memory for the entry.\r
CacheEntry = ArpAllocCacheEntry (Instance);\r
\r
if (CacheEntry == NULL) {\r
- ARP_DEBUG_ERROR (("ArpAdd: Failed to allocate pool for CacheEntry.\n"));\r
+ DEBUG ((EFI_D_ERROR, "ArpAdd: Failed to allocate pool for CacheEntry.\n"));\r
Status = EFI_OUT_OF_RESOURCES;\r
goto UNLOCK_EXIT;\r
}\r
// Add this CacheEntry to the corresponding CacheTable.\r
//\r
if (DenyFlag) {\r
- NetListInsertHead (&ArpService->DeniedCacheTable, &CacheEntry->List);\r
+ InsertHeadList (&ArpService->DeniedCacheTable, &CacheEntry->List);\r
} else {\r
- NetListInsertHead (&ArpService->ResolvedCacheTable, &CacheEntry->List);\r
+ InsertHeadList (&ArpService->ResolvedCacheTable, &CacheEntry->List);\r
}\r
\r
UNLOCK_EXIT:\r
\r
- NET_RESTORE_TPL (OldTpl);\r
+ gBS->RestoreTPL (OldTpl);\r
\r
return Status;\r
}\r
return EFI_NOT_STARTED;\r
}\r
\r
- OldTpl = NET_RAISE_TPL (NET_TPL_LOCK);\r
+ OldTpl = gBS->RaiseTPL (TPL_CALLBACK);\r
\r
//\r
// All the check passed, find the cache entries now.\r
Refresh\r
);\r
\r
- NET_RESTORE_TPL (OldTpl);\r
+ gBS->RestoreTPL (OldTpl);\r
\r
return Status;\r
}\r
return EFI_NOT_STARTED;\r
}\r
\r
- OldTpl = NET_RAISE_TPL (NET_TPL_LOCK);\r
+ OldTpl = gBS->RaiseTPL (TPL_CALLBACK);\r
\r
//\r
// Delete the specified cache entries.\r
//\r
Count = ArpDeleteCacheEntry (Instance, BySwAddress, AddressBuffer, TRUE);\r
\r
- NET_RESTORE_TPL (OldTpl);\r
+ gBS->RestoreTPL (OldTpl);\r
\r
return (Count == 0) ? EFI_NOT_FOUND : EFI_SUCCESS;\r
}\r
return EFI_NOT_STARTED;\r
}\r
\r
- OldTpl = NET_RAISE_TPL (NET_TPL_LOCK);\r
+ OldTpl = gBS->RaiseTPL (TPL_CALLBACK);\r
\r
//\r
// Delete the dynamic entries from the cache table.\r
//\r
Count = ArpDeleteCacheEntry (Instance, FALSE, NULL, FALSE);\r
\r
- NET_RESTORE_TPL (OldTpl);\r
+ gBS->RestoreTPL (OldTpl);\r
\r
return (Count == 0) ? EFI_NOT_FOUND : EFI_SUCCESS;\r
}\r
//\r
// Return the hardware broadcast address.\r
//\r
- NetCopyMem (TargetHwAddress, &SnpMode->BroadcastAddress, SnpMode->HwAddressSize);\r
+ CopyMem (TargetHwAddress, &SnpMode->BroadcastAddress, SnpMode->HwAddressSize);\r
\r
goto SIGNAL_USER;\r
}\r
//\r
// Initialize the TargetHwAddrss to a zero address.\r
//\r
- NetZeroMem (TargetHwAddress, SnpMode->HwAddressSize);\r
+ ZeroMem (TargetHwAddress, SnpMode->HwAddressSize);\r
\r
- OldTpl = NET_RAISE_TPL (NET_TPL_LOCK);\r
+ OldTpl = gBS->RaiseTPL (TPL_CALLBACK);\r
\r
//\r
// Check whether the software address is in the denied table.\r
//\r
// Resolved, copy the address into the user buffer.\r
//\r
- NetCopyMem (\r
+ CopyMem (\r
TargetHwAddress,\r
CacheEntry->Addresses[Hardware].AddressPtr,\r
CacheEntry->Addresses[Hardware].Length\r
//\r
// Create a request context for this arp request.\r
//\r
- RequestContext = NetAllocatePool (sizeof(USER_REQUEST_CONTEXT));\r
+ RequestContext = AllocatePool (sizeof(USER_REQUEST_CONTEXT));\r
if (RequestContext == NULL) {\r
- ARP_DEBUG_ERROR (("ArpRequest: Allocate memory for RequestContext failed.\n"));\r
+ DEBUG ((EFI_D_ERROR, "ArpRequest: Allocate memory for RequestContext failed.\n"));\r
\r
Status = EFI_OUT_OF_RESOURCES;\r
goto UNLOCK_EXIT;\r
RequestContext->Instance = Instance;\r
RequestContext->UserRequestEvent = ResolvedEvent;\r
RequestContext->UserHwAddrBuffer = TargetHwAddress;\r
- NetListInit (&RequestContext->List);\r
+ InitializeListHead (&RequestContext->List);\r
\r
//\r
// Check whether there is a same request.\r
//\r
CacheEntry = ArpAllocCacheEntry (Instance);\r
if (CacheEntry == NULL) {\r
- ARP_DEBUG_ERROR (("ArpRequest: Allocate memory for CacheEntry failed.\n"));\r
- NetFreePool (RequestContext);\r
+ DEBUG ((EFI_D_ERROR, "ArpRequest: Allocate memory for CacheEntry failed.\n"));\r
+ gBS->FreePool (RequestContext);\r
\r
Status = EFI_OUT_OF_RESOURCES;\r
goto UNLOCK_EXIT;\r
//\r
// Add this entry into the PendingRequestTable.\r
//\r
- NetListInsertTail (&ArpService->PendingRequestTable, &CacheEntry->List);\r
+ InsertTailList (&ArpService->PendingRequestTable, &CacheEntry->List);\r
}\r
\r
//\r
// Link this request context into the cache entry.\r
//\r
- NetListInsertHead (&CacheEntry->UserRequestList, &RequestContext->List);\r
+ InsertHeadList (&CacheEntry->UserRequestList, &RequestContext->List);\r
\r
//\r
// Send out the ARP Request frame.\r
\r
UNLOCK_EXIT:\r
\r
- NET_RESTORE_TPL (OldTpl);\r
+ gBS->RestoreTPL (OldTpl);\r
\r
SIGNAL_USER:\r
\r
return EFI_NOT_STARTED;\r
}\r
\r
- OldTpl = NET_RAISE_TPL (NET_TPL_LOCK);\r
+ OldTpl = gBS->RaiseTPL (TPL_CALLBACK);\r
\r
//\r
// Cancel the specified request.\r
//\r
NetLibDispatchDpc ();\r
\r
- NET_RESTORE_TPL (OldTpl);\r
+ gBS->RestoreTPL (OldTpl);\r
\r
return (Count == 0) ? EFI_NOT_FOUND : EFI_SUCCESS;\r
}\r
UdpConfigData.StationPort = DHCP_CLIENT_PORT;\r
UdpConfigData.RemotePort = DHCP_SERVER_PORT;\r
\r
- NetZeroMem (&UdpConfigData.StationAddress, sizeof (EFI_IPv4_ADDRESS));\r
- NetZeroMem (&UdpConfigData.SubnetMask, sizeof (EFI_IPv4_ADDRESS));\r
- NetZeroMem (&UdpConfigData.RemoteAddress, sizeof (EFI_IPv4_ADDRESS));\r
+ ZeroMem (&UdpConfigData.StationAddress, sizeof (EFI_IPv4_ADDRESS));\r
+ ZeroMem (&UdpConfigData.SubnetMask, sizeof (EFI_IPv4_ADDRESS));\r
+ ZeroMem (&UdpConfigData.RemoteAddress, sizeof (EFI_IPv4_ADDRESS));\r
\r
return UdpIo->Udp->Configure (UdpIo->Udp, &UdpConfigData);;\r
}\r
EFI_STATUS Status;\r
\r
*Service = NULL;\r
- DhcpSb = NetAllocateZeroPool (sizeof (DHCP_SERVICE));\r
+ DhcpSb = AllocateZeroPool (sizeof (DHCP_SERVICE));\r
\r
if (DhcpSb == NULL) {\r
return EFI_OUT_OF_RESOURCES;\r
DhcpSb->InDestory = FALSE;\r
DhcpSb->Controller = Controller;\r
DhcpSb->Image = ImageHandle;\r
- NetListInit (&DhcpSb->Children);\r
+ InitializeListHead (&DhcpSb->Children);\r
DhcpSb->DhcpState = Dhcp4Stopped;\r
DhcpSb->Xid = NET_RANDOM (NetRandomInitSeed ());\r
\r
//\r
Status = gBS->CreateEvent (\r
EVT_NOTIFY_SIGNAL | EVT_TIMER,\r
- NET_TPL_TIMER,\r
+ TPL_CALLBACK,\r
DhcpOnTimerTick,\r
DhcpSb,\r
&DhcpSb->Timer\r
\r
ON_ERROR:\r
Dhcp4CloseService (DhcpSb);\r
- NetFreePool (DhcpSb);\r
+ gBS->FreePool (DhcpSb);\r
\r
return Status;\r
}\r
\r
ON_ERROR:\r
Dhcp4CloseService (DhcpSb);\r
- NetFreePool (DhcpSb);\r
+ gBS->FreePool (DhcpSb);\r
return Status;\r
}\r
\r
return EFI_SUCCESS;\r
}\r
\r
- OldTpl = NET_RAISE_TPL (NET_TPL_LOCK);\r
+ OldTpl = gBS->RaiseTPL (TPL_CALLBACK);\r
\r
if (NumberOfChildren == 0) {\r
\r
\r
Dhcp4CloseService (DhcpSb);\r
\r
- NetFreePool (DhcpSb);\r
+ gBS->FreePool (DhcpSb);\r
} else {\r
//\r
// Don't use NET_LIST_FOR_EACH_SAFE here, Dhcp4ServiceBindingDestoryChild\r
// may cause other child to be deleted.\r
//\r
- while (!NetListIsEmpty (&DhcpSb->Children)) {\r
+ while (!IsListEmpty (&DhcpSb->Children)) {\r
Instance = NET_LIST_HEAD (&DhcpSb->Children, DHCP_PROTOCOL, Link);\r
ServiceBinding->DestroyChild (ServiceBinding, Instance->Handle);\r
}\r
}\r
}\r
\r
- NET_RESTORE_TPL (OldTpl);\r
+ gBS->RestoreTPL (OldTpl);\r
\r
return Status;\r
}\r
{\r
Instance->Signature = DHCP_PROTOCOL_SIGNATURE;\r
CopyMem (&Instance->Dhcp4Protocol, &mDhcp4ProtocolTemplate, sizeof (Instance->Dhcp4Protocol));\r
- NetListInit (&Instance->Link);\r
+ InitializeListHead (&Instance->Link);\r
Instance->Handle = NULL;\r
Instance->Service = DhcpSb;\r
Instance->InDestory = FALSE;\r
return EFI_INVALID_PARAMETER;\r
}\r
\r
- Instance = NetAllocatePool (sizeof (*Instance));\r
+ Instance = AllocatePool (sizeof (*Instance));\r
\r
if (Instance == NULL) {\r
return EFI_OUT_OF_RESOURCES;\r
);\r
\r
if (EFI_ERROR (Status)) {\r
- NetFreePool (Instance);\r
+ gBS->FreePool (Instance);\r
return Status;\r
}\r
\r
NULL\r
);\r
\r
- NetFreePool (Instance);\r
+ gBS->FreePool (Instance);\r
return Status;\r
}\r
\r
- OldTpl = NET_RAISE_TPL (NET_TPL_LOCK);\r
+ OldTpl = gBS->RaiseTPL (TPL_CALLBACK);\r
\r
- NetListInsertTail (&DhcpSb->Children, &Instance->Link);\r
+ InsertTailList (&DhcpSb->Children, &Instance->Link);\r
DhcpSb->NumChildren++;\r
\r
- NET_RESTORE_TPL (OldTpl);\r
+ gBS->RestoreTPL (OldTpl);\r
\r
return EFI_SUCCESS;\r
}\r
return EFI_SUCCESS;\r
}\r
\r
- OldTpl = NET_RAISE_TPL (NET_TPL_LOCK);\r
+ OldTpl = gBS->RaiseTPL (TPL_CALLBACK);\r
Instance->InDestory = TRUE;\r
\r
//\r
if (EFI_ERROR (Status)) {\r
Instance->InDestory = FALSE;\r
\r
- NET_RESTORE_TPL (OldTpl);\r
+ gBS->RestoreTPL (OldTpl);\r
return Status;\r
}\r
\r
DhcpYieldControl (DhcpSb);\r
}\r
\r
- NetListRemoveEntry (&Instance->Link);\r
+ RemoveEntryList (&Instance->Link);\r
DhcpSb->NumChildren--;\r
\r
- NET_RESTORE_TPL (OldTpl);\r
+ gBS->RestoreTPL (OldTpl);\r
\r
- NetFreePool (Instance);\r
+ gBS->FreePool (Instance);\r
return EFI_SUCCESS;\r
}\r
\r
Instance = DHCP_INSTANCE_FROM_THIS (This);\r
\r
- OldTpl = NET_RAISE_TPL (NET_TPL_LOCK);\r
+ OldTpl = gBS->RaiseTPL (TPL_CALLBACK);\r
DhcpSb = Instance->Service;\r
\r
//\r
CopyMem (&Dhcp4ModeData->ClientMacAddress, &DhcpSb->Mac, sizeof (Dhcp4ModeData->ClientMacAddress));\r
\r
Ip = HTONL (DhcpSb->ClientAddr);\r
- NetCopyMem (&Dhcp4ModeData->ClientAddress, &Ip, sizeof (EFI_IPv4_ADDRESS));\r
+ CopyMem (&Dhcp4ModeData->ClientAddress, &Ip, sizeof (EFI_IPv4_ADDRESS));\r
\r
Ip = HTONL (DhcpSb->Netmask);\r
- NetCopyMem (&Dhcp4ModeData->SubnetMask, &Ip, sizeof (EFI_IPv4_ADDRESS));\r
+ CopyMem (&Dhcp4ModeData->SubnetMask, &Ip, sizeof (EFI_IPv4_ADDRESS));\r
\r
Ip = HTONL (DhcpSb->ServerAddr);\r
- NetCopyMem (&Dhcp4ModeData->ServerAddress, &Ip, sizeof (EFI_IPv4_ADDRESS));\r
+ CopyMem (&Dhcp4ModeData->ServerAddress, &Ip, sizeof (EFI_IPv4_ADDRESS));\r
\r
Para = DhcpSb->Para;\r
\r
if (Para != NULL) {\r
Ip = HTONL (Para->Router);\r
- NetCopyMem (&Dhcp4ModeData->RouterAddress, &Ip, sizeof (EFI_IPv4_ADDRESS));\r
+ CopyMem (&Dhcp4ModeData->RouterAddress, &Ip, sizeof (EFI_IPv4_ADDRESS));\r
Dhcp4ModeData->LeaseTime = Para->Lease;\r
} else {\r
- NetZeroMem (&Dhcp4ModeData->RouterAddress, sizeof (EFI_IPv4_ADDRESS));\r
+ ZeroMem (&Dhcp4ModeData->RouterAddress, sizeof (EFI_IPv4_ADDRESS));\r
Dhcp4ModeData->LeaseTime = 0xffffffff;\r
}\r
\r
Dhcp4ModeData->ReplyPacket = DhcpSb->Selected;\r
\r
- NET_RESTORE_TPL (OldTpl);\r
+ gBS->RestoreTPL (OldTpl);\r
return EFI_SUCCESS;\r
}\r
\r
UINT32 Index;\r
\r
if (Config->DiscoverTimeout != NULL) {\r
- NetFreePool (Config->DiscoverTimeout);\r
+ gBS->FreePool (Config->DiscoverTimeout);\r
}\r
\r
if (Config->RequestTimeout != NULL) {\r
- NetFreePool (Config->RequestTimeout);\r
+ gBS->FreePool (Config->RequestTimeout);\r
}\r
\r
if (Config->OptionList != NULL) {\r
for (Index = 0; Index < Config->OptionCount; Index++) {\r
if (Config->OptionList[Index] != NULL) {\r
- NetFreePool (Config->OptionList[Index]);\r
+ gBS->FreePool (Config->OptionList[Index]);\r
}\r
}\r
\r
- NetFreePool (Config->OptionList);\r
+ gBS->FreePool (Config->OptionList);\r
}\r
\r
- NetZeroMem (Config, sizeof (EFI_DHCP4_CONFIG_DATA));\r
+ ZeroMem (Config, sizeof (EFI_DHCP4_CONFIG_DATA));\r
}\r
\r
\r
//\r
if (Src->DiscoverTimeout != NULL) {\r
Len = Src->DiscoverTryCount * sizeof (UINT32);\r
- Dst->DiscoverTimeout = NetAllocatePool (Len);\r
+ Dst->DiscoverTimeout = AllocatePool (Len);\r
\r
if (Dst->DiscoverTimeout == NULL) {\r
return EFI_OUT_OF_RESOURCES;\r
//\r
if (Src->RequestTimeout != NULL) {\r
Len = Src->RequestTryCount * sizeof (UINT32);\r
- Dst->RequestTimeout = NetAllocatePool (Len);\r
+ Dst->RequestTimeout = AllocatePool (Len);\r
\r
if (Dst->RequestTimeout == NULL) {\r
goto ON_ERROR;\r
//\r
if (Src->OptionList != NULL) {\r
Len = Src->OptionCount * sizeof (EFI_DHCP4_PACKET_OPTION *);\r
- Dst->OptionList = NetAllocateZeroPool (Len);\r
+ Dst->OptionList = AllocateZeroPool (Len);\r
\r
if (Dst->OptionList == NULL) {\r
goto ON_ERROR;\r
for (Index = 0; Index < Src->OptionCount; Index++) {\r
Len = sizeof (EFI_DHCP4_PACKET_OPTION) + MAX (SrcOptions[Index]->Length - 1, 0);\r
\r
- DstOptions[Index] = NetAllocatePool (Len);\r
+ DstOptions[Index] = AllocatePool (Len);\r
\r
if (DstOptions[Index] == NULL) {\r
goto ON_ERROR;\r
}\r
\r
- NetCopyMem (DstOptions[Index], SrcOptions[Index], Len);\r
+ CopyMem (DstOptions[Index], SrcOptions[Index], Len);\r
}\r
}\r
\r
DhcpSb->ActiveChild = NULL;\r
\r
if (Config->DiscoverTimeout != NULL) {\r
- NetFreePool (Config->DiscoverTimeout);\r
+ gBS->FreePool (Config->DiscoverTimeout);\r
\r
Config->DiscoverTryCount = 0;\r
Config->DiscoverTimeout = NULL;\r
}\r
\r
if (Config->RequestTimeout != NULL) {\r
- NetFreePool (Config->RequestTimeout);\r
+ gBS->FreePool (Config->RequestTimeout);\r
\r
Config->RequestTryCount = 0;\r
Config->RequestTimeout = NULL;\r
return EFI_INVALID_PARAMETER;\r
}\r
\r
- NetCopyMem (&Ip, &Dhcp4CfgData->ClientAddress, sizeof (IP4_ADDR));\r
+ CopyMem (&Ip, &Dhcp4CfgData->ClientAddress, sizeof (IP4_ADDR));\r
\r
if ((Ip != 0) && !Ip4IsUnicast (NTOHL (Ip), 0)) {\r
\r
return EFI_INVALID_PARAMETER;\r
}\r
\r
- OldTpl = NET_RAISE_TPL (NET_TPL_LOCK);\r
+ OldTpl = gBS->RaiseTPL (TPL_CALLBACK);\r
\r
DhcpSb = Instance->Service;\r
Config = &DhcpSb->ActiveConfig;\r
}\r
\r
ON_EXIT:\r
- NET_RESTORE_TPL (OldTpl);\r
+ gBS->RestoreTPL (OldTpl);\r
return Status;\r
}\r
\r
return EFI_INVALID_PARAMETER;\r
}\r
\r
- OldTpl = NET_RAISE_TPL (NET_TPL_LOCK);\r
+ OldTpl = gBS->RaiseTPL (TPL_CALLBACK);\r
DhcpSb = Instance->Service;\r
\r
if (DhcpSb->DhcpState == Dhcp4Stopped) {\r
Instance->CompletionEvent = CompletionEvent;\r
\r
//\r
- // Restore the TPL now, don't call poll function at NET_TPL_LOCK.\r
+ // Restore the TPL now, don't call poll function at TPL_CALLBACK.\r
//\r
- NET_RESTORE_TPL (OldTpl);\r
+ gBS->RestoreTPL (OldTpl);\r
\r
if (CompletionEvent == NULL) {\r
while (DhcpSb->IoStatus == EFI_ALREADY_STARTED) {\r
return EFI_SUCCESS;\r
\r
ON_ERROR:\r
- NET_RESTORE_TPL (OldTpl);\r
+ gBS->RestoreTPL (OldTpl);\r
return Status;\r
}\r
\r
return EFI_INVALID_PARAMETER;\r
}\r
\r
- OldTpl = NET_RAISE_TPL (NET_TPL_LOCK);\r
+ OldTpl = gBS->RaiseTPL (TPL_CALLBACK);\r
DhcpSb = Instance->Service;\r
\r
if (DhcpSb->DhcpState == Dhcp4Stopped) {\r
DhcpSb->IoStatus = EFI_ALREADY_STARTED;\r
Instance->RenewRebindEvent = CompletionEvent;\r
\r
- NET_RESTORE_TPL (OldTpl);\r
+ gBS->RestoreTPL (OldTpl);\r
\r
if (CompletionEvent == NULL) {\r
while (DhcpSb->IoStatus == EFI_ALREADY_STARTED) {\r
return EFI_SUCCESS;\r
\r
ON_ERROR:\r
- NET_RESTORE_TPL (OldTpl);\r
+ gBS->RestoreTPL (OldTpl);\r
return Status;\r
}\r
\r
}\r
\r
Status = EFI_SUCCESS;\r
- OldTpl = NET_RAISE_TPL (NET_TPL_LOCK);\r
+ OldTpl = gBS->RaiseTPL (TPL_CALLBACK);\r
DhcpSb = Instance->Service;\r
\r
if ((DhcpSb->DhcpState != Dhcp4InitReboot) && (DhcpSb->DhcpState != Dhcp4Bound)) {\r
DhcpCleanLease (DhcpSb);\r
\r
ON_EXIT:\r
- NET_RESTORE_TPL (OldTpl);\r
+ gBS->RestoreTPL (OldTpl);\r
return Status;\r
}\r
\r
return EFI_INVALID_PARAMETER;\r
}\r
\r
- OldTpl = NET_RAISE_TPL (NET_TPL_LOCK);\r
+ OldTpl = gBS->RaiseTPL (TPL_CALLBACK);\r
DhcpSb = Instance->Service;\r
\r
DhcpCleanLease (DhcpSb);\r
DhcpSb->DhcpState = Dhcp4Stopped;\r
DhcpSb->ServiceState = DHCP_UNCONFIGED;\r
\r
- NET_RESTORE_TPL (OldTpl);\r
+ gBS->RestoreTPL (OldTpl);\r
return EFI_SUCCESS;\r
}\r
\r
DhcpSb = Instance->Service;\r
Token = Instance->Token;\r
\r
- NetZeroMem (&UdpConfigData, sizeof (EFI_UDP4_CONFIG_DATA));\r
+ ZeroMem (&UdpConfigData, sizeof (EFI_UDP4_CONFIG_DATA));\r
\r
UdpConfigData.AcceptBroadcast = TRUE;\r
UdpConfigData.AllowDuplicatePort = TRUE;\r
UdpConfigData.DoNotFragment = TRUE;\r
\r
Ip = HTONL (DhcpSb->ClientAddr);\r
- NetCopyMem (&UdpConfigData.StationAddress, &Ip, sizeof (EFI_IPv4_ADDRESS));\r
+ CopyMem (&UdpConfigData.StationAddress, &Ip, sizeof (EFI_IPv4_ADDRESS));\r
\r
Ip = HTONL (DhcpSb->Netmask);\r
- NetCopyMem (&UdpConfigData.SubnetMask, &Ip, sizeof (EFI_IPv4_ADDRESS));\r
+ CopyMem (&UdpConfigData.SubnetMask, &Ip, sizeof (EFI_IPv4_ADDRESS));\r
\r
if ((Token->ListenPointCount == 0) || (Token->ListenPoints[0].ListenPort == 0)) {\r
UdpConfigData.StationPort = DHCP_CLIENT_PORT;\r
\r
Token->ResponseCount = Instance->ResponseQueue.BufNum;\r
if (Token->ResponseCount != 0) {\r
- Token->ResponseList = (EFI_DHCP4_PACKET *) NetAllocatePool (Instance->ResponseQueue.BufSize);\r
+ Token->ResponseList = (EFI_DHCP4_PACKET *) AllocatePool (Instance->ResponseQueue.BufSize);\r
if (Token->ResponseList == NULL) {\r
Token->Status = EFI_OUT_OF_RESOURCES;\r
goto SIGNAL_USER;\r
return EFI_NO_MAPPING;\r
}\r
\r
- OldTpl = NET_RAISE_TPL (NET_TPL_LOCK);\r
+ OldTpl = gBS->RaiseTPL (TPL_CALLBACK);\r
\r
//\r
// Save the token and the timeout value.\r
//\r
// Set the destination address and destination port.\r
//\r
- NetCopyMem (&Ip, &Token->RemoteAddress, sizeof (EFI_IPv4_ADDRESS));\r
+ CopyMem (&Ip, &Token->RemoteAddress, sizeof (EFI_IPv4_ADDRESS));\r
EndPoint.RemoteAddr = NTOHL (Ip);\r
\r
if (Token->RemotePort == 0) {\r
SubnetMask = DhcpSb->Netmask;\r
Gateway = 0;\r
if (!IP4_NET_EQUAL (DhcpSb->ClientAddr, EndPoint.RemoteAddr, SubnetMask)) {\r
- NetCopyMem (&Gateway, &Token->GatewayAddress, sizeof (EFI_IPv4_ADDRESS));\r
+ CopyMem (&Gateway, &Token->GatewayAddress, sizeof (EFI_IPv4_ADDRESS));\r
Gateway = NTOHL (Gateway);\r
}\r
\r
Instance->Token = NULL;\r
}\r
\r
- NET_RESTORE_TPL (OldTpl);\r
+ gBS->RestoreTPL (OldTpl);\r
\r
if (!EFI_ERROR (Status) && (Token->CompletionEvent == NULL)) {\r
//\r
return EFI_BUFFER_TOO_SMALL;\r
}\r
\r
- NetZeroMem (PacketOptionList, *OptionCount * sizeof (EFI_DHCP4_PACKET_OPTION *));\r
+ ZeroMem (PacketOptionList, *OptionCount * sizeof (EFI_DHCP4_PACKET_OPTION *));\r
\r
Context.Option = PacketOptionList;\r
Context.OptionCount = *OptionCount;\r
struct _DHCP_PROTOCOL {\r
UINT32 Signature;\r
EFI_DHCP4_PROTOCOL Dhcp4Protocol;\r
- NET_LIST_ENTRY Link;\r
+ LIST_ENTRY Link;\r
EFI_HANDLE Handle;\r
DHCP_SERVICE *Service;\r
\r
EFI_HANDLE Controller;\r
EFI_HANDLE Image;\r
\r
- NET_LIST_ENTRY Children;\r
+ LIST_ENTRY Children;\r
UINTN NumChildren;\r
\r
INTN DhcpState;\r
UdpConfigData.RemotePort = DHCP_SERVER_PORT;\r
\r
Ip = HTONL (DhcpSb->ClientAddr);\r
- NetCopyMem (&UdpConfigData.StationAddress, &Ip, sizeof (EFI_IPv4_ADDRESS));\r
+ CopyMem (&UdpConfigData.StationAddress, &Ip, sizeof (EFI_IPv4_ADDRESS));\r
\r
Ip = HTONL (DhcpSb->Netmask);\r
- NetCopyMem (&UdpConfigData.SubnetMask, &Ip, sizeof (EFI_IPv4_ADDRESS));\r
+ CopyMem (&UdpConfigData.SubnetMask, &Ip, sizeof (EFI_IPv4_ADDRESS));\r
\r
- NetZeroMem (&UdpConfigData.RemoteAddress, sizeof (EFI_IPv4_ADDRESS));\r
+ ZeroMem (&UdpConfigData.RemoteAddress, sizeof (EFI_IPv4_ADDRESS));\r
\r
Status = UdpIo->Udp->Configure (UdpIo->Udp, &UdpConfigData);\r
\r
// Add a default route if received from the server.\r
//\r
if ((DhcpSb->Para != NULL) && (DhcpSb->Para->Router != 0)) {\r
- NetZeroMem (&Subnet, sizeof (EFI_IPv4_ADDRESS));\r
+ ZeroMem (&Subnet, sizeof (EFI_IPv4_ADDRESS));\r
\r
Ip = HTONL (DhcpSb->Para->Router);\r
- NetCopyMem (&Gateway, &Ip, sizeof (EFI_IPv4_ADDRESS));\r
+ CopyMem (&Gateway, &Ip, sizeof (EFI_IPv4_ADDRESS));\r
\r
UdpIo->Udp->Routes (UdpIo->Udp, FALSE, &Subnet, &Subnet, &Gateway);\r
}\r
DhcpSb->ServerAddr = 0;\r
\r
if (DhcpSb->LastOffer != NULL) {\r
- NetFreePool (DhcpSb->LastOffer);\r
+ gBS->FreePool (DhcpSb->LastOffer);\r
DhcpSb->LastOffer = NULL;\r
}\r
\r
if (DhcpSb->Selected != NULL) {\r
- NetFreePool (DhcpSb->Selected);\r
+ gBS->FreePool (DhcpSb->Selected);\r
DhcpSb->Selected = NULL;\r
}\r
\r
if (DhcpSb->Para != NULL) {\r
- NetFreePool (DhcpSb->Para);\r
+ gBS->FreePool (DhcpSb->Para);\r
DhcpSb->Para = NULL;\r
}\r
\r
Selected = DhcpSb->LastOffer;\r
\r
if ((NewPacket != NULL) && !EFI_ERROR (DhcpValidateOptions (NewPacket, NULL))) {\r
- TempPacket = (EFI_DHCP4_PACKET *) NetAllocatePool (NewPacket->Size);\r
+ TempPacket = (EFI_DHCP4_PACKET *) AllocatePool (NewPacket->Size);\r
if (TempPacket != NULL) {\r
- NetCopyMem (TempPacket, NewPacket, NewPacket->Size);\r
- NetFreePool (Selected);\r
+ CopyMem (TempPacket, NewPacket, NewPacket->Size);\r
+ gBS->FreePool (Selected);\r
Selected = TempPacket;\r
}\r
}\r
\r
if (Status == EFI_SUCCESS) {\r
if (DhcpSb->LastOffer != NULL) {\r
- NetFreePool (DhcpSb->LastOffer);\r
+ gBS->FreePool (DhcpSb->LastOffer);\r
}\r
\r
DhcpSb->LastOffer = Packet;\r
\r
} else if (Status == EFI_NOT_READY) {\r
if (DhcpSb->LastOffer != NULL) {\r
- NetFreePool (DhcpSb->LastOffer);\r
+ gBS->FreePool (DhcpSb->LastOffer);\r
}\r
\r
DhcpSb->LastOffer = Packet;\r
return EFI_SUCCESS;\r
\r
ON_EXIT:\r
- NetFreePool (Packet);\r
+ gBS->FreePool (Packet);\r
return Status;\r
}\r
\r
DhcpSb->IoStatus = EFI_SUCCESS;\r
DhcpNotifyUser (DhcpSb, DHCP_NOTIFY_COMPLETION);\r
\r
- NetFreePool (Packet);\r
+ gBS->FreePool (Packet);\r
return EFI_SUCCESS;\r
\r
REJECT:\r
DhcpSendMessage (DhcpSb, DhcpSb->Selected, DhcpSb->Para, DHCP_MSG_DECLINE, Message);\r
\r
ON_EXIT:\r
- NetFreePool (Packet);\r
+ gBS->FreePool (Packet);\r
return Status;\r
}\r
\r
}\r
\r
ON_EXIT:\r
- NetFreePool (Packet);\r
+ gBS->FreePool (Packet);\r
return Status;\r
}\r
\r
//\r
// OK, get the parameter from server, record the lease\r
//\r
- DhcpSb->Para = NetAllocatePool (sizeof (DHCP_PARAMETER));\r
+ DhcpSb->Para = AllocatePool (sizeof (DHCP_PARAMETER));\r
\r
if (DhcpSb->Para == NULL) {\r
Status = EFI_OUT_OF_RESOURCES;\r
return EFI_SUCCESS;\r
\r
ON_EXIT:\r
- NetFreePool (Packet);\r
+ gBS->FreePool (Packet);\r
return Status;\r
}\r
\r
// Copy the DHCP message to a continuous memory block\r
//\r
Len = sizeof (EFI_DHCP4_PACKET) + UdpPacket->TotalSize - sizeof (EFI_DHCP4_HEADER);\r
- Packet = (EFI_DHCP4_PACKET *) NetAllocatePool (Len);\r
+ Packet = (EFI_DHCP4_PACKET *) AllocatePool (Len);\r
\r
if (Packet == NULL) {\r
goto RESTART;\r
//\r
// Ignore the packet in INITREBOOT, INIT and BOUND states\r
//\r
- NetFreePool (Packet);\r
+ gBS->FreePool (Packet);\r
Status = EFI_SUCCESS;\r
break;\r
\r
}\r
\r
if (Para != NULL) {\r
- NetFreePool (Para);\r
+ gBS->FreePool (Para);\r
}\r
\r
Packet = NULL;\r
NetbufFree (UdpPacket);\r
\r
if (Packet != NULL) {\r
- NetFreePool (Packet);\r
+ gBS->FreePool (Packet);\r
}\r
\r
Status = UdpIoRecvDatagram (DhcpSb->UdpIo, DhcpInput, DhcpSb, 0);\r
IN VOID *Arg\r
)\r
{\r
- NetFreePool (Arg);\r
+ gBS->FreePool (Arg);\r
}\r
\r
\r
Len += (UINT32)AsciiStrLen ((CHAR8 *) Msg);\r
}\r
\r
- Packet = NetAllocatePool (Len);\r
+ Packet = AllocatePool (Len);\r
\r
if (Packet == NULL) {\r
return EFI_OUT_OF_RESOURCES;\r
}\r
\r
Head = &Packet->Dhcp4.Header;\r
- NetZeroMem (Head, sizeof (EFI_DHCP4_HEADER));\r
+ ZeroMem (Head, sizeof (EFI_DHCP4_HEADER));\r
\r
Head->OpCode = BOOTP_REQUEST;\r
Head->HwType = DhcpSb->HwType;\r
Head->Reserved = HTONS (0x8000); //Server, broadcast the message please.\r
\r
EFI_IP4 (Head->ClientAddr) = HTONL (DhcpSb->ClientAddr);\r
- NetCopyMem (Head->ClientHwAddr, DhcpSb->Mac.Addr, DhcpSb->HwLen);\r
+ CopyMem (Head->ClientHwAddr, DhcpSb->Mac.Addr, DhcpSb->HwLen);\r
\r
//\r
// Append the DHCP message type\r
}\r
\r
if (EFI_ERROR (Status)) {\r
- NetFreePool (Packet);\r
+ gBS->FreePool (Packet);\r
return Status;\r
}\r
\r
if (NewPacket != NULL) {\r
- NetFreePool (Packet);\r
+ gBS->FreePool (Packet);\r
Packet = NewPacket;\r
}\r
\r
Wrap = NetbufFromExt (&Frag, 1, 0, 0, DhcpReleasePacket, Packet);\r
\r
if (Wrap == NULL) {\r
- NetFreePool (Packet);\r
+ gBS->FreePool (Packet);\r
return EFI_OUT_OF_RESOURCES;\r
}\r
\r
Options[Index].Data = Buf + OptCount[Tag].Offset;\r
}\r
\r
- NetCopyMem (Buf + OptCount[Tag].Offset, Data, Len);\r
+ CopyMem (Buf + OptCount[Tag].Offset, Data, Len);\r
\r
OptCount[Tag].Offset = (UINT16) (OptCount[Tag].Offset + Len);\r
Options[Index].Len = (UINT16) (Options[Index].Len + Len);\r
// First compute how many options and how long each option is\r
// with the "Key indexed counting" algorithms.\r
//\r
- OptCount = NetAllocateZeroPool (DHCP_MAX_OPTIONS * sizeof (DHCP_OPTION_COUNT));\r
+ OptCount = AllocateZeroPool (DHCP_MAX_OPTIONS * sizeof (DHCP_OPTION_COUNT));\r
\r
if (OptCount == NULL) {\r
return EFI_OUT_OF_RESOURCES;\r
// Allocate a buffer to hold the DHCP options, and after that, a\r
// continuous buffer to put all the options' data.\r
//\r
- Options = NetAllocateZeroPool (OptNum * sizeof (DHCP_OPTION) + TotalLen);\r
+ Options = AllocateZeroPool (OptNum * sizeof (DHCP_OPTION) + TotalLen);\r
\r
if (Options == NULL) {\r
Status = EFI_OUT_OF_RESOURCES;\r
Status = DhcpIterateOptions (Packet, DhcpFillOption, &Context);\r
\r
if (EFI_ERROR (Status)) {\r
- NetFreePool (Options);\r
+ gBS->FreePool (Options);\r
goto ON_EXIT;\r
}\r
\r
*OptionPoint = Options;\r
\r
ON_EXIT:\r
- NetFreePool (OptCount);\r
+ gBS->FreePool (OptCount);\r
return Status;\r
}\r
\r
}\r
\r
Updated = FALSE;\r
- NetZeroMem (&Parameter, sizeof (Parameter));\r
+ ZeroMem (&Parameter, sizeof (Parameter));\r
\r
for (Index = 0; Index < Count; Index++) {\r
Option = &AllOption[Index];\r
}\r
\r
if (Updated && (Para != NULL)) {\r
- if ((*Para = NetAllocatePool (sizeof (DHCP_PARAMETER))) == NULL) {\r
+ if ((*Para = AllocatePool (sizeof (DHCP_PARAMETER))) == NULL) {\r
Status = EFI_OUT_OF_RESOURCES;\r
goto ON_EXIT;\r
}\r
}\r
\r
ON_EXIT:\r
- NetFreePool (AllOption);\r
+ gBS->FreePool (AllOption);\r
return Status;\r
}\r
\r
\r
*(Buf++) = Tag;\r
*(Buf++) = (UINT8) Len;\r
- NetCopyMem (Buf, Data + Index * 255, Len);\r
+ CopyMem (Buf, Data + Index * 255, Len);\r
\r
Buf += Len;\r
}\r
// Use an array of DHCP_OPTION to mark the existance\r
// and position of each valid options.\r
//\r
- Mark = NetAllocatePool (sizeof (DHCP_OPTION) * DHCP_MAX_OPTIONS);\r
+ Mark = AllocatePool (sizeof (DHCP_OPTION) * DHCP_MAX_OPTIONS);\r
\r
if (Mark == NULL) {\r
return EFI_OUT_OF_RESOURCES;\r
}\r
\r
Status = EFI_OUT_OF_RESOURCES;\r
- Packet = (EFI_DHCP4_PACKET *) NetAllocatePool (Len);\r
+ Packet = (EFI_DHCP4_PACKET *) AllocatePool (Len);\r
\r
if (Packet == NULL) {\r
goto ON_ERROR;\r
\r
ON_ERROR:\r
if (SeedOptions != NULL) {\r
- NetFreePool (SeedOptions);\r
+ gBS->FreePool (SeedOptions);\r
}\r
\r
- NetFreePool (Mark);\r
+ gBS->FreePool (Mark);\r
return Status;\r
}\r
// If the free list is empty and a DPC is queued, the free list is grown by allocating\r
// an additional set of DPC entries.\r
//\r
-LIST_ENTRY mDpcEntryFreeList = INITIALIZE_LIST_HEAD_VARIABLE(mDpcEntryFreeList);\r
+LIST_ENTRY mDpcEntryFreeList = INITIALIZE_LIST_HEAD_VARIABLE(mDpcEntryFreeList);\r
\r
//\r
// An array of DPC queues. A DPC queue is allocated for every leval EFI_TPL value.\r
// As DPCs are queued, they are added to the end of the linked list.\r
// As DPCs are dispatched, they are removed from the beginning of the linked list.\r
//\r
-LIST_ENTRY mDpcQueue[TPL_HIGH_LEVEL + 1];\r
+LIST_ENTRY mDpcQueue[TPL_HIGH_LEVEL + 1];\r
\r
/**\r
Add a Deferred Procedure Call to the end of the DPC queue.\r
// list or on a DPC queue at a specific EFI_TPL.\r
//\r
typedef struct {\r
- LIST_ENTRY ListEntry;\r
+ LIST_ENTRY ListEntry;\r
EFI_DPC_PROCEDURE DpcProcedure;\r
VOID *DpcContext;\r
} DPC_ENTRY;\r
VerifyRsp\r
);\r
\r
- if (NetCompareMem (VerifyRsp, TargetResponse, ISCSI_CHAP_RSP_LEN)) {\r
+ if (CompareMem (VerifyRsp, TargetResponse, ISCSI_CHAP_RSP_LEN)) {\r
Status = EFI_SECURITY_VIOLATION;\r
}\r
\r
CHAR8 *Value;\r
UINT8 *Data;\r
UINT32 Len;\r
- NET_LIST_ENTRY *KeyValueList;\r
+ LIST_ENTRY *KeyValueList;\r
UINTN Algorithm;\r
CHAR8 *Identifier;\r
CHAR8 *Challenge;\r
AuthData = &Session->AuthData;\r
\r
Len = Conn->RspQue.BufSize;\r
- Data = NetAllocatePool (Len);\r
+ Data = AllocatePool (Len);\r
if (Data == NULL) {\r
return EFI_OUT_OF_RESOURCES;\r
}\r
\r
IScsiFreeKeyValueList (KeyValueList);\r
\r
- NetFreePool (Data);\r
+ gBS->FreePool (Data);\r
\r
return Status;\r
}\r
Status = EFI_SUCCESS;\r
\r
RspLen = 2 * ISCSI_CHAP_RSP_LEN + 3;\r
- Response = NetAllocatePool (RspLen);\r
+ Response = AllocatePool (RspLen);\r
if (Response == NULL) {\r
return EFI_OUT_OF_RESOURCES;\r
}\r
\r
ChallengeLen = 2 * ISCSI_CHAP_RSP_LEN + 3;\r
- Challenge = NetAllocatePool (ChallengeLen);\r
+ Challenge = AllocatePool (ChallengeLen);\r
if (Challenge == NULL) {\r
return EFI_OUT_OF_RESOURCES;\r
}\r
break;\r
}\r
\r
- NetFreePool (Response);\r
- NetFreePool (Challenge);\r
+ gBS->FreePool (Response);\r
+ gBS->FreePool (Challenge);\r
\r
return Status;\r
}\r
UINTN mNumberOfIScsiDevices = 0;\r
ISCSI_FORM_CALLBACK_INFO *mCallbackInfo;\r
\r
-NET_LIST_ENTRY mIScsiConfigFormList = {\r
+LIST_ENTRY mIScsiConfigFormList = {\r
&mIScsiConfigFormList,\r
&mIScsiConfigFormList\r
};\r
NULL\r
);\r
if (Status == EFI_BUFFER_TOO_SMALL) {\r
- DeviceList = (ISCSI_DEVICE_LIST *) NetAllocatePool (DataSize);\r
+ DeviceList = (ISCSI_DEVICE_LIST *) AllocatePool (DataSize);\r
\r
gRT->GetVariable (\r
L"iSCSIDeviceList",\r
// Swap the current MAC address entry with the one indexed by\r
// LastDeviceIndex.\r
//\r
- NetCopyMem (&TempMacInfo, CurMacInfo, sizeof (ISCSI_MAC_INFO));\r
- NetCopyMem (CurMacInfo, &DeviceList->MacInfo[LastDeviceIndex], sizeof (ISCSI_MAC_INFO));\r
- NetCopyMem (&DeviceList->MacInfo[LastDeviceIndex], &TempMacInfo, sizeof (ISCSI_MAC_INFO));\r
+ CopyMem (&TempMacInfo, CurMacInfo, sizeof (ISCSI_MAC_INFO));\r
+ CopyMem (CurMacInfo, &DeviceList->MacInfo[LastDeviceIndex], sizeof (ISCSI_MAC_INFO));\r
+ CopyMem (&DeviceList->MacInfo[LastDeviceIndex], &TempMacInfo, sizeof (ISCSI_MAC_INFO));\r
}\r
\r
LastDeviceIndex++;\r
gRT->SetVariable (MacString, &mIScsiCHAPAuthInfoGuid, 0, 0, NULL);\r
}\r
\r
- NetFreePool (DeviceList);\r
+ gBS->FreePool (DeviceList);\r
} else if (Status != EFI_NOT_FOUND) {\r
- NetFreePool (Handles);\r
+ gBS->FreePool (Handles);\r
return Status;\r
}\r
//\r
// Construct the new iSCSI device list.\r
//\r
DeviceListSize = sizeof (ISCSI_DEVICE_LIST) + (NumHandles - 1) * sizeof (ISCSI_MAC_INFO);\r
- DeviceList = (ISCSI_DEVICE_LIST *) NetAllocatePool (DeviceListSize);\r
+ DeviceList = (ISCSI_DEVICE_LIST *) AllocatePool (DeviceListSize);\r
DeviceList->NumDevice = (UINT8) NumHandles;\r
\r
for (Index = 0; Index < NumHandles; Index++) {\r
Mode = Snp->Mode;\r
\r
CurMacInfo = &DeviceList->MacInfo[Index];\r
- NetCopyMem (&CurMacInfo->Mac, &Mode->PermanentAddress, Mode->HwAddressSize);\r
+ CopyMem (&CurMacInfo->Mac, &Mode->PermanentAddress, Mode->HwAddressSize);\r
CurMacInfo->Len = (UINT8) Mode->HwAddressSize;\r
}\r
\r
DeviceList\r
);\r
\r
- NetFreePool (DeviceList);\r
+ gBS->FreePool (DeviceList);\r
\r
return Status;\r
}\r
--*/\r
{\r
UINT32 CurrentIndex;\r
- NET_LIST_ENTRY *Entry;\r
+ LIST_ENTRY *Entry;\r
ISCSI_CONFIG_FORM_ENTRY *ConfigFormEntry;\r
\r
CurrentIndex = 0;\r
Results,\r
Progress\r
);\r
- NetFreePool (IfrNvData);\r
+ gBS->FreePool (IfrNvData);\r
return Status;\r
}\r
\r
PopUpInvalidNotify (L"Invalid IP address!");\r
Status = EFI_INVALID_PARAMETER;\r
} else {\r
- NetCopyMem (&Private->Current->SessionConfigData.LocalIp, &HostIp.v4, sizeof (HostIp.v4));\r
+ CopyMem (&Private->Current->SessionConfigData.LocalIp, &HostIp.v4, sizeof (HostIp.v4));\r
}\r
\r
break;\r
PopUpInvalidNotify (L"Invalid Subnet Mask!");\r
Status = EFI_INVALID_PARAMETER;\r
} else {\r
- NetCopyMem (&Private->Current->SessionConfigData.SubnetMask, &SubnetMask.v4, sizeof (SubnetMask.v4));\r
+ CopyMem (&Private->Current->SessionConfigData.SubnetMask, &SubnetMask.v4, sizeof (SubnetMask.v4));\r
}\r
\r
break;\r
PopUpInvalidNotify (L"Invalid Gateway!");\r
Status = EFI_INVALID_PARAMETER;\r
} else {\r
- NetCopyMem (&Private->Current->SessionConfigData.Gateway, &Gateway.v4, sizeof (Gateway.v4));\r
+ CopyMem (&Private->Current->SessionConfigData.Gateway, &Gateway.v4, sizeof (Gateway.v4));\r
}\r
\r
break;\r
PopUpInvalidNotify (L"Invalid IP address!");\r
Status = EFI_INVALID_PARAMETER;\r
} else {\r
- NetCopyMem (&Private->Current->SessionConfigData.TargetIp, &HostIp.v4, sizeof (HostIp.v4));\r
+ CopyMem (&Private->Current->SessionConfigData.TargetIp, &HostIp.v4, sizeof (HostIp.v4));\r
}\r
\r
break;\r
if (EFI_ERROR (Status)) {\r
PopUpInvalidNotify (L"Invalid LUN string!");\r
} else {\r
- NetCopyMem (Private->Current->SessionConfigData.BootLun, &Lun, sizeof (Lun));\r
+ CopyMem (Private->Current->SessionConfigData.BootLun, &Lun, sizeof (Lun));\r
}\r
\r
break;\r
// deployed.\r
//\r
if (!Private->Current->SessionConfigData.InitiatorInfoFromDhcp) {\r
- NetCopyMem (&HostIp.v4, &Private->Current->SessionConfigData.LocalIp, sizeof (HostIp.v4));\r
- NetCopyMem (&SubnetMask.v4, &Private->Current->SessionConfigData.SubnetMask, sizeof (SubnetMask.v4));\r
- NetCopyMem (&Gateway.v4, &Private->Current->SessionConfigData.Gateway, sizeof (Gateway.v4));\r
+ CopyMem (&HostIp.v4, &Private->Current->SessionConfigData.LocalIp, sizeof (HostIp.v4));\r
+ CopyMem (&SubnetMask.v4, &Private->Current->SessionConfigData.SubnetMask, sizeof (SubnetMask.v4));\r
+ CopyMem (&Gateway.v4, &Private->Current->SessionConfigData.Gateway, sizeof (Gateway.v4));\r
\r
if ((Gateway.Addr[0] != 0)) {\r
if (SubnetMask.Addr[0] == 0) {\r
// Validate target configuration if DHCP isn't deployed.\r
//\r
if (!Private->Current->SessionConfigData.TargetInfoFromDhcp) {\r
- NetCopyMem (&HostIp.v4, &Private->Current->SessionConfigData.TargetIp, sizeof (HostIp.v4));\r
+ CopyMem (&HostIp.v4, &Private->Current->SessionConfigData.TargetIp, sizeof (HostIp.v4));\r
if (!Ip4IsUnicast (NTOHL (HostIp.Addr[0]), 0)) {\r
PopUpInvalidNotify (L"Target IP is invalid!");\r
Status = EFI_INVALID_PARAMETER;\r
Status = SetBrowserData (NULL, NULL, BufferSize, (UINT8 *) IfrNvData, NULL);\r
}\r
\r
- NetFreePool (IfrNvData);\r
+ gBS->FreePool (IfrNvData);\r
return Status;\r
}\r
\r
\r
--*/\r
{\r
- NET_LIST_ENTRY *Entry;\r
+ LIST_ENTRY *Entry;\r
ISCSI_CONFIG_FORM_ENTRY *ConfigFormEntry;\r
BOOLEAN EntryExisted;\r
EFI_STATUS Status;\r
//\r
// Add a new form.\r
//\r
- ConfigFormEntry = (ISCSI_CONFIG_FORM_ENTRY *) NetAllocateZeroPool (sizeof (ISCSI_CONFIG_FORM_ENTRY));\r
+ ConfigFormEntry = (ISCSI_CONFIG_FORM_ENTRY *) AllocateZeroPool (sizeof (ISCSI_CONFIG_FORM_ENTRY));\r
if (ConfigFormEntry == NULL) {\r
return EFI_OUT_OF_RESOURCES;\r
}\r
\r
- NetListInit (&ConfigFormEntry->Link);\r
+ InitializeListHead (&ConfigFormEntry->Link);\r
ConfigFormEntry->Controller = Controller;\r
\r
//\r
&ConfigFormEntry->SessionConfigData\r
);\r
if (EFI_ERROR (Status)) {\r
- NetZeroMem (&ConfigFormEntry->SessionConfigData, sizeof (ConfigFormEntry->SessionConfigData));\r
+ ZeroMem (&ConfigFormEntry->SessionConfigData, sizeof (ConfigFormEntry->SessionConfigData));\r
}\r
//\r
// Get the CHAP authentication configuration data.\r
&ConfigFormEntry->AuthConfigData\r
);\r
if (EFI_ERROR (Status)) {\r
- NetZeroMem (&ConfigFormEntry->AuthConfigData, sizeof (ConfigFormEntry->AuthConfigData));\r
+ ZeroMem (&ConfigFormEntry->AuthConfigData, sizeof (ConfigFormEntry->AuthConfigData));\r
}\r
//\r
// Compose the Port string and create a new STRING_REF.\r
UnicodeSPrint (PortString, 128, L"Set the iSCSI parameters on port %s", ConfigFormEntry->MacString);\r
HiiLibNewString (mCallbackInfo->RegisteredHandle, &ConfigFormEntry->PortTitleHelpToken, PortString);\r
\r
- NetListInsertTail (&mIScsiConfigFormList, &ConfigFormEntry->Link);\r
+ InsertTailList (&mIScsiConfigFormList, &ConfigFormEntry->Link);\r
mNumberOfIScsiDevices++;\r
}\r
} else {\r
ASSERT (EntryExisted);\r
\r
mNumberOfIScsiDevices--;\r
- NetListRemoveEntry (&ConfigFormEntry->Link);\r
- NetFreePool (ConfigFormEntry);\r
+ RemoveEntryList (&ConfigFormEntry->Link);\r
+ gBS->FreePool (ConfigFormEntry);\r
}\r
//\r
// Allocate space for creation of Buffer\r
//\r
UpdateData.BufferSize = 0x1000;\r
- UpdateData.Data = NetAllocateZeroPool (0x1000);\r
+ UpdateData.Data = AllocateZeroPool (0x1000);\r
UpdateData.Offset = 0;\r
\r
FormIndex = 0;\r
&UpdateData\r
);\r
\r
- NetFreePool (UpdateData.Data);\r
+ gBS->FreePool (UpdateData.Data);\r
\r
return EFI_SUCCESS;\r
}\r
return Status;\r
}\r
\r
- CallbackInfo = (ISCSI_FORM_CALLBACK_INFO *) NetAllocatePool (sizeof (ISCSI_FORM_CALLBACK_INFO));\r
+ CallbackInfo = (ISCSI_FORM_CALLBACK_INFO *) AllocatePool (sizeof (ISCSI_FORM_CALLBACK_INFO));\r
if (CallbackInfo == NULL) {\r
return EFI_OUT_OF_RESOURCES;\r
}\r
CallbackInfo->DriverHandle,\r
&CallbackInfo->RegisteredHandle\r
);\r
- NetFreePool (PackageList);\r
+ gBS->FreePool (PackageList);\r
if (EFI_ERROR (Status)) {\r
return Status;\r
}\r
{\r
ISCSI_CONFIG_FORM_ENTRY *ConfigFormEntry;\r
\r
- while (!NetListIsEmpty (&mIScsiConfigFormList)) {\r
+ while (!IsListEmpty (&mIScsiConfigFormList)) {\r
//\r
// Uninstall the device forms as the iSCSI driver instance may fail to\r
// control the controller but still install the device configuration form.\r
);\r
HiiLibDestroyHiiDriverHandle (mCallbackInfo->DriverHandle);\r
\r
- NetFreePool (mCallbackInfo);\r
+ gBS->FreePool (mCallbackInfo);\r
\r
return EFI_SUCCESS;\r
}\r
#pragma pack()\r
\r
typedef struct _ISCSI_CONFIG_FORM_ENTRY {\r
- NET_LIST_ENTRY Link;\r
+ LIST_ENTRY Link;\r
EFI_HANDLE Controller;\r
CHAR16 MacString[95];\r
STRING_REF PortTitleToken;\r
//\r
IScsiRootPathIdLen = (UINT8) AsciiStrLen (ISCSI_ROOT_PATH_ID);\r
\r
- if ((Length <= IScsiRootPathIdLen) || (NetCompareMem (RootPath, ISCSI_ROOT_PATH_ID, IScsiRootPathIdLen) != 0)) {\r
+ if ((Length <= IScsiRootPathIdLen) || (CompareMem (RootPath, ISCSI_ROOT_PATH_ID, IScsiRootPathIdLen) != 0)) {\r
return EFI_NOT_FOUND;\r
}\r
//\r
RootPath += IScsiRootPathIdLen;\r
Length = (UINT8) (Length - IScsiRootPathIdLen);\r
\r
- TmpStr = (CHAR8 *) NetAllocatePool (Length + 1);\r
+ TmpStr = (CHAR8 *) AllocatePool (Length + 1);\r
if (TmpStr == NULL) {\r
return EFI_OUT_OF_RESOURCES;\r
}\r
\r
- NetCopyMem (TmpStr, RootPath, Length);\r
+ CopyMem (TmpStr, RootPath, Length);\r
TmpStr[Length] = '\0';\r
\r
Index = 0;\r
FieldIndex = 0;\r
- NetZeroMem (&Fields[0], sizeof (Fields));\r
+ ZeroMem (&Fields[0], sizeof (Fields));\r
\r
//\r
// Extract the fields in the Root Path option string.\r
goto ON_EXIT;\r
}\r
} else {\r
- NetZeroMem (ConfigNvData->BootLun, sizeof (ConfigNvData->BootLun));\r
+ ZeroMem (ConfigNvData->BootLun, sizeof (ConfigNvData->BootLun));\r
}\r
//\r
// Get the target iSCSI Name.\r
\r
ON_EXIT:\r
\r
- NetFreePool (TmpStr);\r
+ gBS->FreePool (TmpStr);\r
\r
return Status;\r
}\r
return EFI_NOT_READY;\r
}\r
\r
- OptionList = NetAllocatePool (OptionCount * sizeof (EFI_DHCP4_PACKET_OPTION *));\r
+ OptionList = AllocatePool (OptionCount * sizeof (EFI_DHCP4_PACKET_OPTION *));\r
if (OptionList == NULL) {\r
return EFI_NOT_READY;\r
}\r
\r
Status = This->Parse (This, Packet, &OptionCount, OptionList);\r
if (EFI_ERROR (Status)) {\r
- NetFreePool (OptionList);\r
+ gBS->FreePool (OptionList);\r
return EFI_NOT_READY;\r
}\r
\r
Status = EFI_NOT_READY;\r
}\r
\r
- NetFreePool (OptionList);\r
+ gBS->FreePool (OptionList);\r
\r
return Status;\r
}\r
return EFI_NO_MAPPING;\r
}\r
\r
- NetCopyMem (&ConfigData->NvData.LocalIp, &Dhcp4ModeData.ClientAddress, sizeof (EFI_IPv4_ADDRESS));\r
- NetCopyMem (&ConfigData->NvData.SubnetMask, &Dhcp4ModeData.SubnetMask, sizeof (EFI_IPv4_ADDRESS));\r
- NetCopyMem (&ConfigData->NvData.Gateway, &Dhcp4ModeData.RouterAddress, sizeof (EFI_IPv4_ADDRESS));\r
+ CopyMem (&ConfigData->NvData.LocalIp, &Dhcp4ModeData.ClientAddress, sizeof (EFI_IPv4_ADDRESS));\r
+ CopyMem (&ConfigData->NvData.SubnetMask, &Dhcp4ModeData.SubnetMask, sizeof (EFI_IPv4_ADDRESS));\r
+ CopyMem (&ConfigData->NvData.Gateway, &Dhcp4ModeData.RouterAddress, sizeof (EFI_IPv4_ADDRESS));\r
\r
OptionCount = 0;\r
OptionList = NULL;\r
return EFI_DEVICE_ERROR;\r
}\r
\r
- OptionList = NetAllocatePool (OptionCount * sizeof (EFI_DHCP4_PACKET_OPTION *));\r
+ OptionList = AllocatePool (OptionCount * sizeof (EFI_DHCP4_PACKET_OPTION *));\r
if (OptionList == NULL) {\r
return EFI_OUT_OF_RESOURCES;\r
}\r
\r
Status = Dhcp4->Parse (Dhcp4, Dhcp4ModeData.ReplyPacket, &OptionCount, OptionList);\r
if (EFI_ERROR (Status)) {\r
- NetFreePool (OptionList);\r
+ gBS->FreePool (OptionList);\r
return EFI_DEVICE_ERROR;\r
}\r
\r
//\r
// Primary DNS server address.\r
//\r
- NetCopyMem (&ConfigData->PrimaryDns, &OptionList[Index]->Data[0], sizeof (EFI_IPv4_ADDRESS));\r
+ CopyMem (&ConfigData->PrimaryDns, &OptionList[Index]->Data[0], sizeof (EFI_IPv4_ADDRESS));\r
\r
if (OptionList[Index]->Length > 4) {\r
//\r
// Secondary DNS server address\r
//\r
- NetCopyMem (&ConfigData->SecondaryDns, &OptionList[Index]->Data[4], sizeof (EFI_IPv4_ADDRESS));\r
+ CopyMem (&ConfigData->SecondaryDns, &OptionList[Index]->Data[4], sizeof (EFI_IPv4_ADDRESS));\r
}\r
} else if (OptionList[Index]->OpCode == DHCP4_TAG_SERVER_ID) {\r
if (OptionList[Index]->Length != 4) {\r
break;\r
}\r
\r
- NetCopyMem (&ConfigData->DhcpServer, &OptionList[Index]->Data[0], sizeof (EFI_IPv4_ADDRESS));\r
+ CopyMem (&ConfigData->DhcpServer, &OptionList[Index]->Data[0], sizeof (EFI_IPv4_ADDRESS));\r
}\r
}\r
\r
- NetFreePool (OptionList);\r
+ gBS->FreePool (OptionList);\r
\r
return Status;\r
}\r
goto ON_EXIT;\r
}\r
\r
- ParaList = NetAllocatePool (sizeof (EFI_DHCP4_PACKET_OPTION) + 3);\r
+ ParaList = AllocatePool (sizeof (EFI_DHCP4_PACKET_OPTION) + 3);\r
if (ParaList == NULL) {\r
Status = EFI_OUT_OF_RESOURCES;\r
goto ON_EXIT;\r
ParaList->Data[2] = DHCP4_TAG_DNS;\r
ParaList->Data[3] = DHCP4_TAG_ROOT_PATH;\r
\r
- NetZeroMem (&Dhcp4ConfigData, sizeof (EFI_DHCP4_CONFIG_DATA));\r
+ ZeroMem (&Dhcp4ConfigData, sizeof (EFI_DHCP4_CONFIG_DATA));\r
Dhcp4ConfigData.OptionCount = 1;\r
Dhcp4ConfigData.OptionList = &ParaList;\r
\r
ON_EXIT:\r
\r
if (ParaList != NULL) {\r
- NetFreePool (ParaList);\r
+ gBS->FreePool (ParaList);\r
}\r
\r
if (Dhcp4 != NULL) {\r
}\r
\r
if (DeviceHandleBuffer != NULL) {\r
- NetFreePool (DeviceHandleBuffer);\r
+ gBS->FreePool (DeviceHandleBuffer);\r
}\r
}\r
//\r
Private = ISCSI_DRIVER_DATA_FROM_EXT_SCSI_PASS_THRU (This);\r
ConfigNvData = &Private->Session.ConfigData.NvData;\r
\r
- if ((*Target)[0] == 0 && (NetCompareMem (Lun, ConfigNvData->BootLun, sizeof (UINT64)) == 0)) {\r
+ if ((*Target)[0] == 0 && (CompareMem (Lun, ConfigNvData->BootLun, sizeof (UINT64)) == 0)) {\r
//\r
// Only one <Target, Lun> pair per iSCSI Driver instance.\r
//\r
return EFI_NOT_FOUND;\r
}\r
\r
- NetSetMem (TargetId, TARGET_MAX_BYTES, 0xFF);\r
- if (NetCompareMem (*Target, TargetId, TARGET_MAX_BYTES) == 0) {\r
+ SetMem (TargetId, TARGET_MAX_BYTES, 0xFF);\r
+ if (CompareMem (*Target, TargetId, TARGET_MAX_BYTES) == 0) {\r
(*Target)[0] = 0;\r
- NetCopyMem (Lun, ConfigNvData->BootLun, sizeof (UINT64));\r
+ CopyMem (Lun, ConfigNvData->BootLun, sizeof (UINT64));\r
\r
return EFI_SUCCESS;\r
}\r
ConfigNvData = &Session->ConfigData.NvData;\r
AuthConfig = &Session->AuthData.AuthConfig;\r
\r
- if (NetCompareMem (&Lun, ConfigNvData->BootLun, sizeof (UINT64)) != 0) {\r
+ if (CompareMem (&Lun, ConfigNvData->BootLun, sizeof (UINT64)) != 0) {\r
return EFI_NOT_FOUND;\r
}\r
\r
DevPathNodeLen = sizeof (ISCSI_DEVICE_PATH) + AsciiStrLen (ConfigNvData->TargetName) + 1;\r
- Node = NetAllocatePool (DevPathNodeLen);\r
+ Node = AllocatePool (DevPathNodeLen);\r
if (Node == NULL) {\r
return EFI_OUT_OF_RESOURCES;\r
}\r
break;\r
}\r
\r
- NetCopyMem (&Node->Iscsi.Lun, ConfigNvData->BootLun, sizeof (UINT64));\r
+ CopyMem (&Node->Iscsi.Lun, ConfigNvData->BootLun, sizeof (UINT64));\r
Node->Iscsi.TargetPortalGroupTag = Session->TargetPortalGroupTag;\r
AsciiStrCpy ((CHAR8 *) Node + sizeof (ISCSI_DEVICE_PATH), ConfigNvData->TargetName);\r
\r
Private = ISCSI_DRIVER_DATA_FROM_EXT_SCSI_PASS_THRU (This);\r
ConfigNvData = &Private->Session.ConfigData.NvData;\r
\r
- NetZeroMem (*Target, TARGET_MAX_BYTES);\r
+ ZeroMem (*Target, TARGET_MAX_BYTES);\r
\r
if (AsciiStrCmp (ConfigNvData->TargetName, (CHAR8 *) DevicePath + sizeof (ISCSI_DEVICE_PATH)) != 0) {\r
return EFI_UNSUPPORTED;\r
}\r
\r
- NetCopyMem (Lun, ConfigNvData->BootLun, sizeof (UINT64));\r
+ CopyMem (Lun, ConfigNvData->BootLun, sizeof (UINT64));\r
\r
return EFI_SUCCESS;\r
}\r
{\r
UINT8 TargetId[TARGET_MAX_BYTES];\r
\r
- NetSetMem (TargetId, TARGET_MAX_BYTES, 0xFF);\r
+ SetMem (TargetId, TARGET_MAX_BYTES, 0xFF);\r
\r
- if (NetCompareMem (*Target, TargetId, TARGET_MAX_BYTES) == 0) {\r
+ if (CompareMem (*Target, TargetId, TARGET_MAX_BYTES) == 0) {\r
(*Target)[0] = 0;\r
return EFI_SUCCESS;\r
} else if ((*Target)[0] == 0) {\r
\r
--*/\r
{\r
- NetZeroMem (Header, sizeof (EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_HEADER));\r
+ ZeroMem (Header, sizeof (EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_HEADER));\r
\r
Header->Signature = EFI_ACPI_3_0_ISCSI_BOOT_FIRMWARE_TABLE_SIGNATURE;\r
Header->Length = IBFT_HEAP_OFFSET;\r
\r
Control = (EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_CONTROL_STRUCTURE *) (Table + 1);\r
\r
- NetZeroMem (Control, sizeof (EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_CONTROL_STRUCTURE));\r
+ ZeroMem (Control, sizeof (EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_CONTROL_STRUCTURE));\r
\r
Control->Header.StructureId = EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_CONTROL_STRUCTURE_ID;\r
Control->Header.Version = EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_CONTROL_STRUCTURE_VERSION;\r
//\r
*Heap -= Len + 1;\r
\r
- NetCopyMem (*Heap, Data, Len);\r
+ CopyMem (*Heap, Data, Len);\r
*(*Heap + Len) = 0;\r
}\r
\r
\r
Control->InitiatorOffset = (UINT16) ((UINTN) Initiator - (UINTN) Table);\r
\r
- NetZeroMem (Initiator, sizeof (EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_INITIATOR_STRUCTURE));\r
+ ZeroMem (Initiator, sizeof (EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_INITIATOR_STRUCTURE));\r
\r
Initiator->Header.StructureId = EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_INITIATOR_STRUCTURE_ID;\r
Initiator->Header.Version = EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_INITIATOR_STRUCTURE_VERSION;\r
{\r
UINTN Index;\r
\r
- NetZeroMem (V6, sizeof (EFI_IPv6_ADDRESS));\r
+ ZeroMem (V6, sizeof (EFI_IPv6_ADDRESS));\r
\r
V6->Addr[10] = 0xff;\r
V6->Addr[11] = 0xff;\r
//\r
// Fill the Nic section.\r
//\r
- NetZeroMem (Nic, sizeof (EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_NIC_STRUCTURE));\r
+ ZeroMem (Nic, sizeof (EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_NIC_STRUCTURE));\r
\r
Nic->Header.StructureId = EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_NIC_STRUCTURE_ID;\r
Nic->Header.Version = EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_NIC_STRUCTURE_VERSION;\r
IScsiMapV4ToV6Addr (&SessionConfigData->DhcpServer, &Nic->DhcpServer);\r
\r
Mac = IScsiGetMacAddress (DriverData->Controller);\r
- NetCopyMem (Nic->Mac, Mac, sizeof (Nic->Mac));\r
+ CopyMem (Nic->Mac, Mac, sizeof (Nic->Mac));\r
\r
//\r
// Get the PCI location of the Nic.\r
//\r
// Fill the Target section.\r
//\r
- NetZeroMem (Target, sizeof (EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_TARGET_STRUCTURE));\r
+ ZeroMem (Target, sizeof (EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_TARGET_STRUCTURE));\r
\r
Target->Header.StructureId = EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_TARGET_STRUCTURE_ID;\r
Target->Header.Version = EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_TARGET_STRUCTURE_VERSION;\r
Target->NicIndex = (UINT8) Index;\r
\r
IScsiMapV4ToV6Addr (&SessionConfigData->NvData.TargetIp, &Target->Ip);\r
- NetCopyMem (Target->BootLun, SessionConfigData->NvData.BootLun, sizeof (Target->BootLun));\r
+ CopyMem (Target->BootLun, SessionConfigData->NvData.BootLun, sizeof (Target->BootLun));\r
\r
//\r
// Target iSCSI Name, CHAP name/secret, reverse CHAP name/secret.\r
}\r
\r
Signature = Table->Signature;\r
- NetFreePool (Table);\r
+ gBS->FreePool (Table);\r
\r
if (Signature == EFI_ACPI_3_0_ISCSI_BOOT_FIRMWARE_TABLE_SIGNATURE) {\r
//\r
//\r
// Allocate 4k bytes to hold the ACPI table.\r
//\r
- Table = NetAllocatePool (IBFT_MAX_SIZE);\r
+ Table = AllocatePool (IBFT_MAX_SIZE);\r
if (Table == NULL) {\r
return ;\r
}\r
IScsiFillInitiatorSection (Table, &Heap, HandleBuffer[0]);\r
IScsiFillNICAndTargetSections (Table, &Heap, HandleCount, HandleBuffer);\r
\r
- NetFreePool (HandleBuffer);\r
+ gBS->FreePool (HandleBuffer);\r
\r
TableHandle = 0;\r
\r
AcpiSupport->PublishTables (AcpiSupport, EFI_ACPI_TABLE_VERSION_3_0);\r
}\r
\r
- NetFreePool (Table);\r
+ gBS->FreePool (Table);\r
}\r
UINT32 InitiatorTaskTag;\r
UINT16 NextCID;\r
\r
- NET_LIST_ENTRY Conns;\r
+ LIST_ENTRY Conns;\r
UINT32 NumConns;\r
\r
- NET_LIST_ENTRY TcbList;\r
+ LIST_ENTRY TcbList;\r
\r
//\r
// session-wide parameters\r
\r
struct _ISCSI_CONNECTION {\r
UINT32 Signature;\r
- NET_LIST_ENTRY Link;\r
+ LIST_ENTRY Link;\r
\r
EFI_EVENT TimeoutEvent;\r
\r
CHAR8 Digit;\r
UINTN Temp;\r
\r
- NetZeroMem (Lun, 8);\r
- NetZeroMem (LunUnitStr, sizeof (LunUnitStr));\r
+ ZeroMem (Lun, 8);\r
+ ZeroMem (LunUnitStr, sizeof (LunUnitStr));\r
\r
Index = 0;\r
LunUnitStr[0] = Str;\r
ISCSI_DRIVER_DATA *Private;\r
EFI_STATUS Status;\r
\r
- Private = NetAllocateZeroPool (sizeof (ISCSI_DRIVER_DATA));\r
+ Private = AllocateZeroPool (sizeof (ISCSI_DRIVER_DATA));\r
if (Private == NULL) {\r
return NULL;\r
}\r
&Private->ExitBootServiceEvent\r
);\r
if (EFI_ERROR (Status)) {\r
- NetFreePool (Private);\r
+ gBS->FreePool (Private);\r
return NULL;\r
}\r
\r
- NetCopyMem(&Private->IScsiExtScsiPassThru, &gIScsiExtScsiPassThruProtocolTemplate, sizeof(EFI_EXT_SCSI_PASS_THRU_PROTOCOL));\r
+ CopyMem(&Private->IScsiExtScsiPassThru, &gIScsiExtScsiPassThruProtocolTemplate, sizeof(EFI_EXT_SCSI_PASS_THRU_PROTOCOL));\r
\r
//\r
// 0 is designated to the TargetId, so use another value for the AdapterId.\r
);\r
if (EFI_ERROR (Status)) {\r
gBS->CloseEvent (Private->ExitBootServiceEvent);\r
- NetFreePool (Private);\r
+ gBS->FreePool (Private);\r
\r
return NULL;\r
}\r
Private->DevicePath\r
);\r
\r
- NetFreePool (Private->DevicePath);\r
+ gBS->FreePool (Private->DevicePath);\r
}\r
\r
if (Private->ExtScsiPassThruHandle != NULL) {\r
\r
gBS->CloseEvent (Private->ExitBootServiceEvent);\r
\r
- NetFreePool (Private);\r
+ gBS->FreePool (Private);\r
}\r
\r
EFI_STATUS\r
\r
--*/\r
{\r
- NetListInsertTail (&Session->Conns, &Conn->Link);\r
+ InsertTailList (&Session->Conns, &Conn->Link);\r
Conn->Session = Session;\r
Session->NumConns++;\r
}\r
\r
--*/\r
{\r
- NetListRemoveEntry (&Conn->Link);\r
+ RemoveEntryList (&Conn->Link);\r
Conn->Session->NumConns--;\r
Conn->Session = NULL;\r
}\r
TCP4_IO_CONFIG_DATA Tcp4IoConfig;\r
EFI_STATUS Status;\r
\r
- Conn = NetAllocatePool (sizeof (ISCSI_CONNECTION));\r
+ Conn = AllocatePool (sizeof (ISCSI_CONNECTION));\r
if (Conn == NULL) {\r
return NULL;\r
}\r
\r
Status = gBS->CreateEvent (\r
EFI_EVENT_TIMER,\r
- NET_TPL_TIMER,\r
+ TPL_CALLBACK,\r
NULL,\r
NULL,\r
&Conn->TimeoutEvent\r
);\r
if (EFI_ERROR (Status)) {\r
- NetFreePool (Conn);\r
+ gBS->FreePool (Conn);\r
return NULL;\r
}\r
\r
Conn->HeaderDigest = ISCSI_DIGEST_NONE;\r
Conn->DataDigest = ISCSI_DIGEST_NONE;\r
\r
- NetCopyMem (&Tcp4IoConfig.LocalIp, &Session->ConfigData.NvData.LocalIp, sizeof (EFI_IPv4_ADDRESS));\r
- NetCopyMem (&Tcp4IoConfig.SubnetMask, &Session->ConfigData.NvData.SubnetMask, sizeof (EFI_IPv4_ADDRESS));\r
- NetCopyMem (&Tcp4IoConfig.Gateway, &Session->ConfigData.NvData.Gateway, sizeof (EFI_IPv4_ADDRESS));\r
- NetCopyMem (&Tcp4IoConfig.RemoteIp, &Session->ConfigData.NvData.TargetIp, sizeof (EFI_IPv4_ADDRESS));\r
+ CopyMem (&Tcp4IoConfig.LocalIp, &Session->ConfigData.NvData.LocalIp, sizeof (EFI_IPv4_ADDRESS));\r
+ CopyMem (&Tcp4IoConfig.SubnetMask, &Session->ConfigData.NvData.SubnetMask, sizeof (EFI_IPv4_ADDRESS));\r
+ CopyMem (&Tcp4IoConfig.Gateway, &Session->ConfigData.NvData.Gateway, sizeof (EFI_IPv4_ADDRESS));\r
+ CopyMem (&Tcp4IoConfig.RemoteIp, &Session->ConfigData.NvData.TargetIp, sizeof (EFI_IPv4_ADDRESS));\r
\r
Tcp4IoConfig.RemotePort = Session->ConfigData.NvData.TargetPort;\r
\r
);\r
if (EFI_ERROR (Status)) {\r
gBS->CloseEvent (Conn->TimeoutEvent);\r
- NetFreePool (Conn);\r
+ gBS->FreePool (Conn);\r
Conn = NULL;\r
}\r
\r
Tcp4IoDestroySocket (&Conn->Tcp4Io);\r
NetbufQueFlush (&Conn->RspQue);\r
gBS->CloseEvent (Conn->TimeoutEvent);\r
- NetFreePool (Conn);\r
+ gBS->FreePool (Conn);\r
}\r
\r
EFI_STATUS\r
//\r
// Add the key.\r
//\r
- NetCopyMem (Data, Key, KeyLen);\r
+ CopyMem (Data, Key, KeyLen);\r
Data += KeyLen;\r
\r
*Data = '=';\r
//\r
// Add the value.\r
//\r
- NetCopyMem (Data, Value, ValueLen);\r
+ CopyMem (Data, Value, ValueLen);\r
Data += ValueLen;\r
\r
*Data = '\0';\r
}\r
\r
LoginReq = (ISCSI_LOGIN_REQUEST *) NetbufAllocSpace (Nbuf, sizeof (ISCSI_LOGIN_REQUEST), NET_BUF_TAIL);\r
- NetZeroMem (LoginReq, sizeof (ISCSI_LOGIN_REQUEST));\r
+ ZeroMem (LoginReq, sizeof (ISCSI_LOGIN_REQUEST));\r
\r
//\r
// Init the login request pdu\r
// with their increasing StatSN values.\r
//\r
LoginReq->ExpStatSN = HTONL (Conn->ExpStatSN);\r
- NetCopyMem (LoginReq->ISID, Session->ISID, sizeof (LoginReq->ISID));\r
+ CopyMem (LoginReq->ISID, Session->ISID, sizeof (LoginReq->ISID));\r
\r
if (Conn->PartialRspRcvd) {\r
//\r
(CurrentStage != Conn->CurrentStage) ||\r
(!Conn->TransitInitiated && Transit) ||\r
(Transit && (NextStage != Conn->NextStage)) ||\r
- (NetCompareMem (Session->ISID, LoginRsp->ISID, sizeof (LoginRsp->ISID)) != 0) ||\r
+ (CompareMem (Session->ISID, LoginRsp->ISID, sizeof (LoginRsp->ISID)) != 0) ||\r
(LoginRsp->InitiatorTaskTag != Session->InitiatorTaskTag)\r
) {\r
//\r
\r
--*/\r
{\r
- NET_LIST_ENTRY *KeyValueList;\r
+ LIST_ENTRY *KeyValueList;\r
CHAR8 *TargetAddress;\r
CHAR8 *IpStr;\r
EFI_STATUS Status;\r
{\r
ASSERT (Arg != NULL);\r
\r
- NetbufFreeList ((NET_LIST_ENTRY *) Arg);\r
- NetFreePool (Arg);\r
+ NetbufFreeList ((LIST_ENTRY *) Arg);\r
+ gBS->FreePool (Arg);\r
}\r
\r
VOID\r
\r
--*/\r
{\r
- NET_LIST_ENTRY *NbufList;\r
+ LIST_ENTRY *NbufList;\r
UINT32 Len;\r
NET_BUF *PduHdr;\r
UINT8 *Header;\r
NET_BUF *DataSeg;\r
UINT32 PadAndCRC32[2];\r
\r
- NbufList = NetAllocatePool (sizeof (NET_LIST_ENTRY));\r
+ NbufList = AllocatePool (sizeof (LIST_ENTRY ));\r
if (NbufList == NULL) {\r
return EFI_OUT_OF_RESOURCES;\r
}\r
\r
- NetListInit (NbufList);\r
+ InitializeListHead (NbufList);\r
\r
//\r
// The header digest will be received together with the PDU header if exists.\r
}\r
\r
Header = NetbufAllocSpace (PduHdr, Len, NET_BUF_TAIL);\r
- NetListInsertTail (NbufList, &PduHdr->List);\r
+ InsertTailList (NbufList, &PduHdr->List);\r
\r
//\r
// First step, receive the BHS of the PDU.\r
goto ON_EXIT;\r
}\r
\r
- NetListInsertTail (NbufList, &DataSeg->List);\r
+ InsertTailList (NbufList, &DataSeg->List);\r
\r
//\r
// Receive the data segment with the data digest if any.\r
--*/\r
{\r
EFI_STATUS Status;\r
- NET_LIST_ENTRY *KeyValueList;\r
+ LIST_ENTRY *KeyValueList;\r
CHAR8 *Data;\r
UINT32 Len;\r
ISCSI_SESSION *Session;\r
Session = Conn->Session;\r
\r
Len = Conn->RspQue.BufSize;\r
- Data = NetAllocatePool (Len);\r
+ Data = AllocatePool (Len);\r
if (Data == NULL) {\r
return EFI_OUT_OF_RESOURCES;\r
}\r
//\r
KeyValueList = IScsiBuildKeyValueList (Data, Len);\r
if (KeyValueList == NULL) {\r
- NetFreePool (Data);\r
+ gBS->FreePool (Data);\r
return Status;\r
}\r
//\r
IScsiGetValueByKeyFromList (KeyValueList, ISCSI_KEY_TARGET_ALIAS);\r
IScsiGetValueByKeyFromList (KeyValueList, ISCSI_KEY_TARGET_PORTAL_GROUP_TAG);\r
\r
- if (NetListIsEmpty (KeyValueList)) {\r
+ if (IsListEmpty (KeyValueList)) {\r
//\r
// Succeed if no more keys in the list.\r
//\r
\r
IScsiFreeKeyValueList (KeyValueList);\r
\r
- NetFreePool (Data);\r
+ gBS->FreePool (Data);\r
\r
return Status;\r
}\r
return EFI_OUT_OF_RESOURCES;\r
}\r
\r
- NetZeroMem (Data, PadLen);\r
+ ZeroMem (Data, PadLen);\r
}\r
\r
return EFI_SUCCESS;\r
}\r
\r
-NET_LIST_ENTRY *\r
+LIST_ENTRY *\r
IScsiBuildKeyValueList (\r
IN CHAR8 *Data,\r
IN UINT32 Len\r
\r
--*/\r
{\r
- NET_LIST_ENTRY *ListHead;\r
+ LIST_ENTRY *ListHead;\r
ISCSI_KEY_VALUE_PAIR *KeyValuePair;\r
\r
- ListHead = NetAllocatePool (sizeof (NET_LIST_ENTRY));\r
+ ListHead = AllocatePool (sizeof (LIST_ENTRY ));\r
if (ListHead == NULL) {\r
return NULL;\r
}\r
\r
- NetListInit (ListHead);\r
+ InitializeListHead (ListHead);\r
\r
while (Len > 0) {\r
- KeyValuePair = NetAllocatePool (sizeof (ISCSI_KEY_VALUE_PAIR));\r
+ KeyValuePair = AllocatePool (sizeof (ISCSI_KEY_VALUE_PAIR));\r
if (KeyValuePair == NULL) {\r
goto ON_ERROR;\r
}\r
\r
- NetListInit (&KeyValuePair->List);\r
+ InitializeListHead (&KeyValuePair->List);\r
\r
KeyValuePair->Key = Data;\r
\r
Data++;\r
Len--;\r
} else {\r
- NetFreePool (KeyValuePair);\r
+ gBS->FreePool (KeyValuePair);\r
goto ON_ERROR;\r
}\r
\r
KeyValuePair->Value = Data;\r
\r
- NetListInsertTail (ListHead, &KeyValuePair->List);;\r
+ InsertTailList (ListHead, &KeyValuePair->List);;\r
\r
Data += AsciiStrLen (KeyValuePair->Value) + 1;\r
Len -= (UINT32) AsciiStrLen (KeyValuePair->Value) + 1;\r
\r
CHAR8 *\r
IScsiGetValueByKeyFromList (\r
- IN NET_LIST_ENTRY *KeyValueList,\r
+ IN LIST_ENTRY *KeyValueList,\r
IN CHAR8 *Key\r
)\r
/*++\r
\r
--*/\r
{\r
- NET_LIST_ENTRY *Entry;\r
+ LIST_ENTRY *Entry;\r
ISCSI_KEY_VALUE_PAIR *KeyValuePair;\r
CHAR8 *Value;\r
\r
if (AsciiStrCmp (KeyValuePair->Key, Key) == 0) {\r
Value = KeyValuePair->Value;\r
\r
- NetListRemoveEntry (&KeyValuePair->List);\r
- NetFreePool (KeyValuePair);\r
+ RemoveEntryList (&KeyValuePair->List);\r
+ gBS->FreePool (KeyValuePair);\r
break;\r
}\r
}\r
\r
VOID\r
IScsiFreeKeyValueList (\r
- IN NET_LIST_ENTRY *KeyValueList\r
+ IN LIST_ENTRY *KeyValueList\r
)\r
/*++\r
\r
\r
--*/\r
{\r
- NET_LIST_ENTRY *Entry;\r
+ LIST_ENTRY *Entry;\r
ISCSI_KEY_VALUE_PAIR *KeyValuePair;\r
\r
- while (!NetListIsEmpty (KeyValueList)) {\r
+ while (!IsListEmpty (KeyValueList)) {\r
Entry = NetListRemoveHead (KeyValueList);\r
KeyValuePair = NET_LIST_USER_STRUCT (Entry, ISCSI_KEY_VALUE_PAIR, List);\r
\r
- NetFreePool (KeyValuePair);\r
+ gBS->FreePool (KeyValuePair);\r
}\r
\r
- NetFreePool (KeyValueList);\r
+ gBS->FreePool (KeyValueList);\r
}\r
\r
EFI_STATUS\r
}\r
}\r
\r
- if ((Len < 4) || (NetCompareMem (Name, "iqn.", 4) != 0)) {\r
+ if ((Len < 4) || (CompareMem (Name, "iqn.", 4) != 0)) {\r
//\r
// Only IQN format is accepted now.\r
//\r
return EFI_NOT_READY;\r
}\r
\r
- NewTcb = NetAllocateZeroPool (sizeof (ISCSI_TCB));\r
+ NewTcb = AllocateZeroPool (sizeof (ISCSI_TCB));\r
if (NewTcb == NULL) {\r
return EFI_OUT_OF_RESOURCES;\r
}\r
\r
- NetListInit (&NewTcb->Link);\r
+ InitializeListHead (&NewTcb->Link);\r
\r
NewTcb->SoFarInOrder = TRUE;\r
NewTcb->InitiatorTaskTag = Session->InitiatorTaskTag;\r
NewTcb->CmdSN = Session->CmdSN;\r
NewTcb->Conn = Conn;\r
\r
- NetListInsertTail (&Session->TcbList, &NewTcb->Link);\r
+ InsertTailList (&Session->TcbList, &NewTcb->Link);\r
\r
//\r
// Advance the initiator task tag.\r
\r
--*/\r
{\r
- NetListRemoveEntry (&Tcb->Link);\r
+ RemoveEntryList (&Tcb->Link);\r
\r
- NetFreePool (Tcb);\r
+ gBS->FreePool (Tcb);\r
}\r
\r
ISCSI_TCB *\r
IScsiFindTcbByITT (\r
- IN NET_LIST_ENTRY *TcbList,\r
+ IN LIST_ENTRY *TcbList,\r
IN UINT32 InitiatorTaskTag\r
)\r
/*++\r
--*/\r
{\r
ISCSI_TCB *Tcb;\r
- NET_LIST_ENTRY *Entry;\r
+ LIST_ENTRY *Entry;\r
\r
Tcb = NULL;\r
\r
\r
--*/\r
{\r
- NET_LIST_ENTRY *NbufList;\r
+ LIST_ENTRY *NbufList;\r
NET_BUF *Pdu;\r
NET_BUF *PduHeader;\r
NET_BUF *DataSeg;\r
ScsiCmd = (SCSI_COMMAND *) NetbufAllocSpace (PduHeader, Length, NET_BUF_TAIL);\r
Header = (ISCSI_ADDITIONAL_HEADER *) (ScsiCmd + 1);\r
\r
- NetZeroMem (ScsiCmd, Length);\r
+ ZeroMem (ScsiCmd, Length);\r
\r
ISCSI_SET_OPCODE (ScsiCmd, ISCSI_OPCODE_SCSI_CMD, 0);\r
ISCSI_SET_FLAG (ScsiCmd, ISCSI_TASK_ATTR_SIMPLE);\r
}\r
\r
ScsiCmd->TotalAHSLength = AHSLength;\r
- NetCopyMem (ScsiCmd->Lun, &Lun, sizeof (ScsiCmd->Lun));\r
+ CopyMem (ScsiCmd->Lun, &Lun, sizeof (ScsiCmd->Lun));\r
ScsiCmd->InitiatorTaskTag = NTOHL (Tcb->InitiatorTaskTag);\r
ScsiCmd->CmdSN = NTOHL (Tcb->CmdSN);\r
ScsiCmd->ExpStatSN = NTOHL (Tcb->Conn->ExpStatSN);\r
\r
- NetCopyMem (ScsiCmd->CDB, Packet->Cdb, sizeof (ScsiCmd->CDB));\r
+ CopyMem (ScsiCmd->CDB, Packet->Cdb, sizeof (ScsiCmd->CDB));\r
\r
if (Packet->CdbLength > 16) {\r
Header->Length = NTOHS (Packet->CdbLength - 15);\r
Header->Type = ISCSI_AHS_TYPE_EXT_CDB;\r
\r
- NetCopyMem (Header + 1, (UINT8 *) Packet->Cdb + 16, Packet->CdbLength - 16);\r
+ CopyMem (Header + 1, (UINT8 *) Packet->Cdb + 16, Packet->CdbLength - 16);\r
}\r
\r
Pdu = PduHeader;\r
goto ON_EXIT;\r
}\r
\r
- NbufList = NetAllocatePool (sizeof (NET_LIST_ENTRY));\r
+ NbufList = AllocatePool (sizeof (LIST_ENTRY ));\r
if (NbufList == NULL) {\r
NetbufFree (PduHeader);\r
NetbufFree (DataSeg);\r
goto ON_EXIT;\r
}\r
\r
- NetListInit (NbufList);\r
- NetListInsertTail (NbufList, &PduHeader->List);\r
- NetListInsertTail (NbufList, &DataSeg->List);\r
+ InitializeListHead (NbufList);\r
+ InsertTailList (NbufList, &PduHeader->List);\r
+ InsertTailList (NbufList, &DataSeg->List);\r
\r
Pdu = NetbufFromBufList (NbufList, 0, 0, IScsiFreeNbufList, NbufList);\r
if (Pdu == NULL) {\r
\r
--*/\r
{\r
- NET_LIST_ENTRY *NbufList;\r
+ LIST_ENTRY *NbufList;\r
NET_BUF *PduHdr;\r
NET_BUF *DataSeg;\r
NET_BUF *Pdu;\r
ISCSI_SCSI_DATA_OUT *DataOutHdr;\r
ISCSI_XFER_CONTEXT *XferContext;\r
\r
- NbufList = NetAllocatePool (sizeof (NET_LIST_ENTRY));\r
+ NbufList = AllocatePool (sizeof (LIST_ENTRY ));\r
if (NbufList == NULL) {\r
return NULL;\r
}\r
\r
- NetListInit (NbufList);\r
+ InitializeListHead (NbufList);\r
\r
//\r
// Allocate memory for the BHS.\r
//\r
PduHdr = NetbufAlloc (sizeof (ISCSI_SCSI_DATA_OUT));\r
if (PduHdr == NULL) {\r
- NetFreePool (NbufList);\r
+ gBS->FreePool (NbufList);\r
return NULL;\r
}\r
//\r
// Insert the BHS into the buffer list.\r
//\r
- NetListInsertTail (NbufList, &PduHdr->List);\r
+ InsertTailList (NbufList, &PduHdr->List);\r
\r
DataOutHdr = (ISCSI_SCSI_DATA_OUT *) NetbufAllocSpace (PduHdr, sizeof (ISCSI_SCSI_DATA_OUT), NET_BUF_TAIL);\r
XferContext = &Tcb->XferContext;\r
\r
- NetZeroMem (DataOutHdr, sizeof (ISCSI_SCSI_DATA_OUT));\r
+ ZeroMem (DataOutHdr, sizeof (ISCSI_SCSI_DATA_OUT));\r
\r
//\r
// Set the flags and fields of the Data Out PDU BHS.\r
DataOutHdr->BufferOffset = HTONL (XferContext->Offset);\r
\r
if (XferContext->TargetTransferTag != ISCSI_RESERVED_TAG) {\r
- NetCopyMem (&DataOutHdr->Lun, &Lun, sizeof (DataOutHdr->Lun));\r
+ CopyMem (&DataOutHdr->Lun, &Lun, sizeof (DataOutHdr->Lun));\r
}\r
//\r
// Build the data segment for this Data Out PDU.\r
// Put the data segment into the buffer list and combine it with the BHS\r
// into a full Data Out PDU.\r
//\r
- NetListInsertTail (NbufList, &DataSeg->List);\r
+ InsertTailList (NbufList, &DataSeg->List);\r
Pdu = NetbufFromBufList (NbufList, 0, 0, IScsiFreeNbufList, NbufList);\r
if (Pdu == NULL) {\r
IScsiFreeNbufList (NbufList);\r
return Pdu;\r
}\r
\r
-NET_LIST_ENTRY *\r
+LIST_ENTRY *\r
IScsiGenerateDataOutPduSequence (\r
IN UINT8 *Data,\r
IN ISCSI_TCB *Tcb,\r
\r
--*/\r
{\r
- NET_LIST_ENTRY *PduList;\r
+ LIST_ENTRY *PduList;\r
UINT32 DataSN;\r
UINT32 DataLen;\r
NET_BUF *DataOutPdu;\r
ISCSI_CONNECTION *Conn;\r
ISCSI_XFER_CONTEXT *XferContext;\r
\r
- PduList = NetAllocatePool (sizeof (NET_LIST_ENTRY));\r
+ PduList = AllocatePool (sizeof (LIST_ENTRY ));\r
if (PduList == NULL) {\r
return NULL;\r
}\r
\r
- NetListInit (PduList);\r
+ InitializeListHead (PduList);\r
\r
DataSN = 0;\r
Conn = Tcb->Conn;\r
goto ON_EXIT;\r
}\r
\r
- NetListInsertTail (PduList, &DataOutPdu->List);\r
+ InsertTailList (PduList, &DataOutPdu->List);\r
\r
//\r
// Update the context and DataSN.\r
\r
--*/\r
{\r
- NET_LIST_ENTRY *DataOutPduList;\r
- NET_LIST_ENTRY *Entry;\r
+ LIST_ENTRY *DataOutPduList;\r
+ LIST_ENTRY *Entry;\r
NET_BUF *Pdu;\r
EFI_STATUS Status;\r
\r
\r
Packet->SenseDataLength = (UINT8) MIN (SenseData->Length, Packet->SenseDataLength);\r
if (Packet->SenseDataLength != 0) {\r
- NetCopyMem (Packet->SenseData, &SenseData->Data[0], Packet->SenseDataLength);\r
+ CopyMem (Packet->SenseData, &SenseData->Data[0], Packet->SenseDataLength);\r
}\r
} else {\r
Packet->SenseDataLength = 0;\r
Session->ISID[4] = (UINT8) Random;\r
Session->ISID[5] = (UINT8) (Random >> 8);\r
\r
- NetListInit (&Session->Conns);\r
- NetListInit (&Session->TcbList);\r
+ InitializeListHead (&Session->Conns);\r
+ InitializeListHead (&Session->TcbList);\r
}\r
\r
Session->TSIH = 0;\r
return EFI_SUCCESS;\r
}\r
\r
- ASSERT (!NetListIsEmpty (&Session->Conns));\r
+ ASSERT (!IsListEmpty (&Session->Conns));\r
\r
Private = ISCSI_DRIVER_DATA_FROM_SESSION (Session);\r
\r
- while (!NetListIsEmpty (&Session->Conns)) {\r
+ while (!IsListEmpty (&Session->Conns)) {\r
Conn = NET_LIST_USER_STRUCT_S (\r
Session->Conns.ForwardLink,\r
ISCSI_CONNECTION,\r
} ISCSI_IN_BUFFER_CONTEXT;\r
\r
typedef struct _ISCSI_TCB {\r
- NET_LIST_ENTRY Link;\r
+ LIST_ENTRY Link;\r
\r
BOOLEAN SoFarInOrder;\r
UINT32 ExpDataSN;\r
} ISCSI_TCB;\r
\r
typedef struct _ISCSI_KEY_VALUE_PAIR {\r
- NET_LIST_ENTRY List;\r
+ LIST_ENTRY List;\r
\r
CHAR8 *Key;\r
CHAR8 *Value;\r
IN UINT32 Len\r
);\r
\r
-NET_LIST_ENTRY *\r
+LIST_ENTRY *\r
IScsiBuildKeyValueList (\r
IN CHAR8 *Data,\r
IN UINT32 Len\r
\r
CHAR8 *\r
IScsiGetValueByKeyFromList (\r
- IN NET_LIST_ENTRY *KeyValueList,\r
+ IN LIST_ENTRY *KeyValueList,\r
IN CHAR8 *Key\r
);\r
\r
VOID\r
IScsiFreeKeyValueList (\r
- IN NET_LIST_ENTRY *KeyValueList\r
+ IN LIST_ENTRY *KeyValueList\r
);\r
\r
EFI_STATUS\r
AccessPoint->RemotePort = ConfigData->RemotePort;\r
AccessPoint->ActiveFlag = TRUE;\r
\r
- NetCopyMem (&AccessPoint->StationAddress, &ConfigData->LocalIp, sizeof (EFI_IPv4_ADDRESS));\r
- NetCopyMem (&AccessPoint->SubnetMask, &ConfigData->SubnetMask, sizeof (EFI_IPv4_ADDRESS));\r
- NetCopyMem (&AccessPoint->RemoteAddress, &ConfigData->RemoteIp, sizeof (EFI_IPv4_ADDRESS));\r
+ CopyMem (&AccessPoint->StationAddress, &ConfigData->LocalIp, sizeof (EFI_IPv4_ADDRESS));\r
+ CopyMem (&AccessPoint->SubnetMask, &ConfigData->SubnetMask, sizeof (EFI_IPv4_ADDRESS));\r
+ CopyMem (&AccessPoint->RemoteAddress, &ConfigData->RemoteIp, sizeof (EFI_IPv4_ADDRESS));\r
\r
//\r
// Configure the TCP4 protocol.\r
//\r
Status = gBS->CreateEvent (\r
EFI_EVENT_NOTIFY_SIGNAL,\r
- NET_TPL_EVENT,\r
+ TPL_NOTIFY,\r
Tcp4IoCommonNotify,\r
&Tcp4Io->IsConnDone,\r
&Tcp4Io->ConnToken.CompletionToken.Event\r
\r
Status = gBS->CreateEvent (\r
EFI_EVENT_NOTIFY_SIGNAL,\r
- NET_TPL_EVENT,\r
+ TPL_NOTIFY,\r
Tcp4IoCommonNotify,\r
&Tcp4Io->IsTxDone,\r
&Tcp4Io->TxToken.CompletionToken.Event\r
\r
Status = gBS->CreateEvent (\r
EFI_EVENT_NOTIFY_SIGNAL,\r
- NET_TPL_EVENT,\r
+ TPL_NOTIFY,\r
Tcp4IoCommonNotify,\r
&Tcp4Io->IsRxDone,\r
&Tcp4Io->RxToken.CompletionToken.Event\r
\r
Status = gBS->CreateEvent (\r
EFI_EVENT_NOTIFY_SIGNAL,\r
- NET_TPL_EVENT,\r
+ TPL_NOTIFY,\r
Tcp4IoCommonNotify,\r
&Tcp4Io->IsCloseDone,\r
&Tcp4Io->CloseToken.CompletionToken.Event\r
EFI_TCP4_PROTOCOL *Tcp4;\r
EFI_STATUS Status;\r
\r
- TxData = NetAllocatePool (sizeof (EFI_TCP4_TRANSMIT_DATA) + (Packet->BlockOpNum - 1) * sizeof (EFI_TCP4_FRAGMENT_DATA));\r
+ TxData = AllocatePool (sizeof (EFI_TCP4_TRANSMIT_DATA) + (Packet->BlockOpNum - 1) * sizeof (EFI_TCP4_FRAGMENT_DATA));\r
if (TxData == NULL) {\r
return EFI_OUT_OF_RESOURCES;\r
}\r
\r
ON_EXIT:\r
\r
- NetFreePool (TxData);\r
+ gBS->FreePool (TxData);\r
\r
return Status;\r
}\r
UINT32 CurrentFragment;\r
\r
FragmentCount = Packet->BlockOpNum;\r
- Fragment = NetAllocatePool (FragmentCount * sizeof (NET_FRAGMENT));\r
+ Fragment = AllocatePool (FragmentCount * sizeof (NET_FRAGMENT));\r
if (Fragment == NULL) {\r
return EFI_OUT_OF_RESOURCES;\r
}\r
\r
ON_EXIT:\r
\r
- NetFreePool (Fragment);\r
+ gBS->FreePool (Fragment);\r
\r
return Status;\r
}\r
//\r
// Copy MD5 states to S\r
//\r
- NetCopyMem (S, Md5Ctx->States, MD5_HASHSIZE);\r
+ CopyMem (S, Md5Ctx->States, MD5_HASHSIZE);\r
\r
t = 0;\r
for (i = 0; i < 4; i++) {\r
UINTN Limit;\r
\r
for (Limit = 64 - Md5Ctx->Count; DataLen >= 64 - Md5Ctx->Count; Limit = 64) {\r
- NetCopyMem (Md5Ctx->M + Md5Ctx->Count, (VOID *)Data, Limit);\r
+ CopyMem (Md5Ctx->M + Md5Ctx->Count, (VOID *)Data, Limit);\r
MD5Transform (Md5Ctx);\r
\r
Md5Ctx->Count = 0;\r
DataLen -= Limit;\r
}\r
\r
- NetCopyMem (Md5Ctx->M + Md5Ctx->Count, (VOID *)Data, DataLen);\r
+ CopyMem (Md5Ctx->M + Md5Ctx->Count, (VOID *)Data, DataLen);\r
Md5Ctx->Count += DataLen;\r
}\r
\r
\r
--*/\r
{\r
- NetZeroMem (Md5Ctx, sizeof (*Md5Ctx));\r
+ ZeroMem (Md5Ctx, sizeof (*Md5Ctx));\r
\r
//\r
// Set magic initialization constants.\r
//\r
// Store Hashed value & Zeroize sensitive context information.\r
//\r
- NetCopyMem (HashVal, (UINT8 *) Md5Ctx->States, MD5_HASHSIZE);\r
- NetZeroMem ((UINT8 *)Md5Ctx, sizeof (*Md5Ctx));\r
+ CopyMem (HashVal, (UINT8 *) Md5Ctx->States, MD5_HASHSIZE);\r
+ ZeroMem ((UINT8 *)Md5Ctx, sizeof (*Md5Ctx));\r
\r
return EFI_SUCCESS;\r
}\r
Md5Ctx->Length = LShiftU64 (Md5Ctx->Length, 3);\r
MD5UpdateBlock (Md5Ctx, (CONST UINT8 *) &Md5Ctx->Length, 8);\r
\r
- NetZeroMem (Md5Ctx->M, sizeof (Md5Ctx->M));\r
+ ZeroMem (Md5Ctx->M, sizeof (Md5Ctx->M));\r
Md5Ctx->Length = 0;\r
Md5Ctx->Status = EFI_ALREADY_STARTED;\r
return MD5Final (Md5Ctx, HashVal);\r
Instance = IP4_CONFIG_INSTANCE_FROM_NIC_IP4CONFIG (This);\r
\r
if (Name != NULL) {\r
- NetCopyMem (Name, Instance->NicName, IP4_NIC_NAME_LENGTH);\r
+ CopyMem (Name, Instance->NicName, IP4_NIC_NAME_LENGTH);\r
}\r
\r
if (NicAddr != NULL) {\r
Config = Ip4ConfigFindNicVariable (Variable, NicAddr);\r
\r
if (Config == NULL) {\r
- NetFreePool (Variable);\r
+ gBS->FreePool (Variable);\r
return NULL;\r
}\r
\r
Ip4ConfigWriteVariable (NewVariable);\r
\r
if (NewVariable != NULL) {\r
- NetFreePool (NewVariable);\r
+ gBS->FreePool (NewVariable);\r
};\r
\r
- NetFreePool (Config);\r
+ gBS->FreePool (Config);\r
Config = NULL;\r
}\r
\r
- NetFreePool (Variable);\r
+ gBS->FreePool (Variable);\r
return Config;\r
}\r
\r
Status = EFI_BUFFER_TOO_SMALL;\r
} else {\r
Status = EFI_SUCCESS;\r
- NetCopyMem (NicConfig, Config, Len);\r
+ CopyMem (NicConfig, Config, Len);\r
}\r
\r
*ConfigLen = Len;\r
\r
- NetFreePool (Config);\r
+ gBS->FreePool (Config);\r
return Status;\r
}\r
\r
Status = Ip4ConfigWriteVariable (NewVariable);\r
\r
if (NewVariable != NULL) {\r
- NetFreePool (NewVariable);\r
+ gBS->FreePool (NewVariable);\r
}\r
\r
//\r
// Variable is NULL when saving the first configure parameter\r
//\r
if (Variable != NULL) {\r
- NetFreePool (Variable);\r
+ gBS->FreePool (Variable);\r
}\r
\r
if (EFI_ERROR (Status)) {\r
\r
Instance = IP4_CONFIG_INSTANCE_FROM_IP4CONFIG (This);\r
\r
- OldTpl = NET_RAISE_TPL (NET_TPL_LOCK);\r
+ OldTpl = gBS->RaiseTPL (TPL_CALLBACK);\r
\r
if (Instance->State != IP4_CONFIG_STATE_IDLE) {\r
Status = EFI_ALREADY_STARTED;\r
//\r
Status = gBS->CreateEvent (\r
EVT_NOTIFY_SIGNAL,\r
- NET_TPL_LOCK,\r
+ TPL_CALLBACK,\r
Ip4ConfigOnDhcp4Complete,\r
Instance,\r
&Instance->Dhcp4Event\r
}\r
\r
ON_EXIT:\r
- NET_RESTORE_TPL (OldTpl);\r
+ gBS->RestoreTPL (OldTpl);\r
\r
return Status;\r
}\r
Instance = IP4_CONFIG_INSTANCE_FROM_IP4CONFIG (This);\r
\r
Status = EFI_SUCCESS;\r
- OldTpl = NET_RAISE_TPL (NET_TPL_LOCK);\r
+ OldTpl = gBS->RaiseTPL (TPL_CALLBACK);\r
\r
if (Instance->State == IP4_CONFIG_STATE_IDLE) {\r
Status = EFI_NOT_STARTED;\r
Ip4ConfigCleanConfig (Instance);\r
\r
ON_EXIT:\r
- NET_RESTORE_TPL (OldTpl);\r
+ gBS->RestoreTPL (OldTpl);\r
\r
return Status;\r
}\r
Instance = IP4_CONFIG_INSTANCE_FROM_IP4CONFIG (This);\r
\r
Status = EFI_SUCCESS;\r
- OldTpl = NET_RAISE_TPL (NET_TPL_LOCK);\r
+ OldTpl = gBS->RaiseTPL (TPL_CALLBACK);\r
\r
if (Instance->State == IP4_CONFIG_STATE_IDLE) {\r
Status = EFI_NOT_STARTED;\r
if ((*ConfigDataSize < Len) || (ConfigData == NULL)) {\r
Status = EFI_BUFFER_TOO_SMALL;\r
} else {\r
- NetCopyMem (ConfigData, &NicConfig->Ip4Info, Len);\r
+ CopyMem (ConfigData, &NicConfig->Ip4Info, Len);\r
}\r
\r
*ConfigDataSize = Len;\r
}\r
\r
ON_EXIT:\r
- NET_RESTORE_TPL (OldTpl);\r
+ gBS->RestoreTPL (OldTpl);\r
\r
return Status;\r
}\r
if (Instance->NicConfig != NULL) {\r
ASSERT (Instance->NicConfig->Source == IP4_CONFIG_SOURCE_DHCP);\r
Perment = Instance->NicConfig->Perment;\r
- NetFreePool (Instance->NicConfig);\r
+ gBS->FreePool (Instance->NicConfig);\r
}\r
\r
- Instance->NicConfig = NetAllocatePool (sizeof (NIC_IP4_CONFIG_INFO) + 2* sizeof (EFI_IP4_ROUTE_TABLE));\r
+ Instance->NicConfig = AllocatePool (sizeof (NIC_IP4_CONFIG_INFO) + 2* sizeof (EFI_IP4_ROUTE_TABLE));\r
\r
if (Instance->NicConfig == NULL) {\r
Instance->Result = EFI_OUT_OF_RESOURCES;\r
//\r
Ip4Config->RouteTableSize = 1;\r
\r
- NetCopyMem (&Ip1, &Dhcp4Mode.ClientAddress, sizeof (IP4_ADDR));\r
- NetCopyMem (&Ip2, &Dhcp4Mode.SubnetMask, sizeof (IP4_ADDR));\r
+ CopyMem (&Ip1, &Dhcp4Mode.ClientAddress, sizeof (IP4_ADDR));\r
+ CopyMem (&Ip2, &Dhcp4Mode.SubnetMask, sizeof (IP4_ADDR));\r
\r
Subnet = Ip1 & Ip2;\r
\r
- NetCopyMem (&Ip4Config->RouteTable[0].SubnetAddress, &Subnet, sizeof (EFI_IPv4_ADDRESS));\r
- NetCopyMem (&Ip4Config->RouteTable[0].SubnetMask, &Dhcp4Mode.SubnetMask, sizeof (EFI_IPv4_ADDRESS));\r
- NetZeroMem (&Ip4Config->RouteTable[0].GatewayAddress, sizeof (EFI_IPv4_ADDRESS));\r
+ CopyMem (&Ip4Config->RouteTable[0].SubnetAddress, &Subnet, sizeof (EFI_IPv4_ADDRESS));\r
+ CopyMem (&Ip4Config->RouteTable[0].SubnetMask, &Dhcp4Mode.SubnetMask, sizeof (EFI_IPv4_ADDRESS));\r
+ ZeroMem (&Ip4Config->RouteTable[0].GatewayAddress, sizeof (EFI_IPv4_ADDRESS));\r
\r
//\r
// Create a route if there is a default router.\r
if (!EFI_IP4_EQUAL (&Dhcp4Mode.RouterAddress, &mZeroIp4Addr)) {\r
Ip4Config->RouteTableSize = 2;\r
\r
- NetZeroMem (&Ip4Config->RouteTable[1].SubnetAddress, sizeof (EFI_IPv4_ADDRESS));\r
- NetZeroMem (&Ip4Config->RouteTable[1].SubnetMask, sizeof (EFI_IPv4_ADDRESS));\r
- NetCopyMem (&Ip4Config->RouteTable[1].GatewayAddress, &Dhcp4Mode.RouterAddress, sizeof (EFI_IPv4_ADDRESS));\r
+ ZeroMem (&Ip4Config->RouteTable[1].SubnetAddress, sizeof (EFI_IPv4_ADDRESS));\r
+ ZeroMem (&Ip4Config->RouteTable[1].SubnetMask, sizeof (EFI_IPv4_ADDRESS));\r
+ CopyMem (&Ip4Config->RouteTable[1].GatewayAddress, &Dhcp4Mode.RouterAddress, sizeof (EFI_IPv4_ADDRESS));\r
}\r
\r
Instance->Result = EFI_SUCCESS;\r
)\r
{\r
if (Instance->NicConfig != NULL) {\r
- NetFreePool (Instance->NicConfig);\r
+ gBS->FreePool (Instance->NicConfig);\r
Instance->NicConfig = NULL;\r
}\r
\r
//\r
// Allocate an instance then initialize it\r
//\r
- Instance = NetAllocatePool (sizeof (IP4_CONFIG_INSTANCE));\r
+ Instance = AllocatePool (sizeof (IP4_CONFIG_INSTANCE));\r
\r
if (Instance == NULL) {\r
Status = EFI_OUT_OF_RESOURCES;\r
NewVariable = Ip4ConfigModifyVariable (Variable, &Instance->NicAddr, NULL);\r
\r
} else if (NicConfig->Source == IP4_CONFIG_SOURCE_DHCP) {\r
- NetZeroMem (&NicConfig->Ip4Info, sizeof (EFI_IP4_IPCONFIG_DATA));\r
+ ZeroMem (&NicConfig->Ip4Info, sizeof (EFI_IP4_IPCONFIG_DATA));\r
NewVariable = Ip4ConfigModifyVariable (Variable, &Instance->NicAddr, NicConfig);\r
\r
}\r
Ip4ConfigWriteVariable (NewVariable);\r
\r
if (NewVariable != NULL) {\r
- NetFreePool (NewVariable);\r
+ gBS->FreePool (NewVariable);\r
}\r
\r
ON_EXIT:\r
- NetFreePool (Variable);\r
+ gBS->FreePool (Variable);\r
\r
if (NicConfig != NULL) {\r
- NetFreePool (NicConfig);\r
+ gBS->FreePool (NicConfig);\r
}\r
\r
return EFI_SUCCESS;\r
\r
ON_ERROR:\r
if (Instance != NULL) {\r
- NetFreePool (Instance);\r
+ gBS->FreePool (Instance);\r
}\r
\r
if (Mnp != NULL) {\r
\r
Ip4ConfigCleanConfig (Instance);\r
mIp4ConfigNicList[Instance->NicIndex] = NULL;\r
- NetFreePool (Instance);\r
+ gBS->FreePool (Instance);\r
\r
return EFI_SUCCESS;\r
}\r
http://git.etherboot.org / people / mcb30 / edk2.git / commitdiff