VirtualBox

source: vbox/trunk/src/VBox/Devices/EFI/Firmware/StdLib/EfiSocketLib/Tcp4.c@ 57260

Last change on this file since 57260 was 48674, checked in by vboxsync, 11 years ago

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

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette