Mtftp6Rrq.c@ 48674

最後變更在這個檔案從48674是 48674,由 vboxsync 提交於 11 年前
EFI: Export newly imported tinaocore UEFI sources to OSE.
屬性 svn:eol-style 設為 `native`
檔案大小: 25.0 KB

行
1	/** @file
2	Mtftp6 Rrq process functions implementation.
3
4	Copyright (c) 2009 - 2012, Intel Corporation. All rights reserved.<BR>
5
6	This program and the accompanying materials
7	are licensed and made available under the terms and conditions of the BSD License
8	which accompanies this distribution. The full text of the license may be found at
9	http://opensource.org/licenses/bsd-license.php.
10
11	THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
12	WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
13
14	**/
15
16	#include "Mtftp6Impl.h"
17
18
19	/**
20	Build and send a ACK packet for download.
21
22	@param[in] Instance The pointer to the Mtftp6 instance.
23	@param[in] BlockNum The block number to be acked.
24
25	@retval EFI_OUT_OF_RESOURCES Failed to allocate memory for the packet.
26	@retval EFI_SUCCESS The ACK has been sent.
27	@retval Others Failed to send the ACK.
28
29	**/
30	EFI_STATUS
31	Mtftp6RrqSendAck (
32	IN MTFTP6_INSTANCE *Instance,
33	IN UINT16 BlockNum
34	)
35	{
36	EFI_MTFTP6_PACKET *Ack;
37	NET_BUF *Packet;
38
39	//
40	// Allocate net buffer to create ack packet.
41	//
42	Packet = NetbufAlloc (sizeof (EFI_MTFTP6_ACK_HEADER));
43
44	if (Packet == NULL) {
45	return EFI_OUT_OF_RESOURCES;
46	}
47
48	Ack = (EFI_MTFTP6_PACKET *) NetbufAllocSpace (
49	Packet,
50	sizeof (EFI_MTFTP6_ACK_HEADER),
51	FALSE
52	);
53	ASSERT (Ack != NULL);
54
55	Ack->Ack.OpCode = HTONS (EFI_MTFTP6_OPCODE_ACK);
56	Ack->Ack.Block[0] = HTONS (BlockNum);
57
58	//
59	// Reset current retry count of the instance.
60	//
61	Instance->CurRetry = 0;
62
63	return Mtftp6TransmitPacket (Instance, Packet);
64	}
65
66
67	/**
68	Deliver the received data block to the user, which can be saved
69	in the user provide buffer or through the CheckPacket callback.
70
71	@param[in] Instance The pointer to the Mtftp6 instance.
72	@param[in] Packet The pointer to the received packet.
73	@param[in] Len The packet length.
74	@param[out] UdpPacket The net buf of the received packet.
75
76	@retval EFI_SUCCESS The data was saved successfully.
77	@retval EFI_ABORTED The user tells to abort by return an error through
78	CheckPacket.
79	@retval EFI_BUFFER_TOO_SMALL The user's buffer is too small, and buffer length is
80	updated to the actual buffer size needed.
81
82	**/
83	EFI_STATUS
84	Mtftp6RrqSaveBlock (
85	IN MTFTP6_INSTANCE *Instance,
86	IN EFI_MTFTP6_PACKET *Packet,
87	IN UINT32 Len,
88	OUT NET_BUF **UdpPacket
89	)
90	{
91	EFI_MTFTP6_TOKEN *Token;
92	EFI_STATUS Status;
93	UINT16 Block;
94	UINT64 Start;
95	UINT32 DataLen;
96	UINT64 TotalBlock;
97	BOOLEAN Completed;
98
99	Completed = FALSE;
100	Token = Instance->Token;
101	Block = NTOHS (Packet->Data.Block);
102	DataLen = Len - MTFTP6_DATA_HEAD_LEN;
103
104	//
105	// This is the last block, save the block num
106	//
107	if (DataLen < Instance->BlkSize) {
108	Completed = TRUE;
109	Instance->LastBlk = Block;
110	Mtftp6SetLastBlockNum (&Instance->BlkList, Block);
111	}
112
113	//
114	// Remove this block number from the file hole. If Mtftp6RemoveBlockNum
115	// returns EFI_NOT_FOUND, the block has been saved, don't save it again.
116	// Note that : For bigger files, allowing the block counter to roll over
117	// to accept transfers of unlimited size. So TotalBlock is memorised as
118	// continuous block counter.
119	//
120	Status = Mtftp6RemoveBlockNum (&Instance->BlkList, Block, Completed, &TotalBlock);
121
122	if (Status == EFI_NOT_FOUND) {
123	return EFI_SUCCESS;
124	} else if (EFI_ERROR (Status)) {
125	return Status;
126	}
127
128	if (Token->CheckPacket != NULL) {
129	//
130	// Callback to the check packet routine with the received packet.
131	//
132	Status = Token->CheckPacket (&Instance->Mtftp6, Token, (UINT16) Len, Packet);
133
134	if (EFI_ERROR (Status)) {
135	//
136	// Free the received packet before send new packet in ReceiveNotify,
137	// since the Udp6Io might need to be reconfigured.
138	//
139	NetbufFree (*UdpPacket);
140	*UdpPacket = NULL;
141	//
142	// Send the Mtftp6 error message if user aborted the current session.
143	//
144	Mtftp6SendError (
145	Instance,
146	EFI_MTFTP6_ERRORCODE_ILLEGAL_OPERATION,
147	(UINT8 *) "User aborted download"
148	);
149
150	return EFI_ABORTED;
151	}
152	}
153
154	if (Token->Buffer != NULL) {
155
156	Start = MultU64x32 (TotalBlock - 1, Instance->BlkSize);
157	if (Start + DataLen <= Token->BufferSize) {
158	CopyMem ((UINT8 *) Token->Buffer + Start, Packet->Data.Data, DataLen);
159	//
160	// Update the file size when received the last block
161	//
162	if ((Instance->LastBlk == Block) && Completed) {
163	Token->BufferSize = Start + DataLen;
164	}
165	} else if (Instance->LastBlk != 0) {
166	//
167	// Don't save the data if the buffer is too small, return
168	// EFI_BUFFER_TOO_SMALL if received the last packet. This
169	// will give a accurate file length.
170	//
171	Token->BufferSize = Start + DataLen;
172
173	//
174	// Free the received packet before send new packet in ReceiveNotify,
175	// since the udpio might need to be reconfigured.
176	//
177	NetbufFree (*UdpPacket);
178	*UdpPacket = NULL;
179	//
180	// Send the Mtftp6 error message if no enough buffer.
181	//
182	Mtftp6SendError (
183	Instance,
184	EFI_MTFTP6_ERRORCODE_DISK_FULL,
185	(UINT8 *) "User provided memory block is too small"
186	);
187
188	return EFI_BUFFER_TOO_SMALL;
189	}
190	}
191
192	return EFI_SUCCESS;
193	}
194
195
196	/**
197	Process the received data packets. It will save the block
198	then send back an ACK if it is active.
199
200	@param[in] Instance The pointer to the Mtftp6 instance.
201	@param[in] Packet The pointer to the received packet.
202	@param[in] Len The length of the packet.
203	@param[out] UdpPacket The net buf of received packet.
204	@param[out] IsCompleted If TRUE, the download has been completed.
205	Otherwise, the download has not been completed.
206
207	@retval EFI_SUCCESS The data packet was successfully processed.
208	@retval EFI_ABORTED The download was aborted by the user.
209	@retval EFI_BUFFER_TOO_SMALL The user-provided buffer is too small.
210
211	**/
212	EFI_STATUS
213	Mtftp6RrqHandleData (
214	IN MTFTP6_INSTANCE *Instance,
215	IN EFI_MTFTP6_PACKET *Packet,
216	IN UINT32 Len,
217	OUT NET_BUF **UdpPacket,
218	OUT BOOLEAN *IsCompleted
219	)
220	{
221	EFI_STATUS Status;
222	UINT16 BlockNum;
223	INTN Expected;
224
225	*IsCompleted = FALSE;
226	BlockNum = NTOHS (Packet->Data.Block);
227	Expected = Mtftp6GetNextBlockNum (&Instance->BlkList);
228
229	ASSERT (Expected >= 0);
230
231	//
232	// If we are active and received an unexpected packet, retransmit
233	// the last ACK then restart receiving. If we are passive, save
234	// the block.
235	//
236	if (Instance->IsMaster && (Expected != BlockNum)) {
237	//
238	// Free the received packet before send new packet in ReceiveNotify,
239	// since the udpio might need to be reconfigured.
240	//
241	NetbufFree (*UdpPacket);
242	*UdpPacket = NULL;
243
244	Mtftp6TransmitPacket (Instance, Instance->LastPacket);
245	return EFI_SUCCESS;
246	}
247
248	Status = Mtftp6RrqSaveBlock (Instance, Packet, Len, UdpPacket);
249
250	if (EFI_ERROR (Status)) {
251	return Status;
252	}
253
254	//
255	// Reset the passive client's timer whenever it received a valid data packet.
256	//
257	if (!Instance->IsMaster) {
258	Instance->PacketToLive = Instance->Timeout * 2;
259	}
260
261	//
262	// Check whether we have received all the blocks. Send the ACK if we
263	// are active (unicast client or master client for multicast download).
264	// If we have received all the blocks, send an ACK even if we are passive
265	// to tell the server that we are done.
266	//
267	Expected = Mtftp6GetNextBlockNum (&Instance->BlkList);
268
269	if (Instance->IsMaster \|\| Expected < 0) {
270	if (Expected < 0) {
271	//
272	// If we are passive client, then the just received Block maybe
273	// isn't the last block. We need to send an ACK to the last block
274	// to inform the server that we are done. If we are active client,
275	// the Block == Instance->LastBlock.
276	//
277	BlockNum = Instance->LastBlk;
278	*IsCompleted = TRUE;
279
280	} else {
281	BlockNum = (UINT16) (Expected - 1);
282	}
283	//
284	// Free the received packet before send new packet in ReceiveNotify,
285	// since the udpio might need to be reconfigured.
286	//
287	NetbufFree (*UdpPacket);
288	*UdpPacket = NULL;
289
290	Mtftp6RrqSendAck (Instance, BlockNum);
291	}
292
293	return EFI_SUCCESS;
294	}
295
296
297	/**
298	Validate whether the options received in the server's OACK packet is valid.
299	The options are valid only if:
300	1. The server doesn't include options not requested by us.
301	2. The server can only use smaller blksize than that is requested.
302	3. The server can only use the same timeout as requested.
303	4. The server doesn't change its multicast channel.
304
305	@param[in] Instance The pointer to the Mtftp6 instance.
306	@param[in] ReplyInfo The pointer to options information in reply packet.
307	@param[in] RequestInfo The pointer to requested options info.
308
309	@retval TRUE If the option in the OACK is valid.
310	@retval FALSE If the option is invalid.
311
312	**/
313	BOOLEAN
314	Mtftp6RrqOackValid (
315	IN MTFTP6_INSTANCE *Instance,
316	IN MTFTP6_EXT_OPTION_INFO *ReplyInfo,
317	IN MTFTP6_EXT_OPTION_INFO *RequestInfo
318	)
319	{
320	//
321	// It is invalid for server to return options we don't request
322	//
323	if ((ReplyInfo->BitMap & ~RequestInfo->BitMap) != 0) {
324	return FALSE;
325	}
326
327	//
328	// Server can only specify a smaller block size to be used and
329	// return the timeout matches that requested.
330	//
331	if ((((ReplyInfo->BitMap & MTFTP6_OPT_BLKSIZE_BIT) != 0) && (ReplyInfo->BlkSize > RequestInfo->BlkSize)) \|\|
332	(((ReplyInfo->BitMap & MTFTP6_OPT_TIMEOUT_BIT) != 0) && (ReplyInfo->Timeout != RequestInfo->Timeout))
333	) {
334	return FALSE;
335	}
336
337	//
338	// The server can send ",,master" to client to change its master
339	// setting. But if it use the specific multicast channel, it can't
340	// change the setting.
341	//
342	if (((ReplyInfo->BitMap & MTFTP6_OPT_MCAST_BIT) != 0) && !NetIp6IsUnspecifiedAddr (&Instance->McastIp)) {
343
344	if (!NetIp6IsUnspecifiedAddr (&ReplyInfo->McastIp) && CompareMem (
345	&ReplyInfo->McastIp,
346	&Instance->McastIp,
347	sizeof (EFI_IPv6_ADDRESS)
348	) != 0) {
349	return FALSE;
350	}
351
352	if ((ReplyInfo->McastPort != 0) && (ReplyInfo->McastPort != Instance->McastPort)) {
353	return FALSE;
354	}
355	}
356
357	return TRUE;
358	}
359
360
361	/**
362	Configure Udp6Io to receive a packet from a multicast address.
363
364	@param[in] McastIo The pointer to the mcast Udp6Io.
365	@param[in] Context The pointer to the context.
366
367	@retval EFI_SUCCESS The mcast Udp6Io was successfully configured.
368	@retval Others Failed to configure the Udp6Io.
369
370	**/
371	EFI_STATUS
372	EFIAPI
373	Mtftp6RrqConfigMcastUdpIo (
374	IN UDP_IO *McastIo,
375	IN VOID *Context
376	)
377	{
378	EFI_STATUS Status;
379	EFI_UDP6_PROTOCOL *Udp6;
380	EFI_UDP6_CONFIG_DATA *Udp6Cfg;
381	EFI_IPv6_ADDRESS Group;
382	MTFTP6_INSTANCE *Instance;
383
384	Udp6 = McastIo->Protocol.Udp6;
385	Udp6Cfg = &(McastIo->Config.Udp6);
386	Instance = (MTFTP6_INSTANCE *) Context;
387
388	//
389	// Set the configure data for the mcast Udp6Io.
390	//
391	ZeroMem (Udp6Cfg, sizeof (EFI_UDP6_CONFIG_DATA));
392
393	Udp6Cfg->AcceptPromiscuous = FALSE;
394	Udp6Cfg->AcceptAnyPort = FALSE;
395	Udp6Cfg->AllowDuplicatePort = FALSE;
396	Udp6Cfg->TrafficClass = 0;
397	Udp6Cfg->HopLimit = 128;
398	Udp6Cfg->ReceiveTimeout = 0;
399	Udp6Cfg->TransmitTimeout = 0;
400	Udp6Cfg->StationPort = Instance->McastPort;
401	Udp6Cfg->RemotePort = 0;
402
403	CopyMem (
404	&Udp6Cfg->RemoteAddress,
405	&Instance->ServerIp,
406	sizeof (EFI_IPv6_ADDRESS)
407	);
408
409	//
410	// Configure the mcast Udp6Io.
411	//
412	Status = Udp6->Configure (Udp6, Udp6Cfg);
413
414	if (EFI_ERROR (Status)) {
415	return Status;
416	}
417
418	//
419	// Join the multicast group
420	//
421	CopyMem (&Group, &Instance->McastIp, sizeof (EFI_IPv6_ADDRESS));
422
423	return Udp6->Groups (Udp6, TRUE, &Group);
424	}
425
426
427	/**
428	Process the OACK packet for Rrq.
429
430	@param[in] Instance The pointer to the Mtftp6 instance.
431	@param[in] Packet The pointer to the received packet.
432	@param[in] Len The length of the packet.
433	@param[out] UdpPacket The net buf of received packet.
434	@param[out] IsCompleted If TRUE, the download has been completed.
435	Otherwise, the download has not been completed.
436
437	@retval EFI_DEVICE_ERROR Failed to create/start a multicast Udp6 child.
438	@retval EFI_TFTP_ERROR An error happened during the process.
439	@retval EFI_SUCCESS The OACK packet successfully processed.
440
441	**/
442	EFI_STATUS
443	Mtftp6RrqHandleOack (
444	IN MTFTP6_INSTANCE *Instance,
445	IN EFI_MTFTP6_PACKET *Packet,
446	IN UINT32 Len,
447	OUT NET_BUF **UdpPacket,
448	OUT BOOLEAN *IsCompleted
449	)
450	{
451	EFI_MTFTP6_OPTION *Options;
452	UINT32 Count;
453	MTFTP6_EXT_OPTION_INFO ExtInfo;
454	EFI_STATUS Status;
455	INTN Expected;
456
457	*IsCompleted = FALSE;
458
459	//
460	// If already started the master download, don't change the
461	// setting. Master download always succeeds.
462	//
463	Expected = Mtftp6GetNextBlockNum (&Instance->BlkList);
464	ASSERT (Expected != -1);
465
466	if (Instance->IsMaster && Expected != 1) {
467	return EFI_SUCCESS;
468	}
469
470	ZeroMem (&ExtInfo, sizeof (MTFTP6_EXT_OPTION_INFO));
471
472	//
473	// Parse the options in the packet.
474	//
475	Status = Mtftp6ParseStart (Packet, Len, &Count, &Options);
476
477	if (EFI_ERROR (Status)) {
478	return Status;
479	}
480	ASSERT (Options != NULL);
481
482	//
483	// Parse the extensive options in the packet.
484	//
485	Status = Mtftp6ParseExtensionOption (Options, Count, FALSE, &ExtInfo);
486
487	if (EFI_ERROR (Status) \|\| !Mtftp6RrqOackValid (Instance, &ExtInfo, &Instance->ExtInfo)) {
488	//
489	// Don't send an ERROR packet if the error is EFI_OUT_OF_RESOURCES.
490	//
491	if (Status != EFI_OUT_OF_RESOURCES) {
492	//
493	// Free the received packet before send new packet in ReceiveNotify,
494	// since the udpio might need to be reconfigured.
495	//
496	NetbufFree (*UdpPacket);
497	*UdpPacket = NULL;
498	//
499	// Send the Mtftp6 error message if invalid packet.
500	//
501	Mtftp6SendError (
502	Instance,
503	EFI_MTFTP6_ERRORCODE_ILLEGAL_OPERATION,
504	(UINT8 *) "Mal-formated OACK packet"
505	);
506	}
507
508	return EFI_TFTP_ERROR;
509	}
510
511	if ((ExtInfo.BitMap & MTFTP6_OPT_MCAST_BIT) != 0) {
512
513	//
514	// Save the multicast info. Always update the Master, only update the
515	// multicast IP address, block size, timeoute at the first time. If IP
516	// address is updated, create a UDP child to receive the multicast.
517	//
518	Instance->IsMaster = ExtInfo.IsMaster;
519
520	if (NetIp6IsUnspecifiedAddr (&Instance->McastIp)) {
521	if (NetIp6IsUnspecifiedAddr (&ExtInfo.McastIp) \|\| ExtInfo.McastPort == 0) {
522	//
523	// Free the received packet before send new packet in ReceiveNotify,
524	// since the udpio might need to be reconfigured.
525	//
526	NetbufFree (*UdpPacket);
527	*UdpPacket = NULL;
528	//
529	// Send the Mtftp6 error message if invalid multi-cast setting.
530	//
531	Mtftp6SendError (
532	Instance,
533	EFI_MTFTP6_ERRORCODE_ILLEGAL_OPERATION,
534	(UINT8 *) "Illegal multicast setting"
535	);
536
537	return EFI_TFTP_ERROR;
538	}
539
540	//
541	// Create a UDP child then start receive the multicast from it.
542	//
543	CopyMem (
544	&Instance->McastIp,
545	&ExtInfo.McastIp,
546	sizeof (EFI_IP_ADDRESS)
547	);
548
549	Instance->McastPort = ExtInfo.McastPort;
550	Instance->McastUdpIo = UdpIoCreateIo (
551	Instance->Service->Controller,
552	Instance->Service->Image,
553	Mtftp6RrqConfigMcastUdpIo,
554	UDP_IO_UDP6_VERSION,
555	Instance
556	);
557
558	if (Instance->McastUdpIo == NULL) {
559	return EFI_DEVICE_ERROR;
560	}
561
562	Status = UdpIoRecvDatagram (
563	Instance->McastUdpIo,
564	Mtftp6RrqInput,
565	Instance,
566	0
567	);
568
569	if (EFI_ERROR (Status)) {
570	//
571	// Free the received packet before send new packet in ReceiveNotify,
572	// since the udpio might need to be reconfigured.
573	//
574	NetbufFree (*UdpPacket);
575	*UdpPacket = NULL;
576	//
577	// Send the Mtftp6 error message if failed to create Udp6Io to receive.
578	//
579	Mtftp6SendError (
580	Instance,
581	EFI_MTFTP6_ERRORCODE_ACCESS_VIOLATION,
582	(UINT8 *) "Failed to create socket to receive multicast packet"
583	);
584
585	return Status;
586	}
587
588	//
589	// Update the parameters used.
590	//
591	if (ExtInfo.BlkSize != 0) {
592	Instance->BlkSize = ExtInfo.BlkSize;
593	}
594
595	if (ExtInfo.Timeout != 0) {
596	Instance->Timeout = ExtInfo.Timeout;
597	}
598	}
599
600	} else {
601
602	Instance->IsMaster = TRUE;
603
604	if (ExtInfo.BlkSize != 0) {
605	Instance->BlkSize = ExtInfo.BlkSize;
606	}
607
608	if (ExtInfo.Timeout != 0) {
609	Instance->Timeout = ExtInfo.Timeout;
610	}
611	}
612
613	//
614	// Free the received packet before send new packet in ReceiveNotify,
615	// since the udpio might need to be reconfigured.
616	//
617	NetbufFree (*UdpPacket);
618	*UdpPacket = NULL;
619	//
620	// Send an ACK to (Expected - 1) which is 0 for unicast download,
621	// or tell the server we want to receive the Expected block.
622	//
623	return Mtftp6RrqSendAck (Instance, (UINT16) (Expected - 1));
624	}
625
626
627	/**
628	The packet process callback for Mtftp6 download.
629
630	@param[in] UdpPacket The pointer to the packet received.
631	@param[in] UdpEpt The pointer to the Udp6 access point.
632	@param[in] IoStatus The status from Udp6 instance.
633	@param[in] Context The pointer to the context.
634
635	**/
636	VOID
637	EFIAPI
638	Mtftp6RrqInput (
639	IN NET_BUF *UdpPacket,
640	IN UDP_END_POINT *UdpEpt,
641	IN EFI_STATUS IoStatus,
642	IN VOID *Context
643	)
644	{
645	MTFTP6_INSTANCE *Instance;
646	EFI_MTFTP6_PACKET *Packet;
647	BOOLEAN IsCompleted;
648	BOOLEAN IsMcast;
649	EFI_STATUS Status;
650	UINT16 Opcode;
651	UINT32 TotalNum;
652	UINT32 Len;
653
654	Instance = (MTFTP6_INSTANCE *) Context;
655
656	NET_CHECK_SIGNATURE (Instance, MTFTP6_INSTANCE_SIGNATURE);
657
658	Status = EFI_SUCCESS;
659	Packet = NULL;
660	IsCompleted = FALSE;
661	IsMcast = FALSE;
662	TotalNum = 0;
663
664	//
665	// Return error status if Udp6 instance failed to receive.
666	//
667	if (EFI_ERROR (IoStatus)) {
668	Status = IoStatus;
669	goto ON_EXIT;
670	}
671
672	ASSERT (UdpPacket != NULL);
673
674	if (UdpPacket->TotalSize < MTFTP6_OPCODE_LEN) {
675	goto ON_EXIT;
676	}
677
678	//
679	// Find the port this packet is from to restart receive correctly.
680	//
681	if (CompareMem (
682	Ip6Swap128 (&UdpEpt->LocalAddr.v6),
683	&Instance->McastIp,
684	sizeof (EFI_IPv6_ADDRESS)
685	) == 0) {
686	IsMcast = TRUE;
687	} else {
688	IsMcast = FALSE;
689	}
690
691	//
692	// Client send initial request to server's listening port. Server
693	// will select a UDP port to communicate with the client. The server
694	// is required to use the same port as RemotePort to multicast the
695	// data.
696	//
697	if (UdpEpt->RemotePort != Instance->ServerDataPort) {
698	if (Instance->ServerDataPort != 0) {
699	goto ON_EXIT;
700	} else {
701	//
702	// For the subsequent exchange of requests, reconfigure the udpio as
703	// (serverip, serverport, localip, localport).
704	// Ususally, the client set serverport as 0 to receive and reset it
705	// once the first packet arrives to send ack.
706	//
707	Instance->ServerDataPort = UdpEpt->RemotePort;
708	}
709	}
710
711	//
712	// Copy the MTFTP packet to a continuous buffer if it isn't already so.
713	//
714	Len = UdpPacket->TotalSize;
715	TotalNum = UdpPacket->BlockOpNum;
716
717	if (TotalNum > 1) {
718	Packet = AllocateZeroPool (Len);
719
720	if (Packet == NULL) {
721	Status = EFI_OUT_OF_RESOURCES;
722	goto ON_EXIT;
723	}
724
725	NetbufCopy (UdpPacket, 0, Len, (UINT8 *) Packet);
726
727	} else {
728	Packet = (EFI_MTFTP6_PACKET *) NetbufGetByte (UdpPacket, 0, NULL);
729	ASSERT (Packet != NULL);
730	}
731
732	Opcode = NTOHS (Packet->OpCode);
733
734	//
735	// Callback to the user's CheckPacket if provided. Abort the transmission
736	// if CheckPacket returns an EFI_ERROR code.
737	//
738	if ((Instance->Token->CheckPacket != NULL) &&
739	(Opcode == EFI_MTFTP6_OPCODE_OACK \|\| Opcode == EFI_MTFTP6_OPCODE_ERROR)
740	) {
741
742	Status = Instance->Token->CheckPacket (
743	&Instance->Mtftp6,
744	Instance->Token,
745	(UINT16) Len,
746	Packet
747	);
748
749	if (EFI_ERROR (Status)) {
750	//
751	// Send an error message to the server to inform it
752	//
753	if (Opcode != EFI_MTFTP6_OPCODE_ERROR) {
754	//
755	// Free the received packet before send new packet in ReceiveNotify,
756	// since the udpio might need to be reconfigured.
757	//
758	NetbufFree (UdpPacket);
759	UdpPacket = NULL;
760	//
761	// Send the Mtftp6 error message if user aborted the current session.
762	//
763	Mtftp6SendError (
764	Instance,
765	EFI_MTFTP6_ERRORCODE_REQUEST_DENIED,
766	(UINT8 *) "User aborted the transfer"
767	);
768	}
769
770	Status = EFI_ABORTED;
771	goto ON_EXIT;
772	}
773	}
774
775	//
776	// Switch the process routines by the operation code.
777	//
778	switch (Opcode) {
779	case EFI_MTFTP6_OPCODE_DATA:
780	if ((Len > (UINT32) (MTFTP6_DATA_HEAD_LEN + Instance->BlkSize)) \|\| (Len < (UINT32) MTFTP6_DATA_HEAD_LEN)) {
781	goto ON_EXIT;
782	}
783	//
784	// Handle the data packet of Rrq.
785	//
786	Status = Mtftp6RrqHandleData (
787	Instance,
788	Packet,
789	Len,
790	&UdpPacket,
791	&IsCompleted
792	);
793	break;
794
795	case EFI_MTFTP6_OPCODE_OACK:
796	if (IsMcast \|\| Len <= MTFTP6_OPCODE_LEN) {
797	goto ON_EXIT;
798	}
799	//
800	// Handle the Oack packet of Rrq.
801	//
802	Status = Mtftp6RrqHandleOack (
803	Instance,
804	Packet,
805	Len,
806	&UdpPacket,
807	&IsCompleted
808	);
809	break;
810
811	default:
812	//
813	// Drop and return eror if received error message.
814	//
815	Status = EFI_TFTP_ERROR;
816	break;
817	}
818
819	ON_EXIT:
820	//
821	// Free the resources, then if !EFI_ERROR (Status), restart the
822	// receive, otherwise end the session.
823	//
824	if (Packet != NULL && TotalNum > 1) {
825	FreePool (Packet);
826	}
827	if (UdpPacket != NULL) {
828	NetbufFree (UdpPacket);
829	}
830	if (!EFI_ERROR (Status) && !IsCompleted) {
831	if (IsMcast) {
832	Status = UdpIoRecvDatagram (
833	Instance->McastUdpIo,
834	Mtftp6RrqInput,
835	Instance,
836	0
837	);
838	} else {
839	Status = UdpIoRecvDatagram (
840	Instance->UdpIo,
841	Mtftp6RrqInput,
842	Instance,
843	0
844	);
845	}
846	}
847	//
848	// Clean up the current session if failed to continue.
849	//
850	if (EFI_ERROR (Status) \|\| IsCompleted) {
851	Mtftp6OperationClean (Instance, Status);
852	}
853	}
854
855
856	/**
857	Start the Mtftp6 instance to download. It first initializes some
858	of the internal states, then builds and sends an RRQ reqeuest packet.
859	Finally, it starts receive for the downloading.
860
861	@param[in] Instance The pointer to the Mtftp6 instance.
862	@param[in] Operation The operation code of current packet.
863
864	@retval EFI_SUCCESS The Mtftp6 is started to download.
865	@retval Others Failed to start to download.
866
867	**/
868	EFI_STATUS
869	Mtftp6RrqStart (
870	IN MTFTP6_INSTANCE *Instance,
871	IN UINT16 Operation
872	)
873	{
874	EFI_STATUS Status;
875
876	//
877	// The valid block number range are [1, 0xffff]. For example:
878	// the client sends an RRQ request to the server, the server
879	// transfers the DATA1 block. If option negoitation is ongoing,
880	// the server will send back an OACK, then client will send ACK0.
881	//
882	Status = Mtftp6InitBlockRange (&Instance->BlkList, 1, 0xffff);
883
884	if (EFI_ERROR (Status)) {
885	return Status;
886	}
887
888	Status = Mtftp6SendRequest (Instance, Operation);
889
890	if (EFI_ERROR (Status)) {
891	return Status;
892	}
893
894	return UdpIoRecvDatagram (
895	Instance->UdpIo,
896	Mtftp6RrqInput,
897	Instance,
898	0
899	);
900	}
901

注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

source: vbox/trunk/src/VBox/Devices/EFI/Firmware/NetworkPkg/Mtftp6Dxe/Mtftp6Rrq.c@ 48674

以其他格式下載: