Import SnpDxe, Tcp4Dxe, Udp4Dxe and MnpDxe.

git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@3416 6f19259b-4bc3-4df7-8a09-765794883524

1 files changed, 518 insertions, 0 deletions

diff --git a/MdeModulePkg/Universal/Network/Tcp4Dxe/Socket.h b/MdeModulePkg/Universal/Network/Tcp4Dxe/Socket.h
new file mode 100644
index 0000000000..f3978541fb
--- /dev/null
+++ b/MdeModulePkg/Universal/Network/Tcp4Dxe/Socket.h
@@ -0,0 +1,518 @@
+/** @file
+
+Copyright (c) 2005 - 2006, Intel Corporation
+All rights reserved. This program and the accompanying materials
+are licensed and made available under the terms and conditions of the BSD License
+which accompanies this distribution.  The full text of the license may be found at
+http://opensource.org/licenses/bsd-license.php
+
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+Module Name:
+
+  Socket.h
+
+Abstract:
+
+
+**/
+
+#ifndef _SOCKET_H_
+#define _SOCKET_H_
+
+#include <PiDxe.h>

+

+#include <Protocol/IP4.h>

+#include <Protocol/Tcp4.h>
+#include <Protocol/Udp4.h>

+
+#include <Library/NetLib.h>

+#include <Library/DebugLib.h>

+#include <Library/UefiRuntimeServicesTableLib.h>

+#include <Library/UefiDriverEntryPoint.h>

+#include <Library/UefiBootServicesTableLib.h>

+#include <Library/BaseLib.h>

