TcpDriver.c@ 80721

Last change on this file since 80721 was 80721, checked in by vboxsync, 5 years ago
Devices/EFI/FirmwareNew: Start upgrade process to edk2-stable201908 (compiles on Windows and works to some extent), bugref:4643
Property svn:eol-style set to `native`
File size: 27.2 KB

Line
1	/** @file
2	The driver binding and service binding protocol for the TCP driver.
3
4	Copyright (c) 2009 - 2018, Intel Corporation. All rights reserved.<BR>
5
6	SPDX-License-Identifier: BSD-2-Clause-Patent
7
8	**/
9
10	#include "TcpMain.h"
11
12	UINT16 mTcp4RandomPort;
13	UINT16 mTcp6RandomPort;
14
15	TCP_HEARTBEAT_TIMER mTcpTimer = {
16	NULL,
17	0
18	};
19
20	EFI_TCP4_PROTOCOL gTcp4ProtocolTemplate = {
21	Tcp4GetModeData,
22	Tcp4Configure,
23	Tcp4Routes,
24	Tcp4Connect,
25	Tcp4Accept,
26	Tcp4Transmit,
27	Tcp4Receive,
28	Tcp4Close,
29	Tcp4Cancel,
30	Tcp4Poll
31	};
32
33	EFI_TCP6_PROTOCOL gTcp6ProtocolTemplate = {
34	Tcp6GetModeData,
35	Tcp6Configure,
36	Tcp6Connect,
37	Tcp6Accept,
38	Tcp6Transmit,
39	Tcp6Receive,
40	Tcp6Close,
41	Tcp6Cancel,
42	Tcp6Poll
43	};
44
45	SOCK_INIT_DATA mTcpDefaultSockData = {
46	SockStream,
47	SO_CLOSED,
48	NULL,
49	TCP_BACKLOG,
50	TCP_SND_BUF_SIZE,
51	TCP_RCV_BUF_SIZE,
52	IP_VERSION_4,
53	NULL,
54	TcpCreateSocketCallback,
55	TcpDestroySocketCallback,
56	NULL,
57	NULL,
58	0,
59	TcpDispatcher,
60	NULL,
61	};
62
63	EFI_DRIVER_BINDING_PROTOCOL gTcp4DriverBinding = {
64	Tcp4DriverBindingSupported,
65	Tcp4DriverBindingStart,
66	Tcp4DriverBindingStop,
67	0xa,
68	NULL,
69	NULL
70	};
71
72	EFI_DRIVER_BINDING_PROTOCOL gTcp6DriverBinding = {
73	Tcp6DriverBindingSupported,
74	Tcp6DriverBindingStart,
75	Tcp6DriverBindingStop,
76	0xa,
77	NULL,
78	NULL
79	};
80
81	EFI_SERVICE_BINDING_PROTOCOL gTcpServiceBinding = {
82	TcpServiceBindingCreateChild,
83	TcpServiceBindingDestroyChild
84	};
85
86
87	/**
88	Create and start the heartbeat timer for the TCP driver.
89
90	@retval EFI_SUCCESS The timer was successfully created and started.
91	@retval other The timer was not created.
92
93	**/
94	EFI_STATUS
95	TcpCreateTimer (
96	VOID
97	)
98	{
99	EFI_STATUS Status;
100
101	Status = EFI_SUCCESS;
102
103	if (mTcpTimer.RefCnt == 0) {
104
105	Status = gBS->CreateEvent (
106	EVT_TIMER \| EVT_NOTIFY_SIGNAL,
107	TPL_NOTIFY,
108	TcpTicking,
109	NULL,
110	&mTcpTimer.TimerEvent
111	);
112	if (!EFI_ERROR (Status)) {
113
114	Status = gBS->SetTimer (
115	mTcpTimer.TimerEvent,
116	TimerPeriodic,
117	(UINT64) (TICKS_PER_SECOND / TCP_TICK_HZ)
118	);
119	}
120	}
121
122	if (!EFI_ERROR (Status)) {
123
124	mTcpTimer.RefCnt++;
125	}
126
127	return Status;
128	}
129
130	/**
131	Stop and destroy the heartbeat timer for TCP driver.
132
133	**/
134	VOID
135	TcpDestroyTimer (
136	VOID
137	)
138	{
139	ASSERT (mTcpTimer.RefCnt > 0);
140
141	mTcpTimer.RefCnt--;
142
143	if (mTcpTimer.RefCnt > 0) {
144	return;
145	}
146
147	gBS->SetTimer (mTcpTimer.TimerEvent, TimerCancel, 0);
148	gBS->CloseEvent (mTcpTimer.TimerEvent);
149	mTcpTimer.TimerEvent = NULL;
150	}
151
152	/**
153	The entry point for Tcp driver, which is used to install Tcp driver on the ImageHandle.
154
155	@param[in] ImageHandle The firmware allocated handle for this driver image.
156	@param[in] SystemTable Pointer to the EFI system table.
157
158	@retval EFI_SUCCESS The driver loaded.
159	@retval other The driver did not load.
160
161	**/
162	EFI_STATUS
163	EFIAPI
164	TcpDriverEntryPoint (
165	IN EFI_HANDLE ImageHandle,
166	IN EFI_SYSTEM_TABLE *SystemTable
167	)
168	{
169	EFI_STATUS Status;
170	UINT32 Seed;
171
172	//
173	// Install the TCP Driver Binding Protocol
174	//
175	Status = EfiLibInstallDriverBindingComponentName2 (
176	ImageHandle,
177	SystemTable,
178	&gTcp4DriverBinding,
179	ImageHandle,
180	&gTcpComponentName,
181	&gTcpComponentName2
182	);
183	if (EFI_ERROR (Status)) {
184	return Status;
185	}
186
187	//
188	// Install the TCP Driver Binding Protocol
189	//
190	Status = EfiLibInstallDriverBindingComponentName2 (
191	ImageHandle,
192	SystemTable,
193	&gTcp6DriverBinding,
194	NULL,
195	&gTcpComponentName,
196	&gTcpComponentName2
197	);
198	if (EFI_ERROR (Status)) {
199	EfiLibUninstallDriverBindingComponentName2 (
200	&gTcp4DriverBinding,
201	&gTcpComponentName,
202	&gTcpComponentName2
203	);
204	return Status;
205	}
206
207	//
208	// Initialize ISS and random port.
209	//
210	Seed = NetRandomInitSeed ();
211	mTcpGlobalIss = NET_RANDOM (Seed) % mTcpGlobalIss;
212	mTcp4RandomPort = (UINT16) (TCP_PORT_KNOWN + (NET_RANDOM (Seed) % TCP_PORT_KNOWN));
213	mTcp6RandomPort = mTcp4RandomPort;
214
215	return EFI_SUCCESS;
216	}
217
218	/**
219	Create a new TCP4 or TCP6 driver service binding protocol
220
221	@param[in] Controller Controller handle of device to bind driver to.
222	@param[in] Image The TCP driver's image handle.
223	@param[in] IpVersion IP_VERSION_4 or IP_VERSION_6.
224
225	@retval EFI_OUT_OF_RESOURCES Failed to allocate some resources.
226	@retval EFI_SUCCESS A new IP6 service binding private was created.
227
228	**/
229	EFI_STATUS
230	TcpCreateService (
231	IN EFI_HANDLE Controller,
232	IN EFI_HANDLE Image,
233	IN UINT8 IpVersion
234	)
235	{
236	EFI_STATUS Status;
237	EFI_GUID *IpServiceBindingGuid;
238	EFI_GUID *TcpServiceBindingGuid;
239	TCP_SERVICE_DATA *TcpServiceData;
240	IP_IO_OPEN_DATA OpenData;
241
242	if (IpVersion == IP_VERSION_4) {
243	IpServiceBindingGuid = &gEfiIp4ServiceBindingProtocolGuid;
244	TcpServiceBindingGuid = &gEfiTcp4ServiceBindingProtocolGuid;
245	} else {
246	IpServiceBindingGuid = &gEfiIp6ServiceBindingProtocolGuid;
247	TcpServiceBindingGuid = &gEfiTcp6ServiceBindingProtocolGuid;
248	}
249
250	Status = gBS->OpenProtocol (
251	Controller,
252	TcpServiceBindingGuid,
253	NULL,
254	Image,
255	Controller,
256	EFI_OPEN_PROTOCOL_TEST_PROTOCOL
257	);
258	if (!EFI_ERROR (Status)) {
259	return EFI_ALREADY_STARTED;
260	}
261
262	Status = gBS->OpenProtocol (
263	Controller,
264	IpServiceBindingGuid,
265	NULL,
266	Image,
267	Controller,
268	EFI_OPEN_PROTOCOL_TEST_PROTOCOL
269	);
270	if (EFI_ERROR (Status)) {
271	return EFI_UNSUPPORTED;
272	}
273
274	//
275	// Create the TCP service data.
276	//
277	TcpServiceData = AllocateZeroPool (sizeof (TCP_SERVICE_DATA));
278	if (TcpServiceData == NULL) {
279	return EFI_OUT_OF_RESOURCES;
280	}
281
282	TcpServiceData->Signature = TCP_DRIVER_SIGNATURE;
283	TcpServiceData->ControllerHandle = Controller;
284	TcpServiceData->DriverBindingHandle = Image;
285	TcpServiceData->IpVersion = IpVersion;
286	CopyMem (
287	&TcpServiceData->ServiceBinding,
288	&gTcpServiceBinding,
289	sizeof (EFI_SERVICE_BINDING_PROTOCOL)
290	);
291
292	TcpServiceData->IpIo = IpIoCreate (Image, Controller, IpVersion);
293	if (TcpServiceData->IpIo == NULL) {
294	Status = EFI_OUT_OF_RESOURCES;
295	goto ON_ERROR;
296	}
297
298
299	InitializeListHead (&TcpServiceData->SocketList);
300	ZeroMem (&OpenData, sizeof (IP_IO_OPEN_DATA));
301
302	if (IpVersion == IP_VERSION_4) {
303	CopyMem (
304	&OpenData.IpConfigData.Ip4CfgData,
305	&mIp4IoDefaultIpConfigData,
306	sizeof (EFI_IP4_CONFIG_DATA)
307	);
308	OpenData.IpConfigData.Ip4CfgData.DefaultProtocol = EFI_IP_PROTO_TCP;
309	} else {
310	CopyMem (
311	&OpenData.IpConfigData.Ip6CfgData,
312	&mIp6IoDefaultIpConfigData,
313	sizeof (EFI_IP6_CONFIG_DATA)
314	);
315	OpenData.IpConfigData.Ip6CfgData.DefaultProtocol = EFI_IP_PROTO_TCP;
316	}
317
318	OpenData.PktRcvdNotify = TcpRxCallback;
319	Status = IpIoOpen (TcpServiceData->IpIo, &OpenData);
320	if (EFI_ERROR (Status)) {
321	goto ON_ERROR;
322	}
323
324	Status = TcpCreateTimer ();
325	if (EFI_ERROR (Status)) {
326	goto ON_ERROR;
327	}
328
329	Status = gBS->InstallMultipleProtocolInterfaces (
330	&Controller,
331	TcpServiceBindingGuid,
332	&TcpServiceData->ServiceBinding,
333	NULL
334	);
335	if (EFI_ERROR (Status)) {
336	TcpDestroyTimer ();
337
338	goto ON_ERROR;
339	}
340
341	return EFI_SUCCESS;
342
343	ON_ERROR:
344
345	if (TcpServiceData->IpIo != NULL) {
346	IpIoDestroy (TcpServiceData->IpIo);
347	TcpServiceData->IpIo = NULL;
348	}
349
350	FreePool (TcpServiceData);
351
352	return Status;
353	}
354
355	/**
356	Callback function which provided by user to remove one node in NetDestroyLinkList process.
357
358	@param[in] Entry The entry to be removed.
359	@param[in] Context Pointer to the callback context corresponds to the Context in NetDestroyLinkList.
360
361	@retval EFI_SUCCESS The entry has been removed successfully.
362	@retval Others Fail to remove the entry.
363
364	**/
365	EFI_STATUS
366	EFIAPI
367	TcpDestroyChildEntryInHandleBuffer (
368	IN LIST_ENTRY *Entry,
369	IN VOID *Context
370	)
371	{
372	SOCKET *Sock;
373	EFI_SERVICE_BINDING_PROTOCOL *ServiceBinding;
374	UINTN NumberOfChildren;
375	EFI_HANDLE *ChildHandleBuffer;
376
377	if (Entry == NULL \|\| Context == NULL) {
378	return EFI_INVALID_PARAMETER;
379	}
380
381	Sock = NET_LIST_USER_STRUCT_S (Entry, SOCKET, Link, SOCK_SIGNATURE);
382	ServiceBinding = ((TCP_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT *) Context)->ServiceBinding;
383	NumberOfChildren = ((TCP_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT *) Context)->NumberOfChildren;
384	ChildHandleBuffer = ((TCP_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT *) Context)->ChildHandleBuffer;
385
386	if (!NetIsInHandleBuffer (Sock->SockHandle, NumberOfChildren, ChildHandleBuffer)) {
387	return EFI_SUCCESS;
388	}
389
390	return ServiceBinding->DestroyChild (ServiceBinding, Sock->SockHandle);
391	}
392
393	/**
394	Destroy a TCP6 or TCP4 service binding instance. It will release all
395	the resources allocated by the instance.
396
397	@param[in] Controller Controller handle of device to bind driver to.
398	@param[in] ImageHandle The TCP driver's image handle.
399	@param[in] NumberOfChildren Number of Handles in ChildHandleBuffer. If number
400	of children is zero stop the entire bus driver.
401	@param[in] ChildHandleBuffer An array of child handles to be freed. May be NULL
402	if NumberOfChildren is 0.
403	@param[in] IpVersion IP_VERSION_4 or IP_VERSION_6
404
405	@retval EFI_SUCCESS The resources used by the instance were cleaned up.
406	@retval Others Failed to clean up some of the resources.
407
408	**/
409	EFI_STATUS
410	TcpDestroyService (
411	IN EFI_HANDLE Controller,
412	IN EFI_HANDLE ImageHandle,
413	IN UINTN NumberOfChildren,
414	IN EFI_HANDLE *ChildHandleBuffer, OPTIONAL
415	IN UINT8 IpVersion
416	)
417	{
418	EFI_HANDLE NicHandle;
419	EFI_GUID *IpProtocolGuid;
420	EFI_GUID *ServiceBindingGuid;
421	EFI_SERVICE_BINDING_PROTOCOL *ServiceBinding;
422	TCP_SERVICE_DATA *TcpServiceData;
423	EFI_STATUS Status;
424	LIST_ENTRY *List;
425	TCP_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT Context;
426
427	ASSERT ((IpVersion == IP_VERSION_4) \|\| (IpVersion == IP_VERSION_6));
428
429	if (IpVersion == IP_VERSION_4) {
430	IpProtocolGuid = &gEfiIp4ProtocolGuid;
431	ServiceBindingGuid = &gEfiTcp4ServiceBindingProtocolGuid;
432	} else {
433	IpProtocolGuid = &gEfiIp6ProtocolGuid;
434	ServiceBindingGuid = &gEfiTcp6ServiceBindingProtocolGuid;
435	}
436
437	NicHandle = NetLibGetNicHandle (Controller, IpProtocolGuid);
438	if (NicHandle == NULL) {
439	return EFI_SUCCESS;
440	}
441
442	Status = gBS->OpenProtocol (
443	NicHandle,
444	ServiceBindingGuid,
445	(VOID **) &ServiceBinding,
446	ImageHandle,
447	Controller,
448	EFI_OPEN_PROTOCOL_GET_PROTOCOL
449	);
450	if (EFI_ERROR (Status)) {
451	return EFI_DEVICE_ERROR;
452	}
453
454	TcpServiceData = TCP_SERVICE_FROM_THIS (ServiceBinding);
455
456	if (NumberOfChildren != 0) {
457	List = &TcpServiceData->SocketList;
458	Context.ServiceBinding = ServiceBinding;
459	Context.NumberOfChildren = NumberOfChildren;
460	Context.ChildHandleBuffer = ChildHandleBuffer;
461	Status = NetDestroyLinkList (
462	List,
463	TcpDestroyChildEntryInHandleBuffer,
464	&Context,
465	NULL
466	);
467	} else if (IsListEmpty (&TcpServiceData->SocketList)) {
468	//
469	// Uninstall TCP servicebinding protocol
470	//
471	gBS->UninstallMultipleProtocolInterfaces (
472	NicHandle,
473	ServiceBindingGuid,
474	ServiceBinding,
475	NULL
476	);
477
478	//
479	// Destroy the IpIO consumed by TCP driver
480	//
481	IpIoDestroy (TcpServiceData->IpIo);
482	TcpServiceData->IpIo = NULL;
483
484	//
485	// Destroy the heartbeat timer.
486	//
487	TcpDestroyTimer ();
488
489	//
490	// Release the TCP service data
491	//
492	FreePool (TcpServiceData);
493
494	Status = EFI_SUCCESS;
495	}
496
497	return Status;
498	}
499
500	/**
501	Test to see if this driver supports ControllerHandle.
502
503	@param[in] This Protocol instance pointer.
504	@param[in] ControllerHandle Handle of device to test.
505	@param[in] RemainingDevicePath Optional parameter use to pick a specific
506	child device to start.
507
508	@retval EFI_SUCCESS This driver supports this device.
509	@retval EFI_ALREADY_STARTED This driver is already running on this device.
510	@retval other This driver does not support this device.
511
512	**/
513	EFI_STATUS
514	EFIAPI
515	Tcp4DriverBindingSupported (
516	IN EFI_DRIVER_BINDING_PROTOCOL *This,
517	IN EFI_HANDLE ControllerHandle,
518	IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL
519	)
520	{
521	EFI_STATUS Status;
522
523	//
524	// Test for the Tcp4ServiceBinding Protocol
525	//
526	Status = gBS->OpenProtocol (
527	ControllerHandle,
528	&gEfiTcp4ServiceBindingProtocolGuid,
529	NULL,
530	This->DriverBindingHandle,
531	ControllerHandle,
532	EFI_OPEN_PROTOCOL_TEST_PROTOCOL
533	);
534	if (!EFI_ERROR (Status)) {
535	return EFI_ALREADY_STARTED;
536	}
537
538	//
539	// Test for the Ip4ServiceBinding Protocol
540	//
541	Status = gBS->OpenProtocol (
542	ControllerHandle,
543	&gEfiIp4ServiceBindingProtocolGuid,
544	NULL,
545	This->DriverBindingHandle,
546	ControllerHandle,
547	EFI_OPEN_PROTOCOL_TEST_PROTOCOL
548	);
549	return Status;
550	}
551
552	/**
553	Start this driver on ControllerHandle.
554
555	@param[in] This Protocol instance pointer.
556	@param[in] ControllerHandle Handle of device to bind driver to.
557	@param[in] RemainingDevicePath Optional parameter use to pick a specific child
558	device to start.
559
560	@retval EFI_SUCCESS The driver is added to ControllerHandle.
561	@retval EFI_OUT_OF_RESOURCES There are not enough resources to start the
562	driver.
563	@retval other The driver cannot be added to ControllerHandle.
564
565	**/
566	EFI_STATUS
567	EFIAPI
568	Tcp4DriverBindingStart (
569	IN EFI_DRIVER_BINDING_PROTOCOL *This,
570	IN EFI_HANDLE ControllerHandle,
571	IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL
572	)
573	{
574	EFI_STATUS Status;
575
576	Status = TcpCreateService (ControllerHandle, This->DriverBindingHandle, IP_VERSION_4);
577	if ((Status == EFI_ALREADY_STARTED) \|\| (Status == EFI_UNSUPPORTED)) {
578	Status = EFI_SUCCESS;
579	}
580
581	return Status;
582	}
583
584	/**
585	Stop this driver on ControllerHandle.
586
587	@param[in] This A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
588	@param[in] ControllerHandle A handle to the device being stopped. The handle must
589	support a bus specific I/O protocol for the driver
590	to use to stop the device.
591	@param[in] NumberOfChildren The number of child device handles in ChildHandleBuffer.
592	@param[in] ChildHandleBuffer An array of child handles to be freed. May be NULL
593	if NumberOfChildren is 0.
594
595	@retval EFI_SUCCESS The device was stopped.
596	@retval EFI_DEVICE_ERROR The device could not be stopped due to a device error.
597
598	**/
599	EFI_STATUS
600	EFIAPI
601	Tcp4DriverBindingStop (
602	IN EFI_DRIVER_BINDING_PROTOCOL *This,
603	IN EFI_HANDLE ControllerHandle,
604	IN UINTN NumberOfChildren,
605	IN EFI_HANDLE *ChildHandleBuffer OPTIONAL
606	)
607	{
608	return TcpDestroyService (
609	ControllerHandle,
610	This->DriverBindingHandle,
611	NumberOfChildren,
612	ChildHandleBuffer,
613	IP_VERSION_4
614	);
615	}
616
617	/**
618	Test to see if this driver supports ControllerHandle.
619
620	@param[in] This Protocol instance pointer.
621	@param[in] ControllerHandle Handle of device to test.
622	@param[in] RemainingDevicePath Optional parameter use to pick a specific
623	child device to start.
624
625	@retval EFI_SUCCESS This driver supports this device.
626	@retval EFI_ALREADY_STARTED This driver is already running on this device.
627	@retval other This driver does not support this device.
628
629	**/
630	EFI_STATUS
631	EFIAPI
632	Tcp6DriverBindingSupported (
633	IN EFI_DRIVER_BINDING_PROTOCOL *This,
634	IN EFI_HANDLE ControllerHandle,
635	IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL
636	)
637	{
638	EFI_STATUS Status;
639
640	//
641	// Test for the Tcp6ServiceBinding Protocol
642	//
643	Status = gBS->OpenProtocol (
644	ControllerHandle,
645	&gEfiTcp6ServiceBindingProtocolGuid,
646	NULL,
647	This->DriverBindingHandle,
648	ControllerHandle,
649	EFI_OPEN_PROTOCOL_TEST_PROTOCOL
650	);
651	if (!EFI_ERROR (Status)) {
652	return EFI_ALREADY_STARTED;
653	}
654
655	//
656	// Test for the Ip6ServiceBinding Protocol
657	//
658	Status = gBS->OpenProtocol (
659	ControllerHandle,
660	&gEfiIp6ServiceBindingProtocolGuid,
661	NULL,
662	This->DriverBindingHandle,
663	ControllerHandle,
664	EFI_OPEN_PROTOCOL_TEST_PROTOCOL
665	);
666	return Status;
667	}
668
669	/**
670	Start this driver on ControllerHandle.
671
672	@param[in] This Protocol instance pointer.
673	@param[in] ControllerHandle Handle of device to bind driver to.
674	@param[in] RemainingDevicePath Optional parameter use to pick a specific child
675	device to start.
676
677	@retval EFI_SUCCESS The driver is added to ControllerHandle.
678	@retval EFI_OUT_OF_RESOURCES There are not enough resources to start the
679	driver.
680	@retval other The driver cannot be added to ControllerHandle.
681
682	**/
683	EFI_STATUS
684	EFIAPI
685	Tcp6DriverBindingStart (
686	IN EFI_DRIVER_BINDING_PROTOCOL *This,
687	IN EFI_HANDLE ControllerHandle,
688	IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL
689	)
690	{
691	EFI_STATUS Status;
692
693	Status = TcpCreateService (ControllerHandle, This->DriverBindingHandle, IP_VERSION_6);
694	if ((Status == EFI_ALREADY_STARTED) \|\| (Status == EFI_UNSUPPORTED)) {
695	Status = EFI_SUCCESS;
696	}
697
698	return Status;
699	}
700
701	/**
702	Stop this driver on ControllerHandle.
703
704	@param[in] This A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
705	@param[in] ControllerHandle A handle to the device being stopped. The handle must
706	support a bus specific I/O protocol for the driver
707	to use to stop the device.
708	@param[in] NumberOfChildren The number of child device handles in ChildHandleBuffer.
709	@param[in] ChildHandleBuffer An array of child handles to be freed. May be NULL
710	if NumberOfChildren is 0.
711
712	@retval EFI_SUCCESS The device was stopped.
713	@retval EFI_DEVICE_ERROR The device could not be stopped due to a device error.
714
715	**/
716	EFI_STATUS
717	EFIAPI
718	Tcp6DriverBindingStop (
719	IN EFI_DRIVER_BINDING_PROTOCOL *This,
720	IN EFI_HANDLE ControllerHandle,
721	IN UINTN NumberOfChildren,
722	IN EFI_HANDLE *ChildHandleBuffer OPTIONAL
723	)
724	{
725	return TcpDestroyService (
726	ControllerHandle,
727	This->DriverBindingHandle,
728	NumberOfChildren,
729	ChildHandleBuffer,
730	IP_VERSION_6
731	);
732	}
733
734	/**
735	The Callback funtion called after the TCP socket was created.
736
737	@param[in] This Pointer to the socket just created
738	@param[in] Context Context of the socket
739
740	@retval EFI_SUCCESS This protocol installed successfully.
741	@retval other An error occured.
742
743	**/
744	EFI_STATUS
745	TcpCreateSocketCallback (
746	IN SOCKET *This,
747	IN VOID *Context
748	)
749	{
750	EFI_STATUS Status;
751	TCP_SERVICE_DATA *TcpServiceData;
752	EFI_GUID *IpProtocolGuid;
753	VOID *Ip;
754
755	if (This->IpVersion == IP_VERSION_4) {
756	IpProtocolGuid = &gEfiIp4ProtocolGuid;
757	} else {
758	IpProtocolGuid = &gEfiIp6ProtocolGuid;
759	}
760
761	TcpServiceData = ((TCP_PROTO_DATA *) This->ProtoReserved)->TcpService;
762
763	//
764	// Open the default IP protocol of IP_IO BY_DRIVER.
765	//
766	Status = gBS->OpenProtocol (
767	TcpServiceData->IpIo->ChildHandle,
768	IpProtocolGuid,
769	&Ip,
770	TcpServiceData->DriverBindingHandle,
771	This->SockHandle,
772	EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
773	);
774	if (EFI_ERROR (Status)) {
775	return Status;
776	}
777
778	//
779	// Open the device path on the handle where service binding resides on.
780	//
781	Status = gBS->OpenProtocol (
782	TcpServiceData->ControllerHandle,
783	&gEfiDevicePathProtocolGuid,
784	(VOID **) &This->ParentDevicePath,
785	TcpServiceData->DriverBindingHandle,
786	This->SockHandle,
787	EFI_OPEN_PROTOCOL_GET_PROTOCOL
788	);
789	if (EFI_ERROR (Status)) {
790	gBS->CloseProtocol (
791	TcpServiceData->IpIo->ChildHandle,
792	IpProtocolGuid,
793	TcpServiceData->DriverBindingHandle,
794	This->SockHandle
795	);
796	} else {
797	//
798	// Insert this socket into the SocketList.
799	//
800	InsertTailList (&TcpServiceData->SocketList, &This->Link);
801	}
802
803	return Status;
804	}
805
806	/**
807	The callback function called before the TCP socket was to be destroyed.
808
809	@param[in] This The TCP socket to be destroyed.
810	@param[in] Context The context of the socket.
811
812	**/
813	VOID
814	TcpDestroySocketCallback (
815	IN SOCKET *This,
816	IN VOID *Context
817	)
818	{
819	TCP_SERVICE_DATA *TcpServiceData;
820	EFI_GUID *IpProtocolGuid;
821
822	if (This->IpVersion == IP_VERSION_4) {
823	IpProtocolGuid = &gEfiIp4ProtocolGuid;
824	} else {
825	IpProtocolGuid = &gEfiIp6ProtocolGuid;
826	}
827
828	TcpServiceData = ((TCP_PROTO_DATA *) This->ProtoReserved)->TcpService;
829
830	//
831	// Remove this node from the list.
832	//
833	RemoveEntryList (&This->Link);
834
835	//
836	// Close the IP protocol.
837	//
838	gBS->CloseProtocol (
839	TcpServiceData->IpIo->ChildHandle,
840	IpProtocolGuid,
841	TcpServiceData->DriverBindingHandle,
842	This->SockHandle
843	);
844	}
845
846	/**
847	Creates a child handle with a set of TCP services.
848
849	The CreateChild() function installs a protocol on ChildHandle.
850	If ChildHandle is a pointer to NULL, then a new handle is created and returned in ChildHandle.
851	If ChildHandle is not a pointer to NULL, then the protocol installs on the existing ChildHandle.
852
853	@param[in] This Pointer to the EFI_SERVICE_BINDING_PROTOCOL instance.
854	@param[in, out] ChildHandle Pointer to the handle of the child to create.
855	If it is NULL, then a new handle is created.
856	If it is a pointer to an existing UEFI handle,
857	then the protocol is added to the existing UEFI handle.
858
859	@retval EFI_SUCCES The protocol was added to ChildHandle.
860	@retval EFI_INVALID_PARAMETER ChildHandle is NULL.
861	@retval EFI_OUT_OF_RESOURCES There are not enough resources available to create
862	the child.
863	@retval other The child handle was not created.
864
865	**/
866	EFI_STATUS
867	EFIAPI
868	TcpServiceBindingCreateChild (
869	IN EFI_SERVICE_BINDING_PROTOCOL *This,
870	IN OUT EFI_HANDLE *ChildHandle
871	)
872	{
873	SOCKET *Sock;
874	TCP_SERVICE_DATA *TcpServiceData;
875	TCP_PROTO_DATA TcpProto;
876	EFI_STATUS Status;
877	EFI_TPL OldTpl;
878
879	if (NULL == This \|\| NULL == ChildHandle) {
880	return EFI_INVALID_PARAMETER;
881	}
882
883	OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
884
885	Status = EFI_SUCCESS;
886	TcpServiceData = TCP_SERVICE_FROM_THIS (This);
887	TcpProto.TcpService = TcpServiceData;
888	TcpProto.TcpPcb = NULL;
889
890	//
891	// Create a tcp instance with defualt Tcp default
892	// sock init data and TcpProto
893	//
894	mTcpDefaultSockData.ProtoData = &TcpProto;
895	mTcpDefaultSockData.DataSize = sizeof (TCP_PROTO_DATA);
896	mTcpDefaultSockData.DriverBinding = TcpServiceData->DriverBindingHandle;
897	mTcpDefaultSockData.IpVersion = TcpServiceData->IpVersion;
898
899	if (TcpServiceData->IpVersion == IP_VERSION_4) {
900	mTcpDefaultSockData.Protocol = &gTcp4ProtocolTemplate;
901	} else {
902	mTcpDefaultSockData.Protocol = &gTcp6ProtocolTemplate;
903	}
904
905	Sock = SockCreateChild (&mTcpDefaultSockData);
906	if (NULL == Sock) {
907	DEBUG (
908	(EFI_D_ERROR,
909	"TcpDriverBindingCreateChild: No resource to create a Tcp Child\n")
910	);
911
912	Status = EFI_OUT_OF_RESOURCES;
913	} else {
914	*ChildHandle = Sock->SockHandle;
915	}
916
917	mTcpDefaultSockData.ProtoData = NULL;
918
919	gBS->RestoreTPL (OldTpl);
920	return Status;
921	}
922
923	/**
924	Destroys a child handle with a set of TCP services.
925
926	The DestroyChild() function does the opposite of CreateChild(). It removes a protocol
927	that was installed by CreateChild() from ChildHandle. If the removed protocol is the
928	last protocol on ChildHandle, then ChildHandle is destroyed.
929
930	@param This Pointer to the EFI_SERVICE_BINDING_PROTOCOL instance.
931	@param ChildHandle Handle of the child to be destroyed.
932
933	@retval EFI_SUCCES The protocol was removed from ChildHandle.
934	@retval EFI_UNSUPPORTED ChildHandle does not support the protocol that is being removed.
935	@retval EFI_INVALID_PARAMETER Child handle is NULL.
936	@retval EFI_ACCESS_DENIED The protocol could not be removed from the ChildHandle
937	because its services are being used.
938	@retval other The child handle was not destroyed.
939
940	**/
941	EFI_STATUS
942	EFIAPI
943	TcpServiceBindingDestroyChild (
944	IN EFI_SERVICE_BINDING_PROTOCOL *This,
945	IN EFI_HANDLE ChildHandle
946	)
947	{
948	EFI_STATUS Status;
949	VOID *Tcp;
950	SOCKET *Sock;
951
952	if (NULL == This \|\| NULL == ChildHandle) {
953	return EFI_INVALID_PARAMETER;
954	}
955
956	//
957	// retrieve the Tcp4 protocol from ChildHandle
958	//
959	Status = gBS->OpenProtocol (
960	ChildHandle,
961	&gEfiTcp4ProtocolGuid,
962	&Tcp,
963	gTcp4DriverBinding.DriverBindingHandle,
964	ChildHandle,
965	EFI_OPEN_PROTOCOL_GET_PROTOCOL
966	);
967	if (EFI_ERROR (Status)) {
968	//
969	// No Tcp4, try the Tcp6 protocol
970	//
971	Status = gBS->OpenProtocol (
972	ChildHandle,
973	&gEfiTcp6ProtocolGuid,
974	&Tcp,
975	gTcp6DriverBinding.DriverBindingHandle,
976	ChildHandle,
977	EFI_OPEN_PROTOCOL_GET_PROTOCOL
978	);
979	if (EFI_ERROR (Status)) {
980	Status = EFI_UNSUPPORTED;
981	}
982	}
983
984	if (!EFI_ERROR (Status)) {
985	//
986	// destroy this sock and related Tcp protocol control
987	// block
988	//
989	Sock = SOCK_FROM_THIS (Tcp);
990
991	SockDestroyChild (Sock);
992	}
993
994	return Status;
995	}

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

source: vbox/trunk/src/VBox/Devices/EFI/FirmwareNew/NetworkPkg/TcpDxe/TcpDriver.c@ 80721

Download in other formats: