/** @file
  Implement the socket support for the socket layer.

  Socket States:
  * Bound - pSocket->PortList is not NULL
  * Listen - AcceptWait event is not NULL

  Copyright (c) 2010 - 2014, Intel Corporation. All rights reserved.<BR>
  This program and the accompanying materials are licensed and made available under
  the terms and conditions of the BSD License that 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.


  \section DataStructures Data Structures

  <code><pre>

                +---------------+   +-------------+   +-------------+
  Service Lists | ::ESL_SERVICE |-->| ESL_SERVICE |-->| ESL_SERVICE |--> NULL (pNext)
                +---------------+   +-------------+   +-------------+
                  ^                       | (pPortList)    |
    pUdp4List ^   | pTcp4List             |                |
              |   |                       |                |
          ^   |   |                       |                |
 pIp4List |   |   |                       |                |
        +---------------+                 |                |
        | ::ESL_LAYER   | ::mEslLayer     |                |
        +---------------+                 |                |
                  | (pSocketList)         |                |
    Socket List   V                       V                V
                +---------------+   +-------------+   +-------------+
                | ::ESL_SOCKET  |-->| ::ESL_PORT  |-->|   ESL_PORT  |--> NULL (pLinkSocket)
                +---------------+   +-------------+   +-------------+
                  |                       |                |
                  |                       |                V
                  V                       V               NULL
                +-------------+   +-------------+
                | ESL_SOCKET  |-->|   ESL_PORT  |--> NULL
                +-------------+   +-------------+
                  |    | | | |            |
                  V    | | | |            V
                 NULL  | | | |           NULL
               (pNext) | | | |     (pLinkService)
                       | | | |                                     pRxPacketListHead
                       | | | `-----------------------------------------------.
                       | | |                     pRxOobPacketListHead        |
                       | | `--------------------------------.                |
                       | |      pTxPacketListHead           |                |
                       | `---------------.                  |                |
  pTxOobPacketListHead |                 |                  |                |
                       V                 V                  V                V
                  +--------------+    +------------+    +------------+    +------------+
                  | ::ESL_PACKET |    | ESL_PACKET |    | ESL_PACKET |    | ESL_PACKET |
                  +--------------+    +------------+    +------------+    +------------+
                         |                 |                |                |
                         V                 V                V                V
                  +------------+    +------------+    +------------+    +------------+
                  | ESL_PACKET |    | ESL_PACKET |    | ESL_PACKET |    | ESL_PACKET |
                  +------------+    +------------+    +------------+    +------------+
                         |                 |                |                |
                         V                 V                V                V
                        NULL              NULL             NULL             NULL
                       (pNext)

  </pre></code>

  ::mEslLayer is the one and only ::ESL_LAYER structure.  It connects directly or
  indirectly to the other data structures.  The ESL_LAYER structure has a unique
  service list for each of the network protocol interfaces.

  ::ESL_SERVICE manages the network interfaces for a given transport type (IP4, TCP4, UDP4, etc.)

  ::ESL_SOCKET manages the activity for a single socket instance.  As such, it contains
  the ::EFI_SOCKET_PROTOCOL structure which the BSD socket library uses as the object
  reference and the API into the EFI socket library.

  ::ESL_PORT manages the connection with a single instance of the lower layer network.
  This structure is the socket equivalent of an IP connection or a TCP or UDP port.

  ::ESL_PACKET buffers data for transmit and receive.  There are four queues connected
  to the ::ESL_SOCKET that manage the data:
  <ul>
    <li>ESL_SOCKET::pRxPacketListHead - Normal (low) priority receive data</li>
    <li>ESL_SOCKET::pRxOobPacketListHead - High (out-of-band or urgent) priority receive data</li>
    <li>ESL_SOCKET::pTxPacketListHead - Normal (low) priority transmit data</li>
    <li>ESL_SOCKET::pTxOobPacketListHead - High (out-of-band or urgent) priority transmit data</li>
  </ul>
  The selection of the transmit queue is controlled by the MSG_OOB flag on the transmit
  request as well as the socket option SO_OOBINLINE.  The receive queue is selected by
  the URGENT data flag for TCP and the setting of the socket option SO_OOBINLINE.

  Data structure synchronization is done by raising TPL to TPL_SOCKET.  Modifying
  critical elements within the data structures must be done at this TPL.  TPL is then
  restored to the previous level.  Note that the code verifies that all callbacks are
  entering at TPL_SOCKETS for proper data structure synchronization.

  \section PortCloseStateMachine Port Close State Machine

  The port close state machine walks the port through the necessary
  states to stop activity on the port and get it into a state where
  the resources may be released.  The state machine consists of the
  following arcs and states:

  <code><pre>

      +--------------------------+
      |          Open            |
      +--------------------------+
                   |
                   |  ::EslSocketPortCloseStart
                   V
      +--------------------------+
      | PORT_STATE_CLOSE_STARTED |
      +--------------------------+
                   |
                   |  ::EslSocketPortCloseTxDone
                   V
      +--------------------------+
      | PORT_STATE_CLOSE_TX_DONE |
      +--------------------------+
                   |
                   |  ::EslSocketPortCloseComplete
                   V
      +--------------------------+
      |  PORT_STATE_CLOSE_DONE   |
      +--------------------------+
                   |
                   |  ::EslSocketPortCloseRxDone
                   V
      +--------------------------+
      | PORT_STATE_CLOSE_RX_DONE |
      +--------------------------+
                   |
                   |  ::EslSocketPortClose
                   V
      +--------------------------+
      |          Closed          |
      +--------------------------+

  </pre></code>

  <ul>
    <li>Arc: ::EslSocketPortCloseStart - Marks the port as closing and
      initiates the port close operation</li>
    <li>State: PORT_STATE_CLOSE_STARTED</li>
    <li>Arc: ::EslSocketPortCloseTxDone - Waits until all of the transmit
      operations to complete.  After all of the transmits are complete,
      this routine initiates the network specific close operation by calling
      through ESL_PROTOCOL_API::pfnPortCloseOp.  One such routine is
      ::EslTcp4PortCloseOp.
    </li>
    <li>State: PORT_STATE_CLOSE_TX_DONE</li>
    <li>Arc: ::EslSocketPortCloseComplete - Called when the close operation is
      complete.  After the transition to PORT_STATE_CLOSE_DONE,
      this routine calls ::EslSocketRxCancel to abort the pending receive operations.
    </li>
    <li>State: PORT_STATE_CLOSE_DONE</li>
    <li>Arc: ::EslSocketPortCloseRxDone - Waits until all of the receive
      operation have been cancelled.  After the transition to
      PORT_STATE_CLOSE_RX_DONE, this routine calls ::EslSocketPortClose.
    </li>
    <li>State: PORT_STATE_CLOSE_RX_DONE</li>
    <li>Arc: ::EslSocketPortClose - This routine discards any receive buffers
      using a network specific support routine via ESL_PROTOCOL_API::pfnPacketFree.
      This routine then releases the port resources allocated by ::EslSocketPortAllocate
      and calls the network specific port close routine (e.g. ::EslTcp4PortClose)
      via ESL_PROTOCOL_API::pfnPortClose to release any network specific resources.
    </li>
  </ul>


  \section ReceiveEngine Receive Engine

  The receive path accepts data from the network and queues (buffers) it for the
  application.  Flow control is applied once a maximum amount of buffering is reached
  and is released when the buffer usage drops below that limit.  Eventually the
  application requests data from the socket which removes entries from the queue and
  returns the data.

  The receive engine is the state machine which reads data from the network and
  fills the queue with received packets.  The receive engine uses two data structures
  to manage the network receive opeations and the buffers.

  At a high level, the ::ESL_IO_MGMT structures are managing the tokens and
  events for the interface to the UEFI network stack.  The ::ESL_PACKET
  structures are managing the receive data buffers.  The receive engine
  connects these two structures in the network specific receive completion
  routines.

<code><pre>

      +------------------+
      |     ::ESL_PORT     |
      |                  |
      +------------------+
      |    ::ESL_IO_MGMT   |
      +------------------+
      |    ESL_IO_MGMT   |
      +------------------+
      .                  .
      .    ESL_IO_MGMT   .
      .                  .
      +------------------+

</pre></code>

  The ::ESL_IO_MGMT structures are allocated as part of the ::ESL_PORT structure in
  ::EslSocketPortAllocate.  The ESL_IO_MGMT structures are separated and placed on
  the free list by calling ::EslSocketIoInit.  The ESL_IO_MGMT structure contains
  the network layer specific receive completion token and event.  The receive engine
  is eventually shutdown by ::EslSocketPortCloseTxDone and the resources in these
  structures are released in ::EslSocketPortClose by a call to ::EslSocketIoFree.

<code><pre>

         pPort->pRxActive
                |
                V
          +-------------+   +-------------+   +-------------+
  Active  | ESL_IO_MGMT |-->| ESL_IO_MGMT |-->| ESL_IO_MGMT |--> NULL
          +-------------+   +-------------+   +-------------+

          +-------------+   +-------------+   +-------------+
  Free    | ESL_IO_MGMT |-->| ESL_IO_MGMT |-->| ESL_IO_MGMT |--> NULL
          +-------------+   +-------------+   +-------------+
                ^
                |
          pPort->pRxFree
</pre></code>

  The receive engine is started by calling ::EslSocketRxStart.  Flow control pauses
  the receive engine by stopping the calls to EslSocketRxStart when the amount of
  receive data waiting for the application meets or exceeds MAX_RX_DATA.  After
  the application reads enough data that the amount of buffering drops below this
  limit, the calls to EslSockeRxStart continue which releases the flow control.

  Receive flow control is applied when the port is created, since no receive
  operation are pending to the low layer network driver.  The flow control gets
  released when the low layer network port is configured or the first receive
  operation is posted.  Flow control remains in the released state until the
  maximum buffer space is consumed.  During this time, ::EslSocketRxComplete
  calls ::EslSocketRxStart.  Flow control is applied in EslSocketRxComplete
  by skipping the call to EslSocketRxStart.  Flow control is eventually
  released in ::EslSocketReceive when the buffer space drops below the
  maximum amount causing EslSocketReceive to call EslSocketRxStart.

<code><pre>

                    +------------+   +------------+
    High     .----->| ESL_PACKET |-->| ESL_PACKET |--> NULL (pNext)
  Priority   |      +------------+   +------------+
             |
             | pRxOobPacketListHead
       +------------+
       | ::ESL_SOCKET |
       +------------+
             | pRxPacketListHead
    Low      |
  Priority   |      +------------+   +------------+   +------------+
             `----->| ::ESL_PACKET |-->| ESL_PACKET |-->| ESL_PACKET |--> NULL
                    +------------+   +------------+   +------------+

</pre></code>

  ::EslSocketRxStart connects an ::ESL_PACKET structure to the ::ESL_IO_MGMT structure
  and then calls the network layer to start the receive operation.  Upon
  receive completion, ::EslSocketRxComplete breaks the connection between these
  structrues and places the ESL_IO_MGMT structure onto the ESL_PORT::pRxFree list to
  make token and event available for another receive operation.  EslSocketRxComplete
  then queues the ESL_PACKET structure (data packet) to either the
  ESL_SOCKET::pRxOobPacketListTail or ESL_SOCKET::pRxPacketListTail depending on
  whether urgent or normal data was received.  Finally ::EslSocketRxComplete attempts
  to start another receive operation.

<code><pre>

  Setup for IP4 and UDP4

      +--------------------+
      | ESL_IO_MGMT        |
      |                    |
      |    +---------------+
      |    | Token         |
      |    |        RxData --> NULL
      +----+---------------+
         |
         V
      +--------------------+
      | ESL_PACKET         |
      |                    |
      |    +---------------+
      |    |       pRxData --> NULL
      +----+---------------+

  Completion for IP4 and UDP4

      +--------------------+   +----------------------+
      | ESL_IO_MGMT        |   |      Data Buffer     |
      |                    |   |     (Driver owned)   |
      |    +---------------+   +----------------------+
      |    | Token         |               ^
      |    |      Rx Event |               |
      |    |               |   +----------------------+
      |    |        RxData --> | EFI_IP4_RECEIVE_DATA |
      +----+---------------+   |    (Driver owned)    |
         |                     +----------------------+
         V                                 ^
      +--------------------+               .
      | ESL_PACKET         |               .
      |                    |               .
      |    +---------------+               .
      |    |       pRxData --> NULL  .......
      +----+---------------+


  Setup and completion for TCP4

      +--------------------+   +--------------------------+
      | ESL_IO_MGMT        |-->| ESL_PACKET               |
      |                    |   |                          |
      |    +---------------+   +----------------------+   |
      |    | Token         |   | EFI_IP4_RECEIVE_DATA |   |
      |    |        RxData --> |                      |   |
      |    |               |   +----------------------+---+
      |    |        Event  |   |       Data Buffer        |
      +----+---------------+   |                          |
                               |                          |
                               +--------------------------+

</pre></code>

  To minimize the number of buffer copies, the data is not copied until the
  application makes a receive call.  At this point socket performs a single copy
  in the receive path to move the data from the buffer filled by the network layer
  into the application's buffer.

  The IP4 and UDP4 drivers go one step further to reduce buffer copies.  They
  allow the socket layer to hold on to the actual receive buffer until the
  application has performed a receive operation or closes the socket.  Both
  of theses operations return the buffer to the lower layer network driver
  by calling ESL_PROTOCOL_API::pfnPacketFree.

  When a socket application wants to receive data it indirectly calls
  ::EslSocketReceive to remove data from one of the receive data queues.  This routine
  removes the next available packet from ESL_SOCKET::pRxOobPacketListHead or
  ESL_SOCKET::pRxPacketListHead and copies the data from the packet
  into the application's buffer.  For SOCK_STREAM sockets, if the packet
  contains more data then the ESL_PACKET structures remains at the head of the
  receive queue for the next application receive
  operation.  For SOCK_DGRAM, SOCK_RAW and SOCK_SEQ_PACKET sockets, the ::ESL_PACKET
  structure is removed from the head of the receive queue and any remaining data is
  discarded as the packet is placed on the free queue.

  During socket layer shutdown, ::EslSocketShutdown calls ::EslSocketRxCancel to
  cancel any pending receive operations.  EslSocketRxCancel calls the network specific
  cancel routine using ESL_PORT::pfnRxCancel.


  \section TransmitEngine Transmit Engine

  Application calls to ::EslSocketTransmit cause data to be copied into a buffer.
  The buffer exists as an extension to an ESL_PACKET structure and the structure
  is placed at the end of the transmit queue.

<code><pre>

     *ppQueueHead: pSocket->pRxPacketListHead or pSocket->pRxOobPacketListHead
          |
          V
        +------------+   +------------+   +------------+
  Data  | ESL_PACKET |-->| ESL_PACKET |-->| ESL_PACKET |--> NULL
        +------------+   +------------+   +------------+
                                                     ^
                                                     |
     *ppQueueTail: pSocket->pRxPacketListTail or pSocket->pRxOobPacketListTail

</pre></code>

  There are actually two transmit queues the normal or low priority queue which is
  the default and the urgent or high priority queue which is addressed by specifying
  the MSG_OOB flag during the transmit request.  Associated with each queue is a
  transmit engine which is responsible for sending the data in that queue.

  The transmit engine is the state machine which removes entries from the head
  of the transmit queue and causes the data to be sent over the network.

<code><pre>

      +--------------------+   +--------------------+
      | ESL_IO_MGMT        |   | ESL_PACKET         |
      |                    |   |                    |
      |    +---------------+   +----------------+   |
      |    | Token         |   | Buffer Length  |   |
      |    |        TxData --> | Buffer Address |   |
      |    |               |   +----------------+---+
      |    |        Event  |   | Data Buffer        |
      +----+---------------+   |                    |
                               +--------------------+
</pre></code>

  At a high level, the transmit engine uses a couple of data structures
  to manage the data flow.  The ::ESL_IO_MGMT structures manage the tokens and
  events for the interface to the UEFI network stack.  The ::ESL_PACKET
  structures manage the data buffers that get sent.  The transmit
  engine connects these two structures prior to transmission and disconnects
  them upon completion.

<code><pre>

         pPort->pTxActive or pTxOobActive
                |
                V
          +-------------+   +-------------+   +-------------+
  Active  | ESL_IO_MGMT |-->| ESL_IO_MGMT |-->| ESL_IO_MGMT |--> NULL
          +-------------+   +-------------+   +-------------+

          +-------------+   +-------------+   +-------------+
  Free    | ESL_IO_MGMT |-->| ESL_IO_MGMT |-->| ESL_IO_MGMT |--> NULL
          +-------------+   +-------------+   +-------------+
                ^
                |
          pPort->pTxFree or pTxOobFree

</pre></code>

  The transmit engine manages multiple transmit operations using the
  active and free lists shown above.  ::EslSocketPortAllocate allocates the
  ::ESL_IO_MGMT structures as an extension to the ::ESL_PORT structure.
  This routine places the ESL_IO_MGMT structures on the free list by calling
  ::EslSocketIoInit.  During their lifetime, the ESL_IO_MGMT structures
  will move from the free list to the active list and back again.  The
  active list contains the packets that are actively being processed by
  the UEFI network stack.  Eventually the ESL_IO_MGMT structures will be
  removed from the free list and be deallocated by the EslSocketPortClose
  routine.

  The network specific code calls the ::EslSocketTxStart routine
  to hand a packet to the network stack.  EslSocketTxStart connects
  the transmit packet (::ESL_PACKET) to an ::ESL_IO_MGMT structure
  and then queues the result to one of the active lists:
  ESL_PORT::pTxActive or ESL_PORT::pTxOobActive.  The routine then
  hands the packet to the network stack.

  Upon completion, the network specific TxComplete routine calls
  ::EslSocketTxComplete to disconnect the transmit packet from the
  ESL_IO_MGMT structure and frees the ::ESL_PACKET structure by calling
  ::EslSocketPacketFree.  The routine places the ::ESL_IO_MGMT structure
  into the free list either ESL_PORT::pTxFree or ESL_PORT::pTxOobFree.
  EslSocketTxComplete then starts the next transmit operation while
  the socket is active or calls the ::EslSocketPortCloseTxDone routine
  when the socket is shutting down.

**/

#include "Socket.h"


/** Socket driver connection points

  List the network stack connection points for the socket driver.
**/
CONST ESL_SOCKET_BINDING cEslSocketBinding[] = {
  { L"Ip4",
    &gEfiIp4ServiceBindingProtocolGuid,
    &gEfiIp4ProtocolGuid,
    &mEslIp4ServiceGuid,
    OFFSET_OF ( ESL_LAYER, pIp4List ),
    4,    //  RX buffers
    4,    //  TX buffers
    0 },  //  TX Oob buffers
  { L"Tcp4",
    &gEfiTcp4ServiceBindingProtocolGuid,
    &gEfiTcp4ProtocolGuid,
    &mEslTcp4ServiceGuid,
    OFFSET_OF ( ESL_LAYER, pTcp4List ),
    4,    //  RX buffers
    4,    //  TX buffers
    4 },  //  TX Oob buffers
  { L"Tcp6",
    &gEfiTcp6ServiceBindingProtocolGuid,
    &gEfiTcp6ProtocolGuid,
    &mEslTcp6ServiceGuid,
    OFFSET_OF ( ESL_LAYER, pTcp6List ),
    4,    //  RX buffers
    4,    //  TX buffers
    4 },  //  TX Oob buffers
  { L"Udp4",
    &gEfiUdp4ServiceBindingProtocolGuid,
    &gEfiUdp4ProtocolGuid,
    &mEslUdp4ServiceGuid,
    OFFSET_OF ( ESL_LAYER, pUdp4List ),
    4,    //  RX buffers
    4,    //  TX buffers
    0 },  //  TX Oob buffers
  { L"Udp6",
    &gEfiUdp6ServiceBindingProtocolGuid,
    &gEfiUdp6ProtocolGuid,
    &mEslUdp6ServiceGuid,
    OFFSET_OF ( ESL_LAYER, pUdp6List ),
    4,    //  RX buffers
    4,    //  TX buffers
    0 }   //  TX Oob buffers
};

CONST UINTN cEslSocketBindingEntries = DIM ( cEslSocketBinding );

/// APIs to support the various socket types for the v4 network stack.
CONST ESL_PROTOCOL_API * cEslAfInetApi[] = {
  NULL,             //  0
  &cEslTcp4Api,     //  SOCK_STREAM
  &cEslUdp4Api,     //  SOCK_DGRAM
  &cEslIp4Api,      //  SOCK_RAW
  NULL,             //  SOCK_RDM
  &cEslTcp4Api      //  SOCK_SEQPACKET
};

/// Number of entries in the v4 API array ::cEslAfInetApi.
CONST int cEslAfInetApiSize = DIM ( cEslAfInetApi );


/// APIs to support the various socket types for the v6 network stack.
CONST ESL_PROTOCOL_API * cEslAfInet6Api[] = {
  NULL,             //  0
  &cEslTcp6Api,     //  SOCK_STREAM
  &cEslUdp6Api,     //  SOCK_DGRAM
  NULL,             //  SOCK_RAW
  NULL,             //  SOCK_RDM
  &cEslTcp6Api      //  SOCK_SEQPACKET
};

/// Number of entries in the v6 API array ::cEslAfInet6Api.
CONST int cEslAfInet6ApiSize = DIM ( cEslAfInet6Api );


/// Global management structure for the socket layer.
ESL_LAYER mEslLayer;


/** Initialize an endpoint for network communication.

  This routine initializes the communication endpoint.

  The ::socket routine calls this routine indirectly to create
  the communication endpoint.

  @param[in] pSocketProtocol Address of the socket protocol structure.
  @param[in]  domain   Select the family of protocols for the client or server
                       application.  See the ::socket documentation for values.
  @param[in]  type     Specifies how to make the network connection.
                       See the ::socket documentation for values.
  @param[in]  protocol Specifies the lower layer protocol to use.
                       See the ::socket documentation for values.
  @param[out] pErrno   Address to receive the errno value upon completion.

  @retval EFI_SUCCESS - Socket successfully created
  @retval EFI_INVALID_PARAMETER - Invalid domain value, errno = EAFNOSUPPORT
  @retval EFI_INVALID_PARAMETER - Invalid type value, errno = EINVAL
  @retval EFI_INVALID_PARAMETER - Invalid protocol value, errno = EINVAL
 **/
EFI_STATUS
EslSocket (
  IN EFI_SOCKET_PROTOCOL * pSocketProtocol,
  IN int domain,
  IN int type,
  IN int protocol,
  IN int * pErrno
  )
{
  CONST ESL_PROTOCOL_API * pApi;
  CONST ESL_PROTOCOL_API ** ppApiArray;
  CONST ESL_PROTOCOL_API ** ppApiArrayEnd;
  int ApiArraySize;
  ESL_SOCKET * pSocket;
  EFI_STATUS Status;
  int errno;

  DBG_ENTER ( );

  //  Locate the socket
  pSocket = SOCKET_FROM_PROTOCOL ( pSocketProtocol );

  //  Set the default domain if necessary
  if ( AF_UNSPEC == domain ) {
    domain = AF_INET;
  }

  //  Assume success
  errno = 0;
  Status = EFI_SUCCESS;

  //  Use break instead of goto
  for ( ; ; ) {
    //  Validate the domain value
    if (( AF_INET != domain )
      && ( AF_INET6 != domain )
      && ( AF_LOCAL != domain )) {
      DEBUG (( DEBUG_ERROR | DEBUG_SOCKET,
                "ERROR - Invalid domain value\r\n" ));
      Status = EFI_INVALID_PARAMETER;
      errno = EAFNOSUPPORT;
      break;
    }

    //  Determine the protocol APIs
    ppApiArray = NULL;
    ApiArraySize = 0;
    if (( AF_INET == domain )
      || ( AF_LOCAL == domain )) {
      ppApiArray = &cEslAfInetApi[0];
      ApiArraySize = cEslAfInetApiSize;
    }
    else {
      ppApiArray = &cEslAfInet6Api[0];
      ApiArraySize = cEslAfInet6ApiSize;
    }

    //  Set the default type if necessary
    if ( 0 == type ) {
      type = SOCK_STREAM;
    }

    //  Validate the type value
    if (( type >= ApiArraySize )
      || ( NULL == ppApiArray )
      || ( NULL == ppApiArray[ type ])) {
      DEBUG (( DEBUG_ERROR | DEBUG_SOCKET,
                "ERROR - Invalid type value\r\n" ));
      //  The socket type is not supported
      Status = EFI_INVALID_PARAMETER;
      errno = EPROTOTYPE;
      break;
    }

    //  Set the default protocol if necessary
    pApi = ppApiArray[ type ];
    if ( 0 == protocol ) {
      protocol = pApi->DefaultProtocol;
    }

    //  Validate the protocol value
    if (( pApi->DefaultProtocol != protocol )
      && ( SOCK_RAW != type )) {
      Status = EFI_INVALID_PARAMETER;

      //  Assume that the driver supports this protocol
      ppApiArray = &cEslAfInetApi[0];
      ppApiArrayEnd = &ppApiArray [ cEslAfInetApiSize ];
      while ( ppApiArrayEnd > ppApiArray ) {
        pApi = *ppApiArray;
        if ( protocol == pApi->DefaultProtocol ) {
          break;
        }
        ppApiArray += 1;
      }
      if ( ppApiArrayEnd <= ppApiArray ) {
        //  Verify against the IPv6 table
        ppApiArray = &cEslAfInet6Api[0];
        ppApiArrayEnd = &ppApiArray [ cEslAfInet6ApiSize ];
        while ( ppApiArrayEnd > ppApiArray ) {
          pApi = *ppApiArray;
          if ( protocol == pApi->DefaultProtocol ) {
            break;
          }
          ppApiArray += 1;
        }
      }
      if ( ppApiArrayEnd <= ppApiArray ) {
        DEBUG (( DEBUG_ERROR | DEBUG_SOCKET,
                  "ERROR - The protocol is not supported!\r\n" ));
        errno = EPROTONOSUPPORT;
        break;
      }

      //  The driver does not support this protocol
      DEBUG (( DEBUG_ERROR | DEBUG_SOCKET,
                "ERROR - The protocol does not support this socket type!\r\n" ));
      errno = EPROTONOSUPPORT;
      errno = EPROTOTYPE;
      break;
    }
    //  Save the socket attributes
    pSocket->pApi = pApi;
    pSocket->Domain = domain;
    pSocket->Type = type;
    pSocket->Protocol = protocol;

    //  Done
    break;
  }
  //  Return the operation status
  if ( NULL != pErrno ) {
    *pErrno = errno;
  }
  DBG_EXIT_STATUS ( Status );
  return Status;
}


/** Accept a network connection.

  This routine calls the network specific layer to remove the next
  connection from the FIFO.

  The ::accept calls this routine to poll for a network
  connection to the socket.  When a connection is available
  this routine returns the ::EFI_SOCKET_PROTOCOL structure address
  associated with the new socket and the remote network address
  if requested.

  @param[in]      pSocketProtocol   Address of an ::EFI_SOCKET_PROTOCOL structure.
  @param[in]      pSockAddr         Address of a buffer to receive the remote
                                    network address.
  @param[in,out]  pSockAddrLength   Length in bytes of the address buffer.
                                    On output specifies the length of the
                                    remote network address.
  @param[out]     ppSocketProtocol  Address of a buffer to receive the
                                    ::EFI_SOCKET_PROTOCOL instance
                                    associated with the new socket.
  @param[out]     pErrno            Address to receive the errno value upon completion.

  @retval EFI_SUCCESS   New connection successfully created
  @retval EFI_NOT_READY No connection is available
 **/
EFI_STATUS
EslSocketAccept (
  IN EFI_SOCKET_PROTOCOL * pSocketProtocol,
  IN struct sockaddr * pSockAddr,
  IN OUT socklen_t * pSockAddrLength,
  IN EFI_SOCKET_PROTOCOL ** ppSocketProtocol,
  IN int * pErrno
  )
{
  ESL_SOCKET * pNewSocket;
  ESL_SOCKET * pSocket;
  EFI_STATUS Status;
  EFI_TPL TplPrevious;

  DBG_ENTER ( );

  //
  //  Assume success
  //
  Status = EFI_SUCCESS;

  //
  //  Validate the socket
  //
  pSocket = NULL;
  pNewSocket = NULL;
  if ( NULL != pSocketProtocol ) {
    pSocket = SOCKET_FROM_PROTOCOL ( pSocketProtocol );

    //
    //  Verify the API
    //
    if ( NULL == pSocket->pApi->pfnAccept ) {
      Status = EFI_UNSUPPORTED;
      pSocket->errno = ENOTSUP;
    }
    else {
      //
      //  Validate the sockaddr
      //
      if (( NULL != pSockAddr )
        && ( NULL == pSockAddrLength )) {
        DEBUG (( DEBUG_ACCEPT,
                  "ERROR - pSockAddr is NULL!\r\n" ));
        Status = EFI_INVALID_PARAMETER;
        pSocket->errno = EFAULT;
      }
      else {
        //
        //  Synchronize with the socket layer
        //
        RAISE_TPL ( TplPrevious, TPL_SOCKETS );

        //
        //  Verify that the socket is in the listen state
        //
        if ( SOCKET_STATE_LISTENING != pSocket->State ) {
          DEBUG (( DEBUG_ACCEPT,
                    "ERROR - Socket is not listening!\r\n" ));
          if ( NULL == pSocket->pApi->pfnAccept ) {
            //
            //  Socket does not support listen
            //
            pSocket->errno = EOPNOTSUPP;
            Status = EFI_UNSUPPORTED;
          }
          else {
            //
            //  Socket supports listen, but not in listen state
            //
            pSocket->errno = EINVAL;
            Status = EFI_NOT_STARTED;
          }
        }
        else {
          //
          //  Determine if a socket is available
          //
          if ( 0 == pSocket->FifoDepth ) {
            //
            //  No connections available
            //  Determine if any ports are available
            //
            if ( NULL == pSocket->pPortList ) {
              //
              //  No ports available
              //
              Status = EFI_DEVICE_ERROR;
              pSocket->errno = EINVAL;

              //
              //  Update the socket state
              //
              pSocket->State = SOCKET_STATE_NO_PORTS;
            }
            else {
              //
              //  Ports are available
              //  No connection requests at this time
              //
              Status = EFI_NOT_READY;
              pSocket->errno = EAGAIN;
            }
          }
          else {

            //
            //  Attempt to accept the connection and
            //  get the remote network address
            //
            pNewSocket = pSocket->pFifoHead;
            ASSERT ( NULL != pNewSocket );
            Status = pSocket->pApi->pfnAccept ( pNewSocket,
                                                pSockAddr,
                                                pSockAddrLength );
            if ( !EFI_ERROR ( Status )) {
              //
              //  Remove the new socket from the list
              //
              pSocket->pFifoHead = pNewSocket->pNextConnection;
              if ( NULL == pSocket->pFifoHead ) {
                pSocket->pFifoTail = NULL;
              }

              //
              //  Account for this socket
              //
              pSocket->FifoDepth -= 1;

              //
              //  Update the new socket's state
              //
              pNewSocket->State = SOCKET_STATE_CONNECTED;
              pNewSocket->bConfigured = TRUE;
              DEBUG (( DEBUG_ACCEPT,
                        "0x%08x: Socket connected\r\n",
                        pNewSocket ));
            }
          }
        }

        //
        //  Release the socket layer synchronization
        //
        RESTORE_TPL ( TplPrevious );
      }
    }
  }

  //
  //  Return the new socket
  //
  if (( NULL != ppSocketProtocol )
    && ( NULL != pNewSocket )) {
    *ppSocketProtocol = &pNewSocket->SocketProtocol;
  }

  //
  //  Return the operation status
  //
  if ( NULL != pErrno ) {
    if ( NULL != pSocket ) {
      *pErrno = pSocket->errno;
    }
    else {
      Status = EFI_INVALID_PARAMETER;
      *pErrno = ENOTSOCK;
    }
  }
  DBG_EXIT_STATUS ( Status );
  return Status;
}


/** Allocate and initialize a ESL_SOCKET structure.

  This support function allocates an ::ESL_SOCKET structure
  and installs a protocol on ChildHandle.  If pChildHandle is a
  pointer to NULL, then a new handle is created and returned in
  pChildHandle.  If pChildHandle is not a pointer to NULL, then
  the protocol installs on the existing pChildHandle.

  @param[in,out]  pChildHandle  Pointer to the handle of the child to create.
                                If it is NULL, then a new handle is created.
                                If it is a pointer to an existing UEFI handle,
                                then the protocol is added to the existing UEFI
                                handle.
  @param[in]      DebugFlags    Flags for debug messages
  @param[in,out]  ppSocket      The buffer to receive an ::ESL_SOCKET structure address.

  @retval EFI_SUCCESS           The protocol was added to ChildHandle.
  @retval EFI_INVALID_PARAMETER ChildHandle is NULL.
  @retval EFI_OUT_OF_RESOURCES  There are not enough resources available to create
                                the child
  @retval other                 The child handle was not created
**/
EFI_STATUS
EFIAPI
EslSocketAllocate (
  IN OUT EFI_HANDLE * pChildHandle,
  IN     UINTN DebugFlags,
  IN OUT ESL_SOCKET ** ppSocket
  )
{
  UINTN LengthInBytes;
  ESL_LAYER * pLayer;
  ESL_SOCKET * pSocket;
  EFI_STATUS Status;
  EFI_TPL TplPrevious;

  DBG_ENTER ( );

  //
  //  Create a socket structure
  //
  LengthInBytes = sizeof ( *pSocket );
  pSocket = (ESL_SOCKET *) AllocateZeroPool ( LengthInBytes );
  if ( NULL != pSocket ) {
    DEBUG (( DebugFlags | DEBUG_POOL | DEBUG_INIT,
              "0x%08x: Allocate pSocket, %d bytes\r\n",
              pSocket,
              LengthInBytes ));

    //
    //  Initialize the socket protocol
    //
    pSocket->Signature = SOCKET_SIGNATURE;
    pSocket->SocketProtocol.pfnAccept = EslSocketAccept;
    pSocket->SocketProtocol.pfnBind = EslSocketBind;
    pSocket->SocketProtocol.pfnClosePoll = EslSocketClosePoll;
    pSocket->SocketProtocol.pfnCloseStart = EslSocketCloseStart;
    pSocket->SocketProtocol.pfnConnect = EslSocketConnect;
    pSocket->SocketProtocol.pfnGetLocal = EslSocketGetLocalAddress;
    pSocket->SocketProtocol.pfnGetPeer = EslSocketGetPeerAddress;
    pSocket->SocketProtocol.pfnListen = EslSocketListen;
    pSocket->SocketProtocol.pfnOptionGet = EslSocketOptionGet;
    pSocket->SocketProtocol.pfnOptionSet = EslSocketOptionSet;
    pSocket->SocketProtocol.pfnPoll = EslSocketPoll;
    pSocket->SocketProtocol.pfnReceive = EslSocketReceive;
    pSocket->SocketProtocol.pfnShutdown = EslSocketShutdown;
    pSocket->SocketProtocol.pfnSocket = EslSocket;
    pSocket->SocketProtocol.pfnTransmit = EslSocketTransmit;

    pSocket->MaxRxBuf = MAX_RX_DATA;
    pSocket->MaxTxBuf = MAX_TX_DATA;

    //
    //  Install the socket protocol on the specified handle
    //
    Status = gBS->InstallMultipleProtocolInterfaces (
                    pChildHandle,
                    &gEfiSocketProtocolGuid,
                    &pSocket->SocketProtocol,
                    NULL
                    );
    if ( !EFI_ERROR ( Status )) {
      DEBUG (( DebugFlags | DEBUG_POOL | DEBUG_INIT | DEBUG_INFO,
                "Installed: gEfiSocketProtocolGuid on   0x%08x\r\n",
                *pChildHandle ));
      pSocket->SocketProtocol.SocketHandle = *pChildHandle;

      //
      //  Synchronize with the socket layer
      //
      RAISE_TPL ( TplPrevious, TPL_SOCKETS );

      //
      //  Add this socket to the list
      //
      pLayer = &mEslLayer;
      pSocket->pNext = pLayer->pSocketList;
      pLayer->pSocketList = pSocket;

      //
      //  Release the socket layer synchronization
      //
      RESTORE_TPL ( TplPrevious );

      //
      //  Return the socket structure address
      //
      *ppSocket = pSocket;
    }
    else {
      DEBUG (( DEBUG_ERROR | DebugFlags | DEBUG_POOL | DEBUG_INIT,
                "ERROR - Failed to install gEfiSocketProtocolGuid on 0x%08x, Status: %r\r\n",
                *pChildHandle,
                Status ));
    }

    //
    //  Release the socket if necessary
    //
    if ( EFI_ERROR ( Status )) {
      gBS->FreePool ( pSocket );
      DEBUG (( DebugFlags | DEBUG_POOL | DEBUG_INIT,
                "0x%08x: Free pSocket, %d bytes\r\n",
                pSocket,
                sizeof ( *pSocket )));
      pSocket = NULL;
    }
  }
  else {
    Status = EFI_OUT_OF_RESOURCES;
  }

  //
  //  Return the operation status
  //
  DBG_EXIT_STATUS ( Status );
  return Status;
}


/** Bind a name to a socket.

  This routine calls the network specific layer to save the network
  address of the local connection point.

  The ::bind routine calls this routine to connect a name
  (network address and port) to a socket on the local machine.

  @param[in]  pSocketProtocol Address of an ::EFI_SOCKET_PROTOCOL structure.
  @param[in]  pSockAddr       Address of a sockaddr structure that contains the
                              connection point on the local machine.  An IPv4 address
                              of INADDR_ANY specifies that the connection is made to
                              all of the network stacks on the platform.  Specifying a
                              specific IPv4 address restricts the connection to the
                              network stack supporting that address.  Specifying zero
                              for the port causes the network layer to assign a port
                              number from the dynamic range.  Specifying a specific
                              port number causes the network layer to use that port.
  @param[in]  SockAddrLength  Specifies the length in bytes of the sockaddr structure.
  @param[out] pErrno          Address to receive the errno value upon completion.

  @retval EFI_SUCCESS - Socket successfully created
**/
EFI_STATUS
EslSocketBind (
  IN EFI_SOCKET_PROTOCOL * pSocketProtocol,
  IN CONST struct sockaddr * pSockAddr,
  IN socklen_t SockAddrLength,
  OUT int * pErrno
  )
{
  EFI_HANDLE ChildHandle;
  UINT8 * pBuffer;
  ESL_PORT * pPort;
  ESL_SERVICE ** ppServiceListHead;
  ESL_SOCKET * pSocket;
  ESL_SERVICE * pService;
  EFI_SERVICE_BINDING_PROTOCOL * pServiceBinding;
  EFI_STATUS Status;
  EFI_TPL TplPrevious;

  DBG_ENTER ( );

  //
  //  Assume success
  //
  Status = EFI_SUCCESS;

  //
  //  Validate the socket
  //
  pSocket = NULL;
  if ( NULL != pSocketProtocol ) {
    pSocket = SOCKET_FROM_PROTOCOL ( pSocketProtocol );

    //
    //  Validate the structure pointer
    //
    pSocket->errno = 0;
    if ( NULL == pSockAddr ) {
      DEBUG (( DEBUG_BIND,
                "ERROR - pSockAddr is NULL!\r\n" ));
      Status = EFI_INVALID_PARAMETER;
      pSocket->errno = EFAULT;
    }

    //
    //  Validate the local address length
    //
    else if ( SockAddrLength < pSocket->pApi->MinimumAddressLength ) {
      DEBUG (( DEBUG_BIND,
                "ERROR - Invalid bind name length: %d\r\n",
                SockAddrLength ));
      Status = EFI_INVALID_PARAMETER;
      pSocket->errno = EINVAL;
    }

    //
    //  Validate the shutdown state
    //
    else if ( pSocket->bRxDisable || pSocket->bTxDisable ) {
      DEBUG (( DEBUG_BIND,
                "ERROR - Shutdown has been called on socket 0x%08x\r\n",
                pSocket ));
      pSocket->errno = EINVAL;
      Status = EFI_INVALID_PARAMETER;
    }

    //
    //  Verify the socket state
    //
    else if ( SOCKET_STATE_NOT_CONFIGURED != pSocket->State ) {
      DEBUG (( DEBUG_BIND,
                "ERROR - The socket 0x%08x is already configured!\r\n",
                pSocket ));
      pSocket->errno = EINVAL;
      Status = EFI_ALREADY_STARTED;
    }
    else {
      //
      //  Synchronize with the socket layer
      //
      RAISE_TPL ( TplPrevious, TPL_SOCKETS );

      //
      //  Assume no ports are available
      //
      pSocket->errno = EADDRNOTAVAIL;
      Status = EFI_INVALID_PARAMETER;

      //
      //  Walk the list of services
      //
      pBuffer = (UINT8 *)&mEslLayer;
      pBuffer = &pBuffer[ pSocket->pApi->ServiceListOffset ];
      ppServiceListHead = (ESL_SERVICE **)pBuffer;
      pService = *ppServiceListHead;
      while ( NULL != pService ) {
        //
        //  Create the port
        //
        pServiceBinding = pService->pServiceBinding;
        ChildHandle = NULL;
        Status = pServiceBinding->CreateChild ( pServiceBinding,
                                                &ChildHandle );
        if ( !EFI_ERROR ( Status )) {
          DEBUG (( DEBUG_BIND | DEBUG_POOL,
                    "0x%08x: %s port handle created\r\n",
                    ChildHandle,
                    pService->pSocketBinding->pName ));

          //
          //  Open the port
          //
          Status = EslSocketPortAllocate ( pSocket,
                                           pService,
                                           ChildHandle,
                                           pSockAddr,
                                           TRUE,
                                           DEBUG_BIND,
                                           &pPort );
        }
        else {
          DEBUG (( DEBUG_BIND | DEBUG_POOL,
                    "ERROR - Failed to open %s port handle, Status: %r\r\n",
                    pService->pSocketBinding->pName,
                    Status ));
        }

        //
        //  Set the next service
        //
        pService = pService->pNext;
      }

      //
      //  Verify that at least one network connection was found
      //
      if ( NULL != pSocket->pPortList ) {
        Status = EFI_SUCCESS;
      }
      else {
        if ( EADDRNOTAVAIL == pSocket->errno ) {
          DEBUG (( DEBUG_BIND | DEBUG_POOL | DEBUG_INIT,
                    "ERROR - Socket address is not available!\r\n" ));
        }
        if ( EADDRINUSE == pSocket->errno ) {
          DEBUG (( DEBUG_BIND | DEBUG_POOL | DEBUG_INIT,
                    "ERROR - Socket address is in use!\r\n" ));
        }
        Status = EFI_INVALID_PARAMETER;
      }

      //
      //  Mark this socket as bound if successful
      //
      if ( !EFI_ERROR ( Status )) {
        pSocket->State = SOCKET_STATE_BOUND;
        pSocket->errno = 0;
      }

      //
      //  Release the socket layer synchronization
      //
      RESTORE_TPL ( TplPrevious );
    }
  }

  //
  //  Return the operation status
  //
  if ( NULL != pErrno ) {
    if ( NULL != pSocket ) {
      *pErrno = pSocket->errno;
    }
    else {
      Status = EFI_INVALID_PARAMETER;
      *pErrno = ENOTSOCK;
    }
  }
  DBG_EXIT_STATUS ( Status );
  return Status;
}


/** Test the bind configuration.

  @param[in] pPort        Address of the ::ESL_PORT structure.
  @param[in] ErrnoValue   errno value if test fails

  @retval EFI_SUCCESS   The connection was successfully established.
  @retval Others        The connection attempt failed.
**/
EFI_STATUS
EslSocketBindTest (
  IN ESL_PORT * pPort,
  IN int ErrnoValue
  )
{
  UINT8 * pBuffer;
  VOID * pConfigData;
  EFI_STATUS Status;

  DBG_ENTER ( );

  //
  //  Locate the configuration data
  //
  pBuffer = (UINT8 *)pPort;
  pBuffer = &pBuffer [ pPort->pSocket->pApi->ConfigDataOffset ];
  pConfigData = (VOID *)pBuffer;

  //
  //  Validate that the port is connected
  //
  Status = pPort->pSocket->pApi->pfnVerifyLocalIpAddress ( pPort, pBuffer );
  if ( EFI_ERROR ( Status )) {
    DEBUG (( DEBUG_WARN | DEBUG_BIND,
              "WARNING - Port 0x%08x invalid IP address: %r\r\n",
              pPort,
              Status ));
    pPort->pSocket->errno = ErrnoValue;
  }
  else {
    //
    //  Attempt to use this configuration
    //
    Status = pPort->pfnConfigure ( pPort->pProtocol.v, pConfigData );
    if ( EFI_ERROR ( Status )) {
      DEBUG (( DEBUG_WARN | DEBUG_BIND,
                "WARNING - Port 0x%08x failed configuration, Status: %r\r\n",
                pPort,
                Status ));
      pPort->pSocket->errno = ErrnoValue;
    }
    else {
      //
      //  Reset the port
      //
      Status = pPort->pfnConfigure ( pPort->pProtocol.v, NULL );
      if ( EFI_ERROR ( Status )) {
        DEBUG (( DEBUG_ERROR | DEBUG_BIND,
                  "ERROR - Port 0x%08x failed configuration reset, Status: %r\r\n",
                  pPort,
                  Status ));
        ASSERT ( EFI_SUCCESS == Status );
      }
    }
  }

  //
  //  Return the operation status
  //
  DBG_EXIT_STATUS ( Status );
  return Status;
}


/** Determine if the socket is closed.

  This routine checks the state of the socket to determine if
  the network specific layer has completed the close operation.

  The ::close routine polls this routine to determine when the
  close operation is complete.  The close operation needs to
  reverse the operations of the ::EslSocketAllocate routine.

  @param[in]  pSocketProtocol Address of an ::EFI_SOCKET_PROTOCOL structure.
  @param[out] pErrno          Address to receive the errno value upon completion.

  @retval EFI_SUCCESS     Socket successfully closed
  @retval EFI_NOT_READY   Close still in progress
  @retval EFI_ALREADY     Close operation already in progress
  @retval Other           Failed to close the socket
**/
EFI_STATUS
EslSocketClosePoll (
  IN EFI_SOCKET_PROTOCOL * pSocketProtocol,
  IN int * pErrno
  )
{
  int errno;
  ESL_LAYER * pLayer;
  ESL_SOCKET * pNextSocket;
  ESL_SOCKET * pSocket;
  EFI_STATUS Status;
  EFI_TPL TplPrevious;

  DBG_ENTER ( );

  //
  //  Assume success
  //
  errno = 0;
  Status = EFI_SUCCESS;

  //
  //  Synchronize with the socket layer
  //
  RAISE_TPL ( TplPrevious, TPL_SOCKETS );

  //
  //  Locate the socket
  //
  pLayer = &mEslLayer;
  pNextSocket = pLayer->pSocketList;
  pSocket = SOCKET_FROM_PROTOCOL ( pSocketProtocol );
  while ( NULL != pNextSocket ) {
    if ( pNextSocket == pSocket ) {
      //
      //  Determine if the socket is in the closing state
      //
      if ( SOCKET_STATE_CLOSED == pSocket->State ) {
        //
        //  Walk the list of ports
        //
        if ( NULL == pSocket->pPortList ) {
          //
          //  All the ports are closed
          //  Close the WaitAccept event if necessary
          //
          if ( NULL != pSocket->WaitAccept ) {
            Status = gBS->CloseEvent ( pSocket->WaitAccept );
            if ( !EFI_ERROR ( Status )) {
              DEBUG (( DEBUG_SOCKET | DEBUG_CLOSE | DEBUG_POOL,
                        "0x%08x: Closed WaitAccept event\r\n",
                        pSocket->WaitAccept ));
              //
              //  Return the transmit status
              //
              Status = pSocket->TxError;
              if ( EFI_ERROR ( Status )) {
                pSocket->errno = EIO;
              }
            }
            else {
              DEBUG (( DEBUG_ERROR | DEBUG_SOCKET | DEBUG_CLOSE | DEBUG_POOL,
                        "ERROR - Failed to close the WaitAccept event, Status: %r\r\n",
                        Status ));
              ASSERT ( EFI_SUCCESS == Status );
            }
          }
        }
        else {
          //
          //  At least one port is still open
          //
          Status = EFI_NOT_READY;
          errno = EAGAIN;
        }
      }
      else {
        //
        //  SocketCloseStart was not called
        //
        Status = EFI_NOT_STARTED;
        errno = EPERM;
      }
      break;
    }

    //
    //  Set the next socket
    //
    pNextSocket = pNextSocket->pNext;
  }

  //
  //  Handle the error case where the socket was already closed
  //
  if ( NULL == pSocket ) {
    //
    //  Socket not found
    //
    Status = EFI_NOT_FOUND;
    errno = ENOTSOCK;
  }

  //
  //  Release the socket layer synchronization
  //
  RESTORE_TPL ( TplPrevious );

  //
  //  Return the operation status
  //
  if ( NULL != pErrno ) {
    *pErrno = errno;
  }
  DBG_EXIT_STATUS ( Status );
  return Status;
}


/** Start the close operation on the socket.

  This routine calls the network specific layer to initiate the
  close state machine.  This routine then calls the network
  specific layer to determine if the close state machine has gone
  to completion.  The result from this poll is returned to the
  caller.

  The ::close routine calls this routine to start the close
  operation which reverses the operations of the
  ::EslSocketAllocate routine.  The close routine then polls
  the ::EslSocketClosePoll routine to determine when the
  socket is closed.

  @param[in] pSocketProtocol  Address of an ::EFI_SOCKET_PROTOCOL structure.
  @param[in] bCloseNow        Boolean to control close behavior
  @param[out] pErrno          Address to receive the errno value upon completion.

  @retval EFI_SUCCESS     Socket successfully closed
  @retval EFI_NOT_READY   Close still in progress
  @retval EFI_ALREADY     Close operation already in progress
  @retval Other           Failed to close the socket
**/
EFI_STATUS
EslSocketCloseStart (
  IN EFI_SOCKET_PROTOCOL * pSocketProtocol,
  IN BOOLEAN bCloseNow,
  IN int * pErrno
  )
{
  int errno;
  ESL_PORT * pNextPort;
  ESL_PORT * pPort;
  ESL_SOCKET * pSocket;
  EFI_STATUS Status;
  EFI_TPL TplPrevious;

  DBG_ENTER ( );

  //
  //  Assume success
  //
  Status = EFI_SUCCESS;
  errno = 0;

  //
  //  Synchronize with the socket layer
  //
  RAISE_TPL ( TplPrevious, TPL_SOCKETS );

  //
  //  Determine if the socket is already closed
  //
  pSocket = SOCKET_FROM_PROTOCOL ( pSocketProtocol );
  if ( SOCKET_STATE_CLOSED > pSocket->State ) {
    //
    //  Update the socket state
    //
    pSocket->State = SOCKET_STATE_CLOSED;

    //
    //  Walk the list of ports
    //
    pPort = pSocket->pPortList;
    while ( NULL != pPort ) {
      //
      //  Start closing the ports
      //
      pNextPort = pPort->pLinkSocket;
      Status = EslSocketPortCloseStart ( pPort,
                                         bCloseNow,
                                         DEBUG_CLOSE | DEBUG_LISTEN | DEBUG_CONNECTION );
      if (( EFI_SUCCESS != Status )
        && ( EFI_NOT_READY != Status )) {
        errno = EIO;
        break;
      }

      //
      //  Set the next port
      //
      pPort = pNextPort;
    }

    //
    //  Attempt to finish closing the socket
    //
    if ( NULL == pPort ) {
      Status = EslSocketClosePoll ( pSocketProtocol, &errno );
    }
  }
  else {
    Status = EFI_NOT_READY;
    errno = EAGAIN;
  }

  //
  //  Release the socket layer synchronization
  //
  RESTORE_TPL ( TplPrevious );

  //
  //  Return the operation status
  //
  if ( NULL != pErrno ) {
    *pErrno = errno;
  }
  DBG_EXIT_STATUS ( Status );
  return Status;
}


/** Connect to a remote system via the network.

  This routine calls the network specific layer to establish
  the remote system address and establish the connection to
  the remote system.

  The ::connect routine calls this routine to establish a
  connection with the specified remote system.  This routine
  is designed to be polled by the connect routine for completion
  of the network connection.

  @param[in]  pSocketProtocol Address of an ::EFI_SOCKET_PROTOCOL structure.
  @param[in]  pSockAddr       Network address of the remote system.
  @param[in]  SockAddrLength  Length in bytes of the network address.
  @param[out] pErrno          Address to receive the errno value upon completion.

  @retval EFI_SUCCESS     The connection was successfully established.
  @retval EFI_NOT_READY   The connection is in progress, call this routine again.
  @retval Others          The connection attempt failed.
 **/
EFI_STATUS
EslSocketConnect (
  IN EFI_SOCKET_PROTOCOL * pSocketProtocol,
  IN const struct sockaddr * pSockAddr,
  IN socklen_t SockAddrLength,
  IN int * pErrno
  )
{
  struct sockaddr_in6 LocalAddress;
  ESL_PORT * pPort;
  ESL_SOCKET * pSocket;
  EFI_STATUS Status;
  EFI_TPL TplPrevious;

  DEBUG (( DEBUG_CONNECT, "Entering SocketConnect\r\n" ));

  //
  //  Assume success
  //
  Status = EFI_SUCCESS;

  //
  //  Validate the socket
  //
  pSocket = NULL;
  if ( NULL != pSocketProtocol ) {
    pSocket = SOCKET_FROM_PROTOCOL ( pSocketProtocol );

    //
    //  Validate the name length
    //
    if ( SockAddrLength < ( sizeof ( struct sockaddr ) - sizeof ( pSockAddr->sa_data ))) {
      DEBUG (( DEBUG_CONNECT,
                "ERROR - Invalid bind name length: %d\r\n",
                SockAddrLength ));
      Status = EFI_INVALID_PARAMETER;
      pSocket->errno = EINVAL;
    }
    else {
      //
      //  Assume success
      //
      pSocket->errno = 0;

      //
      //  Synchronize with the socket layer
      //
      RAISE_TPL ( TplPrevious, TPL_SOCKETS );

      //
      //  Validate the socket state
      //
      switch ( pSocket->State ) {
      default:
        //
        //  Wrong socket state
        //
        pSocket->errno = EIO;
        Status = EFI_DEVICE_ERROR;
        break;

      case SOCKET_STATE_NOT_CONFIGURED:
      case SOCKET_STATE_BOUND:
        //
        //  Validate the address length
        //
        if ( SockAddrLength >= pSocket->pApi->MinimumAddressLength ) {
          //
          //  Verify the API
          //
          if ( NULL == pSocket->pApi->pfnRemoteAddrSet ) {
            //
            //  Already connected
            //
            pSocket->errno = ENOTSUP;
            Status = EFI_UNSUPPORTED;
          }
          else {
            //
            //  Determine if BIND was already called
            //
            if ( NULL == pSocket->pPortList ) {
              //
              //  Allow any local port
              //
              ZeroMem ( &LocalAddress, sizeof ( LocalAddress ));
              LocalAddress.sin6_len = (uint8_t)pSocket->pApi->MinimumAddressLength;
              LocalAddress.sin6_family = pSocket->pApi->AddressFamily;
              Status = EslSocketBind ( &pSocket->SocketProtocol,
                                       (struct sockaddr *)&LocalAddress,
                                       LocalAddress.sin6_len,
                                       &pSocket->errno );
            }
            if ( NULL != pSocket->pPortList ) {
              //
              //  Walk the list of ports
              //
              pPort = pSocket->pPortList;
              while ( NULL != pPort ) {
                //
                //  Set the remote address
                //
                Status = pSocket->pApi->pfnRemoteAddrSet ( pPort,
                                                           pSockAddr,
                                                           SockAddrLength );
                if ( EFI_ERROR ( Status )) {
                  break;
                }

                //
                //  Set the next port
                //
                pPort = pPort->pLinkSocket;
              }

              //
              //  Verify the API
              //
              if (( !EFI_ERROR ( Status ))
                && ( NULL != pSocket->pApi->pfnConnectStart )) {
                //
                //  Initiate the connection with the remote system
                //
                Status = pSocket->pApi->pfnConnectStart ( pSocket );

                //
                //  Set the next state if connecting
                //
                if ( EFI_NOT_READY == Status ) {
                  pSocket->State = SOCKET_STATE_CONNECTING;
                }
              }
            }
          }
        }
        else {
          DEBUG (( DEBUG_CONNECT,
                    "ERROR - Invalid address length: %d\r\n",
                    SockAddrLength ));
          Status = EFI_INVALID_PARAMETER;
          pSocket->errno = EINVAL;
        }
        break;

      case SOCKET_STATE_CONNECTING:
        //
        //  Poll the network adapter
        //
        EslSocketRxPoll ( pSocket );

        //
        //  Poll for connection completion
        //
        if ( NULL == pSocket->pApi->pfnConnectPoll ) {
          //
          //  Already connected
          //
          pSocket->errno = EISCONN;
          Status = EFI_ALREADY_STARTED;
        }
        else {
          Status = pSocket->pApi->pfnConnectPoll ( pSocket );

          //
          //  Set the next state if connected
          //
          if ( EFI_NOT_READY != Status ) {
            if ( EFI_ERROR ( Status )) {
              pSocket->State = SOCKET_STATE_BOUND;
            }
          }
        }
        break;

      case SOCKET_STATE_CONNECTED:
        //
        //  Connected
        //
        Status = EFI_SUCCESS;
        break;
      }

      //
      //  Release the socket layer synchronization
      //
      RESTORE_TPL ( TplPrevious );
    }
  }

  //
  //  Return the operation status
  //
  if ( NULL != pErrno ) {
    if ( NULL != pSocket ) {
      *pErrno = pSocket->errno;
    }
    else {
      //
      //  Bad socket protocol
      //
      DEBUG (( DEBUG_ERROR | DEBUG_CONNECT,
                "ERROR - pSocketProtocol invalid!\r\n" ));
      Status = EFI_INVALID_PARAMETER;
      *pErrno = ENOTSOCK;
    }
  }

  //
  //  Return the operation status
  //
  DEBUG (( DEBUG_CONNECT, "Exiting SocketConnect, Status: %r\r\n", Status ));
  return Status;
}


/** Copy a fragmented buffer into a destination buffer.

  This support routine copies a fragmented buffer to the caller specified buffer.

  This routine is called by ::EslIp4Receive and ::EslUdp4Receive.

  @param[in]  FragmentCount   Number of fragments in the table
  @param[in]  pFragmentTable  Address of an EFI_IP4_FRAGMENT_DATA structure
  @param[in]  BufferLength    Length of the the buffer
  @param[in]  pBuffer         Address of a buffer to receive the data.
  @param[in]  pDataLength     Number of received data bytes in the buffer.

  @return   Returns the address of the next free byte in the buffer.
**/
UINT8 *
EslSocketCopyFragmentedBuffer (
  IN UINT32 FragmentCount,
  IN EFI_IP4_FRAGMENT_DATA * pFragmentTable,
  IN size_t BufferLength,
  IN UINT8 * pBuffer,
  OUT size_t * pDataLength
  )
{
  size_t BytesToCopy;
  UINT32 Fragment;
  UINT8 * pBufferEnd;
  UINT8 * pData;

  DBG_ENTER ( );

  //
  //  Validate the IP and UDP structures are identical
  //
  ASSERT ( OFFSET_OF ( EFI_IP4_FRAGMENT_DATA, FragmentLength )
           == OFFSET_OF ( EFI_UDP4_FRAGMENT_DATA, FragmentLength ));
  ASSERT ( OFFSET_OF ( EFI_IP4_FRAGMENT_DATA, FragmentBuffer )
           == OFFSET_OF ( EFI_UDP4_FRAGMENT_DATA, FragmentBuffer ));

  //
  //  Copy the received data
  //
  Fragment = 0;
  pBufferEnd = &pBuffer [ BufferLength ];
  while (( pBufferEnd > pBuffer ) && ( FragmentCount > Fragment )) {
    //
    //  Determine the amount of received data
    //
    pData = pFragmentTable[Fragment].FragmentBuffer;
    BytesToCopy = pFragmentTable[Fragment].FragmentLength;
    if (((size_t)( pBufferEnd - pBuffer )) < BytesToCopy ) {
      BytesToCopy = pBufferEnd - pBuffer;
    }

    //
    //  Move the data into the buffer
    //
    DEBUG (( DEBUG_RX,
              "0x%08x --> 0x%08x: Copy data 0x%08x bytes\r\n",
              pData,
              pBuffer,
              BytesToCopy ));
    CopyMem ( pBuffer, pData, BytesToCopy );
    pBuffer += BytesToCopy;
    Fragment += 1;
  }

  //
  //  Return the data length and the buffer address
  //
  *pDataLength = BufferLength - ( pBufferEnd - pBuffer );
  DBG_EXIT_HEX ( pBuffer );
  return pBuffer;
}


/** Free the socket.

  This routine frees the socket structure and handle resources.

  The ::close routine calls EslServiceFreeProtocol which then calls
  this routine to free the socket context structure and close the
  handle.

  @param[in]  pSocketProtocol Address of an ::EFI_SOCKET_PROTOCOL structure.
  @param[out] pErrno          Address to receive the errno value upon completion.

  @retval EFI_SUCCESS   The socket resources were returned successfully.
**/
EFI_STATUS
EslSocketFree (
  IN EFI_SOCKET_PROTOCOL * pSocketProtocol,
  IN int * pErrno
  )
{
  EFI_HANDLE ChildHandle;
  int errno;
  ESL_LAYER * pLayer;
  ESL_SOCKET * pSocket;
  ESL_SOCKET * pSocketPrevious;
  EFI_STATUS Status;
  EFI_TPL TplPrevious;

  DBG_ENTER ( );

  //
  //  Assume failure
  //
  errno = EIO;
  pSocket = NULL;
  Status = EFI_INVALID_PARAMETER;

  //
  //  Validate the socket
  //
  pLayer = &mEslLayer;
  if ( NULL != pSocketProtocol ) {
    pSocket = SOCKET_FROM_PROTOCOL ( pSocketProtocol );

    //
    //  Synchronize with the socket layer
    //
    RAISE_TPL ( TplPrevious, TPL_SOCKETS );

    //
    //  Walk the socket list
    //
    pSocketPrevious = pLayer->pSocketList;
    if ( NULL != pSocketPrevious ) {
      if ( pSocket == pSocketPrevious ) {
        //
        //  Remove the socket from the head of the list
        //
        pLayer->pSocketList = pSocket->pNext;
      }
      else {
        //
        //  Find the socket in the middle of the list
        //
        while (( NULL != pSocketPrevious )
          && ( pSocket != pSocketPrevious->pNext )) {
          //
          //  Set the next socket
          //
          pSocketPrevious = pSocketPrevious->pNext;
        }
        if ( NULL != pSocketPrevious ) {
          //
          //  Remove the socket from the middle of the list
          //
          pSocketPrevious = pSocket->pNext;
        }
      }
    }
    else {
      DEBUG (( DEBUG_ERROR | DEBUG_POOL,
                "ERROR - Socket list is empty!\r\n" ));
    }

    //
    //  Release the socket layer synchronization
    //
    RESTORE_TPL ( TplPrevious );

    //
    //  Determine if the socket was found
    //
    if ( NULL != pSocketPrevious ) {
      pSocket->pNext = NULL;

      //
      //  Remove the socket protocol
      //
      ChildHandle = pSocket->SocketProtocol.SocketHandle;
      Status = gBS->UninstallMultipleProtocolInterfaces (
                ChildHandle,
                &gEfiSocketProtocolGuid,
                &pSocket->SocketProtocol,
                NULL );
      if ( !EFI_ERROR ( Status )) {
        DEBUG (( DEBUG_POOL | DEBUG_INFO,
                    "Removed:   gEfiSocketProtocolGuid from 0x%08x\r\n",
                    ChildHandle ));

        //
        //  Free the socket structure
        //
        Status = gBS->FreePool ( pSocket );
        if ( !EFI_ERROR ( Status )) {
          DEBUG (( DEBUG_POOL,
                    "0x%08x: Free pSocket, %d bytes\r\n",
                    pSocket,
                    sizeof ( *pSocket )));
          errno = 0;
        }
        else {
          DEBUG (( DEBUG_ERROR | DEBUG_POOL,
                    "ERROR - Failed to free pSocket 0x%08x, Status: %r\r\n",
                    pSocket,
                    Status ));
        }
      }
      else {
        DEBUG (( DEBUG_ERROR | DEBUG_POOL | DEBUG_INFO,
                    "ERROR - Failed to remove gEfiSocketProtocolGuid from 0x%08x, Status: %r\r\n",
                    ChildHandle,
                    Status ));
      }
    }
    else {
      DEBUG (( DEBUG_ERROR | DEBUG_INFO,
                "ERROR - The socket was not in the socket list!\r\n" ));
      Status = EFI_NOT_FOUND;
    }
  }
  else {
    DEBUG (( DEBUG_ERROR,
              "ERROR - Invalid parameter pSocketProtocol is NULL\r\n" ));
  }

  //
  //  Return the errno value if possible
  //
  if ( NULL != pErrno ) {
    *pErrno = errno;
  }

  //
  //  Return the operation status
  //
  DBG_EXIT_STATUS ( Status );
  return Status;
}


/** Get the local address.

  This routine calls the network specific layer to get the network
  address of the local host connection point.

  The ::getsockname routine calls this routine to obtain the network
  address associated with the local host connection point.

  @param[in]      pSocketProtocol Address of an ::EFI_SOCKET_PROTOCOL structure.
  @param[out]     pAddress        Network address to receive the local system address
  @param[in,out]  pAddressLength  Length of the local network address structure
  @param[out]     pErrno          Address to receive the errno value upon completion.

  @retval EFI_SUCCESS - Local address successfully returned
 **/
EFI_STATUS
EslSocketGetLocalAddress (
  IN EFI_SOCKET_PROTOCOL * pSocketProtocol,
  OUT struct sockaddr * pAddress,
  IN OUT socklen_t * pAddressLength,
  IN int * pErrno
  )
{
  socklen_t LengthInBytes;
  ESL_PORT * pPort;
  ESL_SOCKET * pSocket;
  EFI_STATUS Status;
  EFI_TPL TplPrevious;

  DBG_ENTER ( );

  //
  //  Assume success
  //
  Status = EFI_SUCCESS;

  //
  //  Validate the socket
  //
  pSocket = NULL;
  if ( NULL != pSocketProtocol ) {
    pSocket = SOCKET_FROM_PROTOCOL ( pSocketProtocol );

    //
    //  Verify the socket state
    //
    EslSocketIsConfigured ( pSocket );
    if ( pSocket->bAddressSet ) {
      //
      //  Verify the address buffer and length address
      //
      if (( NULL != pAddress ) && ( NULL != pAddressLength )) {
        //
        //  Verify the API
        //
        if ( NULL == pSocket->pApi->pfnLocalAddrGet ) {
          Status = EFI_UNSUPPORTED;
          pSocket->errno = ENOTSUP;
        }
        else {
          //
          //  Synchronize with the socket layer
          //
          RAISE_TPL ( TplPrevious, TPL_SOCKETS );

          //
          //  Verify that there is just a single connection
          //
          pPort = pSocket->pPortList;
          if ( NULL != pPort ) {
            //
            //  Verify the address length
            //
            LengthInBytes = pSocket->pApi->AddressLength;
            if (( LengthInBytes <= *pAddressLength )
              && ( 255 >= LengthInBytes )) {
              //
              //  Return the local address and address length
              //
              ZeroMem ( pAddress, LengthInBytes );
              pAddress->sa_len = (uint8_t)LengthInBytes;
              *pAddressLength = pAddress->sa_len;
              pSocket->pApi->pfnLocalAddrGet ( pPort, pAddress );
              pSocket->errno = 0;
              Status = EFI_SUCCESS;
            }
            else {
              pSocket->errno = EINVAL;
              Status = EFI_INVALID_PARAMETER;
            }
          }
          else {
            pSocket->errno = ENOTCONN;
            Status = EFI_NOT_STARTED;
          }

          //
          //  Release the socket layer synchronization
          //
          RESTORE_TPL ( TplPrevious );
        }
      }
      else {
        pSocket->errno = EINVAL;
        Status = EFI_INVALID_PARAMETER;
      }
    }
    else {
      //
      //  Address not set
      //
      Status = EFI_NOT_STARTED;
      pSocket->errno = EADDRNOTAVAIL;
    }
  }

  //
  //  Return the operation status
  //
  if ( NULL != pErrno ) {
    if ( NULL != pSocket ) {
      *pErrno = pSocket->errno;
    }
    else {
      Status = EFI_INVALID_PARAMETER;
      *pErrno = ENOTSOCK;
    }
  }
  DBG_EXIT_STATUS ( Status );
  return Status;
}


/** Get the peer address.

  This routine calls the network specific layer to get the remote
  system connection point.

  The ::getpeername routine calls this routine to obtain the network
  address of the remote connection point.

  @param[in]      pSocketProtocol   Address of an ::EFI_SOCKET_PROTOCOL structure.
  @param[out]     pAddress          Network address to receive the remote system address
  @param[in,out]  pAddressLength    Length of the remote network address structure
  @param[out]     pErrno            Address to receive the errno value upon completion.

  @retval EFI_SUCCESS - Remote address successfully returned
 **/
EFI_STATUS
EslSocketGetPeerAddress (
  IN EFI_SOCKET_PROTOCOL * pSocketProtocol,
  OUT struct sockaddr * pAddress,
  IN OUT socklen_t * pAddressLength,
  IN int * pErrno
  )
{
  socklen_t LengthInBytes;
  ESL_PORT * pPort;
  ESL_SOCKET * pSocket;
  EFI_STATUS Status;
  EFI_TPL TplPrevious;

  DBG_ENTER ( );

  //
  //  Assume success
  //
  Status = EFI_SUCCESS;

  //
  //  Validate the socket
  //
  pSocket = NULL;
  if ( NULL != pSocketProtocol ) {
    pSocket = SOCKET_FROM_PROTOCOL ( pSocketProtocol );

    //
    //  Verify the socket state
    //
    Status = EslSocketIsConfigured ( pSocket );
    if ( !EFI_ERROR ( Status )) {
      //
      //  Verify the API
      //
      if ( NULL == pSocket->pApi->pfnRemoteAddrGet ) {
        Status = EFI_UNSUPPORTED;
        pSocket->errno = ENOTSUP;
      }
      else {
        //
        //  Verify the address buffer and length address
        //
        if (( NULL != pAddress ) && ( NULL != pAddressLength )) {
          //
          //  Verify the socket state
          //
          if ( SOCKET_STATE_CONNECTED == pSocket->State ) {
            //
            //  Synchronize with the socket layer
            //
            RAISE_TPL ( TplPrevious, TPL_SOCKETS );

            //
            //  Verify that there is just a single connection
            //
            pPort = pSocket->pPortList;
            if (( NULL != pPort ) && ( NULL == pPort->pLinkSocket )) {
              //
              //  Verify the address length
              //
              LengthInBytes = pSocket->pApi->AddressLength;
              if ( LengthInBytes <= *pAddressLength ) {
                //
                //  Return the local address
                //
                ZeroMem ( pAddress, LengthInBytes );
                pAddress->sa_len = (uint8_t)LengthInBytes;
                *pAddressLength = pAddress->sa_len;
                pSocket->pApi->pfnRemoteAddrGet ( pPort, pAddress );
                pSocket->errno = 0;
                Status = EFI_SUCCESS;
              }
              else {
                pSocket->errno = EINVAL;
                Status = EFI_INVALID_PARAMETER;
              }
            }
            else {
              pSocket->errno = ENOTCONN;
              Status = EFI_NOT_STARTED;
            }

            //
            //  Release the socket layer synchronization
            //
            RESTORE_TPL ( TplPrevious );
          }
          else {
            pSocket->errno = ENOTCONN;
            Status = EFI_NOT_STARTED;
          }
        }
        else {
          pSocket->errno = EINVAL;
          Status = EFI_INVALID_PARAMETER;
        }
      }
    }
  }

  //
  //  Return the operation status
  //
  if ( NULL != pErrno ) {
    if ( NULL != pSocket ) {
      *pErrno = pSocket->errno;
    }
    else {
      Status = EFI_INVALID_PARAMETER;
      *pErrno = ENOTSOCK;
    }
  }
  DBG_EXIT_STATUS ( Status );
  return Status;
}


/** Free the ESL_IO_MGMT event and structure.

  This support routine walks the free list to close the event in
  the ESL_IO_MGMT structure and remove the structure from the free
  list.

  See the \ref TransmitEngine section.

  @param[in]  pPort         Address of an ::ESL_PORT structure
  @param[in]  ppFreeQueue   Address of the free queue head
  @param[in]  DebugFlags    Flags for debug messages
  @param[in]  pEventName    Zero terminated string containing the event name

  @retval EFI_SUCCESS - The structures were properly initialized
**/
EFI_STATUS
EslSocketIoFree (
  IN ESL_PORT * pPort,
  IN ESL_IO_MGMT ** ppFreeQueue,
  IN UINTN DebugFlags,
  IN CHAR8 * pEventName
  )
{
  UINT8 * pBuffer;
  EFI_EVENT * pEvent;
  ESL_IO_MGMT * pIo;
  ESL_SOCKET * pSocket;
  EFI_STATUS Status;

  DBG_ENTER ( );

  //
  //  Assume success
  //
  Status = EFI_SUCCESS;

  //
  //  Walk the list of IO structures
  //
  pSocket = pPort->pSocket;
  while ( *ppFreeQueue ) {
    //
    //  Free the event for this structure
    //
    pIo = *ppFreeQueue;
    pBuffer = (UINT8 *)pIo;
    pBuffer = &pBuffer[ pSocket->TxTokenEventOffset ];
    pEvent = (EFI_EVENT *)pBuffer;
    Status = gBS->CloseEvent ( *pEvent );
    if ( EFI_ERROR ( Status )) {
      DEBUG (( DEBUG_ERROR | DebugFlags,
                "ERROR - Failed to close the %a event, Status: %r\r\n",
                pEventName,
                Status ));
      pSocket->errno = ENOMEM;
      break;
    }
    DEBUG (( DebugFlags,
              "0x%08x: Closed %a event 0x%08x\r\n",
              pIo,
              pEventName,
              *pEvent ));

    //
    //  Remove this structure from the queue
    //
    *ppFreeQueue = pIo->pNext;
  }

  //
  //  Return the operation status
  //
  DBG_EXIT_STATUS ( Status );
  return Status;
}


/** Initialize the ESL_IO_MGMT structures.

  This support routine initializes the ESL_IO_MGMT structure and
  places them on to a free list.

  This routine is called by ::EslSocketPortAllocate routines to prepare
  the transmit engines.  See the \ref TransmitEngine section.

  @param[in]        pPort         Address of an ::ESL_PORT structure
  @param[in, out]   ppIo          Address containing the first structure address.  Upon
                                  return this buffer contains the next structure address.
  @param[in]        TokenCount    Number of structures to initialize
  @param[in]        ppFreeQueue   Address of the free queue head
  @param[in]        DebugFlags    Flags for debug messages
  @param[in]        pEventName    Zero terminated string containing the event name
  @param[in]        pfnCompletion Completion routine address

  @retval EFI_SUCCESS - The structures were properly initialized
**/
EFI_STATUS
EslSocketIoInit (
  IN ESL_PORT * pPort,
  IN ESL_IO_MGMT ** ppIo,
  IN UINTN TokenCount,
  IN ESL_IO_MGMT ** ppFreeQueue,
  IN UINTN DebugFlags,
  IN CHAR8 * pEventName,
  IN PFN_API_IO_COMPLETE pfnCompletion
  )
{
  ESL_IO_MGMT * pEnd;
  EFI_EVENT * pEvent;
  ESL_IO_MGMT * pIo;
  ESL_SOCKET * pSocket;
  EFI_STATUS Status;

  DBG_ENTER ( );

  //
  //  Assume success
  //
  Status = EFI_SUCCESS;

  //
  //  Walk the list of IO structures
  //
  pSocket = pPort->pSocket;
  pIo = *ppIo;
  pEnd = &pIo [ TokenCount ];
  while ( pEnd > pIo ) {
    //
    //  Initialize the IO structure
    //
    pIo->pPort = pPort;
    pIo->pPacket = NULL;

    //
    //  Allocate the event for this structure
    //
    pEvent = (EFI_EVENT *)&(((UINT8 *)pIo)[ pSocket->TxTokenEventOffset ]);
    Status = gBS->CreateEvent ( EVT_NOTIFY_SIGNAL,
                                TPL_SOCKETS,
                                (EFI_EVENT_NOTIFY)pfnCompletion,
                                pIo,
                                pEvent );
    if ( EFI_ERROR ( Status )) {
      DEBUG (( DEBUG_ERROR | DebugFlags,
                "ERROR - Failed to create the %a event, Status: %r\r\n",
                pEventName,
                Status ));
      pSocket->errno = ENOMEM;
      break;
    }
    DEBUG (( DebugFlags,
              "0x%08x: Created %a event 0x%08x\r\n",
              pIo,
              pEventName,
              *pEvent ));

    //
    //  Add this structure to the queue
    //
    pIo->pNext = *ppFreeQueue;
    *ppFreeQueue = pIo;

    //
    //  Set the next structure
    //
    pIo += 1;
  }

  //
  //  Save the next structure
  //
  *ppIo = pIo;

  //
  //  Return the operation status
  //
  DBG_EXIT_STATUS ( Status );
  return Status;
}


/** Determine if the socket is configured.

  This support routine is called to determine if the socket if the
  configuration call was made to the network layer.  The following
  routines call this routine to verify that they may be successful
  in their operations:
  <ul>
    <li>::EslSocketGetLocalAddress</li>
    <li>::EslSocketGetPeerAddress</li>
    <li>::EslSocketPoll</li>
    <li>::EslSocketReceive</li>
    <li>::EslSocketTransmit</li>
  </ul>

  @param[in]  pSocket       Address of an ::ESL_SOCKET structure

  @retval EFI_SUCCESS - The socket is configured
**/
EFI_STATUS
EslSocketIsConfigured (
  IN ESL_SOCKET * pSocket
  )
{
  EFI_STATUS Status;
  EFI_TPL TplPrevious;

  //
  //  Assume success
  //
  Status = EFI_SUCCESS;

  //
  //  Verify the socket state
  //
  if ( !pSocket->bConfigured ) {
    DBG_ENTER ( );

    //
    //  Verify the API
    //
    if ( NULL == pSocket->pApi->pfnIsConfigured ) {
      Status = EFI_UNSUPPORTED;
      pSocket->errno = ENOTSUP;
    }
    else {
      //
      //  Synchronize with the socket layer
      //
      RAISE_TPL ( TplPrevious, TPL_SOCKETS );

      //
      //  Determine if the socket is configured
      //
      Status = pSocket->pApi->pfnIsConfigured ( pSocket );

      //
      //  Release the socket layer synchronization
      //
      RESTORE_TPL ( TplPrevious );

      //
      //  Set errno if a failure occurs
      //
      if ( EFI_ERROR ( Status )) {
        pSocket->errno = EADDRNOTAVAIL;
      }
    }

    DBG_EXIT_STATUS ( Status );
  }

  //
  //  Return the configuration status
  //
  return Status;
}


/** Establish the known port to listen for network connections.

  This routine calls into the network protocol layer to establish
  a handler that is called upon connection completion.  The handler
  is responsible for inserting the connection into the FIFO.

  The ::listen routine indirectly calls this routine to place the
  socket into a state that enables connection attempts.  Connections
  are placed in a FIFO that is serviced by the application.  The
  application calls the ::accept (::EslSocketAccept) routine to
  remove the next connection from the FIFO and get the associated
  socket and address.

  @param[in]  pSocketProtocol Address of an ::EFI_SOCKET_PROTOCOL structure.
  @param[in]  Backlog         Backlog specifies the maximum FIFO depth for
                              the connections waiting for the application
                              to call accept.  Connection attempts received
                              while the queue is full are refused.
  @param[out] pErrno          Address to receive the errno value upon completion.

  @retval EFI_SUCCESS - Socket successfully created
  @retval Other - Failed to enable the socket for listen
**/
EFI_STATUS
EslSocketListen (
  IN EFI_SOCKET_PROTOCOL * pSocketProtocol,
  IN INT32 Backlog,
  OUT int * pErrno
  )
{
  ESL_SOCKET * pSocket;
  EFI_STATUS Status;
  EFI_STATUS TempStatus;
  EFI_TPL TplPrevious;

  DBG_ENTER ( );

  //
  //  Assume success
  //
  Status = EFI_SUCCESS;

  //
  //  Validate the socket
  //
  pSocket = NULL;
  if ( NULL != pSocketProtocol ) {
    pSocket = SOCKET_FROM_PROTOCOL ( pSocketProtocol );

    //
    //  Verify the API
    //
    if ( NULL == pSocket->pApi->pfnListen ) {
      Status = EFI_UNSUPPORTED;
      pSocket->errno = ENOTSUP;
    }
    else {
      //
      //  Assume success
      //
      pSocket->Status = EFI_SUCCESS;
      pSocket->errno = 0;

      //
      //  Verify that the bind operation was successful
      //
      if ( SOCKET_STATE_BOUND == pSocket->State ) {
        //
        //  Synchronize with the socket layer
        //
        RAISE_TPL ( TplPrevious, TPL_SOCKETS );

        //
        //  Create the event for SocketAccept completion
        //
        Status = gBS->CreateEvent ( 0,
                                    TPL_SOCKETS,
                                    NULL,
                                    NULL,
                                    &pSocket->WaitAccept );
        if ( !EFI_ERROR ( Status )) {
          DEBUG (( DEBUG_POOL,
                    "0x%08x: Created WaitAccept event\r\n",
                    pSocket->WaitAccept ));
          //
          //  Set the maximum FIFO depth
          //
          if ( 0 >= Backlog ) {
            Backlog = MAX_PENDING_CONNECTIONS;
          }
          else {
            if ( SOMAXCONN < Backlog ) {
              Backlog = SOMAXCONN;
            }
            else {
              pSocket->MaxFifoDepth = Backlog;
            }
          }

          //
          //  Initiate the connection attempt listen
          //
          Status = pSocket->pApi->pfnListen ( pSocket );

          //
          //  Place the socket in the listen state if successful
          //
          if ( !EFI_ERROR ( Status )) {
            pSocket->State = SOCKET_STATE_LISTENING;
            pSocket->bListenCalled = TRUE;
          }
          else {
            //
            //  Not waiting for SocketAccept to complete
            //
            TempStatus = gBS->CloseEvent ( pSocket->WaitAccept );
            if ( !EFI_ERROR ( TempStatus )) {
              DEBUG (( DEBUG_POOL,
                        "0x%08x: Closed WaitAccept event\r\n",
                        pSocket->WaitAccept ));
              pSocket->WaitAccept = NULL;
            }
            else {
              DEBUG (( DEBUG_ERROR | DEBUG_POOL,
                        "ERROR - Failed to close WaitAccept event, Status: %r\r\n",
                        TempStatus ));
              ASSERT ( EFI_SUCCESS == TempStatus );
            }
          }
        }
        else {
          DEBUG (( DEBUG_ERROR | DEBUG_LISTEN,
                    "ERROR - Failed to create the WaitAccept event, Status: %r\r\n",
                    Status ));
          pSocket->errno = ENOMEM;
        }

        //
        //  Release the socket layer synchronization
        //
        RESTORE_TPL ( TplPrevious );
      }
      else {
        DEBUG (( DEBUG_ERROR | DEBUG_LISTEN,
                  "ERROR - Bind operation must be performed first!\r\n" ));
        pSocket->errno = ( SOCKET_STATE_NOT_CONFIGURED == pSocket->State ) ? EDESTADDRREQ
                                                                           : EINVAL;
        Status = EFI_NO_MAPPING;
      }
    }
  }

  //
  //  Return the operation status
  //
  if ( NULL != pErrno ) {
    if ( NULL != pSocket ) {
      *pErrno = pSocket->errno;
    }
    else {
      Status = EFI_INVALID_PARAMETER;
      *pErrno = ENOTSOCK;
    }
  }
  DBG_EXIT_STATUS ( Status );
  return Status;
}


/** Get the socket options.

  This routine handles the socket level options and passes the
  others to the network specific layer.

  The ::getsockopt routine calls this routine to retrieve the
  socket options one at a time by name.

  @param[in]      pSocketProtocol   Address of an ::EFI_SOCKET_PROTOCOL structure.
  @param[in]      level             Option protocol level
  @param[in]      OptionName        Name of the option
  @param[out]     pOptionValue      Buffer to receive the option value
  @param[in,out]  pOptionLength     Length of the buffer in bytes,
                                    upon return length of the option value in bytes
  @param[out]     pErrno            Address to receive the errno value upon completion.

  @retval EFI_SUCCESS - Socket data successfully received
 **/
