StdLib/EfiSocketLib/Tcp4.c

   1 /** @file
   2   Implement the TCP4 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
  14   \section ConnectionManagement Connection Management
  15
  16   The ::EslTcp4Listen routine initially places the SOCK_STREAM or
  17   SOCK_SEQPACKET socket into a listen state.   When a remote machine
  18   makes a connection to the socket, the TCPv4 network layer calls
  19   ::EslTcp4ListenComplete to complete the connection processing.
  20   EslTcp4ListenComplete manages the connections by placing them in
  21   FIFO order in a queue to be serviced by the application.  When the
  22   number of connections exceeds the backlog (ESL_SOCKET::MaxFifoDepth),
  23   the new connection is closed.  Eventually, the application indirectly
  24   calls ::EslTcp4Accept to remove the next connection from the queue
  25   and get the associated socket.
  26
  27 **/
  28
  29 #include "Socket.h"
  30
  31
  32 /**
  33   Attempt to connect to a remote TCP port
  34
  35   This routine starts the connection processing for a SOCK_STREAM
  36   or SOCK_SEQPAKCET socket using the TCPv4 network layer.  It
  37   configures the local TCPv4 connection point and then attempts to
  38   connect to a remote system.  Upon completion, the
  39   ::EslTcp4ConnectComplete routine gets called with the connection
  40   status.
  41
  42   This routine is called by ::EslSocketConnect to initiate the TCPv4
  43   network specific connect operations.  The connection processing is
  44   initiated by this routine and finished by ::EslTcp4ConnectComplete.
  45   This pair of routines walks through the list of local TCPv4
  46   connection points until a connection to the remote system is
  47   made.
  48
  49   @param [in] pSocket   Address of an ::ESL_SOCKET structure.
  50
  51   @retval EFI_SUCCESS   The connection was successfully established.
  52   @retval EFI_NOT_READY The connection is in progress, call this routine again.
  53   @retval Others        The connection attempt failed.
  54
  55  **/
  56 EFI_STATUS
  57 EslTcp4ConnectStart (
  58   IN ESL_SOCKET * pSocket
  59   );
  60
  61
  62 /**
  63   Process the connection attempt
  64
  65   A system has initiated a connection attempt with a socket in the
  66   listen state.  Attempt to complete the connection.
  67
  68   The TCPv4 layer calls this routine when a connection is made to
  69   the socket in the listen state.  See the
  70   \ref ConnectionManagement section.
  71
  72   @param [in] Event     The listen completion event
  73
  74   @param [in] pPort     Address of an ::ESL_PORT structure.
  75
  76 **/
  77 VOID
  78 EslTcp4ListenComplete (
  79   IN EFI_EVENT Event,
  80   IN ESL_PORT * pPort
  81   );
  82
  83
  84 /**
  85   Accept a network connection.
  86
  87   This routine waits for a network connection to the socket and
  88   returns the remote network address to the caller if requested.
  89
  90   This routine is called by ::EslSocketAccept to handle the TCPv4 protocol
  91   specific accept operations for SOCK_STREAM and SOCK_SEQPACKET sockets.
  92   See the \ref ConnectionManagement section.
  93
  94   @param [in] pSocket   Address of an ::ESL_SOCKET structure.
  95
  96   @param [in] pSockAddr       Address of a buffer to receive the remote
  97                               network address.
  98
  99   @param [in, out] pSockAddrLength  Length in bytes of the address buffer.
 100                                     On output specifies the length of the
 101                                     remote network address.
 102
 103   @retval EFI_SUCCESS   Remote address is available
 104   @retval Others        Remote address not available
 105
 106  **/
 107 EFI_STATUS
 108 EslTcp4Accept (
 109   IN ESL_SOCKET * pSocket,
 110   IN struct sockaddr * pSockAddr,
 111   IN OUT socklen_t * pSockAddrLength
 112   )
 113 {
 114   ESL_PORT * pPort;
 115   struct sockaddr_in * pRemoteAddress;
 116   ESL_TCP4_CONTEXT * pTcp4;
 117   UINT32 RemoteAddress;
 118   EFI_STATUS Status;
 119
 120   DBG_ENTER ( );
 121
 122   //
 123   //  Validate the socket length
 124   //
 125   pRemoteAddress = (struct sockaddr_in *) pSockAddr;
 126   if (( NULL == pSockAddrLength )
 127     || ( sizeof ( *pRemoteAddress ) > *pSockAddrLength )) {
 128     //
 129     //  Invalid socket address
 130     //
 131     Status = EFI_INVALID_PARAMETER;
 132     pSocket->errno = EINVAL;
 133     DEBUG (( DEBUG_ACCEPT,
 134               "ERROR - Invalid address length\r\n" ));
 135   }
 136   else {
 137     //
 138     //  Assume success
 139     //
 140     Status = EFI_SUCCESS;
 141
 142     //
 143     //  Locate the address context
 144     //
 145     pPort = pSocket->pPortList;
 146     pTcp4 = &pPort->Context.Tcp4;
 147
 148     //
 149     //  Fill-in the remote address structure
 150     //
 151     ZeroMem ( pRemoteAddress, sizeof ( *pRemoteAddress ));
 152     pRemoteAddress->sin_len = sizeof ( *pRemoteAddress );
 153     pRemoteAddress->sin_family = AF_INET;
 154     pRemoteAddress->sin_port = SwapBytes16 ( pTcp4->ConfigData.AccessPoint.RemotePort );
 155     RemoteAddress = pTcp4->ConfigData.AccessPoint.RemoteAddress.Addr[3];
 156     RemoteAddress <<= 8;
 157     RemoteAddress |= pTcp4->ConfigData.AccessPoint.RemoteAddress.Addr[2];
 158     RemoteAddress <<= 8;
 159     RemoteAddress |= pTcp4->ConfigData.AccessPoint.RemoteAddress.Addr[1];
 160     RemoteAddress <<= 8;
 161     RemoteAddress |= pTcp4->ConfigData.AccessPoint.RemoteAddress.Addr[0];
 162     pRemoteAddress->sin_addr.s_addr = RemoteAddress;
 163   }
 164
 165   //
 166   //  Return the operation status
 167   //
 168   DBG_EXIT_STATUS ( Status );
 169   return Status;
 170 }
 171
 172
 173 /**
 174   Process the remote connection completion event.
 175
 176   This routine handles the completion of a connection attempt.  It
 177   releases the port (TCPv4 adapter connection) in the case of an
 178   error and start a connection attempt on the next port.  If the
 179   connection attempt was successful then this routine releases all
 180   of the other ports.
 181
 182   This routine is called by the TCPv4 layer when a connect request
 183   completes.  It sets the ESL_SOCKET::bConnected flag to notify the
 184   ::EslTcp4ConnectComplete routine that the connection is available.
 185   The flag is set when the connection is established or no more ports
 186   exist in the list.  The connection status is passed via
 187   ESL_SOCKET::ConnectStatus.
 188
 189   @param [in] Event     The connect completion event
 190
 191   @param [in] pPort     Address of an ::ESL_PORT structure.
 192
 193 **/
 194 VOID
 195 EslTcp4ConnectComplete (
 196   IN EFI_EVENT Event,
 197   IN ESL_PORT * pPort
 198   )
 199 {
 200   BOOLEAN bRemoveFirstPort;
 201   BOOLEAN bRemovePorts;
 202   ESL_PORT * pNextPort;
 203   ESL_SOCKET * pSocket;
 204   ESL_TCP4_CONTEXT * pTcp4;
 205   EFI_STATUS Status;
 206
 207   DBG_ENTER ( );
 208
 209   //
 210   //  Locate the TCP context
 211   //
 212   pSocket = pPort->pSocket;
 213   pTcp4 = &pPort->Context.Tcp4;
 214
 215   //
 216   //  Get the connection status
 217   //
 218   bRemoveFirstPort = FALSE;
 219   bRemovePorts = FALSE;
 220   Status = pTcp4->ConnectToken.CompletionToken.Status;
 221   pSocket->ConnectStatus = Status;
 222   if ( !EFI_ERROR ( Status )) {
 223     //
 224     //  The connection was successful
 225     //
 226     DEBUG (( DEBUG_CONNECT,
 227               "0x%08x: Port connected to %d.%d.%d.%d:%d\r\n",
 228               pPort,
 229               pTcp4->ConfigData.AccessPoint.RemoteAddress.Addr[0],
 230               pTcp4->ConfigData.AccessPoint.RemoteAddress.Addr[1],
 231               pTcp4->ConfigData.AccessPoint.RemoteAddress.Addr[2],
 232               pTcp4->ConfigData.AccessPoint.RemoteAddress.Addr[3],
 233               pTcp4->ConfigData.AccessPoint.RemotePort ));
 234
 235     //
 236     //  Start the receive operations
 237     //
 238     pSocket->bConfigured = TRUE;
 239     pSocket->State = SOCKET_STATE_CONNECTED;
 240     EslSocketRxStart ( pPort );
 241
 242     //
 243     //  Remove the rest of the ports
 244     //
 245     bRemovePorts = TRUE;
 246   }
 247   else {
 248     //
 249     //  The connection failed
 250     //
 251     if ( pPort->bConfigured ) {
 252       DEBUG (( DEBUG_CONNECT,
 253                 "0x%08x: Port connection to %d.%d.%d.%d:%d failed, Status: %r\r\n",
 254                 pPort,
 255                 pTcp4->ConfigData.AccessPoint.RemoteAddress.Addr[0],
 256                 pTcp4->ConfigData.AccessPoint.RemoteAddress.Addr[1],
 257                 pTcp4->ConfigData.AccessPoint.RemoteAddress.Addr[2],
 258                 pTcp4->ConfigData.AccessPoint.RemoteAddress.Addr[3],
 259                 pTcp4->ConfigData.AccessPoint.RemotePort,
 260                 Status ));
 261     }
 262
 263     //
 264     //  Close the current port
 265     //
 266     Status = EslSocketPortClose ( pPort );
 267     if ( !EFI_ERROR ( Status )) {
 268       DEBUG (( DEBUG_CONNECT,
 269               "0x%08x: Port closed\r\n",
 270               pPort ));
 271     }
 272     else {
 273       DEBUG (( DEBUG_CONNECT,
 274                 "ERROR - Failed to close port 0x%08x, Status: %r\r\n",
 275                 pPort,
 276                 Status ));
 277     }
 278
 279     //
 280     //  Try to connect using the next port
 281     //
 282     Status = EslTcp4ConnectStart ( pSocket );
 283     if ( EFI_NOT_READY != Status ) {
 284       bRemoveFirstPort = TRUE;
 285     }
 286   }
 287
 288   //
 289   //  Remove the ports if necessary
 290   //
 291   if ( bRemoveFirstPort || bRemovePorts ) {
 292     //
 293     //  Remove the first port if necessary
 294     //
 295     pPort = pSocket->pPortList;
 296     if (( !bRemoveFirstPort ) && ( NULL != pPort )) {
 297       pPort = pPort->pLinkSocket;
 298     }
 299
 300     //
 301     //  Remove the rest of the list
 302     //
 303     while ( NULL != pPort ) {
 304       pNextPort = pPort->pLinkSocket;
 305       EslSocketPortClose ( pPort );
 306       if ( !EFI_ERROR ( Status )) {
 307         DEBUG (( DEBUG_CONNECT,
 308                 "0x%08x: Port closed\r\n",
 309                 pPort ));
 310       }
 311       else {
 312         DEBUG (( DEBUG_CONNECT,
 313                   "ERROR - Failed to close port 0x%08x, Status: %r\r\n",
 314                   pPort,
 315                   Status ));
 316       }
 317       pPort = pNextPort;
 318     }
 319
 320     //
 321     //  Notify the poll routine
 322     //
 323     pSocket->bConnected = TRUE;
 324   }
 325
 326   DBG_EXIT ( );
 327 }
 328
 329
 330 /**
 331   Poll for completion of the connection attempt.
 332
 333   This routine polls the ESL_SOCKET::bConnected flag to determine
 334   when the connection attempt is complete.
 335
 336   This routine is called from ::EslSocketConnect to determine when
 337   the connection is complete.  The ESL_SOCKET::bConnected flag is
 338   set by ::EslTcp4ConnectComplete when the TCPv4 layer establishes
 339   a connection or runs out of local network adapters.  This routine
 340   gets the connection status from ESL_SOCKET::ConnectStatus.
 341
 342   @param [in] pSocket   Address of an ::ESL_SOCKET structure.
 343
 344   @retval EFI_SUCCESS   The connection was successfully established.
 345   @retval EFI_NOT_READY The connection is in progress, call this routine again.
 346   @retval Others        The connection attempt failed.
 347
 348  **/
 349 EFI_STATUS
 350 EslTcp4ConnectPoll (
 351   IN ESL_SOCKET * pSocket
 352   )
 353 {
 354   EFI_STATUS Status;
 355
 356   DBG_ENTER ( );
 357
 358   //
 359   //  Determine if the connection is complete
 360   //
 361   if ( !pSocket->bConnected ) {
 362     //
 363     //  Not connected
 364     //
 365     pSocket->errno = EAGAIN;
 366     Status = EFI_NOT_READY;
 367   }
 368   else {
 369     //
 370     //  The connection processing is complete
 371     //
 372     pSocket->bConnected = FALSE;
 373
 374     //
 375     //  Translate the connection status
 376     //
 377     Status = pSocket->ConnectStatus;
 378     switch ( Status ) {
 379     default:
 380     case EFI_DEVICE_ERROR:
 381       pSocket->errno = EIO;
 382       break;
 383
 384     case EFI_ABORTED:
 385       pSocket->errno = ECONNABORTED;
 386       break;
 387
 388     case EFI_ACCESS_DENIED:
 389       pSocket->errno = EACCES;
 390       break;
 391
 392     case EFI_CONNECTION_RESET:
 393       pSocket->errno = ECONNRESET;
 394       break;
 395
 396     case EFI_INVALID_PARAMETER:
 397       pSocket->errno = EADDRNOTAVAIL;
 398       break;
 399
 400     case EFI_HOST_UNREACHABLE:
 401     case EFI_NO_RESPONSE:
 402       pSocket->errno = EHOSTUNREACH;
 403       break;
 404
 405     case EFI_NO_MAPPING:
 406       pSocket->errno = EAFNOSUPPORT;
 407       break;
 408
 409     case EFI_NO_MEDIA:
 410     case EFI_NETWORK_UNREACHABLE:
 411       pSocket->errno = ENETDOWN;
 412       break;
 413
 414     case EFI_OUT_OF_RESOURCES:
 415       pSocket->errno = ENOBUFS;
 416       break;
 417
 418     case EFI_PORT_UNREACHABLE:
 419     case EFI_PROTOCOL_UNREACHABLE:
 420     case EFI_CONNECTION_REFUSED:
 421       pSocket->errno = ECONNREFUSED;
 422       break;
 423
 424     case EFI_SUCCESS:
 425       pSocket->errno = 0;
 426       break;
 427
 428     case EFI_TIMEOUT:
 429       pSocket->errno = ETIMEDOUT;
 430       break;
 431
 432     case EFI_UNSUPPORTED:
 433       pSocket->errno = EOPNOTSUPP;
 434       break;
 435     }
 436
 437     //
 438     //  Display the translation
 439     //
 440     DEBUG (( DEBUG_CONNECT,
 441               "ERROR - errno: %d, Status: %r\r\n",
 442               pSocket->errno,
 443               Status ));
 444   }
 445
 446   //
 447   //  Return the initialization status
 448   //
 449   DBG_EXIT_STATUS ( Status );
 450   return Status;
 451 }
 452
 453
 454 /**
 455   Attempt to connect to a remote TCP port
 456
 457   This routine starts the connection processing for a SOCK_STREAM
 458   or SOCK_SEQPAKCET socket using the TCPv4 network layer.  It
 459   configures the local TCPv4 connection point and then attempts to
 460   connect to a remote system.  Upon completion, the
 461   ::EslTcp4ConnectComplete routine gets called with the connection
 462   status.
 463
 464   This routine is called by ::EslSocketConnect to initiate the TCPv4
 465   network specific connect operations.  The connection processing is
 466   initiated by this routine and finished by ::EslTcp4ConnectComplete.
 467   This pair of routines walks through the list of local TCPv4
 468   connection points until a connection to the remote system is
 469   made.
 470
 471   @param [in] pSocket   Address of an ::ESL_SOCKET structure.
 472
 473   @retval EFI_SUCCESS   The connection was successfully established.
 474   @retval EFI_NOT_READY The connection is in progress, call this routine again.
 475   @retval Others        The connection attempt failed.
 476
 477  **/
 478 EFI_STATUS
 479 EslTcp4ConnectStart (
 480   IN ESL_SOCKET * pSocket
 481   )
 482 {
 483   ESL_PORT * pPort;
 484   ESL_TCP4_CONTEXT * pTcp4;
 485   EFI_TCP4_PROTOCOL * pTcp4Protocol;
 486   EFI_SIMPLE_NETWORK_MODE SnpModeData;
 487   EFI_STATUS Status;
 488
 489   DBG_ENTER ( );
 490
 491   //
 492   //  Determine if any more local adapters are available
 493   //
 494   pPort = pSocket->pPortList;
 495   if ( NULL != pPort ) {
 496     //
 497     //  Configure the port
 498     //
 499     pTcp4 = &pPort->Context.Tcp4;
 500     pTcp4->ConfigData.AccessPoint.ActiveFlag = TRUE;
 501     pTcp4->ConfigData.TimeToLive = 255;
 502     pTcp4Protocol = pPort->pProtocol.TCPv4;
 503     Status = pTcp4Protocol->Configure ( pTcp4Protocol,
 504                                         &pTcp4->ConfigData );
 505     if ( EFI_ERROR ( Status )) {
 506       DEBUG (( DEBUG_CONNECT,
 507                 "ERROR - Failed to configure the Tcp4 port, Status: %r\r\n",
 508                 Status ));
 509     }
 510     else {
 511       DEBUG (( DEBUG_CONNECT,
 512                 "0x%08x: Port configured\r\n",
 513                 pPort ));
 514       pPort->bConfigured = TRUE;
 515
 516       //
 517       //  Verify the port connection
 518       //
 519       Status = pTcp4Protocol->GetModeData ( pTcp4Protocol,
 520                                             NULL,
 521                                             NULL,
 522                                             NULL,
 523                                             NULL,
 524                                             &SnpModeData );
 525       if ( !EFI_ERROR ( Status )) {
 526         if ( SnpModeData.MediaPresentSupported
 527           && ( !SnpModeData.MediaPresent )) {
 528           //
 529           //  Port is not connected to the network
 530           //
 531           Status = EFI_NO_MEDIA;
 532         }
 533         else {
 534           //
 535           //  Attempt the connection to the remote system
 536           //
 537           Status = pTcp4Protocol->Connect ( pTcp4Protocol,
 538                                             &pTcp4->ConnectToken );
 539         }
 540       }
 541       if ( EFI_ERROR ( Status )) {
 542         //
 543         //  Connection error
 544         //
 545         DEBUG (( DEBUG_CONNECT,
 546                   "ERROR - Port 0x%08x not connected, Status: %r\r\n",
 547                   pPort,
 548                   Status ));
 549       }
 550     }
 551     if ( !EFI_ERROR ( Status )) {
 552       //
 553       //  Connection in progress
 554       //
 555       pSocket->errno = EINPROGRESS;
 556       DEBUG (( DEBUG_CONNECT,
 557                 "0x%08x: Port attempting connection to %d.%d.%d.%d:%d\r\n",
 558                 pPort,
 559                 pTcp4->ConfigData.AccessPoint.RemoteAddress.Addr[0],
 560                 pTcp4->ConfigData.AccessPoint.RemoteAddress.Addr[1],
 561                 pTcp4->ConfigData.AccessPoint.RemoteAddress.Addr[2],
 562                 pTcp4->ConfigData.AccessPoint.RemoteAddress.Addr[3],
 563                 pTcp4->ConfigData.AccessPoint.RemotePort ));
 564     }
 565     else {
 566       //
 567       //  Error return path is through EslTcp4ConnectComplete to
 568       //  enable retry on other ports
 569       //
 570       //  Status to errno translation gets done in EslTcp4ConnectPoll
 571       //
 572       pTcp4->ConnectToken.CompletionToken.Status = Status;
 573
 574       //
 575       //  Continue with the next port
 576       //
 577       gBS->CheckEvent ( pTcp4->ConnectToken.CompletionToken.Event );
 578       gBS->SignalEvent ( pTcp4->ConnectToken.CompletionToken.Event );
 579     }
 580     Status = EFI_NOT_READY;
 581   }
 582   else {
 583     //
 584     //  No more local adapters available
 585     //
 586     pSocket->errno = ENETUNREACH;
 587     Status = EFI_NO_RESPONSE;
 588   }
 589
 590   //
 591   //  Return the operation status
 592   //
 593   DBG_EXIT_STATUS ( Status );
 594   return Status;
 595 }
 596
 597
 598 /**
 599   Establish the known port to listen for network connections.
 600
 601   This routine places the port into a state that enables connection
 602   attempts.
 603
 604   This routine is called by ::EslSocketListen to handle the network
 605   specifics of the listen operation for SOCK_STREAM and SOCK_SEQPACKET
 606   sockets.  See the \ref ConnectionManagement section.
 607
 608   @param [in] pSocket   Address of an ::ESL_SOCKET structure.
 609
 610   @retval EFI_SUCCESS - Socket successfully created
 611   @retval Other - Failed to enable the socket for listen
 612
 613 **/
 614 EFI_STATUS
 615 EslTcp4Listen (
 616   IN ESL_SOCKET * pSocket
 617   )
 618 {
 619   ESL_PORT * pNextPort;
 620   ESL_PORT * pPort;
 621   ESL_TCP4_CONTEXT * pTcp4;
 622   EFI_TCP4_PROTOCOL * pTcp4Protocol;
 623   EFI_STATUS Status;
 624
 625   DBG_ENTER ( );
 626
 627   //
 628   //  Verify the socket layer synchronization
 629   //
 630   VERIFY_TPL ( TPL_SOCKETS );
 631
 632   //
 633   //  Use for/break instead of goto
 634   //
 635   for ( ; ; ) {
 636     //
 637     //  Assume no ports are available
 638     //
 639     pSocket->errno = EOPNOTSUPP;
 640     Status = EFI_NOT_READY;
 641
 642     //
 643     //  Walk the list of ports
 644     //
 645     pPort = pSocket->pPortList;
 646     while ( NULL != pPort ) {
 647       //
 648       //  Assume success
 649       //
 650       pSocket->errno = 0;
 651
 652       //
 653       //  Use for/break insteak of goto
 654       //
 655       for ( ; ; ) {
 656         //
 657         //  Create the listen completion event
 658         //
 659         pTcp4 = &pPort->Context.Tcp4;
 660         Status = gBS->CreateEvent ( EVT_NOTIFY_SIGNAL,
 661                                     TPL_SOCKETS,
 662                                     (EFI_EVENT_NOTIFY)EslTcp4ListenComplete,
 663                                     pPort,
 664                                     &pTcp4->ListenToken.CompletionToken.Event );
 665         if ( EFI_ERROR ( Status )) {
 666           DEBUG (( DEBUG_ERROR | DEBUG_LISTEN,
 667                     "ERROR - Failed to create the listen completion event, Status: %r\r\n",
 668                     Status ));
 669           pSocket->errno = ENOMEM;
 670           break;
 671         }
 672         DEBUG (( DEBUG_POOL,
 673                   "0x%08x: Created listen completion event\r\n",
 674                   pTcp4->ListenToken.CompletionToken.Event ));
 675
 676         //
 677         //  Configure the port
 678         //
 679         pTcp4Protocol = pPort->pProtocol.TCPv4;
 680         Status = pTcp4Protocol->Configure ( pTcp4Protocol,
 681                                             &pTcp4->ConfigData );
 682         if ( EFI_ERROR ( Status )) {
 683           DEBUG (( DEBUG_LISTEN,
 684                     "ERROR - Failed to configure the Tcp4 port, Status: %r\r\n",
 685                     Status ));
 686           switch ( Status ) {
 687           case EFI_ACCESS_DENIED:
 688             pSocket->errno = EACCES;
 689             break;
 690
 691           default:
 692           case EFI_DEVICE_ERROR:
 693             pSocket->errno = EIO;
 694             break;
 695
 696           case EFI_INVALID_PARAMETER:
 697             pSocket->errno = EADDRNOTAVAIL;
 698             break;
 699
 700           case EFI_NO_MAPPING:
 701             pSocket->errno = EAFNOSUPPORT;
 702             break;
 703
 704           case EFI_OUT_OF_RESOURCES:
 705             pSocket->errno = ENOBUFS;
 706             break;
 707
 708           case EFI_UNSUPPORTED:
 709             pSocket->errno = EOPNOTSUPP;
 710             break;
 711           }
 712           break;
 713         }
 714         DEBUG (( DEBUG_LISTEN,
 715                   "0x%08x: Port configured\r\n",
 716                   pPort ));
 717         pPort->bConfigured = TRUE;
 718
 719         //
 720         //  Start the listen operation on the port
 721         //
 722         Status = pTcp4Protocol->Accept ( pTcp4Protocol,
 723                                          &pTcp4->ListenToken );
 724         if ( EFI_ERROR ( Status )) {
 725           DEBUG (( DEBUG_LISTEN,
 726                     "ERROR - Failed Tcp4 accept, Status: %r\r\n",
 727                     Status ));
 728           switch ( Status ) {
 729           case EFI_ACCESS_DENIED:
 730             pSocket->errno = EACCES;
 731             break;
 732
 733           default:
 734           case EFI_DEVICE_ERROR:
 735             pSocket->errno = EIO;
 736             break;
 737
 738           case EFI_INVALID_PARAMETER:
 739             pSocket->errno = EADDRNOTAVAIL;
 740             break;
 741
 742           case EFI_NOT_STARTED:
 743             pSocket->errno = ENETDOWN;
 744             break;
 745
 746           case EFI_OUT_OF_RESOURCES:
 747             pSocket->errno = ENOBUFS;
 748             break;
 749           }
 750           break;
 751         }
 752         DEBUG (( DEBUG_LISTEN,
 753                   "0x%08x: Listen pending on Port\r\n",
 754                   pPort ));
 755
 756         //
 757         //  Listen is pending on this port
 758         //
 759         break;
 760       }
 761
 762       //
 763       //  Get the next port
 764       //
 765       pNextPort = pPort->pLinkSocket;
 766
 767       //
 768       //  Close the port upon error
 769       //
 770       if ( EFI_ERROR ( Status )) {
 771         EslSocketPortCloseStart ( pPort, TRUE, DEBUG_LISTEN );
 772       }
 773
 774       //
 775       //  Set the next port
 776       //
 777       pPort = pNextPort;
 778     }
 779
 780     //
 781     //  Determine if any ports are in the listen state
 782     //
 783     if ( NULL == pSocket->pPortList ) {
 784       //
 785       //  No ports in the listen state
 786       //
 787       pSocket->MaxFifoDepth = 0;
 788
 789       //
 790       //  Return the last error detected
 791       //
 792       break;
 793     }
 794
 795     //
 796     //  Mark the socket as configured
 797     //
 798     pSocket->bConfigured = TRUE;
 799     Status = EFI_SUCCESS;
 800     pSocket->errno = 0;
 801
 802     //
 803     //  All done
 804     //
 805     DEBUG (( DEBUG_LISTEN,
 806               "0x%08x: pSocket - Listen pending on socket\r\n",
 807               pSocket ));
 808     break;
 809   }
 810
 811   //
 812   //  Return the operation status
 813   //
 814   DBG_EXIT_STATUS ( Status );
 815   return Status;
 816 }
 817
 818
 819 /**
 820   Process the connection attempt
 821
 822   A system has initiated a connection attempt with a socket in the
 823   listen state.  Attempt to complete the connection.
 824
 825   The TCPv4 layer calls this routine when a connection is made to
 826   the socket in the listen state.  See the
 827   \ref ConnectionManagement section.
 828
 829   @param [in] Event     The listen completion event
 830
 831   @param [in] pPort     Address of an ::ESL_PORT structure.
 832
 833 **/
 834 VOID
 835 EslTcp4ListenComplete (
 836   IN EFI_EVENT Event,
 837   IN ESL_PORT * pPort
 838   )
 839 {
 840   EFI_HANDLE ChildHandle;
 841   struct sockaddr_in LocalAddress;
 842   EFI_TCP4_CONFIG_DATA * pConfigData;
 843   ESL_PORT * pNewPort;
 844   ESL_SOCKET * pNewSocket;
 845   ESL_SOCKET * pSocket;
 846   ESL_TCP4_CONTEXT * pTcp4;
 847   EFI_TCP4_PROTOCOL * pTcp4Protocol;
 848   EFI_STATUS Status;
 849   EFI_HANDLE TcpPortHandle;
 850   EFI_STATUS TempStatus;
 851
 852   DBG_ENTER ( );
 853   VERIFY_AT_TPL ( TPL_SOCKETS );
 854
 855   //
 856   //  Assume success
 857   //
 858   Status = EFI_SUCCESS;
 859
 860   //
 861   //  Determine if this connection fits into the connection FIFO
 862   //
 863   pSocket = pPort->pSocket;
 864   TcpPortHandle = pPort->Context.Tcp4.ListenToken.NewChildHandle;
 865   if (( SOCKET_STATE_LISTENING == pSocket->State )
 866     && ( pSocket->MaxFifoDepth > pSocket->FifoDepth )) {
 867     //
 868     //  Allocate a socket for this connection
 869     //
 870     ChildHandle = NULL;
 871     Status = EslSocketAllocate ( &ChildHandle,
 872                                  DEBUG_CONNECTION,
 873                                  &pNewSocket );
 874     if ( !EFI_ERROR ( Status )) {
 875       //
 876       //  Clone the socket parameters
 877       //
 878       pNewSocket->pApi = pSocket->pApi;
 879       pNewSocket->Domain = pSocket->Domain;
 880       pNewSocket->Protocol = pSocket->Protocol;
 881       pNewSocket->Type = pSocket->Type;
 882
 883       //
 884       //  Build the local address
 885       //
 886       pTcp4 = &pPort->Context.Tcp4;
 887       LocalAddress.sin_len = (uint8_t)pNewSocket->pApi->MinimumAddressLength;
 888       LocalAddress.sin_family = AF_INET;
 889       LocalAddress.sin_port = 0;
 890       LocalAddress.sin_addr.s_addr = *(UINT32 *)&pTcp4->ConfigData.AccessPoint.StationAddress.Addr[0];
 891
 892       //
 893       //  Allocate a port for this connection
 894       //  Note in this instance Configure may not be called with NULL!
 895       //
 896       Status = EslSocketPortAllocate ( pNewSocket,
 897                                        pPort->pService,
 898                                        TcpPortHandle,
 899                                        (struct sockaddr *)&LocalAddress,
 900                                        FALSE,
 901                                        DEBUG_CONNECTION,
 902                                        &pNewPort );
 903       if ( !EFI_ERROR ( Status )) {
 904         //
 905         //  Restart the listen operation on the port
 906         //
 907         pTcp4Protocol = pPort->pProtocol.TCPv4;
 908         Status = pTcp4Protocol->Accept ( pTcp4Protocol,
 909                                          &pTcp4->ListenToken );
 910
 911         //
 912         //  Close the TCP port using SocketClose
 913         //
 914         TcpPortHandle = NULL;
 915         pTcp4 = &pNewPort->Context.Tcp4;
 916
 917         //
 918         //  Check for an accept call error
 919         //
 920         if ( !EFI_ERROR ( Status )) {
 921           //
 922           //  Get the port configuration
 923           //
 924           pNewPort->bConfigured = TRUE;
 925           pConfigData = &pTcp4->ConfigData;
 926           pConfigData->ControlOption = &pTcp4->Option;
 927           pTcp4Protocol = pNewPort->pProtocol.TCPv4;
 928           Status = pTcp4Protocol->GetModeData ( pTcp4Protocol,
 929                                                 NULL,
 930                                                 pConfigData,
 931                                                 NULL,
 932                                                 NULL,
 933                                                 NULL );
 934           if ( !EFI_ERROR ( Status )) {
 935             //
 936             //  Add the new socket to the connection FIFO
 937             //
 938             if ( NULL == pSocket->pFifoTail ) {
 939               //
 940               //  First connection
 941               //
 942               pSocket->pFifoHead = pNewSocket;
 943             }
 944             else {
 945               //
 946               //  Add to end of list.
 947               //
 948               pSocket->pFifoTail->pNextConnection = pNewSocket;
 949             }
 950             pSocket->pFifoTail = pNewSocket;
 951             pSocket->FifoDepth += 1;
 952
 953             //
 954             //  Update the socket state
 955             //
 956             pNewSocket->State = SOCKET_STATE_IN_FIFO;
 957
 958             //
 959             //  Log the connection
 960             //
 961             DEBUG (( DEBUG_CONNECTION | DEBUG_INFO,
 962                       "0x%08x: Socket on port %d.%d.%d.%d:%d connected to %d.%d.%d.%d:%d\r\n",
 963                       pNewSocket,
 964                       pConfigData->AccessPoint.StationAddress.Addr[0],
 965                       pConfigData->AccessPoint.StationAddress.Addr[1],
 966                       pConfigData->AccessPoint.StationAddress.Addr[2],
 967                       pConfigData->AccessPoint.StationAddress.Addr[3],
 968                       pConfigData->AccessPoint.StationPort,
 969                       pConfigData->AccessPoint.RemoteAddress.Addr[0],
 970                       pConfigData->AccessPoint.RemoteAddress.Addr[1],
 971                       pConfigData->AccessPoint.RemoteAddress.Addr[2],
 972                       pConfigData->AccessPoint.RemoteAddress.Addr[3],
 973                       pConfigData->AccessPoint.RemotePort ));
 974             DEBUG (( DEBUG_CONNECTION | DEBUG_INFO,
 975                       "0x%08x: Listen socket adding socket 0x%08x to FIFO, depth: %d\r\n",
 976                       pSocket,
 977                       pNewSocket,
 978                       pSocket->FifoDepth ));
 979
 980             //
 981             //  Start the receive operation
 982             //
 983             EslSocketRxStart ( pNewPort );
 984           }
 985           else {
 986             DEBUG (( DEBUG_ERROR | DEBUG_CONNECTION | DEBUG_INFO,
 987                       "ERROR - GetModeData failed on port 0x%08x, Status: %r\r\n",
 988                       pNewPort,
 989                       Status ));
 990           }
 991         }
 992         else {
 993           //
 994           //  The listen failed on this port
 995           //
 996           DEBUG (( DEBUG_LISTEN | DEBUG_INFO,
 997                     "ERROR - Listen failed on port 0x%08x, Status: %r\r\n",
 998                     pPort,
 999                     Status ));
1000
1001           //
1002           //  Close the listening port
1003           //
1004           EslSocketPortCloseStart ( pPort, TRUE, DEBUG_LISTEN );
1005         }
1006       }
1007
1008       //
1009       //  Done with the socket if necessary
1010       //
1011       if ( EFI_ERROR ( Status )) {
1012         TempStatus = EslSocketCloseStart ( &pNewSocket->SocketProtocol,
1013                                            TRUE,
1014                                            &pSocket->errno );
1015         ASSERT ( EFI_SUCCESS == TempStatus );
1016       }
1017     }
1018   }
1019   else {
1020     DEBUG (( DEBUG_CONNECTION,
1021               "0x%08x: Socket FIFO full, connection refused\r\n",
1022               pSocket ));
1023
1024     //
1025     //  The FIFO is full or the socket is in the wrong state
1026     //
1027     Status = EFI_BUFFER_TOO_SMALL;
1028   }
1029
1030   //
1031   //  Close the connection if necessary
1032   //
1033   if (( EFI_ERROR ( Status ))
1034     && ( NULL == TcpPortHandle )) {
1035     //
1036     // TODO: Finish this code path
1037     //  The new connection does not fit into the connection FIFO
1038     //
1039     //  Process:
1040     //    Call close
1041     //    Release the resources
1042
1043   }
1044
1045   DBG_EXIT ( );
1046 }
1047
1048
1049 /**
1050   Get the local socket address.
1051
1052   This routine returns the IPv4 address and TCP port number associated
1053   with the local socket.
1054
1055   This routine is called by ::EslSocketGetLocalAddress to determine the
1056   network address for the SOCK_STREAM or SOCK_SEQPACKET socket.
1057
1058   @param [in] pPort       Address of an ::ESL_PORT structure.
1059
1060   @param [out] pSockAddr  Network address to receive the local system address
1061
1062 **/
1063 VOID
1064 EslTcp4LocalAddressGet (
1065   IN ESL_PORT * pPort,
1066   OUT struct sockaddr * pSockAddr
1067   )
1068 {
1069   struct sockaddr_in * pLocalAddress;
1070   ESL_TCP4_CONTEXT * pTcp4;
1071
1072   DBG_ENTER ( );
1073
1074   //
1075   //  Return the local address
1076   //
1077   pTcp4 = &pPort->Context.Tcp4;
1078   pLocalAddress = (struct sockaddr_in *)pSockAddr;
1079   pLocalAddress->sin_family = AF_INET;
1080   pLocalAddress->sin_port = SwapBytes16 ( pTcp4->ConfigData.AccessPoint.StationPort );
1081   CopyMem ( &pLocalAddress->sin_addr,
1082             &pTcp4->ConfigData.AccessPoint.StationAddress.Addr[0],
1083             sizeof ( pLocalAddress->sin_addr ));
1084
1085   DBG_EXIT ( );
1086 }
1087
1088
1089 /**
1090   Set the local port address.
1091
1092   This routine sets the local port address.
1093
1094   This support routine is called by ::EslSocketPortAllocate.
1095
1096   @param [in] pPort       Address of an ESL_PORT structure
1097   @param [in] pSockAddr   Address of a sockaddr structure that contains the
1098                           connection point on the local machine.  An IPv4 address
1099                           of INADDR_ANY specifies that the connection is made to
1100                           all of the network stacks on the platform.  Specifying a
1101                           specific IPv4 address restricts the connection to the
1102                           network stack supporting that address.  Specifying zero
1103                           for the port causes the network layer to assign a port
1104                           number from the dynamic range.  Specifying a specific
1105                           port number causes the network layer to use that port.
1106
1107   @param [in] bBindTest   TRUE = run bind testing
1108
1109   @retval EFI_SUCCESS     The operation was successful
1110
1111  **/
1112 EFI_STATUS
1113 EslTcp4LocalAddressSet (
1114   IN ESL_PORT * pPort,
1115   IN CONST struct sockaddr * pSockAddr,
1116   IN BOOLEAN bBindTest
1117   )
1118 {
1119   EFI_TCP4_ACCESS_POINT * pAccessPoint;
1120   CONST struct sockaddr_in * pIpAddress;
1121   CONST UINT8 * pIpv4Address;
1122   EFI_STATUS Status;
1123
1124   DBG_ENTER ( );
1125
1126   //
1127   //  Validate the address
1128   //
1129   pIpAddress = (struct sockaddr_in *)pSockAddr;
1130   if ( INADDR_BROADCAST == pIpAddress->sin_addr.s_addr ) {
1131     //
1132     //  The local address must not be the broadcast address
1133     //
1134     Status = EFI_INVALID_PARAMETER;
1135     pPort->pSocket->errno = EADDRNOTAVAIL;
1136   }
1137   else {
1138     //
1139     //  Set the local address
1140     //
1141     pIpv4Address = (UINT8 *)&pIpAddress->sin_addr.s_addr;
1142     pAccessPoint = &pPort->Context.Tcp4.ConfigData.AccessPoint;
1143     pAccessPoint->StationAddress.Addr[0] = pIpv4Address[0];
1144     pAccessPoint->StationAddress.Addr[1] = pIpv4Address[1];
1145     pAccessPoint->StationAddress.Addr[2] = pIpv4Address[2];
1146     pAccessPoint->StationAddress.Addr[3] = pIpv4Address[3];
1147
1148     //
1149     //  Determine if the default address is used
1150     //
1151     pAccessPoint->UseDefaultAddress = (BOOLEAN)( 0 == pIpAddress->sin_addr.s_addr );
1152
1153     //
1154     //  Set the subnet mask
1155     //
1156     if ( pAccessPoint->UseDefaultAddress ) {
1157       pAccessPoint->SubnetMask.Addr[0] = 0;
1158       pAccessPoint->SubnetMask.Addr[1] = 0;
1159       pAccessPoint->SubnetMask.Addr[2] = 0;
1160       pAccessPoint->SubnetMask.Addr[3] = 0;
1161     }
1162     else {
1163       pAccessPoint->SubnetMask.Addr[0] = 0xff;
1164       pAccessPoint->SubnetMask.Addr[1] = ( 128 <= pAccessPoint->StationAddress.Addr[0]) ? 0xff : 0;
1165       pAccessPoint->SubnetMask.Addr[2] = ( 192 <= pAccessPoint->StationAddress.Addr[0]) ? 0xff : 0;
1166       pAccessPoint->SubnetMask.Addr[3] = ( 224 <= pAccessPoint->StationAddress.Addr[0]) ? 0xff : 0;
1167     }
1168
1169     //
1170     //  Validate the IP address
1171     //
1172     pAccessPoint->StationPort = 0;
1173     Status = bBindTest ? EslSocketBindTest ( pPort, EADDRNOTAVAIL )
1174                        : EFI_SUCCESS;
1175     if ( !EFI_ERROR ( Status )) {
1176       //
1177       //  Set the port number
1178       //
1179       pAccessPoint->StationPort = SwapBytes16 ( pIpAddress->sin_port );
1180       pPort->pSocket->bAddressSet = TRUE;
1181
1182       //
1183       //  Display the local address
1184       //
1185       DEBUG (( DEBUG_BIND,
1186                 "0x%08x: Port, Local TCP4 Address: %d.%d.%d.%d:%d\r\n",
1187                 pPort,
1188                 pAccessPoint->StationAddress.Addr[0],
1189                 pAccessPoint->StationAddress.Addr[1],
1190                 pAccessPoint->StationAddress.Addr[2],
1191                 pAccessPoint->StationAddress.Addr[3],
1192                 pAccessPoint->StationPort ));
1193     }
1194   }
1195
1196   //
1197   //  Return the operation status
1198   //
1199   DBG_EXIT_STATUS ( Status );
1200   return Status;
1201 }
1202
1203
1204 /**
1205   Free a receive packet
1206
1207   This routine performs the network specific operations necessary
1208   to free a receive packet.
1209
1210   This routine is called by ::EslSocketPortCloseTxDone to free a
1211   receive packet.
1212
1213   @param [in] pPacket         Address of an ::ESL_PACKET structure.
1214   @param [in, out] pRxBytes   Address of the count of RX bytes
1215
1216 **/
1217 VOID
1218 EslTcp4PacketFree (
1219   IN ESL_PACKET * pPacket,
1220   IN OUT size_t * pRxBytes
1221   )
1222 {
1223   DBG_ENTER ( );
1224
1225   //
1226   //  Account for the receive bytes
1227   //
1228   *pRxBytes -= pPacket->Op.Tcp4Rx.RxData.DataLength;
1229   DBG_EXIT ( );
1230 }
1231
1232
1233 /**
1234   Initialize the network specific portions of an ::ESL_PORT structure.
1235
1236   This routine initializes the network specific portions of an
1237   ::ESL_PORT structure for use by the socket.
1238
1239   This support routine is called by ::EslSocketPortAllocate
1240   to connect the socket with the underlying network adapter
1241   running the TCPv4 protocol.
1242
1243   @param [in] pPort       Address of an ESL_PORT structure
1244   @param [in] DebugFlags  Flags for debug messages
1245
1246   @retval EFI_SUCCESS - Socket successfully created
1247
1248  **/
1249 EFI_STATUS
1250 EslTcp4PortAllocate (
1251   IN ESL_PORT * pPort,
1252   IN UINTN DebugFlags
1253   )
1254 {
1255   EFI_TCP4_ACCESS_POINT * pAccessPoint;
1256   ESL_SOCKET * pSocket;
1257   ESL_TCP4_CONTEXT * pTcp4;
1258   EFI_STATUS Status;
1259
1260   DBG_ENTER ( );
1261
1262   //
1263   //  Use for/break instead of goto
1264   for ( ; ; ) {
1265     //
1266     //  Allocate the close event
1267     //
1268     pSocket = pPort->pSocket;
1269     pTcp4 = &pPort->Context.Tcp4;
1270     Status = gBS->CreateEvent (  EVT_NOTIFY_SIGNAL,
1271                                  TPL_SOCKETS,
1272                                  (EFI_EVENT_NOTIFY)EslSocketPortCloseComplete,
1273                                  pPort,
1274                                  &pTcp4->CloseToken.CompletionToken.Event);
1275     if ( EFI_ERROR ( Status )) {
1276       DEBUG (( DEBUG_ERROR | DebugFlags,
1277                 "ERROR - Failed to create the close event, Status: %r\r\n",
1278                 Status ));
1279       pSocket->errno = ENOMEM;
1280       break;
1281     }
1282     DEBUG (( DEBUG_CLOSE | DEBUG_POOL,
1283               "0x%08x: Created close event\r\n",
1284               pTcp4->CloseToken.CompletionToken.Event ));
1285
1286     //
1287     //  Allocate the connection event
1288     //
1289     Status = gBS->CreateEvent (  EVT_NOTIFY_SIGNAL,
1290                                  TPL_SOCKETS,
1291                                  (EFI_EVENT_NOTIFY)EslTcp4ConnectComplete,
1292                                  pPort,
1293                                  &pTcp4->ConnectToken.CompletionToken.Event);
1294     if ( EFI_ERROR ( Status )) {
1295       DEBUG (( DEBUG_ERROR | DebugFlags,
1296                 "ERROR - Failed to create the connect event, Status: %r\r\n",
1297                 Status ));
1298       pSocket->errno = ENOMEM;
1299       break;
1300     }
1301     DEBUG (( DEBUG_CLOSE | DEBUG_POOL,
1302               "0x%08x: Created connect event\r\n",
1303               pTcp4->ConnectToken.CompletionToken.Event ));
1304
1305     //
1306     //  Initialize the port
1307     //
1308     pSocket->TxPacketOffset = OFFSET_OF ( ESL_PACKET, Op.Tcp4Tx.TxData );
1309     pSocket->TxTokenEventOffset = OFFSET_OF ( ESL_IO_MGMT, Token.Tcp4Tx.CompletionToken.Event );
1310     pSocket->TxTokenOffset = OFFSET_OF ( EFI_TCP4_IO_TOKEN, Packet.TxData );
1311
1312     //
1313     //  Save the cancel, receive and transmit addresses
1314     //  pPort->pfnRxCancel = NULL; since the UEFI implementation returns EFI_UNSUPPORTED
1315     //
1316     pPort->pfnConfigure = (PFN_NET_CONFIGURE)pPort->pProtocol.TCPv4->Configure;
1317     pPort->pfnRxPoll = (PFN_NET_POLL)pPort->pProtocol.TCPv4->Poll;
1318     pPort->pfnRxStart = (PFN_NET_IO_START)pPort->pProtocol.TCPv4->Receive;
1319     pPort->pfnTxStart = (PFN_NET_IO_START)pPort->pProtocol.TCPv4->Transmit;
1320
1321     //
1322     //  Set the configuration flags
1323     //
1324     pAccessPoint = &pPort->Context.Tcp4.ConfigData.AccessPoint;
1325     pAccessPoint->ActiveFlag = FALSE;
1326     pTcp4->ConfigData.TimeToLive = 255;
1327     break;
1328   }
1329
1330   //
1331   //  Return the operation status
1332   //
1333   DBG_EXIT_STATUS ( Status );
1334   return Status;
1335 }
1336
1337
1338 /**
1339   Close a TCP4 port.
1340
1341   This routine releases the network specific resources allocated by
1342   ::EslTcp4PortAllocate.
1343
1344   This routine is called by ::EslSocketPortClose.
1345   See the \ref PortCloseStateMachine section.
1346
1347   @param [in] pPort       Address of an ::ESL_PORT structure.
1348
1349   @retval EFI_SUCCESS     The port is closed
1350   @retval other           Port close error
1351
1352 **/
1353 EFI_STATUS
1354 EslTcp4PortClose (
1355   IN ESL_PORT * pPort
1356   )
1357 {
1358   UINTN DebugFlags;
1359   ESL_TCP4_CONTEXT * pTcp4;
1360   EFI_STATUS Status;
1361
1362   DBG_ENTER ( );
1363
1364   //
1365   //  Locate the port in the socket list
1366   //
1367   Status = EFI_SUCCESS;
1368   DebugFlags = pPort->DebugFlags;
1369   pTcp4 = &pPort->Context.Tcp4;
1370
1371   //
1372   //  Done with the connect event
1373   //
1374   if ( NULL != pTcp4->ConnectToken.CompletionToken.Event ) {
1375     Status = gBS->CloseEvent ( pTcp4->ConnectToken.CompletionToken.Event );
1376     if ( !EFI_ERROR ( Status )) {
1377       DEBUG (( DebugFlags | DEBUG_POOL,
1378                 "0x%08x: Closed connect event\r\n",
1379                 pTcp4->ConnectToken.CompletionToken.Event ));
1380     }
1381     else {
1382       DEBUG (( DEBUG_ERROR | DebugFlags,
1383                 "ERROR - Failed to close the connect event, Status: %r\r\n",
1384                 Status ));
1385       ASSERT ( EFI_SUCCESS == Status );
1386     }
1387   }
1388
1389   //
1390   //  Done with the close event
1391   //
1392   if ( NULL != pTcp4->CloseToken.CompletionToken.Event ) {
1393     Status = gBS->CloseEvent ( pTcp4->CloseToken.CompletionToken.Event );
1394     if ( !EFI_ERROR ( Status )) {
1395       DEBUG (( DebugFlags | DEBUG_POOL,
1396                 "0x%08x: Closed close event\r\n",
1397                 pTcp4->CloseToken.CompletionToken.Event ));
1398     }
1399     else {
1400       DEBUG (( DEBUG_ERROR | DebugFlags,
1401                 "ERROR - Failed to close the close event, Status: %r\r\n",
1402                 Status ));
1403       ASSERT ( EFI_SUCCESS == Status );
1404     }
1405   }
1406
1407   //
1408   //  Done with the listen completion event
1409   //
1410   if ( NULL != pTcp4->ListenToken.CompletionToken.Event ) {
1411     Status = gBS->CloseEvent ( pTcp4->ListenToken.CompletionToken.Event );
1412     if ( !EFI_ERROR ( Status )) {
1413       DEBUG (( DebugFlags | DEBUG_POOL,
1414                 "0x%08x: Closed listen completion event\r\n",
1415                 pTcp4->ListenToken.CompletionToken.Event ));
1416     }
1417     else {
1418       DEBUG (( DEBUG_ERROR | DebugFlags,
1419                 "ERROR - Failed to close the listen completion event, Status: %r\r\n",
1420                 Status ));
1421       ASSERT ( EFI_SUCCESS == Status );
1422     }
1423   }
1424
1425   //
1426   //  Return the operation status
1427   //
1428   DBG_EXIT_STATUS ( Status );
1429   return Status;
1430 }
1431
1432
1433 /**
1434   Perform the network specific close operation on the port.
1435
1436   This routine performs a cancel operations on the TCPv4 port to
1437   shutdown the receive operations on the port.
1438
1439   This routine is called by the ::EslSocketPortCloseTxDone
1440   routine after the port completes all of the transmission.
1441
1442   @param [in] pPort           Address of an ::ESL_PORT structure.
1443
1444   @retval EFI_SUCCESS         The port is closed, not normally returned
1445   @retval EFI_NOT_READY       The port is still closing
1446   @retval EFI_ALREADY_STARTED Error, the port is in the wrong state,
1447                               most likely the routine was called already.
1448
1449 **/
1450 EFI_STATUS
1451 EslTcp4PortCloseOp (
1452   IN ESL_PORT * pPort
1453   )
1454 {
1455   ESL_TCP4_CONTEXT * pTcp4;
1456   EFI_TCP4_PROTOCOL * pTcp4Protocol;
1457   EFI_STATUS Status;
1458
1459   DBG_ENTER ( );
1460
1461   //
1462   //  Close the configured port
1463   //
1464   Status = EFI_SUCCESS;
1465   pTcp4 = &pPort->Context.Tcp4;
1466   pTcp4Protocol = pPort->pProtocol.TCPv4;
1467   pTcp4->CloseToken.AbortOnClose = pPort->bCloseNow;
1468   Status = pTcp4Protocol->Close ( pTcp4Protocol,
1469                                   &pTcp4->CloseToken );
1470   if ( !EFI_ERROR ( Status )) {
1471     DEBUG (( pPort->DebugFlags | DEBUG_CLOSE | DEBUG_INFO,
1472               "0x%08x: Port close started\r\n",
1473               pPort ));
1474   }
1475   else {
1476     DEBUG (( DEBUG_ERROR | pPort->DebugFlags | DEBUG_CLOSE | DEBUG_INFO,
1477              "ERROR - Close failed on port 0x%08x, Status: %r\r\n",
1478              pPort,
1479              Status ));
1480   }
1481
1482   //
1483   //  Return the operation status
1484   //
1485   DBG_EXIT_STATUS ( Status );
1486   return Status;
1487 }
1488
1489
1490 /**
1491   Receive data from a network connection.
1492
1493   This routine attempts to return buffered data to the caller.  The
1494   data is removed from the urgent queue if the message flag MSG_OOB
1495   is specified, otherwise data is removed from the normal queue.
1496   See the \ref ReceiveEngine section.
1497
1498   This routine is called by ::EslSocketReceive to handle the network
1499   specific receive operation to support SOCK_STREAM and SOCK_SEQPACKET
1500   sockets.
1501
1502   @param [in] pPort           Address of an ::ESL_PORT structure.
1503
1504   @param [in] pPacket         Address of an ::ESL_PACKET structure.
1505
1506   @param [in] pbConsumePacket Address of a BOOLEAN indicating if the packet is to be consumed
1507
1508   @param [in] BufferLength    Length of the the buffer
1509
1510   @param [in] pBuffer         Address of a buffer to receive the data.
1511
1512   @param [in] pDataLength     Number of received data bytes in the buffer.
1513
1514   @param [out] pAddress       Network address to receive the remote system address
1515
1516   @param [out] pSkipBytes     Address to receive the number of bytes skipped
1517
1518   @return   Returns the address of the next free byte in the buffer.
1519
1520  **/
1521 UINT8 *
1522 EslTcp4Receive (
1523   IN ESL_PORT * pPort,
1524   IN ESL_PACKET * pPacket,
1525   IN BOOLEAN * pbConsumePacket,
1526   IN size_t BufferLength,
1527   IN UINT8 * pBuffer,
1528   OUT size_t * pDataLength,
1529   OUT struct sockaddr * pAddress,
1530   OUT size_t * pSkipBytes
1531   )
1532 {
1533   size_t DataLength;
1534   struct sockaddr_in * pRemoteAddress;
1535   ESL_TCP4_CONTEXT * pTcp4;
1536
1537   DBG_ENTER ( );
1538
1539   //
1540   //  Return the remote system address if requested
1541   //
1542   if ( NULL != pAddress ) {
1543     //
1544     //  Build the remote address
1545     //
1546     pTcp4 = &pPort->Context.Tcp4;
1547     DEBUG (( DEBUG_RX,
1548               "Getting packet remote address: %d.%d.%d.%d:%d\r\n",
1549               pTcp4->ConfigData.AccessPoint.RemoteAddress.Addr[0],
1550               pTcp4->ConfigData.AccessPoint.RemoteAddress.Addr[1],
1551               pTcp4->ConfigData.AccessPoint.RemoteAddress.Addr[2],
1552               pTcp4->ConfigData.AccessPoint.RemoteAddress.Addr[3],
1553               pTcp4->ConfigData.AccessPoint.RemotePort ));
1554     pRemoteAddress = (struct sockaddr_in *)pAddress;
1555     CopyMem ( &pRemoteAddress->sin_addr,
1556               &pTcp4->ConfigData.AccessPoint.RemoteAddress.Addr[0],
1557               sizeof ( pRemoteAddress->sin_addr ));
1558     pRemoteAddress->sin_port = SwapBytes16 ( pTcp4->ConfigData.AccessPoint.RemotePort );
1559   }
1560
1561   //
1562   //  Determine the amount of received data
1563   //
1564   DataLength = pPacket->ValidBytes;
1565   if ( BufferLength < DataLength ) {
1566     DataLength = BufferLength;
1567   }
1568
1569   //
1570   //  Move the data into the buffer
1571   //
1572   DEBUG (( DEBUG_RX,
1573             "0x%08x: Port copy packet 0x%08x data into 0x%08x, 0x%08x bytes\r\n",
1574             pPort,
1575             pPacket,
1576             pBuffer,
1577             DataLength ));
1578   CopyMem ( pBuffer, pPacket->pBuffer, DataLength );
1579
1580   //
1581   //  Set the next buffer address
1582   //
1583   pBuffer += DataLength;
1584
1585   //
1586   //  Determine if the data is being read
1587   //
1588   if ( *pbConsumePacket ) {
1589     //
1590     //  Account for the bytes consumed
1591     //
1592     pPacket->pBuffer += DataLength;
1593     pPacket->ValidBytes -= DataLength;
1594     DEBUG (( DEBUG_RX,
1595               "0x%08x: Port account for 0x%08x bytes\r\n",
1596               pPort,
1597               DataLength ));
1598
1599     //
1600     //  Determine if the entire packet was consumed
1601     //
1602     if (( 0 == pPacket->ValidBytes )
1603       || ( SOCK_STREAM != pPort->pSocket->Type )) {
1604       //
1605       //  All done with this packet
1606       //  Account for any discarded data
1607       //
1608       *pSkipBytes = pPacket->ValidBytes;
1609     }
1610     else
1611     {
1612       //
1613       //  More data to consume later
1614       //
1615       *pbConsumePacket = FALSE;
1616     }
1617   }
1618
1619   //
1620   //  Return the data length and the buffer address
1621   //
1622   *pDataLength = DataLength;
1623   DBG_EXIT_HEX ( pBuffer );
1624   return pBuffer;
1625 }
1626
1627
1628 /**
1629   Get the remote socket address.
1630
1631   This routine returns the address of the remote connection point
1632   associated with the SOCK_STREAM or SOCK_SEQPACKET socket.
1633
1634   This routine is called by ::EslSocketGetPeerAddress to detemine
1635   the TCPv4 address and por number associated with the network adapter.
1636
1637   @param [in] pPort       Address of an ::ESL_PORT structure.
1638
1639   @param [out] pAddress   Network address to receive the remote system address
1640
1641 **/
1642 VOID
1643 EslTcp4RemoteAddressGet (
1644   IN ESL_PORT * pPort,
1645   OUT struct sockaddr * pAddress
1646   )
1647 {
1648   struct sockaddr_in * pRemoteAddress;
1649   ESL_TCP4_CONTEXT * pTcp4;
1650
1651   DBG_ENTER ( );
1652
1653   //
1654   //  Return the remote address
1655   //
1656   pTcp4 = &pPort->Context.Tcp4;
1657   pRemoteAddress = (struct sockaddr_in *)pAddress;
1658   pRemoteAddress->sin_family = AF_INET;
1659   pRemoteAddress->sin_port = SwapBytes16 ( pTcp4->ConfigData.AccessPoint.RemotePort );
1660   CopyMem ( &pRemoteAddress->sin_addr,
1661             &pTcp4->ConfigData.AccessPoint.RemoteAddress.Addr[0],
1662             sizeof ( pRemoteAddress->sin_addr ));
1663
1664   DBG_EXIT ( );
1665 }
1666
1667
1668 /**
1669   Set the remote address
1670
1671   This routine sets the remote address in the port.
1672
1673   This routine is called by ::EslSocketConnect to specify the
1674   remote network address.
1675
1676   @param [in] pPort           Address of an ::ESL_PORT structure.
1677
1678   @param [in] pSockAddr       Network address of the remote system.
1679
1680   @param [in] SockAddrLength  Length in bytes of the network address.
1681
1682   @retval EFI_SUCCESS     The operation was successful
1683
1684  **/
1685 EFI_STATUS
1686 EslTcp4RemoteAddressSet (
1687   IN ESL_PORT * pPort,
1688   IN CONST struct sockaddr * pSockAddr,
1689   IN socklen_t SockAddrLength
1690   )
1691 {
1692   CONST struct sockaddr_in * pRemoteAddress;
1693   ESL_TCP4_CONTEXT * pTcp4;
1694   EFI_STATUS Status;
1695
1696   DBG_ENTER ( );
1697
1698   //
1699   //  Set the remote address
1700   //
1701   pTcp4 = &pPort->Context.Tcp4;
1702   pRemoteAddress = (struct sockaddr_in *)pSockAddr;
1703   pTcp4->ConfigData.AccessPoint.RemoteAddress.Addr[0] = (UINT8)( pRemoteAddress->sin_addr.s_addr );
1704   pTcp4->ConfigData.AccessPoint.RemoteAddress.Addr[1] = (UINT8)( pRemoteAddress->sin_addr.s_addr >> 8 );
1705   pTcp4->ConfigData.AccessPoint.RemoteAddress.Addr[2] = (UINT8)( pRemoteAddress->sin_addr.s_addr >> 16 );
1706   pTcp4->ConfigData.AccessPoint.RemoteAddress.Addr[3] = (UINT8)( pRemoteAddress->sin_addr.s_addr >> 24 );
1707   pTcp4->ConfigData.AccessPoint.RemotePort = SwapBytes16 ( pRemoteAddress->sin_port );
1708   Status = EFI_SUCCESS;
1709   if ( INADDR_BROADCAST == pRemoteAddress->sin_addr.s_addr ) {
1710     DEBUG (( DEBUG_CONNECT,
1711               "ERROR - Invalid remote address\r\n" ));
1712     Status = EFI_INVALID_PARAMETER;
1713     pPort->pSocket->errno = EAFNOSUPPORT;
1714   }
1715
1716   //
1717   //  Return the operation status
1718   //
1719   DBG_EXIT_STATUS ( Status );
1720   return Status;
1721 }
1722
1723
1724 /**
1725   Process the receive completion
1726
1727   This routine queues the data in FIFO order in either the urgent
1728   or normal data queues depending upon the type of data received.
1729   See the \ref ReceiveEngine section.
1730
1731   This routine is called by the TCPv4 driver when some data is
1732   received.
1733
1734   Buffer the data that was just received.
1735
1736   @param [in] Event     The receive completion event
1737
1738   @param [in] pIo       Address of an ::ESL_IO_MGMT structure
1739
1740 **/
1741 VOID
1742 EslTcp4RxComplete (
1743   IN EFI_EVENT Event,
1744   IN ESL_IO_MGMT * pIo
1745   )
1746 {
1747   BOOLEAN bUrgent;
1748   size_t LengthInBytes;
1749   ESL_PACKET * pPacket;
1750   EFI_STATUS Status;
1751
1752   DBG_ENTER ( );
1753
1754   //
1755   //  Get the operation status.
1756   //
1757   Status = pIo->Token.Tcp4Rx.CompletionToken.Status;
1758
1759   //
1760   //      +--------------------+   +---------------------------+
1761   //      | ESL_IO_MGMT        |   | ESL_PACKET                |
1762   //      |                    |   |                           |
1763   //      |    +---------------+   +-----------------------+   |
1764   //      |    | Token         |   | EFI_TCP4_RECEIVE_DATA |   |
1765   //      |    |        RxData --> |                       |   |
1766   //      |    |               |   +-----------------------+---+
1767   //      |    |        Event  |   |       Data Buffer         |
1768   //      +----+---------------+   |                           |
1769   //                               |                           |
1770   //                               +---------------------------+
1771   //
1772   //
1773   //  Duplicate the buffer address and length for use by the
1774   //  buffer handling code in EslTcp4Receive.  These fields are
1775   //  used when a partial read is done of the data from the
1776   //  packet.
1777   //
1778   pPacket = pIo->pPacket;
1779   pPacket->pBuffer = pPacket->Op.Tcp4Rx.RxData.FragmentTable[0].FragmentBuffer;
1780   LengthInBytes = pPacket->Op.Tcp4Rx.RxData.DataLength;
1781   pPacket->ValidBytes = LengthInBytes;
1782
1783   //
1784   //  Get the data type so that it may be linked to the
1785   //  correct receive buffer list on the ESL_SOCKET structure
1786   //
1787   bUrgent = pPacket->Op.Tcp4Rx.RxData.UrgentFlag;
1788
1789   //
1790   //  Complete this request
1791   //
1792   EslSocketRxComplete ( pIo, Status, LengthInBytes, bUrgent );
1793   DBG_EXIT ( );
1794 }
1795
1796
1797 /**
1798   Start a receive operation
1799
1800   This routine posts a receive buffer to the TCPv4 driver.
1801   See the \ref ReceiveEngine section.
1802
1803   This support routine is called by EslSocketRxStart.
1804
1805   @param [in] pPort       Address of an ::ESL_PORT structure.
1806   @param [in] pIo         Address of an ::ESL_IO_MGMT structure.
1807
1808  **/
1809 VOID
1810 EslTcp4RxStart (
1811   IN ESL_PORT * pPort,
1812   IN ESL_IO_MGMT * pIo
1813   )
1814 {
1815   ESL_PACKET * pPacket;
1816
1817   DBG_ENTER ( );
1818
1819   //
1820   //  Initialize the buffer for receive
1821   //
1822   pPacket = pIo->pPacket;
1823   pIo->Token.Tcp4Rx.Packet.RxData = &pPacket->Op.Tcp4Rx.RxData;
1824   pPacket->Op.Tcp4Rx.RxData.DataLength = sizeof ( pPacket->Op.Tcp4Rx.Buffer );
1825   pPacket->Op.Tcp4Rx.RxData.FragmentCount = 1;
1826   pPacket->Op.Tcp4Rx.RxData.FragmentTable[0].FragmentLength = pPacket->Op.Tcp4Rx.RxData.DataLength;
1827   pPacket->Op.Tcp4Rx.RxData.FragmentTable[0].FragmentBuffer = &pPacket->Op.Tcp4Rx.Buffer[0];
1828
1829   DBG_EXIT ( );
1830 }
1831
1832
1833 /**
1834   Determine if the socket is configured.
1835
1836   This routine uses the flag ESL_SOCKET::bConfigured to determine
1837   if the network layer's configuration routine has been called.
1838
1839   This routine is called by EslSocketIsConfigured to verify
1840   that the socket has been configured.
1841
1842   @param [in] pSocket   Address of an ::ESL_SOCKET structure.
1843
1844   @retval EFI_SUCCESS - The port is connected
1845   @retval EFI_NOT_STARTED - The port is not connected
1846
1847  **/
1848  EFI_STATUS
1849  EslTcp4SocketIsConfigured (
1850   IN ESL_SOCKET * pSocket
1851   )
1852 {
1853   EFI_STATUS Status;
1854
1855   DBG_ENTER ( );
1856
1857   //
1858   //  Determine the socket configuration status
1859   //
1860   Status = pSocket->bConfigured ? EFI_SUCCESS : EFI_NOT_STARTED;
1861
1862   //
1863   //  Return the port connected state.
1864   //
1865   DBG_EXIT_STATUS ( Status );
1866   return Status;
1867 }
1868
1869
1870 /**
1871   Buffer data for transmission over a network connection.
1872
1873   This routine buffers data for the transmit engine in one of two
1874   queues, one for urgent (out-of-band) data and the other for normal
1875   data.  The urgent data is provided to TCP as soon as it is available,
1876   allowing the TCP layer to schedule transmission of the urgent data
1877   between packets of normal data.
1878
1879   This routine is called by ::EslSocketTransmit to buffer
1880   data for transmission.  When the \ref TransmitEngine has resources,
1881   this routine will start the transmission of the next buffer on
1882   the network connection.
1883
1884   Transmission errors are returned during the next transmission or
1885   during the close operation.  Only buffering errors are returned
1886   during the current transmission attempt.
1887
1888   @param [in] pSocket         Address of an ::ESL_SOCKET structure
1889
1890   @param [in] Flags           Message control flags
1891
1892   @param [in] BufferLength    Length of the the buffer
1893
1894   @param [in] pBuffer         Address of a buffer to receive the data.
1895
1896   @param [in] pDataLength     Number of received data bytes in the buffer.
1897
1898   @param [in] pAddress        Network address of the remote system address
1899
1900   @param [in] AddressLength   Length of the remote network address structure
1901
1902   @retval EFI_SUCCESS - Socket data successfully buffered
1903
1904  **/
1905 EFI_STATUS
1906 EslTcp4TxBuffer (
1907   IN ESL_SOCKET * pSocket,
1908   IN int Flags,
1909   IN size_t BufferLength,
1910   IN CONST UINT8 * pBuffer,
1911   OUT size_t * pDataLength,
1912   IN const struct sockaddr * pAddress,
1913   IN socklen_t AddressLength
1914   )
1915 {
1916   BOOLEAN bUrgent;
1917   BOOLEAN bUrgentQueue;
1918   ESL_PACKET * pPacket;
1919   ESL_IO_MGMT ** ppActive;
1920   ESL_IO_MGMT ** ppFree;
1921   ESL_PORT * pPort;
1922   ESL_PACKET ** ppQueueHead;
1923   ESL_PACKET ** ppQueueTail;
1924   ESL_PACKET * pPreviousPacket;
1925   size_t * pTxBytes;
1926   EFI_TCP4_TRANSMIT_DATA * pTxData;
1927   EFI_STATUS Status;
1928   EFI_TPL TplPrevious;
1929
1930   DBG_ENTER ( );
1931
1932   //
1933   //  Assume failure
1934   //
1935   Status = EFI_UNSUPPORTED;
1936   pSocket->errno = ENOTCONN;
1937   *pDataLength = 0;
1938
1939   //
1940   //  Verify that the socket is connected
1941   //
1942   if ( SOCKET_STATE_CONNECTED == pSocket->State ) {
1943     //
1944     //  Locate the port
1945     //
1946     pPort = pSocket->pPortList;
1947     if ( NULL != pPort ) {
1948       //
1949       //  Determine the queue head
1950       //
1951       bUrgent = (BOOLEAN)( 0 != ( Flags & MSG_OOB ));
1952       bUrgentQueue = bUrgent
1953                     && ( !pSocket->bOobInLine )
1954                     && pSocket->pApi->bOobSupported;
1955       if ( bUrgentQueue ) {
1956         ppQueueHead = &pSocket->pTxOobPacketListHead;
1957         ppQueueTail = &pSocket->pTxOobPacketListTail;
1958         ppActive = &pPort->pTxOobActive;
1959         ppFree = &pPort->pTxOobFree;
1960         pTxBytes = &pSocket->TxOobBytes;
1961       }
1962       else {
1963         ppQueueHead = &pSocket->pTxPacketListHead;
1964         ppQueueTail = &pSocket->pTxPacketListTail;
1965         ppActive = &pPort->pTxActive;
1966         ppFree = &pPort->pTxFree;
1967         pTxBytes = &pSocket->TxBytes;
1968       }
1969
1970       //
1971       //  Verify that there is enough room to buffer another
1972       //  transmit operation
1973       //
1974       if ( pSocket->MaxTxBuf > *pTxBytes ) {
1975         if ( pPort->bTxFlowControl ) {
1976           DEBUG (( DEBUG_TX,
1977                     "TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT\r\n0x%08x: pPort, TX flow control released, Max bytes: %d > %d bufferred bytes\r\n",
1978                     pPort,
1979                     pSocket->MaxTxBuf,
1980                     *pTxBytes ));
1981           pPort->bTxFlowControl = FALSE;
1982         }
1983
1984         //
1985         //  Attempt to allocate the packet
1986         //
1987         Status = EslSocketPacketAllocate ( &pPacket,
1988                                            sizeof ( pPacket->Op.Tcp4Tx )
1989                                            - sizeof ( pPacket->Op.Tcp4Tx.Buffer )
1990                                            + BufferLength,
1991                                            0,
1992                                            DEBUG_TX );
1993         if ( !EFI_ERROR ( Status )) {
1994           //
1995           //  Initialize the transmit operation
1996           //
1997           pTxData = &pPacket->Op.Tcp4Tx.TxData;
1998           pTxData->Push = TRUE || bUrgent;
1999           pTxData->Urgent = bUrgent;
2000           pTxData->DataLength = (UINT32) BufferLength;
2001           pTxData->FragmentCount = 1;
2002           pTxData->FragmentTable[0].FragmentLength = (UINT32) BufferLength;
2003           pTxData->FragmentTable[0].FragmentBuffer = &pPacket->Op.Tcp4Tx.Buffer[0];
2004
2005           //
2006           //  Copy the data into the buffer
2007           //
2008           CopyMem ( &pPacket->Op.Tcp4Tx.Buffer[0],
2009                     pBuffer,
2010                     BufferLength );
2011
2012           //
2013           //  Synchronize with the socket layer
2014           //
2015           RAISE_TPL ( TplPrevious, TPL_SOCKETS );
2016
2017           //
2018           //  Stop transmission after an error
2019           //
2020           if ( !EFI_ERROR ( pSocket->TxError )) {
2021             //
2022             //  Display the request
2023             //
2024             DEBUG (( DEBUG_TX,
2025                       "Send %d %s bytes from 0x%08x\r\n",
2026                       BufferLength,
2027                       bUrgent ? L"urgent" : L"normal",
2028                       pBuffer ));
2029
2030             //
2031             //  Queue the data for transmission
2032             //
2033             pPacket->pNext = NULL;
2034             pPreviousPacket = *ppQueueTail;
2035             if ( NULL == pPreviousPacket ) {
2036               *ppQueueHead = pPacket;
2037             }
2038             else {
2039               pPreviousPacket->pNext = pPacket;
2040             }
2041             *ppQueueTail = pPacket;
2042             DEBUG (( DEBUG_TX,
2043                       "0x%08x: Packet on %s transmit list\r\n",
2044                       pPacket,
2045                       bUrgentQueue ? L"urgent" : L"normal" ));
2046
2047             //
2048             //  Account for the buffered data
2049             //
2050             *pTxBytes += BufferLength;
2051             *pDataLength = BufferLength;
2052
2053             //
2054             //  Start the transmit engine if it is idle
2055             //
2056             if ( NULL != *ppFree ) {
2057               EslSocketTxStart ( pPort,
2058                                  ppQueueHead,
2059                                  ppQueueTail,
2060                                  ppActive,
2061                                  ppFree );
2062             }
2063           }
2064           else {
2065             //
2066             //  Previous transmit error
2067             //  Stop transmission
2068             //
2069             Status = pSocket->TxError;
2070             pSocket->errno = EIO;
2071
2072             //
2073             //  Free the packet
2074             //
2075             EslSocketPacketFree ( pPacket, DEBUG_TX );
2076           }
2077
2078           //
2079           //  Release the socket layer synchronization
2080           //
2081           RESTORE_TPL ( TplPrevious );
2082         }
2083         else {
2084           //
2085           //  Packet allocation failed
2086           //
2087           pSocket->errno = ENOMEM;
2088         }
2089       }
2090       else {
2091         if ( !pPort->bTxFlowControl ) {
2092           DEBUG (( DEBUG_TX,
2093                     "0x%08x: pPort, TX flow control applied, Max bytes %d <= %d bufferred bytes\r\nTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT\r\n",
2094                     pPort,
2095                     pSocket->MaxTxBuf,
2096                     *pTxBytes ));
2097           pPort->bTxFlowControl = TRUE;
2098         }
2099         //
2100         //  Not enough buffer space available
2101         //
2102         pSocket->errno = EAGAIN;
2103         Status = EFI_NOT_READY;
2104       }
2105     }
2106   }
2107
2108   //
2109   //  Return the operation status
2110   //
2111   DBG_EXIT_STATUS ( Status );
2112   return Status;
2113 }
2114
2115
2116 /**
2117   Process the normal data transmit completion
2118
2119   This routine use ::EslSocketTxComplete to perform the transmit
2120   completion processing for normal data.
2121
2122   This routine is called by the TCPv4 network layer when a
2123   normal data transmit request completes.
2124
2125   @param [in] Event     The normal transmit completion event
2126
2127   @param [in] pIo       The ESL_IO_MGMT structure address
2128
2129 **/
2130 VOID
2131 EslTcp4TxComplete (
2132   IN EFI_EVENT Event,
2133   IN ESL_IO_MGMT * pIo
2134   )
2135 {
2136   UINT32 LengthInBytes;
2137   ESL_PACKET * pPacket;
2138   ESL_PORT * pPort;
2139   ESL_SOCKET * pSocket;
2140   EFI_STATUS Status;
2141
2142   DBG_ENTER ( );
2143
2144   //
2145   //  Locate the active transmit packet
2146   //
2147   pPacket = pIo->pPacket;
2148   pPort = pIo->pPort;
2149   pSocket = pPort->pSocket;
2150
2151   //
2152   //  Get the transmit length and status
2153   //
2154   LengthInBytes = pPacket->Op.Tcp4Tx.TxData.DataLength;
2155   pSocket->TxBytes -= LengthInBytes;
2156   Status = pIo->Token.Tcp4Tx.CompletionToken.Status;
2157
2158   //
2159   //  Complete the transmit operation
2160   //
2161   EslSocketTxComplete ( pIo,
2162                         LengthInBytes,
2163                         Status,
2164                         "Normal ",
2165                         &pSocket->pTxPacketListHead,
2166                         &pSocket->pTxPacketListTail,
2167                         &pPort->pTxActive,
2168                         &pPort->pTxFree );
2169   DBG_EXIT ( );
2170 }
2171
2172
2173 /**
2174   Process the urgent data transmit completion
2175
2176   This routine use ::EslSocketTxComplete to perform the transmit
2177   completion processing for urgent data.
2178
2179   This routine is called by the TCPv4 network layer when a
2180   urgent data transmit request completes.
2181
2182   @param [in] Event     The urgent transmit completion event
2183
2184   @param [in] pIo       The ESL_IO_MGMT structure address
2185
2186 **/
2187 VOID
2188 EslTcp4TxOobComplete (
2189   IN EFI_EVENT Event,
2190   IN ESL_IO_MGMT * pIo
2191   )
2192 {
2193   UINT32 LengthInBytes;
2194   ESL_PACKET * pPacket;
2195   ESL_PORT * pPort;
2196   ESL_SOCKET * pSocket;
2197   EFI_STATUS Status;
2198
2199   DBG_ENTER ( );
2200
2201   //
2202   //  Locate the active transmit packet
2203   //
2204   pPacket = pIo->pPacket;
2205   pPort = pIo->pPort;
2206   pSocket = pPort->pSocket;
2207
2208   //
2209   //  Get the transmit length and status
2210   //
2211   LengthInBytes = pPacket->Op.Tcp4Tx.TxData.DataLength;
2212   pSocket->TxOobBytes -= LengthInBytes;
2213   Status = pIo->Token.Tcp4Tx.CompletionToken.Status;
2214
2215   //
2216   //  Complete the transmit operation
2217   //
2218   EslSocketTxComplete ( pIo,
2219                         LengthInBytes,
2220                         Status,
2221                         "Urgent ",
2222                         &pSocket->pTxOobPacketListHead,
2223                         &pSocket->pTxOobPacketListTail,
2224                         &pPort->pTxOobActive,
2225                         &pPort->pTxOobFree );
2226   DBG_EXIT ( );
2227 }
2228
2229
2230 /**
2231   Verify the adapter's IP address
2232
2233   This support routine is called by EslSocketBindTest.
2234
2235   @param [in] pPort       Address of an ::ESL_PORT structure.
2236   @param [in] pConfigData Address of the configuration data
2237
2238   @retval EFI_SUCCESS - The IP address is valid
2239   @retval EFI_NOT_STARTED - The IP address is invalid
2240
2241  **/
2242 EFI_STATUS
2243 EslTcp4VerifyLocalIpAddress (
2244   IN ESL_PORT * pPort,
2245   IN EFI_TCP4_CONFIG_DATA * pConfigData
2246   )
2247 {
2248   UINTN DataSize;
2249   EFI_TCP4_ACCESS_POINT * pAccess;
2250   EFI_IP4_CONFIG2_INTERFACE_INFO * pIfInfo;
2251   EFI_IP4_CONFIG2_PROTOCOL * pIpConfig2Protocol;
2252   ESL_SERVICE * pService;
2253   EFI_STATUS Status;
2254
2255   DBG_ENTER ( );
2256
2257   //
2258   //  Use break instead of goto
2259   //
2260   pIfInfo = NULL;
2261   for ( ; ; ) {
2262     //
2263     //  Determine if the IP address is specified
2264     //
2265     pAccess = &pConfigData->AccessPoint;
2266     DEBUG (( DEBUG_BIND,
2267               "UseDefaultAddress: %s\r\n",
2268               pAccess->UseDefaultAddress ? L"TRUE" : L"FALSE" ));
2269     DEBUG (( DEBUG_BIND,
2270               "Requested IP address: %d.%d.%d.%d\r\n",
2271               pAccess->StationAddress.Addr [ 0 ],
2272               pAccess->StationAddress.Addr [ 1 ],
2273               pAccess->StationAddress.Addr [ 2 ],
2274               pAccess->StationAddress.Addr [ 3 ]));
2275     if ( pAccess->UseDefaultAddress
2276       || (( 0 == pAccess->StationAddress.Addr [ 0 ])
2277       && ( 0 == pAccess->StationAddress.Addr [ 1 ])
2278       && ( 0 == pAccess->StationAddress.Addr [ 2 ])
2279       && ( 0 == pAccess->StationAddress.Addr [ 3 ])))
2280     {
2281       Status = EFI_SUCCESS;
2282       break;
2283     }
2284
2285     //
2286     //  Open the configuration protocol
2287     //
2288     pService = pPort->pService;
2289     Status = gBS->OpenProtocol (
2290                     pService->Controller,
2291                     &gEfiIp4Config2ProtocolGuid,
2292                     (VOID **)&pIpConfig2Protocol,
2293                     NULL,
2294                     NULL,
2295                     EFI_OPEN_PROTOCOL_GET_PROTOCOL
2296                     );
2297     if ( EFI_ERROR ( Status )) {
2298       DEBUG (( DEBUG_ERROR,
2299                 "ERROR - IP Configuration Protocol not available, Status: %r\r\n",
2300                 Status ));
2301       break;
2302     }
2303
2304     //
2305     // Get the interface information size.
2306     //
2307     DataSize = 0;
2308     Status = pIpConfig2Protocol->GetData (
2309                                    pIpConfig2Protocol,
2310                                    Ip4Config2DataTypeInterfaceInfo,
2311                                    &DataSize,
2312                                    NULL
2313                                    );
2314     if ( EFI_BUFFER_TOO_SMALL != Status ) {
2315       DEBUG (( DEBUG_ERROR,
2316                 "ERROR - Failed to get the interface information size, Status: %r\r\n",
2317                 Status ));
2318       break;
2319     }
2320
2321     //
2322     //  Allocate the interface information buffer
2323     //
2324     pIfInfo = AllocatePool ( DataSize );
2325     if ( NULL == pIfInfo ) {
2326       DEBUG (( DEBUG_ERROR,
2327                 "ERROR - Not enough memory to allocate the interface information buffer!\r\n" ));
2328       Status = EFI_OUT_OF_RESOURCES;
2329       break;
2330     }
2331
2332     //
2333     // Get the interface info.
2334     //
2335     Status = pIpConfig2Protocol->GetData (
2336                                   pIpConfig2Protocol,
2337                                   Ip4Config2DataTypeInterfaceInfo,
2338                                   &DataSize,
2339                                   pIfInfo
2340                                   );
2341     if ( EFI_ERROR ( Status )) {
2342       DEBUG (( DEBUG_ERROR,
2343                 "ERROR - Failed to return the interface info, Status: %r\r\n",
2344                 Status ));
2345       break;
2346     }
2347
2348     //
2349     //  Display the current configuration
2350     //
2351     DEBUG (( DEBUG_BIND,
2352               "Actual adapter IP address: %d.%d.%d.%d\r\n",
2353               pIfInfo->StationAddress.Addr [ 0 ],
2354               pIfInfo->StationAddress.Addr [ 1 ],
2355               pIfInfo->StationAddress.Addr [ 2 ],
2356               pIfInfo->StationAddress.Addr [ 3 ]));
2357
2358     //
2359     //  Assume the port is not configured
2360     //
2361     Status = EFI_SUCCESS;
2362     if (( pAccess->StationAddress.Addr [ 0 ] == pIfInfo->StationAddress.Addr [ 0 ])
2363       && ( pAccess->StationAddress.Addr [ 1 ] == pIfInfo->StationAddress.Addr [ 1 ])
2364       && ( pAccess->StationAddress.Addr [ 2 ] == pIfInfo->StationAddress.Addr [ 2 ])
2365       && ( pAccess->StationAddress.Addr [ 3 ] == pIfInfo->StationAddress.Addr [ 3 ])) {
2366       break;
2367     }
2368
2369     //
2370     //  The IP address did not match
2371     //
2372     Status = EFI_NOT_STARTED;
2373     break;
2374   }
2375
2376   //
2377   //  Free the buffer if necessary
2378   //
2379   if ( NULL != pIfInfo ) {
2380     FreePool ( pIfInfo );
2381   }
2382
2383   //
2384   //  Return the IP address status
2385   //
2386   DBG_EXIT_STATUS ( Status );
2387   return Status;
2388 }
2389
2390
2391 /**
2392   Interface between the socket layer and the network specific
2393   code that supports SOCK_STREAM and SOCK_SEQPACKET sockets
2394   over TCPv4.
2395 **/
2396 CONST ESL_PROTOCOL_API cEslTcp4Api = {
2397   "TCPv4",
2398   IPPROTO_TCP,
2399   OFFSET_OF ( ESL_PORT, Context.Tcp4.ConfigData ),
2400   OFFSET_OF ( ESL_LAYER, pTcp4List ),
2401   OFFSET_OF ( struct sockaddr_in, sin_zero ),
2402   sizeof ( struct sockaddr_in ),
2403   AF_INET,
2404   sizeof (((ESL_PACKET *)0 )->Op.Tcp4Rx ),
2405   OFFSET_OF ( ESL_PACKET, Op.Tcp4Rx.Buffer ) - OFFSET_OF ( ESL_PACKET, Op ),
2406   OFFSET_OF ( ESL_IO_MGMT, Token.Tcp4Rx.Packet.RxData ),
2407   TRUE,
2408   EADDRINUSE,
2409   EslTcp4Accept,
2410   EslTcp4ConnectPoll,
2411   EslTcp4ConnectStart,
2412   EslTcp4SocketIsConfigured,
2413   EslTcp4LocalAddressGet,
2414   EslTcp4LocalAddressSet,
2415   EslTcp4Listen,
2416   NULL,   //  OptionGet
2417   NULL,   //  OptionSet
2418   EslTcp4PacketFree,
2419   EslTcp4PortAllocate,
2420   EslTcp4PortClose,
2421   EslTcp4PortCloseOp,
2422   FALSE,
2423   EslTcp4Receive,
2424   EslTcp4RemoteAddressGet,
2425   EslTcp4RemoteAddressSet,
2426   EslTcp4RxComplete,
2427   EslTcp4RxStart,
2428   EslTcp4TxBuffer,
2429   EslTcp4TxComplete,
2430   EslTcp4TxOobComplete,
2431   (PFN_API_VERIFY_LOCAL_IP_ADDRESS)EslTcp4VerifyLocalIpAddress
2432 };