StdLib/EfiSocketLib/Ip4.c

   1 /** @file
   2   Implement the IP4 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 associated with the local
  22   socket.
  23
  24   This routine is called by ::EslSocketGetLocalAddress to determine the
  25   network address for the SOCK_RAW socket.
  26
  27   @param [in] pPort       Address of an ::ESL_PORT structure.
  28
  29   @param [out] pAddress   Network address to receive the local system address
  30
  31 **/
  32 VOID
  33 EslIp4LocalAddressGet (
  34   IN ESL_PORT * pPort,
  35   OUT struct sockaddr * pAddress
  36   )
  37 {
  38   struct sockaddr_in * pLocalAddress;
  39   ESL_IP4_CONTEXT * pIp4;
  40
  41   DBG_ENTER ( );
  42
  43   //
  44   //  Return the local address
  45   //
  46   pIp4 = &pPort->Context.Ip4;
  47   pLocalAddress = (struct sockaddr_in *)pAddress;
  48   pLocalAddress->sin_family = AF_INET;
  49   CopyMem ( &pLocalAddress->sin_addr,
  50             &pIp4->ModeData.ConfigData.StationAddress.Addr[0],
  51             sizeof ( pLocalAddress->sin_addr ));
  52
  53   DBG_EXIT ( );
  54 }
  55
  56
  57 /**
  58   Set the local port address.
  59
  60   This routine sets the local port address.
  61
  62   This support routine is called by ::EslSocketPortAllocate.
  63
  64   @param [in] pPort       Address of an ESL_PORT structure
  65   @param [in] pSockAddr   Address of a sockaddr structure that contains the
  66                           connection point on the local machine.  An IPv4 address
  67                           of INADDR_ANY specifies that the connection is made to
  68                           all of the network stacks on the platform.  Specifying a
  69                           specific IPv4 address restricts the connection to the
  70                           network stack supporting that address.  Specifying zero
  71                           for the port causes the network layer to assign a port
  72                           number from the dynamic range.  Specifying a specific
  73                           port number causes the network layer to use that port.
  74
  75   @param [in] bBindTest   TRUE = run bind testing
  76
  77   @retval EFI_SUCCESS     The operation was successful
  78
  79  **/
  80 EFI_STATUS
  81 EslIp4LocalAddressSet (
  82   IN ESL_PORT * pPort,
  83   IN CONST struct sockaddr * pSockAddr,
  84   IN BOOLEAN bBindTest
  85   )
  86 {
  87   EFI_IP4_CONFIG_DATA * pConfig;
  88   CONST struct sockaddr_in * pIpAddress;
  89   CONST UINT8 * pIpv4Address;
  90   EFI_STATUS Status;
  91
  92   DBG_ENTER ( );
  93
  94   //
  95   //  Validate the address
  96   //
  97   pIpAddress = (struct sockaddr_in *)pSockAddr;
  98   if ( INADDR_BROADCAST == pIpAddress->sin_addr.s_addr ) {
  99     //
 100     //  The local address must not be the broadcast address
 101     //
 102     Status = EFI_INVALID_PARAMETER;
 103     pPort->pSocket->errno = EADDRNOTAVAIL;
 104   }
 105   else {
 106     Status = EFI_SUCCESS;
 107
 108     //
 109     //  Set the local address
 110     //
 111     pIpAddress = (struct sockaddr_in *)pSockAddr;
 112     pIpv4Address = (UINT8 *)&pIpAddress->sin_addr.s_addr;
 113     pConfig = &pPort->Context.Ip4.ModeData.ConfigData;
 114     pConfig->StationAddress.Addr[0] = pIpv4Address[0];
 115     pConfig->StationAddress.Addr[1] = pIpv4Address[1];
 116     pConfig->StationAddress.Addr[2] = pIpv4Address[2];
 117     pConfig->StationAddress.Addr[3] = pIpv4Address[3];
 118
 119     //
 120     //  Determine if the default address is used
 121     //
 122     pConfig->UseDefaultAddress = (BOOLEAN)( 0 == pIpAddress->sin_addr.s_addr );
 123
 124     //
 125     //  Display the local address
 126     //
 127     DEBUG (( DEBUG_BIND,
 128               "0x%08x: Port, Local IP4 Address: %d.%d.%d.%d\r\n",
 129               pPort,
 130               pConfig->StationAddress.Addr[0],
 131               pConfig->StationAddress.Addr[1],
 132               pConfig->StationAddress.Addr[2],
 133               pConfig->StationAddress.Addr[3]));
 134
 135     //
 136     //  Set the subnet mask
 137     //
 138     if ( pConfig->UseDefaultAddress ) {
 139       pConfig->SubnetMask.Addr[0] = 0;
 140       pConfig->SubnetMask.Addr[1] = 0;
 141       pConfig->SubnetMask.Addr[2] = 0;
 142       pConfig->SubnetMask.Addr[3] = 0;
 143     }
 144     else {
 145       pConfig->SubnetMask.Addr[0] = 0xff;
 146       pConfig->SubnetMask.Addr[1] = 0xff;
 147       pConfig->SubnetMask.Addr[2] = 0xff;
 148       pConfig->SubnetMask.Addr[3] = 0xff;
 149     }
 150   }
 151
 152   //
 153   //  Return the operation status
 154   //
 155   DBG_EXIT_STATUS ( Status );
 156   return Status;
 157 }
 158
 159
 160 /**
 161   Get the option value
 162
 163   This routine handles the IPv4 level options.
 164
 165   The ::EslSocketOptionGet routine calls this routine to retrieve
 166   the IPv4 options one at a time by name.
 167
 168   @param [in] pSocket           Address of an ::ESL_SOCKET structure
 169   @param [in] OptionName        Name of the option
 170   @param [out] ppOptionData     Buffer to receive address of option value
 171   @param [out] pOptionLength    Buffer to receive the option length
 172
 173   @retval EFI_SUCCESS - Socket data successfully received
 174
 175  **/
 176 EFI_STATUS
 177 EslIp4OptionGet (
 178   IN ESL_SOCKET * pSocket,
 179   IN int OptionName,
 180   OUT CONST void ** __restrict ppOptionData,
 181   OUT socklen_t * __restrict pOptionLength
 182   )
 183 {
 184   EFI_STATUS Status;
 185
 186   DBG_ENTER ( );
 187
 188   //
 189   //  Assume success
 190   //
 191   pSocket->errno = 0;
 192   Status = EFI_SUCCESS;
 193
 194   //
 195   //  Attempt to get the option
 196   //
 197   switch ( OptionName ) {
 198   default:
 199     //
 200     //  Option not supported
 201     //
 202     pSocket->errno = ENOPROTOOPT;
 203     Status = EFI_INVALID_PARAMETER;
 204     break;
 205
 206   case IP_HDRINCL:
 207     *ppOptionData = (void *)&pSocket->bIncludeHeader;
 208     *pOptionLength = sizeof ( pSocket->bIncludeHeader );
 209     break;
 210   }
 211
 212   //
 213   //  Return the operation status
 214   //
 215   DBG_EXIT_STATUS ( Status );
 216   return Status;
 217 }
 218
 219
 220 /**
 221   Set the option value
 222
 223   This routine handles the IPv4 level options.
 224
 225   The ::EslSocketOptionSet routine calls this routine to adjust
 226   the IPv4 options one at a time by name.
 227
 228   @param [in] pSocket         Address of an ::ESL_SOCKET structure
 229   @param [in] OptionName      Name of the option
 230   @param [in] pOptionValue    Buffer containing the option value
 231   @param [in] OptionLength    Length of the buffer in bytes
 232
 233   @retval EFI_SUCCESS - Option successfully set
 234
 235  **/
 236 EFI_STATUS
 237 EslIp4OptionSet (
 238   IN ESL_SOCKET * pSocket,
 239   IN int OptionName,
 240   IN CONST void * pOptionValue,
 241   IN socklen_t OptionLength
 242   )
 243 {
 244   BOOLEAN bTrueFalse;
 245   socklen_t LengthInBytes;
 246   UINT8 * pOptionData;
 247   EFI_STATUS Status;
 248
 249   DBG_ENTER ( );
 250
 251   //
 252   //  Assume success
 253   //
 254   pSocket->errno = 0;
 255   Status = EFI_SUCCESS;
 256
 257   //
 258   //  Determine if the option protocol matches
 259   //
 260   LengthInBytes = 0;
 261   pOptionData = NULL;
 262   switch ( OptionName ) {
 263   default:
 264     //
 265     //  Protocol level not supported
 266     //
 267     DEBUG (( DEBUG_INFO | DEBUG_OPTION, "ERROR - Invalid protocol option\r\n" ));
 268     pSocket->errno = ENOTSUP;
 269     Status = EFI_UNSUPPORTED;
 270     break;
 271
 272   case IP_HDRINCL:
 273
 274     //
 275     //  Validate the option length
 276     //
 277     if ( sizeof ( UINT32 ) == OptionLength ) {
 278       //
 279       //  Restrict the input to TRUE or FALSE
 280       //
 281       bTrueFalse = TRUE;
 282       if ( 0 == *(UINT32 *)pOptionValue ) {
 283         bTrueFalse = FALSE;
 284       }
 285       pOptionValue = &bTrueFalse;
 286
 287       //
 288       //  Set the option value
 289       //
 290       pOptionData = (UINT8 *)&pSocket->bIncludeHeader;
 291       LengthInBytes = sizeof ( pSocket->bIncludeHeader );
 292     }
 293     break;
 294   }
 295
 296   //
 297   //  Return the operation status
 298   //
 299   DBG_EXIT_STATUS ( Status );
 300   return Status;
 301 }
 302
 303
 304 /**
 305   Free a receive packet
 306
 307   This routine performs the network specific operations necessary
 308   to free a receive packet.
 309
 310   This routine is called by ::EslSocketPortCloseTxDone to free a
 311   receive packet.
 312
 313   @param [in] pPacket         Address of an ::ESL_PACKET structure.
 314   @param [in, out] pRxBytes   Address of the count of RX bytes
 315
 316 **/
 317 VOID
 318 EslIp4PacketFree (
 319   IN ESL_PACKET * pPacket,
 320   IN OUT size_t * pRxBytes
 321   )
 322 {
 323   EFI_IP4_RECEIVE_DATA * pRxData;
 324   DBG_ENTER ( );
 325
 326   //
 327   //  Account for the receive bytes
 328   //
 329   pRxData = pPacket->Op.Ip4Rx.pRxData;
 330   *pRxBytes -= pRxData->HeaderLength + pRxData->DataLength;
 331
 332   //
 333   //  Disconnect the buffer from the packet
 334   //
 335   pPacket->Op.Ip4Rx.pRxData = NULL;
 336
 337   //
 338   //  Return the buffer to the IP4 driver
 339   //
 340   gBS->SignalEvent ( pRxData->RecycleSignal );
 341   DBG_EXIT ( );
 342 }
 343
 344
 345 /**
 346   Initialize the network specific portions of an ::ESL_PORT structure.
 347
 348   This routine initializes the network specific portions of an
 349   ::ESL_PORT structure for use by the socket.
 350
 351   This support routine is called by ::EslSocketPortAllocate
 352   to connect the socket with the underlying network adapter
 353   running the IPv4 protocol.
 354
 355   @param [in] pPort       Address of an ESL_PORT structure
 356   @param [in] DebugFlags  Flags for debug messages
 357
 358   @retval EFI_SUCCESS - Socket successfully created
 359
 360  **/
 361 EFI_STATUS
 362 EslIp4PortAllocate (
 363   IN ESL_PORT * pPort,
 364   IN UINTN DebugFlags
 365   )
 366 {
 367   EFI_IP4_CONFIG_DATA * pConfig;
 368   ESL_SOCKET * pSocket;
 369   EFI_STATUS Status;
 370
 371   DBG_ENTER ( );
 372
 373   //
 374   //  Initialize the port
 375   //
 376   pSocket = pPort->pSocket;
 377   pSocket->TxPacketOffset = OFFSET_OF ( ESL_PACKET, Op.Ip4Tx.TxData );
 378   pSocket->TxTokenEventOffset = OFFSET_OF ( ESL_IO_MGMT, Token.Ip4Tx.Event );
 379   pSocket->TxTokenOffset = OFFSET_OF ( EFI_IP4_COMPLETION_TOKEN, Packet.TxData );
 380
 381   //
 382   //  Save the cancel, receive and transmit addresses
 383   //
 384   pPort->pfnConfigure = (PFN_NET_CONFIGURE)pPort->pProtocol.IPv4->Configure;
 385   pPort->pfnRxCancel = (PFN_NET_IO_START)pPort->pProtocol.IPv4->Cancel;
 386   pPort->pfnRxPoll = (PFN_NET_POLL)pPort->pProtocol.IPv4->Poll;
 387   pPort->pfnRxStart = (PFN_NET_IO_START)pPort->pProtocol.IPv4->Receive;
 388   pPort->pfnTxStart = (PFN_NET_IO_START)pPort->pProtocol.IPv4->Transmit;
 389
 390   //
 391   //  Set the configuration flags
 392   //
 393   pConfig = &pPort->Context.Ip4.ModeData.ConfigData;
 394   pConfig->AcceptIcmpErrors = FALSE;
 395   pConfig->AcceptBroadcast = FALSE;
 396   pConfig->AcceptPromiscuous = FALSE;
 397   pConfig->TypeOfService = 0;
 398   pConfig->TimeToLive = 255;
 399   pConfig->DoNotFragment = FALSE;
 400   pConfig->RawData = FALSE;
 401   pConfig->ReceiveTimeout = 0;
 402   pConfig->TransmitTimeout = 0;
 403
 404   //
 405   //  Set the default protocol
 406   //
 407   pConfig->DefaultProtocol = (UINT8)pSocket->Protocol;
 408   pConfig->AcceptAnyProtocol = (BOOLEAN)( 0 == pConfig->DefaultProtocol );
 409   Status = EFI_SUCCESS;
 410
 411   //
 412   //  Return the operation status
 413   //
 414   DBG_EXIT_STATUS ( Status );
 415   return Status;
 416 }
 417
 418
 419 /**
 420   Receive data from a network connection.
 421
 422   This routine attempts to return buffered data to the caller.  The
 423   data is removed from the urgent queue if the message flag MSG_OOB
 424   is specified, otherwise data is removed from the normal queue.
 425   See the \ref ReceiveEngine section.
 426
 427   This routine is called by ::EslSocketReceive to handle the network
 428   specific receive operation to support SOCK_RAW sockets.
 429
 430   @param [in] pPort           Address of an ::ESL_PORT structure.
 431
 432   @param [in] pPacket         Address of an ::ESL_PACKET structure.
 433
 434   @param [in] pbConsumePacket Address of a BOOLEAN indicating if the packet is to be consumed
 435
 436   @param [in] BufferLength    Length of the the buffer
 437
 438   @param [in] pBuffer         Address of a buffer to receive the data.
 439
 440   @param [in] pDataLength     Number of received data bytes in the buffer.
 441
 442   @param [out] pAddress       Network address to receive the remote system address
 443
 444   @param [out] pSkipBytes     Address to receive the number of bytes skipped
 445
 446   @return   Returns the address of the next free byte in the buffer.
 447
 448  **/
 449 UINT8 *
 450 EslIp4Receive (
 451   IN ESL_PORT * pPort,
 452   IN ESL_PACKET * pPacket,
 453   IN BOOLEAN * pbConsumePacket,
 454   IN size_t BufferLength,
 455   IN UINT8 * pBuffer,
 456   OUT size_t * pDataLength,
 457   OUT struct sockaddr * pAddress,
 458   OUT size_t * pSkipBytes
 459   )
 460 {
 461   size_t DataBytes;
 462   size_t HeaderBytes;
 463   size_t LengthInBytes;
 464   struct sockaddr_in * pRemoteAddress;
 465   EFI_IP4_RECEIVE_DATA * pRxData;
 466
 467   DBG_ENTER ( );
 468
 469   //
 470   //  Return the remote system address if requested
 471   //
 472   pRxData = pPacket->Op.Ip4Rx.pRxData;
 473   if ( NULL != pAddress ) {
 474     //
 475     //  Build the remote address
 476     //
 477     DEBUG (( DEBUG_RX,
 478               "Getting packet remote address: %d.%d.%d.%d\r\n",
 479               pRxData->Header->SourceAddress.Addr[0],
 480               pRxData->Header->SourceAddress.Addr[1],
 481               pRxData->Header->SourceAddress.Addr[2],
 482               pRxData->Header->SourceAddress.Addr[3]));
 483     pRemoteAddress = (struct sockaddr_in *)pAddress;
 484     CopyMem ( &pRemoteAddress->sin_addr,
 485               &pRxData->Header->SourceAddress.Addr[0],
 486               sizeof ( pRemoteAddress->sin_addr ));
 487   }
 488
 489   //
 490   //  Copy the IP header
 491   //
 492   HeaderBytes = pRxData->HeaderLength;
 493   if ( HeaderBytes > BufferLength ) {
 494     HeaderBytes = BufferLength;
 495   }
 496   DEBUG (( DEBUG_RX,
 497             "0x%08x --> 0x%08x: Copy header 0x%08x bytes\r\n",
 498             pRxData->Header,
 499             pBuffer,
 500             HeaderBytes ));
 501   CopyMem ( pBuffer, pRxData->Header, HeaderBytes );
 502   pBuffer += HeaderBytes;
 503   LengthInBytes = HeaderBytes;
 504
 505   //
 506   //  Copy the received data
 507   //
 508   if ( 0 < ( BufferLength - LengthInBytes )) {
 509     pBuffer = EslSocketCopyFragmentedBuffer ( pRxData->FragmentCount,
 510                                               &pRxData->FragmentTable[0],
 511                                               BufferLength - LengthInBytes,
 512                                               pBuffer,
 513                                               &DataBytes );
 514     LengthInBytes += DataBytes;
 515   }
 516
 517   //
 518   //  Determine if the data is being read
 519   //
 520   if ( *pbConsumePacket ) {
 521     //
 522     //  Display for the bytes consumed
 523     //
 524     DEBUG (( DEBUG_RX,
 525               "0x%08x: Port account for 0x%08x bytes\r\n",
 526               pPort,
 527               LengthInBytes ));
 528
 529     //
 530     //  Account for any discarded data
 531     //
 532     *pSkipBytes = pRxData->HeaderLength + pRxData->DataLength - LengthInBytes;
 533   }
 534
 535   //
 536   //  Return the data length and the buffer address
 537   //
 538   *pDataLength = LengthInBytes;
 539   DBG_EXIT_HEX ( pBuffer );
 540   return pBuffer;
 541 }
 542
 543
 544 /**
 545   Get the remote socket address
 546
 547   This routine returns the address of the remote connection point
 548   associated with the SOCK_RAW socket.
 549
 550   This routine is called by ::EslSocketGetPeerAddress to detemine
 551   the IPv4 address associated with the network adapter.
 552
 553   @param [in] pPort       Address of an ::ESL_PORT structure.
 554
 555   @param [out] pAddress   Network address to receive the remote system address
 556
 557 **/
 558 VOID
 559 EslIp4RemoteAddressGet (
 560   IN ESL_PORT * pPort,
 561   OUT struct sockaddr * pAddress
 562   )
 563 {
 564   struct sockaddr_in * pRemoteAddress;
 565   ESL_IP4_CONTEXT * pIp4;
 566
 567   DBG_ENTER ( );
 568
 569   //
 570   //  Return the remote address
 571   //
 572   pIp4 = &pPort->Context.Ip4;
 573   pRemoteAddress = (struct sockaddr_in *)pAddress;
 574   pRemoteAddress->sin_family = AF_INET;
 575   CopyMem ( &pRemoteAddress->sin_addr,
 576             &pIp4->DestinationAddress.Addr[0],
 577             sizeof ( pRemoteAddress->sin_addr ));
 578
 579   DBG_EXIT ( );
 580 }
 581
 582
 583 /**
 584   Set the remote address
 585
 586   This routine sets the remote address in the port.
 587
 588   This routine is called by ::EslSocketConnect to specify the
 589   remote network address.
 590
 591   @param [in] pPort           Address of an ::ESL_PORT structure.
 592
 593   @param [in] pSockAddr       Network address of the remote system.
 594
 595   @param [in] SockAddrLength  Length in bytes of the network address.
 596
 597   @retval EFI_SUCCESS     The operation was successful
 598
 599  **/
 600 EFI_STATUS
 601 EslIp4RemoteAddressSet (
 602   IN ESL_PORT * pPort,
 603   IN CONST struct sockaddr * pSockAddr,
 604   IN socklen_t SockAddrLength
 605   )
 606 {
 607   ESL_IP4_CONTEXT * pIp4;
 608   CONST struct sockaddr_in * pRemoteAddress;
 609   EFI_STATUS Status;
 610
 611   DBG_ENTER ( );
 612
 613   //
 614   //  Set the remote address
 615   //
 616   pIp4 = &pPort->Context.Ip4;
 617   pRemoteAddress = (struct sockaddr_in *)pSockAddr;
 618   pIp4->DestinationAddress.Addr[0] = (UINT8)( pRemoteAddress->sin_addr.s_addr );
 619   pIp4->DestinationAddress.Addr[1] = (UINT8)( pRemoteAddress->sin_addr.s_addr >> 8 );
 620   pIp4->DestinationAddress.Addr[2] = (UINT8)( pRemoteAddress->sin_addr.s_addr >> 16 );
 621   pIp4->DestinationAddress.Addr[3] = (UINT8)( pRemoteAddress->sin_addr.s_addr >> 24 );
 622   pPort->pSocket->bAddressSet = TRUE;
 623   Status = EFI_SUCCESS;
 624
 625   //
 626   //  Return the operation status
 627   //
 628   DBG_EXIT_STATUS ( Status );
 629   return Status;
 630 }
 631
 632
 633 /**
 634   Process the receive completion
 635
 636   This routine keeps the IPv4 driver's buffer and queues it in
 637   in FIFO order to the data queue.  The IP4 driver's buffer will
 638   be returned by either ::EslIp4Receive or ::EslSocketPortCloseTxDone.
 639   See the \ref ReceiveEngine section.
 640
 641   This routine is called by the IPv4 driver when data is
 642   received.
 643
 644   @param [in] Event     The receive completion event
 645
 646   @param [in] pIo       The address of an ::ESL_IO_MGMT structure
 647
 648 **/
 649 VOID
 650 EslIp4RxComplete (
 651   IN EFI_EVENT Event,
 652   IN ESL_IO_MGMT * pIo
 653   )
 654 {
 655   size_t LengthInBytes;
 656   ESL_PORT * pPort;
 657   ESL_PACKET * pPacket;
 658   EFI_IP4_RECEIVE_DATA * pRxData;
 659   EFI_STATUS Status;
 660
 661   DBG_ENTER ( );
 662
 663   //
 664   //  Get the operation status.
 665   //
 666   pPort = pIo->pPort;
 667   Status = pIo->Token.Ip4Rx.Status;
 668
 669   //
 670   //  Get the packet length
 671   //
 672   pRxData = pIo->Token.Ip4Rx.Packet.RxData;
 673   LengthInBytes = pRxData->HeaderLength + pRxData->DataLength;
 674
 675   //
 676   //      +--------------------+   +----------------------+
 677   //      | ESL_IO_MGMT        |   |      Data Buffer     |
 678   //      |                    |   |     (Driver owned)   |
 679   //      |    +---------------+   +----------------------+
 680   //      |    | Token         |               ^
 681   //      |    |      Rx Event |               |
 682   //      |    |               |   +----------------------+
 683   //      |    |        RxData --> | EFI_IP4_RECEIVE_DATA |
 684   //      +----+---------------+   |    (Driver owned)    |
 685   //                               +----------------------+
 686   //      +--------------------+               ^
 687   //      | ESL_PACKET         |               .
 688   //      |                    |               .
 689   //      |    +---------------+               .
 690   //      |    |       pRxData --> NULL  .......
 691   //      +----+---------------+
 692   //
 693   //
 694   //  Save the data in the packet
 695   //
 696   pPacket = pIo->pPacket;
 697   pPacket->Op.Ip4Rx.pRxData = pRxData;
 698
 699   //
 700   //  Complete this request
 701   //
 702   EslSocketRxComplete ( pIo, Status, LengthInBytes, FALSE );
 703   DBG_EXIT ( );
 704 }
 705
 706
 707 /**
 708   Determine if the socket is configured.
 709
 710   This routine uses the flag ESL_SOCKET::bConfigured to determine
 711   if the network layer's configuration routine has been called.
 712   This routine calls the ::EslSocketBind and configuration routines
 713   if they were not already called.  After the port is configured,
 714   the \ref ReceiveEngine is started.
 715
 716   This routine is called by EslSocketIsConfigured to verify
 717   that the socket is configured.
 718
 719   @param [in] pSocket         Address of an ::ESL_SOCKET structure
 720
 721   @retval EFI_SUCCESS - The port is connected
 722   @retval EFI_NOT_STARTED - The port is not connected
 723
 724  **/
 725  EFI_STATUS
 726  EslIp4SocketIsConfigured (
 727   IN ESL_SOCKET * pSocket
 728   )
 729 {
 730   UINTN Index;
 731   ESL_PORT * pPort;
 732   ESL_PORT * pNextPort;
 733   ESL_IP4_CONTEXT * pIp4;
 734   EFI_IP4_PROTOCOL * pIp4Protocol;
 735   EFI_STATUS Status;
 736   struct sockaddr_in LocalAddress;
 737
 738   DBG_ENTER ( );
 739
 740   //
 741   //  Assume success
 742   //
 743   Status = EFI_SUCCESS;
 744
 745   //
 746   //  Configure the port if necessary
 747   //
 748   if ( !pSocket->bConfigured ) {
 749     //
 750     //  Fill in the port list if necessary
 751     //
 752     if ( NULL == pSocket->pPortList ) {
 753       LocalAddress.sin_len = sizeof ( LocalAddress );
 754       LocalAddress.sin_family = AF_INET;
 755       LocalAddress.sin_addr.s_addr = 0;
 756       LocalAddress.sin_port = 0;
 757       Status = EslSocketBind ( &pSocket->SocketProtocol,
 758                                (struct sockaddr *)&LocalAddress,
 759                                LocalAddress.sin_len,
 760                                &pSocket->errno );
 761     }
 762
 763     //
 764     //  Walk the port list
 765     //
 766     pPort = pSocket->pPortList;
 767     while ( NULL != pPort ) {
 768       //
 769       //  Update the raw setting
 770       //
 771       pIp4 = &pPort->Context.Ip4;
 772       if ( pSocket->bIncludeHeader ) {
 773         //
 774         //  IP header will be included with the data on transmit
 775         //
 776         pIp4->ModeData.ConfigData.RawData = TRUE;
 777       }
 778
 779       //
 780       //  Attempt to configure the port
 781       //
 782       pNextPort = pPort->pLinkSocket;
 783       pIp4Protocol = pPort->pProtocol.IPv4;
 784       DEBUG (( DEBUG_TX,
 785                 "0x%08x: pPort Configuring for %d.%d.%d.%d --> %d.%d.%d.%d\r\n",
 786                           pPort,
 787                           pIp4->ModeData.ConfigData.StationAddress.Addr[0],
 788                           pIp4->ModeData.ConfigData.StationAddress.Addr[1],
 789                           pIp4->ModeData.ConfigData.StationAddress.Addr[2],
 790                           pIp4->ModeData.ConfigData.StationAddress.Addr[3],
 791                           pIp4->DestinationAddress.Addr[0],
 792                           pIp4->DestinationAddress.Addr[1],
 793                           pIp4->DestinationAddress.Addr[2],
 794                           pIp4->DestinationAddress.Addr[3]));
 795       Status = pIp4Protocol->Configure ( pIp4Protocol,
 796                                           &pIp4->ModeData.ConfigData );
 797       if ( !EFI_ERROR ( Status )) {
 798         //
 799         //  Update the configuration data
 800         //
 801         Status = pIp4Protocol->GetModeData ( pIp4Protocol,
 802                                              &pIp4->ModeData,
 803                                              NULL,
 804                                              NULL );
 805       }
 806       if ( EFI_ERROR ( Status )) {
 807         DEBUG (( DEBUG_LISTEN,
 808                   "ERROR - Failed to configure the Ip4 port, Status: %r\r\n",
 809                   Status ));
 810         switch ( Status ) {
 811         case EFI_ACCESS_DENIED:
 812           pSocket->errno = EACCES;
 813           break;
 814
 815         default:
 816         case EFI_DEVICE_ERROR:
 817           pSocket->errno = EIO;
 818           break;
 819
 820         case EFI_INVALID_PARAMETER:
 821           pSocket->errno = EADDRNOTAVAIL;
 822           break;
 823
 824         case EFI_NO_MAPPING:
 825           pSocket->errno = EAFNOSUPPORT;
 826           break;
 827
 828         case EFI_OUT_OF_RESOURCES:
 829           pSocket->errno = ENOBUFS;
 830           break;
 831
 832         case EFI_UNSUPPORTED:
 833           pSocket->errno = EOPNOTSUPP;
 834           break;
 835         }
 836       }
 837       else {
 838         DEBUG (( DEBUG_TX,
 839                   "0x%08x: pPort Configured for %d.%d.%d.%d --> %d.%d.%d.%d\r\n",
 840                   pPort,
 841                   pIp4->ModeData.ConfigData.StationAddress.Addr[0],
 842                   pIp4->ModeData.ConfigData.StationAddress.Addr[1],
 843                   pIp4->ModeData.ConfigData.StationAddress.Addr[2],
 844                   pIp4->ModeData.ConfigData.StationAddress.Addr[3],
 845                   pIp4->DestinationAddress.Addr[0],
 846                   pIp4->DestinationAddress.Addr[1],
 847                   pIp4->DestinationAddress.Addr[2],
 848                   pIp4->DestinationAddress.Addr[3]));
 849         DEBUG (( DEBUG_TX,
 850                   "Subnet Mask: %d.%d.%d.%d\r\n",
 851                   pIp4->ModeData.ConfigData.SubnetMask.Addr[0],
 852                   pIp4->ModeData.ConfigData.SubnetMask.Addr[1],
 853                   pIp4->ModeData.ConfigData.SubnetMask.Addr[2],
 854                   pIp4->ModeData.ConfigData.SubnetMask.Addr[3]));
 855         DEBUG (( DEBUG_TX,
 856                   "Route Count: %d\r\n",
 857                   pIp4->ModeData.RouteCount ));
 858         for ( Index = 0; pIp4->ModeData.RouteCount > Index; Index++ ) {
 859           if ( 0 == Index ) {
 860             DEBUG (( DEBUG_TX, "Route Table:\r\n" ));
 861           }
 862           DEBUG (( DEBUG_TX,
 863                     "%5d: %d.%d.%d.%d, %d.%d.%d.%d ==> %d.%d.%d.%d\r\n",
 864                     Index,
 865                     pIp4->ModeData.RouteTable[Index].SubnetAddress.Addr[0],
 866                     pIp4->ModeData.RouteTable[Index].SubnetAddress.Addr[1],
 867                     pIp4->ModeData.RouteTable[Index].SubnetAddress.Addr[2],
 868                     pIp4->ModeData.RouteTable[Index].SubnetAddress.Addr[3],
 869                     pIp4->ModeData.RouteTable[Index].SubnetMask.Addr[0],
 870                     pIp4->ModeData.RouteTable[Index].SubnetMask.Addr[1],
 871                     pIp4->ModeData.RouteTable[Index].SubnetMask.Addr[2],
 872                     pIp4->ModeData.RouteTable[Index].SubnetMask.Addr[3],
 873                     pIp4->ModeData.RouteTable[Index].GatewayAddress.Addr[0],
 874                     pIp4->ModeData.RouteTable[Index].GatewayAddress.Addr[1],
 875                     pIp4->ModeData.RouteTable[Index].GatewayAddress.Addr[2],
 876                     pIp4->ModeData.RouteTable[Index].GatewayAddress.Addr[3]));
 877         }
 878         pPort->bConfigured = TRUE;
 879
 880         //
 881         //  Start the first read on the port
 882         //
 883         EslSocketRxStart ( pPort );
 884
 885         //
 886         //  The socket is connected
 887         //
 888         pSocket->State = SOCKET_STATE_CONNECTED;
 889       }
 890
 891       //
 892       //  Set the next port
 893       //
 894       pPort = pNextPort;
 895     }
 896
 897     //
 898     //  Determine the configuration status
 899     //
 900     if ( NULL != pSocket->pPortList ) {
 901       pSocket->bConfigured = TRUE;
 902     }
 903   }
 904
 905   //
 906   //  Determine the socket configuration status
 907   //
 908   if ( !EFI_ERROR ( Status )) {
 909     Status = pSocket->bConfigured ? EFI_SUCCESS : EFI_NOT_STARTED;
 910   }
 911
 912   //
 913   //  Return the port connected state.
 914   //
 915   DBG_EXIT_STATUS ( Status );
 916   return Status;
 917 }
 918
 919
 920 /**
 921   Buffer data for transmission over a network connection.
 922
 923   This routine buffers data for the transmit engine in the normal
 924   data queue.  When the \ref TransmitEngine has resources, this
 925   routine will start the transmission of the next buffer on the
 926   network connection.
 927
 928   This routine is called by ::EslSocketTransmit to buffer
 929   data for transmission.  The data is copied into a local buffer
 930   freeing the application buffer for reuse upon return.  When
 931   necessary, this routine starts the transmit engine that
 932   performs the data transmission on the network connection.  The
 933   transmit engine transmits the data a packet at a time over the
 934   network connection.
 935
 936   Transmission errors are returned during the next transmission or
 937   during the close operation.  Only buffering errors are returned
 938   during the current transmission attempt.
 939
 940   @param [in] pSocket         Address of an ::ESL_SOCKET structure
 941
 942   @param [in] Flags           Message control flags
 943
 944   @param [in] BufferLength    Length of the the buffer
 945
 946   @param [in] pBuffer         Address of a buffer to receive the data.
 947
 948   @param [in] pDataLength     Number of received data bytes in the buffer.
 949
 950   @param [in] pAddress        Network address of the remote system address
 951
 952   @param [in] AddressLength   Length of the remote network address structure
 953
 954   @retval EFI_SUCCESS - Socket data successfully buffered
 955
 956 **/
 957 EFI_STATUS
 958 EslIp4TxBuffer (
 959   IN ESL_SOCKET * pSocket,
 960   IN int Flags,
 961   IN size_t BufferLength,
 962   IN CONST UINT8 * pBuffer,
 963   OUT size_t * pDataLength,
 964   IN const struct sockaddr * pAddress,
 965   IN socklen_t AddressLength
 966   )
 967 {
 968   ESL_PACKET * pPacket;
 969   ESL_PACKET * pPreviousPacket;
 970   ESL_PORT * pPort;
 971   const struct sockaddr_in * pRemoteAddress;
 972   ESL_IP4_CONTEXT * pIp4;
 973   size_t * pTxBytes;
 974   ESL_IP4_TX_DATA * pTxData;
 975   EFI_STATUS Status;
 976   EFI_TPL TplPrevious;
 977
 978   DBG_ENTER ( );
 979
 980   //
 981   //  Assume failure
 982   //
 983   Status = EFI_UNSUPPORTED;
 984   pSocket->errno = ENOTCONN;
 985   *pDataLength = 0;
 986
 987   //
 988   //  Verify that the socket is connected
 989   //
 990   if ( SOCKET_STATE_CONNECTED == pSocket->State ) {
 991     //
 992     //  Locate the port
 993     //
 994     pPort = pSocket->pPortList;
 995     if ( NULL != pPort ) {
 996       //
 997       //  Determine the queue head
 998       //
 999       pIp4 = &pPort->Context.Ip4;
1000       pTxBytes = &pSocket->TxBytes;
1001
1002       //
1003       //  Verify that there is enough room to buffer another
1004       //  transmit operation
1005       //
1006       if ( pSocket->MaxTxBuf > *pTxBytes ) {
1007         //
1008         //  Attempt to allocate the packet
1009         //
1010         Status = EslSocketPacketAllocate ( &pPacket,
1011                                            sizeof ( pPacket->Op.Ip4Tx )
1012                                            - sizeof ( pPacket->Op.Ip4Tx.Buffer )
1013                                            + BufferLength,
1014                                            0,
1015                                            DEBUG_TX );
1016         if ( !EFI_ERROR ( Status )) {
1017           //
1018           //  Initialize the transmit operation
1019           //
1020           pTxData = &pPacket->Op.Ip4Tx;
1021           pTxData->TxData.DestinationAddress.Addr[0] = pIp4->DestinationAddress.Addr[0];
1022           pTxData->TxData.DestinationAddress.Addr[1] = pIp4->DestinationAddress.Addr[1];
1023           pTxData->TxData.DestinationAddress.Addr[2] = pIp4->DestinationAddress.Addr[2];
1024           pTxData->TxData.DestinationAddress.Addr[3] = pIp4->DestinationAddress.Addr[3];
1025           pTxData->TxData.OverrideData = NULL;
1026           pTxData->TxData.OptionsLength = 0;
1027           pTxData->TxData.OptionsBuffer = NULL;
1028           pTxData->TxData.TotalDataLength = (UINT32) BufferLength;
1029           pTxData->TxData.FragmentCount = 1;
1030           pTxData->TxData.FragmentTable[0].FragmentLength = (UINT32) BufferLength;
1031           pTxData->TxData.FragmentTable[0].FragmentBuffer = &pPacket->Op.Ip4Tx.Buffer[0];
1032
1033           //
1034           //  Set the remote system address if necessary
1035           //
1036           if ( NULL != pAddress ) {
1037             pRemoteAddress = (const struct sockaddr_in *)pAddress;
1038             pTxData->Override.SourceAddress.Addr[0] = pIp4->ModeData.ConfigData.StationAddress.Addr[0];
1039             pTxData->Override.SourceAddress.Addr[1] = pIp4->ModeData.ConfigData.StationAddress.Addr[1];
1040             pTxData->Override.SourceAddress.Addr[2] = pIp4->ModeData.ConfigData.StationAddress.Addr[2];
1041             pTxData->Override.SourceAddress.Addr[3] = pIp4->ModeData.ConfigData.StationAddress.Addr[3];
1042             pTxData->TxData.DestinationAddress.Addr[0] = (UINT8)pRemoteAddress->sin_addr.s_addr;
1043             pTxData->TxData.DestinationAddress.Addr[1] = (UINT8)( pRemoteAddress->sin_addr.s_addr >> 8 );
1044             pTxData->TxData.DestinationAddress.Addr[2] = (UINT8)( pRemoteAddress->sin_addr.s_addr >> 16 );
1045             pTxData->TxData.DestinationAddress.Addr[3] = (UINT8)( pRemoteAddress->sin_addr.s_addr >> 24 );
1046             pTxData->Override.GatewayAddress.Addr[0] = 0;
1047             pTxData->Override.GatewayAddress.Addr[1] = 0;
1048             pTxData->Override.GatewayAddress.Addr[2] = 0;
1049             pTxData->Override.GatewayAddress.Addr[3] = 0;
1050             pTxData->Override.Protocol = (UINT8)pSocket->Protocol;
1051             pTxData->Override.TypeOfService = 0;
1052             pTxData->Override.TimeToLive = 255;
1053             pTxData->Override.DoNotFragment = FALSE;
1054
1055             //
1056             //  Use the remote system address when sending this packet
1057             //
1058             pTxData->TxData.OverrideData = &pTxData->Override;
1059           }
1060
1061           //
1062           //  Copy the data into the buffer
1063           //
1064           CopyMem ( &pPacket->Op.Ip4Tx.Buffer[0],
1065                     pBuffer,
1066                     BufferLength );
1067
1068           //
1069           //  Synchronize with the socket layer
1070           //
1071           RAISE_TPL ( TplPrevious, TPL_SOCKETS );
1072
1073           //
1074           //  Stop transmission after an error
1075           //
1076           if ( !EFI_ERROR ( pSocket->TxError )) {
1077             //
1078             //  Display the request
1079             //
1080             DEBUG (( DEBUG_TX,
1081                       "Send %d bytes from 0x%08x, %d.%d.%d.%d --> %d.%d.%d.%d\r\n",
1082                       BufferLength,
1083                       pBuffer,
1084                       pIp4->ModeData.ConfigData.StationAddress.Addr[0],
1085                       pIp4->ModeData.ConfigData.StationAddress.Addr[1],
1086                       pIp4->ModeData.ConfigData.StationAddress.Addr[2],
1087                       pIp4->ModeData.ConfigData.StationAddress.Addr[3],
1088                       pTxData->TxData.DestinationAddress.Addr[0],
1089                       pTxData->TxData.DestinationAddress.Addr[1],
1090                       pTxData->TxData.DestinationAddress.Addr[2],
1091                       pTxData->TxData.DestinationAddress.Addr[3]));
1092
1093             //
1094             //  Queue the data for transmission
1095             //
1096             pPacket->pNext = NULL;
1097             pPreviousPacket = pSocket->pTxPacketListTail;
1098             if ( NULL == pPreviousPacket ) {
1099               pSocket->pTxPacketListHead = pPacket;
1100             }
1101             else {
1102               pPreviousPacket->pNext = pPacket;
1103             }
1104             pSocket->pTxPacketListTail = pPacket;
1105             DEBUG (( DEBUG_TX,
1106                       "0x%08x: Packet on transmit list\r\n",
1107                       pPacket ));
1108
1109             //
1110             //  Account for the buffered data
1111             //
1112             *pTxBytes += BufferLength;
1113             *pDataLength = BufferLength;
1114
1115             //
1116             //  Start the transmit engine if it is idle
1117             //
1118             if ( NULL != pPort->pTxFree ) {
1119               EslSocketTxStart ( pPort,
1120                                  &pSocket->pTxPacketListHead,
1121                                  &pSocket->pTxPacketListTail,
1122                                  &pPort->pTxActive,
1123                                  &pPort->pTxFree );
1124             }
1125           }
1126           else {
1127             //
1128             //  Previous transmit error
1129             //  Stop transmission
1130             //
1131             Status = pSocket->TxError;
1132             pSocket->errno = EIO;
1133
1134             //
1135             //  Free the packet
1136             //
1137             EslSocketPacketFree ( pPacket, DEBUG_TX );
1138           }
1139
1140           //
1141           //  Release the socket layer synchronization
1142           //
1143           RESTORE_TPL ( TplPrevious );
1144         }
1145         else {
1146           //
1147           //  Packet allocation failed
1148           //
1149           pSocket->errno = ENOMEM;
1150         }
1151       }
1152       else {
1153         //
1154         //  Not enough buffer space available
1155         //
1156         pSocket->errno = EAGAIN;
1157         Status = EFI_NOT_READY;
1158       }
1159     }
1160   }
1161
1162   //
1163   //  Return the operation status
1164   //
1165   DBG_EXIT_STATUS ( Status );
1166   return Status;
1167 }
1168
1169
1170 /**
1171   Process the transmit completion
1172
1173   This routine use ::EslSocketTxComplete to perform the transmit
1174   completion processing for data packets.
1175
1176   This routine is called by the IPv4 network layer when a data
1177   transmit request completes.
1178
1179   @param [in] Event     The normal transmit completion event
1180
1181   @param [in] pIo       The address of an ::ESL_IO_MGMT structure
1182
1183 **/
1184 VOID
1185 EslIp4TxComplete (
1186   IN EFI_EVENT Event,
1187   IN ESL_IO_MGMT * pIo
1188   )
1189 {
1190   UINT32 LengthInBytes;
1191   ESL_PORT * pPort;
1192   ESL_PACKET * pPacket;
1193   ESL_SOCKET * pSocket;
1194   EFI_STATUS Status;
1195
1196   DBG_ENTER ( );
1197
1198   //
1199   //  Locate the active transmit packet
1200   //
1201   pPacket = pIo->pPacket;
1202   pPort = pIo->pPort;
1203   pSocket = pPort->pSocket;
1204
1205   //
1206   //  Get the transmit length and status
1207   //
1208   LengthInBytes = pPacket->Op.Ip4Tx.TxData.TotalDataLength;
1209   pSocket->TxBytes -= LengthInBytes;
1210   Status = pIo->Token.Ip4Tx.Status;
1211
1212   //
1213   //  Complete the transmit operation
1214   //
1215   EslSocketTxComplete ( pIo,
1216                         LengthInBytes,
1217                         Status,
1218                         "Raw ",
1219                         &pSocket->pTxPacketListHead,
1220                         &pSocket->pTxPacketListTail,
1221                         &pPort->pTxActive,
1222                         &pPort->pTxFree );
1223   DBG_EXIT ( );
1224 }
1225
1226
1227 /**
1228   Interface between the socket layer and the network specific
1229   code that supports SOCK_RAW sockets over IPv4.
1230 **/
1231 CONST ESL_PROTOCOL_API cEslIp4Api = {
1232   "IPv4",
1233     IPPROTO_IP,
1234   OFFSET_OF ( ESL_PORT, Context.Ip4.ModeData.ConfigData ),
1235   OFFSET_OF ( ESL_LAYER, pIp4List ),
1236   OFFSET_OF ( struct sockaddr_in, sin_zero ),
1237   sizeof ( struct sockaddr_in ),
1238   AF_INET,
1239   sizeof (((ESL_PACKET *)0 )->Op.Ip4Rx ),
1240   sizeof (((ESL_PACKET *)0 )->Op.Ip4Rx ),
1241   OFFSET_OF ( ESL_IO_MGMT, Token.Ip4Rx.Packet.RxData ),
1242   FALSE,
1243   EADDRNOTAVAIL,
1244   NULL,   //  Accept
1245   NULL,   //  ConnectPoll
1246   NULL,   //  ConnectStart
1247   EslIp4SocketIsConfigured,
1248   EslIp4LocalAddressGet,
1249   EslIp4LocalAddressSet,
1250   NULL,   //  Listen
1251   EslIp4OptionGet,
1252   EslIp4OptionSet,
1253   EslIp4PacketFree,
1254   EslIp4PortAllocate,
1255   NULL,   //  PortClose
1256   NULL,   //  PortCloseOp
1257   TRUE,
1258   EslIp4Receive,
1259   EslIp4RemoteAddressGet,
1260   EslIp4RemoteAddressSet,
1261   EslIp4RxComplete,
1262   NULL,   //  RxStart
1263   EslIp4TxBuffer,
1264   EslIp4TxComplete,
1265   NULL    //  TxOobComplete
1266 };