EFI_STATUS
EslSocketOptionGet (
  IN EFI_SOCKET_PROTOCOL * pSocketProtocol,
  IN int level,
  IN int OptionName,
  OUT void * __restrict pOptionValue,
  IN OUT socklen_t * __restrict pOptionLength,
  IN int * pErrno
  )
{
  int errno;
  socklen_t LengthInBytes;
  socklen_t MaxBytes;
  CONST UINT8 * pOptionData;
  ESL_SOCKET * pSocket;
  EFI_STATUS Status;

  DBG_ENTER ( );

  //
  //  Assume failure
  //
  errno = EINVAL;
  Status = EFI_INVALID_PARAMETER;

  //
  //  Validate the socket
  //
  pSocket = NULL;
  if ( NULL == pSocketProtocol ) {
    DEBUG (( DEBUG_OPTION, "ERROR - pSocketProtocol is NULL!\r\n" ));
  }
  else if ( NULL == pOptionValue ) {
    DEBUG (( DEBUG_OPTION, "ERROR - No option buffer specified\r\n" ));
  }
  else if ( NULL == pOptionLength ) {
    DEBUG (( DEBUG_OPTION, "ERROR - Option length not specified!\r\n" ));
  }
  else {
    pSocket = SOCKET_FROM_PROTOCOL ( pSocketProtocol );
    LengthInBytes = 0;
    MaxBytes = *pOptionLength;
    pOptionData = NULL;
    switch ( level ) {
    default:
      //
      //  See if the protocol will handle the option
      //
      if ( NULL != pSocket->pApi->pfnOptionGet ) {
        if ( pSocket->pApi->DefaultProtocol == level ) {
          Status = pSocket->pApi->pfnOptionGet ( pSocket,
                                                 OptionName,
                                                 (CONST void ** __restrict)&pOptionData,
                                                 &LengthInBytes );
          errno = pSocket->errno;
          break;
        }
        else {
          //
          //  Protocol not supported
          //
          DEBUG (( DEBUG_OPTION,
                    "ERROR - The socket does not support this protocol!\r\n" ));
        }
      }
      else {
        //
        //  Protocol level not supported
        //
        DEBUG (( DEBUG_OPTION,
                  "ERROR - %a does not support any options!\r\n",
                  pSocket->pApi->pName ));
      }
      errno = ENOPROTOOPT;
      Status = EFI_INVALID_PARAMETER;
      break;

    case SOL_SOCKET:
      switch ( OptionName ) {
      default:
        //
        //  Socket option not supported
        //
        DEBUG (( DEBUG_INFO | DEBUG_OPTION, "ERROR - Invalid socket option!\r\n" ));
        errno = EINVAL;
        Status = EFI_INVALID_PARAMETER;
        break;

      case SO_ACCEPTCONN:
        //
        //  Return the listen flag
        //
        pOptionData = (CONST UINT8 *)&pSocket->bListenCalled;
        LengthInBytes = sizeof ( pSocket->bListenCalled );
        break;

      case SO_DEBUG:
        //
        //  Return the debug flags
        //
        pOptionData = (CONST UINT8 *)&pSocket->bOobInLine;
        LengthInBytes = sizeof ( pSocket->bOobInLine );
        break;

      case SO_OOBINLINE:
        //
        //  Return the out-of-band inline flag
        //
        pOptionData = (CONST UINT8 *)&pSocket->bOobInLine;
        LengthInBytes = sizeof ( pSocket->bOobInLine );
        break;

      case SO_RCVTIMEO:
        //
        //  Return the receive timeout
        //
        pOptionData = (CONST UINT8 *)&pSocket->RxTimeout;
        LengthInBytes = sizeof ( pSocket->RxTimeout );
        break;

      case SO_RCVBUF:
        //
        //  Return the maximum receive buffer size
        //
        pOptionData = (CONST UINT8 *)&pSocket->MaxRxBuf;
        LengthInBytes = sizeof ( pSocket->MaxRxBuf );
        break;

      case SO_REUSEADDR:
        //
        //  Return the address reuse flag
        //
        pOptionData = (UINT8 *)&pSocket->bReUseAddr;
        LengthInBytes = sizeof ( pSocket->bReUseAddr );
        break;

      case SO_SNDBUF:
        //
        //  Return the maximum transmit buffer size
        //
        pOptionData = (CONST UINT8 *)&pSocket->MaxTxBuf;
        LengthInBytes = sizeof ( pSocket->MaxTxBuf );
        break;

      case SO_TYPE:
        //
        //  Return the socket type
        //
        pOptionData = (CONST UINT8 *)&pSocket->Type;
        LengthInBytes = sizeof ( pSocket->Type );
        break;
      }
      break;
    }

    //
    //  Return the option length
    //
    *pOptionLength = LengthInBytes;

    //
    //  Determine if the option is present
    //
    if ( 0 != LengthInBytes ) {
      //
      //  Silently truncate the value length
      //
      if ( LengthInBytes > MaxBytes ) {
        DEBUG (( DEBUG_OPTION,
                  "INFO - Truncating option from %d to %d bytes\r\n",
                  LengthInBytes,
                  MaxBytes ));
        LengthInBytes = MaxBytes;
      }

      //
      //  Return the value
      //
      CopyMem ( pOptionValue, pOptionData, LengthInBytes );

      //
      //  Zero fill any remaining space
      //
      if ( LengthInBytes < MaxBytes ) {
        ZeroMem ( &((UINT8 *)pOptionValue)[LengthInBytes], MaxBytes - LengthInBytes );
      }
      errno = 0;
      Status = EFI_SUCCESS;
    }
  }

  //
  //  Return the operation status
  //
  if ( NULL != pErrno ) {
    *pErrno = errno;
  }
  DBG_EXIT_STATUS ( Status );
  return Status;
}


/** Set the socket options.

  This routine handles the socket level options and passes the
  others to the network specific layer.

  The ::setsockopt routine calls this routine to adjust the socket
  options one at a time by name.

  @param[in]  pSocketProtocol Address of an ::EFI_SOCKET_PROTOCOL structure.
  @param[in]  level           Option protocol level
  @param[in]  OptionName      Name of the option
  @param[in]  pOptionValue    Buffer containing the option value
  @param[in]  OptionLength    Length of the buffer in bytes
  @param[out] pErrno          Address to receive the errno value upon completion.

  @retval EFI_SUCCESS - Option successfully set
**/
EFI_STATUS
EslSocketOptionSet (
  IN EFI_SOCKET_PROTOCOL * pSocketProtocol,
  IN int level,
  IN int OptionName,
  IN CONST void * pOptionValue,
  IN socklen_t OptionLength,
  IN int * pErrno
  )
{
  BOOLEAN bTrueFalse;
  int errno;
  socklen_t LengthInBytes;
  UINT8 * pOptionData;
  ESL_SOCKET * pSocket;
  EFI_STATUS Status;

  DBG_ENTER ( );

  //
  //  Assume failure
  //
  errno = EINVAL;
  Status = EFI_INVALID_PARAMETER;

  //
  //  Validate the socket
  //
  pSocket = NULL;
  if ( NULL == pSocketProtocol ) {
    DEBUG (( DEBUG_OPTION, "ERROR - pSocketProtocol is NULL!\r\n" ));
  }
  else if ( NULL == pOptionValue ) {
    DEBUG (( DEBUG_OPTION, "ERROR - No option buffer specified\r\n" ));
  }
  else
  {
    pSocket = SOCKET_FROM_PROTOCOL ( pSocketProtocol );
    if ( pSocket->bRxDisable || pSocket->bTxDisable ) {
      DEBUG (( DEBUG_OPTION, "ERROR - Socket has been shutdown!\r\n" ));
    }
    else {
      LengthInBytes = 0;
      pOptionData = NULL;
      switch ( level ) {
      default:
        //
        //  See if the protocol will handle the option
        //
        if ( NULL != pSocket->pApi->pfnOptionSet ) {
          if ( pSocket->pApi->DefaultProtocol == level ) {
            Status = pSocket->pApi->pfnOptionSet ( pSocket,
                                                   OptionName,
                                                   pOptionValue,
                                                   OptionLength );
            errno = pSocket->errno;
            break;
          }
          else {
            //
            //  Protocol not supported
            //
            DEBUG (( DEBUG_OPTION,
                      "ERROR - The socket does not support this protocol!\r\n" ));
          }
        }
        else {
          //
          //  Protocol level not supported
          //
          DEBUG (( DEBUG_OPTION,
                    "ERROR - %a does not support any options!\r\n",
                    pSocket->pApi->pName ));
        }
        errno = ENOPROTOOPT;
        Status = EFI_INVALID_PARAMETER;
        break;

      case SOL_SOCKET:
        switch ( OptionName ) {
        default:
          //
          //  Option not supported
          //
          DEBUG (( DEBUG_OPTION,
                    "ERROR - Sockets does not support this option!\r\n" ));
          errno = EINVAL;
          Status = EFI_INVALID_PARAMETER;
          break;

        case SO_DEBUG:
          //
          //  Set the debug flags
          //
          pOptionData = (UINT8 *)&pSocket->bOobInLine;
          LengthInBytes = sizeof ( pSocket->bOobInLine );
          break;

        case SO_OOBINLINE:
          pOptionData = (UINT8 *)&pSocket->bOobInLine;
          LengthInBytes = sizeof ( pSocket->bOobInLine );

          //
          //  Validate the option length
          //
          if ( sizeof ( UINT32 ) == OptionLength ) {
            //
            //  Restrict the input to TRUE or FALSE
            //
            bTrueFalse = TRUE;
            if ( 0 == *(UINT32 *)pOptionValue ) {
              bTrueFalse = FALSE;
            }
            pOptionValue = &bTrueFalse;
          }
          else {
            //
            //  Force an invalid option length error
            //
            OptionLength = LengthInBytes - 1;
          }
          break;

        case SO_RCVTIMEO:
          //
          //  Return the receive timeout
          //
          pOptionData = (UINT8 *)&pSocket->RxTimeout;
          LengthInBytes = sizeof ( pSocket->RxTimeout );
          break;

        case SO_RCVBUF:
          //
          //  Return the maximum receive buffer size
          //
          pOptionData = (UINT8 *)&pSocket->MaxRxBuf;
          LengthInBytes = sizeof ( pSocket->MaxRxBuf );
          break;

        case SO_REUSEADDR:
          //
          //  Return the address reuse flag
          //
          pOptionData = (UINT8 *)&pSocket->bReUseAddr;
          LengthInBytes = sizeof ( pSocket->bReUseAddr );
          break;

        case SO_SNDBUF:
          //
          //  Send buffer size
          //
          //
          //  Return the maximum transmit buffer size
          //
          pOptionData = (UINT8 *)&pSocket->MaxTxBuf;
          LengthInBytes = sizeof ( pSocket->MaxTxBuf );
          break;
        }
        break;
      }

      //
      //  Determine if an option was found
      //
      if ( 0 != LengthInBytes ) {
        //
        //  Validate the option length
        //
        if ( LengthInBytes <= OptionLength ) {
          //
          //  Set the option value
          //
          CopyMem ( pOptionData, pOptionValue, LengthInBytes );
          errno = 0;
          Status = EFI_SUCCESS;
        }
        else {
          DEBUG (( DEBUG_OPTION,
                    "ERROR - Buffer to small, %d bytes < %d bytes!\r\n",
                    OptionLength,
                    LengthInBytes ));
        }
      }
    }
  }

  //
  //  Return the operation status
  //
  if ( NULL != pErrno ) {
    *pErrno = errno;
  }
  DBG_EXIT_STATUS ( Status );
  return Status;
}


/**  Allocate a packet for a receive or transmit operation.

  This support routine is called by ::EslSocketRxStart and the
  network specific TxBuffer routines to get buffer space for the
  next operation.

  @param[in]  ppPacket      Address to receive the ::ESL_PACKET structure
  @param[in]  LengthInBytes Length of the packet structure
  @param[in]  ZeroBytes     Length of packet to zero
  @param[in]  DebugFlags    Flags for debug messages

  @retval EFI_SUCCESS - The packet was allocated successfully
**/
EFI_STATUS
EslSocketPacketAllocate (
  IN ESL_PACKET ** ppPacket,
  IN size_t LengthInBytes,
  IN size_t ZeroBytes,
  IN UINTN DebugFlags
  )
{
  ESL_PACKET * pPacket;
  EFI_STATUS Status;

  DBG_ENTER ( );

  //
  //  Allocate a packet structure
  //
  LengthInBytes += sizeof ( *pPacket )
                - sizeof ( pPacket->Op );
  Status = gBS->AllocatePool ( EfiRuntimeServicesData,
                               LengthInBytes,
                               (VOID **)&pPacket );
  if ( !EFI_ERROR ( Status )) {
    DEBUG (( DebugFlags | DEBUG_POOL,
              "0x%08x: Allocate pPacket, %d bytes\r\n",
              pPacket,
              LengthInBytes ));
    if ( 0 != ZeroBytes ) {
      ZeroMem ( &pPacket->Op, ZeroBytes );
    }
    pPacket->PacketSize = LengthInBytes;
  }
  else {
    DEBUG (( DebugFlags | DEBUG_POOL | DEBUG_INFO,
              "ERROR - Packet allocation failed for %d bytes, Status: %r\r\n",
              LengthInBytes,
              Status ));
    pPacket = NULL;
  }

  //
  //  Return the packet
  //
  *ppPacket = pPacket;

  //
  //  Return the operation status
  //
  DBG_EXIT_STATUS ( Status );
  return Status;
}


/** Free a packet used for receive or transmit operation.

  This support routine is called by the network specific Close
  and TxComplete routines and during error cases in RxComplete
  and TxBuffer.  Note that the network layers typically place
  receive packets on the ESL_SOCKET::pRxFree list for reuse.

  @param[in]  pPacket     Address of an ::ESL_PACKET structure
  @param[in]  DebugFlags  Flags for debug messages

  @retval EFI_SUCCESS - The packet was allocated successfully
**/
EFI_STATUS
EslSocketPacketFree (
  IN ESL_PACKET * pPacket,
  IN UINTN DebugFlags
  )
{
  UINTN LengthInBytes;
  EFI_STATUS Status;

  DBG_ENTER ( );

  //
  //  Free a packet structure
  //
  LengthInBytes = pPacket->PacketSize;
  Status = gBS->FreePool ( pPacket );
  if ( !EFI_ERROR ( Status )) {
    DEBUG (( DebugFlags | DEBUG_POOL,
              "0x%08x: Free pPacket, %d bytes\r\n",
              pPacket,
              LengthInBytes ));
  }
  else {
    DEBUG (( DebugFlags | DEBUG_POOL | DEBUG_INFO,
              "ERROR - Failed to free packet 0x%08x, Status: %r\r\n",
              pPacket,
              Status ));
  }

  //
  //  Return the operation status
  //
  DBG_EXIT_STATUS ( Status );
  return Status;
}


/** Poll a socket for pending activity.

  This routine builds a detected event mask which is returned to
  the caller in the buffer provided.

  The ::poll routine calls this routine to determine if the socket
  needs to be serviced as a result of connection, error, receive or
  transmit activity.

  @param[in]  pSocketProtocol Address of an ::EFI_SOCKET_PROTOCOL structure.
  @param[in]  Events          Events of interest for this socket
  @param[in]  pEvents         Address to receive the detected events
  @param[out] pErrno          Address to receive the errno value upon completion.

  @retval EFI_SUCCESS - Socket successfully polled
  @retval EFI_INVALID_PARAMETER - When pEvents is NULL
**/
EFI_STATUS
EslSocketPoll (
  IN EFI_SOCKET_PROTOCOL * pSocketProtocol,
  IN short Events,
  IN short * pEvents,
  IN int * pErrno
  )
{
  short DetectedEvents;
  ESL_SOCKET * pSocket;
  EFI_STATUS Status;
  EFI_TPL TplPrevious;
  short ValidEvents;
  int   _errno = EINVAL;

  DEBUG (( DEBUG_POLL, "Entering SocketPoll\r\n" ));

  //
  //  Assume success
  //
  Status = EFI_SUCCESS;
  DetectedEvents = 0;
  pSocket = SOCKET_FROM_PROTOCOL ( pSocketProtocol );
  pSocket->errno = 0;

  //
  //  Verify the socket state
  //
  Status = EslSocketIsConfigured ( pSocket );
  if ( !EFI_ERROR ( Status )) {
    //
    //  Check for invalid events
    //
    ValidEvents = POLLIN
                | POLLPRI
                | POLLOUT | POLLWRNORM
                | POLLERR
                | POLLHUP
                | POLLNVAL
                | POLLRDNORM
                | POLLRDBAND
                | POLLWRBAND ;
    if ( 0 != ( Events & ( ~ValidEvents ))) {
      DetectedEvents |= POLLNVAL;
      DEBUG (( DEBUG_INFO | DEBUG_POLL,
                "ERROR - Invalid event mask, Valid Events: 0x%04x, Invalid Events: 0x%04x\r\n",
                Events & ValidEvents,
                Events & ( ~ValidEvents )));
    }
    else {
      //
      //  Synchronize with the socket layer
      //
      RAISE_TPL ( TplPrevious, TPL_SOCKETS );

      //
      //  Increase the network performance by extending the
      //  polling (idle) loop down into the LAN driver
      //
      EslSocketRxPoll ( pSocket );

      //
      //  Release the socket layer synchronization
      //
      RESTORE_TPL ( TplPrevious );

      //
      //  Check for pending connections
      //
      if ( 0 != pSocket->FifoDepth ) {
        //
        //  A connection is waiting for an accept call
        //  See posix connect documentation at
        //  http://pubs.opengroup.org/onlinepubs/9699919799/functions/accept.htm
        //
        DetectedEvents |= POLLIN | POLLRDNORM;
      }
      if ( pSocket->bConnected ) {
        //
        //  A connection is present
        //  See posix connect documentation at
        //  http://pubs.opengroup.org/onlinepubs/9699919799/functions/listen.htm
        //
        DetectedEvents |= POLLOUT | POLLWRNORM;
      }

      //
      //  The following bits are set based upon the POSIX poll documentation at
      //  http://pubs.opengroup.org/onlinepubs/9699919799/functions/poll.html
      //

      //
      //  Check for urgent receive data
      //
      if ( 0 < pSocket->RxOobBytes ) {
        DetectedEvents |= POLLRDBAND | POLLPRI | POLLIN;
      }

      //
      //  Check for normal receive data
      //
      if (( 0 < pSocket->RxBytes )
        || ( EFI_SUCCESS != pSocket->RxError )) {
        DetectedEvents |= POLLRDNORM | POLLIN;
      }

      //
      //  Handle the receive errors
      //
      if (( EFI_SUCCESS != pSocket->RxError )
        && ( 0 == ( DetectedEvents & POLLIN ))) {
        DetectedEvents |= POLLERR | POLLIN | POLLRDNORM | POLLRDBAND;
      }

      //
      //  Check for urgent transmit data buffer space
      //
      if (( MAX_TX_DATA > pSocket->TxOobBytes )
        || ( EFI_SUCCESS != pSocket->TxError )) {
        DetectedEvents |= POLLWRBAND;
      }

      //
      //  Check for normal transmit data buffer space
      //
      if (( MAX_TX_DATA > pSocket->TxBytes )
        || ( EFI_SUCCESS != pSocket->TxError )) {
        DetectedEvents |= POLLWRNORM;
      }

      //
      //  Handle the transmit error
      //
      if ( EFI_ERROR ( pSocket->TxError )) {
        DetectedEvents |= POLLERR;
      }
      _errno = pSocket->errno;
    }
  }

  //
  //  Return the detected events
  //
  *pEvents = DetectedEvents & ( Events
                              | POLLERR
                              | POLLHUP
                              | POLLNVAL );
  if ( NULL != pErrno ) {
    *pErrno = _errno;
  }
  //
  //  Return the operation status
  //
  DEBUG (( DEBUG_POLL, "Exiting SocketPoll, Status: %r\r\n", Status ));
  return Status;
}


/** Allocate and initialize a ESL_PORT structure.

  This routine initializes an ::ESL_PORT structure for use by
  the socket.  This routine calls a routine via
  ESL_PROTOCOL_API::pfnPortAllocate to initialize the network
  specific resources.  The resources are released later by the
  \ref PortCloseStateMachine.

  This support routine is called by:
  <ul>
    <li>::EslSocketBind</li>
    <li>::EslTcp4ListenComplete</li>
  </ul>
  to connect the socket with the underlying network adapter
  to the socket.

  @param[in]  pSocket     Address of an ::ESL_SOCKET structure.
  @param[in]  pService    Address of an ::ESL_SERVICE structure.
  @param[in]  ChildHandle Network protocol child handle
  @param[in]  pSockAddr   Address of a sockaddr structure that contains the
                          connection point on the local machine.  An IPv4 address
                          of INADDR_ANY specifies that the connection is made to
                          all of the network stacks on the platform.  Specifying a
                          specific IPv4 address restricts the connection to the
                          network stack supporting that address.  Specifying zero
                          for the port causes the network layer to assign a port
                          number from the dynamic range.  Specifying a specific
                          port number causes the network layer to use that port.
  @param[in]  bBindTest   TRUE if EslSocketBindTest should be called
  @param[in]  DebugFlags  Flags for debug messages
  @param[out] ppPort      Buffer to receive new ::ESL_PORT structure address

  @retval EFI_SUCCESS - Socket successfully created
**/
EFI_STATUS
EslSocketPortAllocate (
  IN ESL_SOCKET * pSocket,
  IN ESL_SERVICE * pService,
  IN EFI_HANDLE ChildHandle,
  IN CONST struct sockaddr * pSockAddr,
  IN BOOLEAN bBindTest,
  IN UINTN DebugFlags,
  OUT ESL_PORT ** ppPort
  )
{
  UINTN LengthInBytes;
  UINT8 * pBuffer;
  ESL_IO_MGMT * pIo;
  ESL_LAYER * pLayer;
  ESL_PORT * pPort;
  EFI_SERVICE_BINDING_PROTOCOL * pServiceBinding;
  CONST ESL_SOCKET_BINDING * pSocketBinding;
  EFI_STATUS Status;
  EFI_STATUS TempStatus;

  DBG_ENTER ( );

  //
  //  Verify the socket layer synchronization
  //
  VERIFY_TPL ( TPL_SOCKETS );

  //
  //  Use for/break instead of goto
  pSocketBinding = pService->pSocketBinding;
  for ( ; ; ) {
    //
    //  Allocate a port structure
    //
    pLayer = &mEslLayer;
    LengthInBytes = sizeof ( *pPort )
                  + ESL_STRUCTURE_ALIGNMENT_BYTES
                  + (( pSocketBinding->RxIo
                       + pSocketBinding->TxIoNormal
                       + pSocketBinding->TxIoUrgent )
                     * sizeof ( ESL_IO_MGMT ));
    pPort = (ESL_PORT *) AllocateZeroPool ( LengthInBytes );
    if ( NULL == pPort ) {
      Status = EFI_OUT_OF_RESOURCES;
      pSocket->errno = ENOMEM;
      break;
    }
    DEBUG (( DebugFlags | DEBUG_POOL | DEBUG_INIT,
              "0x%08x: Allocate pPort, %d bytes\r\n",
              pPort,
              LengthInBytes ));

    //
    //  Initialize the port
    //
    pPort->DebugFlags = DebugFlags;
    pPort->Handle = ChildHandle;
    pPort->pService = pService;
    pPort->pServiceBinding = pService->pServiceBinding;
    pPort->pSocket = pSocket;
    pPort->pSocketBinding = pService->pSocketBinding;
    pPort->Signature = PORT_SIGNATURE;

    //
    //  Open the port protocol
    //
    Status = gBS->OpenProtocol ( pPort->Handle,
                                 pSocketBinding->pNetworkProtocolGuid,
                                 &pPort->pProtocol.v,
                                 pLayer->ImageHandle,
                                 NULL,
                                 EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL );
    if ( EFI_ERROR ( Status )) {
      DEBUG (( DEBUG_ERROR | DebugFlags,
                "ERROR - Failed to open network protocol GUID on controller 0x%08x\r\n",
                pPort->Handle ));
      pSocket->errno = EEXIST;
      break;
    }
    DEBUG (( DebugFlags,
              "0x%08x: Network protocol GUID opened on controller 0x%08x\r\n",
              pPort->pProtocol.v,
              pPort->Handle ));

    //
    //  Initialize the port specific resources
    //
    Status = pSocket->pApi->pfnPortAllocate ( pPort,
                                              DebugFlags );
    if ( EFI_ERROR ( Status )) {
      break;
    }

    //
    //  Set the local address
    //
    Status = pSocket->pApi->pfnLocalAddrSet ( pPort, pSockAddr, bBindTest );
    if ( EFI_ERROR ( Status )) {
      break;
    }

    //
    //  Test the address/port configuration
    //
    if ( bBindTest ) {
      Status = EslSocketBindTest ( pPort, pSocket->pApi->BindTestErrno );
      if ( EFI_ERROR ( Status )) {
        break;
      }
    }

    //
    //  Initialize the receive structures
    //
    pBuffer = (UINT8 *)&pPort[ 1 ];
    pBuffer = &pBuffer[ ESL_STRUCTURE_ALIGNMENT_BYTES ];
    pBuffer = (UINT8 *)( ESL_STRUCTURE_ALIGNMENT_MASK & (UINTN)pBuffer );
    pIo = (ESL_IO_MGMT *)pBuffer;
    if (( 0 != pSocketBinding->RxIo )
      && ( NULL != pSocket->pApi->pfnRxComplete )) {
      Status = EslSocketIoInit ( pPort,
                                 &pIo,
                                 pSocketBinding->RxIo,
                                 &pPort->pRxFree,
                                 DebugFlags | DEBUG_POOL,
                                 "receive",
                                 pSocket->pApi->pfnRxComplete );
      if ( EFI_ERROR ( Status )) {
        break;
      }
    }

    //
    //  Initialize the urgent transmit structures
    //
    if (( 0 != pSocketBinding->TxIoUrgent )
      && ( NULL != pSocket->pApi->pfnTxOobComplete )) {
      Status = EslSocketIoInit ( pPort,
                                 &pIo,
                                 pSocketBinding->TxIoUrgent,
                                 &pPort->pTxOobFree,
                                 DebugFlags | DEBUG_POOL,
                                 "urgent transmit",
                                 pSocket->pApi->pfnTxOobComplete );
      if ( EFI_ERROR ( Status )) {
        break;
      }
    }

    //
    //  Initialize the normal transmit structures
    //
    if (( 0 != pSocketBinding->TxIoNormal )
      && ( NULL != pSocket->pApi->pfnTxComplete )) {
      Status = EslSocketIoInit ( pPort,
                                 &pIo,
                                 pSocketBinding->TxIoNormal,
                                 &pPort->pTxFree,
                                 DebugFlags | DEBUG_POOL,
                                 "normal transmit",
                                 pSocket->pApi->pfnTxComplete );
      if ( EFI_ERROR ( Status )) {
        break;
      }
    }

    //
    //  Add this port to the socket
    //
    pPort->pLinkSocket = pSocket->pPortList;
    pSocket->pPortList = pPort;
    DEBUG (( DebugFlags,
              "0x%08x: Socket adding port: 0x%08x\r\n",
              pSocket,
              pPort ));

    //
    //  Add this port to the service
    //
    pPort->pLinkService = pService->pPortList;
    pService->pPortList = pPort;

    //
    //  Return the port
    //
    *ppPort = pPort;
    break;
  }

  //
  //  Clean up after the error if necessary
  //
  if ( EFI_ERROR ( Status )) {
    if ( NULL != pPort ) {
      //
      //  Close the port
      //
      EslSocketPortClose ( pPort );
    }
    else {
      //
      //  Close the port if necessary
      //
      pServiceBinding = pService->pServiceBinding;
      TempStatus = pServiceBinding->DestroyChild ( pServiceBinding,
                                                   ChildHandle );
      if ( !EFI_ERROR ( TempStatus )) {
        DEBUG (( DEBUG_BIND | DEBUG_POOL,
                  "0x%08x: %s port handle destroyed\r\n",
                  ChildHandle,
                  pSocketBinding->pName ));
      }
      else {
        DEBUG (( DEBUG_ERROR | DEBUG_BIND | DEBUG_POOL,
                  "ERROR - Failed to destroy the %s port handle 0x%08x, Status: %r\r\n",
                  pSocketBinding->pName,
                  ChildHandle,
                  TempStatus ));
        ASSERT ( EFI_SUCCESS == TempStatus );
      }
    }
  }
  //
  //  Return the operation status
  //
  DBG_EXIT_STATUS ( Status );
  return Status;
}


