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   Status = EFI_SUCCESS;
 623
 624   //
 625   //  Return the operation status
 626   //
 627   DBG_EXIT_STATUS ( Status );
 628   return Status;
 629 }
 630
 631
 632 /**
 633   Process the receive completion
 634
 635   This routine keeps the IPv4 driver's buffer and queues it in
 636   in FIFO order to the data queue.  The IP4 driver's buffer will
 637   be returned by either ::EslIp4Receive or ::EslSocketPortCloseTxDone.
 638   See the \ref ReceiveEngine section.
 639
 640   This routine is called by the IPv4 driver when data is
 641   received.
 642
 643   @param [in] Event     The receive completion event
 644
 645   @param [in] pIo       The address of an ::ESL_IO_MGMT structure
 646
 647 **/
 648 VOID
 649 EslIp4RxComplete (
 650   IN EFI_EVENT Event,
 651   IN ESL_IO_MGMT * pIo
 652   )
 653 {
 654   size_t LengthInBytes;
 655   ESL_PORT * pPort;
 656   ESL_PACKET * pPacket;
 657   EFI_IP4_RECEIVE_DATA * pRxData;
 658   EFI_STATUS Status;
 659
 660   DBG_ENTER ( );
 661
 662   //
 663   //  Get the operation status.
 664   //
 665   pPort = pIo->pPort;
 666   Status = pIo->Token.Ip4Rx.Status;
 667
 668   //
 669   //  Get the packet length
 670   //
 671   pRxData = pIo->Token.Ip4Rx.Packet.RxData;
 672   LengthInBytes = pRxData->HeaderLength + pRxData->DataLength;
 673
 674   //
 675   //      +--------------------+   +----------------------+
 676   //      | ESL_IO_MGMT        |   |      Data Buffer     |
 677   //      |                    |   |     (Driver owned)   |
 678   //      |    +---------------+   +----------------------+
 679   //      |    | Token         |               ^
 680   //      |    |      Rx Event |               |
 681   //      |    |               |   +----------------------+
 682   //      |    |        RxData --> | EFI_IP4_RECEIVE_DATA |
 683   //      +----+---------------+   |    (Driver owned)    |
 684   //                               +----------------------+
 685   //      +--------------------+               ^
 686   //      | ESL_PACKET         |               .
 687   //      |                    |               .
 688   //      |    +---------------+               .
 689   //      |    |       pRxData --> NULL  .......
 690   //      +----+---------------+
 691   //
 692   //
 693   //  Save the data in the packet
 694   //
 695   pPacket = pIo->pPacket;
 696   pPacket->Op.Ip4Rx.pRxData = pRxData;
 697
 698   //
 699   //  Complete this request
 700   //
 701   EslSocketRxComplete ( pIo, Status, LengthInBytes, FALSE );
 702   DBG_EXIT ( );
 703 }
 704
 705
 706 /**
 707   Determine if the socket is configured.
 708
 709   This routine uses the flag ESL_SOCKET::bConfigured to determine
 710   if the network layer's configuration routine has been called.
 711   This routine calls the ::EslSocketBind and configuration routines
 712   if they were not already called.  After the port is configured,
 713   the \ref ReceiveEngine is started.
 714
 715   This routine is called by EslSocketIsConfigured to verify
 716   that the socket is configured.
 717
 718   @param [in] pSocket         Address of an ::ESL_SOCKET structure
 719
 720   @retval EFI_SUCCESS - The port is connected
 721   @retval EFI_NOT_STARTED - The port is not connected
 722
 723  **/
 724  EFI_STATUS
 725  EslIp4SocketIsConfigured (
 726   IN ESL_SOCKET * pSocket
 727   )
 728 {
 729   UINTN Index;
 730   ESL_PORT * pPort;
 731   ESL_PORT * pNextPort;
 732   ESL_IP4_CONTEXT * pIp4;
 733   EFI_IP4_PROTOCOL * pIp4Protocol;
 734   EFI_STATUS Status;
 735   struct sockaddr_in LocalAddress;
 736
 737   DBG_ENTER ( );
 738
 739   //
 740   //  Assume success
 741   //
 742   Status = EFI_SUCCESS;
 743
 744   //
 745   //  Configure the port if necessary
 746   //
 747   if ( !pSocket->bConfigured ) {
 748     //
 749     //  Fill in the port list if necessary
 750     //
 751     if ( NULL == pSocket->pPortList ) {
 752       LocalAddress.sin_len = sizeof ( LocalAddress );
 753       LocalAddress.sin_family = AF_INET;
 754       LocalAddress.sin_addr.s_addr = 0;
 755       LocalAddress.sin_port = 0;
 756       Status = EslSocketBind ( &pSocket->SocketProtocol,
 757                                (struct sockaddr *)&LocalAddress,
 758                                LocalAddress.sin_len,
 759                                &pSocket->errno );
 760     }
 761
 762     //
 763     //  Walk the port list
 764     //
 765     pPort = pSocket->pPortList;
 766     while ( NULL != pPort ) {
 767       //
 768       //  Update the raw setting
 769       //
 770       pIp4 = &pPort->Context.Ip4;
 771       if ( pSocket->bIncludeHeader ) {
 772         //
 773         //  IP header will be included with the data on transmit
 774         //
 775         pIp4->ModeData.ConfigData.RawData = TRUE;
 776       }
 777
 778       //
 779       //  Attempt to configure the port
 780       //
 781       pNextPort = pPort->pLinkSocket;
 782       pIp4Protocol = pPort->pProtocol.IPv4;
 783       DEBUG (( DEBUG_TX,
 784                 "0x%08x: pPort Configuring for %d.%d.%d.%d --> %d.%d.%d.%d\r\n",
 785                           pPort,
 786                           pIp4->ModeData.ConfigData.StationAddress.Addr[0],
 787                           pIp4->ModeData.ConfigData.StationAddress.Addr[1],
 788                           pIp4->ModeData.ConfigData.StationAddress.Addr[2],
 789                           pIp4->ModeData.ConfigData.StationAddress.Addr[3],
 790                           pIp4->DestinationAddress.Addr[0],
 791                           pIp4->DestinationAddress.Addr[1],
 792                           pIp4->DestinationAddress.Addr[2],
 793                           pIp4->DestinationAddress.Addr[3]));
 794       Status = pIp4Protocol->Configure ( pIp4Protocol,
 795                                           &pIp4->ModeData.ConfigData );
 796       if ( !EFI_ERROR ( Status )) {
 797         //
 798         //  Update the configuration data
 799         //
 800         Status = pIp4Protocol->GetModeData ( pIp4Protocol,
 801                                              &pIp4->ModeData,
 802                                              NULL,
 803                                              NULL );
 804       }
 805       if ( EFI_ERROR ( Status )) {
 806         DEBUG (( DEBUG_LISTEN,
 807                   "ERROR - Failed to configure the Ip4 port, Status: %r\r\n",
 808                   Status ));
 809         switch ( Status ) {
 810         case EFI_ACCESS_DENIED:
 811           pSocket->errno = EACCES;
 812           break;
 813
 814         default:
 815         case EFI_DEVICE_ERROR:
 816           pSocket->errno = EIO;
 817           break;
 818
 819         case EFI_INVALID_PARAMETER:
 820           pSocket->errno = EADDRNOTAVAIL;
 821           break;
 822
 823         case EFI_NO_MAPPING:
 824           pSocket->errno = EAFNOSUPPORT;
 825           break;
 826
 827         case EFI_OUT_OF_RESOURCES:
 828           pSocket->errno = ENOBUFS;
 829           break;
 830
 831         case EFI_UNSUPPORTED:
 832           pSocket->errno = EOPNOTSUPP;
 833           break;
 834         }
 835       }
 836       else {
 837         DEBUG (( DEBUG_TX,
 838                   "0x%08x: pPort Configured for %d.%d.%d.%d --> %d.%d.%d.%d\r\n",
 839                   pPort,
 840                   pIp4->ModeData.ConfigData.StationAddress.Addr[0],
 841                   pIp4->ModeData.ConfigData.StationAddress.Addr[1],
 842                   pIp4->ModeData.ConfigData.StationAddress.Addr[2],
 843                   pIp4->ModeData.ConfigData.StationAddress.Addr[3],
 844                   pIp4->DestinationAddress.Addr[0],
 845                   pIp4->DestinationAddress.Addr[1],
 846                   pIp4->DestinationAddress.Addr[2],
 847                   pIp4->DestinationAddress.Addr[3]));
 848         DEBUG (( DEBUG_TX,
 849                   "Subnet Mask: %d.%d.%d.%d\r\n",
 850                   pIp4->ModeData.ConfigData.SubnetMask.Addr[0],
 851                   pIp4->ModeData.ConfigData.SubnetMask.Addr[1],
 852                   pIp4->ModeData.ConfigData.SubnetMask.Addr[2],
 853                   pIp4->ModeData.ConfigData.SubnetMask.Addr[3]));
 854         DEBUG (( DEBUG_TX,
 855                   "Route Count: %d\r\n",
 856                   pIp4->ModeData.RouteCount ));
 857         for ( Index = 0; pIp4->ModeData.RouteCount > Index; Index++ ) {
 858           if ( 0 == Index ) {
 859             DEBUG (( DEBUG_TX, "Route Table:\r\n" ));
 860           }
 861           DEBUG (( DEBUG_TX,
 862                     "%5d: %d.%d.%d.%d, %d.%d.%d.%d ==> %d.%d.%d.%d\r\n",
 863                     Index,
 864                     pIp4->ModeData.RouteTable[Index].SubnetAddress.Addr[0],
 865                     pIp4->ModeData.RouteTable[Index].SubnetAddress.Addr[1],
 866                     pIp4->ModeData.RouteTable[Index].SubnetAddress.Addr[2],
 867                     pIp4->ModeData.RouteTable[Index].SubnetAddress.Addr[3],
 868                     pIp4->ModeData.RouteTable[Index].SubnetMask.Addr[0],
 869                     pIp4->ModeData.RouteTable[Index].SubnetMask.Addr[1],
 870                     pIp4->ModeData.RouteTable[Index].SubnetMask.Addr[2],
 871                     pIp4->ModeData.RouteTable[Index].SubnetMask.Addr[3],
 872                     pIp4->ModeData.RouteTable[Index].GatewayAddress.Addr[0],
 873                     pIp4->ModeData.RouteTable[Index].GatewayAddress.Addr[1],
 874                     pIp4->ModeData.RouteTable[Index].GatewayAddress.Addr[2],
 875                     pIp4->ModeData.RouteTable[Index].GatewayAddress.Addr[3]));
 876         }
 877         pPort->bConfigured = TRUE;
 878
 879         //
 880         //  Start the first read on the port
 881         //
 882         EslSocketRxStart ( pPort );
 883
 884         //
 885         //  The socket is connected
 886         //
 887         pSocket->State = SOCKET_STATE_CONNECTED;
 888       }
 889
 890       //
 891       //  Set the next port
 892       //
 893       pPort = pNextPort;
 894     }
 895
 896     //
 897     //  Determine the configuration status
 898     //
 899     if ( NULL != pSocket->pPortList ) {
 900       pSocket->bConfigured = TRUE;
 901     }
 902   }
 903
 904   //
 905   //  Determine the socket configuration status
 906   //
 907   if ( !EFI_ERROR ( Status )) {
 908     Status = pSocket->bConfigured ? EFI_SUCCESS : EFI_NOT_STARTED;
 909   }
 910
 911   //
 912   //  Return the port connected state.
 913   //
 914   DBG_EXIT_STATUS ( Status );
 915   return Status;
 916 }
 917
 918
 919 /**
 920   Buffer data for transmission over a network connection.
 921
 922   This routine buffers data for the transmit engine in the normal
 923   data queue.  When the \ref TransmitEngine has resources, this
 924   routine will start the transmission of the next buffer on the
 925   network connection.
 926
 927   This routine is called by ::EslSocketTransmit to buffer
 928   data for transmission.  The data is copied into a local buffer
 929   freeing the application buffer for reuse upon return.  When
 930   necessary, this routine starts the transmit engine that
 931   performs the data transmission on the network connection.  The
 932   transmit engine transmits the data a packet at a time over the
 933   network connection.
 934
 935   Transmission errors are returned during the next transmission or
 936   during the close operation.  Only buffering errors are returned
 937   during the current transmission attempt.
 938
 939   @param [in] pSocket         Address of an ::ESL_SOCKET structure
 940
 941   @param [in] Flags           Message control flags
 942
 943   @param [in] BufferLength    Length of the the buffer
 944
 945   @param [in] pBuffer         Address of a buffer to receive the data.
 946
 947   @param [in] pDataLength     Number of received data bytes in the buffer.
 948
 949   @param [in] pAddress        Network address of the remote system address
 950
 951   @param [in] AddressLength   Length of the remote network address structure
 952
 953   @retval EFI_SUCCESS - Socket data successfully buffered
 954
 955 **/
 956 EFI_STATUS
 957 EslIp4TxBuffer (
 958   IN ESL_SOCKET * pSocket,
 959   IN int Flags,
 960   IN size_t BufferLength,
 961   IN CONST UINT8 * pBuffer,
 962   OUT size_t * pDataLength,
 963   IN const struct sockaddr * pAddress,
 964   IN socklen_t AddressLength
 965   )
 966 {
 967   ESL_PACKET * pPacket;
 968   ESL_PACKET * pPreviousPacket;
 969   ESL_PORT * pPort;
 970   const struct sockaddr_in * pRemoteAddress;
 971   ESL_IP4_CONTEXT * pIp4;
 972   size_t * pTxBytes;
 973   ESL_IP4_TX_DATA * pTxData;
 974   EFI_STATUS Status;
 975   EFI_TPL TplPrevious;
 976
 977   DBG_ENTER ( );
 978
 979   //
 980   //  Assume failure
 981   //
 982   Status = EFI_UNSUPPORTED;
 983   pSocket->errno = ENOTCONN;
 984   *pDataLength = 0;
 985
 986   //
 987   //  Verify that the socket is connected
 988   //
 989   if ( SOCKET_STATE_CONNECTED == pSocket->State ) {
 990     //
 991     //  Locate the port
 992     //
 993     pPort = pSocket->pPortList;
 994     if ( NULL != pPort ) {
 995       //
 996       //  Determine the queue head
 997       //
 998       pIp4 = &pPort->Context.Ip4;
 999       pTxBytes = &pSocket->TxBytes;
1000
1001       //
1002       //  Verify that there is enough room to buffer another
1003       //  transmit operation
1004       //
1005       if ( pSocket->MaxTxBuf > *pTxBytes ) {
1006         //
1007         //  Attempt to allocate the packet
1008         //
1009         Status = EslSocketPacketAllocate ( &pPacket,
1010                                            sizeof ( pPacket->Op.Ip4Tx )
1011                                            - sizeof ( pPacket->Op.Ip4Tx.Buffer )
1012                                            + BufferLength,
1013                                            0,
1014                                            DEBUG_TX );
1015         if ( !EFI_ERROR ( Status )) {
1016           //
1017           //  Initialize the transmit operation
1018           //
1019           pTxData = &pPacket->Op.Ip4Tx;
1020           pTxData->TxData.DestinationAddress.Addr[0] = pIp4->DestinationAddress.Addr[0];
1021           pTxData->TxData.DestinationAddress.Addr[1] = pIp4->DestinationAddress.Addr[1];
1022           pTxData->TxData.DestinationAddress.Addr[2] = pIp4->DestinationAddress.Addr[2];
1023           pTxData->TxData.DestinationAddress.Addr[3] = pIp4->DestinationAddress.Addr[3];
1024           pTxData->TxData.OverrideData = NULL;
1025           pTxData->TxData.OptionsLength = 0;
1026           pTxData->TxData.OptionsBuffer = NULL;
1027           pTxData->TxData.TotalDataLength = (UINT32) BufferLength;
1028           pTxData->TxData.FragmentCount = 1;
1029           pTxData->TxData.FragmentTable[0].FragmentLength = (UINT32) BufferLength;
1030           pTxData->TxData.FragmentTable[0].FragmentBuffer = &pPacket->Op.Ip4Tx.Buffer[0];
1031
1032           //
1033           //  Set the remote system address if necessary
1034           //
1035           if ( NULL != pAddress ) {
1036             pRemoteAddress = (const struct sockaddr_in *)pAddress;
1037             pTxData->Override.SourceAddress.Addr[0] = pIp4->ModeData.ConfigData.StationAddress.Addr[0];
1038             pTxData->Override.SourceAddress.Addr[1] = pIp4->ModeData.ConfigData.StationAddress.Addr[1];
1039             pTxData->Override.SourceAddress.Addr[2] = pIp4->ModeData.ConfigData.StationAddress.Addr[2];
1040             pTxData->Override.SourceAddress.Addr[3] = pIp4->ModeData.ConfigData.StationAddress.Addr[3];
1041             pTxData->TxData.DestinationAddress.Addr[0] = (UINT8)pRemoteAddress->sin_addr.s_addr;
1042             pTxData->TxData.DestinationAddress.Addr[1] = (UINT8)( pRemoteAddress->sin_addr.s_addr >> 8 );
1043             pTxData->TxData.DestinationAddress.Addr[2] = (UINT8)( pRemoteAddress->sin_addr.s_addr >> 16 );
1044             pTxData->TxData.DestinationAddress.Addr[3] = (UINT8)( pRemoteAddress->sin_addr.s_addr >> 24 );
1045             pTxData->Override.GatewayAddress.Addr[0] = 0;
1046             pTxData->Override.GatewayAddress.Addr[1] = 0;
1047             pTxData->Override.GatewayAddress.Addr[2] = 0;
1048             pTxData->Override.GatewayAddress.Addr[3] = 0;
1049             pTxData->Override.Protocol = (UINT8)pSocket->Protocol;
1050             pTxData->Override.TypeOfService = 0;
1051             pTxData->Override.TimeToLive = 255;
1052             pTxData->Override.DoNotFragment = FALSE;
1053
1054             //
1055             //  Use the remote system address when sending this packet
1056             //
1057             pTxData->TxData.OverrideData = &pTxData->Override;
1058           }
1059
1060           //
1061           //  Copy the data into the buffer
1062           //
1063           CopyMem ( &pPacket->Op.Ip4Tx.Buffer[0],
1064                     pBuffer,
1065                     BufferLength );
1066
1067           //
1068           //  Synchronize with the socket layer
1069           //
1070           RAISE_TPL ( TplPrevious, TPL_SOCKETS );
1071
1072           //
1073           //  Stop transmission after an error
1074           //
1075           if ( !EFI_ERROR ( pSocket->TxError )) {
1076             //
1077             //  Display the request
1078             //
1079             DEBUG (( DEBUG_TX,
1080                       "Send %d bytes from 0x%08x, %d.%d.%d.%d --> %d.%d.%d.%d\r\n",
1081                       BufferLength,
1082                       pBuffer,
1083                       pIp4->ModeData.ConfigData.StationAddress.Addr[0],
1084                       pIp4->ModeData.ConfigData.StationAddress.Addr[1],
1085                       pIp4->ModeData.ConfigData.StationAddress.Addr[2],
1086                       pIp4->ModeData.ConfigData.StationAddress.Addr[3],
1087                       pTxData->TxData.DestinationAddress.Addr[0],
1088                       pTxData->TxData.DestinationAddress.Addr[1],
1089                       pTxData->TxData.DestinationAddress.Addr[2],
1090                       pTxData->TxData.DestinationAddress.Addr[3]));
1091
1092             //
1093             //  Queue the data for transmission
1094             //
1095             pPacket->pNext = NULL;
1096             pPreviousPacket = pSocket->pTxPacketListTail;
1097             if ( NULL == pPreviousPacket ) {
1098               pSocket->pTxPacketListHead = pPacket;
1099             }
1100             else {
1101               pPreviousPacket->pNext = pPacket;
1102             }
1103             pSocket->pTxPacketListTail = pPacket;
1104             DEBUG (( DEBUG_TX,
1105                       "0x%08x: Packet on transmit list\r\n",
1106                       pPacket ));
1107
1108             //
1109             //  Account for the buffered data
1110             //
1111             *pTxBytes += BufferLength;
1112             *pDataLength = BufferLength;
1113
1114             //
1115             //  Start the transmit engine if it is idle
1116             //
1117             if ( NULL != pPort->pTxFree ) {
1118               EslSocketTxStart ( pPort,
1119                                  &pSocket->pTxPacketListHead,
1120                                  &pSocket->pTxPacketListTail,
1121                                  &pPort->pTxActive,
1122                                  &pPort->pTxFree );
1123             }
1124           }
1125           else {
1126             //
1127             //  Previous transmit error
1128             //  Stop transmission
1129             //
1130             Status = pSocket->TxError;
1131             pSocket->errno = EIO;
1132
1133             //
1134             //  Free the packet
1135             //
1136             EslSocketPacketFree ( pPacket, DEBUG_TX );
1137           }
1138
1139           //
1140           //  Release the socket layer synchronization
1141           //
1142           RESTORE_TPL ( TplPrevious );
1143         }
1144         else {
1145           //
1146           //  Packet allocation failed
1147           //
1148           pSocket->errno = ENOMEM;
1149         }
1150       }
1151       else {
1152         //
1153         //  Not enough buffer space available
1154         //
1155         pSocket->errno = EAGAIN;
1156         Status = EFI_NOT_READY;
1157       }
1158     }
1159   }
1160
1161   //
1162   //  Return the operation status
1163   //
1164   DBG_EXIT_STATUS ( Status );
1165   return Status;
1166 }
1167
1168
1169 /**
1170   Process the transmit completion
1171
1172   This routine use ::EslSocketTxComplete to perform the transmit
1173   completion processing for data packets.
1174
1175   This routine is called by the IPv4 network layer when a data
1176   transmit request completes.
1177
1178   @param [in] Event     The normal transmit completion event
1179
1180   @param [in] pIo       The address of an ::ESL_IO_MGMT structure
1181
1182 **/
1183 VOID
1184 EslIp4TxComplete (
1185   IN EFI_EVENT Event,
1186   IN ESL_IO_MGMT * pIo
1187   )
1188 {
1189   UINT32 LengthInBytes;
1190   ESL_PORT * pPort;
1191   ESL_PACKET * pPacket;
1192   ESL_SOCKET * pSocket;
1193   EFI_STATUS Status;
1194
1195   DBG_ENTER ( );
1196
1197   //
1198   //  Locate the active transmit packet
1199   //
1200   pPacket = pIo->pPacket;
1201   pPort = pIo->pPort;
1202   pSocket = pPort->pSocket;
1203
1204   //
1205   //  Get the transmit length and status
1206   //
1207   LengthInBytes = pPacket->Op.Ip4Tx.TxData.TotalDataLength;
1208   pSocket->TxBytes -= LengthInBytes;
1209   Status = pIo->Token.Ip4Tx.Status;
1210
1211   //
1212   //  Complete the transmit operation
1213   //
1214   EslSocketTxComplete ( pIo,
1215                         LengthInBytes,
1216                         Status,
1217                         "Raw ",
1218                         &pSocket->pTxPacketListHead,
1219                         &pSocket->pTxPacketListTail,
1220                         &pPort->pTxActive,
1221                         &pPort->pTxFree );
1222   DBG_EXIT ( );
1223 }
1224
1225
1226 /**
1227   Interface between the socket layer and the network specific
1228   code that supports SOCK_RAW sockets over IPv4.
1229 **/
1230 CONST ESL_PROTOCOL_API cEslIp4Api = {
1231   "IPv4",
1232     IPPROTO_IP,
1233   OFFSET_OF ( ESL_PORT, Context.Ip4.ModeData.ConfigData ),
1234   OFFSET_OF ( ESL_LAYER, pIp4List ),
1235   OFFSET_OF ( struct sockaddr_in, sin_zero ),
1236   sizeof ( struct sockaddr_in ),
1237   AF_INET,
1238   sizeof (((ESL_PACKET *)0 )->Op.Ip4Rx ),
1239   sizeof (((ESL_PACKET *)0 )->Op.Ip4Rx ),
1240   OFFSET_OF ( ESL_IO_MGMT, Token.Ip4Rx.Packet.RxData ),
1241   FALSE,
1242   EADDRNOTAVAIL,
1243   NULL,   //  Accept
1244   NULL,   //  ConnectPoll
1245   NULL,   //  ConnectStart
1246   EslIp4SocketIsConfigured,
1247   EslIp4LocalAddressGet,
1248   EslIp4LocalAddressSet,
1249   NULL,   //  Listen
1250   EslIp4OptionGet,
1251   EslIp4OptionSet,
1252   EslIp4PacketFree,
1253   EslIp4PortAllocate,
1254   NULL,   //  PortClose
1255   NULL,   //  PortCloseOp
1256   TRUE,
1257   EslIp4Receive,
1258   EslIp4RemoteAddressGet,
1259   EslIp4RemoteAddressSet,
1260   EslIp4RxComplete,
1261   NULL,   //  RxStart
1262   EslIp4TxBuffer,
1263   EslIp4TxComplete,
1264   NULL    //  TxOobComplete
1265 };