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