StdLib/EfiSocketLib/Udp4.c

   1 /** @file
   2   Implement the UDP4 driver support for the socket layer.
   3
   4   Copyright (c) 2011, Intel Corporation
   5   All rights reserved. This program and the accompanying materials
   6   are licensed and made available under the terms and conditions of the BSD License
   7   which accompanies this distribution.  The full text of the license may be found at
   8   http://opensource.org/licenses/bsd-license.php
   9
  10   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13 **/
  14
  15 #include "Socket.h"
  16
  17
  18 /**
  19   Get the local socket address
  20
  21   This routine returns the IPv4 address and UDP port number associated
  22   with the local socket.
  23
  24   This routine is called by ::EslSocketGetLocalAddress to determine the
  25   network address for the SOCK_DGRAM socket.
  26
  27   @param [in] pPort       Address of an ::ESL_PORT structure.
  28
  29   @param [out] pSockAddr  Network address to receive the local system address
  30
  31 **/
  32 VOID
  33 EslUdp4LocalAddressGet (
  34   IN ESL_PORT * pPort,
  35   OUT struct sockaddr * pSockAddr
  36   )
  37 {
  38   struct sockaddr_in * pLocalAddress;
  39   ESL_UDP4_CONTEXT * pUdp4;
  40
  41   DBG_ENTER ( );
  42
  43   //
  44   //  Return the local address
  45   //
  46   pUdp4 = &pPort->Context.Udp4;
  47   pLocalAddress = (struct sockaddr_in *)pSockAddr;
  48   pLocalAddress->sin_family = AF_INET;
  49   pLocalAddress->sin_port = SwapBytes16 ( pUdp4->ConfigData.StationPort );
  50   CopyMem ( &pLocalAddress->sin_addr,
  51             &pUdp4->ConfigData.StationAddress.Addr[0],
  52             sizeof ( pLocalAddress->sin_addr ));
  53
  54   DBG_EXIT ( );
  55 }
  56
  57
  58 /**
  59   Set the local port address.
  60
  61   This routine sets the local port address.
  62
  63   This support routine is called by ::EslSocketPortAllocate.
  64
  65   @param [in] pPort       Address of an ESL_PORT structure
  66   @param [in] pSockAddr   Address of a sockaddr structure that contains the
  67                           connection point on the local machine.  An IPv4 address
  68                           of INADDR_ANY specifies that the connection is made to
  69                           all of the network stacks on the platform.  Specifying a
  70                           specific IPv4 address restricts the connection to the
  71                           network stack supporting that address.  Specifying zero
  72                           for the port causes the network layer to assign a port
  73                           number from the dynamic range.  Specifying a specific
  74                           port number causes the network layer to use that port.
  75
  76   @param [in] bBindTest   TRUE = run bind testing
  77
  78   @retval EFI_SUCCESS     The operation was successful
  79
  80  **/
  81 EFI_STATUS
  82 EslUdp4LocalAddressSet (
  83   IN ESL_PORT * pPort,
  84   IN CONST struct sockaddr * pSockAddr,
  85   IN BOOLEAN bBindTest
  86   )
  87 {
  88   EFI_UDP4_CONFIG_DATA * pConfig;
  89   CONST struct sockaddr_in * pIpAddress;
  90   CONST UINT8 * pIpv4Address;
  91   EFI_STATUS Status;
  92
  93   DBG_ENTER ( );
  94
  95   //
  96   //  Validate the address
  97   //
  98   pIpAddress = (struct sockaddr_in *)pSockAddr;
  99   if ( INADDR_BROADCAST == pIpAddress->sin_addr.s_addr ) {
 100     //
 101     //  The local address must not be the broadcast address
 102     //
 103     Status = EFI_INVALID_PARAMETER;
 104     pPort->pSocket->errno = EADDRNOTAVAIL;
 105   }
 106   else {
 107     //
 108     //  Set the local address
 109     //
 110     pIpAddress = (struct sockaddr_in *)pSockAddr;
 111     pIpv4Address = (UINT8 *)&pIpAddress->sin_addr.s_addr;
 112     pConfig = &pPort->Context.Udp4.ConfigData;
 113     pConfig->StationAddress.Addr[0] = pIpv4Address[0];
 114     pConfig->StationAddress.Addr[1] = pIpv4Address[1];
 115     pConfig->StationAddress.Addr[2] = pIpv4Address[2];
 116     pConfig->StationAddress.Addr[3] = pIpv4Address[3];
 117
 118     //
 119     //  Determine if the default address is used
 120     //
 121     pConfig->UseDefaultAddress = (BOOLEAN)( 0 == pIpAddress->sin_addr.s_addr );
 122
 123     //
 124     //  Set the subnet mask
 125     //
 126     if ( pConfig->UseDefaultAddress ) {
 127       pConfig->SubnetMask.Addr[0] = 0;
 128       pConfig->SubnetMask.Addr[1] = 0;
 129       pConfig->SubnetMask.Addr[2] = 0;
 130       pConfig->SubnetMask.Addr[3] = 0;
 131     }
 132     else {
 133       pConfig->SubnetMask.Addr[0] = 0xff;
 134       pConfig->SubnetMask.Addr[1] = 0xff;
 135       pConfig->SubnetMask.Addr[2] = 0xff;
 136       pConfig->SubnetMask.Addr[3] = 0xff;
 137     }
 138
 139     //
 140     //  Validate the IP address
 141     //
 142     pConfig->StationPort = 0;
 143     Status = bBindTest ? EslSocketBindTest ( pPort, EADDRNOTAVAIL )
 144                        : EFI_SUCCESS;
 145     if ( !EFI_ERROR ( Status )) {
 146       //
 147       //  Set the port number
 148       //
 149       pConfig->StationPort = SwapBytes16 ( pIpAddress->sin_port );
 150
 151       //
 152       //  Display the local address
 153       //
 154       DEBUG (( DEBUG_BIND,
 155                 "0x%08x: Port, Local UDP4 Address: %d.%d.%d.%d:%d\r\n",
 156                 pPort,
 157                 pConfig->StationAddress.Addr[0],
 158                 pConfig->StationAddress.Addr[1],
 159                 pConfig->StationAddress.Addr[2],
 160                 pConfig->StationAddress.Addr[3],
 161                 pConfig->StationPort ));
 162     }
 163   }
 164
 165   //
 166   //  Return the operation status
 167   //
 168   DBG_EXIT_STATUS ( Status );
 169   return Status;
 170 }
 171
 172
 173 /**
 174   Free a receive packet
 175
 176   This routine performs the network specific operations necessary
 177   to free a receive packet.
 178
 179   This routine is called by ::EslSocketPortCloseTxDone to free a
 180   receive packet.
 181
 182   @param [in] pPacket         Address of an ::ESL_PACKET structure.
 183   @param [in, out] pRxBytes   Address of the count of RX bytes
 184
 185 **/
 186 VOID
 187 EslUdp4PacketFree (
 188   IN ESL_PACKET * pPacket,
 189   IN OUT size_t * pRxBytes
 190   )
 191 {
 192   EFI_UDP4_RECEIVE_DATA * pRxData;
 193
 194   DBG_ENTER ( );
 195
 196   //
 197   //  Account for the receive bytes
 198   //
 199   pRxData = pPacket->Op.Udp4Rx.pRxData;
 200   *pRxBytes -= pRxData->DataLength;
 201
 202   //
 203   //  Disconnect the buffer from the packet
 204   //
 205   pPacket->Op.Udp4Rx.pRxData = NULL;
 206
 207   //
 208   //  Return the buffer to the UDP4 driver
 209   //
 210   gBS->SignalEvent ( pRxData->RecycleSignal );
 211   DBG_EXIT ( );
 212 }
 213
 214
 215 /**
 216   Initialize the network specific portions of an ::ESL_PORT structure.
 217
 218   This routine initializes the network specific portions of an
 219   ::ESL_PORT structure for use by the socket.
 220
 221   This support routine is called by ::EslSocketPortAllocate
 222   to connect the socket with the underlying network adapter
 223   running the UDPv4 protocol.
 224
 225   @param [in] pPort       Address of an ESL_PORT structure
 226   @param [in] DebugFlags  Flags for debug messages
 227
 228   @retval EFI_SUCCESS - Socket successfully created
 229
 230  **/
 231 EFI_STATUS
 232 EslUdp4PortAllocate (
 233   IN ESL_PORT * pPort,
 234   IN UINTN DebugFlags
 235   )
 236 {
 237   EFI_UDP4_CONFIG_DATA * pConfig;
 238   ESL_SOCKET * pSocket;
 239   EFI_STATUS Status;
 240
 241   DBG_ENTER ( );
 242
 243   //
 244   //  Initialize the port
 245   //
 246   pSocket = pPort->pSocket;
 247   pSocket->TxPacketOffset = OFFSET_OF ( ESL_PACKET, Op.Udp4Tx.TxData );
 248   pSocket->TxTokenEventOffset = OFFSET_OF ( ESL_IO_MGMT, Token.Udp4Tx.Event );
 249   pSocket->TxTokenOffset = OFFSET_OF ( EFI_UDP4_COMPLETION_TOKEN, Packet.TxData );
 250
 251   //
 252   //  Save the cancel, receive and transmit addresses
 253   //
 254   pPort->pfnConfigure = (PFN_NET_CONFIGURE)pPort->pProtocol.UDPv4->Configure;
 255   pPort->pfnRxCancel = (PFN_NET_IO_START)pPort->pProtocol.UDPv4->Cancel;
 256   pPort->pfnRxPoll = (PFN_NET_POLL)pPort->pProtocol.UDPv4->Poll;
 257   pPort->pfnRxStart = (PFN_NET_IO_START)pPort->pProtocol.UDPv4->Receive;
 258   pPort->pfnTxStart = (PFN_NET_IO_START)pPort->pProtocol.UDPv4->Transmit;
 259
 260   //
 261   //  Set the configuration flags
 262   //
 263   pConfig = &pPort->Context.Udp4.ConfigData;
 264   pConfig->TimeToLive = 255;
 265   pConfig->AcceptAnyPort = FALSE;
 266   pConfig->AcceptBroadcast = FALSE;
 267   pConfig->AcceptPromiscuous = FALSE;
 268   pConfig->AllowDuplicatePort = TRUE;
 269   pConfig->DoNotFragment = TRUE;
 270   Status = EFI_SUCCESS;
 271
 272   //
 273   //  Return the operation status
 274   //
 275   DBG_EXIT_STATUS ( Status );
 276   return Status;
 277 }
 278
 279
 280 /**
 281   Receive data from a network connection.
 282
 283   This routine attempts to return buffered data to the caller.  The
 284   data is removed from the urgent queue if the message flag MSG_OOB
 285   is specified, otherwise data is removed from the normal queue.
 286   See the \ref ReceiveEngine section.
 287
 288   This routine is called by ::EslSocketReceive to handle the network
 289   specific receive operation to support SOCK_DGRAM sockets.
 290
 291   @param [in] pPort           Address of an ::ESL_PORT structure.
 292
 293   @param [in] pPacket         Address of an ::ESL_PACKET structure.
 294
 295   @param [in] pbConsumePacket Address of a BOOLEAN indicating if the packet is to be consumed
 296
 297   @param [in] BufferLength    Length of the the buffer
 298
 299   @param [in] pBuffer         Address of a buffer to receive the data.
 300
 301   @param [in] pDataLength     Number of received data bytes in the buffer.
 302
 303   @param [out] pAddress       Network address to receive the remote system address
 304
 305   @param [out] pSkipBytes     Address to receive the number of bytes skipped
 306
 307   @return   Returns the address of the next free byte in the buffer.
 308
 309  **/
 310 UINT8 *
 311 EslUdp4Receive (
 312   IN ESL_PORT * pPort,
 313   IN ESL_PACKET * pPacket,
 314   IN BOOLEAN * pbConsumePacket,
 315   IN size_t BufferLength,
 316   IN UINT8 * pBuffer,
 317   OUT size_t * pDataLength,
 318   OUT struct sockaddr * pAddress,
 319   OUT size_t * pSkipBytes
 320   )
 321 {
 322   size_t DataBytes;
 323   struct sockaddr_in * pRemoteAddress;
 324   EFI_UDP4_RECEIVE_DATA * pRxData;
 325
 326   DBG_ENTER ( );
 327
 328   pRxData = pPacket->Op.Udp4Rx.pRxData;
 329   //
 330   //  Return the remote system address if requested
 331   //
 332   if ( NULL != pAddress ) {
 333     //
 334     //  Build the remote address
 335     //
 336     DEBUG (( DEBUG_RX,
 337               "Getting packet remote address: %d.%d.%d.%d:%d\r\n",
 338               pRxData->UdpSession.SourceAddress.Addr[0],
 339               pRxData->UdpSession.SourceAddress.Addr[1],
 340               pRxData->UdpSession.SourceAddress.Addr[2],
 341               pRxData->UdpSession.SourceAddress.Addr[3],
 342               pRxData->UdpSession.SourcePort ));
 343     pRemoteAddress = (struct sockaddr_in *)pAddress;
 344     CopyMem ( &pRemoteAddress->sin_addr,
 345               &pRxData->UdpSession.SourceAddress.Addr[0],
 346               sizeof ( pRemoteAddress->sin_addr ));
 347     pRemoteAddress->sin_port = SwapBytes16 ( pRxData->UdpSession.SourcePort );
 348   }
 349
 350   //
 351   //  Copy the received data
 352   //
 353   pBuffer = EslSocketCopyFragmentedBuffer ( pRxData->FragmentCount,
 354                                             (EFI_IP4_FRAGMENT_DATA *)&pRxData->FragmentTable[0],
 355                                             BufferLength,
 356                                             pBuffer,
 357                                             &DataBytes );
 358
 359   //
 360   //  Determine if the data is being read
 361   //
 362   if ( *pbConsumePacket ) {
 363     //
 364     //  Display for the bytes consumed
 365     //
 366     DEBUG (( DEBUG_RX,
 367               "0x%08x: Port account for 0x%08x bytes\r\n",
 368               pPort,
 369               DataBytes ));
 370
 371     //
 372     //  Account for any discarded data
 373     //
 374     *pSkipBytes = pRxData->DataLength - DataBytes;
 375   }
 376
 377   //
 378   //  Return the data length and the buffer address
 379   //
 380   *pDataLength = DataBytes;
 381   DBG_EXIT_HEX ( pBuffer );
 382   return pBuffer;
 383 }
 384
 385
 386 /**
 387   Get the remote socket address
 388
 389   This routine returns the address of the remote connection point
 390   associated with the SOCK_DGRAM socket.
 391
 392   This routine is called by ::EslSocketGetPeerAddress to detemine
 393   the UDPv4 address and port number associated with the network adapter.
 394
 395   @param [in] pPort       Address of an ::ESL_PORT structure.
 396
 397   @param [out] pAddress   Network address to receive the remote system address
 398
 399 **/
 400 VOID
 401 EslUdp4RemoteAddressGet (
 402   IN ESL_PORT * pPort,
 403   OUT struct sockaddr * pAddress
 404   )
 405 {
 406   struct sockaddr_in * pRemoteAddress;
 407   ESL_UDP4_CONTEXT * pUdp4;
 408
 409   DBG_ENTER ( );
 410
 411   //
 412   //  Return the remote address
 413   //
 414   pUdp4 = &pPort->Context.Udp4;
 415   pRemoteAddress = (struct sockaddr_in *)pAddress;
 416   pRemoteAddress->sin_family = AF_INET;
 417   pRemoteAddress->sin_port = SwapBytes16 ( pUdp4->ConfigData.RemotePort );
 418   CopyMem ( &pRemoteAddress->sin_addr,
 419             &pUdp4->ConfigData.RemoteAddress.Addr[0],
 420             sizeof ( pRemoteAddress->sin_addr ));
 421
 422   DBG_EXIT ( );
 423 }
 424
 425
 426 /**
 427   Set the remote address
 428
 429   This routine sets the remote address in the port.
 430
 431   This routine is called by ::EslSocketConnect to specify the
 432   remote network address.
 433
 434   @param [in] pPort           Address of an ::ESL_PORT structure.
 435
 436   @param [in] pSockAddr       Network address of the remote system.
 437
 438   @param [in] SockAddrLength  Length in bytes of the network address.
 439
 440   @retval EFI_SUCCESS     The operation was successful
 441
 442  **/
 443 EFI_STATUS
 444 EslUdp4RemoteAddressSet (
 445   IN ESL_PORT * pPort,
 446   IN CONST struct sockaddr * pSockAddr,
 447   IN socklen_t SockAddrLength
 448   )
 449 {
 450   CONST struct sockaddr_in * pRemoteAddress;
 451   ESL_UDP4_CONTEXT * pUdp4;
 452   EFI_STATUS Status;
 453
 454   DBG_ENTER ( );
 455
 456   //
 457   //  Set the remote address
 458   //
 459   pUdp4 = &pPort->Context.Udp4;
 460   pRemoteAddress = (struct sockaddr_in *)pSockAddr;
 461   pUdp4->ConfigData.RemoteAddress.Addr[0] = (UINT8)( pRemoteAddress->sin_addr.s_addr );
 462   pUdp4->ConfigData.RemoteAddress.Addr[1] = (UINT8)( pRemoteAddress->sin_addr.s_addr >> 8 );
 463   pUdp4->ConfigData.RemoteAddress.Addr[2] = (UINT8)( pRemoteAddress->sin_addr.s_addr >> 16 );
 464   pUdp4->ConfigData.RemoteAddress.Addr[3] = (UINT8)( pRemoteAddress->sin_addr.s_addr >> 24 );
 465   pUdp4->ConfigData.RemotePort = SwapBytes16 ( pRemoteAddress->sin_port );
 466   pPort->pSocket->bAddressSet = TRUE;
 467   Status = EFI_SUCCESS;
 468
 469   //
 470   //  Return the operation status
 471   //
 472   DBG_EXIT_STATUS ( Status );
 473   return Status;
 474 }
 475
 476
 477 /**
 478   Process the receive completion
 479
 480   This routine keeps the UDPv4 driver's buffer and queues it in
 481   in FIFO order to the data queue.  The UDP4 driver's buffer will
 482   be returned by either ::EslUdp4Receive or ::EslSocketPortCloseTxDone.
 483   See the \ref ReceiveEngine section.
 484
 485   This routine is called by the UDPv4 driver when data is
 486   received.
 487
 488   @param [in] Event     The receive completion event
 489
 490   @param [in] pIo       Address of an ::ESL_IO_MGMT structure
 491
 492 **/
 493 VOID
 494 EslUdp4RxComplete (
 495   IN EFI_EVENT Event,
 496   IN ESL_IO_MGMT * pIo
 497   )
 498 {
 499   size_t LengthInBytes;
 500   ESL_PACKET * pPacket;
 501   EFI_UDP4_RECEIVE_DATA * pRxData;
 502   EFI_STATUS Status;
 503
 504   DBG_ENTER ( );
 505
 506   //
 507   //  Get the operation status.
 508   //
 509   Status = pIo->Token.Udp4Rx.Status;
 510
 511   //
 512   //  Get the packet length
 513   //
 514   pRxData = pIo->Token.Udp4Rx.Packet.RxData;
 515   LengthInBytes = pRxData->DataLength;
 516
 517   //
 518   //      +--------------------+   +-----------------------+
 519   //      | ESL_IO_MGMT        |   |      Data Buffer      |
 520   //      |                    |   |     (Driver owned)    |
 521   //      |    +---------------+   +-----------------------+
 522   //      |    | Token         |               ^
 523   //      |    |      Rx Event |               |
 524   //      |    |               |   +-----------------------+
 525   //      |    |        RxData --> | EFI_UDP4_RECEIVE_DATA |
 526   //      +----+---------------+   |     (Driver owned)    |
 527   //                               +-----------------------+
 528   //      +--------------------+               ^
 529   //      | ESL_PACKET         |               .
 530   //      |                    |               .
 531   //      |    +---------------+               .
 532   //      |    |       pRxData --> NULL  .......
 533   //      +----+---------------+
 534   //
 535   //
 536   //  Save the data in the packet
 537   //
 538   pPacket = pIo->pPacket;
 539   pPacket->Op.Udp4Rx.pRxData = pRxData;
 540
 541   //
 542   //  Complete this request
 543   //
 544   EslSocketRxComplete ( pIo, Status, LengthInBytes, FALSE );
 545   DBG_EXIT ( );
 546 }
 547
 548
 549 /**
 550   Determine if the socket is configured.
 551
 552   This routine uses the flag ESL_SOCKET::bConfigured to determine
 553   if the network layer's configuration routine has been called.
 554   This routine calls the bind and configuration routines if they
 555   were not already called.  After the port is configured, the
 556   \ref ReceiveEngine is started.
 557
 558   This routine is called by EslSocketIsConfigured to verify
 559   that the socket is configured.
 560
 561   @param [in] pSocket         Address of an ::ESL_SOCKET structure
 562
 563   @retval EFI_SUCCESS - The port is connected
 564   @retval EFI_NOT_STARTED - The port is not connected
 565
 566  **/
 567  EFI_STATUS
 568  EslUdp4SocketIsConfigured (
 569   IN ESL_SOCKET * pSocket
 570   )
 571 {
 572   EFI_UDP4_CONFIG_DATA * pConfigData;
 573   ESL_PORT * pPort;
 574   ESL_PORT * pNextPort;
 575   ESL_UDP4_CONTEXT * pUdp4;
 576   EFI_UDP4_PROTOCOL * pUdp4Protocol;
 577   EFI_STATUS Status;
 578   struct sockaddr_in LocalAddress;
 579
 580   DBG_ENTER ( );
 581
 582   //
 583   //  Assume success
 584   //
 585   Status = EFI_SUCCESS;
 586
 587   //
 588   //  Configure the port if necessary
 589   //
 590   if ( !pSocket->bConfigured ) {
 591     //
 592     //  Fill in the port list if necessary
 593     //
 594     if ( NULL == pSocket->pPortList ) {
 595       LocalAddress.sin_len = sizeof ( LocalAddress );
 596       LocalAddress.sin_family = AF_INET;
 597       LocalAddress.sin_addr.s_addr = 0;
 598       LocalAddress.sin_port = 0;
 599       Status = EslSocketBind ( &pSocket->SocketProtocol,
 600                                (struct sockaddr *)&LocalAddress,
 601                                LocalAddress.sin_len,
 602                                &pSocket->errno );
 603     }
 604
 605     //
 606     //  Walk the port list
 607     //
 608     pPort = pSocket->pPortList;
 609     while ( NULL != pPort ) {
 610       //
 611       //  Attempt to configure the port
 612       //
 613       pNextPort = pPort->pLinkSocket;
 614       pUdp4 = &pPort->Context.Udp4;
 615       pUdp4Protocol = pPort->pProtocol.UDPv4;
 616       pConfigData = &pUdp4->ConfigData;
 617       DEBUG (( DEBUG_TX,
 618                 "0x%08x: pPort Configuring for %d.%d.%d.%d:%d --> %d.%d.%d.%d:%d\r\n",
 619                 pPort,
 620                 pConfigData->StationAddress.Addr[0],
 621                 pConfigData->StationAddress.Addr[1],
 622                 pConfigData->StationAddress.Addr[2],
 623                 pConfigData->StationAddress.Addr[3],
 624                 pConfigData->StationPort,
 625                 pConfigData->RemoteAddress.Addr[0],
 626                 pConfigData->RemoteAddress.Addr[1],
 627                 pConfigData->RemoteAddress.Addr[2],
 628                 pConfigData->RemoteAddress.Addr[3],
 629                 pConfigData->RemotePort ));
 630       Status = pUdp4Protocol->Configure ( pUdp4Protocol,
 631                                           pConfigData );
 632       if ( !EFI_ERROR ( Status )) {
 633         //
 634         //  Update the configuration data
 635         //
 636         Status = pUdp4Protocol->GetModeData ( pUdp4Protocol,
 637                                               pConfigData,
 638                                               NULL,
 639                                               NULL,
 640                                               NULL );
 641       }
 642       if ( EFI_ERROR ( Status )) {
 643         DEBUG (( DEBUG_LISTEN,
 644                   "ERROR - Failed to configure the Udp4 port, Status: %r\r\n",
 645                   Status ));
 646         switch ( Status ) {
 647         case EFI_ACCESS_DENIED:
 648           pSocket->errno = EACCES;
 649           break;
 650
 651         default:
 652         case EFI_DEVICE_ERROR:
 653           pSocket->errno = EIO;
 654           break;
 655
 656         case EFI_INVALID_PARAMETER:
 657           pSocket->errno = EADDRNOTAVAIL;
 658           break;
 659
 660         case EFI_NO_MAPPING:
 661           pSocket->errno = EAFNOSUPPORT;
 662           break;
 663
 664         case EFI_OUT_OF_RESOURCES:
 665           pSocket->errno = ENOBUFS;
 666           break;
 667
 668         case EFI_UNSUPPORTED:
 669           pSocket->errno = EOPNOTSUPP;
 670           break;
 671         }
 672       }
 673       else {
 674         DEBUG (( DEBUG_TX,
 675                   "0x%08x: pPort Configured for %d.%d.%d.%d:%d --> %d.%d.%d.%d:%d\r\n",
 676                   pPort,
 677                   pConfigData->StationAddress.Addr[0],
 678                   pConfigData->StationAddress.Addr[1],
 679                   pConfigData->StationAddress.Addr[2],
 680                   pConfigData->StationAddress.Addr[3],
 681                   pConfigData->StationPort,
 682                   pConfigData->RemoteAddress.Addr[0],
 683                   pConfigData->RemoteAddress.Addr[1],
 684                   pConfigData->RemoteAddress.Addr[2],
 685                   pConfigData->RemoteAddress.Addr[3],
 686                   pConfigData->RemotePort ));
 687         pPort->bConfigured = TRUE;
 688
 689         //
 690         //  Start the first read on the port
 691         //
 692         EslSocketRxStart ( pPort );
 693
 694         //
 695         //  The socket is connected
 696         //
 697         pSocket->State = SOCKET_STATE_CONNECTED;
 698       }
 699
 700       //
 701       //  Set the next port
 702       //
 703       pPort = pNextPort;
 704     }
 705
 706     //
 707     //  Determine the configuration status
 708     //
 709     if ( NULL != pSocket->pPortList ) {
 710       pSocket->bConfigured = TRUE;
 711     }
 712   }
 713
 714   //
 715   //  Determine the socket configuration status
 716   //
 717   if ( !EFI_ERROR ( Status )) {
 718     Status = pSocket->bConfigured ? EFI_SUCCESS : EFI_NOT_STARTED;
 719   }
 720
 721   //
 722   //  Return the port connected state.
 723   //
 724   DBG_EXIT_STATUS ( Status );
 725   return Status;
 726 }
 727
 728
 729 /**
 730   Buffer data for transmission over a network connection.
 731
 732   This routine buffers data for the transmit engine in the normal
 733   data queue.  When the \ref TransmitEngine has resources, this
 734   routine will start the transmission of the next buffer on the
 735   network connection.
 736
 737   This routine is called by ::EslSocketTransmit to buffer
 738   data for transmission.  The data is copied into a local buffer
 739   freeing the application buffer for reuse upon return.  When
 740   necessary, this routine starts the transmit engine that
 741   performs the data transmission on the network connection.  The
 742   transmit engine transmits the data a packet at a time over the
 743   network connection.
 744
 745   Transmission errors are returned during the next transmission or
 746   during the close operation.  Only buffering errors are returned
 747   during the current transmission attempt.
 748
 749   @param [in] pSocket         Address of an ::ESL_SOCKET structure
 750
 751   @param [in] Flags           Message control flags
 752
 753   @param [in] BufferLength    Length of the the buffer
 754
 755   @param [in] pBuffer         Address of a buffer to receive the data.
 756
 757   @param [in] pDataLength     Number of received data bytes in the buffer.
 758
 759   @param [in] pAddress        Network address of the remote system address
 760
 761   @param [in] AddressLength   Length of the remote network address structure
 762
 763   @retval EFI_SUCCESS - Socket data successfully buffered
 764
 765 **/
 766 EFI_STATUS
 767 EslUdp4TxBuffer (
 768   IN ESL_SOCKET * pSocket,
 769   IN int Flags,
 770   IN size_t BufferLength,
 771   IN CONST UINT8 * pBuffer,
 772   OUT size_t * pDataLength,
 773   IN const struct sockaddr * pAddress,
 774   IN socklen_t AddressLength
 775   )
 776 {
 777   ESL_PACKET * pPacket;
 778   ESL_PACKET * pPreviousPacket;
 779   ESL_PORT * pPort;
 780   const struct sockaddr_in * pRemoteAddress;
 781   ESL_UDP4_CONTEXT * pUdp4;
 782   size_t * pTxBytes;
 783   ESL_UDP4_TX_DATA * pTxData;
 784   EFI_STATUS Status;
 785   EFI_TPL TplPrevious;
 786
 787   DBG_ENTER ( );
 788
 789   //
 790   //  Assume failure
 791   //
 792   Status = EFI_UNSUPPORTED;
 793   pSocket->errno = ENOTCONN;
 794   *pDataLength = 0;
 795
 796   //
 797   //  Verify that the socket is connected
 798   //
 799   if ( SOCKET_STATE_CONNECTED == pSocket->State ) {
 800     //
 801     //  Locate the port
 802     //
 803     pPort = pSocket->pPortList;
 804     if ( NULL != pPort ) {
 805       //
 806       //  Determine the queue head
 807       //
 808       pUdp4 = &pPort->Context.Udp4;
 809       pTxBytes = &pSocket->TxBytes;
 810
 811       //
 812       //  Verify that there is enough room to buffer another
 813       //  transmit operation
 814       //
 815       if ( pSocket->MaxTxBuf > *pTxBytes ) {
 816         //
 817         //  Attempt to allocate the packet
 818         //
 819         Status = EslSocketPacketAllocate ( &pPacket,
 820                                            sizeof ( pPacket->Op.Udp4Tx )
 821                                            - sizeof ( pPacket->Op.Udp4Tx.Buffer )
 822                                            + BufferLength,
 823                                            0,
 824                                            DEBUG_TX );
 825         if ( !EFI_ERROR ( Status )) {
 826           //
 827           //  Initialize the transmit operation
 828           //
 829           pTxData = &pPacket->Op.Udp4Tx;
 830           pTxData->TxData.GatewayAddress = NULL;
 831           pTxData->TxData.UdpSessionData = NULL;
 832           pTxData->TxData.DataLength = (UINT32) BufferLength;
 833           pTxData->TxData.FragmentCount = 1;
 834           pTxData->TxData.FragmentTable[0].FragmentLength = (UINT32) BufferLength;
 835           pTxData->TxData.FragmentTable[0].FragmentBuffer = &pPacket->Op.Udp4Tx.Buffer[0];
 836           pTxData->RetransmitCount = 0;
 837
 838           //
 839           //  Set the remote system address if necessary
 840           //
 841           pTxData->TxData.UdpSessionData = NULL;
 842           if ( NULL != pAddress ) {
 843             pRemoteAddress = (const struct sockaddr_in *)pAddress;
 844             pTxData->Session.SourceAddress.Addr[0] = pUdp4->ConfigData.StationAddress.Addr[0];
 845             pTxData->Session.SourceAddress.Addr[1] = pUdp4->ConfigData.StationAddress.Addr[1];
 846             pTxData->Session.SourceAddress.Addr[2] = pUdp4->ConfigData.StationAddress.Addr[2];
 847             pTxData->Session.SourceAddress.Addr[3] = pUdp4->ConfigData.StationAddress.Addr[3];
 848             pTxData->Session.SourcePort = 0;
 849             pTxData->Session.DestinationAddress.Addr[0] = (UINT8)pRemoteAddress->sin_addr.s_addr;
 850             pTxData->Session.DestinationAddress.Addr[1] = (UINT8)( pRemoteAddress->sin_addr.s_addr >> 8 );
 851             pTxData->Session.DestinationAddress.Addr[2] = (UINT8)( pRemoteAddress->sin_addr.s_addr >> 16 );
 852             pTxData->Session.DestinationAddress.Addr[3] = (UINT8)( pRemoteAddress->sin_addr.s_addr >> 24 );
 853             pTxData->Session.DestinationPort = SwapBytes16 ( pRemoteAddress->sin_port );
 854
 855             //
 856             //  Use the remote system address when sending this packet
 857             //
 858             pTxData->TxData.UdpSessionData = &pTxData->Session;
 859           }
 860
 861           //
 862           //  Copy the data into the buffer
 863           //
 864           CopyMem ( &pPacket->Op.Udp4Tx.Buffer[0],
 865                     pBuffer,
 866                     BufferLength );
 867
 868           //
 869           //  Synchronize with the socket layer
 870           //
 871           RAISE_TPL ( TplPrevious, TPL_SOCKETS );
 872
 873           //
 874           //  Stop transmission after an error
 875           //
 876           if ( !EFI_ERROR ( pSocket->TxError )) {
 877             //
 878             //  Display the request
 879             //
 880             DEBUG (( DEBUG_TX,
 881                       "Send %d %s bytes from 0x%08x\r\n",
 882                       BufferLength,
 883                       pBuffer ));
 884
 885             //
 886             //  Queue the data for transmission
 887             //
 888             pPacket->pNext = NULL;
 889             pPreviousPacket = pSocket->pTxPacketListTail;
 890             if ( NULL == pPreviousPacket ) {
 891               pSocket->pTxPacketListHead = pPacket;
 892             }
 893             else {
 894               pPreviousPacket->pNext = pPacket;
 895             }
 896             pSocket->pTxPacketListTail = pPacket;
 897             DEBUG (( DEBUG_TX,
 898                       "0x%08x: Packet on transmit list\r\n",
 899                       pPacket ));
 900
 901             //
 902             //  Account for the buffered data
 903             //
 904             *pTxBytes += BufferLength;
 905             *pDataLength = BufferLength;
 906
 907             //
 908             //  Start the transmit engine if it is idle
 909             //
 910             if ( NULL != pPort->pTxFree ) {
 911               EslSocketTxStart ( pPort,
 912                                  &pSocket->pTxPacketListHead,
 913                                  &pSocket->pTxPacketListTail,
 914                                  &pPort->pTxActive,
 915                                  &pPort->pTxFree );
 916             }
 917           }
 918           else {
 919             //
 920             //  Previous transmit error
 921             //  Stop transmission
 922             //
 923             Status = pSocket->TxError;
 924             pSocket->errno = EIO;
 925
 926             //
 927             //  Free the packet
 928             //
 929             EslSocketPacketFree ( pPacket, DEBUG_TX );
 930           }
 931
 932           //
 933           //  Release the socket layer synchronization
 934           //
 935           RESTORE_TPL ( TplPrevious );
 936         }
 937         else {
 938           //
 939           //  Packet allocation failed
 940           //
 941           pSocket->errno = ENOMEM;
 942         }
 943       }
 944       else {
 945         //
 946         //  Not enough buffer space available
 947         //
 948         pSocket->errno = EAGAIN;
 949         Status = EFI_NOT_READY;
 950       }
 951     }
 952   }
 953
 954   //
 955   //  Return the operation status
 956   //
 957   DBG_EXIT_STATUS ( Status );
 958   return Status;
 959 }
 960
 961
 962 /**
 963   Process the transmit completion
 964
 965   This routine use ::EslSocketTxComplete to perform the transmit
 966   completion processing for data packets.
 967
 968   This routine is called by the UDPv4 network layer when a data
 969   transmit request completes.
 970
 971   @param [in] Event     The normal transmit completion event
 972
 973   @param [in] pIo       Address of an ::ESL_IO_MGMT structure
 974
 975 **/
 976 VOID
 977 EslUdp4TxComplete (
 978   IN EFI_EVENT Event,
 979   IN ESL_IO_MGMT * pIo
 980   )
 981 {
 982   UINT32 LengthInBytes;
 983   ESL_PORT * pPort;
 984   ESL_PACKET * pPacket;
 985   ESL_SOCKET * pSocket;
 986   EFI_STATUS Status;
 987
 988   DBG_ENTER ( );
 989
 990   //
 991   //  Locate the active transmit packet
 992   //
 993   pPacket = pIo->pPacket;
 994   pPort = pIo->pPort;
 995   pSocket = pPort->pSocket;
 996
 997   //
 998   //  Get the transmit length and status
 999   //
1000   LengthInBytes = pPacket->Op.Udp4Tx.TxData.DataLength;
1001   pSocket->TxBytes -= LengthInBytes;
1002   Status = pIo->Token.Udp4Tx.Status;
1003
1004   //
1005   //  Complete the transmit operation
1006   //
1007   EslSocketTxComplete ( pIo,
1008                         LengthInBytes,
1009                         Status,
1010                         "UDP ",
1011                         &pSocket->pTxPacketListHead,
1012                         &pSocket->pTxPacketListTail,
1013                         &pPort->pTxActive,
1014                         &pPort->pTxFree );
1015   DBG_EXIT ( );
1016 }
1017
1018
1019 /**
1020   Interface between the socket layer and the network specific
1021   code that supports SOCK_DGRAM sockets over UDPv4.
1022 **/
1023 CONST ESL_PROTOCOL_API cEslUdp4Api = {
1024   "UDPv4",
1025   IPPROTO_UDP,
1026   OFFSET_OF ( ESL_PORT, Context.Udp4.ConfigData ),
1027   OFFSET_OF ( ESL_LAYER, pUdp4List ),
1028   OFFSET_OF ( struct sockaddr_in, sin_zero ),
1029   sizeof ( struct sockaddr_in ),
1030   AF_INET,
1031   sizeof (((ESL_PACKET *)0 )->Op.Udp4Rx ),
1032   sizeof (((ESL_PACKET *)0 )->Op.Udp4Rx ),
1033   OFFSET_OF ( ESL_IO_MGMT, Token.Udp4Rx.Packet.RxData ),
1034   FALSE,
1035   EADDRINUSE,
1036   NULL,   //  Accept
1037   NULL,   //  ConnectPoll
1038   NULL,   //  ConnectStart
1039   EslUdp4SocketIsConfigured,
1040   EslUdp4LocalAddressGet,
1041   EslUdp4LocalAddressSet,
1042   NULL,   //  Listen
1043   NULL,   //  OptionGet
1044   NULL,   //  OptionSet
1045   EslUdp4PacketFree,
1046   EslUdp4PortAllocate,
1047   NULL,   //  PortClose,
1048   NULL,   //  PortCloseOp
1049   TRUE,
1050   EslUdp4Receive,
1051   EslUdp4RemoteAddressGet,
1052   EslUdp4RemoteAddressSet,
1053   EslUdp4RxComplete,
1054   NULL,   //  RxStart
1055   EslUdp4TxBuffer,
1056   EslUdp4TxComplete,
1057   NULL    //  TxOobComplete
1058 };