3 Copyright (c) 2005 - 2006, Intel Corporation
4 All rights reserved. This program and the accompanying materials
5 are licensed and made available under the terms and conditions of the BSD License
6 which accompanies this distribution. The full text of the license may be found at
7 http://opensource.org/licenses/bsd-license.php
9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
26 IN SOCK_BUFFER
*SockBuffer
,
47 Get the length of the data that can be retrieved from the socket
50 @param SockBuffer Pointer to the socket receive buffer.
51 @param IsUrg Pointer to a BOOLEAN variable. If TRUE the data is
53 @param BufLen The maximum length of the data buffer to store the
54 received data in socket layer.
56 @return The length of the data can be retreived.
62 IN SOCK_BUFFER
*SockBuffer
,
69 TCP_RSV_DATA
*TcpRsvData
;
72 ASSERT (SockBuffer
&& IsUrg
&& (BufLen
> 0));
74 RcvBufEntry
= SockBufFirst (SockBuffer
);
77 TcpRsvData
= (TCP_RSV_DATA
*) RcvBufEntry
->ProtoData
;
79 *IsUrg
= (BOOLEAN
) ((TcpRsvData
->UrgLen
> 0) ? TRUE
: FALSE
);
81 if (*IsUrg
&& TcpRsvData
->UrgLen
< RcvBufEntry
->TotalSize
) {
83 DataLen
= MIN (TcpRsvData
->UrgLen
, BufLen
);
85 if (DataLen
< TcpRsvData
->UrgLen
) {
86 TcpRsvData
->UrgLen
= TcpRsvData
->UrgLen
- DataLen
;
88 TcpRsvData
->UrgLen
= 0;
95 DataLen
= RcvBufEntry
->TotalSize
;
97 RcvBufEntry
= SockBufNext (SockBuffer
, RcvBufEntry
);
99 while ((BufLen
> DataLen
) && (RcvBufEntry
!= NULL
)) {
101 TcpRsvData
= (TCP_RSV_DATA
*) RcvBufEntry
->ProtoData
;
103 Urg
= (BOOLEAN
) ((TcpRsvData
->UrgLen
> 0) ? TRUE
: FALSE
);
109 if (*IsUrg
&& TcpRsvData
->UrgLen
< RcvBufEntry
->TotalSize
) {
111 if (TcpRsvData
->UrgLen
+ DataLen
< BufLen
) {
112 TcpRsvData
->UrgLen
= 0;
114 TcpRsvData
->UrgLen
= TcpRsvData
->UrgLen
- (BufLen
- DataLen
);
117 return MIN (TcpRsvData
->UrgLen
+ DataLen
, BufLen
);
121 DataLen
+= RcvBufEntry
->TotalSize
;
123 RcvBufEntry
= SockBufNext (SockBuffer
, RcvBufEntry
);
126 DataLen
= MIN (BufLen
, DataLen
);
132 Copy data from socket buffer to application provided receive buffer.
134 @param Sock Pointer to the socket.
135 @param TcpRxData Pointer to the application provided receive buffer.
136 @param RcvdBytes The maximum length of the data can be copied.
137 @param IsOOB If TURE the data is OOB, else the data is normal.
153 EFI_TCP4_RECEIVE_DATA
*RxData
;
154 EFI_TCP4_FRAGMENT_DATA
*Fragment
;
156 RxData
= (EFI_TCP4_RECEIVE_DATA
*) TcpRxData
;
160 ASSERT (RxData
->DataLength
>= RcvdBytes
);
162 RxData
->DataLength
= RcvdBytes
;
163 RxData
->UrgentFlag
= IsOOB
;
165 for (Index
= 0; (Index
< RxData
->FragmentCount
) && (RcvdBytes
> 0); Index
++) {
167 Fragment
= &RxData
->FragmentTable
[Index
];
168 CopyBytes
= MIN ((UINT32
) (Fragment
->FragmentLength
), RcvdBytes
);
171 Sock
->RcvBuffer
.DataQueue
,
174 Fragment
->FragmentBuffer
177 Fragment
->FragmentLength
= CopyBytes
;
178 RcvdBytes
-= CopyBytes
;
185 Get received data from the socket layer to the receive token.
187 @param Sock Pointer to the socket.
188 @param RcvToken Pointer to the application provided receive token.
190 @return The length of data received in this token.
194 SockProcessRcvToken (
196 IN SOCK_IO_TOKEN
*RcvToken
199 UINT32 TokenRcvdBytes
;
200 EFI_TCP4_RECEIVE_DATA
*RxData
;
205 ASSERT (SOCK_STREAM
== Sock
->Type
);
207 RxData
= RcvToken
->Packet
.RxData
;
209 TokenRcvdBytes
= SockTcpDataToRcv (
212 (UINT32
) RxData
->DataLength
216 // Copy data from RcvBuffer of socket to user
217 // provided RxData and set the fields in TCP RxData
219 SockSetTcpRxData (Sock
, RxData
, TokenRcvdBytes
, IsUrg
);
221 SOCK_TRIM_RCV_BUFF (Sock
, TokenRcvdBytes
);
222 SIGNAL_TOKEN (&(RcvToken
->Token
), EFI_SUCCESS
);
224 return TokenRcvdBytes
;
229 Process the TCP send data, buffer the tcp txdata and append
230 the buffer to socket send buffer,then try to send it.
232 @param Sock Pointer to the socket.
233 @param TcpTxData Pointer to the tcp txdata.
235 @retval EFI_SUCCESS The operation is completed successfully.
236 @retval EFI_OUT_OF_RESOURCES Failed due to resource limit.
240 SockProcessTcpSndData (
247 EFI_TCP4_TRANSMIT_DATA
*TxData
;
249 TxData
= (EFI_TCP4_TRANSMIT_DATA
*) TcpTxData
;
252 // transform this TxData into a NET_BUFFER
253 // and insert it into Sock->SndBuffer
255 SndData
= NetbufFromExt (
256 (NET_FRAGMENT
*) TxData
->FragmentTable
,
257 (UINT32
) TxData
->FragmentCount
,
264 if (NULL
== SndData
) {
265 SOCK_DEBUG_ERROR (("SockKProcessSndData: Failed to"
266 " call NetBufferFromExt\n"));
268 return EFI_OUT_OF_RESOURCES
;
271 NetbufQueAppend (Sock
->SndBuffer
.DataQueue
, SndData
);
274 // notify the low layer protocol to handle this send token
276 if (TxData
->Urgent
) {
277 Status
= Sock
->ProtoHandler (Sock
, SOCK_SNDURG
, NULL
);
279 if (EFI_ERROR (Status
)) {
285 Status
= Sock
->ProtoHandler (Sock
, SOCK_SNDPUSH
, NULL
);
287 if (EFI_ERROR (Status
)) {
293 // low layer protocol should really handle the sending
294 // process when catching SOCK_SND request
296 Status
= Sock
->ProtoHandler (Sock
, SOCK_SND
, NULL
);
298 if (EFI_ERROR (Status
)) {
307 Flush the tokens in the specific token list.
309 @param Sock Pointer to the socket.
310 @param PendingTokenList Pointer to the token list to be flushed.
317 SockFlushPendingToken (
319 IN NET_LIST_ENTRY
*PendingTokenList
322 SOCK_TOKEN
*SockToken
;
323 SOCK_COMPLETION_TOKEN
*Token
;
325 ASSERT (Sock
&& PendingTokenList
);
327 while (!NetListIsEmpty (PendingTokenList
)) {
328 SockToken
= NET_LIST_HEAD (
334 Token
= SockToken
->Token
;
335 SIGNAL_TOKEN (Token
, Sock
->SockError
);
337 NetListRemoveEntry (&(SockToken
->TokenList
));
338 NetFreePool (SockToken
);
344 Wake up the connection token while the connection is
345 successfully established, then try to process any
348 @param Sock Pointer to the socket.
359 ASSERT (Sock
->ConnectionToken
!= NULL
);
361 SIGNAL_TOKEN (Sock
->ConnectionToken
, EFI_SUCCESS
);
362 Sock
->ConnectionToken
= NULL
;
365 // check to see if some pending send token existed?
367 SockProcessSndToken (Sock
);
373 Wake up the listen token while the connection is
374 established successfully.
376 @param Sock Pointer to the socket.
383 SockWakeListenToken (
388 SOCK_TOKEN
*SockToken
;
389 EFI_TCP4_LISTEN_TOKEN
*ListenToken
;
391 Parent
= Sock
->Parent
;
393 ASSERT (Parent
&& SOCK_IS_LISTENING (Parent
) && SOCK_IS_CONNECTED (Sock
));
395 if (!NetListIsEmpty (&Parent
->ListenTokenList
)) {
396 SockToken
= NET_LIST_HEAD (
397 &Parent
->ListenTokenList
,
402 ListenToken
= (EFI_TCP4_LISTEN_TOKEN
*) SockToken
->Token
;
403 ListenToken
->NewChildHandle
= Sock
->SockHandle
;
405 SIGNAL_TOKEN (&(ListenToken
->CompletionToken
), EFI_SUCCESS
);
407 NetListRemoveEntry (&SockToken
->TokenList
);
408 NetFreePool (SockToken
);
410 NetListRemoveEntry (&Sock
->ConnectionList
);
413 SOCK_DEBUG_WARN (("SockWakeListenToken: accept a socket,"
414 "now conncnt is %d", Parent
->ConnCnt
));
422 Wake up the receive token while some data is received.
424 @param Sock Pointer to the socket.
436 UINT32 TokenRcvdBytes
;
437 SOCK_TOKEN
*SockToken
;
438 SOCK_IO_TOKEN
*RcvToken
;
440 ASSERT (Sock
->RcvBuffer
.DataQueue
);
442 RcvdBytes
= (Sock
->RcvBuffer
.DataQueue
)->BufSize
;
444 ASSERT (RcvdBytes
> 0);
446 while (RcvdBytes
> 0 && !NetListIsEmpty (&Sock
->RcvTokenList
)) {
448 SockToken
= NET_LIST_HEAD (
454 RcvToken
= (SOCK_IO_TOKEN
*) SockToken
->Token
;
455 TokenRcvdBytes
= SockProcessRcvToken (Sock
, RcvToken
);
457 if (0 == TokenRcvdBytes
) {
461 NetListRemoveEntry (&(SockToken
->TokenList
));
462 NetFreePool (SockToken
);
463 RcvdBytes
-= TokenRcvdBytes
;
469 Process the send token.
471 @param Sock Pointer to the socket.
478 SockProcessSndToken (
483 SOCK_TOKEN
*SockToken
;
485 SOCK_IO_TOKEN
*SndToken
;
486 EFI_TCP4_TRANSMIT_DATA
*TxData
;
489 ASSERT (Sock
&& (SOCK_STREAM
== Sock
->Type
));
491 FreeSpace
= SockGetFreeSpace (Sock
, SOCK_SND_BUF
);
494 // to determine if process a send token using
495 // socket layer flow control policy
497 while ((FreeSpace
>= Sock
->SndBuffer
.LowWater
) &&
498 !NetListIsEmpty (&Sock
->SndTokenList
)) {
500 SockToken
= NET_LIST_HEAD (
501 &(Sock
->SndTokenList
),
507 // process this token
509 NetListRemoveEntry (&(SockToken
->TokenList
));
511 &(Sock
->ProcessingSndTokenList
),
512 &(SockToken
->TokenList
)
516 // Proceess it in the light of SockType
518 SndToken
= (SOCK_IO_TOKEN
*) SockToken
->Token
;
519 TxData
= SndToken
->Packet
.TxData
;
521 DataLen
= (UINT32
) TxData
->DataLength
;
522 Status
= SockProcessTcpSndData (Sock
, TxData
);
524 if (EFI_ERROR (Status
)) {
528 if (DataLen
>= FreeSpace
) {
532 FreeSpace
-= DataLen
;
541 NetListRemoveEntry (&SockToken
->TokenList
);
542 SIGNAL_TOKEN (SockToken
->Token
, Status
);
543 NetFreePool (SockToken
);
548 Create a socket with initial data SockInitData.
550 @param SockInitData Pointer to the initial data of the socket.
552 @return Pointer to the newly created socket.
557 IN SOCK_INIT_DATA
*SockInitData
564 ASSERT (SockInitData
&& SockInitData
->ProtoHandler
);
565 ASSERT (SockInitData
->Type
== SOCK_STREAM
);
566 ASSERT (SockInitData
->ProtoData
&& (SockInitData
->DataSize
<= PROTO_RESERVED_LEN
));
568 Parent
= SockInitData
->Parent
;
570 if (Parent
&& (Parent
->ConnCnt
== Parent
->BackLog
)) {
572 ("SockCreate: Socket parent has "
573 "reached its connection limit with %d ConnCnt and %d BackLog\n",
581 Sock
= NetAllocateZeroPool (sizeof (SOCKET
));
584 SOCK_DEBUG_ERROR (("SockCreate: No resource to create a new socket\n"));
588 NetListInit (&Sock
->Link
);
589 NetListInit (&Sock
->ConnectionList
);
590 NetListInit (&Sock
->ListenTokenList
);
591 NetListInit (&Sock
->RcvTokenList
);
592 NetListInit (&Sock
->SndTokenList
);
593 NetListInit (&Sock
->ProcessingSndTokenList
);
595 NET_LOCK_INIT (&(Sock
->Lock
));
597 Sock
->SndBuffer
.DataQueue
= NetbufQueAlloc ();
598 if (NULL
== Sock
->SndBuffer
.DataQueue
) {
599 SOCK_DEBUG_ERROR (("SockCreate: No resource to allocate"
600 " SndBuffer for new socket\n"));
605 Sock
->RcvBuffer
.DataQueue
= NetbufQueAlloc ();
606 if (NULL
== Sock
->RcvBuffer
.DataQueue
) {
607 SOCK_DEBUG_ERROR (("SockCreate: No resource to allocate "
608 "RcvBuffer for new socket\n"));
613 Sock
->Signature
= SOCK_SIGNATURE
;
615 Sock
->Parent
= Parent
;
616 Sock
->BackLog
= SockInitData
->BackLog
;
617 Sock
->ProtoHandler
= SockInitData
->ProtoHandler
;
618 Sock
->SndBuffer
.HighWater
= SockInitData
->SndBufferSize
;
619 Sock
->RcvBuffer
.HighWater
= SockInitData
->RcvBufferSize
;
620 Sock
->Type
= SockInitData
->Type
;
621 Sock
->DriverBinding
= SockInitData
->DriverBinding
;
622 Sock
->State
= SockInitData
->State
;
623 Sock
->CreateCallback
= SockInitData
->CreateCallback
;
624 Sock
->DestroyCallback
= SockInitData
->DestroyCallback
;
625 Sock
->Context
= SockInitData
->Context
;
627 Sock
->SockError
= EFI_ABORTED
;
628 Sock
->SndBuffer
.LowWater
= SOCK_BUFF_LOW_WATER
;
629 Sock
->RcvBuffer
.LowWater
= SOCK_BUFF_LOW_WATER
;
632 // Install protocol on Sock->SockHandle
635 &(Sock
->NetProtocol
.TcpProtocol
),
636 SockInitData
->Protocol
,
637 sizeof (EFI_TCP4_PROTOCOL
)
641 // copy the protodata into socket
643 NetCopyMem (Sock
->ProtoReserved
, SockInitData
->ProtoData
, SockInitData
->DataSize
);
645 Status
= gBS
->InstallMultipleProtocolInterfaces (
647 &gEfiTcp4ProtocolGuid
,
648 &(Sock
->NetProtocol
.TcpProtocol
),
652 if (EFI_ERROR (Status
)) {
653 SOCK_DEBUG_ERROR (("SockCreate: Install TCP protocol in "
654 "socket failed with %r\n", Status
));
659 if (Parent
!= NULL
) {
660 ASSERT (Parent
->BackLog
> 0);
661 ASSERT (SOCK_IS_LISTENING (Parent
));
664 // need to add it into Parent->ConnectionList
665 // if the Parent->ConnCnt < Parent->BackLog
669 SOCK_DEBUG_WARN (("SockCreate: Create a new socket and"
670 "add to parent, now conncnt is %d\n", Parent
->ConnCnt
));
672 NetListInsertTail (&Parent
->ConnectionList
, &Sock
->ConnectionList
);
675 if (Sock
->CreateCallback
!= NULL
) {
676 Status
= Sock
->CreateCallback (Sock
, Sock
->Context
);
677 if (EFI_ERROR (Status
)) {
686 if (Sock
->SockHandle
!= NULL
) {
687 gBS
->UninstallMultipleProtocolInterfaces (
689 &gEfiTcp4ProtocolGuid
,
690 &(Sock
->NetProtocol
.TcpProtocol
),
695 if (NULL
!= Sock
->SndBuffer
.DataQueue
) {
696 NetbufQueFree (Sock
->SndBuffer
.DataQueue
);
699 if (NULL
!= Sock
->RcvBuffer
.DataQueue
) {
700 NetbufQueFree (Sock
->RcvBuffer
.DataQueue
);
712 @param Sock Pointer to the socket.
723 EFI_GUID
*ProtocolGuid
;
726 ASSERT (SOCK_STREAM
== Sock
->Type
);
728 if (Sock
->DestroyCallback
!= NULL
) {
729 Sock
->DestroyCallback (Sock
, Sock
->Context
);
733 // Flush the completion token buffered
734 // by sock and rcv, snd buffer
736 if (!SOCK_IS_UNCONFIGURED (Sock
)) {
738 SockConnFlush (Sock
);
739 SockSetState (Sock
, SO_CLOSED
);
740 Sock
->ConfigureState
= SO_UNCONFIGURED
;
744 // Destory the RcvBuffer Queue and SendBuffer Queue
746 NetbufQueFree (Sock
->RcvBuffer
.DataQueue
);
747 NetbufQueFree (Sock
->SndBuffer
.DataQueue
);
750 // Remove it from parent connection list if needed
754 NetListRemoveEntry (&(Sock
->ConnectionList
));
755 (Sock
->Parent
->ConnCnt
)--;
757 SOCK_DEBUG_WARN (("SockDestory: Delete a unaccepted socket from parent"
758 "now conncnt is %d\n", Sock
->Parent
->ConnCnt
));
764 // Set the protocol guid and driver binding handle
765 // in the light of Sock->SockType
767 ProtocolGuid
= &gEfiTcp4ProtocolGuid
;
770 // Retrieve the protocol installed on this sock
772 Status
= gBS
->OpenProtocol (
778 EFI_OPEN_PROTOCOL_GET_PROTOCOL
781 if (EFI_ERROR (Status
)) {
783 SOCK_DEBUG_ERROR (("SockDestroy: Open protocol installed "
784 "on socket failed with %r\n", Status
));
790 // Uninstall the protocol installed on this sock
791 // in the light of Sock->SockType
793 gBS
->UninstallMultipleProtocolInterfaces (
809 @param Sock Pointer to the socket.
824 // Clear the flag in this socket
829 // Flush the SndBuffer and RcvBuffer of Sock
831 NetbufQueFlush (Sock
->SndBuffer
.DataQueue
);
832 NetbufQueFlush (Sock
->RcvBuffer
.DataQueue
);
835 // Signal the pending token
837 if (Sock
->ConnectionToken
!= NULL
) {
838 SIGNAL_TOKEN (Sock
->ConnectionToken
, Sock
->SockError
);
839 Sock
->ConnectionToken
= NULL
;
842 if (Sock
->CloseToken
!= NULL
) {
843 SIGNAL_TOKEN (Sock
->CloseToken
, Sock
->SockError
);
844 Sock
->CloseToken
= NULL
;
847 SockFlushPendingToken (Sock
, &(Sock
->ListenTokenList
));
848 SockFlushPendingToken (Sock
, &(Sock
->RcvTokenList
));
849 SockFlushPendingToken (Sock
, &(Sock
->SndTokenList
));
850 SockFlushPendingToken (Sock
, &(Sock
->ProcessingSndTokenList
));
853 // Destroy the pending connection, if it is a listening socket
855 if (SOCK_IS_LISTENING (Sock
)) {
856 while (!NetListIsEmpty (&Sock
->ConnectionList
)) {
857 Child
= NET_LIST_HEAD (
858 &Sock
->ConnectionList
,
863 SockDestroyChild (Child
);
874 Set the state of the socket.
876 @param Sock Pointer to the socket.
877 @param State The new state to be set.
893 Clone a new socket including its associated protocol control block.
895 @param Sock Pointer to the socket to be cloned.
897 @retval * Pointer to the newly cloned socket. If NULL, error
907 SOCK_INIT_DATA InitData
;
909 InitData
.BackLog
= Sock
->BackLog
;
910 InitData
.Parent
= Sock
;
911 InitData
.State
= Sock
->State
;
912 InitData
.ProtoHandler
= Sock
->ProtoHandler
;
913 InitData
.Type
= Sock
->Type
;
914 InitData
.RcvBufferSize
= Sock
->RcvBuffer
.HighWater
;
915 InitData
.SndBufferSize
= Sock
->SndBuffer
.HighWater
;
916 InitData
.DriverBinding
= Sock
->DriverBinding
;
917 InitData
.Protocol
= &(Sock
->NetProtocol
);
918 InitData
.CreateCallback
= Sock
->CreateCallback
;
919 InitData
.DestroyCallback
= Sock
->DestroyCallback
;
920 InitData
.Context
= Sock
->Context
;
921 InitData
.ProtoData
= Sock
->ProtoReserved
;
922 InitData
.DataSize
= sizeof (Sock
->ProtoReserved
);
924 ClonedSock
= SockCreate (&InitData
);
926 if (NULL
== ClonedSock
) {
927 SOCK_DEBUG_ERROR (("SockClone: no resource to create a cloned sock\n"));
931 SockSetState (ClonedSock
, SO_CONNECTING
);
932 ClonedSock
->ConfigureState
= Sock
->ConfigureState
;
939 Called by the low layer protocol to indicate the socket
940 a connection is established. This function just changes
941 the socket's state to SO_CONNECTED and signals the token
942 used for connection establishment.
944 @param Sock Pointer to the socket associated with the
945 established connection.
951 SockConnEstablished (
956 ASSERT (SO_CONNECTING
== Sock
->State
);
958 SockSetState (Sock
, SO_CONNECTED
);
960 if (NULL
== Sock
->Parent
) {
961 SockWakeConnToken (Sock
);
963 SockWakeListenToken (Sock
);
971 Called by the low layer protocol to indicate the connection
972 is closed. This function flushes the socket, sets the state
973 to SO_CLOSED and signals the close token.
975 @param Sock Pointer to the socket associated with the closed
986 if (Sock
->CloseToken
) {
987 SIGNAL_TOKEN (Sock
->CloseToken
, EFI_SUCCESS
);
988 Sock
->CloseToken
= NULL
;
991 SockConnFlush (Sock
);
992 SockSetState (Sock
, SO_CLOSED
);
994 if (Sock
->Parent
!= NULL
) {
995 SockDestroyChild (Sock
);
1002 Called by low layer protocol to indicate that some
1003 data is sent or processed. This function trims the
1004 sent data in the socket send buffer, signals the
1005 data token if proper
1007 @param Sock Pointer to the socket.
1008 @param Count The length of the data processed or sent, in bytes.
1019 SOCK_TOKEN
*SockToken
;
1020 SOCK_COMPLETION_TOKEN
*SndToken
;
1022 ASSERT (!NetListIsEmpty (&Sock
->ProcessingSndTokenList
));
1023 ASSERT (Count
<= (Sock
->SndBuffer
.DataQueue
)->BufSize
);
1025 NetbufQueTrim (Sock
->SndBuffer
.DataQueue
, Count
);
1028 // To check if we can signal some snd token in this socket
1031 SockToken
= NET_LIST_HEAD (
1032 &(Sock
->ProcessingSndTokenList
),
1037 SndToken
= SockToken
->Token
;
1039 if (SockToken
->RemainDataLen
<= Count
) {
1041 NetListRemoveEntry (&(SockToken
->TokenList
));
1042 SIGNAL_TOKEN (SndToken
, EFI_SUCCESS
);
1043 Count
-= SockToken
->RemainDataLen
;
1044 NetFreePool (SockToken
);
1047 SockToken
->RemainDataLen
-= Count
;
1053 // to judge if we can process some send token in
1054 // Sock->SndTokenList, if so process those send token
1056 SockProcessSndToken (Sock
);
1062 Called by the low layer protocol to copy some data in socket send
1063 buffer starting from the specific offset to a buffer provided by
1066 @param Sock Pointer to the socket.
1067 @param Offset The start point of the data to be copied.
1068 @param Len The length of the data to be copied.
1069 @param Dest Pointer to the destination to copy the data.
1071 @return The data size copied.
1082 ASSERT (Sock
&& SOCK_STREAM
== Sock
->Type
);
1084 return NetbufQueCopy (
1085 Sock
->SndBuffer
.DataQueue
,
1094 Called by the low layer protocol to deliver received data
1095 to socket layer. This function will append the data to the
1096 socket receive buffer, set ther urgent data length and then
1097 check if any receive token can be signaled.
1099 @param Sock Pointer to the socket.
1100 @param NetBuffer Pointer to the buffer that contains the received
1102 @param UrgLen The length of the urgent data in the received data.
1110 IN NET_BUF
*NetBuffer
,
1114 ASSERT (Sock
&& Sock
->RcvBuffer
.DataQueue
&&
1115 UrgLen
<= NetBuffer
->TotalSize
);
1117 NET_GET_REF (NetBuffer
);
1119 ((TCP_RSV_DATA
*) (NetBuffer
->ProtoData
))->UrgLen
= UrgLen
;
1121 NetbufQueAppend (Sock
->RcvBuffer
.DataQueue
, NetBuffer
);
1123 SockWakeRcvToken (Sock
);
1129 Get the length of the free space of the specific socket buffer.
1131 @param Sock Pointer to the socket.
1132 @param Which Flag to indicate which socket buffer to check,
1133 either send buffer or receive buffer.
1135 @return The length of the free space, in bytes.
1145 SOCK_BUFFER
*SockBuffer
;
1147 ASSERT (Sock
&& ((SOCK_SND_BUF
== Which
) || (SOCK_RCV_BUF
== Which
)));
1149 if (SOCK_SND_BUF
== Which
) {
1150 SockBuffer
= &(Sock
->SndBuffer
);
1152 SockBuffer
= &(Sock
->RcvBuffer
);
1155 BufferCC
= (SockBuffer
->DataQueue
)->BufSize
;
1157 if (BufferCC
>= SockBuffer
->HighWater
) {
1162 return SockBuffer
->HighWater
- BufferCC
;
1167 Signal the receive token with the specific error or
1168 set socket error code after error is received.
1170 @param Sock Pointer to the socket.
1171 @param Error The error code received.
1182 SOCK_TOKEN
*SockToken
;
1184 if (!NetListIsEmpty (&Sock
->RcvTokenList
)) {
1186 SockToken
= NET_LIST_HEAD (
1187 &Sock
->RcvTokenList
,
1192 NetListRemoveEntry (&SockToken
->TokenList
);
1194 SIGNAL_TOKEN (SockToken
->Token
, Error
);
1196 NetFreePool (SockToken
);
1199 SOCK_ERROR (Sock
, Error
);
1205 Called by the low layer protocol to indicate that there
1206 will be no more data from the communication peer. This
1207 function set the socket's state to SO_NO_MORE_DATA and
1208 signal all queued IO tokens with the error status
1211 @param Sock Pointer to the socket.
1223 SOCK_NO_MORE_DATA (Sock
);
1225 if (!NetListIsEmpty (&Sock
->RcvTokenList
)) {
1227 ASSERT (0 == GET_RCV_DATASIZE (Sock
));
1229 Err
= Sock
->SockError
;
1231 SOCK_ERROR (Sock
, EFI_CONNECTION_FIN
);
1233 SockFlushPendingToken (Sock
, &Sock
->RcvTokenList
);
1235 SOCK_ERROR (Sock
, Err
);
1243 Get the first buffer block in the specific socket buffer.
1245 @param Sockbuf Pointer to the socket buffer.
1247 @return Pointer to the first buffer in the queue. NULL if the queue is empty.
1252 IN SOCK_BUFFER
*Sockbuf
1255 NET_LIST_ENTRY
*NetbufList
;
1257 NetbufList
= &(Sockbuf
->DataQueue
->BufList
);
1259 if (NetListIsEmpty (NetbufList
)) {
1263 return NET_LIST_HEAD (NetbufList
, NET_BUF
, List
);
1268 Get the next buffer block in the specific socket buffer.
1270 @param Sockbuf Pointer to the socket buffer.
1271 @param SockEntry Pointer to the buffer block prior to the required
1274 @return Pointer to the buffer block next to SockEntry. NULL if SockEntry is the tail or head entry.
1279 IN SOCK_BUFFER
*Sockbuf
,
1280 IN NET_BUF
*SockEntry
1283 NET_LIST_ENTRY
*NetbufList
;
1285 NetbufList
= &(Sockbuf
->DataQueue
->BufList
);
1287 if ((SockEntry
->List
.ForwardLink
== NetbufList
) ||
1288 (SockEntry
->List
.BackLink
== &SockEntry
->List
) ||
1289 (SockEntry
->List
.ForwardLink
== &SockEntry
->List
)
1295 return NET_LIST_USER_STRUCT (SockEntry
->List
.ForwardLink
, NET_BUF
, List
);