+#include <Library/UefiLib.h>
+#include <Library/MemoryAllocationLib.h>
+#include <Library/BaseMemoryLib.h>
+
+#define SOCK_SND_BUF        0
+#define SOCK_RCV_BUF        1
+
+#define SOCK_BUFF_LOW_WATER 2 * 1024
+#define SOCK_RCV_BUFF_SIZE  8 * 1024
+#define SOCK_SND_BUFF_SIZE  8 * 1024
+#define SOCK_BACKLOG        5
+
+#define PROTO_RESERVED_LEN  20
+
+#define SO_NO_MORE_DATA     0x0001
+
+//
+//
+//
+// When a socket is created it enters into SO_UNCONFIGURED,
+// no actions can be taken on this socket, only after calling
+// SockConfigure. The state transition diagram of socket is
+// as following:
+//
+// SO_UNCONFIGURED --- SO_CONFIGURED --- SO_CONNECTING
+//  ^      |                                    |
+//  |      --->  SO_LISTENING                   |
+//  |                                           |
+//  |------------------SO_DISCONNECTING<-- SO_CONNECTED
+//
+// A passive socket can only go into SO_LISTENING and
+// SO_UNCONFIGURED state. SO_XXXING state is a middle state
+// when a socket is undergoing a protocol procedure such
+// as requesting a TCP connection.
+//
+//
+//
+typedef enum {
+  SO_CLOSED       = 0,
+  SO_LISTENING,
+  SO_CONNECTING,
+  SO_CONNECTED,
+  SO_DISCONNECTING
+} SOCK_STATE;
+
+typedef enum {
+  SO_UNCONFIGURED       = 0,
+  SO_CONFIGURED_ACTIVE,
+  SO_CONFIGURED_PASSIVE,
+  SO_NO_MAPPING
+} SOCK_CONFIGURE_STATE;
+
+#define SOCK_NO_MORE_DATA(Sock)     ((Sock)->Flag |= SO_NO_MORE_DATA)
+
+#define SOCK_IS_UNCONFIGURED(Sock)  ((Sock)->ConfigureState == SO_UNCONFIGURED)
+
+#define SOCK_IS_CONFIGURED(Sock) \
+    (((Sock)->ConfigureState == SO_CONFIGURED_ACTIVE) || \
+    ((Sock)->ConfigureState == SO_CONFIGURED_PASSIVE))
+
+#define SOCK_IS_CONFIGURED_ACTIVE(Sock) \
+  ((Sock)->ConfigureState == SO_CONFIGURED_ACTIVE)
+
+#define SOCK_IS_CONNECTED_PASSIVE(Sock) \
+  ((Sock)->ConfigureState == SO_CONFIGURED_PASSIVE)
+
+#define SOCK_IS_NO_MAPPING(Sock) \
+  ((Sock)->ConfigureState == SO_NO_MAPPING)
+
+#define SOCK_IS_CLOSED(Sock)         ((Sock)->State == SO_CLOSED)
+
+#define SOCK_IS_LISTENING(Sock)      ((Sock)->State == SO_LISTENING)
+
+#define SOCK_IS_CONNECTING(Sock)     ((Sock)->State == SO_CONNECTING)
+
+#define SOCK_IS_CONNECTED(Sock)      ((Sock)->State == SO_CONNECTED)
+
+#define SOCK_IS_DISCONNECTING(Sock)  ((Sock)->State == SO_DISCONNECTING)
+
+#define SOCK_IS_NO_MORE_DATA(Sock)   (0 != ((Sock)->Flag & SO_NO_MORE_DATA))
+
+#define SOCK_SIGNATURE           EFI_SIGNATURE_32 ('S', 'O', 'C', 'K')
+
+#define SOCK_FROM_THIS(a)        CR ((a), SOCKET, NetProtocol, SOCK_SIGNATURE)
+
+#define SET_RCV_BUFFSIZE(Sock, Size)  ((Sock)->RcvBuffer.HighWater = (Size))
+
+#define GET_RCV_BUFFSIZE(Sock)        ((Sock)->RcvBuffer.HighWater)
+
+#define GET_RCV_DATASIZE(Sock)        (((Sock)->RcvBuffer.DataQueue)->BufSize)
+
+#define SET_SND_BUFFSIZE(Sock, Size)  ((Sock)->SndBuffer.HighWater = (Size))
+
+#define GET_SND_BUFFSIZE(Sock)        ((Sock)->SndBuffer.HighWater)
+
+#define GET_SND_DATASIZE(Sock)        (((Sock)->SndBuffer.DataQueue)->BufSize)
+
+#define SET_BACKLOG(Sock, Value)      ((Sock)->BackLog = (Value))
+
+#define GET_BACKLOG(Sock)             ((Sock)->BackLog)
+
+#define SOCK_ERROR(Sock, Error)       ((Sock)->SockError = (Error))
+
+#define SND_BUF_HDR_LEN(Sock) \
+  ((SockBufFirst (&((Sock)->SndBuffer)))->TotalSize)
+
+#define RCV_BUF_HDR_LEN(Sock) \
+  ((SockBufFirst (&((Sock)->RcvBuffer)))->TotalSize)
+
+#define SOCK_FROM_TOKEN(Token)        (((SOCK_TOKEN *) (Token))->Sock)
+
+#define PROTO_TOKEN_FORM_SOCK(SockToken, Type) \
+  ((Type *) (((SOCK_TOKEN *) (SockToken))->Token))
+
+typedef struct _SOCKET SOCKET;
+
+typedef struct _SOCK_COMPLETION_TOKEN {
+  EFI_EVENT   Event;
+  EFI_STATUS  Status;
+} SOCK_COMPLETION_TOKEN;
+
+typedef struct _SOCK_IO_TOKEN {
+  SOCK_COMPLETION_TOKEN Token;
+  union {
+    VOID  *RxData;
+    VOID  *TxData;
+  } Packet;
+} SOCK_IO_TOKEN;
+
+//
+// the request issued from socket layer to protocol layer
+//
+typedef enum {
+  SOCK_ATTACH,    // attach current socket to a new PCB
+  SOCK_DETACH,    // detach current socket from the PCB
+  SOCK_CONFIGURE, // configure attached PCB
+  SOCK_FLUSH,     // flush attached PCB
+  SOCK_SND,       // need protocol to send something
+  SOCK_SNDPUSH,   // need protocol to send pushed data
+  SOCK_SNDURG,    // need protocol to send urgent data
+  SOCK_CONSUMED,  // application has retrieved data from socket
+  SOCK_CONNECT,   // need to connect to a peer
+  SOCK_CLOSE,     // need to close the protocol process
+  SOCK_ABORT,     // need to reset the protocol process
+  SOCK_POLL,      // need to poll to the protocol layer
+  SOCK_ROUTE,     // need to add a route information
+  SOCK_MODE,      // need to get the mode data of the protocol
+  SOCK_GROUP      // need to join a mcast group
+} SOCK_REQUEST;
+
+//
+// the socket type
+//
+typedef enum {
+  SOCK_DGRAM, // this socket providing datagram service
+  SOCK_STREAM // this socket providing stream service
+} SOCK_TYPE;
+
+//
+// the handler of protocol for request from socket
+//
+typedef
+EFI_STATUS
+(*SOCK_PROTO_HANDLER) (
+  IN SOCKET       * Socket,  // the socket issuing the request to protocol
+  IN SOCK_REQUEST Request,   // the request issued by socket
+  IN VOID *RequestData       // the request related data
+  );
+
+//
+// the buffer structure of rcvd data and send data used by socket
+//
+typedef struct _SOCK_BUFFER {
+  UINT32        HighWater;  // the buffersize upper limit of sock_buffer
+  UINT32        LowWater;   // the low warter mark of sock_buffer
+  NET_BUF_QUEUE *DataQueue; // the queue to buffer data
+} SOCK_BUFFER;
+
+//
+// the initialize data for create a new socket
+//
+typedef struct _SOCK_INIT_DATA {
+  SOCK_TYPE   Type;
+  SOCK_STATE  State;
+
+  SOCKET      *Parent;        // the parent of this socket
+  UINT32      BackLog;        // the connection limit for listening socket
+  UINT32      SndBufferSize;  // the high warter mark of send buffer
+  UINT32      RcvBufferSize;  // the high warter mark of receive buffer
+  VOID        *Protocol;      // the pointer to protocol function template
+                              // wanted to install on socket
+
+  SOCK_PROTO_HANDLER  ProtoHandler;
+
+  EFI_HANDLE   DriverBinding; // the driver binding handle
+} SOCK_INIT_DATA;
+
+//
+// socket provided oprerations for low layer protocol
+//
+
+//
+// socket provided operations for user interface
+//
+VOID
+SockSetState (
+  IN SOCKET     *Sock,
+  IN SOCK_STATE State
+  );
+
+//
+// when the connection establishment process for a Sock
+// is finished low layer protocol calling this function
+// to notify socket layer
+//
+VOID
+SockConnEstablished (
+  IN SOCKET *Sock
+  );
+
+VOID
+SockConnClosed (
+  IN SOCKET *Sock
+  );
+
+//
+// called by low layer protocol to trim send buffer of
+// Sock, when Count data is sent out completely
+//
+VOID
+SockDataSent (
+  IN SOCKET  *Sock,
+  IN UINT32  Count
+  );
+
+//
+// called by low layer protocol to get Len of data from
+// socket to send and copy it in Dest
+//
+UINT32
+SockGetDataToSend (
+  IN SOCKET *Sock,
+  IN UINT32 Offset,
+  IN UINT32 Len,
+  IN UINT8  *Dest
+  );
+
+//
+//  called by low layer protocol to notify socket no more data can be
+//  received
+//
+VOID
+SockNoMoreData (
+  IN SOCKET *Sock
+  );
+
+//
+// called by low layer protocol to append a NetBuffer
+// to rcv buffer of sock
+//
+VOID
+SockDataRcvd (
+  IN SOCKET    *Sock,
+  IN NET_BUF   *NetBuffer,
+  IN UINT32     UrgLen
+  );
+
+UINT32
+SockGetFreeSpace (
+  IN SOCKET   *Sock,
+  IN UINT32   Which
+  );
+
+SOCKET  *
+SockClone (
+  IN SOCKET *Sock
+  );
+
+VOID
+SockRcvdErr (
+  IN SOCKET       *Sock,
+  IN EFI_STATUS   Error
+  );
+
+//
+// the socket structure representing a network service access point
+//
+typedef struct _SOCKET {
+
+  //
+  // socket description information
+  //
+  UINT32                Signature;
+  EFI_HANDLE            SockHandle;     // the virtual handle of the socket
+  EFI_HANDLE            DriverBinding;  // socket't driver binding protocol
+  SOCK_CONFIGURE_STATE  ConfigureState;
+  SOCK_TYPE             Type;
+  SOCK_STATE            State;
+  UINT16                Flag;
+  NET_LOCK              Lock;       // the lock of socket
+  SOCK_BUFFER           SndBuffer;  // send buffer of application's data
+  SOCK_BUFFER           RcvBuffer;  // receive buffer of received data
+  EFI_STATUS            SockError;  // the error returned by low layer protocol
+  BOOLEAN               IsDestroyed;
+
+  //
+  // fields used to manage the connection request
+  //
+  UINT32          BackLog;        // the limit of connection to this socket
+  UINT32          ConnCnt;        // the current count of connections to it
+  SOCKET          *Parent;        // listening parent that accept the connection
+  NET_LIST_ENTRY  ConnectionList; // the connections maintained by this socket
+  //
+  // the queue to buffer application's asynchronous token
+  //
+  NET_LIST_ENTRY  ListenTokenList;
+  NET_LIST_ENTRY  RcvTokenList;
+  NET_LIST_ENTRY  SndTokenList;
+  NET_LIST_ENTRY  ProcessingSndTokenList;
+
+  SOCK_COMPLETION_TOKEN *ConnectionToken; // app's token to signal if connected
+  SOCK_COMPLETION_TOKEN *CloseToken;      // app's token to signal if closed
+
+  //
+  // interface for low level protocol
+  //
+  SOCK_PROTO_HANDLER    ProtoHandler; // the request handler of protocol
+  UINT8 ProtoReserved[PROTO_RESERVED_LEN];  // Data fields reserved for protocol
+  union {
+    EFI_TCP4_PROTOCOL TcpProtocol;
+    EFI_UDP4_PROTOCOL UdpProtocol;
+  } NetProtocol;
+} SOCKET;
+
+//
+// the token structure buffered in socket layer
+//
+typedef struct _SOCK_TOKEN {
+  NET_LIST_ENTRY        TokenList;      // the entry to add in the token list
+  SOCK_COMPLETION_TOKEN *Token;         // The application's token
+  UINT32                RemainDataLen;  // unprocessed data length
+  SOCKET                *Sock;          // the poninter to the socket this token
+                                        // belongs to
+} SOCK_TOKEN;
+
+//
+// reserved data to access the NET_BUF delivered by UDP driver
+//
+typedef struct _UDP_RSV_DATA {
+  EFI_TIME              TimeStamp;
+  EFI_UDP4_SESSION_DATA Session;
+} UDP_RSV_DATA;
+
+//
+// reserved data to access the NET_BUF delivered by TCP driver
+//
+typedef struct _TCP_RSV_DATA {
+  UINT32 UrgLen;
+} TCP_RSV_DATA;
+
+//
+// call it to creat a socket and attach it to a PCB
+//
+SOCKET  *
+SockCreateChild (
+  IN SOCK_INIT_DATA *SockInitData,
+  IN VOID           *ProtoData,
+  IN UINT32         Len
+  );
+
+//
+// call it to destroy a socket and its related PCB
+//
+EFI_STATUS
+SockDestroyChild (
+  IN SOCKET *Sock
+  );
+
+//
+// call it to configure a socket and its related PCB
+//
+EFI_STATUS
+SockConfigure (
+  IN SOCKET *Sock,
+  IN VOID   *ConfigData
+  );
+
+//
+// call it to connect a socket to the peer
+//
+EFI_STATUS
+SockConnect (
+  IN SOCKET *Sock,
+  IN VOID   *Token
+  );
+
+//
+// call it to issue an asynchronous listen token to the socket
+//
+EFI_STATUS
+SockAccept (
+  IN SOCKET *Sock,
+  IN VOID   *Token
+  );
+
+//
+// Call it to send data using this socket
+//
+EFI_STATUS
+SockSend (
+  IN SOCKET *Sock,
+  IN VOID   *Token
+  );
+
+//
+// Call it to receive data from this socket
+//
+EFI_STATUS
+SockRcv (
+  IN SOCKET *Sock,
+  IN VOID   *Token
+  );
+
+//
+// Call it to flush a socket
+//
+EFI_STATUS
+SockFlush (
+  IN SOCKET *Sock
+  );
+
+//
+// Call it to close a socket in the light of policy in Token
+//
+EFI_STATUS
+SockClose (
+  IN SOCKET  *Sock,
+  IN VOID    *Token,
+  IN BOOLEAN OnAbort
+  );
+
+//
+// Call it to get the mode data of low layer protocol
+//
+EFI_STATUS
+SockGetMode (
+  IN SOCKET *Sock,
+  IN VOID   *Mode
+  );
+
+//
+// call it to add this socket instance into a group
+//
+EFI_STATUS
+SockGroup (
+  IN SOCKET *Sock,
+  IN VOID   *GroupInfo
+  );
+
+//
+// call it to add a route entry for this socket instance
+//
+EFI_STATUS
+SockRoute (
+  IN SOCKET    *Sock,
+  IN VOID      *RouteInfo
+  );
+
+//
+// Supporting function to operate on socket buffer
+//
+NET_BUF *
+SockBufFirst (
+  IN SOCK_BUFFER *Sockbuf
+  );
+
+NET_BUF *
+SockBufNext (
+  IN SOCK_BUFFER *Sockbuf,
+  IN NET_BUF     *SockEntry
+  );
+
+#endif