2 Implementation of the Socket.
4 Copyright (c) 2009 - 2012, Intel Corporation. All rights reserved.<BR>
6 This program and the accompanying materials
7 are licensed and made available under the terms and conditions of the BSD License
8 which accompanies this distribution. The full text of the license may be found at
9 http://opensource.org/licenses/bsd-license.php.
11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
19 Get the first buffer block in the specific socket buffer.
21 @param[in] Sockbuf Pointer to the socket buffer.
23 @return Pointer to the first buffer in the queue. NULL if the queue is empty.
28 IN SOCK_BUFFER
*Sockbuf
31 LIST_ENTRY
*NetbufList
;
33 NetbufList
= &(Sockbuf
->DataQueue
->BufList
);
35 if (IsListEmpty (NetbufList
)) {
39 return NET_LIST_HEAD (NetbufList
, NET_BUF
, List
);
43 Get the next buffer block in the specific socket buffer.
45 @param[in] Sockbuf Pointer to the socket buffer.
46 @param[in] SockEntry Pointer to the buffer block prior to the required one.
48 @return Pointer to the buffer block next to SockEntry. NULL if SockEntry is
49 the tail or head entry.
54 IN SOCK_BUFFER
*Sockbuf
,
58 LIST_ENTRY
*NetbufList
;
60 NetbufList
= &(Sockbuf
->DataQueue
->BufList
);
62 if ((SockEntry
->List
.ForwardLink
== NetbufList
) ||
63 (SockEntry
->List
.BackLink
== &SockEntry
->List
) ||
64 (SockEntry
->List
.ForwardLink
== &SockEntry
->List
)
70 return NET_LIST_USER_STRUCT (SockEntry
->List
.ForwardLink
, NET_BUF
, List
);
74 User provided callback function for NetbufFromExt.
76 @param[in] Event The Event this notify function registered to, ignored.
89 Get the length of the data that can be retrieved from the socket
92 @param[in] SockBuffer Pointer to the socket receive buffer.
93 @param[out] IsUrg Pointer to a BOOLEAN variable.
94 If TRUE the data is OOB.
95 @param[in] BufLen The maximum length of the data buffer to
96 store the received data in the socket layer.
98 @return The length of the data can be retreived.
103 IN SOCK_BUFFER
*SockBuffer
,
108 NET_BUF
*RcvBufEntry
;
110 TCP_RSV_DATA
*TcpRsvData
;
113 ASSERT ((SockBuffer
!= NULL
) && (IsUrg
!= NULL
) && (BufLen
> 0));
116 // Get the first socket receive buffer
118 RcvBufEntry
= SockBufFirst (SockBuffer
);
119 ASSERT (RcvBufEntry
!= NULL
);
121 TcpRsvData
= (TCP_RSV_DATA
*) RcvBufEntry
->ProtoData
;
124 // Check whether the receive data is out of bound. If yes, calculate the maximum
125 // allowed length of the urgent data and output it.
127 *IsUrg
= (BOOLEAN
) ((TcpRsvData
->UrgLen
> 0) ? TRUE
: FALSE
);
129 if (*IsUrg
&& (TcpRsvData
->UrgLen
< RcvBufEntry
->TotalSize
)) {
131 DataLen
= MIN (TcpRsvData
->UrgLen
, BufLen
);
133 if (DataLen
< TcpRsvData
->UrgLen
) {
134 TcpRsvData
->UrgLen
= TcpRsvData
->UrgLen
- DataLen
;
136 TcpRsvData
->UrgLen
= 0;
144 // Process the next socket receive buffer to get the maximum allowed length
145 // of the received data.
147 DataLen
= RcvBufEntry
->TotalSize
;
149 RcvBufEntry
= SockBufNext (SockBuffer
, RcvBufEntry
);
151 while ((BufLen
> DataLen
) && (RcvBufEntry
!= NULL
)) {
153 TcpRsvData
= (TCP_RSV_DATA
*) RcvBufEntry
->ProtoData
;
155 Urg
= (BOOLEAN
) ((TcpRsvData
->UrgLen
> 0) ? TRUE
: FALSE
);
161 if (*IsUrg
&& TcpRsvData
->UrgLen
< RcvBufEntry
->TotalSize
) {
163 if (TcpRsvData
->UrgLen
+ DataLen
< BufLen
) {
164 TcpRsvData
->UrgLen
= 0;
166 TcpRsvData
->UrgLen
= TcpRsvData
->UrgLen
- (BufLen
- DataLen
);
169 return MIN (TcpRsvData
->UrgLen
+ DataLen
, BufLen
);
173 DataLen
+= RcvBufEntry
->TotalSize
;
175 RcvBufEntry
= SockBufNext (SockBuffer
, RcvBufEntry
);
178 DataLen
= MIN (BufLen
, DataLen
);
183 Copy data from socket buffer to an application provided receive buffer.
185 @param[in] Sock Pointer to the socket.
186 @param[in] TcpRxData Pointer to the application provided receive buffer.
187 @param[in] RcvdBytes The maximum length of the data can be copied.
188 @param[in] IsUrg If TRUE the data is Out of Bound, FALSE the data is normal.
202 EFI_TCP4_RECEIVE_DATA
*RxData
;
203 EFI_TCP4_FRAGMENT_DATA
*Fragment
;
205 RxData
= (EFI_TCP4_RECEIVE_DATA
*) TcpRxData
;
209 ASSERT (RxData
->DataLength
>= RcvdBytes
);
211 RxData
->DataLength
= RcvdBytes
;
212 RxData
->UrgentFlag
= IsUrg
;
215 // Copy the CopyBytes data from socket receive buffer to RxData.
217 for (Index
= 0; (Index
< RxData
->FragmentCount
) && (RcvdBytes
> 0); Index
++) {
219 Fragment
= &RxData
->FragmentTable
[Index
];
220 CopyBytes
= MIN ((UINT32
) (Fragment
->FragmentLength
), RcvdBytes
);
223 Sock
->RcvBuffer
.DataQueue
,
226 Fragment
->FragmentBuffer
229 Fragment
->FragmentLength
= CopyBytes
;
230 RcvdBytes
-= CopyBytes
;
236 Process the send token.
238 @param[in, out] Sock Pointer to the socket.
242 SockProcessSndToken (
247 SOCK_TOKEN
*SockToken
;
249 SOCK_IO_TOKEN
*SndToken
;
250 EFI_TCP4_TRANSMIT_DATA
*TxData
;
253 ASSERT ((Sock
!= NULL
) && (SockStream
== Sock
->Type
));
255 FreeSpace
= SockGetFreeSpace (Sock
, SOCK_SND_BUF
);
258 // to determine if process a send token using
259 // socket layer flow control policy
261 while ((FreeSpace
>= Sock
->SndBuffer
.LowWater
) && !IsListEmpty (&Sock
->SndTokenList
)) {
263 SockToken
= NET_LIST_HEAD (
264 &(Sock
->SndTokenList
),
270 // process this token
272 RemoveEntryList (&(SockToken
->TokenList
));
274 &(Sock
->ProcessingSndTokenList
),
275 &(SockToken
->TokenList
)
279 // Proceess it in the light of SockType
281 SndToken
= (SOCK_IO_TOKEN
*) SockToken
->Token
;
282 TxData
= SndToken
->Packet
.TxData
;
284 DataLen
= TxData
->DataLength
;
285 Status
= SockProcessTcpSndData (Sock
, TxData
);
287 if (EFI_ERROR (Status
)) {
291 if (DataLen
>= FreeSpace
) {
295 FreeSpace
-= DataLen
;
304 RemoveEntryList (&SockToken
->TokenList
);
305 SIGNAL_TOKEN (SockToken
->Token
, Status
);
306 FreePool (SockToken
);
310 Get received data from the socket layer to the receive token.
312 @param[in, out] Sock Pointer to the socket.
313 @param[in, out] RcvToken Pointer to the application provided receive token.
315 @return The length of data received in this token.
319 SockProcessRcvToken (
321 IN OUT SOCK_IO_TOKEN
*RcvToken
324 UINT32 TokenRcvdBytes
;
325 EFI_TCP4_RECEIVE_DATA
*RxData
;
328 ASSERT (Sock
!= NULL
);
330 ASSERT (SockStream
== Sock
->Type
);
332 RxData
= RcvToken
->Packet
.RxData
;
334 TokenRcvdBytes
= SockTcpDataToRcv (
341 // Copy data from RcvBuffer of socket to user
342 // provided RxData and set the fields in TCP RxData
344 SockSetTcpRxData (Sock
, RxData
, TokenRcvdBytes
, IsUrg
);
346 NetbufQueTrim (Sock
->RcvBuffer
.DataQueue
, TokenRcvdBytes
);
347 SIGNAL_TOKEN (&(RcvToken
->Token
), EFI_SUCCESS
);
349 return TokenRcvdBytes
;
353 Process the TCP send data, buffer the tcp txdata, and append
354 the buffer to socket send buffer, then try to send it.
356 @param[in] Sock Pointer to the socket.
357 @param[in] TcpTxData Pointer to the application provided send buffer.
359 @retval EFI_SUCCESS The operation completed successfully.
360 @retval EFI_OUT_OF_RESOURCES Failed due to resource limits.
364 SockProcessTcpSndData (
371 EFI_TCP4_TRANSMIT_DATA
*TxData
;
373 TxData
= (EFI_TCP4_TRANSMIT_DATA
*) TcpTxData
;
376 // transform this TxData into a NET_BUFFER
377 // and insert it into Sock->SndBuffer
379 SndData
= NetbufFromExt (
380 (NET_FRAGMENT
*) TxData
->FragmentTable
,
381 TxData
->FragmentCount
,
388 if (NULL
== SndData
) {
391 "SockKProcessSndData: Failed to call NetBufferFromExt\n")
394 return EFI_OUT_OF_RESOURCES
;
397 NetbufQueAppend (Sock
->SndBuffer
.DataQueue
, SndData
);
400 // notify the low layer protocol to handle this send token
402 if (TxData
->Urgent
) {
403 Status
= Sock
->ProtoHandler (Sock
, SOCK_SNDURG
, NULL
);
405 if (EFI_ERROR (Status
)) {
411 Status
= Sock
->ProtoHandler (Sock
, SOCK_SNDPUSH
, NULL
);
413 if (EFI_ERROR (Status
)) {
419 // low layer protocol should really handle the sending
420 // process when catching SOCK_SND request
422 Status
= Sock
->ProtoHandler (Sock
, SOCK_SND
, NULL
);
424 if (EFI_ERROR (Status
)) {
432 Flush the tokens in the specific token list.
434 @param[in] Sock Pointer to the socket.
435 @param[in, out] PendingTokenList Pointer to the token list to be flushed.
439 SockFlushPendingToken (
441 IN OUT LIST_ENTRY
*PendingTokenList
444 SOCK_TOKEN
*SockToken
;
445 SOCK_COMPLETION_TOKEN
*Token
;
447 ASSERT ((Sock
!= NULL
) && (PendingTokenList
!= NULL
));
449 while (!IsListEmpty (PendingTokenList
)) {
450 SockToken
= NET_LIST_HEAD (
456 Token
= SockToken
->Token
;
457 SIGNAL_TOKEN (Token
, Sock
->SockError
);
459 RemoveEntryList (&(SockToken
->TokenList
));
460 FreePool (SockToken
);
465 Wake up the connection token while the connection is successfully established,
466 then try to process any pending send token.
468 @param[in, out] Sock Pointer to the socket.
476 ASSERT (Sock
->ConnectionToken
!= NULL
);
478 SIGNAL_TOKEN (Sock
->ConnectionToken
, EFI_SUCCESS
);
479 Sock
->ConnectionToken
= NULL
;
482 // check to see if some pending send token existed?
484 SockProcessSndToken (Sock
);
488 Wake up the listen token while the connection is established successfully.
490 @param[in, out] Sock Pointer to the socket.
494 SockWakeListenToken (
499 SOCK_TOKEN
*SockToken
;
500 EFI_TCP4_LISTEN_TOKEN
*ListenToken
;
502 Parent
= Sock
->Parent
;
504 ASSERT ((Parent
!= NULL
) && SOCK_IS_LISTENING (Parent
) && SOCK_IS_CONNECTED (Sock
));
506 if (!IsListEmpty (&Parent
->ListenTokenList
)) {
507 SockToken
= NET_LIST_HEAD (
508 &Parent
->ListenTokenList
,
513 ListenToken
= (EFI_TCP4_LISTEN_TOKEN
*) SockToken
->Token
;
514 ListenToken
->NewChildHandle
= Sock
->SockHandle
;
516 SIGNAL_TOKEN (&(ListenToken
->CompletionToken
), EFI_SUCCESS
);
518 RemoveEntryList (&SockToken
->TokenList
);
519 FreePool (SockToken
);
521 RemoveEntryList (&Sock
->ConnectionList
);
526 "SockWakeListenToken: accept a socket, now conncnt is %d",
535 Wake up the receive token while some data is received.
537 @param[in, out] Sock Pointer to the socket.
546 UINT32 TokenRcvdBytes
;
547 SOCK_TOKEN
*SockToken
;
548 SOCK_IO_TOKEN
*RcvToken
;
550 ASSERT (Sock
->RcvBuffer
.DataQueue
!= NULL
);
552 RcvdBytes
= (Sock
->RcvBuffer
.DataQueue
)->BufSize
;
554 ASSERT (RcvdBytes
> 0);
556 while (RcvdBytes
> 0 && !IsListEmpty (&Sock
->RcvTokenList
)) {
558 SockToken
= NET_LIST_HEAD (
564 RcvToken
= (SOCK_IO_TOKEN
*) SockToken
->Token
;
565 TokenRcvdBytes
= SockProcessRcvToken (Sock
, RcvToken
);
567 if (0 == TokenRcvdBytes
) {
571 RemoveEntryList (&(SockToken
->TokenList
));
572 FreePool (SockToken
);
573 RcvdBytes
-= TokenRcvdBytes
;
578 Create a socket with initial data SockInitData.
580 @param[in] SockInitData Pointer to the initial data of the socket.
582 @return Pointer to the newly created socket, return NULL when an exception occurs.
587 IN SOCK_INIT_DATA
*SockInitData
593 EFI_GUID
*TcpProtocolGuid
;
594 UINTN ProtocolLength
;
596 ASSERT ((SockInitData
!= NULL
) && (SockInitData
->ProtoHandler
!= NULL
));
597 ASSERT (SockInitData
->Type
== SockStream
);
598 ASSERT ((SockInitData
->ProtoData
!= NULL
) && (SockInitData
->DataSize
<= PROTO_RESERVED_LEN
));
600 if (SockInitData
->IpVersion
== IP_VERSION_4
) {
601 TcpProtocolGuid
= &gEfiTcp4ProtocolGuid
;
602 ProtocolLength
= sizeof (EFI_TCP4_PROTOCOL
);
604 TcpProtocolGuid
= &gEfiTcp6ProtocolGuid
;
605 ProtocolLength
= sizeof (EFI_TCP6_PROTOCOL
);
609 Parent
= SockInitData
->Parent
;
611 if ((Parent
!= NULL
) && (Parent
->ConnCnt
== Parent
->BackLog
)) {
614 "SockCreate: Socket parent has reached its connection limit with %d ConnCnt and %d BackLog\n",
622 Sock
= AllocateZeroPool (sizeof (SOCKET
));
625 DEBUG ((EFI_D_ERROR
, "SockCreate: No resource to create a new socket\n"));
629 InitializeListHead (&Sock
->Link
);
630 InitializeListHead (&Sock
->ConnectionList
);
631 InitializeListHead (&Sock
->ListenTokenList
);
632 InitializeListHead (&Sock
->RcvTokenList
);
633 InitializeListHead (&Sock
->SndTokenList
);
634 InitializeListHead (&Sock
->ProcessingSndTokenList
);
636 EfiInitializeLock (&(Sock
->Lock
), TPL_CALLBACK
);
638 Sock
->SndBuffer
.DataQueue
= NetbufQueAlloc ();
639 if (NULL
== Sock
->SndBuffer
.DataQueue
) {
642 "SockCreate: No resource to allocate SndBuffer for new socket\n")
648 Sock
->RcvBuffer
.DataQueue
= NetbufQueAlloc ();
649 if (NULL
== Sock
->RcvBuffer
.DataQueue
) {
652 "SockCreate: No resource to allocate RcvBuffer for new socket\n")
658 Sock
->Signature
= SOCK_SIGNATURE
;
660 Sock
->Parent
= Parent
;
661 Sock
->BackLog
= SockInitData
->BackLog
;
662 Sock
->ProtoHandler
= SockInitData
->ProtoHandler
;
663 Sock
->SndBuffer
.HighWater
= SockInitData
->SndBufferSize
;
664 Sock
->RcvBuffer
.HighWater
= SockInitData
->RcvBufferSize
;
665 Sock
->Type
= SockInitData
->Type
;
666 Sock
->DriverBinding
= SockInitData
->DriverBinding
;
667 Sock
->State
= SockInitData
->State
;
668 Sock
->CreateCallback
= SockInitData
->CreateCallback
;
669 Sock
->DestroyCallback
= SockInitData
->DestroyCallback
;
670 Sock
->Context
= SockInitData
->Context
;
672 Sock
->SockError
= EFI_ABORTED
;
673 Sock
->SndBuffer
.LowWater
= SOCK_BUFF_LOW_WATER
;
674 Sock
->RcvBuffer
.LowWater
= SOCK_BUFF_LOW_WATER
;
676 Sock
->IpVersion
= SockInitData
->IpVersion
;
679 // Install protocol on Sock->SockHandle
681 CopyMem (&Sock
->NetProtocol
, SockInitData
->Protocol
, ProtocolLength
);
684 // copy the protodata into socket
686 CopyMem (Sock
->ProtoReserved
, SockInitData
->ProtoData
, SockInitData
->DataSize
);
688 Status
= gBS
->InstallMultipleProtocolInterfaces (
695 if (EFI_ERROR (Status
)) {
698 "SockCreate: Install TCP protocol in socket failed with %r\n",
705 if (Parent
!= NULL
) {
706 ASSERT (Parent
->BackLog
> 0);
707 ASSERT (SOCK_IS_LISTENING (Parent
));
710 // need to add it into Parent->ConnectionList
711 // if the Parent->ConnCnt < Parent->BackLog
717 "SockCreate: Create a new socket and add to parent, now conncnt is %d\n",
721 InsertTailList (&Parent
->ConnectionList
, &Sock
->ConnectionList
);
724 if (Sock
->CreateCallback
!= NULL
) {
725 Status
= Sock
->CreateCallback (Sock
, Sock
->Context
);
726 if (EFI_ERROR (Status
)) {
735 if (Sock
->SockHandle
!= NULL
) {
736 gBS
->UninstallMultipleProtocolInterfaces (
744 if (NULL
!= Sock
->SndBuffer
.DataQueue
) {
745 NetbufQueFree (Sock
->SndBuffer
.DataQueue
);
748 if (NULL
!= Sock
->RcvBuffer
.DataQueue
) {
749 NetbufQueFree (Sock
->RcvBuffer
.DataQueue
);
760 @param[in, out] Sock Pointer to the socket.
769 EFI_GUID
*TcpProtocolGuid
;
772 ASSERT (SockStream
== Sock
->Type
);
774 if (Sock
->DestroyCallback
!= NULL
) {
775 Sock
->DestroyCallback (Sock
, Sock
->Context
);
779 // Flush the completion token buffered
780 // by sock and rcv, snd buffer
782 if (!SOCK_IS_UNCONFIGURED (Sock
)) {
784 SockConnFlush (Sock
);
785 SockSetState (Sock
, SO_CLOSED
);
786 Sock
->ConfigureState
= SO_UNCONFIGURED
;
790 // Destroy the RcvBuffer Queue and SendBuffer Queue
792 NetbufQueFree (Sock
->RcvBuffer
.DataQueue
);
793 NetbufQueFree (Sock
->SndBuffer
.DataQueue
);
796 // Remove it from parent connection list if needed
798 if (Sock
->Parent
!= NULL
) {
800 RemoveEntryList (&(Sock
->ConnectionList
));
801 (Sock
->Parent
->ConnCnt
)--;
805 "SockDestroy: Delete a unaccepted socket from parent now conncnt is %d\n",
806 Sock
->Parent
->ConnCnt
)
813 // Set the protocol guid and driver binding handle
814 // in the light of Sock->SockType
816 if (Sock
->IpVersion
== IP_VERSION_4
) {
817 TcpProtocolGuid
= &gEfiTcp4ProtocolGuid
;
819 TcpProtocolGuid
= &gEfiTcp6ProtocolGuid
;
823 // Retrieve the protocol installed on this sock
825 Status
= gBS
->OpenProtocol (
831 EFI_OPEN_PROTOCOL_GET_PROTOCOL
834 if (EFI_ERROR (Status
)) {
838 "SockDestroy: Open protocol installed on socket failed with %r\n",
846 // Uninstall the protocol installed on this sock
847 // in the light of Sock->SockType
849 gBS
->UninstallMultipleProtocolInterfaces (
862 Flush the sndBuffer and rcvBuffer of socket.
864 @param[in, out] Sock Pointer to the socket.
874 ASSERT (Sock
!= NULL
);
877 // Clear the flag in this socket
882 // Flush the SndBuffer and RcvBuffer of Sock
884 NetbufQueFlush (Sock
->SndBuffer
.DataQueue
);
885 NetbufQueFlush (Sock
->RcvBuffer
.DataQueue
);
888 // Signal the pending token
890 if (Sock
->ConnectionToken
!= NULL
) {
891 SIGNAL_TOKEN (Sock
->ConnectionToken
, Sock
->SockError
);
892 Sock
->ConnectionToken
= NULL
;
895 if (Sock
->CloseToken
!= NULL
) {
896 SIGNAL_TOKEN (Sock
->CloseToken
, Sock
->SockError
);
897 Sock
->CloseToken
= NULL
;
900 SockFlushPendingToken (Sock
, &(Sock
->ListenTokenList
));
901 SockFlushPendingToken (Sock
, &(Sock
->RcvTokenList
));
902 SockFlushPendingToken (Sock
, &(Sock
->SndTokenList
));
903 SockFlushPendingToken (Sock
, &(Sock
->ProcessingSndTokenList
));
906 // Destroy the pending connection, if it is a listening socket
908 if (SOCK_IS_LISTENING (Sock
)) {
909 while (!IsListEmpty (&Sock
->ConnectionList
)) {
910 Child
= NET_LIST_HEAD (
911 &Sock
->ConnectionList
,
916 SockDestroyChild (Child
);
925 Set the state of the socket.
927 @param[in, out] Sock Pointer to the socket.
928 @param[in] State The new socket state to be set.
941 Clone a new socket, including its associated protocol control block.
943 @param[in] Sock Pointer to the socket to be cloned.
945 @return Pointer to the newly cloned socket. If NULL, an error condition occurred.
954 SOCK_INIT_DATA InitData
;
956 InitData
.BackLog
= Sock
->BackLog
;
957 InitData
.Parent
= Sock
;
958 InitData
.State
= Sock
->State
;
959 InitData
.ProtoHandler
= Sock
->ProtoHandler
;
960 InitData
.Type
= Sock
->Type
;
961 InitData
.RcvBufferSize
= Sock
->RcvBuffer
.HighWater
;
962 InitData
.SndBufferSize
= Sock
->SndBuffer
.HighWater
;
963 InitData
.DriverBinding
= Sock
->DriverBinding
;
964 InitData
.IpVersion
= Sock
->IpVersion
;
965 InitData
.Protocol
= &(Sock
->NetProtocol
);
966 InitData
.CreateCallback
= Sock
->CreateCallback
;
967 InitData
.DestroyCallback
= Sock
->DestroyCallback
;
968 InitData
.Context
= Sock
->Context
;
969 InitData
.ProtoData
= Sock
->ProtoReserved
;
970 InitData
.DataSize
= sizeof (Sock
->ProtoReserved
);
972 ClonedSock
= SockCreate (&InitData
);
974 if (NULL
== ClonedSock
) {
975 DEBUG ((EFI_D_ERROR
, "SockClone: no resource to create a cloned sock\n"));
979 SockSetState (ClonedSock
, SO_CONNECTING
);
980 ClonedSock
->ConfigureState
= Sock
->ConfigureState
;
986 Called by the low layer protocol to indicate the socket a connection is
989 This function just changes the socket's state to SO_CONNECTED
990 and signals the token used for connection establishment.
992 @param[in, out] Sock Pointer to the socket associated with the
993 established connection.
997 SockConnEstablished (
1002 ASSERT (SO_CONNECTING
== Sock
->State
);
1004 SockSetState (Sock
, SO_CONNECTED
);
1006 if (NULL
== Sock
->Parent
) {
1007 SockWakeConnToken (Sock
);
1009 SockWakeListenToken (Sock
);
1015 Called by the low layer protocol to indicate the connection is closed.
1017 This function flushes the socket, sets the state to SO_CLOSED, and signals
1020 @param[in, out] Sock Pointer to the socket associated with the closed
1029 if (Sock
->CloseToken
!= NULL
) {
1030 SIGNAL_TOKEN (Sock
->CloseToken
, EFI_SUCCESS
);
1031 Sock
->CloseToken
= NULL
;
1034 SockConnFlush (Sock
);
1035 SockSetState (Sock
, SO_CLOSED
);
1037 if (Sock
->Parent
!= NULL
) {
1038 SockDestroyChild (Sock
);
1044 Called by low layer protocol to indicate that some data was sent or processed.
1046 This function trims the sent data in the socket send buffer, and signals the data
1049 @param[in, out] Sock Pointer to the socket.
1050 @param[in] Count The length of the data processed or sent, in bytes.
1055 IN OUT SOCKET
*Sock
,
1059 SOCK_TOKEN
*SockToken
;
1060 SOCK_COMPLETION_TOKEN
*SndToken
;
1062 ASSERT (!IsListEmpty (&Sock
->ProcessingSndTokenList
));
1063 ASSERT (Count
<= (Sock
->SndBuffer
.DataQueue
)->BufSize
);
1065 NetbufQueTrim (Sock
->SndBuffer
.DataQueue
, Count
);
1068 // To check if we can signal some snd token in this socket
1071 SockToken
= NET_LIST_HEAD (
1072 &(Sock
->ProcessingSndTokenList
),
1077 SndToken
= SockToken
->Token
;
1079 if (SockToken
->RemainDataLen
<= Count
) {
1081 RemoveEntryList (&(SockToken
->TokenList
));
1082 SIGNAL_TOKEN (SndToken
, EFI_SUCCESS
);
1083 Count
-= SockToken
->RemainDataLen
;
1084 FreePool (SockToken
);
1087 SockToken
->RemainDataLen
-= Count
;
1093 // to judge if we can process some send token in
1094 // Sock->SndTokenList, if so process those send token
1096 SockProcessSndToken (Sock
);
1100 Called by the low layer protocol to copy some data in the socket send
1101 buffer starting from the specific offset to a buffer provided by
1104 @param[in] Sock Pointer to the socket.
1105 @param[in] Offset The start point of the data to be copied.
1106 @param[in] Len The length of the data to be copied.
1107 @param[out] Dest Pointer to the destination to copy the data.
1109 @return The data size copied.
1120 ASSERT ((Sock
!= NULL
) && SockStream
== Sock
->Type
);
1122 return NetbufQueCopy (
1123 Sock
->SndBuffer
.DataQueue
,
1131 Called by the low layer protocol to deliver received data to socket layer.
1133 This function will append the data to the socket receive buffer, set the
1134 urgent data length, and then check if any receive token can be signaled.
1136 @param[in, out] Sock Pointer to the socket.
1137 @param[in, out] NetBuffer Pointer to the buffer that contains the received data.
1138 @param[in] UrgLen The length of the urgent data in the received data.
1143 IN OUT SOCKET
*Sock
,
1144 IN OUT NET_BUF
*NetBuffer
,
1148 ASSERT ((Sock
!= NULL
) && (Sock
->RcvBuffer
.DataQueue
!= NULL
) &&
1149 UrgLen
<= NetBuffer
->TotalSize
);
1151 NET_GET_REF (NetBuffer
);
1153 ((TCP_RSV_DATA
*) (NetBuffer
->ProtoData
))->UrgLen
= UrgLen
;
1155 NetbufQueAppend (Sock
->RcvBuffer
.DataQueue
, NetBuffer
);
1157 SockWakeRcvToken (Sock
);
1161 Get the length of the free space of the specific socket buffer.
1163 @param[in] Sock Pointer to the socket.
1164 @param[in] Which Flag to indicate which socket buffer to check:
1165 either send buffer or receive buffer.
1167 @return The length of the free space, in bytes.
1177 SOCK_BUFFER
*SockBuffer
;
1179 ASSERT (Sock
!= NULL
&& ((SOCK_SND_BUF
== Which
) || (SOCK_RCV_BUF
== Which
)));
1181 if (SOCK_SND_BUF
== Which
) {
1182 SockBuffer
= &(Sock
->SndBuffer
);
1184 SockBuffer
= &(Sock
->RcvBuffer
);
1187 BufferCC
= (SockBuffer
->DataQueue
)->BufSize
;
1189 if (BufferCC
>= SockBuffer
->HighWater
) {
1194 return SockBuffer
->HighWater
- BufferCC
;
1198 Called by the low layer protocol to indicate that there will be no more data
1199 from the communication peer.
1201 This function sets the socket's state to SO_NO_MORE_DATA and signals all queued
1202 IO tokens with the error status EFI_CONNECTION_FIN.
1204 @param[in, out] Sock Pointer to the socket.
1214 SOCK_NO_MORE_DATA (Sock
);
1216 if (!IsListEmpty (&Sock
->RcvTokenList
)) {
1218 ASSERT (0 == GET_RCV_DATASIZE (Sock
));
1220 Err
= Sock
->SockError
;
1222 SOCK_ERROR (Sock
, EFI_CONNECTION_FIN
);
1224 SockFlushPendingToken (Sock
, &Sock
->RcvTokenList
);
1226 SOCK_ERROR (Sock
, Err
);