mirror of https://github.com/acidanthera/audk.git
3112 lines
83 KiB
C
3112 lines
83 KiB
C
/** @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) 2011, Intel Corporation
|
|
All rights reserved. This program and the accompanying materials
|
|
are licensed and made available under the terms and conditions of the BSD License
|
|
which accompanies this distribution. The full text of the license may be found at
|
|
http://opensource.org/licenses/bsd-license.php
|
|
|
|
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
|
|
|
**/
|
|
|
|
#include "Socket.h"
|
|
|
|
|
|
/**
|
|
Socket driver connection points
|
|
|
|
List the network stack connection points for the socket driver.
|
|
**/
|
|
CONST DT_SOCKET_BINDING cEslSocketBinding [] = {
|
|
{ L"Tcp4",
|
|
&gEfiTcp4ServiceBindingProtocolGuid,
|
|
&mEslTcp4ServiceGuid,
|
|
EslTcpInitialize4,
|
|
EslTcpShutdown4 },
|
|
{ L"Udp4",
|
|
&gEfiUdp4ServiceBindingProtocolGuid,
|
|
&mEslUdp4ServiceGuid,
|
|
EslUdpInitialize4,
|
|
EslUdpShutdown4 }
|
|
};
|
|
|
|
CONST UINTN cEslSocketBindingEntries = DIM ( cEslSocketBinding );
|
|
|
|
DT_LAYER mEslLayer;
|
|
|
|
|
|
/**
|
|
Initialize an endpoint for network communication.
|
|
|
|
The ::Socket routine initializes the communication endpoint by providing
|
|
the support for the socket library function ::socket. The
|
|
<a href="http://www.linuxhowtos.org/manpages/2/socket.htm">Linux</a>,
|
|
<a href="http://pubs.opengroup.org/onlinepubs/9699919799/functions/socket.html">POSIX</a>
|
|
and <a href="http://msdn.microsoft.com/en-us/library/ms740506(v=VS.85).aspx">Windows</a>
|
|
documentation for the socket routine are available online for reference.
|
|
|
|
@param [in] pSocketProtocol Address of the socket protocol structure.
|
|
@param [in] domain Select the family of protocols for the client or server
|
|
application.
|
|
|
|
@param [in] type Specifies how to make the network connection. The following values
|
|
are supported:
|
|
<ul>
|
|
<li>
|
|
SOCK_STREAM - Connect to TCP, provides a byte stream
|
|
that is manipluated by read, recv, send and write.
|
|
</li>
|
|
<li>
|
|
SOCK_SEQPACKET - Connect to TCP, provides sequenced packet stream
|
|
that is manipulated by read, recv, send and write.
|
|
</li>
|
|
<li>
|
|
SOCK_DGRAM - Connect to UDP, provides a datagram service that is
|
|
manipulated by recvfrom and sendto.
|
|
</li>
|
|
</ul>
|
|
|
|
@param [in] protocol Specifies the lower layer protocol to use. The following
|
|
values are supported:
|
|
<ul>
|
|
<li>IPPROTO_TCP</li> - This value must be combined with SOCK_STREAM.</li>
|
|
<li>IPPROTO_UDP</li> - This value must be combined with SOCK_DGRAM.</li>
|
|
</ul>
|
|
|
|
@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
|
|
)
|
|
{
|
|
DT_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_LOCAL != domain ))
|
|
{
|
|
DEBUG (( DEBUG_ERROR | DEBUG_SOCKET,
|
|
"ERROR - Invalid domain value" ));
|
|
Status = EFI_INVALID_PARAMETER;
|
|
errno = EAFNOSUPPORT;
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Set the default type if necessary
|
|
//
|
|
if ( 0 == type ) {
|
|
type = SOCK_STREAM;
|
|
}
|
|
|
|
//
|
|
// Validate the type value
|
|
//
|
|
if (( SOCK_STREAM == type )
|
|
|| ( SOCK_SEQPACKET == type )) {
|
|
//
|
|
// Set the default protocol if necessary
|
|
//
|
|
if ( 0 == protocol ) {
|
|
protocol = IPPROTO_TCP;
|
|
}
|
|
}
|
|
else if ( SOCK_DGRAM == type ) {
|
|
//
|
|
// Set the default protocol if necessary
|
|
//
|
|
if ( 0 == protocol ) {
|
|
protocol = IPPROTO_UDP;
|
|
}
|
|
}
|
|
else {
|
|
DEBUG (( DEBUG_ERROR | DEBUG_SOCKET,
|
|
"ERROR - Invalid type value" ));
|
|
Status = EFI_INVALID_PARAMETER;
|
|
errno = EINVAL;
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Validate the protocol value
|
|
//
|
|
if (( IPPROTO_TCP != protocol )
|
|
&& ( IPPROTO_UDP != protocol )) {
|
|
DEBUG (( DEBUG_ERROR | DEBUG_SOCKET,
|
|
"ERROR - Invalid protocol value" ));
|
|
Status = EFI_INVALID_PARAMETER;
|
|
errno = EINVAL;
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Save the socket attributes
|
|
//
|
|
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.
|
|
|
|
The SocketAccept routine waits for a network connection to the socket.
|
|
It is able to return the remote network address to the caller if
|
|
requested.
|
|
|
|
@param [in] pSocketProtocol Address of the 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 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
|
|
)
|
|
{
|
|
DT_SOCKET * pNewSocket;
|
|
DT_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 );
|
|
|
|
//
|
|
// 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" ));
|
|
Status = EFI_NOT_STARTED;
|
|
pSocket->errno = EOPNOTSUPP;
|
|
}
|
|
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 {
|
|
|
|
//
|
|
// Get the remote network address
|
|
//
|
|
pNewSocket = pSocket->pFifoHead;
|
|
ASSERT ( NULL != pNewSocket );
|
|
switch ( pSocket->Domain ) {
|
|
default:
|
|
DEBUG (( DEBUG_ACCEPT,
|
|
"ERROR - Invalid socket address family: %d\r\n",
|
|
pSocket->Domain ));
|
|
Status = EFI_INVALID_PARAMETER;
|
|
pSocket->errno = EADDRNOTAVAIL;
|
|
break;
|
|
|
|
case AF_INET:
|
|
//
|
|
// Determine the connection point within the network stack
|
|
//
|
|
switch ( pSocket->Type ) {
|
|
default:
|
|
DEBUG (( DEBUG_ACCEPT,
|
|
"ERROR - Invalid socket type: %d\r\n",
|
|
pSocket->Type));
|
|
Status = EFI_INVALID_PARAMETER;
|
|
pSocket->errno = EADDRNOTAVAIL;
|
|
break;
|
|
|
|
case SOCK_STREAM:
|
|
case SOCK_SEQPACKET:
|
|
Status = EslTcpAccept4 ( pNewSocket,
|
|
pSockAddr,
|
|
pSockAddrLength );
|
|
break;
|
|
|
|
/*
|
|
case SOCK_DGRAM:
|
|
Status = UdpAccept4 ( pSocket );
|
|
break;
|
|
*/
|
|
}
|
|
break;
|
|
}
|
|
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 = EBADF;
|
|
}
|
|
}
|
|
DBG_EXIT_STATUS ( Status );
|
|
return Status;
|
|
}
|
|
|
|
|
|
/**
|
|
Allocate and initialize a DT_SOCKET structure.
|
|
|
|
The ::SocketAllocate() function allocates a DT_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 the DT_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 availabe 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 DT_SOCKET ** ppSocket
|
|
)
|
|
{
|
|
UINTN LengthInBytes;
|
|
DT_LAYER * pLayer;
|
|
DT_SOCKET * pSocket;
|
|
EFI_STATUS Status;
|
|
EFI_TPL TplPrevious;
|
|
|
|
DBG_ENTER ( );
|
|
|
|
//
|
|
// Create a socket structure
|
|
//
|
|
LengthInBytes = sizeof ( *pSocket );
|
|
Status = gBS->AllocatePool (
|
|
EfiRuntimeServicesData,
|
|
LengthInBytes,
|
|
(VOID **) &pSocket
|
|
);
|
|
if ( !EFI_ERROR ( Status )) {
|
|
DEBUG (( DebugFlags | DEBUG_POOL | DEBUG_INIT,
|
|
"0x%08x: Allocate pSocket, %d bytes\r\n",
|
|
pSocket,
|
|
LengthInBytes ));
|
|
|
|
//
|
|
// Initialize the socket protocol
|
|
//
|
|
ZeroMem ( pSocket, LengthInBytes );
|
|
|
|
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.pfnSend = EslSocketTransmit;
|
|
pSocket->SocketProtocol.pfnShutdown = EslSocketShutdown;
|
|
pSocket->SocketProtocol.pfnSocket = EslSocket;
|
|
|
|
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 {
|
|
DEBUG (( DEBUG_ERROR | DebugFlags | DEBUG_POOL | DEBUG_INIT,
|
|
"ERROR - Failed socket allocation, Status: %r\r\n",
|
|
Status ));
|
|
}
|
|
|
|
//
|
|
// Return the operation status
|
|
//
|
|
DBG_EXIT_STATUS ( Status );
|
|
return Status;
|
|
}
|
|
|
|
|
|
/**
|
|
Bind a name to a socket.
|
|
|
|
The ::SocketBind routine connects a name to a socket on the local machine. The
|
|
<a href="http://pubs.opengroup.org/onlinepubs/9699919799/functions/bind.html">POSIX</a>
|
|
documentation for the bind routine is available online for reference.
|
|
|
|
@param [in] pSocketProtocol Address of the 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] SockAddrLen 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
|
|
)
|
|
{
|
|
DT_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 );
|
|
|
|
//
|
|
// Validate the structure pointer
|
|
//
|
|
if ( NULL == pSockAddr ) {
|
|
DEBUG (( DEBUG_BIND,
|
|
"ERROR - pSockAddr is NULL!\r\n" ));
|
|
Status = EFI_INVALID_PARAMETER;
|
|
pSocket->errno = EFAULT;
|
|
}
|
|
else{
|
|
//
|
|
// Validate the name length
|
|
//
|
|
if (( SockAddrLength < ( sizeof ( struct sockaddr ) - sizeof ( pSockAddr->sa_data )))
|
|
|| ( pSockAddr->sa_len < ( sizeof ( struct sockaddr ) - sizeof ( pSockAddr->sa_data )))) {
|
|
DEBUG (( DEBUG_BIND,
|
|
"ERROR - Invalid bind name length: %d, sa_len: %d\r\n",
|
|
SockAddrLength,
|
|
pSockAddr->sa_len ));
|
|
Status = EFI_INVALID_PARAMETER;
|
|
pSocket->errno = EINVAL;
|
|
}
|
|
else {
|
|
//
|
|
// Set the socket address length
|
|
//
|
|
if ( SockAddrLength > pSockAddr->sa_len ) {
|
|
SockAddrLength = pSockAddr->sa_len;
|
|
}
|
|
|
|
//
|
|
// Synchronize with the socket layer
|
|
//
|
|
RAISE_TPL ( TplPrevious, TPL_SOCKETS );
|
|
|
|
//
|
|
// Validate the local address
|
|
//
|
|
switch ( pSockAddr->sa_family ) {
|
|
default:
|
|
DEBUG (( DEBUG_BIND,
|
|
"ERROR - Invalid bind address family: %d\r\n",
|
|
pSockAddr->sa_family ));
|
|
Status = EFI_INVALID_PARAMETER;
|
|
pSocket->errno = EADDRNOTAVAIL;
|
|
break;
|
|
|
|
case AF_INET:
|
|
//
|
|
// Determine the connection point within the network stack
|
|
//
|
|
switch ( pSocket->Type ) {
|
|
default:
|
|
DEBUG (( DEBUG_BIND,
|
|
"ERROR - Invalid socket type: %d\r\n",
|
|
pSocket->Type));
|
|
Status = EFI_INVALID_PARAMETER;
|
|
pSocket->errno = EADDRNOTAVAIL;
|
|
break;
|
|
|
|
case SOCK_STREAM:
|
|
case SOCK_SEQPACKET:
|
|
Status = EslTcpBind4 ( pSocket,
|
|
pSockAddr,
|
|
SockAddrLength );
|
|
break;
|
|
|
|
case SOCK_DGRAM:
|
|
Status = EslUdpBind4 ( pSocket,
|
|
pSockAddr,
|
|
SockAddrLength );
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Mark this socket as bound if successful
|
|
//
|
|
if ( !EFI_ERROR ( Status )) {
|
|
pSocket->State = SOCKET_STATE_BOUND;
|
|
}
|
|
|
|
//
|
|
// 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 = EBADF;
|
|
}
|
|
}
|
|
DBG_EXIT_STATUS ( Status );
|
|
return Status;
|
|
}
|
|
|
|
|
|
/**
|
|
Determine if the socket is closed
|
|
|
|
Reverses the operations of the ::SocketAllocate() routine.
|
|
|
|
@param [in] pSocketProtocol Address of the 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;
|
|
DT_LAYER * pLayer;
|
|
DT_SOCKET * pNextSocket;
|
|
DT_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
|
|
|
|
Start closing the socket by closing all of the ports. Upon
|
|
completion, the ::SocketPoll() routine finishes closing the
|
|
socket.
|
|
|
|
@param [in] pSocketProtocol Address of the 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;
|
|
DT_PORT * pNextPort;
|
|
DT_PORT * pPort;
|
|
DT_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 = pPort->pfnCloseStart ( 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_ALREADY_STARTED;
|
|
errno = EALREADY;
|
|
}
|
|
|
|
//
|
|
// 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.
|
|
|
|
The ::SocketConnect routine attempts to establish a connection to a
|
|
socket on the local or remote system using the specified address.
|
|
The POSIX
|
|
<a href="http://pubs.opengroup.org/onlinepubs/9699919799/functions/connect.html">connect</a>
|
|
documentation is available online.
|
|
|
|
There are three states associated with a connection:
|
|
<ul>
|
|
<li>Not connected</li>
|
|
<li>Connection in progress</li>
|
|
<li>Connected</li>
|
|
</ul>
|
|
In the "Not connected" state, calls to ::connect start the connection
|
|
processing and update the state to "Connection in progress". During
|
|
the "Connection in progress" state, connect polls for connection completion
|
|
and moves the state to "Connected" after the connection is established.
|
|
Note that these states are only visible when the file descriptor is marked
|
|
with O_NONBLOCK. Also, the POLL_WRITE bit is set when the connection
|
|
completes and may be used by poll or select as an indicator to call
|
|
connect again.
|
|
|
|
@param [in] pSocketProtocol Address of the 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
|
|
)
|
|
{
|
|
DT_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 )))
|
|
|| ( pSockAddr->sa_len < ( sizeof ( struct sockaddr ) - sizeof ( pSockAddr->sa_data )))) {
|
|
DEBUG (( DEBUG_CONNECT,
|
|
"ERROR - Invalid bind name length: %d, sa_len: %d\r\n",
|
|
SockAddrLength,
|
|
pSockAddr->sa_len ));
|
|
Status = EFI_INVALID_PARAMETER;
|
|
pSocket->errno = EINVAL;
|
|
}
|
|
else {
|
|
//
|
|
// Assume success
|
|
//
|
|
pSocket->errno = 0;
|
|
|
|
//
|
|
// Set the socket address length
|
|
//
|
|
if ( SockAddrLength > pSockAddr->sa_len ) {
|
|
SockAddrLength = pSockAddr->sa_len;
|
|
}
|
|
|
|
//
|
|
// 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 local address
|
|
//
|
|
switch ( pSockAddr->sa_family ) {
|
|
default:
|
|
DEBUG (( DEBUG_CONNECT,
|
|
"ERROR - Invalid bind address family: %d\r\n",
|
|
pSockAddr->sa_family ));
|
|
Status = EFI_INVALID_PARAMETER;
|
|
pSocket->errno = EADDRNOTAVAIL;
|
|
break;
|
|
|
|
case AF_INET:
|
|
//
|
|
// Determine the connection point within the network stack
|
|
//
|
|
switch ( pSocket->Type ) {
|
|
default:
|
|
DEBUG (( DEBUG_CONNECT,
|
|
"ERROR - Invalid socket type: %d\r\n",
|
|
pSocket->Type));
|
|
Status = EFI_INVALID_PARAMETER;
|
|
pSocket->errno = EADDRNOTAVAIL;
|
|
break;
|
|
|
|
case SOCK_STREAM:
|
|
case SOCK_SEQPACKET:
|
|
//
|
|
// Start the connection processing
|
|
//
|
|
Status = EslTcpConnectStart4 ( pSocket,
|
|
pSockAddr,
|
|
SockAddrLength );
|
|
|
|
//
|
|
// Set the next state if connecting
|
|
//
|
|
if ( EFI_NOT_READY == Status ) {
|
|
pSocket->State = SOCKET_STATE_CONNECTING;
|
|
}
|
|
break;
|
|
|
|
case SOCK_DGRAM:
|
|
Status = EslUdpConnect4 ( pSocket,
|
|
pSockAddr,
|
|
SockAddrLength );
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case SOCKET_STATE_CONNECTING:
|
|
//
|
|
// Validate the local address
|
|
//
|
|
switch ( pSockAddr->sa_family ) {
|
|
default:
|
|
DEBUG (( DEBUG_CONNECT,
|
|
"ERROR - Invalid bind address family: %d\r\n",
|
|
pSockAddr->sa_family ));
|
|
Status = EFI_INVALID_PARAMETER;
|
|
pSocket->errno = EADDRNOTAVAIL;
|
|
break;
|
|
|
|
case AF_INET:
|
|
//
|
|
// Determine the connection point within the network stack
|
|
//
|
|
switch ( pSocket->Type ) {
|
|
default:
|
|
DEBUG (( DEBUG_CONNECT,
|
|
"ERROR - Invalid socket type: %d\r\n",
|
|
pSocket->Type));
|
|
Status = EFI_INVALID_PARAMETER;
|
|
pSocket->errno = EADDRNOTAVAIL;
|
|
break;
|
|
|
|
case SOCK_STREAM:
|
|
case SOCK_SEQPACKET:
|
|
//
|
|
// Determine if the connection processing is completed
|
|
//
|
|
Status = EslTcpConnectPoll4 ( pSocket );
|
|
|
|
//
|
|
// Set the next state if connected
|
|
//
|
|
if ( EFI_NOT_READY != Status ) {
|
|
if ( !EFI_ERROR ( Status )) {
|
|
pSocket->State = SOCKET_STATE_CONNECTED;
|
|
}
|
|
else {
|
|
pSocket->State = SOCKET_STATE_BOUND;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case SOCK_DGRAM:
|
|
//
|
|
// Already connected
|
|
//
|
|
pSocket->errno = EISCONN;
|
|
Status = EFI_ALREADY_STARTED;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case SOCKET_STATE_CONNECTED:
|
|
//
|
|
// Already connected
|
|
//
|
|
pSocket->errno = EISCONN;
|
|
Status = EFI_ALREADY_STARTED;
|
|
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 = EBADF;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Return the operation status
|
|
//
|
|
DEBUG (( DEBUG_CONNECT, "Exiting SocketConnect, Status: %r\r\n", Status ));
|
|
return Status;
|
|
}
|
|
|
|
|
|
/**
|
|
Creates a child handle and installs a protocol.
|
|
|
|
The CreateChild() function 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] pThis Pointer to the EFI_SERVICE_BINDING_PROTOCOL instance.
|
|
@param [in] 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.
|
|
|
|
@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 availabe to create
|
|
the child
|
|
@retval other The child handle was not created
|
|
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
EslSocketCreateChild (
|
|
IN EFI_SERVICE_BINDING_PROTOCOL * pThis,
|
|
IN OUT EFI_HANDLE * pChildHandle
|
|
)
|
|
{
|
|
DT_SOCKET * pSocket;
|
|
EFI_STATUS Status;
|
|
|
|
DBG_ENTER ( );
|
|
|
|
//
|
|
// Create a socket structure
|
|
//
|
|
Status = EslSocketAllocate ( pChildHandle,
|
|
DEBUG_SOCKET,
|
|
&pSocket );
|
|
|
|
//
|
|
// Return the operation status
|
|
//
|
|
DBG_EXIT_STATUS ( Status );
|
|
return Status;
|
|
}
|
|
|
|
|
|
/**
|
|
Destroys a child handle with a protocol installed on it.
|
|
|
|
The DestroyChild() function does the opposite of CreateChild(). It removes a protocol
|
|
that was installed by CreateChild() from ChildHandle. If the removed protocol is the
|
|
last protocol on ChildHandle, then ChildHandle is destroyed.
|
|
|
|
@param [in] pThis Pointer to the EFI_SERVICE_BINDING_PROTOCOL instance.
|
|
@param [in] ChildHandle Handle of the child to destroy
|
|
|
|
@retval EFI_SUCCESS The protocol was removed from ChildHandle.
|
|
@retval EFI_UNSUPPORTED ChildHandle does not support the protocol that is being removed.
|
|
@retval EFI_INVALID_PARAMETER Child handle is not a valid UEFI Handle.
|
|
@retval EFI_ACCESS_DENIED The protocol could not be removed from the ChildHandle
|
|
because its services are being used.
|
|
@retval other The child handle was not destroyed
|
|
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
EslSocketDestroyChild (
|
|
IN EFI_SERVICE_BINDING_PROTOCOL * pThis,
|
|
IN EFI_HANDLE ChildHandle
|
|
)
|
|
{
|
|
DT_LAYER * pLayer;
|
|
DT_SOCKET * pSocket;
|
|
DT_SOCKET * pSocketPrevious;
|
|
EFI_SOCKET_PROTOCOL * pSocketProtocol;
|
|
EFI_STATUS Status;
|
|
EFI_TPL TplPrevious;
|
|
|
|
DBG_ENTER ( );
|
|
|
|
//
|
|
// Locate the socket control structure
|
|
//
|
|
pLayer = &mEslLayer;
|
|
Status = gBS->OpenProtocol (
|
|
ChildHandle,
|
|
&gEfiSocketProtocolGuid,
|
|
(VOID **)&pSocketProtocol,
|
|
pLayer->ImageHandle,
|
|
NULL,
|
|
EFI_OPEN_PROTOCOL_GET_PROTOCOL
|
|
);
|
|
if ( !EFI_ERROR ( Status )) {
|
|
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
|
|
//
|
|
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 )));
|
|
}
|
|
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 - Failed to open socket protocol on 0x%08x, Status; %r\r\n",
|
|
ChildHandle,
|
|
Status ));
|
|
}
|
|
|
|
//
|
|
// Return the operation status
|
|
//
|
|
DBG_EXIT_STATUS ( Status );
|
|
return Status;
|
|
}
|
|
|
|
|
|
/**
|
|
Get the local address.
|
|
|
|
@param [in] pSocketProtocol Address of the 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
|
|
)
|
|
{
|
|
DT_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 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 );
|
|
|
|
//
|
|
// Validate the local address
|
|
//
|
|
switch ( pSocket->Domain ) {
|
|
default:
|
|
DEBUG (( DEBUG_RX,
|
|
"ERROR - Invalid socket address family: %d\r\n",
|
|
pSocket->Domain ));
|
|
Status = EFI_INVALID_PARAMETER;
|
|
pSocket->errno = EADDRNOTAVAIL;
|
|
break;
|
|
|
|
case AF_INET:
|
|
//
|
|
// Determine the connection point within the network stack
|
|
//
|
|
switch ( pSocket->Type ) {
|
|
default:
|
|
DEBUG (( DEBUG_RX,
|
|
"ERROR - Invalid socket type: %d\r\n",
|
|
pSocket->Type));
|
|
Status = EFI_INVALID_PARAMETER;
|
|
break;
|
|
|
|
case SOCK_STREAM:
|
|
case SOCK_SEQPACKET:
|
|
//
|
|
// Get the local address
|
|
//
|
|
Status = EslTcpGetLocalAddress4 ( pSocket,
|
|
pAddress,
|
|
pAddressLength );
|
|
break;
|
|
|
|
case SOCK_DGRAM:
|
|
//
|
|
// Get the local address
|
|
//
|
|
Status = EslUdpGetLocalAddress4 ( pSocket,
|
|
pAddress,
|
|
pAddressLength );
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
//
|
|
// 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 = EBADF;
|
|
}
|
|
}
|
|
DBG_EXIT_STATUS ( Status );
|
|
return Status;
|
|
}
|
|
|
|
|
|
/**
|
|
Get the peer address.
|
|
|
|
@param [in] pSocketProtocol Address of the 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
|
|
)
|
|
{
|
|
DT_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 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 );
|
|
|
|
//
|
|
// Validate the local address
|
|
//
|
|
switch ( pSocket->Domain ) {
|
|
default:
|
|
DEBUG (( DEBUG_RX,
|
|
"ERROR - Invalid socket address family: %d\r\n",
|
|
pSocket->Domain ));
|
|
Status = EFI_INVALID_PARAMETER;
|
|
pSocket->errno = EADDRNOTAVAIL;
|
|
break;
|
|
|
|
case AF_INET:
|
|
//
|
|
// Determine the connection point within the network stack
|
|
//
|
|
switch ( pSocket->Type ) {
|
|
default:
|
|
DEBUG (( DEBUG_RX,
|
|
"ERROR - Invalid socket type: %d\r\n",
|
|
pSocket->Type));
|
|
Status = EFI_INVALID_PARAMETER;
|
|
break;
|
|
|
|
case SOCK_STREAM:
|
|
case SOCK_SEQPACKET:
|
|
//
|
|
// Verify the port state
|
|
//
|
|
Status = EslTcpGetRemoteAddress4 ( pSocket,
|
|
pAddress,
|
|
pAddressLength );
|
|
break;
|
|
|
|
case SOCK_DGRAM:
|
|
//
|
|
// Verify the port state
|
|
//
|
|
Status = EslUdpGetRemoteAddress4 ( pSocket,
|
|
pAddress,
|
|
pAddressLength );
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
//
|
|
// 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 = EBADF;
|
|
}
|
|
}
|
|
DBG_EXIT_STATUS ( Status );
|
|
return Status;
|
|
}
|
|
|
|
|
|
/**
|
|
Establish the known port to listen for network connections.
|
|
|
|
The ::SocketListen routine places the port into a state that enables connection
|
|
attempts. Connections are placed into FIFO order in a queue to be serviced
|
|
by the application. The application calls the ::SocketAccept routine to remove
|
|
the next connection from the queue and get the associated socket. The
|
|
<a href="http://pubs.opengroup.org/onlinepubs/9699919799/functions/listen.html">POSIX</a>
|
|
documentation for the listen routine is available online for reference.
|
|
|
|
@param [in] pSocketProtocol Address of the 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
|
|
)
|
|
{
|
|
DT_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 );
|
|
|
|
//
|
|
// 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,
|
|
TplPrevious,
|
|
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;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Validate the local address
|
|
//
|
|
switch ( pSocket->Domain ) {
|
|
default:
|
|
DEBUG (( DEBUG_BIND,
|
|
"ERROR - Invalid socket address family: %d\r\n",
|
|
pSocket->Domain ));
|
|
Status = EFI_INVALID_PARAMETER;
|
|
pSocket->errno = EADDRNOTAVAIL;
|
|
break;
|
|
|
|
case AF_INET:
|
|
//
|
|
// Determine the connection point within the network stack
|
|
//
|
|
switch ( pSocket->Type ) {
|
|
default:
|
|
DEBUG (( DEBUG_BIND,
|
|
"ERROR - Invalid socket type: %d\r\n",
|
|
pSocket->Type));
|
|
Status = EFI_INVALID_PARAMETER;
|
|
pSocket->errno = EADDRNOTAVAIL;
|
|
break;
|
|
|
|
case SOCK_STREAM:
|
|
case SOCK_SEQPACKET:
|
|
Status = EslTcpListen4 ( pSocket );
|
|
break;
|
|
|
|
/*
|
|
case SOCK_DGRAM:
|
|
Status = UdpListen4 ( pSocket );
|
|
break;
|
|
*/
|
|
}
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Place the socket in the listen state if successful
|
|
//
|
|
if ( !EFI_ERROR ( Status )) {
|
|
pSocket->State = SOCKET_STATE_LISTENING;
|
|
}
|
|
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 = EDESTADDRREQ;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Return the operation status
|
|
//
|
|
if ( NULL != pErrno ) {
|
|
if ( NULL != pSocket ) {
|
|
*pErrno = pSocket->errno;
|
|
}
|
|
else
|
|
{
|
|
Status = EFI_INVALID_PARAMETER;
|
|
*pErrno = EBADF;
|
|
}
|
|
}
|
|
DBG_EXIT_STATUS ( Status );
|
|
return Status;
|
|
}
|
|
|
|
|
|
/**
|
|
Get the socket options
|
|
|
|
Retrieve the socket options one at a time by name. The
|
|
<a href="http://pubs.opengroup.org/onlinepubs/9699919799/functions/getsockopt.html">POSIX</a>
|
|
documentation is available online.
|
|
|
|
@param [in] pSocketProtocol Address of the 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;
|
|
UINT8 * pOptionData;
|
|
DT_SOCKET * pSocket;
|
|
EFI_STATUS Status;
|
|
|
|
DBG_ENTER ( );
|
|
|
|
//
|
|
// Assume failure
|
|
//
|
|
errno = EINVAL;
|
|
Status = EFI_INVALID_PARAMETER;
|
|
|
|
//
|
|
// Validate the socket
|
|
//
|
|
pSocket = NULL;
|
|
if (( NULL != pSocketProtocol )
|
|
&& ( NULL != pOptionValue )
|
|
&& ( NULL != pOptionLength )) {
|
|
pSocket = SOCKET_FROM_PROTOCOL ( pSocketProtocol );
|
|
LengthInBytes = 0;
|
|
MaxBytes = *pOptionLength;
|
|
pOptionData = NULL;
|
|
switch ( level ) {
|
|
default:
|
|
//
|
|
// Protocol level not supported
|
|
//
|
|
errno = ENOTSUP;
|
|
Status = EFI_UNSUPPORTED;
|
|
break;
|
|
|
|
case SOL_SOCKET:
|
|
switch ( OptionName ) {
|
|
default:
|
|
//
|
|
// Option not supported
|
|
//
|
|
errno = ENOTSUP;
|
|
Status = EFI_UNSUPPORTED;
|
|
break;
|
|
|
|
case SO_RCVTIMEO:
|
|
//
|
|
// Return the receive timeout
|
|
//
|
|
pOptionData = (UINT8 *)&pSocket->RxTimeout;
|
|
LengthInBytes = sizeof ( pSocket->RxTimeout );
|
|
break;
|
|
|
|
case SO_RCVBUF:
|
|
//
|
|
// Return the maximum transmit buffer size
|
|
//
|
|
pOptionData = (UINT8 *)&pSocket->MaxRxBuf;
|
|
LengthInBytes = sizeof ( pSocket->MaxRxBuf );
|
|
break;
|
|
|
|
case SO_SNDBUF:
|
|
//
|
|
// Return the maximum transmit buffer size
|
|
//
|
|
pOptionData = (UINT8 *)&pSocket->MaxTxBuf;
|
|
LengthInBytes = sizeof ( pSocket->MaxTxBuf );
|
|
break;
|
|
|
|
case SO_TYPE:
|
|
//
|
|
// Return the socket type
|
|
//
|
|
pOptionData = (UINT8 *)&pSocket->Type;
|
|
LengthInBytes = sizeof ( pSocket->Type );
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Return the option length
|
|
//
|
|
*pOptionLength = LengthInBytes;
|
|
|
|
//
|
|
// Return the option value
|
|
//
|
|
if ( NULL != pOptionData ) {
|
|
//
|
|
// Silently truncate the value length
|
|
//
|
|
if ( LengthInBytes > MaxBytes ) {
|
|
LengthInBytes = MaxBytes;
|
|
}
|
|
CopyMem ( pOptionValue, pOptionData, 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
|
|
|
|
Adjust the socket options one at a time by name. The
|
|
<a href="http://pubs.opengroup.org/onlinepubs/9699919799/functions/setsockopt.html">POSIX</a>
|
|
documentation is available online.
|
|
|
|
@param [in] pSocketProtocol Address of the 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 - Socket data successfully received
|
|
|
|
**/
|
|
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
|
|
)
|
|
{
|
|
int errno;
|
|
socklen_t LengthInBytes;
|
|
UINT8 * pOptionData;
|
|
DT_SOCKET * pSocket;
|
|
EFI_STATUS Status;
|
|
|
|
DBG_ENTER ( );
|
|
|
|
//
|
|
// Assume failure
|
|
//
|
|
errno = EINVAL;
|
|
Status = EFI_INVALID_PARAMETER;
|
|
|
|
//
|
|
// Validate the socket
|
|
//
|
|
pSocket = NULL;
|
|
if (( NULL != pSocketProtocol )
|
|
&& ( NULL != pOptionValue )) {
|
|
pSocket = SOCKET_FROM_PROTOCOL ( pSocketProtocol );
|
|
LengthInBytes = 0;
|
|
pOptionData = NULL;
|
|
switch ( level ) {
|
|
default:
|
|
//
|
|
// Protocol level not supported
|
|
//
|
|
errno = ENOTSUP;
|
|
Status = EFI_UNSUPPORTED;
|
|
break;
|
|
|
|
case SOL_SOCKET:
|
|
switch ( OptionName ) {
|
|
default:
|
|
//
|
|
// Option not supported
|
|
//
|
|
errno = ENOTSUP;
|
|
Status = EFI_UNSUPPORTED;
|
|
break;
|
|
|
|
case SO_RCVTIMEO:
|
|
//
|
|
// Return the receive timeout
|
|
//
|
|
pOptionData = (UINT8 *)&pSocket->RxTimeout;
|
|
LengthInBytes = sizeof ( pSocket->RxTimeout );
|
|
break;
|
|
|
|
case SO_RCVBUF:
|
|
//
|
|
// Return the maximum transmit buffer size
|
|
//
|
|
pOptionData = (UINT8 *)&pSocket->MaxRxBuf;
|
|
LengthInBytes = sizeof ( pSocket->MaxRxBuf );
|
|
break;
|
|
|
|
case SO_SNDBUF:
|
|
//
|
|
// Send buffer size
|
|
//
|
|
//
|
|
// Return the maximum transmit buffer size
|
|
//
|
|
pOptionData = (UINT8 *)&pSocket->MaxTxBuf;
|
|
LengthInBytes = sizeof ( pSocket->MaxTxBuf );
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Validate the option length
|
|
//
|
|
if ( LengthInBytes <= OptionLength ) {
|
|
//
|
|
// Set the option value
|
|
//
|
|
if ( NULL != pOptionData ) {
|
|
CopyMem ( pOptionData, pOptionValue, LengthInBytes );
|
|
errno = 0;
|
|
Status = EFI_SUCCESS;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Return the operation status
|
|
//
|
|
if ( NULL != pErrno ) {
|
|
*pErrno = errno;
|
|
}
|
|
DBG_EXIT_STATUS ( Status );
|
|
return Status;
|
|
}
|
|
|
|
|
|
/**
|
|
Allocate a packet for a receive or transmit operation
|
|
|
|
@param [in] ppPacket Address to receive the DT_PACKET structure
|
|
@param [in] LengthInBytes Length of the packet structure
|
|
@param [in] DebugFlags Flags for debug messages
|
|
|
|
@retval EFI_SUCCESS - The packet was allocated successfully
|
|
|
|
**/
|
|
EFI_STATUS
|
|
EslSocketPacketAllocate (
|
|
IN DT_PACKET ** ppPacket,
|
|
IN size_t LengthInBytes,
|
|
IN UINTN DebugFlags
|
|
)
|
|
{
|
|
DT_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 | DEBUG_INIT,
|
|
"0x%08x: Allocate pPacket, %d bytes\r\n",
|
|
pPacket,
|
|
LengthInBytes ));
|
|
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
|
|
|
|
@param [in] pPacket Address of the DT_PACKET structure
|
|
@param [in] DebugFlags Flags for debug messages
|
|
|
|
@retval EFI_SUCCESS - The packet was allocated successfully
|
|
|
|
**/
|
|
EFI_STATUS
|
|
EslSocketPacketFree (
|
|
IN DT_PACKET * pPacket,
|
|
IN UINTN DebugFlags
|
|
)
|
|
{
|
|
UINTN LengthInBytes;
|
|
EFI_STATUS Status;
|
|
|
|
DBG_ENTER ( );
|
|
|
|
//
|
|
// Allocate 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.
|
|
|
|
The SocketPoll routine checks a socket for pending activity associated
|
|
with the event mask. Activity is returned in the detected event buffer.
|
|
|
|
@param [in] pSocketProtocol Address of the 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;
|
|
DT_SOCKET * pSocket;
|
|
EFI_STATUS Status;
|
|
EFI_TPL TplPrevious;
|
|
short ValidEvents;
|
|
|
|
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
|
|
//
|
|
if ( !pSocket->bConfigured ) {
|
|
//
|
|
// Synchronize with the socket layer
|
|
//
|
|
RAISE_TPL ( TplPrevious, TPL_SOCKETS );
|
|
|
|
//
|
|
// Validate the local address
|
|
//
|
|
switch ( pSocket->Domain ) {
|
|
default:
|
|
DEBUG (( DEBUG_RX,
|
|
"ERROR - Invalid socket address family: %d\r\n",
|
|
pSocket->Domain ));
|
|
Status = EFI_INVALID_PARAMETER;
|
|
pSocket->errno = EADDRNOTAVAIL;
|
|
break;
|
|
|
|
case AF_INET:
|
|
//
|
|
// Determine the connection point within the network stack
|
|
//
|
|
switch ( pSocket->Type ) {
|
|
default:
|
|
DEBUG (( DEBUG_RX,
|
|
"ERROR - Invalid socket type: %d\r\n",
|
|
pSocket->Type));
|
|
Status = EFI_INVALID_PARAMETER;
|
|
pSocket->errno = EADDRNOTAVAIL;
|
|
break;
|
|
|
|
case SOCK_STREAM:
|
|
case SOCK_SEQPACKET:
|
|
//
|
|
// Verify the port state
|
|
//
|
|
Status = EslTcpSocketIsConfigured4 ( pSocket );
|
|
break;
|
|
|
|
case SOCK_DGRAM:
|
|
//
|
|
// Verify the port state
|
|
//
|
|
Status = EslUdpSocketIsConfigured4 ( pSocket );
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Release the socket layer synchronization
|
|
//
|
|
RESTORE_TPL ( TplPrevious );
|
|
}
|
|
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 {
|
|
//
|
|
// 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;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Return the detected events
|
|
//
|
|
*pEvents = DetectedEvents & ( Events
|
|
| POLLERR
|
|
| POLLHUP
|
|
| POLLNVAL );
|
|
|
|
//
|
|
// Return the operation status
|
|
//
|
|
DEBUG (( DEBUG_POLL, "Exiting SocketPoll, Status: %r\r\n", Status ));
|
|
return Status;
|
|
}
|
|
|
|
|
|
/**
|
|
Receive data from a network connection.
|
|
|
|
|
|
@param [in] pSocketProtocol Address of the 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
|
|
)
|
|
{
|
|
DT_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
|
|
//
|
|
if ( !pSocket->bConfigured ) {
|
|
//
|
|
// Synchronize with the socket layer
|
|
//
|
|
RAISE_TPL ( TplPrevious, TPL_SOCKETS );
|
|
|
|
//
|
|
// Validate the local address
|
|
//
|
|
switch ( pSocket->Domain ) {
|
|
default:
|
|
DEBUG (( DEBUG_RX,
|
|
"ERROR - Invalid socket address family: %d\r\n",
|
|
pSocket->Domain ));
|
|
Status = EFI_INVALID_PARAMETER;
|
|
pSocket->errno = EADDRNOTAVAIL;
|
|
break;
|
|
|
|
case AF_INET:
|
|
//
|
|
// Determine the connection point within the network stack
|
|
//
|
|
switch ( pSocket->Type ) {
|
|
default:
|
|
DEBUG (( DEBUG_RX,
|
|
"ERROR - Invalid socket type: %d\r\n",
|
|
pSocket->Type));
|
|
Status = EFI_INVALID_PARAMETER;
|
|
break;
|
|
|
|
case SOCK_STREAM:
|
|
case SOCK_SEQPACKET:
|
|
//
|
|
// Verify the port state
|
|
//
|
|
Status = EslTcpSocketIsConfigured4 ( pSocket );
|
|
break;
|
|
|
|
case SOCK_DGRAM:
|
|
//
|
|
// Verify the port state
|
|
//
|
|
Status = EslUdpSocketIsConfigured4 ( pSocket );
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Release the socket layer synchronization
|
|
//
|
|
RESTORE_TPL ( TplPrevious );
|
|
|
|
//
|
|
// Set errno if a failure occurs
|
|
//
|
|
if ( EFI_ERROR ( Status )) {
|
|
pSocket->errno = EADDRNOTAVAIL;
|
|
}
|
|
}
|
|
if ( !EFI_ERROR ( Status )) {
|
|
//
|
|
// 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{
|
|
//
|
|
// Synchronize with the socket layer
|
|
//
|
|
RAISE_TPL ( TplPrevious, TPL_SOCKETS );
|
|
|
|
//
|
|
// Validate the local address
|
|
//
|
|
switch ( pSocket->Domain ) {
|
|
default:
|
|
DEBUG (( DEBUG_RX,
|
|
"ERROR - Invalid socket address family: %d\r\n",
|
|
pSocket->Domain ));
|
|
Status = EFI_INVALID_PARAMETER;
|
|
pSocket->errno = EADDRNOTAVAIL;
|
|
break;
|
|
|
|
case AF_INET:
|
|
//
|
|
// Determine the connection point within the network stack
|
|
//
|
|
switch ( pSocket->Type ) {
|
|
default:
|
|
DEBUG (( DEBUG_RX,
|
|
"ERROR - Invalid socket type: %d\r\n",
|
|
pSocket->Type));
|
|
Status = EFI_INVALID_PARAMETER;
|
|
pSocket->errno = EADDRNOTAVAIL;
|
|
break;
|
|
|
|
case SOCK_STREAM:
|
|
case SOCK_SEQPACKET:
|
|
Status = EslTcpReceive4 ( pSocket,
|
|
Flags,
|
|
BufferLength,
|
|
pBuffer,
|
|
pDataLength,
|
|
pAddress,
|
|
pAddressLength );
|
|
break;
|
|
|
|
case SOCK_DGRAM:
|
|
Status = EslUdpReceive4 ( pSocket,
|
|
Flags,
|
|
BufferLength,
|
|
pBuffer,
|
|
pDataLength,
|
|
pAddress,
|
|
pAddressLength);
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
//
|
|
// 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 = EBADF;
|
|
}
|
|
}
|
|
DBG_EXIT_STATUS ( Status );
|
|
return Status;
|
|
}
|
|
|
|
|
|
/**
|
|
Shutdown the socket receive and transmit operations
|
|
|
|
The SocketShutdown routine stops the socket receive and transmit
|
|
operations.
|
|
|
|
@param [in] pSocketProtocol Address of the 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
|
|
)
|
|
{
|
|
DT_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;
|
|
}
|
|
|
|
//
|
|
// Validate the local address
|
|
//
|
|
switch ( pSocket->Domain ) {
|
|
default:
|
|
DEBUG (( DEBUG_RX,
|
|
"ERROR - Invalid socket address family: %d\r\n",
|
|
pSocket->Domain ));
|
|
Status = EFI_INVALID_PARAMETER;
|
|
pSocket->errno = EADDRNOTAVAIL;
|
|
break;
|
|
|
|
case AF_INET:
|
|
//
|
|
// Determine the connection point within the network stack
|
|
//
|
|
switch ( pSocket->Type ) {
|
|
default:
|
|
DEBUG (( DEBUG_RX,
|
|
"ERROR - Invalid socket type: %d\r\n",
|
|
pSocket->Type));
|
|
Status = EFI_INVALID_PARAMETER;
|
|
break;
|
|
|
|
case SOCK_STREAM:
|
|
case SOCK_SEQPACKET:
|
|
//
|
|
// Cancel the pending receive operation
|
|
//
|
|
Status = EslTcpRxCancel4 ( pSocket );
|
|
break;
|
|
|
|
case SOCK_DGRAM:
|
|
//
|
|
// Cancel the pending receive operation
|
|
//
|
|
Status = EslUdpRxCancel4 ( pSocket );
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Release the socket layer synchronization
|
|
//
|
|
RESTORE_TPL ( TplPrevious );
|
|
}
|
|
else {
|
|
//
|
|
// The socket is not connected
|
|
//
|
|
pSocket->errno = ENOTCONN;
|
|
Status = EFI_NOT_STARTED;
|
|
}
|
|
}
|
|
else {
|
|
//
|
|
// Invalid How value
|
|
//
|
|
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 = EBADF;
|
|
}
|
|
}
|
|
DBG_EXIT_STATUS ( Status );
|
|
return Status;
|
|
}
|
|
|
|
|
|
/**
|
|
Send data using a network connection.
|
|
|
|
The SocketTransmit routine queues the data for transmission to the
|
|
remote network connection.
|
|
|
|
@param [in] pSocketProtocol Address of the 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
|
|
)
|
|
{
|
|
DT_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
|
|
//
|
|
if ( !pSocket->bConfigured ) {
|
|
//
|
|
// Synchronize with the socket layer
|
|
//
|
|
RAISE_TPL ( TplPrevious, TPL_SOCKETS );
|
|
|
|
//
|
|
// Validate the local address
|
|
//
|
|
switch ( pSocket->Domain ) {
|
|
default:
|
|
DEBUG (( DEBUG_RX,
|
|
"ERROR - Invalid socket address family: %d\r\n",
|
|
pSocket->Domain ));
|
|
Status = EFI_INVALID_PARAMETER;
|
|
pSocket->errno = EADDRNOTAVAIL;
|
|
break;
|
|
|
|
case AF_INET:
|
|
//
|
|
// Determine the connection point within the network stack
|
|
//
|
|
switch ( pSocket->Type ) {
|
|
default:
|
|
DEBUG (( DEBUG_RX,
|
|
"ERROR - Invalid socket type: %d\r\n",
|
|
pSocket->Type));
|
|
Status = EFI_INVALID_PARAMETER;
|
|
break;
|
|
|
|
case SOCK_STREAM:
|
|
case SOCK_SEQPACKET:
|
|
//
|
|
// Verify the port state
|
|
//
|
|
Status = EslTcpSocketIsConfigured4 ( pSocket );
|
|
break;
|
|
|
|
case SOCK_DGRAM:
|
|
//
|
|
// Verify the port state
|
|
//
|
|
Status = EslUdpSocketIsConfigured4 ( pSocket );
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Release the socket layer synchronization
|
|
//
|
|
RESTORE_TPL ( TplPrevious );
|
|
|
|
//
|
|
// Set errno if a failure occurs
|
|
//
|
|
if ( EFI_ERROR ( Status )) {
|
|
pSocket->errno = EADDRNOTAVAIL;
|
|
}
|
|
}
|
|
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 {
|
|
//
|
|
// Synchronize with the socket layer
|
|
//
|
|
RAISE_TPL ( TplPrevious, TPL_SOCKETS );
|
|
|
|
//
|
|
// Validate the local address
|
|
//
|
|
switch ( pSocket->Domain ) {
|
|
default:
|
|
DEBUG (( DEBUG_RX,
|
|
"ERROR - Invalid socket address family: %d\r\n",
|
|
pSocket->Domain ));
|
|
Status = EFI_INVALID_PARAMETER;
|
|
pSocket->errno = EADDRNOTAVAIL;
|
|
break;
|
|
|
|
case AF_INET:
|
|
//
|
|
// Determine the connection point within the network stack
|
|
//
|
|
switch ( pSocket->Type ) {
|
|
default:
|
|
DEBUG (( DEBUG_RX,
|
|
"ERROR - Invalid socket type: %d\r\n",
|
|
pSocket->Type));
|
|
Status = EFI_INVALID_PARAMETER;
|
|
pSocket->errno = EADDRNOTAVAIL;
|
|
break;
|
|
|
|
case SOCK_STREAM:
|
|
case SOCK_SEQPACKET:
|
|
Status = EslTcpTxBuffer4 ( pSocket,
|
|
Flags,
|
|
BufferLength,
|
|
pBuffer,
|
|
pDataLength );
|
|
break;
|
|
|
|
case SOCK_DGRAM:
|
|
Status = EslUdpTxBuffer4 ( pSocket,
|
|
Flags,
|
|
BufferLength,
|
|
pBuffer,
|
|
pDataLength,
|
|
pAddress,
|
|
AddressLength );
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
//
|
|
// 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 = EBADF;
|
|
}
|
|
}
|
|
DBG_EXIT_STATUS ( Status );
|
|
return Status;
|
|
}
|
|
|
|
|
|
/**
|
|
Socket layer's service binding protocol delcaration.
|
|
**/
|
|
EFI_SERVICE_BINDING_PROTOCOL mEfiServiceBinding = {
|
|
EslSocketCreateChild,
|
|
EslSocketDestroyChild
|
|
};
|