StdLib/EfiSocketLib/Ip4.c

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