/** Close a port.

  This routine releases the resources allocated by ::EslSocketPortAllocate.
  This routine calls ESL_PROTOCOL_API::pfnPortClose to release the network
  specific resources.

  This routine is called by:
  <ul>
    <li>::EslSocketPortAllocate - Port initialization failure</li>
    <li>::EslSocketPortCloseRxDone - Last step of close processing</li>
    <li>::EslTcp4ConnectComplete - Connection failure and reducing the port list to a single port</li>
  </ul>
  See the \ref PortCloseStateMachine section.

  @param[in]  pPort       Address of an ::ESL_PORT structure.

  @retval EFI_SUCCESS     The port is closed
  @retval other           Port close error
**/
EFI_STATUS
EslSocketPortClose (
  IN ESL_PORT * pPort
  )
{
  UINTN DebugFlags;
  ESL_LAYER * pLayer;
  ESL_PACKET * pPacket;
  ESL_PORT * pPreviousPort;
  ESL_SERVICE * pService;
  EFI_SERVICE_BINDING_PROTOCOL * pServiceBinding;
  CONST ESL_SOCKET_BINDING * pSocketBinding;
  ESL_SOCKET * pSocket;
  EFI_STATUS Status;

  DBG_ENTER ( );

  //
  //  Verify the socket layer synchronization
  //
  VERIFY_TPL ( TPL_SOCKETS );

  //
  //  Locate the port in the socket list
  //
  Status = EFI_SUCCESS;
  pLayer = &mEslLayer;
  DebugFlags = pPort->DebugFlags;
  pSocket = pPort->pSocket;
  pPreviousPort = pSocket->pPortList;
  if ( pPreviousPort == pPort ) {
    //
    //  Remove this port from the head of the socket list
    //
    pSocket->pPortList = pPort->pLinkSocket;
  }
  else {
    //
    //  Locate the port in the middle of the socket list
    //
    while (( NULL != pPreviousPort )
      && ( pPreviousPort->pLinkSocket != pPort )) {
      pPreviousPort = pPreviousPort->pLinkSocket;
    }
    if ( NULL != pPreviousPort ) {
      //
      //  Remove the port from the middle of the socket list
      //
      pPreviousPort->pLinkSocket = pPort->pLinkSocket;
    }
  }

  //
  //  Locate the port in the service list
  //  Note that the port may not be in the service list
  //  if the service has been shutdown.
  //
  pService = pPort->pService;
  if ( NULL != pService ) {
    pPreviousPort = pService->pPortList;
    if ( pPreviousPort == pPort ) {
      //
      //  Remove this port from the head of the service list
      //
      pService->pPortList = pPort->pLinkService;
    }
    else {
      //
      //  Locate the port in the middle of the service list
      //
      while (( NULL != pPreviousPort )
        && ( pPreviousPort->pLinkService != pPort )) {
        pPreviousPort = pPreviousPort->pLinkService;
      }
      if ( NULL != pPreviousPort ) {
        //
        //  Remove the port from the middle of the service list
        //
        pPreviousPort->pLinkService = pPort->pLinkService;
      }
    }
  }

  //
  //  Empty the urgent receive queue
  //
  while ( NULL != pSocket->pRxOobPacketListHead ) {
    pPacket = pSocket->pRxOobPacketListHead;
    pSocket->pRxOobPacketListHead = pPacket->pNext;
    pSocket->pApi->pfnPacketFree ( pPacket, &pSocket->RxOobBytes );
    EslSocketPacketFree ( pPacket, DEBUG_RX );
  }
  pSocket->pRxOobPacketListTail = NULL;
  ASSERT ( 0 == pSocket->RxOobBytes );

  //
  //  Empty the receive queue
  //
  while ( NULL != pSocket->pRxPacketListHead ) {
    pPacket = pSocket->pRxPacketListHead;
    pSocket->pRxPacketListHead = pPacket->pNext;
    pSocket->pApi->pfnPacketFree ( pPacket, &pSocket->RxBytes );
    EslSocketPacketFree ( pPacket, DEBUG_RX );
  }
  pSocket->pRxPacketListTail = NULL;
  ASSERT ( 0 == pSocket->RxBytes );

  //
  //  Empty the receive free queue
  //
  while ( NULL != pSocket->pRxFree ) {
    pPacket = pSocket->pRxFree;
    pSocket->pRxFree = pPacket->pNext;
    EslSocketPacketFree ( pPacket, DEBUG_RX );
  }

  //
  //  Release the network specific resources
  //
  if ( NULL != pSocket->pApi->pfnPortClose ) {
    Status = pSocket->pApi->pfnPortClose ( pPort );
  }

  //
  //  Done with the normal transmit events
  //
  Status = EslSocketIoFree ( pPort,
                             &pPort->pTxFree,
                             DebugFlags | DEBUG_POOL,
                             "normal transmit" );

  //
  //  Done with the urgent transmit events
  //
  Status = EslSocketIoFree ( pPort,
                             &pPort->pTxOobFree,
                             DebugFlags | DEBUG_POOL,
                             "urgent transmit" );

  //
  //  Done with the receive events
  //
  Status = EslSocketIoFree ( pPort,
                             &pPort->pRxFree,
                             DebugFlags | DEBUG_POOL,
                             "receive" );

  //
  //  Done with the lower layer network protocol
  //
  pSocketBinding = pPort->pSocketBinding;
  if ( NULL != pPort->pProtocol.v ) {
    Status = gBS->CloseProtocol ( pPort->Handle,
                                  pSocketBinding->pNetworkProtocolGuid,
                                  pLayer->ImageHandle,
                                  NULL );
    if ( !EFI_ERROR ( Status )) {
      DEBUG (( DebugFlags,
                "0x%08x: Network protocol GUID closed on controller 0x%08x\r\n",
                pPort->pProtocol.v,
                pPort->Handle ));
    }
    else {
      DEBUG (( DEBUG_ERROR | DebugFlags,
                "ERROR - Failed to close network protocol GUID on controller 0x%08x, Status: %r\r\n",
                pPort->Handle,
                Status ));
      ASSERT ( EFI_SUCCESS == Status );
    }
  }

  //
  //  Done with the network port
  //
  pServiceBinding = pPort->pServiceBinding;
  if ( NULL != pPort->Handle ) {
    Status = pServiceBinding->DestroyChild ( pServiceBinding,
                                             pPort->Handle );
    if ( !EFI_ERROR ( Status )) {
      DEBUG (( DebugFlags | DEBUG_POOL,
                "0x%08x: %s port handle destroyed\r\n",
                pPort->Handle,
                pSocketBinding->pName ));
    }
    else {
      DEBUG (( DEBUG_ERROR | DebugFlags | DEBUG_POOL,
                "ERROR - Failed to destroy the %s port handle, Status: %r\r\n",
                pSocketBinding->pName,
                Status ));
      ASSERT ( EFI_SUCCESS == Status );
    }
  }

  //
  //  Release the port structure
  //
  Status = gBS->FreePool ( pPort );
  if ( !EFI_ERROR ( Status )) {
    DEBUG (( DebugFlags | DEBUG_POOL,
              "0x%08x: Free pPort, %d bytes\r\n",
              pPort,
              sizeof ( *pPort )));
  }
  else {
    DEBUG (( DEBUG_ERROR | DebugFlags | DEBUG_POOL,
              "ERROR - Failed to free pPort: 0x%08x, Status: %r\r\n",
              pPort,
              Status ));
    ASSERT ( EFI_SUCCESS == Status );
  }

  //
  //  Mark the socket as closed if necessary
  //
  if ( NULL == pSocket->pPortList ) {
    pSocket->State = SOCKET_STATE_CLOSED;
    DEBUG (( DEBUG_CLOSE | DEBUG_INFO,
              "0x%08x: Socket State: SOCKET_STATE_CLOSED\r\n",
              pSocket ));
  }

  //
  //  Return the operation status
  //
  DBG_EXIT_STATUS ( Status );
  return Status;
}


/** Port close state 3.

  This routine attempts to complete the port close operation.

  This routine is called by the TCP layer upon completion of
  the close operation and by ::EslSocketPortCloseTxDone.
  See the \ref PortCloseStateMachine section.

  @param[in]  Event     The close completion event
  @param[in]  pPort     Address of an ::ESL_PORT structure.
**/
VOID
EslSocketPortCloseComplete (
  IN EFI_EVENT Event,
  IN ESL_PORT * pPort
  )
{
  ESL_IO_MGMT * pIo;
  EFI_STATUS Status;

  DBG_ENTER ( );
  VERIFY_AT_TPL ( TPL_SOCKETS );

  //  Update the port state
  pPort->State = PORT_STATE_CLOSE_DONE;
  DEBUG (( DEBUG_CLOSE | DEBUG_INFO,
            "0x%08x: Port Close State: PORT_STATE_CLOSE_DONE\r\n",
            pPort ));

  //  Shutdown the receive operation on the port
  if ( NULL != pPort->pfnRxCancel ) {
    pIo = pPort->pRxActive;
    while ( NULL != pIo ) {
      EslSocketRxCancel ( pPort, pIo );
      pIo = pIo->pNext;
    }
  }

  //  Determine if the receive operation is pending
  Status = EslSocketPortCloseRxDone ( pPort );
  DBG_EXIT_STATUS ( Status );
  --Status;
}


/** Port close state 4.

  This routine determines the state of the receive operations and
  continues the close operation after the pending receive operations
  are cancelled.

  This routine is called by
  <ul>
    <li>::EslSocketPortCloseComplete</li>
    <li>::EslSocketPortCloseTxDone</li>
    <li>::EslSocketRxComplete</li>
  </ul>
  to determine the state of the receive operations.
  See the \ref PortCloseStateMachine section.

  @param[in]  pPort       Address of an ::ESL_PORT structure.

  @retval EFI_SUCCESS         The port is closed
  @retval EFI_NOT_READY       The port is still closing
  @retval EFI_ALREADY_STARTED Error, the port is in the wrong state,
                              most likely the routine was called already.
**/
EFI_STATUS
EslSocketPortCloseRxDone (
  IN ESL_PORT * pPort
  )
{
  EFI_STATUS Status;

  DBG_ENTER ( );

  //
  //  Verify the socket layer synchronization
  //
  VERIFY_TPL ( TPL_SOCKETS );

  //
  //  Verify that the port is closing
  //
  Status = EFI_ALREADY_STARTED;
  if ( PORT_STATE_CLOSE_DONE == pPort->State ) {
    //
    //  Determine if the receive operation is pending
    //
    Status = EFI_NOT_READY;
    if ( NULL == pPort->pRxActive ) {
      //
      //  The receive operation is complete
      //  Update the port state
      //
      pPort->State = PORT_STATE_CLOSE_RX_DONE;
      DEBUG (( DEBUG_CLOSE | DEBUG_INFO,
                "0x%08x: Port Close State: PORT_STATE_CLOSE_RX_DONE\r\n",
                pPort ));

      //
      //  Complete the port close operation
      //
      Status = EslSocketPortClose ( pPort );
    }
    else {
      DEBUG_CODE_BEGIN ();
      {
        ESL_IO_MGMT * pIo;
        //
        //  Display the outstanding receive operations
        //
        DEBUG (( DEBUG_CLOSE | DEBUG_INFO,
                  "0x%08x: Port Close: Receive still pending!\r\n",
                  pPort ));
        pIo = pPort->pRxActive;
        while ( NULL != pIo ) {
          DEBUG (( DEBUG_CLOSE | DEBUG_INFO,
                    "0x%08x: Packet pending on network adapter\r\n",
                    pIo->pPacket ));
          pIo = pIo->pNext;
        }
      }
      DEBUG_CODE_END ( );
    }
  }

  //
  //  Return the operation status
  //
  DBG_EXIT_STATUS ( Status );
  return Status;
}


/** Start the close operation on a port, state 1.

  This routine marks the port as closed and initiates the \ref
  PortCloseStateMachine. The first step is to allow the \ref
  TransmitEngine to run down.

  This routine is called by ::EslSocketCloseStart to initiate the socket
  network specific close operation on the socket.

  @param[in]  pPort       Address of an ::ESL_PORT structure.
  @param[in]  bCloseNow   Set TRUE to abort active transfers
  @param[in]  DebugFlags  Flags for debug messages

  @retval EFI_SUCCESS         The port is closed, not normally returned
  @retval EFI_NOT_READY       The port has started the closing process
  @retval EFI_ALREADY_STARTED Error, the port is in the wrong state,
                              most likely the routine was called already.
**/
EFI_STATUS
EslSocketPortCloseStart (
  IN ESL_PORT * pPort,
  IN BOOLEAN bCloseNow,
  IN UINTN DebugFlags
  )
{
  ESL_SOCKET * pSocket;
  EFI_STATUS Status;

  DBG_ENTER ( );

  //
  //  Verify the socket layer synchronization
  //
  VERIFY_TPL ( TPL_SOCKETS );

  //
  //  Mark the port as closing
  //
  Status = EFI_ALREADY_STARTED;
  pSocket = pPort->pSocket;
  pSocket->errno = EALREADY;
  if ( PORT_STATE_CLOSE_STARTED > pPort->State ) {

    //
    //  Update the port state
    //
    pPort->State = PORT_STATE_CLOSE_STARTED;
    DEBUG (( DEBUG_CLOSE | DEBUG_INFO,
              "0x%08x: Port Close State: PORT_STATE_CLOSE_STARTED\r\n",
              pPort ));
    pPort->bCloseNow = bCloseNow;
    pPort->DebugFlags = DebugFlags;

    //
    //  Determine if transmits are complete
    //
    Status = EslSocketPortCloseTxDone ( pPort );
  }

  //
  //  Return the operation status
  //
  DBG_EXIT_STATUS ( Status );
  return Status;
}


/** Port close state 2.

  This routine determines the state of the transmit engine and
  continue the close operation after the transmission is complete.
  The next step is to stop the \ref ReceiveEngine.
  See the \ref PortCloseStateMachine section.

  This routine is called by ::EslSocketPortCloseStart to determine
  if the transmission is complete.

  @param[in]  pPort           Address of an ::ESL_PORT structure.

  @retval EFI_SUCCESS         The port is closed, not normally returned
  @retval EFI_NOT_READY       The port is still closing
  @retval EFI_ALREADY_STARTED Error, the port is in the wrong state,
                              most likely the routine was called already.

**/
EFI_STATUS
EslSocketPortCloseTxDone (
  IN ESL_PORT * pPort
  )
{
  ESL_IO_MGMT * pIo;
  ESL_SOCKET * pSocket;
  EFI_STATUS Status;

  DBG_ENTER ( );

  //
  //  Verify the socket layer synchronization
  //
  VERIFY_TPL ( TPL_SOCKETS );

  //
  //  All transmissions are complete or must be stopped
  //  Mark the port as TX complete
  //
  Status = EFI_ALREADY_STARTED;
  if ( PORT_STATE_CLOSE_STARTED == pPort->State ) {
    //
    //  Verify that the transmissions are complete
    //
    pSocket = pPort->pSocket;
    if ( pPort->bCloseNow
         || ( EFI_SUCCESS != pSocket->TxError )
         || (( NULL == pPort->pTxActive )
                && ( NULL == pPort->pTxOobActive ))) {
      //
      //  Update the port state
      //
      pPort->State = PORT_STATE_CLOSE_TX_DONE;
      DEBUG (( DEBUG_CLOSE | DEBUG_INFO,
                "0x%08x: Port Close State: PORT_STATE_CLOSE_TX_DONE\r\n",
                pPort ));

      //
      //  Close the port
      //  Skip the close operation if the port is not configured
      //
      Status = EFI_SUCCESS;
      pSocket = pPort->pSocket;
      if (( pPort->bConfigured )
        && ( NULL != pSocket->pApi->pfnPortCloseOp )) {
          //
          //  Start the close operation
          //
          Status = pSocket->pApi->pfnPortCloseOp ( pPort );
          DEBUG (( DEBUG_CLOSE | DEBUG_INFO,
                    "0x%08x: Port Close: Close operation still pending!\r\n",
                    pPort ));
          ASSERT ( EFI_SUCCESS == Status );
      }
      else {
        //
        //  The receive operation is complete
        //  Update the port state
        //
        EslSocketPortCloseComplete ( NULL, pPort );
      }
    }
    else {
      //
      //  Transmissions are still active, exit
      //
      Status = EFI_NOT_READY;
      pSocket->errno = EAGAIN;
      DEBUG_CODE_BEGIN ( );
      {
        ESL_PACKET * pPacket;

        DEBUG (( DEBUG_CLOSE | DEBUG_INFO,
                  "0x%08x: Port Close: Transmits are still pending!\r\n",
                  pPort ));

        //
        //  Display the pending urgent transmit packets
        //
        pPacket = pSocket->pTxOobPacketListHead;
        while ( NULL != pPacket ) {
          DEBUG (( DEBUG_CLOSE | DEBUG_INFO,
                    "0x%08x: Packet pending on urgent TX list, %d bytes\r\n",
                    pPacket,
                    pPacket->PacketSize ));
          pPacket = pPacket->pNext;
        }

        pIo = pPort->pTxOobActive;
        while ( NULL != pIo ) {
          pPacket = pIo->pPacket;
          DEBUG (( DEBUG_CLOSE | DEBUG_INFO,
                    "0x%08x: Packet active %d bytes, pIo: 0x%08x\r\n",
                    pPacket,
                    pPacket->PacketSize,
                    pIo ));
          pIo = pIo->pNext;
        }

        //
        //  Display the pending normal transmit packets
        //
        pPacket = pSocket->pTxPacketListHead;
        while ( NULL != pPacket ) {
          DEBUG (( DEBUG_CLOSE | DEBUG_INFO,
                    "0x%08x: Packet pending on normal TX list, %d bytes\r\n",
                    pPacket,
                    pPacket->PacketSize ));
          pPacket = pPacket->pNext;
        }

        pIo = pPort->pTxActive;
        while ( NULL != pIo ) {
          pPacket = pIo->pPacket;
          DEBUG (( DEBUG_CLOSE | DEBUG_INFO,
                    "0x%08x: Packet active %d bytes, pIo: 0x%08x\r\n",
                    pPacket,
                    pPacket->PacketSize,
                    pIo ));
          pIo = pIo->pNext;
        }
      }
      DEBUG_CODE_END ();
    }
  }

  //
  //  Return the operation status
  //
  DBG_EXIT_STATUS ( Status );
  return Status;
}


