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