Sync the bug that list node is free before it is removed from the list. That made...
[mirror_edk2.git] / MdeModulePkg / Universal / Network / Tcp4Dxe / Tcp4Misc.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 Tcp4Misc.c
15
16 Abstract:
17
18 Misc support routines for tcp.
19
20
21 **/
22
23
24 #include "Tcp4Main.h"
25
26 #include <Library/DevicePathLib.h>
27
28 NET_LIST_ENTRY mTcpRunQue = {
29 &mTcpRunQue,
30 &mTcpRunQue
31 };
32
33 NET_LIST_ENTRY mTcpListenQue = {
34 &mTcpListenQue,
35 &mTcpListenQue
36 };
37
38 TCP_SEQNO mTcpGlobalIss = 0x4d7e980b;
39
40 CHAR16 *mTcpStateName[] = {
41 L"TCP_CLOSED",
42 L"TCP_LISTEN",
43 L"TCP_SYN_SENT",
44 L"TCP_SYN_RCVD",
45 L"TCP_ESTABLISHED",
46 L"TCP_FIN_WAIT_1",
47 L"TCP_FIN_WAIT_2",
48 L"TCP_CLOSING",
49 L"TCP_TIME_WAIT",
50 L"TCP_CLOSE_WAIT",
51 L"TCP_LAST_ACK"
52 };
53
54
55 /**
56 Initialize the Tcb local related members.
57
58 @param Tcb Pointer to the TCP_CB of this TCP instance.
59
60 @return None
61
62 **/
63 VOID
64 TcpInitTcbLocal (
65 IN TCP_CB *Tcb
66 )
67 {
68 //
69 // Compute the checksum of the fixed parts of pseudo header
70 //
71 Tcb->HeadSum = NetPseudoHeadChecksum (
72 Tcb->LocalEnd.Ip,
73 Tcb->RemoteEnd.Ip,
74 0x06,
75 0
76 );
77
78 Tcb->Iss = TcpGetIss ();
79 Tcb->SndUna = Tcb->Iss;
80 Tcb->SndNxt = Tcb->Iss;
81
82 Tcb->SndWl2 = Tcb->Iss;
83 Tcb->SndWnd = 536;
84
85 Tcb->RcvWnd = GET_RCV_BUFFSIZE (Tcb->Sk);
86
87 //
88 // Fisrt window size is never scaled
89 //
90 Tcb->RcvWndScale = 0;
91 }
92
93
94 /**
95 Initialize the peer related members.
96
97 @param Tcb Pointer to the TCP_CB of this TCP instance.
98 @param Seg Pointer to the segment that contains the peer's
99 intial info.
100 @param Opt Pointer to the options announced by the peer.
101
102 @return None
103
104 **/
105 VOID
106 TcpInitTcbPeer (
107 IN TCP_CB *Tcb,
108 IN TCP_SEG *Seg,
109 IN TCP_OPTION *Opt
110 )
111 {
112 UINT16 RcvMss;
113
114 ASSERT (Tcb && Seg && Opt);
115 ASSERT (TCP_FLG_ON (Seg->Flag, TCP_FLG_SYN));
116
117 Tcb->SndWnd = Seg->Wnd;
118 Tcb->SndWndMax = Tcb->SndWnd;
119 Tcb->SndWl1 = Seg->Seq;
120
121 if (TCP_FLG_ON (Seg->Flag, TCP_FLG_ACK)) {
122 Tcb->SndWl2 = Seg->Ack;
123 } else {
124 Tcb->SndWl2 = Tcb->Iss + 1;
125 }
126
127 if (TCP_FLG_ON (Opt->Flag, TCP_OPTION_RCVD_MSS)) {
128 Tcb->SndMss = (UINT16) MAX (64, Opt->Mss);
129
130 RcvMss = TcpGetRcvMss (Tcb->Sk);
131 if (Tcb->SndMss > RcvMss) {
132 Tcb->SndMss = RcvMss;
133 }
134
135 } else {
136 //
137 // One end doesn't support MSS option, use default.
138 //
139 Tcb->RcvMss = 536;
140 }
141
142 Tcb->CWnd = Tcb->SndMss;
143
144 Tcb->Irs = Seg->Seq;
145 Tcb->RcvNxt = Tcb->Irs + 1;
146
147 Tcb->RcvWl2 = Tcb->RcvNxt;
148
149 if (TCP_FLG_ON (Opt->Flag, TCP_OPTION_RCVD_WS) &&
150 !TCP_FLG_ON (Tcb->CtrlFlag, TCP_CTRL_NO_WS)) {
151
152 Tcb->SndWndScale = Opt->WndScale;
153
154 Tcb->RcvWndScale = TcpComputeScale (Tcb);
155 TCP_SET_FLG (Tcb->CtrlFlag, TCP_CTRL_RCVD_WS);
156
157 } else {
158 //
159 // One end doesn't support window scale option. use zero.
160 //
161 Tcb->RcvWndScale = 0;
162 }
163
164 if (TCP_FLG_ON (Opt->Flag, TCP_OPTION_RCVD_TS) &&
165 !TCP_FLG_ON (Tcb->CtrlFlag, TCP_CTRL_NO_TS)) {
166
167 TCP_SET_FLG (Tcb->CtrlFlag, TCP_CTRL_SND_TS);
168 TCP_SET_FLG (Tcb->CtrlFlag, TCP_CTRL_RCVD_TS);
169
170 //
171 // Compute the effective SndMss per RFC1122
172 // section 4.2.2.6. If timestamp option is
173 // enabled, it will always occupy 12 bytes.
174 //
175 Tcb->SndMss -= TCP_OPTION_TS_ALIGNED_LEN;
176 }
177 }
178
179
180 /**
181 Locate a listen TCB that matchs the Local and Remote.
182
183 @param Local Pointer to the local (IP, Port).
184 @param Remote Pointer to the remote (IP, Port).
185
186 @return Pointer to the TCP_CB with the least number of wildcard, if NULL no match is found.
187
188 **/
189 STATIC
190 TCP_CB *
191 TcpLocateListenTcb (
192 IN TCP_PEER *Local,
193 IN TCP_PEER *Remote
194 )
195 {
196 NET_LIST_ENTRY *Entry;
197 TCP_CB *Node;
198 TCP_CB *Match;
199 INTN Last;
200 INTN Cur;
201
202 Last = 4;
203 Match = NULL;
204
205 NET_LIST_FOR_EACH (Entry, &mTcpListenQue) {
206 Node = NET_LIST_USER_STRUCT (Entry, TCP_CB, List);
207
208 if ((Local->Port != Node->LocalEnd.Port) ||
209 !TCP_PEER_MATCH (Remote, &Node->RemoteEnd) ||
210 !TCP_PEER_MATCH (Local, &Node->LocalEnd)
211 ) {
212
213 continue;
214 }
215
216 //
217 // Compute the number of wildcard
218 //
219 Cur = 0;
220 if (Node->RemoteEnd.Ip == 0) {
221 Cur++;
222 }
223
224 if (Node->RemoteEnd.Port == 0) {
225 Cur++;
226 }
227
228 if (Node->LocalEnd.Ip == 0) {
229 Cur++;
230 }
231
232 if (Cur < Last) {
233 if (Cur == 0) {
234 return Node;
235 }
236
237 Last = Cur;
238 Match = Node;
239 }
240 }
241
242 return Match;
243 }
244
245
246 /**
247 Try to find one Tcb whose <Ip, Port> equals to <IN Addr, IN Port>.
248
249 @param Addr Pointer to the IP address needs to match.
250 @param Port The port number needs to match.
251
252 @return The Tcb which matches the <Addr Port> paire exists or not.
253
254 **/
255 BOOLEAN
256 TcpFindTcbByPeer (
257 IN EFI_IPv4_ADDRESS *Addr,
258 IN TCP_PORTNO Port
259 )
260 {
261 TCP_PORTNO LocalPort;
262 NET_LIST_ENTRY *Entry;
263 TCP_CB *Tcb;
264
265 ASSERT ((Addr != NULL) && (Port != 0));
266
267 LocalPort = HTONS (Port);
268
269 NET_LIST_FOR_EACH (Entry, &mTcpListenQue) {
270 Tcb = NET_LIST_USER_STRUCT (Entry, TCP_CB, List);
271
272 if (EFI_IP4_EQUAL (Addr, &Tcb->LocalEnd.Ip) &&
273 (LocalPort == Tcb->LocalEnd.Port)) {
274
275 return TRUE;
276 }
277 }
278
279 NET_LIST_FOR_EACH (Entry, &mTcpRunQue) {
280 Tcb = NET_LIST_USER_STRUCT (Entry, TCP_CB, List);
281
282 if (EFI_IP4_EQUAL (Addr, &Tcb->LocalEnd.Ip) &&
283 (LocalPort == Tcb->LocalEnd.Port)) {
284
285 return TRUE;
286 }
287 }
288
289 return FALSE;
290 }
291
292
293 /**
294 Locate the TCP_CB related to the socket pair.
295
296 @param LocalPort The local port number.
297 @param LocalIp The local IP address.
298 @param RemotePort The remote port number.
299 @param RemoteIp The remote IP address.
300 @param Syn Whether to search the listen sockets, if TRUE, the
301 listen sockets are searched.
302
303 @return Pointer to the related TCP_CB, if NULL no match is found.
304
305 **/
306 TCP_CB *
307 TcpLocateTcb (
308 IN TCP_PORTNO LocalPort,
309 IN UINT32 LocalIp,
310 IN TCP_PORTNO RemotePort,
311 IN UINT32 RemoteIp,
312 IN BOOLEAN Syn
313 )
314 {
315 TCP_PEER Local;
316 TCP_PEER Remote;
317 NET_LIST_ENTRY *Entry;
318 TCP_CB *Tcb;
319
320 Local.Port = LocalPort;
321 Local.Ip = LocalIp;
322
323 Remote.Port = RemotePort;
324 Remote.Ip = RemoteIp;
325
326 //
327 // First check for exact match.
328 //
329 NET_LIST_FOR_EACH (Entry, &mTcpRunQue) {
330 Tcb = NET_LIST_USER_STRUCT (Entry, TCP_CB, List);
331
332 if (TCP_PEER_EQUAL (&Remote, &Tcb->RemoteEnd) &&
333 TCP_PEER_EQUAL (&Local, &Tcb->LocalEnd)) {
334
335 NetListRemoveEntry (&Tcb->List);
336 NetListInsertHead (&mTcpRunQue, &Tcb->List);
337
338 return Tcb;
339 }
340 }
341
342 //
343 // Only check listen queue when SYN flag is on
344 //
345 if (Syn) {
346 return TcpLocateListenTcb (&Local, &Remote);
347 }
348
349 return NULL;
350 }
351
352
353 /**
354 Insert a Tcb into the proper queue.
355
356 @param Tcb Pointer to the TCP_CB to be inserted.
357
358 @retval 0 The Tcb is inserted successfully.
359 @retval -1 Error condition occurred.
360
361 **/
362 INTN
363 TcpInsertTcb (
364 IN TCP_CB *Tcb
365 )
366 {
367 NET_LIST_ENTRY *Entry;
368 NET_LIST_ENTRY *Head;
369 TCP_CB *Node;
370 TCP4_PROTO_DATA *TcpProto;
371
372 ASSERT (
373 Tcb &&
374 (
375 (Tcb->State == TCP_LISTEN) ||
376 (Tcb->State == TCP_SYN_SENT) ||
377 (Tcb->State == TCP_SYN_RCVD) ||
378 (Tcb->State == TCP_CLOSED)
379 )
380 );
381
382 if (Tcb->LocalEnd.Port == 0) {
383 return -1;
384 }
385
386 Head = &mTcpRunQue;
387
388 if (Tcb->State == TCP_LISTEN) {
389 Head = &mTcpListenQue;
390 }
391
392 //
393 // Check that Tcb isn't already on the list.
394 //
395 NET_LIST_FOR_EACH (Entry, Head) {
396 Node = NET_LIST_USER_STRUCT (Entry, TCP_CB, List);
397
398 if (TCP_PEER_EQUAL (&Tcb->LocalEnd, &Node->LocalEnd) &&
399 TCP_PEER_EQUAL (&Tcb->RemoteEnd, &Node->RemoteEnd)) {
400
401 return -1;
402 }
403 }
404
405 NetListInsertHead (Head, &Tcb->List);
406
407 TcpProto = (TCP4_PROTO_DATA *) Tcb->Sk->ProtoReserved;
408 TcpSetVariableData (TcpProto->TcpService);
409
410 return 0;
411 }
412
413
414 /**
415 Clone a TCP_CB from Tcb.
416
417 @param Tcb Pointer to the TCP_CB to be cloned.
418
419 @return Pointer to the new cloned TCP_CB, if NULL error condition occurred.
420
421 **/
422 TCP_CB *
423 TcpCloneTcb (
424 IN TCP_CB *Tcb
425 )
426 {
427 TCP_CB *Clone;
428
429 Clone = NetAllocatePool (sizeof (TCP_CB));
430
431 if (Clone == NULL) {
432 return NULL;
433
434 }
435
436 NetCopyMem (Clone, Tcb, sizeof (TCP_CB));
437
438 //
439 // Increate the reference count of the shared IpInfo.
440 //
441 NET_GET_REF (Tcb->IpInfo);
442
443 NetListInit (&Clone->List);
444 NetListInit (&Clone->SndQue);
445 NetListInit (&Clone->RcvQue);
446
447 Clone->Sk = SockClone (Tcb->Sk);
448 if (Clone->Sk == NULL) {
449 TCP4_DEBUG_ERROR (("TcpCloneTcb: failed to clone a sock\n"));
450 NetFreePool (Clone);
451 return NULL;
452 }
453
454 ((TCP4_PROTO_DATA *) (Clone->Sk->ProtoReserved))->TcpPcb = Clone;
455
456 return Clone;
457 }
458
459
460 /**
461 Compute an ISS to be used by a new connection.
462
463 None
464
465 @return The result ISS.
466
467 **/
468 TCP_SEQNO
469 TcpGetIss (
470 VOID
471 )
472 {
473 mTcpGlobalIss += 2048;
474 return mTcpGlobalIss;
475 }
476
477
478 /**
479 Get the local mss.
480
481 None
482
483 @return The mss size.
484
485 **/
486 UINT16
487 TcpGetRcvMss (
488 IN SOCKET *Sock
489 )
490 {
491 EFI_SIMPLE_NETWORK_MODE SnpMode;
492 TCP4_PROTO_DATA *TcpProto;
493 EFI_IP4_PROTOCOL *Ip;
494
495 ASSERT (Sock);
496
497 TcpProto = (TCP4_PROTO_DATA *) Sock->ProtoReserved;
498 Ip = TcpProto->TcpService->IpIo->Ip;
499 ASSERT (Ip);
500
501 Ip->GetModeData (Ip, NULL, NULL, &SnpMode);
502
503 return (UINT16) (SnpMode.MaxPacketSize - 40);
504 }
505
506
507 /**
508 Set the Tcb's state.
509
510 @param Tcb Pointer to the TCP_CB of this TCP instance.
511 @param State The state to be set.
512
513 @return None
514
515 **/
516 VOID
517 TcpSetState (
518 IN TCP_CB *Tcb,
519 IN UINT8 State
520 )
521 {
522 TCP4_DEBUG_TRACE (
523 ("Tcb (%x) state %s --> %s\n",
524 Tcb,
525 mTcpStateName[Tcb->State],
526 mTcpStateName[State])
527 );
528
529 Tcb->State = State;
530
531 switch (State) {
532 case TCP_ESTABLISHED:
533
534 SockConnEstablished (Tcb->Sk);
535
536 if (Tcb->Parent != NULL) {
537 //
538 // A new connection is accepted by a listening socket, install
539 // the device path.
540 //
541 TcpInstallDevicePath (Tcb->Sk);
542 }
543
544 break;
545
546 case TCP_CLOSED:
547
548 SockConnClosed (Tcb->Sk);
549
550 break;
551 }
552 }
553
554
555 /**
556 Compute the TCP segment's checksum.
557
558 @param Nbuf Pointer to the buffer that contains the TCP
559 segment.
560 @param HeadSum The checksum value of the fixed part of pseudo
561 header.
562
563 @return The checksum value.
564
565 **/
566 UINT16
567 TcpChecksum (
568 IN NET_BUF *Nbuf,
569 IN UINT16 HeadSum
570 )
571 {
572 UINT16 Checksum;
573
574 Checksum = NetbufChecksum (Nbuf);
575 Checksum = NetAddChecksum (Checksum, HeadSum);
576
577 Checksum = NetAddChecksum (
578 Checksum,
579 HTONS ((UINT16) Nbuf->TotalSize)
580 );
581
582 return (UINT16) ~Checksum;
583 }
584
585
586 /**
587 Translate the information from the head of the received TCP
588 segment Nbuf contains and fill it into a TCP_SEG structure.
589
590 @param Tcb Pointer to the TCP_CB of this TCP instance.
591 @param Nbuf Pointer to the buffer contains the TCP segment.
592
593 @return Pointer to the TCP_SEG that contains the translated TCP head information.
594
595 **/
596 TCP_SEG *
597 TcpFormatNetbuf (
598 IN TCP_CB *Tcb,
599 IN NET_BUF *Nbuf
600 )
601 {
602 TCP_SEG *Seg;
603 TCP_HEAD *Head;
604
605 Seg = TCPSEG_NETBUF (Nbuf);
606 Head = (TCP_HEAD *) NetbufGetByte (Nbuf, 0, NULL);
607 Nbuf->Tcp = Head;
608
609 Seg->Seq = NTOHL (Head->Seq);
610 Seg->Ack = NTOHL (Head->Ack);
611 Seg->End = Seg->Seq + (Nbuf->TotalSize - (Head->HeadLen << 2));
612
613 Seg->Urg = NTOHS (Head->Urg);
614 Seg->Wnd = (NTOHS (Head->Wnd) << Tcb->SndWndScale);
615 Seg->Flag = Head->Flag;
616
617 //
618 // SYN and FIN flag occupy one sequence space each.
619 //
620 if (TCP_FLG_ON (Seg->Flag, TCP_FLG_SYN)) {
621 //
622 // RFC requires that initial window not be scaled
623 //
624 Seg->Wnd = NTOHS (Head->Wnd);
625 Seg->End++;
626 }
627
628 if (TCP_FLG_ON (Seg->Flag, TCP_FLG_FIN)) {
629 Seg->End++;
630 }
631
632 return Seg;
633 }
634
635
636 /**
637 Reset the connection related with Tcb.
638
639 @param Tcb Pointer to the TCP_CB of the connection to be
640 reset.
641
642 @return None
643
644 **/
645 VOID
646 TcpResetConnection (
647 IN TCP_CB *Tcb
648 )
649 {
650 NET_BUF *Nbuf;
651 TCP_HEAD *Nhead;
652
653 Nbuf = NetbufAlloc (TCP_MAX_HEAD);
654
655 if (Nbuf == NULL) {
656 return ;
657 }
658
659 Nhead = (TCP_HEAD *) NetbufAllocSpace (
660 Nbuf,
661 sizeof (TCP_HEAD),
662 NET_BUF_TAIL
663 );
664
665 ASSERT (Nhead != NULL);
666
667 Nbuf->Tcp = Nhead;
668
669 Nhead->Flag = TCP_FLG_RST;
670 Nhead->Seq = HTONL (Tcb->SndNxt);
671 Nhead->Ack = HTONL (Tcb->RcvNxt);
672 Nhead->SrcPort = Tcb->LocalEnd.Port;
673 Nhead->DstPort = Tcb->RemoteEnd.Port;
674 Nhead->HeadLen = (sizeof (TCP_HEAD) >> 2);
675 Nhead->Res = 0;
676 Nhead->Wnd = HTONS (0xFFFF);
677 Nhead->Checksum = 0;
678 Nhead->Urg = 0;
679 Nhead->Checksum = TcpChecksum (Nbuf, Tcb->HeadSum);
680
681 TcpSendIpPacket (Tcb, Nbuf, Tcb->LocalEnd.Ip, Tcb->RemoteEnd.Ip);
682
683 NetbufFree (Nbuf);
684 }
685
686
687 /**
688 Initialize an active connection,
689
690 @param Tcb Pointer to the TCP_CB that wants to initiate a
691 connection.
692
693 @return None
694
695 **/
696 VOID
697 TcpOnAppConnect (
698 IN TCP_CB *Tcb
699 )
700 {
701 TcpInitTcbLocal (Tcb);
702 TcpSetState (Tcb, TCP_SYN_SENT);
703
704 TcpSetTimer (Tcb, TCP_TIMER_CONNECT, Tcb->ConnectTimeout);
705 TcpToSendData (Tcb, 1);
706 }
707
708
709 /**
710 Initiate the connection close procedure, called when
711 applications want to close the connection.
712
713 @param Tcb Pointer to the TCP_CB of this TCP instance.
714
715 @return None.
716
717 **/
718 VOID
719 TcpOnAppClose (
720 IN TCP_CB *Tcb
721 )
722 {
723 ASSERT (Tcb);
724
725 if (!NetListIsEmpty (&Tcb->RcvQue) || GET_RCV_DATASIZE (Tcb->Sk)) {
726
727 TCP4_DEBUG_WARN (("TcpOnAppClose: connection reset "
728 "because data is lost for TCB %x\n", Tcb));
729
730 TcpResetConnection (Tcb);
731 TcpClose (Tcb);
732 return;
733 }
734
735 switch (Tcb->State) {
736 case TCP_CLOSED:
737 case TCP_LISTEN:
738 case TCP_SYN_SENT:
739 TcpSetState (Tcb, TCP_CLOSED);
740 break;
741
742 case TCP_SYN_RCVD:
743 case TCP_ESTABLISHED:
744 TcpSetState (Tcb, TCP_FIN_WAIT_1);
745 break;
746
747 case TCP_CLOSE_WAIT:
748 TcpSetState (Tcb, TCP_LAST_ACK);
749 break;
750 }
751
752 TcpToSendData (Tcb, 1);
753 }
754
755
756 /**
757 Check whether the application's newly delivered data
758 can be sent out.
759
760 @param Tcb Pointer to the TCP_CB of this TCP instance.
761
762 @retval 0 Whether the data is sent out or is buffered for
763 further sending.
764 @retval -1 The Tcb is not in a state that data is permitted to
765 be sent out.
766
767 **/
768 INTN
769 TcpOnAppSend (
770 IN TCP_CB *Tcb
771 )
772 {
773
774 switch (Tcb->State) {
775 case TCP_CLOSED:
776 return -1;
777 break;
778
779 case TCP_LISTEN:
780 return -1;
781 break;
782
783 case TCP_SYN_SENT:
784 case TCP_SYN_RCVD:
785 return 0;
786 break;
787
788 case TCP_ESTABLISHED:
789 case TCP_CLOSE_WAIT:
790 TcpToSendData (Tcb, 0);
791 return 0;
792 break;
793
794 case TCP_FIN_WAIT_1:
795 case TCP_FIN_WAIT_2:
796 case TCP_CLOSING:
797 case TCP_LAST_ACK:
798 case TCP_TIME_WAIT:
799 return -1;
800 break;
801 }
802
803 return 0;
804 }
805
806
807 /**
808 Application has consumed some data, check whether
809 to send a window updata ack or a delayed ack.
810
811 @param Tcb Pointer to the TCP_CB of this TCP instance.
812
813
814 **/
815 INTN
816 TcpOnAppConsume (
817 IN TCP_CB *Tcb
818 )
819 {
820 UINT32 TcpOld;
821
822 switch (Tcb->State) {
823 case TCP_CLOSED:
824 return -1;
825 break;
826
827 case TCP_LISTEN:
828 return -1;
829 break;
830
831 case TCP_SYN_SENT:
832 case TCP_SYN_RCVD:
833 return 0;
834 break;
835
836 case TCP_ESTABLISHED:
837 TcpOld = TcpRcvWinOld (Tcb);
838 if (TcpRcvWinNow (Tcb) > TcpOld) {
839
840 if (TcpOld < Tcb->RcvMss) {
841
842 TCP4_DEBUG_TRACE (("TcpOnAppConsume: send a window"
843 " update for a window closed Tcb(%x)\n", Tcb));
844
845 TcpSendAck (Tcb);
846 } else if (Tcb->DelayedAck == 0) {
847
848 TCP4_DEBUG_TRACE (("TcpOnAppConsume: scheduled a delayed"
849 " ACK to update window for Tcb(%x)\n", Tcb));
850
851 Tcb->DelayedAck = 1;
852 }
853 }
854
855 break;
856
857 case TCP_CLOSE_WAIT:
858 return 0;
859 break;
860
861 case TCP_FIN_WAIT_1:
862 case TCP_FIN_WAIT_2:
863 case TCP_CLOSING:
864 case TCP_LAST_ACK:
865 case TCP_TIME_WAIT:
866 return -1;
867 break;
868 }
869
870 return -1;
871 }
872
873
874 /**
875 Abort the connection by sending a reset segment, called
876 when the application wants to abort the connection.
877
878 @param Tcb Pointer to the TCP_CB of the TCP instance.
879
880 @return None.
881
882 **/
883 VOID
884 TcpOnAppAbort (
885 IN TCP_CB *Tcb
886 )
887 {
888 TCP4_DEBUG_WARN (("TcpOnAppAbort: connection reset "
889 "issued by application for TCB %x\n", Tcb));
890
891 switch (Tcb->State) {
892 case TCP_SYN_RCVD:
893 case TCP_ESTABLISHED:
894 case TCP_FIN_WAIT_1:
895 case TCP_FIN_WAIT_2:
896 case TCP_CLOSE_WAIT:
897 TcpResetConnection (Tcb);
898 break;
899 }
900
901 TcpSetState (Tcb, TCP_CLOSED);
902 }
903
904
905 /**
906 Set the Tdp4 variable data.
907
908 @param Tcp4Service Tcp4 service data.
909
910 @retval EFI_OUT_OF_RESOURCES There are not enough resources to set the variable.
911 @retval other Set variable failed.
912
913 **/
914 EFI_STATUS
915 TcpSetVariableData (
916 IN TCP4_SERVICE_DATA *Tcp4Service
917 )
918 {
919 UINT32 NumConfiguredInstance;
920 NET_LIST_ENTRY *Entry;
921 TCP_CB *TcpPcb;
922 TCP4_PROTO_DATA *TcpProto;
923 UINTN VariableDataSize;
924 EFI_TCP4_VARIABLE_DATA *Tcp4VariableData;
925 EFI_TCP4_SERVICE_POINT *Tcp4ServicePoint;
926 CHAR16 *NewMacString;
927 EFI_STATUS Status;
928
929 NumConfiguredInstance = 0;
930
931 //
932 // Go through the running queue to count the instances.
933 //
934 NET_LIST_FOR_EACH (Entry, &mTcpRunQue) {
935 TcpPcb = NET_LIST_USER_STRUCT (Entry, TCP_CB, List);
936
937 TcpProto = (TCP4_PROTO_DATA *) TcpPcb->Sk->ProtoReserved;
938
939 if (TcpProto->TcpService == Tcp4Service) {
940 //
941 // This tcp instance belongs to the Tcp4Service.
942 //
943 NumConfiguredInstance++;
944 }
945 }
946
947 //
948 // Go through the listening queue to count the instances.
949 //
950 NET_LIST_FOR_EACH (Entry, &mTcpListenQue) {
951 TcpPcb = NET_LIST_USER_STRUCT (Entry, TCP_CB, List);
952
953 TcpProto = (TCP4_PROTO_DATA *) TcpPcb->Sk->ProtoReserved;
954
955 if (TcpProto->TcpService == Tcp4Service) {
956 //
957 // This tcp instance belongs to the Tcp4Service.
958 //
959 NumConfiguredInstance++;
960 }
961 }
962
963 //
964 // Calculate the size of the Tcp4VariableData. As there may be no Tcp4 child,
965 // we should add extra buffer for the service points only if the number of configured
966 // children is more than 1.
967 //
968 VariableDataSize = sizeof (EFI_TCP4_VARIABLE_DATA);
969
970 if (NumConfiguredInstance > 1) {
971 VariableDataSize += sizeof (EFI_TCP4_SERVICE_POINT) * (NumConfiguredInstance - 1);
972 }
973
974 Tcp4VariableData = NetAllocatePool (VariableDataSize);
975 if (Tcp4VariableData == NULL) {
976 return EFI_OUT_OF_RESOURCES;
977 }
978
979 Tcp4VariableData->DriverHandle = Tcp4Service->DriverBindingHandle;
980 Tcp4VariableData->ServiceCount = NumConfiguredInstance;
981
982 Tcp4ServicePoint = &Tcp4VariableData->Services[0];
983
984 //
985 // Go through the running queue to fill the service points.
986 //
987 NET_LIST_FOR_EACH (Entry, &mTcpRunQue) {
988 TcpPcb = NET_LIST_USER_STRUCT (Entry, TCP_CB, List);
989
990 TcpProto = (TCP4_PROTO_DATA *) TcpPcb->Sk->ProtoReserved;
991
992 if (TcpProto->TcpService == Tcp4Service) {
993 //
994 // This tcp instance belongs to the Tcp4Service.
995 //
996 Tcp4ServicePoint->InstanceHandle = TcpPcb->Sk->SockHandle;
997 NetCopyMem (&Tcp4ServicePoint->LocalAddress, &TcpPcb->LocalEnd.Ip, sizeof (EFI_IPv4_ADDRESS));
998 Tcp4ServicePoint->LocalPort = NTOHS (TcpPcb->LocalEnd.Port);
999 NetCopyMem (&Tcp4ServicePoint->RemoteAddress, &TcpPcb->RemoteEnd.Ip, sizeof (EFI_IPv4_ADDRESS));
1000 Tcp4ServicePoint->RemotePort = NTOHS (TcpPcb->RemoteEnd.Port);
1001
1002 Tcp4ServicePoint++;
1003 }
1004 }
1005
1006 //
1007 // Go through the listening queue to fill the service points.
1008 //
1009 NET_LIST_FOR_EACH (Entry, &mTcpListenQue) {
1010 TcpPcb = NET_LIST_USER_STRUCT (Entry, TCP_CB, List);
1011
1012 TcpProto = (TCP4_PROTO_DATA *) TcpPcb->Sk->ProtoReserved;
1013
1014 if (TcpProto->TcpService == Tcp4Service) {
1015 //
1016 // This tcp instance belongs to the Tcp4Service.
1017 //
1018 Tcp4ServicePoint->InstanceHandle = TcpPcb->Sk->SockHandle;
1019 NetCopyMem (&Tcp4ServicePoint->LocalAddress, &TcpPcb->LocalEnd.Ip, sizeof (EFI_IPv4_ADDRESS));
1020 Tcp4ServicePoint->LocalPort = NTOHS (TcpPcb->LocalEnd.Port);
1021 NetCopyMem (&Tcp4ServicePoint->RemoteAddress, &TcpPcb->RemoteEnd.Ip, sizeof (EFI_IPv4_ADDRESS));
1022 Tcp4ServicePoint->RemotePort = NTOHS (TcpPcb->RemoteEnd.Port);
1023
1024 Tcp4ServicePoint++;
1025 }
1026 }
1027
1028 //
1029 // Get the mac string.
1030 //
1031 Status = NetLibGetMacString (
1032 Tcp4Service->ControllerHandle,
1033 Tcp4Service->DriverBindingHandle,
1034 &NewMacString
1035 );
1036 if (EFI_ERROR (Status)) {
1037 goto ON_ERROR;
1038 }
1039
1040 if (Tcp4Service->MacString != NULL) {
1041 //
1042 // The variable is set already, we're going to update it.
1043 //
1044 if (StrCmp (Tcp4Service->MacString, NewMacString) != 0) {
1045 //
1046 // The mac address is changed, delete the previous variable first.
1047 //
1048 gRT->SetVariable (
1049 Tcp4Service->MacString,
1050 &gEfiTcp4ServiceBindingProtocolGuid,
1051 EFI_VARIABLE_BOOTSERVICE_ACCESS,
1052 0,
1053 NULL
1054 );
1055 }
1056
1057 NetFreePool (Tcp4Service->MacString);
1058 }
1059
1060 Tcp4Service->MacString = NewMacString;
1061
1062 Status = gRT->SetVariable (
1063 Tcp4Service->MacString,
1064 &gEfiTcp4ServiceBindingProtocolGuid,
1065 EFI_VARIABLE_BOOTSERVICE_ACCESS,
1066 VariableDataSize,
1067 (VOID *) Tcp4VariableData
1068 );
1069
1070 ON_ERROR:
1071
1072 NetFreePool (Tcp4VariableData);
1073
1074 return Status;
1075 }
1076
1077
1078 /**
1079 Clear the variable and free the resource.
1080
1081 @param Tcp4Service Tcp4 service data.
1082
1083 @return None.
1084
1085 **/
1086 VOID
1087 TcpClearVariableData (
1088 IN TCP4_SERVICE_DATA *Tcp4Service
1089 )
1090 {
1091 ASSERT (Tcp4Service->MacString != NULL);
1092
1093 gRT->SetVariable (
1094 Tcp4Service->MacString,
1095 &gEfiTcp4ServiceBindingProtocolGuid,
1096 EFI_VARIABLE_BOOTSERVICE_ACCESS,
1097 0,
1098 NULL
1099 );
1100
1101 NetFreePool (Tcp4Service->MacString);
1102 Tcp4Service->MacString = NULL;
1103 }
1104
1105 EFI_STATUS
1106 TcpInstallDevicePath (
1107 IN SOCKET *Sock
1108 )
1109 /*++
1110
1111 Routine Description:
1112
1113 Install the device path protocol on the TCP instance.
1114
1115 Arguments:
1116
1117 Sock - Pointer to the socket representing the TCP instance.
1118
1119 Returns:
1120
1121 EFI_SUCCESS - The device path protocol is installed.
1122 other - Failed to install the device path protocol.
1123
1124 --*/
1125 {
1126 TCP4_PROTO_DATA *TcpProto;
1127 TCP4_SERVICE_DATA *TcpService;
1128 TCP_CB *Tcb;
1129 IPv4_DEVICE_PATH Ip4DPathNode;
1130 EFI_STATUS Status;
1131
1132 TcpProto = (TCP4_PROTO_DATA *) Sock->ProtoReserved;
1133 TcpService = TcpProto->TcpService;
1134 Tcb = TcpProto->TcpPcb;
1135
1136 NetLibCreateIPv4DPathNode (
1137 &Ip4DPathNode,
1138 TcpService->ControllerHandle,
1139 Tcb->LocalEnd.Ip,
1140 NTOHS (Tcb->LocalEnd.Port),
1141 Tcb->RemoteEnd.Ip,
1142 NTOHS (Tcb->RemoteEnd.Port),
1143 EFI_IP_PROTO_TCP,
1144 Tcb->UseDefaultAddr
1145 );
1146
1147 Sock->DevicePath = AppendDevicePathNode (
1148 Sock->ParentDevicePath,
1149 (EFI_DEVICE_PATH_PROTOCOL *) &Ip4DPathNode
1150 );
1151 if (Sock->DevicePath == NULL) {
1152 return EFI_OUT_OF_RESOURCES;
1153 }
1154
1155 Status = gBS->InstallProtocolInterface (
1156 &Sock->SockHandle,
1157 &gEfiDevicePathProtocolGuid,
1158 EFI_NATIVE_INTERFACE,
1159 Sock->DevicePath
1160 );
1161 if (EFI_ERROR (Status)) {
1162 NetFreePool (Sock->DevicePath);
1163 }
1164
1165 return Status;
1166 }