Sync the bug that list node is free before it is removed from the list. That made...
[mirror_edk2.git] / MdeModulePkg / Universal / Network / Tcp4Dxe / SockImpl.c
1 /** @file
2
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
8
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.
11
12 Module Name:
13
14 SockImpl.c
15
16 Abstract:
17
18
19 **/
20
21 #include "SockImpl.h"
22
23 STATIC
24 UINT32
25 SockTcpDataToRcv (
26 IN SOCK_BUFFER *SockBuffer,
27 OUT BOOLEAN *IsOOB,
28 IN UINT32 BufLen
29 );
30
31 STATIC
32 VOID
33 SockProcessSndToken (
34 IN SOCKET *Sock
35 );
36
37 VOID
38 SockFreeFoo (
39 IN EFI_EVENT Event
40 )
41 {
42 return ;
43 }
44
45
46 /**
47 Get the length of the data that can be retrieved from the socket
48 receive buffer.
49
50 @param SockBuffer Pointer to the socket receive buffer.
51 @param IsUrg Pointer to a BOOLEAN variable. If TRUE the data is
52 OOB.
53 @param BufLen The maximum length of the data buffer to store the
54 received data in socket layer.
55
56 @return The length of the data can be retreived.
57
58 **/
59 STATIC
60 UINT32
61 SockTcpDataToRcv (
62 IN SOCK_BUFFER *SockBuffer,
63 OUT BOOLEAN *IsUrg,
64 IN UINT32 BufLen
65 )
66 {
67 NET_BUF *RcvBufEntry;
68 UINT32 DataLen;
69 TCP_RSV_DATA *TcpRsvData;
70 BOOLEAN Urg;
71
72 ASSERT (SockBuffer && IsUrg && (BufLen > 0));
73
74 RcvBufEntry = SockBufFirst (SockBuffer);
75 ASSERT (RcvBufEntry);
76
77 TcpRsvData = (TCP_RSV_DATA *) RcvBufEntry->ProtoData;
78
79 *IsUrg = (BOOLEAN) ((TcpRsvData->UrgLen > 0) ? TRUE : FALSE);
80
81 if (*IsUrg && TcpRsvData->UrgLen < RcvBufEntry->TotalSize) {
82
83 DataLen = MIN (TcpRsvData->UrgLen, BufLen);
84
85 if (DataLen < TcpRsvData->UrgLen) {
86 TcpRsvData->UrgLen = TcpRsvData->UrgLen - DataLen;
87 } else {
88 TcpRsvData->UrgLen = 0;
89 }
90
91 return DataLen;
92
93 }
94
95 DataLen = RcvBufEntry->TotalSize;
96
97 RcvBufEntry = SockBufNext (SockBuffer, RcvBufEntry);
98
99 while ((BufLen > DataLen) && (RcvBufEntry != NULL)) {
100
101 TcpRsvData = (TCP_RSV_DATA *) RcvBufEntry->ProtoData;
102
103 Urg = (BOOLEAN) ((TcpRsvData->UrgLen > 0) ? TRUE : FALSE);
104
105 if (*IsUrg != Urg) {
106 break;
107 }
108
109 if (*IsUrg && TcpRsvData->UrgLen < RcvBufEntry->TotalSize) {
110
111 if (TcpRsvData->UrgLen + DataLen < BufLen) {
112 TcpRsvData->UrgLen = 0;
113 } else {
114 TcpRsvData->UrgLen = TcpRsvData->UrgLen - (BufLen - DataLen);
115 }
116
117 return MIN (TcpRsvData->UrgLen + DataLen, BufLen);
118
119 }
120
121 DataLen += RcvBufEntry->TotalSize;
122
123 RcvBufEntry = SockBufNext (SockBuffer, RcvBufEntry);
124 }
125
126 DataLen = MIN (BufLen, DataLen);
127 return DataLen;
128 }
129
130
131 /**
132 Copy data from socket buffer to application provided receive buffer.
133
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.
138
139 @return None.
140
141 **/
142 VOID
143 SockSetTcpRxData (
144 IN SOCKET *Sock,
145 IN VOID *TcpRxData,
146 IN UINT32 RcvdBytes,
147 IN BOOLEAN IsOOB
148 )
149 {
150 UINT32 Index;
151 UINT32 CopyBytes;
152 UINT32 OffSet;
153 EFI_TCP4_RECEIVE_DATA *RxData;
154 EFI_TCP4_FRAGMENT_DATA *Fragment;
155
156 RxData = (EFI_TCP4_RECEIVE_DATA *) TcpRxData;
157
158 OffSet = 0;
159
160 ASSERT (RxData->DataLength >= RcvdBytes);
161
162 RxData->DataLength = RcvdBytes;
163 RxData->UrgentFlag = IsOOB;
164
165 for (Index = 0; (Index < RxData->FragmentCount) && (RcvdBytes > 0); Index++) {
166
167 Fragment = &RxData->FragmentTable[Index];
168 CopyBytes = MIN ((UINT32) (Fragment->FragmentLength), RcvdBytes);
169
170 NetbufQueCopy (
171 Sock->RcvBuffer.DataQueue,
172 OffSet,
173 CopyBytes,
174 Fragment->FragmentBuffer
175 );
176
177 Fragment->FragmentLength = CopyBytes;
178 RcvdBytes -= CopyBytes;
179 OffSet += CopyBytes;
180 }
181 }
182
183
184 /**
185 Get received data from the socket layer to the receive token.
186
187 @param Sock Pointer to the socket.
188 @param RcvToken Pointer to the application provided receive token.
189
190 @return The length of data received in this token.
191
192 **/
193 UINT32
194 SockProcessRcvToken (
195 IN SOCKET *Sock,
196 IN SOCK_IO_TOKEN *RcvToken
197 )
198 {
199 UINT32 TokenRcvdBytes;
200 EFI_TCP4_RECEIVE_DATA *RxData;
201 BOOLEAN IsUrg;
202
203 ASSERT (Sock);
204
205 ASSERT (SOCK_STREAM == Sock->Type);
206
207 RxData = RcvToken->Packet.RxData;
208
209 TokenRcvdBytes = SockTcpDataToRcv (
210 &Sock->RcvBuffer,
211 &IsUrg,
212 (UINT32) RxData->DataLength
213 );
214
215 //
216 // Copy data from RcvBuffer of socket to user
217 // provided RxData and set the fields in TCP RxData
218 //
219 SockSetTcpRxData (Sock, RxData, TokenRcvdBytes, IsUrg);
220
221 SOCK_TRIM_RCV_BUFF (Sock, TokenRcvdBytes);
222 SIGNAL_TOKEN (&(RcvToken->Token), EFI_SUCCESS);
223
224 return TokenRcvdBytes;
225 }
226
227
228 /**
229 Process the TCP send data, buffer the tcp txdata and append
230 the buffer to socket send buffer,then try to send it.
231
232 @param Sock Pointer to the socket.
233 @param TcpTxData Pointer to the tcp txdata.
234
235 @retval EFI_SUCCESS The operation is completed successfully.
236 @retval EFI_OUT_OF_RESOURCES Failed due to resource limit.
237
238 **/
239 EFI_STATUS
240 SockProcessTcpSndData (
241 IN SOCKET *Sock,
242 IN VOID *TcpTxData
243 )
244 {
245 NET_BUF *SndData;
246 EFI_STATUS Status;
247 EFI_TCP4_TRANSMIT_DATA *TxData;
248
249 TxData = (EFI_TCP4_TRANSMIT_DATA *) TcpTxData;
250
251 //
252 // transform this TxData into a NET_BUFFER
253 // and insert it into Sock->SndBuffer
254 //
255 SndData = NetbufFromExt (
256 (NET_FRAGMENT *) TxData->FragmentTable,
257 (UINT32) TxData->FragmentCount,
258 0,
259 0,
260 SockFreeFoo,
261 NULL
262 );
263
264 if (NULL == SndData) {
265 SOCK_DEBUG_ERROR (("SockKProcessSndData: Failed to"
266 " call NetBufferFromExt\n"));
267
268 return EFI_OUT_OF_RESOURCES;
269 }
270
271 NetbufQueAppend (Sock->SndBuffer.DataQueue, SndData);
272
273 //
274 // notify the low layer protocol to handle this send token
275 //
276 if (TxData->Urgent) {
277 Status = Sock->ProtoHandler (Sock, SOCK_SNDURG, NULL);
278
279 if (EFI_ERROR (Status)) {
280 return Status;
281 }
282 }
283
284 if (TxData->Push) {
285 Status = Sock->ProtoHandler (Sock, SOCK_SNDPUSH, NULL);
286
287 if (EFI_ERROR (Status)) {
288 return Status;
289 }
290 }
291
292 //
293 // low layer protocol should really handle the sending
294 // process when catching SOCK_SND request
295 //
296 Status = Sock->ProtoHandler (Sock, SOCK_SND, NULL);
297
298 if (EFI_ERROR (Status)) {
299 return Status;
300 }
301
302 return EFI_SUCCESS;
303 }
304
305
306 /**
307 Flush the tokens in the specific token list.
308
309 @param Sock Pointer to the socket.
310 @param PendingTokenList Pointer to the token list to be flushed.
311
312 @return None.
313
314 **/
315 STATIC
316 VOID
317 SockFlushPendingToken (
318 IN SOCKET *Sock,
319 IN NET_LIST_ENTRY *PendingTokenList
320 )
321 {
322 SOCK_TOKEN *SockToken;
323 SOCK_COMPLETION_TOKEN *Token;
324
325 ASSERT (Sock && PendingTokenList);
326
327 while (!NetListIsEmpty (PendingTokenList)) {
328 SockToken = NET_LIST_HEAD (
329 PendingTokenList,
330 SOCK_TOKEN,
331 TokenList
332 );
333
334 Token = SockToken->Token;
335 SIGNAL_TOKEN (Token, Sock->SockError);
336
337 NetListRemoveEntry (&(SockToken->TokenList));
338 NetFreePool (SockToken);
339 }
340 }
341
342
343 /**
344 Wake up the connection token while the connection is
345 successfully established, then try to process any
346 pending send token.
347
348 @param Sock Pointer to the socket.
349
350 @return None.
351
352 **/
353 STATIC
354 VOID
355 SockWakeConnToken (
356 IN SOCKET *Sock
357 )
358 {
359 ASSERT (Sock->ConnectionToken != NULL);
360
361 SIGNAL_TOKEN (Sock->ConnectionToken, EFI_SUCCESS);
362 Sock->ConnectionToken = NULL;
363
364 //
365 // check to see if some pending send token existed?
366 //
367 SockProcessSndToken (Sock);
368 return ;
369 }
370
371
372 /**
373 Wake up the listen token while the connection is
374 established successfully.
375
376 @param Sock Pointer to the socket.
377
378 @return None.
379
380 **/
381 STATIC
382 VOID
383 SockWakeListenToken (
384 IN SOCKET *Sock
385 )
386 {
387 SOCKET *Parent;
388 SOCK_TOKEN *SockToken;
389 EFI_TCP4_LISTEN_TOKEN *ListenToken;
390
391 Parent = Sock->Parent;
392
393 ASSERT (Parent && SOCK_IS_LISTENING (Parent) && SOCK_IS_CONNECTED (Sock));
394
395 if (!NetListIsEmpty (&Parent->ListenTokenList)) {
396 SockToken = NET_LIST_HEAD (
397 &Parent->ListenTokenList,
398 SOCK_TOKEN,
399 TokenList
400 );
401
402 ListenToken = (EFI_TCP4_LISTEN_TOKEN *) SockToken->Token;
403 ListenToken->NewChildHandle = Sock->SockHandle;
404
405 SIGNAL_TOKEN (&(ListenToken->CompletionToken), EFI_SUCCESS);
406
407 NetListRemoveEntry (&SockToken->TokenList);
408 NetFreePool (SockToken);
409
410 NetListRemoveEntry (&Sock->ConnectionList);
411
412 Parent->ConnCnt--;
413 SOCK_DEBUG_WARN (("SockWakeListenToken: accept a socket,"
414 "now conncnt is %d", Parent->ConnCnt));
415
416 Sock->Parent = NULL;
417 }
418 }
419
420
421 /**
422 Wake up the receive token while some data is received.
423
424 @param Sock Pointer to the socket.
425
426 @return None.
427
428 **/
429 STATIC
430 VOID
431 SockWakeRcvToken (
432 IN SOCKET *Sock
433 )
434 {
435 UINT32 RcvdBytes;
436 UINT32 TokenRcvdBytes;
437 SOCK_TOKEN *SockToken;
438 SOCK_IO_TOKEN *RcvToken;
439
440 ASSERT (Sock->RcvBuffer.DataQueue);
441
442 RcvdBytes = (Sock->RcvBuffer.DataQueue)->BufSize;
443
444 ASSERT (RcvdBytes > 0);
445
446 while (RcvdBytes > 0 && !NetListIsEmpty (&Sock->RcvTokenList)) {
447
448 SockToken = NET_LIST_HEAD (
449 &Sock->RcvTokenList,
450 SOCK_TOKEN,
451 TokenList
452 );
453
454 RcvToken = (SOCK_IO_TOKEN *) SockToken->Token;
455 TokenRcvdBytes = SockProcessRcvToken (Sock, RcvToken);
456
457 if (0 == TokenRcvdBytes) {
458 return ;
459 }
460
461 NetListRemoveEntry (&(SockToken->TokenList));
462 NetFreePool (SockToken);
463 RcvdBytes -= TokenRcvdBytes;
464 }
465 }
466
467
468 /**
469 Process the send token.
470
471 @param Sock Pointer to the socket.
472
473 @return None.
474
475 **/
476 STATIC
477 VOID
478 SockProcessSndToken (
479 IN SOCKET *Sock
480 )
481 {
482 UINT32 FreeSpace;
483 SOCK_TOKEN *SockToken;
484 UINT32 DataLen;
485 SOCK_IO_TOKEN *SndToken;
486 EFI_TCP4_TRANSMIT_DATA *TxData;
487 EFI_STATUS Status;
488
489 ASSERT (Sock && (SOCK_STREAM == Sock->Type));
490
491 FreeSpace = SockGetFreeSpace (Sock, SOCK_SND_BUF);
492
493 //
494 // to determine if process a send token using
495 // socket layer flow control policy
496 //
497 while ((FreeSpace >= Sock->SndBuffer.LowWater) &&
498 !NetListIsEmpty (&Sock->SndTokenList)) {
499
500 SockToken = NET_LIST_HEAD (
501 &(Sock->SndTokenList),
502 SOCK_TOKEN,
503 TokenList
504 );
505
506 //
507 // process this token
508 //
509 NetListRemoveEntry (&(SockToken->TokenList));
510 NetListInsertTail (
511 &(Sock->ProcessingSndTokenList),
512 &(SockToken->TokenList)
513 );
514
515 //
516 // Proceess it in the light of SockType
517 //
518 SndToken = (SOCK_IO_TOKEN *) SockToken->Token;
519 TxData = SndToken->Packet.TxData;
520
521 DataLen = (UINT32) TxData->DataLength;
522 Status = SockProcessTcpSndData (Sock, TxData);
523
524 if (EFI_ERROR (Status)) {
525 goto OnError;
526 }
527
528 if (DataLen >= FreeSpace) {
529 FreeSpace = 0;
530
531 } else {
532 FreeSpace -= DataLen;
533
534 }
535 }
536
537 return ;
538
539 OnError:
540
541 NetListRemoveEntry (&SockToken->TokenList);
542 SIGNAL_TOKEN (SockToken->Token, Status);
543 NetFreePool (SockToken);
544 }
545
546
547 /**
548 Create a socket with initial data SockInitData.
549
550 @param SockInitData Pointer to the initial data of the socket.
551
552 @return Pointer to the newly created socket.
553
554 **/
555 SOCKET *
556 SockCreate (
557 IN SOCK_INIT_DATA *SockInitData
558 )
559 {
560 SOCKET *Sock;
561 SOCKET *Parent;
562 EFI_STATUS Status;
563
564 ASSERT (SockInitData && SockInitData->ProtoHandler);
565 ASSERT (SockInitData->Type == SOCK_STREAM);
566 ASSERT (SockInitData->ProtoData && (SockInitData->DataSize <= PROTO_RESERVED_LEN));
567
568 Parent = SockInitData->Parent;
569
570 if (Parent && (Parent->ConnCnt == Parent->BackLog)) {
571 SOCK_DEBUG_ERROR (
572 ("SockCreate: Socket parent has "
573 "reached its connection limit with %d ConnCnt and %d BackLog\n",
574 Parent->ConnCnt,
575 Parent->BackLog)
576 );
577
578 return NULL;
579 }
580
581 Sock = NetAllocateZeroPool (sizeof (SOCKET));
582 if (NULL == Sock) {
583
584 SOCK_DEBUG_ERROR (("SockCreate: No resource to create a new socket\n"));
585 return NULL;
586 }
587
588 NetListInit (&Sock->Link);
589 NetListInit (&Sock->ConnectionList);
590 NetListInit (&Sock->ListenTokenList);
591 NetListInit (&Sock->RcvTokenList);
592 NetListInit (&Sock->SndTokenList);
593 NetListInit (&Sock->ProcessingSndTokenList);
594
595 NET_LOCK_INIT (&(Sock->Lock));
596
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"));
601
602 goto OnError;
603 }
604
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"));
609
610 goto OnError;
611 }
612
613 Sock->Signature = SOCK_SIGNATURE;
614
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;
626
627 Sock->SockError = EFI_ABORTED;
628 Sock->SndBuffer.LowWater = SOCK_BUFF_LOW_WATER;
629 Sock->RcvBuffer.LowWater = SOCK_BUFF_LOW_WATER;
630
631 //
632 // Install protocol on Sock->SockHandle
633 //
634 NetCopyMem (
635 &(Sock->NetProtocol.TcpProtocol),
636 SockInitData->Protocol,
637 sizeof (EFI_TCP4_PROTOCOL)
638 );
639
640 //
641 // copy the protodata into socket
642 //
643 NetCopyMem (Sock->ProtoReserved, SockInitData->ProtoData, SockInitData->DataSize);
644
645 Status = gBS->InstallMultipleProtocolInterfaces (
646 &Sock->SockHandle,
647 &gEfiTcp4ProtocolGuid,
648 &(Sock->NetProtocol.TcpProtocol),
649 NULL
650 );
651
652 if (EFI_ERROR (Status)) {
653 SOCK_DEBUG_ERROR (("SockCreate: Install TCP protocol in "
654 "socket failed with %r\n", Status));
655
656 goto OnError;
657 }
658
659 if (Parent != NULL) {
660 ASSERT (Parent->BackLog > 0);
661 ASSERT (SOCK_IS_LISTENING (Parent));
662
663 //
664 // need to add it into Parent->ConnectionList
665 // if the Parent->ConnCnt < Parent->BackLog
666 //
667 Parent->ConnCnt++;
668
669 SOCK_DEBUG_WARN (("SockCreate: Create a new socket and"
670 "add to parent, now conncnt is %d\n", Parent->ConnCnt));
671
672 NetListInsertTail (&Parent->ConnectionList, &Sock->ConnectionList);
673 }
674
675 if (Sock->CreateCallback != NULL) {
676 Status = Sock->CreateCallback (Sock, Sock->Context);
677 if (EFI_ERROR (Status)) {
678 goto OnError;
679 }
680 }
681
682 return Sock;
683
684 OnError:
685
686 if (Sock->SockHandle != NULL) {
687 gBS->UninstallMultipleProtocolInterfaces (
688 Sock->SockHandle,
689 &gEfiTcp4ProtocolGuid,
690 &(Sock->NetProtocol.TcpProtocol),
691 NULL
692 );
693 }
694
695 if (NULL != Sock->SndBuffer.DataQueue) {
696 NetbufQueFree (Sock->SndBuffer.DataQueue);
697 }
698
699 if (NULL != Sock->RcvBuffer.DataQueue) {
700 NetbufQueFree (Sock->RcvBuffer.DataQueue);
701 }
702
703 NetFreePool (Sock);
704
705 return NULL;
706 }
707
708
709 /**
710 Destroy a socket.
711
712 @param Sock Pointer to the socket.
713
714 @return None.
715
716 **/
717 VOID
718 SockDestroy (
719 IN SOCKET *Sock
720 )
721 {
722 VOID *SockProtocol;
723 EFI_GUID *ProtocolGuid;
724 EFI_STATUS Status;
725
726 ASSERT (SOCK_STREAM == Sock->Type);
727
728 if (Sock->DestroyCallback != NULL) {
729 Sock->DestroyCallback (Sock, Sock->Context);
730 }
731
732 //
733 // Flush the completion token buffered
734 // by sock and rcv, snd buffer
735 //
736 if (!SOCK_IS_UNCONFIGURED (Sock)) {
737
738 SockConnFlush (Sock);
739 SockSetState (Sock, SO_CLOSED);
740 Sock->ConfigureState = SO_UNCONFIGURED;
741
742 }
743 //
744 // Destory the RcvBuffer Queue and SendBuffer Queue
745 //
746 NetbufQueFree (Sock->RcvBuffer.DataQueue);
747 NetbufQueFree (Sock->SndBuffer.DataQueue);
748
749 //
750 // Remove it from parent connection list if needed
751 //
752 if (Sock->Parent) {
753
754 NetListRemoveEntry (&(Sock->ConnectionList));
755 (Sock->Parent->ConnCnt)--;
756
757 SOCK_DEBUG_WARN (("SockDestory: Delete a unaccepted socket from parent"
758 "now conncnt is %d\n", Sock->Parent->ConnCnt));
759
760 Sock->Parent = NULL;
761 }
762
763 //
764 // Set the protocol guid and driver binding handle
765 // in the light of Sock->SockType
766 //
767 ProtocolGuid = &gEfiTcp4ProtocolGuid;
768
769 //
770 // Retrieve the protocol installed on this sock
771 //
772 Status = gBS->OpenProtocol (
773 Sock->SockHandle,
774 ProtocolGuid,
775 &SockProtocol,
776 Sock->DriverBinding,
777 Sock->SockHandle,
778 EFI_OPEN_PROTOCOL_GET_PROTOCOL
779 );
780
781 if (EFI_ERROR (Status)) {
782
783 SOCK_DEBUG_ERROR (("SockDestroy: Open protocol installed "
784 "on socket failed with %r\n", Status));
785
786 goto FreeSock;
787 }
788
789 //
790 // Uninstall the protocol installed on this sock
791 // in the light of Sock->SockType
792 //
793 gBS->UninstallMultipleProtocolInterfaces (
794 Sock->SockHandle,
795 ProtocolGuid,
796 SockProtocol,
797 NULL
798 );
799
800 FreeSock:
801 NetFreePool (Sock);
802 return ;
803 }
804
805
806 /**
807 Flush the socket.
808
809 @param Sock Pointer to the socket.
810
811 @return None.
812
813 **/
814 VOID
815 SockConnFlush (
816 IN SOCKET *Sock
817 )
818 {
819 SOCKET *Child;
820
821 ASSERT (Sock);
822
823 //
824 // Clear the flag in this socket
825 //
826 Sock->Flag = 0;
827
828 //
829 // Flush the SndBuffer and RcvBuffer of Sock
830 //
831 NetbufQueFlush (Sock->SndBuffer.DataQueue);
832 NetbufQueFlush (Sock->RcvBuffer.DataQueue);
833
834 //
835 // Signal the pending token
836 //
837 if (Sock->ConnectionToken != NULL) {
838 SIGNAL_TOKEN (Sock->ConnectionToken, Sock->SockError);
839 Sock->ConnectionToken = NULL;
840 }
841
842 if (Sock->CloseToken != NULL) {
843 SIGNAL_TOKEN (Sock->CloseToken, Sock->SockError);
844 Sock->CloseToken = NULL;
845 }
846
847 SockFlushPendingToken (Sock, &(Sock->ListenTokenList));
848 SockFlushPendingToken (Sock, &(Sock->RcvTokenList));
849 SockFlushPendingToken (Sock, &(Sock->SndTokenList));
850 SockFlushPendingToken (Sock, &(Sock->ProcessingSndTokenList));
851
852 //
853 // Destroy the pending connection, if it is a listening socket
854 //
855 if (SOCK_IS_LISTENING (Sock)) {
856 while (!NetListIsEmpty (&Sock->ConnectionList)) {
857 Child = NET_LIST_HEAD (
858 &Sock->ConnectionList,
859 SOCKET,
860 ConnectionList
861 );
862
863 SockDestroyChild (Child);
864 }
865
866 Sock->ConnCnt = 0;
867 }
868
869 return ;
870 }
871
872
873 /**
874 Set the state of the socket.
875
876 @param Sock Pointer to the socket.
877 @param State The new state to be set.
878
879 @return None.
880
881 **/
882 VOID
883 SockSetState (
884 IN SOCKET *Sock,
885 IN SOCK_STATE State
886 )
887 {
888 Sock->State = State;
889 }
890
891
892 /**
893 Clone a new socket including its associated protocol control block.
894
895 @param Sock Pointer to the socket to be cloned.
896
897 @retval * Pointer to the newly cloned socket. If NULL, error
898 condition occurred.
899
900 **/
901 SOCKET *
902 SockClone (
903 IN SOCKET *Sock
904 )
905 {
906 SOCKET *ClonedSock;
907 SOCK_INIT_DATA InitData;
908
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);
923
924 ClonedSock = SockCreate (&InitData);
925
926 if (NULL == ClonedSock) {
927 SOCK_DEBUG_ERROR (("SockClone: no resource to create a cloned sock\n"));
928 return NULL;
929 }
930
931 SockSetState (ClonedSock, SO_CONNECTING);
932 ClonedSock->ConfigureState = Sock->ConfigureState;
933
934 return ClonedSock;
935 }
936
937
938 /**
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.
943
944 @param Sock Pointer to the socket associated with the
945 established connection.
946
947 @return None.
948
949 **/
950 VOID
951 SockConnEstablished (
952 IN SOCKET *Sock
953 )
954 {
955
956 ASSERT (SO_CONNECTING == Sock->State);
957
958 SockSetState (Sock, SO_CONNECTED);
959
960 if (NULL == Sock->Parent) {
961 SockWakeConnToken (Sock);
962 } else {
963 SockWakeListenToken (Sock);
964 }
965
966 return ;
967 }
968
969
970 /**
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.
974
975 @param Sock Pointer to the socket associated with the closed
976 connection.
977
978 @return None.
979
980 **/
981 VOID
982 SockConnClosed (
983 IN SOCKET *Sock
984 )
985 {
986 if (Sock->CloseToken) {
987 SIGNAL_TOKEN (Sock->CloseToken, EFI_SUCCESS);
988 Sock->CloseToken = NULL;
989 }
990
991 SockConnFlush (Sock);
992 SockSetState (Sock, SO_CLOSED);
993
994 if (Sock->Parent != NULL) {
995 SockDestroyChild (Sock);
996 }
997
998 }
999
1000
1001 /**
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
1006
1007 @param Sock Pointer to the socket.
1008 @param Count The length of the data processed or sent, in bytes.
1009
1010 @return None.
1011
1012 **/
1013 VOID
1014 SockDataSent (
1015 IN SOCKET *Sock,
1016 IN UINT32 Count
1017 )
1018 {
1019 SOCK_TOKEN *SockToken;
1020 SOCK_COMPLETION_TOKEN *SndToken;
1021
1022 ASSERT (!NetListIsEmpty (&Sock->ProcessingSndTokenList));
1023 ASSERT (Count <= (Sock->SndBuffer.DataQueue)->BufSize);
1024
1025 NetbufQueTrim (Sock->SndBuffer.DataQueue, Count);
1026
1027 //
1028 // To check if we can signal some snd token in this socket
1029 //
1030 while (Count > 0) {
1031 SockToken = NET_LIST_HEAD (
1032 &(Sock->ProcessingSndTokenList),
1033 SOCK_TOKEN,
1034 TokenList
1035 );
1036
1037 SndToken = SockToken->Token;
1038
1039 if (SockToken->RemainDataLen <= Count) {
1040
1041 NetListRemoveEntry (&(SockToken->TokenList));
1042 SIGNAL_TOKEN (SndToken, EFI_SUCCESS);
1043 Count -= SockToken->RemainDataLen;
1044 NetFreePool (SockToken);
1045 } else {
1046
1047 SockToken->RemainDataLen -= Count;
1048 Count = 0;
1049 }
1050 }
1051
1052 //
1053 // to judge if we can process some send token in
1054 // Sock->SndTokenList, if so process those send token
1055 //
1056 SockProcessSndToken (Sock);
1057 return ;
1058 }
1059
1060
1061 /**
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
1064 the caller.
1065
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.
1070
1071 @return The data size copied.
1072
1073 **/
1074 UINT32
1075 SockGetDataToSend (
1076 IN SOCKET *Sock,
1077 IN UINT32 Offset,
1078 IN UINT32 Len,
1079 IN UINT8 *Dest
1080 )
1081 {
1082 ASSERT (Sock && SOCK_STREAM == Sock->Type);
1083
1084 return NetbufQueCopy (
1085 Sock->SndBuffer.DataQueue,
1086 Offset,
1087 Len,
1088 Dest
1089 );
1090 }
1091
1092
1093 /**
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.
1098
1099 @param Sock Pointer to the socket.
1100 @param NetBuffer Pointer to the buffer that contains the received
1101 data.
1102 @param UrgLen The length of the urgent data in the received data.
1103
1104 @return None.
1105
1106 **/
1107 VOID
1108 SockDataRcvd (
1109 IN SOCKET *Sock,
1110 IN NET_BUF *NetBuffer,
1111 IN UINT32 UrgLen
1112 )
1113 {
1114 ASSERT (Sock && Sock->RcvBuffer.DataQueue &&
1115 UrgLen <= NetBuffer->TotalSize);
1116
1117 NET_GET_REF (NetBuffer);
1118
1119 ((TCP_RSV_DATA *) (NetBuffer->ProtoData))->UrgLen = UrgLen;
1120
1121 NetbufQueAppend (Sock->RcvBuffer.DataQueue, NetBuffer);
1122
1123 SockWakeRcvToken (Sock);
1124 return ;
1125 }
1126
1127
1128 /**
1129 Get the length of the free space of the specific socket buffer.
1130
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.
1134
1135 @return The length of the free space, in bytes.
1136
1137 **/
1138 UINT32
1139 SockGetFreeSpace (
1140 IN SOCKET *Sock,
1141 IN UINT32 Which
1142 )
1143 {
1144 UINT32 BufferCC;
1145 SOCK_BUFFER *SockBuffer;
1146
1147 ASSERT (Sock && ((SOCK_SND_BUF == Which) || (SOCK_RCV_BUF == Which)));
1148
1149 if (SOCK_SND_BUF == Which) {
1150 SockBuffer = &(Sock->SndBuffer);
1151 } else {
1152 SockBuffer = &(Sock->RcvBuffer);
1153 }
1154
1155 BufferCC = (SockBuffer->DataQueue)->BufSize;
1156
1157 if (BufferCC >= SockBuffer->HighWater) {
1158
1159 return 0;
1160 }
1161
1162 return SockBuffer->HighWater - BufferCC;
1163 }
1164
1165
1166 /**
1167 Signal the receive token with the specific error or
1168 set socket error code after error is received.
1169
1170 @param Sock Pointer to the socket.
1171 @param Error The error code received.
1172
1173 @return None.
1174
1175 **/
1176 VOID
1177 SockRcvdErr (
1178 IN SOCKET *Sock,
1179 IN EFI_STATUS Error
1180 )
1181 {
1182 SOCK_TOKEN *SockToken;
1183
1184 if (!NetListIsEmpty (&Sock->RcvTokenList)) {
1185
1186 SockToken = NET_LIST_HEAD (
1187 &Sock->RcvTokenList,
1188 SOCK_TOKEN,
1189 TokenList
1190 );
1191
1192 NetListRemoveEntry (&SockToken->TokenList);
1193
1194 SIGNAL_TOKEN (SockToken->Token, Error);
1195
1196 NetFreePool (SockToken);
1197 } else {
1198
1199 SOCK_ERROR (Sock, Error);
1200 }
1201 }
1202
1203
1204 /**
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
1209 EFI_CONNECTION_FIN.
1210
1211 @param Sock Pointer to the socket.
1212
1213 @return None.
1214
1215 **/
1216 VOID
1217 SockNoMoreData (
1218 IN SOCKET *Sock
1219 )
1220 {
1221 EFI_STATUS Err;
1222
1223 SOCK_NO_MORE_DATA (Sock);
1224
1225 if (!NetListIsEmpty (&Sock->RcvTokenList)) {
1226
1227 ASSERT (0 == GET_RCV_DATASIZE (Sock));
1228
1229 Err = Sock->SockError;
1230
1231 SOCK_ERROR (Sock, EFI_CONNECTION_FIN);
1232
1233 SockFlushPendingToken (Sock, &Sock->RcvTokenList);
1234
1235 SOCK_ERROR (Sock, Err);
1236
1237 }
1238
1239 }
1240
1241
1242 /**
1243 Get the first buffer block in the specific socket buffer.
1244
1245 @param Sockbuf Pointer to the socket buffer.
1246
1247 @return Pointer to the first buffer in the queue. NULL if the queue is empty.
1248
1249 **/
1250 NET_BUF *
1251 SockBufFirst (
1252 IN SOCK_BUFFER *Sockbuf
1253 )
1254 {
1255 NET_LIST_ENTRY *NetbufList;
1256
1257 NetbufList = &(Sockbuf->DataQueue->BufList);
1258
1259 if (NetListIsEmpty (NetbufList)) {
1260 return NULL;
1261 }
1262
1263 return NET_LIST_HEAD (NetbufList, NET_BUF, List);
1264 }
1265
1266
1267 /**
1268 Get the next buffer block in the specific socket buffer.
1269
1270 @param Sockbuf Pointer to the socket buffer.
1271 @param SockEntry Pointer to the buffer block prior to the required
1272 one.
1273
1274 @return Pointer to the buffer block next to SockEntry. NULL if SockEntry is the tail or head entry.
1275
1276 **/
1277 NET_BUF *
1278 SockBufNext (
1279 IN SOCK_BUFFER *Sockbuf,
1280 IN NET_BUF *SockEntry
1281 )
1282 {
1283 NET_LIST_ENTRY *NetbufList;
1284
1285 NetbufList = &(Sockbuf->DataQueue->BufList);
1286
1287 if ((SockEntry->List.ForwardLink == NetbufList) ||
1288 (SockEntry->List.BackLink == &SockEntry->List) ||
1289 (SockEntry->List.ForwardLink == &SockEntry->List)
1290 ) {
1291
1292 return NULL;
1293 }
1294
1295 return NET_LIST_USER_STRUCT (SockEntry->List.ForwardLink, NET_BUF, List);
1296 }