/** Receive data from a network connection.

  This routine calls the network specific routine to remove the
  next portion of data from the receive queue and return it to the
  caller.

  The ::recvfrom routine calls this routine to determine if any data
  is received from the remote system.  Note that the other routines
  ::recv and ::read are layered on top of ::recvfrom.

  @param[in]      pSocketProtocol Address of an ::EFI_SOCKET_PROTOCOL structure.
  @param[in]      Flags           Message control flags
  @param[in]      BufferLength    Length of the the buffer
  @param[in]      pBuffer         Address of a buffer to receive the data.
  @param[in]      pDataLength     Number of received data bytes in the buffer.
  @param[out]     pAddress        Network address to receive the remote system address
  @param[in,out]  pAddressLength  Length of the remote network address structure
  @param[out]     pErrno          Address to receive the errno value upon completion.

  @retval EFI_SUCCESS - Socket data successfully received
**/
EFI_STATUS
EslSocketReceive (
  IN EFI_SOCKET_PROTOCOL * pSocketProtocol,
  IN INT32 Flags,
  IN size_t BufferLength,
  IN UINT8 * pBuffer,
  OUT size_t * pDataLength,
  OUT struct sockaddr * pAddress,
  IN OUT socklen_t * pAddressLength,
  IN int * pErrno
  )
{
  union {
    struct sockaddr_in v4;
    struct sockaddr_in6 v6;
  } Addr;
  socklen_t AddressLength;
  BOOLEAN bConsumePacket;
  BOOLEAN bUrgentQueue;
  size_t DataLength;
  ESL_PACKET * pNextPacket;
  ESL_PACKET * pPacket;
  ESL_PORT * pPort;
  ESL_PACKET ** ppQueueHead;
  ESL_PACKET ** ppQueueTail;
  struct sockaddr * pRemoteAddress;
  size_t * pRxDataBytes;
  ESL_SOCKET * pSocket;
  size_t SkipBytes;
  EFI_STATUS Status;
  EFI_TPL TplPrevious;

  DBG_ENTER ( );

  //
  //  Assume success
  //
  Status = EFI_SUCCESS;

  //
  //  Validate the socket
  //
  pSocket = NULL;
  if ( NULL != pSocketProtocol ) {
    pSocket = SOCKET_FROM_PROTOCOL ( pSocketProtocol );

    //
    //  Validate the return address parameters
    //
    if (( NULL == pAddress ) || ( NULL != pAddressLength )) {
      //
      //  Return the transmit error if necessary
      //
      if ( EFI_SUCCESS != pSocket->TxError ) {
        pSocket->errno = EIO;
        Status = pSocket->TxError;
        pSocket->TxError = EFI_SUCCESS;
      }
      else {
        //
        //  Verify the socket state
        //
        Status = EslSocketIsConfigured ( pSocket );
        if ( !EFI_ERROR ( Status )) {
          //
          //  Validate the buffer length
          //
          if (( NULL == pDataLength )
            || ( NULL == pBuffer )) {
            if ( NULL == pDataLength ) {
              DEBUG (( DEBUG_RX,
                        "ERROR - pDataLength is NULL!\r\n" ));
            }
            else {
              DEBUG (( DEBUG_RX,
                        "ERROR - pBuffer is NULL!\r\n" ));
            }
            Status = EFI_INVALID_PARAMETER;
            pSocket->errno = EFAULT;
          }
          else {
            //
            //  Verify the API
            //
            if ( NULL == pSocket->pApi->pfnReceive ) {
              Status = EFI_UNSUPPORTED;
              pSocket->errno = ENOTSUP;
            }
            else {
              //
              //  Zero the receive address if being returned
              //
              pRemoteAddress = NULL;
              if ( NULL != pAddress ) {
                pRemoteAddress = (struct sockaddr *)&Addr;
                ZeroMem ( pRemoteAddress, sizeof ( Addr ));
                pRemoteAddress->sa_family = pSocket->pApi->AddressFamily;
                pRemoteAddress->sa_len = (UINT8)pSocket->pApi->AddressLength;
              }

              //
              //  Synchronize with the socket layer
              //
              RAISE_TPL ( TplPrevious, TPL_SOCKETS );

              //
              //  Assume failure
              //
              Status = EFI_UNSUPPORTED;
              pSocket->errno = ENOTCONN;

              //
              //  Verify that the socket is connected
              //
              if ( SOCKET_STATE_CONNECTED == pSocket->State ) {
                //
                //  Poll the network to increase performance
                //
                EslSocketRxPoll ( pSocket );

                //
                //  Locate the port
                //
                pPort = pSocket->pPortList;
                if ( NULL != pPort ) {
                  //
                  //  Determine the queue head
                  //
                  bUrgentQueue = (BOOLEAN)( 0 != ( Flags & MSG_OOB ));
                  if ( bUrgentQueue ) {
                    ppQueueHead = &pSocket->pRxOobPacketListHead;
                    ppQueueTail = &pSocket->pRxOobPacketListTail;
                    pRxDataBytes = &pSocket->RxOobBytes;
                  }
                  else {
                    ppQueueHead = &pSocket->pRxPacketListHead;
                    ppQueueTail = &pSocket->pRxPacketListTail;
                    pRxDataBytes = &pSocket->RxBytes;
                  }

                  //
                  //  Determine if there is any data on the queue
                  //
                  *pDataLength = 0;
                  pPacket = *ppQueueHead;
                  if ( NULL != pPacket ) {
                    //
                    //  Copy the received data
                    //
                    do {
                      //
                      //  Attempt to receive a packet
                      //
                      SkipBytes = 0;
                      bConsumePacket = (BOOLEAN)( 0 == ( Flags & MSG_PEEK ));
                      pBuffer = pSocket->pApi->pfnReceive ( pPort,
                                                            pPacket,
                                                            &bConsumePacket,
                                                            BufferLength,
                                                            pBuffer,
                                                            &DataLength,
                                                            (struct sockaddr *)&Addr,
                                                            &SkipBytes );
                      *pDataLength += DataLength;
                      BufferLength -= DataLength;

                      //
                      //  Determine if the data is being read
                      //
                      pNextPacket = pPacket->pNext;
                      if ( bConsumePacket ) {
                        //
                        //  All done with this packet
                        //  Account for any discarded data
                        //
                        pSocket->pApi->pfnPacketFree ( pPacket, pRxDataBytes );
                        if ( 0 != SkipBytes ) {
                          DEBUG (( DEBUG_RX,
                                    "0x%08x: Port, packet read, skipping over 0x%08x bytes\r\n",
                                    pPort,
                                    SkipBytes ));
                        }

                        //
                        //  Remove this packet from the queue
                        //
                        *ppQueueHead = pPacket->pNext;
                        if ( NULL == *ppQueueHead ) {
                          *ppQueueTail = NULL;
                        }

                        //
                        //  Move the packet to the free queue
                        //
                        pPacket->pNext = pSocket->pRxFree;
                        pSocket->pRxFree = pPacket;
                        DEBUG (( DEBUG_RX,
                                  "0x%08x: Port freeing packet 0x%08x\r\n",
                                  pPort,
                                  pPacket ));

                        //
                        //  Restart the receive operation if necessary
                        //
                        if (( NULL != pPort->pRxFree )
                          && ( MAX_RX_DATA > pSocket->RxBytes )) {
                            EslSocketRxStart ( pPort );
                        }
                      }

                      //
                      //  Get the next packet
                      //
                      pPacket = pNextPacket;
                    } while (( SOCK_STREAM == pSocket->Type )
                          && ( NULL != pPacket )
                          && ( 0 < BufferLength ));

                    //
                    //  Successful operation
                    //
                    Status = EFI_SUCCESS;
                    pSocket->errno = 0;
                  }
                  else {
                    //
                    //  The queue is empty
                    //  Determine if it is time to return the receive error
                    //
                    if ( EFI_ERROR ( pSocket->RxError )
                      && ( NULL == pSocket->pRxPacketListHead )
                      && ( NULL == pSocket->pRxOobPacketListHead )) {
                      Status = pSocket->RxError;
                      pSocket->RxError = EFI_SUCCESS;
                      switch ( Status ) {
                      default:
                        pSocket->errno = EIO;
                        break;

                      case EFI_CONNECTION_FIN:
                        //
                        //  Continue to return zero bytes received when the
                        //  peer has successfully closed the connection
                        //
                        pSocket->RxError = EFI_CONNECTION_FIN;
                        *pDataLength = 0;
                        pSocket->errno = 0;
                        Status = EFI_SUCCESS;
                        break;

                      case EFI_CONNECTION_REFUSED:
                        pSocket->errno = ECONNREFUSED;
                        break;

                      case EFI_CONNECTION_RESET:
                        pSocket->errno = ECONNRESET;
                        break;

                      case EFI_HOST_UNREACHABLE:
                        pSocket->errno = EHOSTUNREACH;
                        break;

                      case EFI_NETWORK_UNREACHABLE:
                        pSocket->errno = ENETUNREACH;
                        break;

                      case EFI_PORT_UNREACHABLE:
                        pSocket->errno = EPROTONOSUPPORT;
                        break;

                      case EFI_PROTOCOL_UNREACHABLE:
                        pSocket->errno = ENOPROTOOPT;
                        break;
                      }
                    }
                    else {
                      Status = EFI_NOT_READY;
                      pSocket->errno = EAGAIN;
                    }
                  }
                }
              }

              //
              //  Release the socket layer synchronization
              //
              RESTORE_TPL ( TplPrevious );

              if (( !EFI_ERROR ( Status )) && ( NULL != pAddress )) {
                //
                //  Return the remote address if requested, truncate if necessary
                //
                AddressLength = pRemoteAddress->sa_len;
                if ( AddressLength > *pAddressLength ) {
                  AddressLength = *pAddressLength;
                }
                DEBUG (( DEBUG_RX,
                          "Returning the remote address, 0x%016x bytes --> 0x%16x\r\n", *pAddressLength, pAddress ));
                ZeroMem ( pAddress, *pAddressLength );
                CopyMem ( pAddress, &Addr, AddressLength );

                //
                //  Update the address length
                //
                *pAddressLength = pRemoteAddress->sa_len;
              }
            }
          }
        }
      }


    }
    else {
      //
      //  Bad return address pointer and length
      //
      Status = EFI_INVALID_PARAMETER;
      pSocket->errno = EINVAL;
    }
  }

  //
  //  Return the operation status
  //
  if ( NULL != pErrno ) {
    if ( NULL != pSocket ) {
      *pErrno = pSocket->errno;
    }
    else {
      Status = EFI_INVALID_PARAMETER;
      *pErrno = ENOTSOCK;
    }
  }
  DBG_EXIT_STATUS ( Status );
  return Status;
}


/** Cancel the receive operations.

  This routine cancels a pending receive operation.
  See the \ref ReceiveEngine section.

  This routine is called by ::EslSocketShutdown when the socket
  layer is being shutdown.

  @param[in]  pPort     Address of an ::ESL_PORT structure
  @param[in]  pIo       Address of an ::ESL_IO_MGMT structure
**/
VOID
EslSocketRxCancel (
  IN ESL_PORT * pPort,
  IN ESL_IO_MGMT * pIo
  )
{
  EFI_STATUS Status;

  DBG_ENTER ( );

  //
  //  Cancel the outstanding receive
  //
  Status = pPort->pfnRxCancel ( pPort->pProtocol.v,
                                &pIo->Token );
  if ( !EFI_ERROR ( Status )) {
    DEBUG (( pPort->DebugFlags | DEBUG_CLOSE | DEBUG_INFO,
              "0x%08x: Packet receive aborted on port: 0x%08x\r\n",
              pIo->pPacket,
              pPort ));
  }
  else {
    DEBUG (( pPort->DebugFlags | DEBUG_CLOSE | DEBUG_INFO,
              "0x%08x: Packet receive pending on Port 0x%08x, Status: %r\r\n",
              pIo->pPacket,
              pPort,
              Status ));
  }
  DBG_EXIT ( );
}


/** Process the receive completion.

  This routine queues the data in FIFO order in either the urgent
  or normal data queues depending upon the type of data received.
  See the \ref ReceiveEngine section.

  This routine is called when some data is received by:
  <ul>
    <li>::EslIp4RxComplete</li>
    <li>::EslTcp4RxComplete</li>
    <li>::EslUdp4RxComplete</li>
  </ul>

  @param[in]  pIo           Address of an ::ESL_IO_MGMT structure
  @param[in]  Status        Receive status
  @param[in]  LengthInBytes Length of the receive data
  @param[in]  bUrgent       TRUE if urgent data is received and FALSE
                            for normal data.
**/
VOID
EslSocketRxComplete (
  IN ESL_IO_MGMT * pIo,
  IN EFI_STATUS Status,
  IN UINTN LengthInBytes,
  IN BOOLEAN bUrgent
  )
{
  BOOLEAN bUrgentQueue;
  ESL_IO_MGMT * pIoNext;
  ESL_PACKET * pPacket;
  ESL_PORT * pPort;
  ESL_PACKET * pPrevious;
  ESL_PACKET ** ppQueueHead;
  ESL_PACKET ** ppQueueTail;
  size_t * pRxBytes;
  ESL_SOCKET * pSocket;

  DBG_ENTER ( );
  VERIFY_AT_TPL ( TPL_SOCKETS );

  //
  //  Locate the active receive packet
  //
  pPacket = pIo->pPacket;
  pPort = pIo->pPort;
  pSocket = pPort->pSocket;

  //
  //         pPort->pRxActive
  //                |
  //                V
  //          +-------------+   +-------------+   +-------------+
  //  Active  | ESL_IO_MGMT |-->| ESL_IO_MGMT |-->| ESL_IO_MGMT |--> NULL
  //          +-------------+   +-------------+   +-------------+
  //
  //          +-------------+   +-------------+   +-------------+
  //  Free    | ESL_IO_MGMT |-->| ESL_IO_MGMT |-->| ESL_IO_MGMT |--> NULL
  //          +-------------+   +-------------+   +-------------+
  //                ^
  //                |
  //          pPort->pRxFree
  //
  //
  //  Remove the IO structure from the active list
  //  The following code searches for the entry in the list and does not
  //  assume that the receive operations complete in the order they were
  //  issued to the UEFI network layer.
  //
  pIoNext = pPort->pRxActive;
  while (( NULL != pIoNext ) && ( pIoNext != pIo ) && ( pIoNext->pNext != pIo ))
  {
    pIoNext = pIoNext->pNext;
  }
  ASSERT ( NULL != pIoNext );
  if ( pIoNext == pIo ) {
    pPort->pRxActive = pIo->pNext;  //  Beginning of list
  }
  else {
    pIoNext->pNext = pIo->pNext;    //  Middle of list
  }

  //
  //  Free the IO structure
  //
  pIo->pNext = pPort->pRxFree;
  pPort->pRxFree = pIo;

  //
  //            pRxOobPacketListHead              pRxOobPacketListTail
  //                      |                                 |
  //                      V                                 V
  //               +------------+   +------------+   +------------+
  //  Urgent Data  | ESL_PACKET |-->| ESL_PACKET |-->| ESL_PACKET |--> NULL
  //               +------------+   +------------+   +------------+
  //
  //               +------------+   +------------+   +------------+
  //  Normal Data  | ESL_PACKET |-->| ESL_PACKET |-->| ESL_PACKET |--> NULL
  //               +------------+   +------------+   +------------+
  //                      ^                                 ^
  //                      |                                 |
  //              pRxPacketListHead                pRxPacketListTail
  //
  //
  //  Determine the queue to use
  //
  bUrgentQueue = (BOOLEAN)( bUrgent
               && pSocket->pApi->bOobSupported
               && ( !pSocket->bOobInLine ));
  if ( bUrgentQueue ) {
    ppQueueHead = &pSocket->pRxOobPacketListHead;
    ppQueueTail = &pSocket->pRxOobPacketListTail;
    pRxBytes = &pSocket->RxOobBytes;
  }
  else {
    ppQueueHead = &pSocket->pRxPacketListHead;
    ppQueueTail = &pSocket->pRxPacketListTail;
    pRxBytes = &pSocket->RxBytes;
  }

  //
  //  Determine if this receive was successful
  //
  if (( !EFI_ERROR ( Status ))
    && ( PORT_STATE_CLOSE_STARTED > pPort->State )
    && ( !pSocket->bRxDisable )) {
    //
    //  Account for the received data
    //
    *pRxBytes += LengthInBytes;

    //
    //  Log the received data
    //
    DEBUG (( DEBUG_RX | DEBUG_INFO,
              "0x%08x: Packet queued on %s queue of port 0x%08x with 0x%08x bytes of %s data\r\n",
              pPacket,
              bUrgentQueue ? L"urgent" : L"normal",
              pPort,
              LengthInBytes,
              bUrgent ? L"urgent" : L"normal" ));

    //
    //  Add the packet to the list tail.
    //
    pPacket->pNext = NULL;
    pPrevious = *ppQueueTail;
    if ( NULL == pPrevious ) {
      *ppQueueHead = pPacket;
    }
    else {
      pPrevious->pNext = pPacket;
    }
    *ppQueueTail = pPacket;

    //
    //  Attempt to restart this receive operation
    //
    if ( pSocket->MaxRxBuf > pSocket->RxBytes ) {
      EslSocketRxStart ( pPort );
    }
    else {
      DEBUG (( DEBUG_RX,
                "0x%08x: Port RX suspended, 0x%08x bytes queued\r\n",
                pPort,
                pSocket->RxBytes ));
    }
  }
  else {
    if ( EFI_ERROR ( Status )) {
        DEBUG (( DEBUG_RX | DEBUG_INFO,
                  "ERROR - Receive error on port 0x%08x, packet 0x%08x, Status:%r\r\n",
                  pPort,
                  pPacket,
                  Status ));
    }

    //
    //  Account for the receive bytes and release the driver's buffer
    //
    if ( !EFI_ERROR ( Status )) {
      *pRxBytes += LengthInBytes;
      pSocket->pApi->pfnPacketFree ( pPacket, pRxBytes );
    }

    //
    //  Receive error, free the packet save the error
    //
    EslSocketPacketFree ( pPacket, DEBUG_RX );
    if ( !EFI_ERROR ( pSocket->RxError )) {
      pSocket->RxError = Status;
    }

    //
    //  Update the port state
    //
    if ( PORT_STATE_CLOSE_STARTED <= pPort->State ) {
      if ( PORT_STATE_CLOSE_DONE == pPort->State ) {
        EslSocketPortCloseRxDone ( pPort );
      }
    }
    else {
      if ( EFI_ERROR ( Status )) {
        DEBUG (( DEBUG_RX | DEBUG_INFO,
                  "0x%08x: Port state: PORT_STATE_RX_ERROR, Status: %r\r\n",
                  pPort,
                  Status ));
        pPort->State = PORT_STATE_RX_ERROR;
      }
    }
  }

  DBG_EXIT ( );
}


/** Poll a socket for pending receive activity.

  This routine is called at elivated TPL and extends the idle
  loop which polls a socket down into the LAN driver layer to
  determine if there is any receive activity.

  The ::EslSocketPoll, ::EslSocketReceive and ::EslSocketTransmit
  routines call this routine when there is nothing to do.

  @param[in]  pSocket   Address of an ::EFI_SOCKET structure.
 **/
VOID
EslSocketRxPoll (
  IN ESL_SOCKET * pSocket
  )
{
  ESL_PORT * pPort;

  DEBUG (( DEBUG_POLL, "Entering EslSocketRxPoll\r\n" ));

  //
  //  Increase the network performance by extending the
  //  polling (idle) loop down into the LAN driver
  //
  pPort = pSocket->pPortList;
  while ( NULL != pPort ) {
    //
    //  Poll the LAN adapter
    //
    pPort->pfnRxPoll ( pPort->pProtocol.v );

    //
    //  Locate the next LAN adapter
    //
    pPort = pPort->pLinkSocket;
  }

  DEBUG (( DEBUG_POLL, "Exiting EslSocketRxPoll\r\n" ));
}


/** Start a receive operation.

  This routine posts a receive buffer to the network adapter.
  See the \ref ReceiveEngine section.

  This support routine is called by:
  <ul>
    <li>::EslIp4Receive to restart the receive engine to release flow control.</li>
    <li>::EslIp4RxComplete to continue the operation of the receive engine if flow control is not being applied.</li>
    <li>::EslIp4SocketIsConfigured to start the receive engine for the new socket.</li>
    <li>::EslTcp4ListenComplete to start the recevie engine for the new socket.</li>
    <li>::EslTcp4Receive to restart the receive engine to release flow control.</li>
    <li>::EslTcp4RxComplete to continue the operation of the receive engine if flow control is not being applied.</li>
    <li>::EslUdp4Receive to restart the receive engine to release flow control.</li>
    <li>::EslUdp4RxComplete to continue the operation of the receive engine if flow control is not being applied.</li>
    <li>::EslUdp4SocketIsConfigured to start the recevie engine for the new socket.</li>
  </ul>

  @param[in]  pPort       Address of an ::ESL_PORT structure.
**/
VOID
EslSocketRxStart (
  IN ESL_PORT * pPort
  )
{
  UINT8 * pBuffer;
  ESL_IO_MGMT * pIo;
  ESL_PACKET * pPacket;
  ESL_SOCKET * pSocket;
  EFI_STATUS Status;

  DBG_ENTER ( );

  //
  //  Determine if a receive is already pending
  //
  Status = EFI_SUCCESS;
  pPacket = NULL;
  pSocket = pPort->pSocket;
  if ( !EFI_ERROR ( pPort->pSocket->RxError )) {
    if (( NULL != pPort->pRxFree )
      && ( !pSocket->bRxDisable )
      && ( PORT_STATE_CLOSE_STARTED > pPort->State )) {
      //
      //  Start all of the pending receive operations
      //
      while ( NULL != pPort->pRxFree ) {
        //
        //  Determine if there are any free packets
        //
        pPacket = pSocket->pRxFree;
        if ( NULL != pPacket ) {
          //
          //  Remove this packet from the free list
          //
          pSocket->pRxFree = pPacket->pNext;
          DEBUG (( DEBUG_RX,
                    "0x%08x: Port removed packet 0x%08x from free list\r\n",
                    pPort,
                    pPacket ));
        }
        else {
          //
          //  Allocate a packet structure
          //
          Status = EslSocketPacketAllocate ( &pPacket,
                                             pSocket->pApi->RxPacketBytes,
                                             pSocket->pApi->RxZeroBytes,
                                             DEBUG_RX );
          if ( EFI_ERROR ( Status )) {
            pPacket = NULL;
            DEBUG (( DEBUG_ERROR | DEBUG_RX,
                      "0x%08x: Port failed to allocate RX packet, Status: %r\r\n",
                      pPort,
                      Status ));
            break;
          }
        }

        //
        //  Connect the IO and packet structures
        //
        pIo = pPort->pRxFree;
        pIo->pPacket = pPacket;

        //
        //  Eliminate the need for IP4 and UDP4 specific routines by
        //  clearing the RX data pointer here.
        //
        //  No driver buffer for this packet
        //
        //    +--------------------+
        //    | ESL_IO_MGMT        |
        //    |                    |
        //    |    +---------------+
        //    |    | Token         |
        //    |    |        RxData --> NULL
        //    +----+---------------+
        //
        pBuffer = (UINT8 *)pIo;
        pBuffer = &pBuffer[ pSocket->pApi->RxBufferOffset ];
        *(VOID **)pBuffer = NULL;

        //
        //  Network specific receive packet initialization
        //
        if ( NULL != pSocket->pApi->pfnRxStart ) {
          pSocket->pApi->pfnRxStart ( pPort, pIo );
        }

        //
        //  Start the receive on the packet
        //
        Status = pPort->pfnRxStart ( pPort->pProtocol.v, &pIo->Token );
        if ( !EFI_ERROR ( Status )) {
          DEBUG (( DEBUG_RX | DEBUG_INFO,
                    "0x%08x: Packet receive pending on port 0x%08x\r\n",
                    pPacket,
                    pPort ));
          //
          //  Allocate the receive control structure
          //
          pPort->pRxFree = pIo->pNext;

          //
          //  Mark this receive as pending
          //
          pIo->pNext = pPort->pRxActive;
          pPort->pRxActive = pIo;

        }
        else {
          DEBUG (( DEBUG_RX | DEBUG_INFO,
                    "ERROR - Failed to post a receive on port 0x%08x, Status: %r\r\n",
                    pPort,
                    Status ));
          if ( !EFI_ERROR ( pSocket->RxError )) {
            //
            //  Save the error status
            //
            pSocket->RxError = Status;
          }

          //
          //  Free the packet
          //
          pIo->pPacket = NULL;
          pPacket->pNext = pSocket->pRxFree;
          pSocket->pRxFree = pPacket;
          break;
        }
      }
    }
    else {
      if ( NULL == pPort->pRxFree ) {
        DEBUG (( DEBUG_RX | DEBUG_INFO,
                  "0x%08x: Port, no available ESL_IO_MGMT structures\r\n",
                  pPort));
      }
      if ( pSocket->bRxDisable ) {
        DEBUG (( DEBUG_RX | DEBUG_INFO,
                  "0x%08x: Port, receive disabled!\r\n",
                  pPort ));
      }
      if ( PORT_STATE_CLOSE_STARTED <= pPort->State ) {
        DEBUG (( DEBUG_RX | DEBUG_INFO,
                  "0x%08x: Port, is closing!\r\n",
                  pPort ));
      }
    }
  }
  else {
    DEBUG (( DEBUG_ERROR | DEBUG_RX,
              "ERROR - Previous receive error, Status: %r\r\n",
               pPort->pSocket->RxError ));
  }

  DBG_EXIT ( );
}


/** Shutdown the socket receive and transmit operations.

  This routine sets a flag to stop future transmissions and calls
  the network specific layer to cancel the pending receive operation.

  The ::shutdown routine calls this routine to stop receive and transmit
  operations on the socket.

  @param[in]  pSocketProtocol Address of an ::EFI_SOCKET_PROTOCOL structure.
  @param[in]  How             Which operations to stop
  @param[out] pErrno          Address to receive the errno value upon completion.

  @retval EFI_SUCCESS - Socket operations successfully shutdown
**/
EFI_STATUS
EslSocketShutdown (
  IN EFI_SOCKET_PROTOCOL * pSocketProtocol,
  IN int How,
  IN int * pErrno
  )
{
  ESL_IO_MGMT * pIo;
  ESL_PORT * pPort;
  ESL_SOCKET * pSocket;
  EFI_STATUS Status;
  EFI_TPL TplPrevious;

  DBG_ENTER ( );

  //
  //  Assume success
  //
  Status = EFI_SUCCESS;

  //
  //  Validate the socket
  //
  pSocket = NULL;
  if ( NULL != pSocketProtocol ) {
    pSocket = SOCKET_FROM_PROTOCOL ( pSocketProtocol );

    //
    //  Verify that the socket is connected
    //
    if ( pSocket->bConnected ) {
      //
      //  Validate the How value
      //
      if (( SHUT_RD <= How ) && ( SHUT_RDWR >= How )) {
        //
        //  Synchronize with the socket layer
        //
        RAISE_TPL ( TplPrevious, TPL_SOCKETS );

        //
        //  Disable the receiver if requested
        //
        if (( SHUT_RD == How ) || ( SHUT_RDWR == How )) {
          pSocket->bRxDisable = TRUE;
        }

        //
        //  Disable the transmitter if requested
        //
        if (( SHUT_WR == How ) || ( SHUT_RDWR == How )) {
          pSocket->bTxDisable = TRUE;
        }

        //
        //  Cancel the pending receive operations
        //
        if ( pSocket->bRxDisable ) {
          //
          //  Walk the list of ports
          //
          pPort = pSocket->pPortList;
          while ( NULL != pPort ) {
            //
            //  Walk the list of active receive operations
            //
            pIo = pPort->pRxActive;
            while ( NULL != pIo ) {
              EslSocketRxCancel ( pPort, pIo );
            }

            //
            //  Set the next port
            //
            pPort = pPort->pLinkSocket;
          }
        }

        //
        //  Release the socket layer synchronization
        //
        RESTORE_TPL ( TplPrevious );
      }
      else {
        //
        //  Invalid How value
        //
        pSocket->errno = EINVAL;
        Status = EFI_INVALID_PARAMETER;
      }
    }
    else {
      //
      //  The socket is not connected
      //
      pSocket->errno = ENOTCONN;
      Status = EFI_NOT_STARTED;
    }
  }

  //
  //  Return the operation status
  //
  if ( NULL != pErrno ) {
    if ( NULL != pSocket ) {
      *pErrno = pSocket->errno;
    }
    else {
      Status = EFI_INVALID_PARAMETER;
      *pErrno = ENOTSOCK;
    }
  }
  DBG_EXIT_STATUS ( Status );
  return Status;
}


/** Send data using a network connection.

  This routine calls the network specific layer to queue the data
  for transmission.  Eventually the buffer will reach the head of
  the queue and will get transmitted over the network by the
  \ref TransmitEngine.  For datagram
  sockets (SOCK_DGRAM and SOCK_RAW) there is no guarantee that
  the data reaches the application running on the remote system.

  The ::sendto routine calls this routine to send data to the remote
  system.  Note that ::send and ::write are layered on top of ::sendto.

  @param[in]  pSocketProtocol Address of an ::EFI_SOCKET_PROTOCOL structure.
  @param[in]  Flags           Message control flags
  @param[in]  BufferLength    Length of the the buffer
  @param[in]  pBuffer         Address of a buffer containing the data to send
  @param[in]  pDataLength     Address to receive the number of data bytes sent
  @param[in]  pAddress        Network address of the remote system address
  @param[in]  AddressLength   Length of the remote network address structure
  @param[out] pErrno          Address to receive the errno value upon completion.

  @retval EFI_SUCCESS - Socket data successfully queued for transmit
**/
EFI_STATUS
EslSocketTransmit (
  IN EFI_SOCKET_PROTOCOL * pSocketProtocol,
  IN int Flags,
  IN size_t BufferLength,
  IN CONST UINT8 * pBuffer,
  OUT size_t * pDataLength,
  IN const struct sockaddr * pAddress,
  IN socklen_t AddressLength,
  IN int * pErrno
  )
{
  ESL_SOCKET * pSocket;
  EFI_STATUS Status;
  EFI_TPL TplPrevious;

  DBG_ENTER ( );

  //
  //  Assume success
  //
  Status = EFI_SUCCESS;

  //
  //  Validate the socket
  //
  pSocket = NULL;
  if ( NULL != pSocketProtocol ) {
    pSocket = SOCKET_FROM_PROTOCOL ( pSocketProtocol );

    //
    //  Return the transmit error if necessary
    //
    if ( EFI_SUCCESS != pSocket->TxError ) {
      pSocket->errno = EIO;
      Status = pSocket->TxError;
      pSocket->TxError = EFI_SUCCESS;
    }
    else {
      //
      //  Verify the socket state
      //
      Status = EslSocketIsConfigured ( pSocket );
      if ( !EFI_ERROR ( Status )) {
        //
        //  Verify that transmit is still allowed
        //
        if ( !pSocket->bTxDisable ) {
          //
          //  Validate the buffer length
          //
          if (( NULL == pDataLength )
            && ( 0 > pDataLength )
            && ( NULL == pBuffer )) {
            if ( NULL == pDataLength ) {
              DEBUG (( DEBUG_RX,
                        "ERROR - pDataLength is NULL!\r\n" ));
            }
            else if ( NULL == pBuffer ) {
              DEBUG (( DEBUG_RX,
                        "ERROR - pBuffer is NULL!\r\n" ));
            }
            else {
              DEBUG (( DEBUG_RX,
                        "ERROR - Data length < 0!\r\n" ));
            }
            Status = EFI_INVALID_PARAMETER;
            pSocket->errno = EFAULT;
          }
          else {
            //
            //  Validate the remote network address
            //
            if (( NULL != pAddress )
              && ( AddressLength < pAddress->sa_len )) {
              DEBUG (( DEBUG_TX,
                        "ERROR - Invalid sin_len field in address\r\n" ));
              Status = EFI_INVALID_PARAMETER;
              pSocket->errno = EFAULT;
            }
            else {
              //
              //  Verify the API
              //
              if ( NULL == pSocket->pApi->pfnTransmit ) {
                Status = EFI_UNSUPPORTED;
                pSocket->errno = ENOTSUP;
              }
              else {
                //
                //  Synchronize with the socket layer
                //
                RAISE_TPL ( TplPrevious, TPL_SOCKETS );

                //
                //  Poll the network to increase performance
                //
                EslSocketRxPoll ( pSocket );

                //
                //  Attempt to buffer the packet for transmission
                //
                Status = pSocket->pApi->pfnTransmit ( pSocket,
                                                      Flags,
                                                      BufferLength,
                                                      pBuffer,
                                                      pDataLength,
                                                      pAddress,
                                                      AddressLength );

                //
                //  Release the socket layer synchronization
                //
                RESTORE_TPL ( TplPrevious );
              }
            }
          }
        }
        else {
          //
          //  The transmitter was shutdown
          //
          pSocket->errno = EPIPE;
          Status = EFI_NOT_STARTED;
        }
      }
    }
  }

  //
  //  Return the operation status
  //
  if ( NULL != pErrno ) {
    if ( NULL != pSocket ) {
      *pErrno = pSocket->errno;
    }
    else {
      Status = EFI_INVALID_PARAMETER;
      *pErrno = ENOTSOCK;
    }
  }
  DBG_EXIT_STATUS ( Status );
  return Status;
}


/** Complete the transmit operation.

  This support routine handles the transmit completion processing for
  the various network layers.  It frees the ::ESL_IO_MGMT structure
  and and frees packet resources by calling ::EslSocketPacketFree.
  Transmit errors are logged in ESL_SOCKET::TxError.
  See the \ref TransmitEngine section.

  This routine is called by:
  <ul>
    <li>::EslIp4TxComplete</li>
    <li>::EslTcp4TxComplete</li>
    <li>::EslTcp4TxOobComplete</li>
    <li>::EslUdp4TxComplete</li>
  </ul>

  @param[in]  pIo             Address of an ::ESL_IO_MGMT structure
  @param[in]  LengthInBytes   Length of the data in bytes
  @param[in]  Status          Transmit operation status
  @param[in]  pQueueType      Zero terminated string describing queue type
  @param[in]  ppQueueHead     Transmit queue head address
  @param[in]  ppQueueTail     Transmit queue tail address
  @param[in]  ppActive        Active transmit queue address
  @param[in]  ppFree          Free transmit queue address
**/
VOID
EslSocketTxComplete (
  IN ESL_IO_MGMT * pIo,
  IN UINT32 LengthInBytes,
  IN EFI_STATUS Status,
  IN CONST CHAR8 * pQueueType,
  IN ESL_PACKET ** ppQueueHead,
  IN ESL_PACKET ** ppQueueTail,
  IN ESL_IO_MGMT ** ppActive,
  IN ESL_IO_MGMT ** ppFree
  )
{
  ESL_PACKET * pCurrentPacket;
  ESL_IO_MGMT * pIoNext;
  ESL_PACKET * pNextPacket;
  ESL_PACKET * pPacket;
  ESL_PORT * pPort;
  ESL_SOCKET * pSocket;

  DBG_ENTER ( );
  VERIFY_AT_TPL ( TPL_SOCKETS );

  //
  //  Locate the active transmit packet
  //
  pPacket = pIo->pPacket;
  pPort = pIo->pPort;
  pSocket = pPort->pSocket;

  //
  //  No more packet
  //
  pIo->pPacket = NULL;

  //
  //  Remove the IO structure from the active list
  //
  pIoNext = *ppActive;
  while (( NULL != pIoNext ) && ( pIoNext != pIo ) && ( pIoNext->pNext != pIo ))
  {
    pIoNext = pIoNext->pNext;
  }
  ASSERT ( NULL != pIoNext );
  if ( pIoNext == pIo ) {
    *ppActive = pIo->pNext;       //  Beginning of list
  }
  else {
    pIoNext->pNext = pIo->pNext;  //  Middle of list
  }

  //
  //  Free the IO structure
  //
  pIo->pNext = *ppFree;
  *ppFree = pIo;

  //
  //  Display the results
  //
  DEBUG (( DEBUG_TX | DEBUG_INFO,
            "0x%08x: pIo Released\r\n",
            pIo ));

  //
  //  Save any transmit error
  //
  if ( EFI_ERROR ( Status )) {
    if ( !EFI_ERROR ( pSocket->TxError )) {
      pSocket->TxError = Status;
    }
    DEBUG (( DEBUG_TX | DEBUG_INFO,
              "ERROR - Transmit failure for %apacket 0x%08x, Status: %r\r\n",
              pQueueType,
              pPacket,
              Status ));

    //
    //  Empty the normal transmit list
    //
    pCurrentPacket = pPacket;
    pNextPacket = *ppQueueHead;
    while ( NULL != pNextPacket ) {
      pPacket = pNextPacket;
      pNextPacket = pPacket->pNext;
      EslSocketPacketFree ( pPacket, DEBUG_TX );
    }
    *ppQueueHead = NULL;
    *ppQueueTail = NULL;
    pPacket = pCurrentPacket;
  }
  else {
    DEBUG (( DEBUG_TX | DEBUG_INFO,
              "0x%08x: %apacket transmitted %d bytes successfully\r\n",
              pPacket,
              pQueueType,
              LengthInBytes ));

    //
    //  Verify the transmit engine is still running
    //
    if ( !pPort->bCloseNow ) {
      //
      //  Start the next packet transmission
      //
      EslSocketTxStart ( pPort,
                         ppQueueHead,
                         ppQueueTail,
                         ppActive,
                         ppFree );
    }
  }

  //
  //  Release this packet
  //
  EslSocketPacketFree ( pPacket, DEBUG_TX );

  //
  //  Finish the close operation if necessary
  //
  if ( PORT_STATE_CLOSE_STARTED <= pPort->State ) {
    //
    //  Indicate that the transmit is complete
    //
    EslSocketPortCloseTxDone ( pPort );
  }

  DBG_EXIT ( );
}


/** Transmit data using a network connection.

  This support routine starts a transmit operation on the
  underlying network layer.

  The network specific code calls this routine to start a
  transmit operation.  See the \ref TransmitEngine section.

  @param[in]  pPort           Address of an ::ESL_PORT structure
  @param[in]  ppQueueHead     Transmit queue head address
  @param[in]  ppQueueTail     Transmit queue tail address
  @param[in]  ppActive        Active transmit queue address
  @param[in]  ppFree          Free transmit queue address
**/
VOID
EslSocketTxStart (
  IN ESL_PORT * pPort,
  IN ESL_PACKET ** ppQueueHead,
  IN ESL_PACKET ** ppQueueTail,
  IN ESL_IO_MGMT ** ppActive,
  IN ESL_IO_MGMT ** ppFree
  )
{
  UINT8 * pBuffer;
  ESL_IO_MGMT * pIo;
  ESL_PACKET * pNextPacket;
  ESL_PACKET * pPacket;
  VOID ** ppTokenData;
  ESL_SOCKET * pSocket;
  EFI_STATUS Status;

  DBG_ENTER ( );

  //
  //  Assume success
  //
  Status = EFI_SUCCESS;

  //
  //  Get the packet from the queue head
  //
  pPacket = *ppQueueHead;
  pIo = *ppFree;
  if (( NULL != pPacket ) && ( NULL != pIo )) {
    pSocket = pPort->pSocket;
    //
    //     *ppQueueHead: pSocket->pRxPacketListHead or pSocket->pRxOobPacketListHead
    //          |
    //          V
    //        +------------+   +------------+   +------------+
    //  Data  | ESL_PACKET |-->| ESL_PACKET |-->| ESL_PACKET |--> NULL
    //        +------------+   +------------+   +------------+
    //                                                     ^
    //                                                     |
    //     *ppQueueTail: pSocket->pRxPacketListTail or pSocket->pRxOobPacketListTail
    //
    //
    //  Remove the packet from the queue
    //
    pNextPacket = pPacket->pNext;
    *ppQueueHead = pNextPacket;
    if ( NULL == pNextPacket ) {
      *ppQueueTail = NULL;
    }
    pPacket->pNext = NULL;

    //
    //  Eliminate the need for IP4 and UDP4 specific routines by
    //  connecting the token with the TX data control structure here.
    //
    //    +--------------------+   +--------------------+
    //    | ESL_IO_MGMT        |   | ESL_PACKET         |
    //    |                    |   |                    |
    //    |    +---------------+   +----------------+   |
    //    |    | Token         |   | Buffer Length  |   |
    //    |    |        TxData --> | Buffer Address |   |
    //    |    |               |   +----------------+---+
    //    |    |        Event  |   | Data Buffer        |
    //    +----+---------------+   |                    |
    //                             +--------------------+
    //
    //  Compute the address of the TxData pointer in the token
    //
    pBuffer = (UINT8 *)&pIo->Token;
    pBuffer = &pBuffer[ pSocket->TxTokenOffset ];
    ppTokenData = (VOID **)pBuffer;

    //
    //  Compute the address of the TX data control structure in the packet
    //
    //      * EFI_IP4_TRANSMIT_DATA
    //      * EFI_TCP4_TRANSMIT_DATA
    //      * EFI_UDP4_TRANSMIT_DATA
    //
    pBuffer = (UINT8 *)pPacket;
    pBuffer = &pBuffer[ pSocket->TxPacketOffset ];

    //
    //  Connect the token to the transmit data control structure
    //
    *ppTokenData = (VOID **)pBuffer;

    //
    //  Display the results
    //
    DEBUG (( DEBUG_TX | DEBUG_INFO,
              "0x%08x: pIo allocated for pPacket: 0x%08x\r\n",
              pIo,
              pPacket ));

    //
    //  Start the transmit operation
    //
    Status = pPort->pfnTxStart ( pPort->pProtocol.v,
                                 &pIo->Token );
    if ( !EFI_ERROR ( Status )) {
      //
      //  Connect the structures
      //
      pIo->pPacket = pPacket;

      //
      //          +-------------+   +-------------+   +-------------+
      //  Free    | ESL_IO_MGMT |-->| ESL_IO_MGMT |-->| ESL_IO_MGMT |--> NULL
      //          +-------------+   +-------------+   +-------------+
      //              ^
      //              |
      //          *ppFree:  pPort->pTxFree or pTxOobFree
      //
      //
      //  Remove the IO structure from the queue
      //
      *ppFree = pIo->pNext;

      //
      //         *ppActive:  pPort->pTxActive or pTxOobActive
      //             |
      //             V
      //          +-------------+   +-------------+   +-------------+
      //  Active  | ESL_IO_MGMT |-->| ESL_IO_MGMT |-->| ESL_IO_MGMT |--> NULL
      //          +-------------+   +-------------+   +-------------+
      //
      //
      //  Mark this packet as active
      //
      pIo->pPacket = pPacket;
      pIo->pNext = *ppActive;
      *ppActive = pIo;
    }
    else {
      //
      //  Display the transmit error
      //
      DEBUG (( DEBUG_TX | DEBUG_INFO,
                "0x%08x, 0x%08x: pIo, pPacket transmit failure: %r\r\n",
                pIo,
                pPacket,
                Status ));
      if ( EFI_SUCCESS == pSocket->TxError ) {
        pSocket->TxError = Status;
      }

      //
      //  Free the IO structure
      //
      pIo->pNext = *ppFree;
      *ppFree = pIo;

      //
      //  Discard the transmit buffer
      //
      EslSocketPacketFree ( pPacket, DEBUG_TX );
    }
  }

  DBG_EXIT ( );
}