TcpDispatcher.c@ 99396

Last change on this file since 99396 was 85718, checked in by vboxsync, 5 years ago
Devices/EFI: Merge edk-stable202005 and make it build, bugref:4643
Property svn:eol-style set to `native`
File size: 25.0 KB

Line
1	/** @file
2	The implementation of a dispatch routine for processing TCP requests.
3
4	(C) Copyright 2014 Hewlett-Packard Development Company, L.P.<BR>
5	Copyright (c) 2009 - 2018, Intel Corporation. All rights reserved.<BR>
6
7	SPDX-License-Identifier: BSD-2-Clause-Patent
8
9	**/
10
11	#include "TcpMain.h"
12
13	/**
14	Add or remove a route entry in the IP route table associated with this TCP instance.
15
16	@param[in] Tcb Pointer to the TCP_CB of this TCP instance.
17	@param[in] RouteInfo Pointer to the route information to be processed.
18
19	@retval EFI_SUCCESS The operation completed successfully.
20	@retval EFI_NOT_STARTED The driver instance has not been started.
21	@retval EFI_NO_MAPPING When using the default address, configuration(DHCP,
22	BOOTP, RARP, etc.) is not finished yet.
23	@retval EFI_OUT_OF_RESOURCES Could not add the entry to the routing table.
24	@retval EFI_NOT_FOUND This route is not in the routing table
25	(when RouteInfo->DeleteRoute is TRUE).
26	@retval EFI_ACCESS_DENIED The route is already defined in the routing table
27	(when RouteInfo->DeleteRoute is FALSE).
28	**/
29	EFI_STATUS
30	Tcp4Route (
31	IN TCP_CB *Tcb,
32	IN TCP4_ROUTE_INFO *RouteInfo
33	)
34	{
35	IP_IO_IP_PROTOCOL Ip;
36
37	Ip = Tcb->IpInfo->Ip;
38
39	ASSERT (Ip.Ip4!= NULL);
40
41	return Ip.Ip4->Routes (
42	Ip.Ip4,
43	RouteInfo->DeleteRoute,
44	RouteInfo->SubnetAddress,
45	RouteInfo->SubnetMask,
46	RouteInfo->GatewayAddress
47	);
48
49	}
50
51	/**
52	Get the operational settings of this TCPv4 instance.
53
54	@param[in] Tcb Pointer to the TCP_CB of this TCP instance.
55	@param[in, out] Mode Pointer to the buffer to store the operational
56	settings.
57
58	@retval EFI_SUCCESS The mode data was read.
59	@retval EFI_NOT_STARTED No configuration data is available because this
60	instance hasn't been started.
61
62	**/
63	EFI_STATUS
64	Tcp4GetMode (
65	IN TCP_CB *Tcb,
66	IN OUT TCP4_MODE_DATA *Mode
67	)
68	{
69	SOCKET *Sock;
70	EFI_TCP4_CONFIG_DATA *ConfigData;
71	EFI_TCP4_ACCESS_POINT *AccessPoint;
72	EFI_TCP4_OPTION *Option;
73	EFI_IP4_PROTOCOL *Ip;
74
75	Sock = Tcb->Sk;
76
77	if (!SOCK_IS_CONFIGURED (Sock) && (Mode->Tcp4ConfigData != NULL)) {
78	return EFI_NOT_STARTED;
79	}
80
81	if (Mode->Tcp4State != NULL) {
82	*(Mode->Tcp4State) = (EFI_TCP4_CONNECTION_STATE) Tcb->State;
83	}
84
85	if (Mode->Tcp4ConfigData != NULL) {
86
87	ConfigData = Mode->Tcp4ConfigData;
88	AccessPoint = &(ConfigData->AccessPoint);
89	Option = ConfigData->ControlOption;
90
91	ConfigData->TypeOfService = Tcb->Tos;
92	ConfigData->TimeToLive = Tcb->Ttl;
93
94	AccessPoint->UseDefaultAddress = Tcb->UseDefaultAddr;
95
96	IP4_COPY_ADDRESS (&AccessPoint->StationAddress, &Tcb->LocalEnd.Ip);
97
98	IP4_COPY_ADDRESS (&AccessPoint->SubnetMask, &Tcb->SubnetMask);
99	AccessPoint->StationPort = NTOHS (Tcb->LocalEnd.Port);
100
101	IP4_COPY_ADDRESS (&AccessPoint->RemoteAddress, &Tcb->RemoteEnd.Ip);
102
103	AccessPoint->RemotePort = NTOHS (Tcb->RemoteEnd.Port);
104	AccessPoint->ActiveFlag = (BOOLEAN) (Tcb->State != TCP_LISTEN);
105
106	if (Option != NULL) {
107	Option->ReceiveBufferSize = GET_RCV_BUFFSIZE (Tcb->Sk);
108	Option->SendBufferSize = GET_SND_BUFFSIZE (Tcb->Sk);
109	Option->MaxSynBackLog = GET_BACKLOG (Tcb->Sk);
110
111	Option->ConnectionTimeout = Tcb->ConnectTimeout / TCP_TICK_HZ;
112	Option->DataRetries = Tcb->MaxRexmit;
113	Option->FinTimeout = Tcb->FinWait2Timeout / TCP_TICK_HZ;
114	Option->TimeWaitTimeout = Tcb->TimeWaitTimeout / TCP_TICK_HZ;
115	Option->KeepAliveProbes = Tcb->MaxKeepAlive;
116	Option->KeepAliveTime = Tcb->KeepAliveIdle / TCP_TICK_HZ;
117	Option->KeepAliveInterval = Tcb->KeepAlivePeriod / TCP_TICK_HZ;
118
119	Option->EnableNagle = (BOOLEAN) (!TCP_FLG_ON (Tcb->CtrlFlag, TCP_CTRL_NO_NAGLE));
120	Option->EnableTimeStamp = (BOOLEAN) (!TCP_FLG_ON (Tcb->CtrlFlag, TCP_CTRL_NO_TS));
121	Option->EnableWindowScaling = (BOOLEAN) (!TCP_FLG_ON (Tcb->CtrlFlag, TCP_CTRL_NO_WS));
122
123	Option->EnableSelectiveAck = FALSE;
124	Option->EnablePathMtuDiscovery = FALSE;
125	}
126	}
127
128	Ip = Tcb->IpInfo->Ip.Ip4;
129	ASSERT (Ip != NULL);
130
131	return Ip->GetModeData (Ip, Mode->Ip4ModeData, Mode->MnpConfigData, Mode->SnpModeData);
132	}
133
134	/**
135	Get the operational settings of this TCPv6 instance.
136
137	@param[in] Tcb Pointer to the TCP_CB of this TCP instance.
138	@param[in, out] Mode Pointer to the buffer to store the operational
139	settings.
140
141	@retval EFI_SUCCESS The mode data was read.
142	@retval EFI_NOT_STARTED No configuration data is available because this
143	instance hasn't been started.
144
145	**/
146	EFI_STATUS
147	Tcp6GetMode (
148	IN TCP_CB *Tcb,
149	IN OUT TCP6_MODE_DATA *Mode
150	)
151	{
152	SOCKET *Sock;
153	EFI_TCP6_CONFIG_DATA *ConfigData;
154	EFI_TCP6_ACCESS_POINT *AccessPoint;
155	EFI_TCP6_OPTION *Option;
156	EFI_IP6_PROTOCOL *Ip;
157
158	Sock = Tcb->Sk;
159
160	if (!SOCK_IS_CONFIGURED (Sock) && (Mode->Tcp6ConfigData != NULL)) {
161	return EFI_NOT_STARTED;
162	}
163
164	if (Mode->Tcp6State != NULL) {
165	*(Mode->Tcp6State) = (EFI_TCP6_CONNECTION_STATE) (Tcb->State);
166	}
167
168	if (Mode->Tcp6ConfigData != NULL) {
169
170	ConfigData = Mode->Tcp6ConfigData;
171	AccessPoint = &(ConfigData->AccessPoint);
172	Option = ConfigData->ControlOption;
173
174	ConfigData->TrafficClass = Tcb->Tos;
175	ConfigData->HopLimit = Tcb->Ttl;
176
177	AccessPoint->StationPort = NTOHS (Tcb->LocalEnd.Port);
178	AccessPoint->RemotePort = NTOHS (Tcb->RemoteEnd.Port);
179	AccessPoint->ActiveFlag = (BOOLEAN) (Tcb->State != TCP_LISTEN);
180
181	IP6_COPY_ADDRESS (&AccessPoint->StationAddress, &Tcb->LocalEnd.Ip);
182	IP6_COPY_ADDRESS (&AccessPoint->RemoteAddress, &Tcb->RemoteEnd.Ip);
183
184	if (Option != NULL) {
185	Option->ReceiveBufferSize = GET_RCV_BUFFSIZE (Tcb->Sk);
186	Option->SendBufferSize = GET_SND_BUFFSIZE (Tcb->Sk);
187	Option->MaxSynBackLog = GET_BACKLOG (Tcb->Sk);
188
189	Option->ConnectionTimeout = Tcb->ConnectTimeout / TCP_TICK_HZ;
190	Option->DataRetries = Tcb->MaxRexmit;
191	Option->FinTimeout = Tcb->FinWait2Timeout / TCP_TICK_HZ;
192	Option->TimeWaitTimeout = Tcb->TimeWaitTimeout / TCP_TICK_HZ;
193	Option->KeepAliveProbes = Tcb->MaxKeepAlive;
194	Option->KeepAliveTime = Tcb->KeepAliveIdle / TCP_TICK_HZ;
195	Option->KeepAliveInterval = Tcb->KeepAlivePeriod / TCP_TICK_HZ;
196
197	Option->EnableNagle = (BOOLEAN) (!TCP_FLG_ON (Tcb->CtrlFlag, TCP_CTRL_NO_NAGLE));
198	Option->EnableTimeStamp = (BOOLEAN) (!TCP_FLG_ON (Tcb->CtrlFlag, TCP_CTRL_NO_TS));
199	Option->EnableWindowScaling = (BOOLEAN) (!TCP_FLG_ON (Tcb->CtrlFlag, TCP_CTRL_NO_WS));
200
201	Option->EnableSelectiveAck = FALSE;
202	Option->EnablePathMtuDiscovery = FALSE;
203	}
204	}
205
206	Ip = Tcb->IpInfo->Ip.Ip6;
207	ASSERT (Ip != NULL);
208
209	return Ip->GetModeData (Ip, Mode->Ip6ModeData, Mode->MnpConfigData, Mode->SnpModeData);
210	}
211
212	/**
213	If TcpAp->StationPort isn't zero, check whether the access point
214	is registered, else generate a random station port for this
215	access point.
216
217	@param[in] TcpAp Pointer to the access point.
218	@param[in] IpVersion IP_VERSION_4 or IP_VERSION_6
219
220	@retval EFI_SUCCESS The check passed or the port is assigned.
221	@retval EFI_INVALID_PARAMETER The non-zero station port is already used.
222	@retval EFI_OUT_OF_RESOURCES No port can be allocated.
223
224	**/
225	EFI_STATUS
226	TcpBind (
227	IN TCP_ACCESS_POINT *TcpAp,
228	IN UINT8 IpVersion
229	)
230	{
231	BOOLEAN Cycle;
232	EFI_IP_ADDRESS Local;
233	UINT16 *Port;
234	UINT16 *RandomPort;
235
236	if (IpVersion == IP_VERSION_4) {
237	IP4_COPY_ADDRESS (&Local, &TcpAp->Tcp4Ap.StationAddress);
238	Port = &TcpAp->Tcp4Ap.StationPort;
239	RandomPort = &mTcp4RandomPort;
240	} else {
241	IP6_COPY_ADDRESS (&Local, &TcpAp->Tcp6Ap.StationAddress);
242	Port = &TcpAp->Tcp6Ap.StationPort;
243	RandomPort = &mTcp6RandomPort;
244	}
245
246	if (0 != *Port) {
247	//
248	// Check if a same endpoing is bound.
249	//
250	if (TcpFindTcbByPeer (&Local, *Port, IpVersion)) {
251
252	return EFI_INVALID_PARAMETER;
253	}
254	} else {
255	//
256	// generate a random port
257	//
258	Cycle = FALSE;
259
260	if (TCP_PORT_USER_RESERVED == *RandomPort) {
261	*RandomPort = TCP_PORT_KNOWN;
262	}
263
264	(*RandomPort)++;
265
266	while (TcpFindTcbByPeer (&Local, *RandomPort, IpVersion)) {
267	(*RandomPort)++;
268
269	if (*RandomPort <= TCP_PORT_KNOWN) {
270	if (Cycle) {
271	DEBUG (
272	(EFI_D_ERROR,
273	"TcpBind: no port can be allocated for this pcb\n")
274	);
275	return EFI_OUT_OF_RESOURCES;
276	}
277
278	*RandomPort = TCP_PORT_KNOWN + 1;
279
280	Cycle = TRUE;
281	}
282	}
283
284	Port = RandomPort;
285	}
286
287	return EFI_SUCCESS;
288	}
289
290	/**
291	Flush the Tcb add its associated protocols.
292
293	@param[in, out] Tcb Pointer to the TCP_CB to be flushed.
294
295	**/
296	VOID
297	TcpFlushPcb (
298	IN OUT TCP_CB *Tcb
299	)
300	{
301	SOCKET *Sock;
302
303	IpIoConfigIp (Tcb->IpInfo, NULL);
304
305	Sock = Tcb->Sk;
306
307	if (SOCK_IS_CONFIGURED (Sock)) {
308	RemoveEntryList (&Tcb->List);
309
310	if (Sock->DevicePath != NULL) {
311	//
312	// Uninstall the device path protocol.
313	//
314	gBS->UninstallProtocolInterface (
315	Sock->SockHandle,
316	&gEfiDevicePathProtocolGuid,
317	Sock->DevicePath
318	);
319
320	FreePool (Sock->DevicePath);
321	Sock->DevicePath = NULL;
322	}
323	}
324
325	NetbufFreeList (&Tcb->SndQue);
326	NetbufFreeList (&Tcb->RcvQue);
327	Tcb->State = TCP_CLOSED;
328	Tcb->RemoteIpZero = FALSE;
329	}
330
331	/**
332	Attach a Pcb to the socket.
333
334	@param[in] Sk Pointer to the socket of this TCP instance.
335
336	@retval EFI_SUCCESS The operation completed successfully.
337	@retval EFI_OUT_OF_RESOURCES Failed due to resource limits.
338
339	**/
340	EFI_STATUS
341	TcpAttachPcb (
342	IN SOCKET *Sk
343	)
344	{
345	TCP_CB *Tcb;
346	TCP_PROTO_DATA *ProtoData;
347	IP_IO *IpIo;
348	EFI_STATUS Status;
349	VOID *Ip;
350	EFI_GUID *IpProtocolGuid;
351
352	if (Sk->IpVersion == IP_VERSION_4) {
353	IpProtocolGuid = &gEfiIp4ProtocolGuid;
354	} else {
355	IpProtocolGuid = &gEfiIp6ProtocolGuid;
356	}
357
358	Tcb = AllocateZeroPool (sizeof (TCP_CB));
359
360	if (Tcb == NULL) {
361
362	DEBUG ((EFI_D_ERROR, "TcpConfigurePcb: failed to allocate a TCB\n"));
363
364	return EFI_OUT_OF_RESOURCES;
365	}
366
367	ProtoData = (TCP_PROTO_DATA *) Sk->ProtoReserved;
368	IpIo = ProtoData->TcpService->IpIo;
369
370	//
371	// Create an IpInfo for this Tcb.
372	//
373	Tcb->IpInfo = IpIoAddIp (IpIo);
374	if (Tcb->IpInfo == NULL) {
375
376	FreePool (Tcb);
377	return EFI_OUT_OF_RESOURCES;
378	}
379
380	//
381	// Open the new created IP instance BY_CHILD.
382	//
383	Status = gBS->OpenProtocol (
384	Tcb->IpInfo->ChildHandle,
385	IpProtocolGuid,
386	&Ip,
387	IpIo->Image,
388	Sk->SockHandle,
389	EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
390	);
391	if (EFI_ERROR (Status)) {
392	IpIoRemoveIp (IpIo, Tcb->IpInfo);
393	FreePool (Tcb);
394	return Status;
395	}
396
397	InitializeListHead (&Tcb->List);
398	InitializeListHead (&Tcb->SndQue);
399	InitializeListHead (&Tcb->RcvQue);
400
401	Tcb->State = TCP_CLOSED;
402	Tcb->Sk = Sk;
403	ProtoData->TcpPcb = Tcb;
404
405	return EFI_SUCCESS;
406	}
407
408	/**
409	Detach the Pcb of the socket.
410
411	@param[in, out] Sk Pointer to the socket of this TCP instance.
412
413	**/
414	VOID
415	TcpDetachPcb (
416	IN OUT SOCKET *Sk
417	)
418	{
419	TCP_PROTO_DATA *ProtoData;
420	TCP_CB *Tcb;
421
422	ProtoData = (TCP_PROTO_DATA *) Sk->ProtoReserved;
423	Tcb = ProtoData->TcpPcb;
424
425	ASSERT (Tcb != NULL);
426
427	TcpFlushPcb (Tcb);
428
429	IpIoRemoveIp (ProtoData->TcpService->IpIo, Tcb->IpInfo);
430
431	FreePool (Tcb);
432
433	ProtoData->TcpPcb = NULL;
434	}
435
436	/**
437	Configure the Pcb using CfgData.
438
439	@param[in] Sk Pointer to the socket of this TCP instance.
440	@param[in] CfgData Pointer to the TCP configuration data.
441
442	@retval EFI_SUCCESS The operation completed successfully.
443	@retval EFI_INVALID_PARAMETER A same access point has been configured in
444	another TCP instance.
445	@retval EFI_OUT_OF_RESOURCES Failed due to resource limits.
446
447	**/
448	EFI_STATUS
449	TcpConfigurePcb (
450	IN SOCKET *Sk,
451	IN TCP_CONFIG_DATA *CfgData
452	)
453	{
454	IP_IO_IP_CONFIG_DATA IpCfgData;
455	EFI_STATUS Status;
456	EFI_TCP4_OPTION *Option;
457	TCP_PROTO_DATA *TcpProto;
458	TCP_CB *Tcb;
459	TCP_ACCESS_POINT *TcpAp;
460
461	ASSERT ((CfgData != NULL) && (Sk != NULL) && (Sk->SockHandle != NULL));
462
463	TcpProto = (TCP_PROTO_DATA *) Sk->ProtoReserved;
464	Tcb = TcpProto->TcpPcb;
465
466	ASSERT (Tcb != NULL);
467
468	if (Sk->IpVersion == IP_VERSION_4) {
469	//
470	// Add Ip for send pkt to the peer
471	//
472	CopyMem (&IpCfgData.Ip4CfgData, &mIp4IoDefaultIpConfigData, sizeof (EFI_IP4_CONFIG_DATA));
473	IpCfgData.Ip4CfgData.DefaultProtocol = EFI_IP_PROTO_TCP;
474	IpCfgData.Ip4CfgData.TypeOfService = CfgData->Tcp4CfgData.TypeOfService;
475	IpCfgData.Ip4CfgData.TimeToLive = CfgData->Tcp4CfgData.TimeToLive;
476	IpCfgData.Ip4CfgData.UseDefaultAddress = CfgData->Tcp4CfgData.AccessPoint.UseDefaultAddress;
477	IP4_COPY_ADDRESS (
478	&IpCfgData.Ip4CfgData.SubnetMask,
479	&CfgData->Tcp4CfgData.AccessPoint.SubnetMask
480	);
481	IpCfgData.Ip4CfgData.ReceiveTimeout = (UINT32) (-1);
482	IP4_COPY_ADDRESS (
483	&IpCfgData.Ip4CfgData.StationAddress,
484	&CfgData->Tcp4CfgData.AccessPoint.StationAddress
485	);
486
487	} else {
488	ASSERT (Sk->IpVersion == IP_VERSION_6);
489
490	CopyMem (&IpCfgData.Ip6CfgData, &mIp6IoDefaultIpConfigData, sizeof (EFI_IP6_CONFIG_DATA));
491	IpCfgData.Ip6CfgData.DefaultProtocol = EFI_IP_PROTO_TCP;
492	IpCfgData.Ip6CfgData.TrafficClass = CfgData->Tcp6CfgData.TrafficClass;
493	IpCfgData.Ip6CfgData.HopLimit = CfgData->Tcp6CfgData.HopLimit;
494	IpCfgData.Ip6CfgData.ReceiveTimeout = (UINT32) (-1);
495	IP6_COPY_ADDRESS (
496	&IpCfgData.Ip6CfgData.StationAddress,
497	&CfgData->Tcp6CfgData.AccessPoint.StationAddress
498	);
499	IP6_COPY_ADDRESS (
500	&IpCfgData.Ip6CfgData.DestinationAddress,
501	&CfgData->Tcp6CfgData.AccessPoint.RemoteAddress
502	);
503	}
504
505	//
506	// Configure the IP instance this Tcb consumes.
507	//
508	Status = IpIoConfigIp (Tcb->IpInfo, &IpCfgData);
509	if (EFI_ERROR (Status)) {
510	goto OnExit;
511	}
512
513	if (Sk->IpVersion == IP_VERSION_4) {
514	//
515	// Get the default address information if the instance is configured to use default address.
516	//
517	IP4_COPY_ADDRESS (
518	&CfgData->Tcp4CfgData.AccessPoint.StationAddress,
519	&IpCfgData.Ip4CfgData.StationAddress
520	);
521	IP4_COPY_ADDRESS (
522	&CfgData->Tcp4CfgData.AccessPoint.SubnetMask,
523	&IpCfgData.Ip4CfgData.SubnetMask
524	);
525
526	TcpAp = (TCP_ACCESS_POINT *) &CfgData->Tcp4CfgData.AccessPoint;
527	} else {
528	IP6_COPY_ADDRESS (
529	&CfgData->Tcp6CfgData.AccessPoint.StationAddress,
530	&IpCfgData.Ip6CfgData.StationAddress
531	);
532
533	TcpAp = (TCP_ACCESS_POINT *) &CfgData->Tcp6CfgData.AccessPoint;
534	}
535
536	//
537	// check if we can bind this endpoint in CfgData
538	//
539	Status = TcpBind (TcpAp, Sk->IpVersion);
540
541	if (EFI_ERROR (Status)) {
542	DEBUG (
543	(EFI_D_ERROR,
544	"TcpConfigurePcb: Bind endpoint failed with %r\n",
545	Status)
546	);
547
548	goto OnExit;
549	}
550
551	//
552	// Initialize the operating information in this Tcb
553	//
554	ASSERT (Tcb->State == TCP_CLOSED &&
555	IsListEmpty (&Tcb->SndQue) &&
556	IsListEmpty (&Tcb->RcvQue));
557
558	TCP_SET_FLG (Tcb->CtrlFlag, TCP_CTRL_NO_KEEPALIVE);
559	Tcb->State = TCP_CLOSED;
560
561	Tcb->SndMss = 536;
562	Tcb->RcvMss = TcpGetRcvMss (Sk);
563
564	Tcb->SRtt = 0;
565	Tcb->Rto = 3 * TCP_TICK_HZ;
566
567	Tcb->CWnd = Tcb->SndMss;
568	Tcb->Ssthresh = 0xffffffff;
569
570	Tcb->CongestState = TCP_CONGEST_OPEN;
571
572	Tcb->KeepAliveIdle = TCP_KEEPALIVE_IDLE_MIN;
573	Tcb->KeepAlivePeriod = TCP_KEEPALIVE_PERIOD;
574	Tcb->MaxKeepAlive = TCP_MAX_KEEPALIVE;
575	Tcb->MaxRexmit = TCP_MAX_LOSS;
576	Tcb->FinWait2Timeout = TCP_FIN_WAIT2_TIME;
577	Tcb->TimeWaitTimeout = TCP_TIME_WAIT_TIME;
578	Tcb->ConnectTimeout = TCP_CONNECT_TIME;
579
580	if (Sk->IpVersion == IP_VERSION_4) {
581	//
582	// initialize Tcb in the light of CfgData
583	//
584	Tcb->Ttl = CfgData->Tcp4CfgData.TimeToLive;
585	Tcb->Tos = CfgData->Tcp4CfgData.TypeOfService;
586
587	Tcb->UseDefaultAddr = CfgData->Tcp4CfgData.AccessPoint.UseDefaultAddress;
588
589	CopyMem (&Tcb->LocalEnd.Ip, &CfgData->Tcp4CfgData.AccessPoint.StationAddress, sizeof (IP4_ADDR));
590	Tcb->LocalEnd.Port = HTONS (CfgData->Tcp4CfgData.AccessPoint.StationPort);
591	IP4_COPY_ADDRESS (&Tcb->SubnetMask, &CfgData->Tcp4CfgData.AccessPoint.SubnetMask);
592
593	CopyMem (&Tcb->RemoteEnd.Ip, &CfgData->Tcp4CfgData.AccessPoint.RemoteAddress, sizeof (IP4_ADDR));
594	Tcb->RemoteEnd.Port = HTONS (CfgData->Tcp4CfgData.AccessPoint.RemotePort);
595
596	Option = CfgData->Tcp4CfgData.ControlOption;
597	} else {
598	Tcb->Ttl = CfgData->Tcp6CfgData.HopLimit;
599	Tcb->Tos = CfgData->Tcp6CfgData.TrafficClass;
600
601	IP6_COPY_ADDRESS (&Tcb->LocalEnd.Ip, &CfgData->Tcp6CfgData.AccessPoint.StationAddress);
602	Tcb->LocalEnd.Port = HTONS (CfgData->Tcp6CfgData.AccessPoint.StationPort);
603
604	IP6_COPY_ADDRESS (&Tcb->RemoteEnd.Ip, &CfgData->Tcp6CfgData.AccessPoint.RemoteAddress);
605	Tcb->RemoteEnd.Port = HTONS (CfgData->Tcp6CfgData.AccessPoint.RemotePort);
606
607	//
608	// Type EFI_TCP4_OPTION and EFI_TCP6_OPTION are the same.
609	//
610	Option = (EFI_TCP4_OPTION *) CfgData->Tcp6CfgData.ControlOption;
611	}
612
613	if (Option != NULL) {
614	SET_RCV_BUFFSIZE (
615	Sk,
616	(UINT32) (TCP_COMP_VAL (
617	TCP_RCV_BUF_SIZE_MIN,
618	TCP_RCV_BUF_SIZE,
619	TCP_RCV_BUF_SIZE,
620	Option->ReceiveBufferSize
621	)
622	)
623	);
624	SET_SND_BUFFSIZE (
625	Sk,
626	(UINT32) (TCP_COMP_VAL (
627	TCP_SND_BUF_SIZE_MIN,
628	TCP_SND_BUF_SIZE,
629	TCP_SND_BUF_SIZE,
630	Option->SendBufferSize
631	)
632	)
633	);
634
635	SET_BACKLOG (
636	Sk,
637	(UINT32) (TCP_COMP_VAL (
638	TCP_BACKLOG_MIN,
639	TCP_BACKLOG,
640	TCP_BACKLOG,
641	Option->MaxSynBackLog
642	)
643	)
644	);
645
646	Tcb->MaxRexmit = (UINT16) TCP_COMP_VAL (
647	TCP_MAX_LOSS_MIN,
648	TCP_MAX_LOSS,
649	TCP_MAX_LOSS,
650	Option->DataRetries
651	);
652	Tcb->FinWait2Timeout = TCP_COMP_VAL (
653	TCP_FIN_WAIT2_TIME,
654	TCP_FIN_WAIT2_TIME_MAX,
655	TCP_FIN_WAIT2_TIME,
656	(UINT32) (Option->FinTimeout * TCP_TICK_HZ)
657	);
658
659	if (Option->TimeWaitTimeout != 0) {
660	Tcb->TimeWaitTimeout = TCP_COMP_VAL (
661	TCP_TIME_WAIT_TIME,
662	TCP_TIME_WAIT_TIME_MAX,
663	TCP_TIME_WAIT_TIME,
664	(UINT32) (Option->TimeWaitTimeout * TCP_TICK_HZ)
665	);
666	} else {
667	Tcb->TimeWaitTimeout = 0;
668	}
669
670	if (Option->KeepAliveProbes != 0) {
671	TCP_CLEAR_FLG (Tcb->CtrlFlag, TCP_CTRL_NO_KEEPALIVE);
672
673	Tcb->MaxKeepAlive = (UINT8) TCP_COMP_VAL (
674	TCP_MAX_KEEPALIVE_MIN,
675	TCP_MAX_KEEPALIVE,
676	TCP_MAX_KEEPALIVE,
677	Option->KeepAliveProbes
678	);
679	Tcb->KeepAliveIdle = TCP_COMP_VAL (
680	TCP_KEEPALIVE_IDLE_MIN,
681	TCP_KEEPALIVE_IDLE_MAX,
682	TCP_KEEPALIVE_IDLE_MIN,
683	(UINT32) (Option->KeepAliveTime * TCP_TICK_HZ)
684	);
685	Tcb->KeepAlivePeriod = TCP_COMP_VAL (
686	TCP_KEEPALIVE_PERIOD_MIN,
687	TCP_KEEPALIVE_PERIOD,
688	TCP_KEEPALIVE_PERIOD,
689	(UINT32) (Option->KeepAliveInterval * TCP_TICK_HZ)
690	);
691	}
692
693	Tcb->ConnectTimeout = TCP_COMP_VAL (
694	TCP_CONNECT_TIME_MIN,
695	TCP_CONNECT_TIME,
696	TCP_CONNECT_TIME,
697	(UINT32) (Option->ConnectionTimeout * TCP_TICK_HZ)
698	);
699
700	if (!Option->EnableNagle) {
701	TCP_SET_FLG (Tcb->CtrlFlag, TCP_CTRL_NO_NAGLE);
702	}
703
704	if (!Option->EnableTimeStamp) {
705	TCP_SET_FLG (Tcb->CtrlFlag, TCP_CTRL_NO_TS);
706	}
707
708	if (!Option->EnableWindowScaling) {
709	TCP_SET_FLG (Tcb->CtrlFlag, TCP_CTRL_NO_WS);
710	}
711	}
712
713	//
714	// The socket is bound, the <SrcIp, SrcPort, DstIp, DstPort> is
715	// determined, construct the IP device path and install it.
716	//
717	Status = TcpInstallDevicePath (Sk);
718	if (EFI_ERROR (Status)) {
719	goto OnExit;
720	}
721
722	//
723	// update state of Tcb and socket
724	//
725	if (((Sk->IpVersion == IP_VERSION_4) && !CfgData->Tcp4CfgData.AccessPoint.ActiveFlag) \|\|
726	((Sk->IpVersion == IP_VERSION_6) && !CfgData->Tcp6CfgData.AccessPoint.ActiveFlag)
727	) {
728
729	TcpSetState (Tcb, TCP_LISTEN);
730	SockSetState (Sk, SO_LISTENING);
731
732	Sk->ConfigureState = SO_CONFIGURED_PASSIVE;
733	} else {
734
735	Sk->ConfigureState = SO_CONFIGURED_ACTIVE;
736	}
737
738	if (Sk->IpVersion == IP_VERSION_6) {
739	Tcb->Tick = TCP6_REFRESH_NEIGHBOR_TICK;
740
741	if (NetIp6IsUnspecifiedAddr (&Tcb->RemoteEnd.Ip.v6)) {
742	Tcb->RemoteIpZero = TRUE;
743	}
744	}
745
746	TcpInsertTcb (Tcb);
747
748	OnExit:
749
750	return Status;
751	}
752
753	/**
754	The protocol handler provided to the socket layer, which is used to
755	dispatch the socket level requests by calling the corresponding
756	TCP layer functions.
757
758	@param[in] Sock Pointer to the socket of this TCP instance.
759	@param[in] Request The code of this operation request.
760	@param[in] Data Pointer to the operation specific data passed in
761	together with the operation request. This is an
762	optional parameter that may be NULL.
763
764	@retval EFI_SUCCESS The socket request completed successfully.
765	@retval other The error status returned by the corresponding TCP
766	layer function.
767
768	**/
769	EFI_STATUS
770	TcpDispatcher (
771	IN SOCKET *Sock,
772	IN UINT8 Request,
773	IN VOID *Data OPTIONAL
774	)
775	{
776	TCP_CB *Tcb;
777	TCP_PROTO_DATA *ProtoData;
778
779	ProtoData = (TCP_PROTO_DATA *) Sock->ProtoReserved;
780	Tcb = ProtoData->TcpPcb;
781
782	switch (Request) {
783	case SOCK_POLL:
784	if (Tcb->Sk->IpVersion == IP_VERSION_4) {
785	ProtoData->TcpService->IpIo->Ip.Ip4->Poll (ProtoData->TcpService->IpIo->Ip.Ip4);
786	} else {
787	ProtoData->TcpService->IpIo->Ip.Ip6->Poll (ProtoData->TcpService->IpIo->Ip.Ip6);
788	}
789
790	break;
791
792	case SOCK_CONSUMED:
793	//
794	// After user received data from socket buffer, socket will
795	// notify TCP using this message to give it a chance to send out
796	// window update information
797	//
798	ASSERT (Tcb != NULL);
799	TcpOnAppConsume (Tcb);
800	break;
801
802	case SOCK_SND:
803
804	ASSERT (Tcb != NULL);
805	TcpOnAppSend (Tcb);
806	break;
807
808	case SOCK_CLOSE:
809
810	TcpOnAppClose (Tcb);
811
812	break;
813
814	case SOCK_ABORT:
815
816	TcpOnAppAbort (Tcb);
817
818	break;
819
820	case SOCK_SNDPUSH:
821	Tcb->SndPsh = TcpGetMaxSndNxt (Tcb) + GET_SND_DATASIZE (Tcb->Sk);
822	TCP_SET_FLG (Tcb->CtrlFlag, TCP_CTRL_SND_PSH);
823
824	break;
825
826	case SOCK_SNDURG:
827	Tcb->SndUp = TcpGetMaxSndNxt (Tcb) + GET_SND_DATASIZE (Tcb->Sk) - 1;
828	TCP_SET_FLG (Tcb->CtrlFlag, TCP_CTRL_SND_URG);
829
830	break;
831
832	case SOCK_CONNECT:
833
834	TcpOnAppConnect (Tcb);
835
836	break;
837
838	case SOCK_ATTACH:
839
840	return TcpAttachPcb (Sock);
841
842	break;
843
844	case SOCK_FLUSH:
845
846	TcpFlushPcb (Tcb);
847
848	break;
849
850	case SOCK_DETACH:
851
852	TcpDetachPcb (Sock);
853
854	break;
855
856	case SOCK_CONFIGURE:
857
858	return TcpConfigurePcb (
859	Sock,
860	(TCP_CONFIG_DATA *) Data
861	);
862
863	break;
864
865	case SOCK_MODE:
866
867	ASSERT ((Data != NULL) && (Tcb != NULL));
868
869	if (Tcb->Sk->IpVersion == IP_VERSION_4) {
870
871	return Tcp4GetMode (Tcb, (TCP4_MODE_DATA *) Data);
872	} else {
873
874	return Tcp6GetMode (Tcb, (TCP6_MODE_DATA *) Data);
875	}
876
877	break;
878
879	case SOCK_ROUTE:
880
881	ASSERT ((Data != NULL) && (Tcb != NULL) && (Tcb->Sk->IpVersion == IP_VERSION_4));
882
883	return Tcp4Route (Tcb, (TCP4_ROUTE_INFO *) Data);
884
885	default:
886
887	return EFI_UNSUPPORTED;
888	}
889
890	return EFI_SUCCESS;
891	}

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Devices/EFI/FirmwareNew/NetworkPkg/TcpDxe/TcpDispatcher.c@ 99396

Download in other formats: