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