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
);
567 Parent
= SockInitData
->Parent
;
569 if (Parent
&& (Parent
->ConnCnt
== Parent
->BackLog
)) {
571 ("SockCreate: Socket parent has "
572 "reached its connection limit with %d ConnCnt and %d BackLog\n",
580 Sock
= NetAllocateZeroPool (sizeof (SOCKET
));
583 SOCK_DEBUG_ERROR (("SockCreate: No resource to create a new socket\n"));
587 NetListInit (&Sock
->Link
);
588 NetListInit (&Sock
->ConnectionList
);
589 NetListInit (&Sock
->ListenTokenList
);
590 NetListInit (&Sock
->RcvTokenList
);
591 NetListInit (&Sock
->SndTokenList
);
592 NetListInit (&Sock
->ProcessingSndTokenList
);
594 NET_LOCK_INIT (&(Sock
->Lock
));
596 Sock
->SndBuffer
.DataQueue
= NetbufQueAlloc ();
597 if (NULL
== Sock
->SndBuffer
.DataQueue
) {
598 SOCK_DEBUG_ERROR (("SockCreate: No resource to allocate"
599 " SndBuffer for new socket\n"));
604 Sock
->RcvBuffer
.DataQueue
= NetbufQueAlloc ();
605 if (NULL
== Sock
->RcvBuffer
.DataQueue
) {
606 SOCK_DEBUG_ERROR (("SockCreate: No resource to allocate "
607 "RcvBuffer for new socket\n"));
612 Sock
->Signature
= SOCK_SIGNATURE
;
614 Sock
->Parent
= Parent
;
615 Sock
->BackLog
= SockInitData
->BackLog
;
616 Sock
->ProtoHandler
= SockInitData
->ProtoHandler
;
617 Sock
->SndBuffer
.HighWater
= SockInitData
->SndBufferSize
;
618 Sock
->RcvBuffer
.HighWater
= SockInitData
->RcvBufferSize
;
619 Sock
->Type
= SockInitData
->Type
;
620 Sock
->DriverBinding
= SockInitData
->DriverBinding
;
621 Sock
->State
= SockInitData
->State
;
623 Sock
->SockError
= EFI_ABORTED
;
624 Sock
->SndBuffer
.LowWater
= SOCK_BUFF_LOW_WATER
;
625 Sock
->RcvBuffer
.LowWater
= SOCK_BUFF_LOW_WATER
;
628 // Install protocol on Sock->SockHandle
631 &(Sock
->NetProtocol
.TcpProtocol
),
632 SockInitData
->Protocol
,
633 sizeof (EFI_TCP4_PROTOCOL
)
636 Status
= gBS
->InstallMultipleProtocolInterfaces (
638 &gEfiTcp4ProtocolGuid
,
639 &(Sock
->NetProtocol
.TcpProtocol
),
643 if (EFI_ERROR (Status
)) {
644 SOCK_DEBUG_ERROR (("SockCreate: Install TCP protocol in "
645 "socket failed with %r\n", Status
));
650 if (Parent
!= NULL
) {
651 ASSERT (Parent
->BackLog
> 0);
652 ASSERT (SOCK_IS_LISTENING (Parent
));
655 // need to add it into Parent->ConnectionList
656 // if the Parent->ConnCnt < Parent->BackLog
660 SOCK_DEBUG_WARN (("SockCreate: Create a new socket and"
661 "add to parent, now conncnt is %d\n", Parent
->ConnCnt
));
663 NetListInsertTail (&Parent
->ConnectionList
, &Sock
->ConnectionList
);
671 if (NULL
!= Sock
->SndBuffer
.DataQueue
) {
672 NetbufQueFree (Sock
->SndBuffer
.DataQueue
);
675 if (NULL
!= Sock
->RcvBuffer
.DataQueue
) {
676 NetbufQueFree (Sock
->RcvBuffer
.DataQueue
);
689 @param Sock Pointer to the socket.
700 EFI_GUID
*ProtocolGuid
;
703 ASSERT (SOCK_STREAM
== Sock
->Type
);
706 // Flush the completion token buffered
707 // by sock and rcv, snd buffer
709 if (!SOCK_IS_UNCONFIGURED (Sock
)) {
711 SockConnFlush (Sock
);
712 SockSetState (Sock
, SO_CLOSED
);
713 Sock
->ConfigureState
= SO_UNCONFIGURED
;
717 // Destory the RcvBuffer Queue and SendBuffer Queue
719 NetbufQueFree (Sock
->RcvBuffer
.DataQueue
);
720 NetbufQueFree (Sock
->SndBuffer
.DataQueue
);
723 // Remove it from parent connection list if needed
727 NetListRemoveEntry (&(Sock
->ConnectionList
));
728 (Sock
->Parent
->ConnCnt
)--;
730 SOCK_DEBUG_WARN (("SockDestory: Delete a unaccepted socket from parent"
731 "now conncnt is %d\n", Sock
->Parent
->ConnCnt
));
737 // Set the protocol guid and driver binding handle
738 // in the light of Sock->SockType
740 ProtocolGuid
= &gEfiTcp4ProtocolGuid
;
743 // Retrieve the protocol installed on this sock
745 Status
= gBS
->OpenProtocol (
751 EFI_OPEN_PROTOCOL_GET_PROTOCOL
754 if (EFI_ERROR (Status
)) {
756 SOCK_DEBUG_ERROR (("SockDestroy: Open protocol installed "
757 "on socket failed with %r\n", Status
));
763 // Uninstall the protocol installed on this sock
764 // in the light of Sock->SockType
766 gBS
->UninstallMultipleProtocolInterfaces (
782 @param Sock Pointer to the socket.
797 // Clear the flag in this socket
802 // Flush the SndBuffer and RcvBuffer of Sock
804 NetbufQueFlush (Sock
->SndBuffer
.DataQueue
);
805 NetbufQueFlush (Sock
->RcvBuffer
.DataQueue
);
808 // Signal the pending token
810 if (Sock
->ConnectionToken
!= NULL
) {
811 SIGNAL_TOKEN (Sock
->ConnectionToken
, Sock
->SockError
);
812 Sock
->ConnectionToken
= NULL
;
815 if (Sock
->CloseToken
!= NULL
) {
816 SIGNAL_TOKEN (Sock
->CloseToken
, Sock
->SockError
);
817 Sock
->CloseToken
= NULL
;
820 SockFlushPendingToken (Sock
, &(Sock
->ListenTokenList
));
821 SockFlushPendingToken (Sock
, &(Sock
->RcvTokenList
));
822 SockFlushPendingToken (Sock
, &(Sock
->SndTokenList
));
823 SockFlushPendingToken (Sock
, &(Sock
->ProcessingSndTokenList
));
826 // Destroy the pending connection, if it is a listening socket
828 if (SOCK_IS_LISTENING (Sock
)) {
829 while (!NetListIsEmpty (&Sock
->ConnectionList
)) {
830 Child
= NET_LIST_HEAD (
831 &Sock
->ConnectionList
,
836 SockDestroyChild (Child
);
847 Set the state of the socket.
849 @param Sock Pointer to the socket.
850 @param State The new state to be set.
866 Clone a new socket including its associated protocol control block.
868 @param Sock Pointer to the socket to be cloned.
870 @retval * Pointer to the newly cloned socket. If NULL, error
880 SOCK_INIT_DATA InitData
;
882 InitData
.BackLog
= Sock
->BackLog
;
883 InitData
.Parent
= Sock
;
884 InitData
.State
= Sock
->State
;
885 InitData
.ProtoHandler
= Sock
->ProtoHandler
;
886 InitData
.Type
= Sock
->Type
;
887 InitData
.RcvBufferSize
= Sock
->RcvBuffer
.HighWater
;
888 InitData
.SndBufferSize
= Sock
->SndBuffer
.HighWater
;
889 InitData
.DriverBinding
= Sock
->DriverBinding
;
890 InitData
.Protocol
= &(Sock
->NetProtocol
);
892 ClonedSock
= SockCreate (&InitData
);
894 if (NULL
== ClonedSock
) {
895 SOCK_DEBUG_ERROR (("SockClone: no resource to create a cloned sock\n"));
900 ClonedSock
->ProtoReserved
,
905 SockSetState (ClonedSock
, SO_CONNECTING
);
906 ClonedSock
->ConfigureState
= Sock
->ConfigureState
;
913 Called by the low layer protocol to indicate the socket
914 a connection is established. This function just changes
915 the socket's state to SO_CONNECTED and signals the token
916 used for connection establishment.
918 @param Sock Pointer to the socket associated with the
919 established connection.
925 SockConnEstablished (
930 ASSERT (SO_CONNECTING
== Sock
->State
);
932 SockSetState (Sock
, SO_CONNECTED
);
934 if (NULL
== Sock
->Parent
) {
935 SockWakeConnToken (Sock
);
937 SockWakeListenToken (Sock
);
945 Called by the low layer protocol to indicate the connection
946 is closed. This function flushes the socket, sets the state
947 to SO_CLOSED and signals the close token.
949 @param Sock Pointer to the socket associated with the closed
960 if (Sock
->CloseToken
) {
961 SIGNAL_TOKEN (Sock
->CloseToken
, EFI_SUCCESS
);
962 Sock
->CloseToken
= NULL
;
965 SockConnFlush (Sock
);
966 SockSetState (Sock
, SO_CLOSED
);
968 if (Sock
->Parent
!= NULL
) {
969 SockDestroyChild (Sock
);
976 Called by low layer protocol to indicate that some
977 data is sent or processed. This function trims the
978 sent data in the socket send buffer, signals the
981 @param Sock Pointer to the socket.
982 @param Count The length of the data processed or sent, in bytes.
993 SOCK_TOKEN
*SockToken
;
994 SOCK_COMPLETION_TOKEN
*SndToken
;
996 ASSERT (!NetListIsEmpty (&Sock
->ProcessingSndTokenList
));
997 ASSERT (Count
<= (Sock
->SndBuffer
.DataQueue
)->BufSize
);
999 NetbufQueTrim (Sock
->SndBuffer
.DataQueue
, Count
);
1002 // To check if we can signal some snd token in this socket
1005 SockToken
= NET_LIST_HEAD (
1006 &(Sock
->ProcessingSndTokenList
),
1011 SndToken
= SockToken
->Token
;
1013 if (SockToken
->RemainDataLen
<= Count
) {
1015 NetListRemoveEntry (&(SockToken
->TokenList
));
1016 SIGNAL_TOKEN (SndToken
, EFI_SUCCESS
);
1017 Count
-= SockToken
->RemainDataLen
;
1018 NetFreePool (SockToken
);
1021 SockToken
->RemainDataLen
-= Count
;
1027 // to judge if we can process some send token in
1028 // Sock->SndTokenList, if so process those send token
1030 SockProcessSndToken (Sock
);
1036 Called by the low layer protocol to copy some data in socket send
1037 buffer starting from the specific offset to a buffer provided by
1040 @param Sock Pointer to the socket.
1041 @param Offset The start point of the data to be copied.
1042 @param Len The length of the data to be copied.
1043 @param Dest Pointer to the destination to copy the data.
1045 @return The data size copied.
1056 ASSERT (Sock
&& SOCK_STREAM
== Sock
->Type
);
1058 return NetbufQueCopy (
1059 Sock
->SndBuffer
.DataQueue
,
1068 Called by the low layer protocol to deliver received data
1069 to socket layer. This function will append the data to the
1070 socket receive buffer, set ther urgent data length and then
1071 check if any receive token can be signaled.
1073 @param Sock Pointer to the socket.
1074 @param NetBuffer Pointer to the buffer that contains the received
1076 @param UrgLen The length of the urgent data in the received data.
1084 IN NET_BUF
*NetBuffer
,
1088 ASSERT (Sock
&& Sock
->RcvBuffer
.DataQueue
&&
1089 UrgLen
<= NetBuffer
->TotalSize
);
1091 NET_GET_REF (NetBuffer
);
1093 ((TCP_RSV_DATA
*) (NetBuffer
->ProtoData
))->UrgLen
= UrgLen
;
1095 NetbufQueAppend (Sock
->RcvBuffer
.DataQueue
, NetBuffer
);
1097 SockWakeRcvToken (Sock
);
1103 Get the length of the free space of the specific socket buffer.
1105 @param Sock Pointer to the socket.
1106 @param Which Flag to indicate which socket buffer to check,
1107 either send buffer or receive buffer.
1109 @return The length of the free space, in bytes.
1119 SOCK_BUFFER
*SockBuffer
;
1121 ASSERT (Sock
&& ((SOCK_SND_BUF
== Which
) || (SOCK_RCV_BUF
== Which
)));
1123 if (SOCK_SND_BUF
== Which
) {
1124 SockBuffer
= &(Sock
->SndBuffer
);
1126 SockBuffer
= &(Sock
->RcvBuffer
);
1129 BufferCC
= (SockBuffer
->DataQueue
)->BufSize
;
1131 if (BufferCC
>= SockBuffer
->HighWater
) {
1136 return SockBuffer
->HighWater
- BufferCC
;
1141 Signal the receive token with the specific error or
1142 set socket error code after error is received.
1144 @param Sock Pointer to the socket.
1145 @param Error The error code received.
1156 SOCK_TOKEN
*SockToken
;
1158 if (!NetListIsEmpty (&Sock
->RcvTokenList
)) {
1160 SockToken
= NET_LIST_HEAD (
1161 &Sock
->RcvTokenList
,
1166 NetListRemoveEntry (&SockToken
->TokenList
);
1168 SIGNAL_TOKEN (SockToken
->Token
, Error
);
1170 NetFreePool (SockToken
);
1173 SOCK_ERROR (Sock
, Error
);
1179 Called by the low layer protocol to indicate that there
1180 will be no more data from the communication peer. This
1181 function set the socket's state to SO_NO_MORE_DATA and
1182 signal all queued IO tokens with the error status
1185 @param Sock Pointer to the socket.
1197 SOCK_NO_MORE_DATA (Sock
);
1199 if (!NetListIsEmpty (&Sock
->RcvTokenList
)) {
1201 ASSERT (0 == GET_RCV_DATASIZE (Sock
));
1203 Err
= Sock
->SockError
;
1205 SOCK_ERROR (Sock
, EFI_CONNECTION_FIN
);
1207 SockFlushPendingToken (Sock
, &Sock
->RcvTokenList
);
1209 SOCK_ERROR (Sock
, Err
);
1217 Get the first buffer block in the specific socket buffer.
1219 @param Sockbuf Pointer to the socket buffer.
1221 @return Pointer to the first buffer in the queue. NULL if the queue is empty.
1226 IN SOCK_BUFFER
*Sockbuf
1229 NET_LIST_ENTRY
*NetbufList
;
1231 NetbufList
= &(Sockbuf
->DataQueue
->BufList
);
1233 if (NetListIsEmpty (NetbufList
)) {
1237 return NET_LIST_HEAD (NetbufList
, NET_BUF
, List
);
1242 Get the next buffer block in the specific socket buffer.
1244 @param Sockbuf Pointer to the socket buffer.
1245 @param SockEntry Pointer to the buffer block prior to the required
1248 @return Pointer to the buffer block next to SockEntry. NULL if SockEntry is the tail or head entry.
1253 IN SOCK_BUFFER
*Sockbuf
,
1254 IN NET_BUF
*SockEntry
1257 NET_LIST_ENTRY
*NetbufList
;
1259 NetbufList
= &(Sockbuf
->DataQueue
->BufList
);
1261 if ((SockEntry
->List
.ForwardLink
== NetbufList
) ||
1262 (SockEntry
->List
.BackLink
== &SockEntry
->List
) ||
1263 (SockEntry
->List
.ForwardLink
== &SockEntry
->List
)
1269 return NET_LIST_USER_STRUCT (SockEntry
->List
.ForwardLink
, NET_BUF
, List
);