2 Mtftp6 support functions implementation.
4 Copyright (c) 2009 - 2018, Intel Corporation. All rights reserved.<BR>
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.
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.
16 #include "Mtftp6Impl.h"
20 Allocate a MTFTP block range, then init it to the range of [Start, End].
22 @param[in] Start The start block number.
23 @param[in] End The last block number in the range.
25 @return Range The range of the allocated block buffer.
34 MTFTP6_BLOCK_RANGE
*Range
;
36 Range
= AllocateZeroPool (sizeof (MTFTP6_BLOCK_RANGE
));
42 InitializeListHead (&Range
->Link
);
52 Initialize the block range for either RRQ or WRQ. RRQ and WRQ have
53 different requirements for Start and End. For example, during startup,
54 WRQ initializes its whole valid block range to [0, 0xffff]. This
55 is bacause the server will send an ACK0 to inform the user to start the
56 upload. When the client receives an ACK0, it will remove 0 from the range,
57 get the next block number, which is 1, then upload the BLOCK1. For RRQ
58 without option negotiation, the server will directly send the BLOCK1
59 in response to the client's RRQ. When received BLOCK1, the client will
60 remove it from the block range and send an ACK. It also works if there
61 is option negotiation.
63 @param[in] Head The block range head to initialize.
64 @param[in] Start The Start block number.
65 @param[in] End The last block number.
67 @retval EFI_OUT_OF_RESOURCES Failed to allocate memory for initial block range.
68 @retval EFI_SUCCESS The initial block range is created.
72 Mtftp6InitBlockRange (
78 MTFTP6_BLOCK_RANGE
*Range
;
80 Range
= Mtftp6AllocateRange (Start
, End
);
83 return EFI_OUT_OF_RESOURCES
;
86 InsertTailList (Head
, &Range
->Link
);
92 Get the first valid block number on the range list.
94 @param[in] Head The block range head.
96 @retval ==-1 If the block range is empty.
97 @retval >-1 The first valid block number.
101 Mtftp6GetNextBlockNum (
105 MTFTP6_BLOCK_RANGE
*Range
;
107 if (IsListEmpty (Head
)) {
111 Range
= NET_LIST_HEAD (Head
, MTFTP6_BLOCK_RANGE
, Link
);
117 Set the last block number of the block range list. It
118 removes all the blocks after the Last. MTFTP initialize the
119 block range to the maximum possible range, such as [0, 0xffff]
120 for WRQ. When it gets the last block number, it calls
121 this function to set the last block number.
123 @param[in] Head The block range list.
124 @param[in] Last The last block number.
128 Mtftp6SetLastBlockNum (
133 MTFTP6_BLOCK_RANGE
*Range
;
136 // Iterate from the tail to head to remove the block number
139 while (!IsListEmpty (Head
)) {
140 Range
= NET_LIST_TAIL (Head
, MTFTP6_BLOCK_RANGE
, Link
);
142 if (Range
->Start
> Last
) {
143 RemoveEntryList (&Range
->Link
);
148 if (Range
->End
> Last
) {
157 Remove the block number from the block range list.
159 @param[in] Head The block range list to remove from.
160 @param[in] Num The block number to remove.
161 @param[in] Completed Whether Num is the last block number
162 @param[out] TotalBlock The continuous block number in all
164 @retval EFI_NOT_FOUND The block number isn't in the block range list.
165 @retval EFI_SUCCESS The block number has been removed from the list.
166 @retval EFI_OUT_OF_RESOURCES Failed to allocate resources.
170 Mtftp6RemoveBlockNum (
173 IN BOOLEAN Completed
,
174 OUT UINT64
*TotalBlock
177 MTFTP6_BLOCK_RANGE
*Range
;
178 MTFTP6_BLOCK_RANGE
*NewRange
;
181 NET_LIST_FOR_EACH (Entry
, Head
) {
184 // Each block represents a hole [Start, End] in the file,
185 // skip to the first range with End >= Num
187 Range
= NET_LIST_USER_STRUCT (Entry
, MTFTP6_BLOCK_RANGE
, Link
);
189 if (Range
->End
< Num
) {
194 // There are three different cases for Start
195 // 1. (Start > Num) && (End >= Num):
196 // because all the holes before this one has the condition of
197 // End < Num, so this block number has been removed.
199 // 2. (Start == Num) && (End >= Num):
200 // Need to increase the Start by one, and if End == Num, this
201 // hole has been removed completely, remove it.
203 // 3. (Start < Num) && (End >= Num):
204 // if End == Num, only need to decrease the End by one because
205 // we have (Start < Num) && (Num == End), so (Start <= End - 1).
206 // if (End > Num), the hold is splited into two holes, with
207 // [Start, Num - 1] and [Num + 1, End].
209 if (Range
->Start
> Num
) {
210 return EFI_NOT_FOUND
;
212 } else if (Range
->Start
== Num
) {
216 // Note that: RFC 1350 does not mention block counter roll-over,
217 // but several TFTP hosts implement the roll-over be able to accept
218 // transfers of unlimited size. There is no consensus, however, whether
219 // the counter should wrap around to zero or to one. Many implementations
220 // wrap to zero, because this is the simplest to implement. Here we choose
225 if (Range
->Round
> 0) {
226 *TotalBlock
+= Range
->Bound
+ MultU64x32 (Range
->Round
- 1, (UINT32
)(Range
->Bound
+ 1)) + 1;
229 if (Range
->Start
> Range
->Bound
) {
234 if ((Range
->Start
> Range
->End
) || Completed
) {
235 RemoveEntryList (&Range
->Link
);
242 if (Range
->End
== Num
) {
245 NewRange
= Mtftp6AllocateRange ((UINT16
) (Num
+ 1), (UINT16
) Range
->End
);
247 if (NewRange
== NULL
) {
248 return EFI_OUT_OF_RESOURCES
;
251 Range
->End
= Num
- 1;
252 NetListInsertAfter (&Range
->Link
, &NewRange
->Link
);
259 return EFI_NOT_FOUND
;
264 Configure the opened Udp6 instance until the corresponding Ip6 instance
267 @param[in] UdpIo The pointer to the Udp6 Io.
268 @param[in] UdpCfgData The pointer to the Udp6 configure data.
270 @retval EFI_SUCCESS Configure the Udp6 instance successfully.
271 @retval EFI_NO_MAPPING The corresponding Ip6 instance has not
278 IN EFI_UDP6_CONFIG_DATA
*UdpCfgData
281 EFI_IP6_MODE_DATA Ip6Mode
;
282 EFI_UDP6_PROTOCOL
*Udp6
;
287 Udp6
= UdpIo
->Protocol
.Udp6
;
290 // Create a timer to check whether the Ip6 instance configured or not.
292 Status
= gBS
->CreateEvent (
299 if (EFI_ERROR (Status
)) {
303 Status
= gBS
->SetTimer (
306 MTFTP6_GET_MAPPING_TIMEOUT
* MTFTP6_TICK_PER_SECOND
308 if (EFI_ERROR (Status
)) {
313 // Check the Ip6 mode data till timeout.
315 while (EFI_ERROR (gBS
->CheckEvent (Event
))) {
319 Status
= Udp6
->GetModeData (Udp6
, NULL
, &Ip6Mode
, NULL
, NULL
);
321 if (!EFI_ERROR (Status
)) {
322 if (Ip6Mode
.AddressList
!= NULL
) {
323 FreePool (Ip6Mode
.AddressList
);
326 if (Ip6Mode
.GroupTable
!= NULL
) {
327 FreePool (Ip6Mode
.GroupTable
);
330 if (Ip6Mode
.RouteTable
!= NULL
) {
331 FreePool (Ip6Mode
.RouteTable
);
334 if (Ip6Mode
.NeighborCache
!= NULL
) {
335 FreePool (Ip6Mode
.NeighborCache
);
338 if (Ip6Mode
.PrefixTable
!= NULL
) {
339 FreePool (Ip6Mode
.PrefixTable
);
342 if (Ip6Mode
.IcmpTypeList
!= NULL
) {
343 FreePool (Ip6Mode
.IcmpTypeList
);
346 if (Ip6Mode
.IsConfigured
) {
348 // Continue to configure the Udp6 instance.
350 Status
= Udp6
->Configure (Udp6
, UdpCfgData
);
352 Status
= EFI_NO_MAPPING
;
360 gBS
->CloseEvent (Event
);
368 The dummy configure routine for create a new Udp6 Io.
370 @param[in] UdpIo The pointer to the Udp6 Io.
371 @param[in] Context The pointer to the context.
373 @retval EFI_SUCCESS This value is always returned.
378 Mtftp6ConfigDummyUdpIo (
388 The configure routine for Mtftp6 instance to transmit/receive.
390 @param[in] UdpIo The pointer to the Udp6 Io.
391 @param[in] ServerIp The pointer to the server address.
392 @param[in] ServerPort The pointer to the server port.
393 @param[in] LocalIp The pointer to the local address.
394 @param[in] LocalPort The pointer to the local port.
396 @retval EFI_SUCCESS Configured the Udp6 Io for Mtftp6 successfully.
397 @retval EFI_NO_MAPPING The corresponding Ip6 instance has not been
404 IN EFI_IPv6_ADDRESS
*ServerIp
,
405 IN UINT16 ServerPort
,
406 IN EFI_IPv6_ADDRESS
*LocalIp
,
411 EFI_UDP6_PROTOCOL
*Udp6
;
412 EFI_UDP6_CONFIG_DATA
*Udp6Cfg
;
414 Udp6
= UdpIo
->Protocol
.Udp6
;
415 Udp6Cfg
= &(UdpIo
->Config
.Udp6
);
417 ZeroMem (Udp6Cfg
, sizeof (EFI_UDP6_CONFIG_DATA
));
420 // Set the Udp6 Io configure data.
422 Udp6Cfg
->AcceptPromiscuous
= FALSE
;
423 Udp6Cfg
->AcceptAnyPort
= FALSE
;
424 Udp6Cfg
->AllowDuplicatePort
= FALSE
;
425 Udp6Cfg
->TrafficClass
= 0;
426 Udp6Cfg
->HopLimit
= 128;
427 Udp6Cfg
->ReceiveTimeout
= 0;
428 Udp6Cfg
->TransmitTimeout
= 0;
429 Udp6Cfg
->StationPort
= LocalPort
;
430 Udp6Cfg
->RemotePort
= ServerPort
;
433 &Udp6Cfg
->StationAddress
,
435 sizeof (EFI_IPv6_ADDRESS
)
439 &Udp6Cfg
->RemoteAddress
,
441 sizeof (EFI_IPv6_ADDRESS
)
445 // Configure the Udp6 instance with current configure data.
447 Status
= Udp6
->Configure (Udp6
, Udp6Cfg
);
449 if (Status
== EFI_NO_MAPPING
) {
451 return Mtftp6GetMapping (UdpIo
, Udp6Cfg
);
459 Build and transmit the request packet for the Mtftp6 instance.
461 @param[in] Instance The pointer to the Mtftp6 instance.
462 @param[in] Operation The operation code of this packet.
464 @retval EFI_OUT_OF_RESOURCES Failed to allocate memory for the request.
465 @retval EFI_SUCCESS The request is built and sent.
466 @retval Others Failed to transmit the packet.
471 IN MTFTP6_INSTANCE
*Instance
,
475 EFI_MTFTP6_PACKET
*Packet
;
476 EFI_MTFTP6_OPTION
*Options
;
477 EFI_MTFTP6_TOKEN
*Token
;
478 RETURN_STATUS Status
;
484 UINTN FileNameLength
;
486 UINTN OptionStrLength
;
487 UINTN ValueStrLength
;
489 Token
= Instance
->Token
;
490 Options
= Token
->OptionList
;
491 Mode
= Token
->ModeStr
;
494 Mode
= (UINT8
*) "octet";
498 // The header format of RRQ/WRQ packet is:
500 // 2 bytes string 1 byte string 1 byte
501 // ------------------------------------------------
502 // | Opcode | Filename | 0 | Mode | 0 |
503 // ------------------------------------------------
505 // The common option format is:
507 // string 1 byte string 1 byte
508 // ---------------------------------------
509 // | OptionStr | 0 | ValueStr | 0 |
510 // ---------------------------------------
514 // Compute the size of new Mtftp6 packet.
516 FileNameLength
= AsciiStrLen ((CHAR8
*) Token
->Filename
);
517 ModeLength
= AsciiStrLen ((CHAR8
*) Mode
);
518 BufferLength
= (UINT32
) FileNameLength
+ (UINT32
) ModeLength
+ 4;
520 for (Index
= 0; Index
< Token
->OptionCount
; Index
++) {
521 OptionStrLength
= AsciiStrLen ((CHAR8
*) Options
[Index
].OptionStr
);
522 ValueStrLength
= AsciiStrLen ((CHAR8
*) Options
[Index
].ValueStr
);
523 BufferLength
+= (UINT32
) OptionStrLength
+ (UINT32
) ValueStrLength
+ 2;
527 // Allocate a packet then copy the data.
529 if ((Nbuf
= NetbufAlloc (BufferLength
)) == NULL
) {
530 return EFI_OUT_OF_RESOURCES
;
534 // Copy the opcode, filename and mode into packet.
536 Packet
= (EFI_MTFTP6_PACKET
*) NetbufAllocSpace (Nbuf
, BufferLength
, FALSE
);
537 ASSERT (Packet
!= NULL
);
539 Packet
->OpCode
= HTONS (Operation
);
540 BufferLength
-= sizeof (Packet
->OpCode
);
542 Cur
= Packet
->Rrq
.Filename
;
543 Status
= AsciiStrCpyS ((CHAR8
*) Cur
, BufferLength
, (CHAR8
*) Token
->Filename
);
544 ASSERT_EFI_ERROR (Status
);
545 BufferLength
-= (UINT32
) (FileNameLength
+ 1);
546 Cur
+= FileNameLength
+ 1;
547 Status
= AsciiStrCpyS ((CHAR8
*) Cur
, BufferLength
, (CHAR8
*) Mode
);
548 ASSERT_EFI_ERROR (Status
);
549 BufferLength
-= (UINT32
) (ModeLength
+ 1);
550 Cur
+= ModeLength
+ 1;
553 // Copy all the extension options into the packet.
555 for (Index
= 0; Index
< Token
->OptionCount
; ++Index
) {
556 OptionStrLength
= AsciiStrLen ((CHAR8
*) Options
[Index
].OptionStr
);
557 ValueStrLength
= AsciiStrLen ((CHAR8
*) Options
[Index
].ValueStr
);
559 Status
= AsciiStrCpyS ((CHAR8
*) Cur
, BufferLength
, (CHAR8
*) Options
[Index
].OptionStr
);
560 ASSERT_EFI_ERROR (Status
);
561 BufferLength
-= (UINT32
) (OptionStrLength
+ 1);
562 Cur
+= OptionStrLength
+ 1;
564 Status
= AsciiStrCpyS ((CHAR8
*) Cur
, BufferLength
, (CHAR8
*) Options
[Index
].ValueStr
);
565 ASSERT_EFI_ERROR (Status
);
566 BufferLength
-= (UINT32
) (ValueStrLength
+ 1);
567 Cur
+= ValueStrLength
+ 1;
572 // Save the packet buf for retransmit
574 if (Instance
->LastPacket
!= NULL
) {
575 NetbufFree (Instance
->LastPacket
);
578 Instance
->LastPacket
= Nbuf
;
579 Instance
->CurRetry
= 0;
581 return Mtftp6TransmitPacket (Instance
, Nbuf
);
586 Build and send an error packet.
588 @param[in] Instance The pointer to the Mtftp6 instance.
589 @param[in] ErrCode The error code in the packet.
590 @param[in] ErrInfo The error message in the packet.
592 @retval EFI_OUT_OF_RESOURCES Failed to allocate memory for the error packet.
593 @retval EFI_SUCCESS The error packet is transmitted.
594 @retval Others Failed to transmit the packet.
599 IN MTFTP6_INSTANCE
*Instance
,
605 EFI_MTFTP6_PACKET
*TftpError
;
609 // Allocate a packet then copy the data.
611 Len
= (UINT32
) (AsciiStrLen ((CHAR8
*) ErrInfo
) + sizeof (EFI_MTFTP6_ERROR_HEADER
));
612 Nbuf
= NetbufAlloc (Len
);
615 return EFI_OUT_OF_RESOURCES
;
618 TftpError
= (EFI_MTFTP6_PACKET
*) NetbufAllocSpace (Nbuf
, Len
, FALSE
);
620 if (TftpError
== NULL
) {
622 return EFI_OUT_OF_RESOURCES
;
625 TftpError
->OpCode
= HTONS (EFI_MTFTP6_OPCODE_ERROR
);
626 TftpError
->Error
.ErrorCode
= HTONS (ErrCode
);
628 AsciiStrCpyS ((CHAR8
*) TftpError
->Error
.ErrorMessage
, AsciiStrLen ((CHAR8
*) ErrInfo
) + 1 , (CHAR8
*) ErrInfo
);
631 // Save the packet buf for retransmit
633 if (Instance
->LastPacket
!= NULL
) {
634 NetbufFree (Instance
->LastPacket
);
637 Instance
->LastPacket
= Nbuf
;
638 Instance
->CurRetry
= 0;
640 return Mtftp6TransmitPacket (Instance
, Nbuf
);
645 The callback function called when the packet is transmitted.
647 @param[in] Packet The pointer to the packet.
648 @param[in] UdpEpt The pointer to the Udp6 access point.
649 @param[in] IoStatus The result of the transmission.
650 @param[in] Context The pointer to the context.
657 IN UDP_END_POINT
*UdpEpt
,
658 IN EFI_STATUS IoStatus
,
663 *(BOOLEAN
*) Context
= TRUE
;
668 Send the packet for the Mtftp6 instance.
670 @param[in] Instance The pointer to the Mtftp6 instance.
671 @param[in] Packet The pointer to the packet to be sent.
673 @retval EFI_SUCCESS The packet was sent out
674 @retval Others Failed to transmit the packet.
678 Mtftp6TransmitPacket (
679 IN MTFTP6_INSTANCE
*Instance
,
683 EFI_UDP6_PROTOCOL
*Udp6
;
684 EFI_UDP6_CONFIG_DATA Udp6CfgData
;
690 ZeroMem (&Udp6CfgData
, sizeof(EFI_UDP6_CONFIG_DATA
));
691 Udp6
= Instance
->UdpIo
->Protocol
.Udp6
;
694 // Set the live time of the packet.
696 Instance
->PacketToLive
= Instance
->IsMaster
? Instance
->Timeout
: (Instance
->Timeout
* 2);
698 Temp
= (UINT16
*) NetbufGetByte (Packet
, 0, NULL
);
699 ASSERT (Temp
!= NULL
);
702 OpCode
= NTOHS (Value
);
704 if (OpCode
== EFI_MTFTP6_OPCODE_RRQ
|| OpCode
== EFI_MTFTP6_OPCODE_DIR
|| OpCode
== EFI_MTFTP6_OPCODE_WRQ
) {
706 // For the Rrq, Dir, Wrq requests of the operation, configure the Udp6Io as
707 // (serverip, 69, localip, localport) to send.
708 // Usually local address and local port are both default as zero.
710 Status
= Udp6
->Configure (Udp6
, NULL
);
712 if (EFI_ERROR (Status
)) {
716 Status
= Mtftp6ConfigUdpIo (
719 Instance
->ServerCmdPort
,
720 &Instance
->Config
->StationIp
,
721 Instance
->Config
->LocalPort
724 if (EFI_ERROR (Status
)) {
729 // Get the current local address and port by get Udp6 mode data.
731 Status
= Udp6
->GetModeData (Udp6
, &Udp6CfgData
, NULL
, NULL
, NULL
);
732 if (EFI_ERROR (Status
)) {
736 NET_GET_REF (Packet
);
738 Instance
->IsTransmitted
= FALSE
;
740 Status
= UdpIoSendDatagram (
746 &Instance
->IsTransmitted
749 if (EFI_ERROR (Status
)) {
750 NET_PUT_REF (Packet
);
755 // Poll till the packet sent out from the ip6 queue.
757 gBS
->RestoreTPL (Instance
->OldTpl
);
759 while (!Instance
->IsTransmitted
) {
763 Instance
->OldTpl
= gBS
->RaiseTPL (TPL_CALLBACK
);
766 // For the subsequent exchange of such requests, reconfigure the Udp6Io as
767 // (serverip, 0, localip, localport) to receive.
768 // Currently local address and local port are specified by Udp6 mode data.
770 Status
= Udp6
->Configure (Udp6
, NULL
);
772 if (EFI_ERROR (Status
)) {
776 Status
= Mtftp6ConfigUdpIo (
779 Instance
->ServerDataPort
,
780 &Udp6CfgData
.StationAddress
,
781 Udp6CfgData
.StationPort
785 // For the data exchange, configure the Udp6Io as (serverip, dataport,
786 // localip, localport) to send/receive.
787 // Currently local address and local port are specified by Udp6 mode data.
789 Status
= Udp6
->GetModeData (Udp6
, &Udp6CfgData
, NULL
, NULL
, NULL
);
790 if (EFI_ERROR (Status
)) {
794 if (Udp6CfgData
.RemotePort
!= Instance
->ServerDataPort
) {
796 Status
= Udp6
->Configure (Udp6
, NULL
);
798 if (EFI_ERROR (Status
)) {
802 Status
= Mtftp6ConfigUdpIo (
805 Instance
->ServerDataPort
,
806 &Udp6CfgData
.StationAddress
,
807 Udp6CfgData
.StationPort
810 if (EFI_ERROR (Status
)) {
815 NET_GET_REF (Packet
);
817 Instance
->IsTransmitted
= FALSE
;
819 Status
= UdpIoSendDatagram (
825 &Instance
->IsTransmitted
828 if (EFI_ERROR (Status
)) {
829 NET_PUT_REF (Packet
);
833 // Poll till the packet sent out from the ip6 queue.
835 gBS
->RestoreTPL (Instance
->OldTpl
);
837 while (!Instance
->IsTransmitted
) {
841 Instance
->OldTpl
= gBS
->RaiseTPL (TPL_CALLBACK
);
849 Check packet for GetInfo callback routine.
851 GetInfo is implemented with EfiMtftp6ReadFile. It's used to inspect
852 the first packet from server, then abort the session.
854 @param[in] This The pointer to the Mtftp6 protocol.
855 @param[in] Token The pointer to the Mtftp6 token.
856 @param[in] PacketLen The length of the packet.
857 @param[in] Packet The pointer to the received packet.
859 @retval EFI_ABORTED Abort the Mtftp6 operation.
865 IN EFI_MTFTP6_PROTOCOL
*This
,
866 IN EFI_MTFTP6_TOKEN
*Token
,
868 IN EFI_MTFTP6_PACKET
*Packet
871 MTFTP6_GETINFO_CONTEXT
*Context
;
874 Context
= (MTFTP6_GETINFO_CONTEXT
*) Token
->Context
;
875 OpCode
= NTOHS (Packet
->OpCode
);
878 // Set the GetInfo's return status according to the OpCode.
881 case EFI_MTFTP6_OPCODE_ERROR
:
882 Context
->Status
= EFI_TFTP_ERROR
;
885 case EFI_MTFTP6_OPCODE_OACK
:
886 Context
->Status
= EFI_SUCCESS
;
890 Context
->Status
= EFI_PROTOCOL_ERROR
;
894 // Allocate buffer then copy the packet over. Use gBS->AllocatePool
895 // in case NetAllocatePool will implements something tricky.
897 *(Context
->Packet
) = AllocateZeroPool (PacketLen
);
899 if (*(Context
->Packet
) == NULL
) {
900 Context
->Status
= EFI_OUT_OF_RESOURCES
;
904 *(Context
->PacketLen
) = PacketLen
;
905 CopyMem (*(Context
->Packet
), Packet
, PacketLen
);
912 Clean up the current Mtftp6 operation.
914 @param[in] Instance The pointer to the Mtftp6 instance.
915 @param[in] Result The result to be returned to the user.
919 Mtftp6OperationClean (
920 IN MTFTP6_INSTANCE
*Instance
,
926 MTFTP6_BLOCK_RANGE
*Block
;
929 // Clean up the current token and event.
931 if (Instance
->Token
!= NULL
) {
932 Instance
->Token
->Status
= Result
;
933 if (Instance
->Token
->Event
!= NULL
) {
934 gBS
->SignalEvent (Instance
->Token
->Event
);
936 Instance
->Token
= NULL
;
940 // Clean up the corresponding Udp6Io.
942 if (Instance
->UdpIo
!= NULL
) {
943 UdpIoCleanIo (Instance
->UdpIo
);
946 if (Instance
->McastUdpIo
!= NULL
) {
948 Instance
->McastUdpIo
->UdpHandle
,
949 &gEfiUdp6ProtocolGuid
,
950 Instance
->McastUdpIo
->Image
,
953 UdpIoFreeIo (Instance
->McastUdpIo
);
954 Instance
->McastUdpIo
= NULL
;
958 // Clean up the stored last packet.
960 if (Instance
->LastPacket
!= NULL
) {
961 NetbufFree (Instance
->LastPacket
);
962 Instance
->LastPacket
= NULL
;
965 NET_LIST_FOR_EACH_SAFE (Entry
, Next
, &Instance
->BlkList
) {
966 Block
= NET_LIST_USER_STRUCT (Entry
, MTFTP6_BLOCK_RANGE
, Link
);
967 RemoveEntryList (Entry
);
972 // Reinitialize the corresponding fields of the Mtftp6 operation.
974 ZeroMem (&Instance
->ExtInfo
, sizeof (MTFTP6_EXT_OPTION_INFO
));
975 ZeroMem (&Instance
->ServerIp
, sizeof (EFI_IPv6_ADDRESS
));
976 ZeroMem (&Instance
->McastIp
, sizeof (EFI_IPv6_ADDRESS
));
978 Instance
->ServerCmdPort
= 0;
979 Instance
->ServerDataPort
= 0;
980 Instance
->McastPort
= 0;
981 Instance
->BlkSize
= 0;
982 Instance
->LastBlk
= 0;
983 Instance
->PacketToLive
= 0;
984 Instance
->MaxRetry
= 0;
985 Instance
->CurRetry
= 0;
986 Instance
->Timeout
= 0;
987 Instance
->IsMaster
= TRUE
;
992 Start the Mtftp6 instance to perform the operation, such as read file,
993 write file, and read directory.
995 @param[in] This The MTFTP session.
996 @param[in] Token The token than encapsues the user's request.
997 @param[in] OpCode The operation to perform.
999 @retval EFI_INVALID_PARAMETER Some of the parameters are invalid.
1000 @retval EFI_NOT_STARTED The MTFTP session hasn't been configured.
1001 @retval EFI_ALREADY_STARTED There is pending operation for the session.
1002 @retval EFI_SUCCESS The operation is successfully started.
1006 Mtftp6OperationStart (
1007 IN EFI_MTFTP6_PROTOCOL
*This
,
1008 IN EFI_MTFTP6_TOKEN
*Token
,
1012 MTFTP6_INSTANCE
*Instance
;
1017 Token
->Filename
== NULL
||
1018 (Token
->OptionCount
!= 0 && Token
->OptionList
== NULL
) ||
1019 (Token
->OverrideData
!= NULL
&& !NetIp6IsValidUnicast (&Token
->OverrideData
->ServerIp
))
1021 return EFI_INVALID_PARAMETER
;
1025 // At least define one method to collect the data for download.
1027 if ((OpCode
== EFI_MTFTP6_OPCODE_RRQ
|| OpCode
== EFI_MTFTP6_OPCODE_DIR
) &&
1028 Token
->Buffer
== NULL
&&
1029 Token
->CheckPacket
== NULL
1031 return EFI_INVALID_PARAMETER
;
1035 // At least define one method to provide the data for upload.
1037 if (OpCode
== EFI_MTFTP6_OPCODE_WRQ
&& Token
->Buffer
== NULL
&& Token
->PacketNeeded
== NULL
) {
1038 return EFI_INVALID_PARAMETER
;
1041 Instance
= MTFTP6_INSTANCE_FROM_THIS (This
);
1043 if (Instance
->Config
== NULL
) {
1044 return EFI_NOT_STARTED
;
1047 if (Instance
->Token
!= NULL
) {
1048 return EFI_ACCESS_DENIED
;
1051 Status
= EFI_SUCCESS
;
1052 Instance
->OldTpl
= gBS
->RaiseTPL (TPL_CALLBACK
);
1055 // Parse the extension options in the request packet.
1057 if (Token
->OptionCount
!= 0) {
1059 Status
= Mtftp6ParseExtensionOption (
1066 if (EFI_ERROR (Status
)) {
1072 // Initialize runtime data from config data or override data.
1074 Instance
->Token
= Token
;
1075 Instance
->ServerCmdPort
= Instance
->Config
->InitialServerPort
;
1076 Instance
->ServerDataPort
= 0;
1077 Instance
->MaxRetry
= Instance
->Config
->TryCount
;
1078 Instance
->Timeout
= Instance
->Config
->TimeoutValue
;
1079 Instance
->IsMaster
= TRUE
;
1082 &Instance
->ServerIp
,
1083 &Instance
->Config
->ServerIp
,
1084 sizeof (EFI_IPv6_ADDRESS
)
1087 if (Token
->OverrideData
!= NULL
) {
1088 Instance
->ServerCmdPort
= Token
->OverrideData
->ServerPort
;
1089 Instance
->MaxRetry
= Token
->OverrideData
->TryCount
;
1090 Instance
->Timeout
= Token
->OverrideData
->TimeoutValue
;
1093 &Instance
->ServerIp
,
1094 &Token
->OverrideData
->ServerIp
,
1095 sizeof (EFI_IPv6_ADDRESS
)
1100 // Set default value for undefined parameters.
1102 if (Instance
->ServerCmdPort
== 0) {
1103 Instance
->ServerCmdPort
= MTFTP6_DEFAULT_SERVER_CMD_PORT
;
1105 if (Instance
->BlkSize
== 0) {
1106 Instance
->BlkSize
= MTFTP6_DEFAULT_BLK_SIZE
;
1108 if (Instance
->MaxRetry
== 0) {
1109 Instance
->MaxRetry
= MTFTP6_DEFAULT_MAX_RETRY
;
1111 if (Instance
->Timeout
== 0) {
1112 Instance
->Timeout
= MTFTP6_DEFAULT_TIMEOUT
;
1115 Token
->Status
= EFI_NOT_READY
;
1118 // Switch the routines by the operation code.
1121 case EFI_MTFTP6_OPCODE_RRQ
:
1122 Status
= Mtftp6RrqStart (Instance
, OpCode
);
1125 case EFI_MTFTP6_OPCODE_DIR
:
1126 Status
= Mtftp6RrqStart (Instance
, OpCode
);
1129 case EFI_MTFTP6_OPCODE_WRQ
:
1130 Status
= Mtftp6WrqStart (Instance
, OpCode
);
1134 Status
= EFI_DEVICE_ERROR
;
1138 if (EFI_ERROR (Status
)) {
1143 // Return immediately for asynchronous or poll the instance for synchronous.
1145 gBS
->RestoreTPL (Instance
->OldTpl
);
1147 if (Token
->Event
== NULL
) {
1148 while (Token
->Status
== EFI_NOT_READY
) {
1151 return Token
->Status
;
1158 Mtftp6OperationClean (Instance
, Status
);
1159 gBS
->RestoreTPL (Instance
->OldTpl
);
1166 The timer ticking routine for the Mtftp6 instance.
1168 @param[in] Event The pointer to the ticking event.
1169 @param[in] Context The pointer to the context.
1179 MTFTP6_SERVICE
*Service
;
1180 MTFTP6_INSTANCE
*Instance
;
1183 EFI_MTFTP6_TOKEN
*Token
;
1186 Service
= (MTFTP6_SERVICE
*) Context
;
1189 // Iterate through all the children of the Mtftp service instance. Time
1190 // out the packet. If maximum retries reached, clean the session up.
1192 NET_LIST_FOR_EACH_SAFE (Entry
, Next
, &Service
->Children
) {
1194 Instance
= NET_LIST_USER_STRUCT (Entry
, MTFTP6_INSTANCE
, Link
);
1196 if (Instance
->Token
== NULL
) {
1200 if (Instance
->PacketToLive
> 0) {
1201 Instance
->PacketToLive
--;
1205 Instance
->CurRetry
++;
1206 Token
= Instance
->Token
;
1208 if (Token
->TimeoutCallback
!= NULL
) {
1210 // Call the timeout callback routine if has.
1212 Status
= Token
->TimeoutCallback (&Instance
->Mtftp6
, Token
);
1214 if (EFI_ERROR (Status
)) {
1217 EFI_MTFTP6_ERRORCODE_REQUEST_DENIED
,
1218 (UINT8
*) "User aborted the transfer in time out"
1220 Mtftp6OperationClean (Instance
, EFI_ABORTED
);
1226 // Retransmit the packet if haven't reach the maxmium retry count,
1227 // otherwise exit the transfer.
1229 if (Instance
->CurRetry
< Instance
->MaxRetry
) {
1230 Mtftp6TransmitPacket (Instance
, Instance
->LastPacket
);
1232 Mtftp6OperationClean (Instance
, EFI_TIMEOUT
);