MdeModulePkg/Universal/Network/Mtftp4Dxe/Mtftp4Rrq.c

   1 /** @file
   2
   3 Copyright (c) 2006 - 2007, Intel Corporation
   4 All rights reserved. This program and the accompanying materials
   5 are licensed and made available under the terms and conditions of the BSD License
   6 which accompanies this distribution.  The full text of the license may be found at
   7 http://opensource.org/licenses/bsd-license.php
   8
   9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  11
  12 Module Name:
  13
  14   Mtftp4Rrq.c
  15
  16 Abstract:
  17
  18   Routines to process Rrq (download)
  19
  20
  21 **/
  22
  23 #include "Mtftp4Impl.h"
  24
  25 VOID
  26 Mtftp4RrqInput (
  27   IN NET_BUF                *UdpPacket,
  28   IN UDP_POINTS             *Points,
  29   IN EFI_STATUS             IoStatus,
  30   IN VOID                   *Context
  31   );
  32
  33
  34 /**
  35   Start the MTFTP session to download. It will first initialize some
  36   of the internal states then build and send a RRQ reqeuest packet, at
  37   last, it will start receive for the downloading.
  38
  39   @param  Instance              The Mtftp session
  40   @param  Operation             The MTFTP opcode, it may be a EFI_MTFTP4_OPCODE_RRQ
  41                                 or EFI_MTFTP4_OPCODE_DIR.
  42
  43   @retval EFI_SUCCESS           The mtftp download session is started.
  44   @retval Others                Failed to start downloading.
  45
  46 **/
  47 EFI_STATUS
  48 Mtftp4RrqStart (
  49   IN MTFTP4_PROTOCOL        *Instance,
  50   IN UINT16                 Operation
  51   )
  52 {
  53   EFI_STATUS                Status;
  54
  55   //
  56   // The valid block number range are [1, 0xffff]. For example:
  57   // the client sends an RRQ request to the server, the server
  58   // transfers the DATA1 block. If option negoitation is ongoing,
  59   // the server will send back an OACK, then client will send ACK0.
  60   //
  61   Status = Mtftp4InitBlockRange (&Instance->Blocks, 1, 0xffff);
  62
  63   if (EFI_ERROR (Status)) {
  64     return Status;
  65   }
  66
  67   Status = Mtftp4SendRequest (Instance);
  68
  69   if (EFI_ERROR (Status)) {
  70     return Status;
  71   }
  72
  73   return UdpIoRecvDatagram (Instance->UnicastPort, Mtftp4RrqInput, Instance, 0);
  74 }
  75
  76
  77 /**
  78   Build and send a ACK packet for the download session.
  79
  80   @param  Instance              The Mtftp session
  81   @param  BlkNo                 The BlkNo to ack.
  82
  83   @retval EFI_OUT_OF_RESOURCES  Failed to allocate memory for the packet
  84   @retval EFI_SUCCESS           The ACK has been sent
  85   @retval Others                Failed to send the ACK.
  86
  87 **/
  88 EFI_STATUS
  89 Mtftp4RrqSendAck (
  90   IN MTFTP4_PROTOCOL        *Instance,
  91   IN UINT16                 BlkNo
  92   )
  93 {
  94   EFI_MTFTP4_PACKET         *Ack;
  95   NET_BUF                   *Packet;
  96
  97   Packet = NetbufAlloc (sizeof (EFI_MTFTP4_ACK_HEADER));
  98
  99   if (Packet == NULL) {
 100     return EFI_OUT_OF_RESOURCES;
 101   }
 102
 103   Ack = (EFI_MTFTP4_PACKET *) NetbufAllocSpace (
 104                                 Packet,
 105                                 sizeof (EFI_MTFTP4_ACK_HEADER),
 106                                 FALSE
 107                                 );
 108
 109   Ack->Ack.OpCode   = HTONS (EFI_MTFTP4_OPCODE_ACK);
 110   Ack->Ack.Block[0] = HTONS (BlkNo);
 111
 112   return Mtftp4SendPacket (Instance, Packet);
 113 }
 114
 115
 116 /**
 117   Deliver the received data block to the user, which can be saved
 118   in the user provide buffer or through the CheckPacket callback.
 119
 120   @param  Instance              The Mtftp session
 121   @param  Packet                The received data packet
 122   @param  Len                   The packet length
 123
 124   @retval EFI_SUCCESS           The data is saved successfully
 125   @retval EFI_ABORTED           The user tells to abort by return an error  through
 126                                 CheckPacket
 127   @retval EFI_BUFFER_TOO_SMALL  The user's buffer is too small and buffer length is
 128                                  updated to the actual buffer size needed.
 129
 130 **/
 131 EFI_STATUS
 132 Mtftp4RrqSaveBlock (
 133   IN MTFTP4_PROTOCOL        *Instance,
 134   IN EFI_MTFTP4_PACKET      *Packet,
 135   IN UINT32                 Len
 136   )
 137 {
 138   EFI_MTFTP4_TOKEN          *Token;
 139   EFI_STATUS                Status;
 140   UINT16                    Block;
 141   UINT64                    Start;
 142   UINT32                    DataLen;
 143
 144   Token   = Instance->Token;
 145   Block   = NTOHS (Packet->Data.Block);
 146   DataLen = Len - MTFTP4_DATA_HEAD_LEN;
 147
 148   //
 149   // This is the last block, save the block no
 150   //
 151   if (DataLen < Instance->BlkSize) {
 152     Instance->LastBlock = Block;
 153     Mtftp4SetLastBlockNum (&Instance->Blocks, Block);
 154   }
 155
 156   //
 157   // Remove this block number from the file hole. If Mtftp4RemoveBlockNum
 158   // returns EFI_NOT_FOUND, the block has been saved, don't save it again.
 159   //
 160   Status = Mtftp4RemoveBlockNum (&Instance->Blocks, Block);
 161
 162   if (Status == EFI_NOT_FOUND) {
 163     return EFI_SUCCESS;
 164   } else if (EFI_ERROR (Status)) {
 165     return Status;
 166   }
 167
 168   if (Token->CheckPacket != NULL) {
 169     Status = Token->CheckPacket (&Instance->Mtftp4, Token, (UINT16) Len, Packet);
 170
 171     if (EFI_ERROR (Status)) {
 172       Mtftp4SendError (
 173         Instance,
 174         EFI_MTFTP4_ERRORCODE_ILLEGAL_OPERATION,
 175         (UINT8 *) "User aborted download"
 176         );
 177
 178       return EFI_ABORTED;
 179     }
 180   }
 181
 182   if (Token->Buffer != NULL) {
 183     Start = MultU64x32 (Block - 1, Instance->BlkSize);
 184
 185     if (Start + DataLen <= Token->BufferSize) {
 186       NetCopyMem ((UINT8 *) Token->Buffer + Start, Packet->Data.Data, DataLen);
 187
 188       //
 189       // Update the file size when received the last block
 190       //
 191       if (Instance->LastBlock == Block) {
 192         Token->BufferSize = Start + DataLen;
 193       }
 194
 195     } else if (Instance->LastBlock != 0) {
 196       //
 197       // Don't save the data if the buffer is too small, return
 198       // EFI_BUFFER_TOO_SMALL if received the last packet. This
 199       // will give a accurate file length.
 200       //
 201       Token->BufferSize = Start + DataLen;
 202
 203       Mtftp4SendError (
 204         Instance,
 205         EFI_MTFTP4_ERRORCODE_DISK_FULL,
 206         (UINT8 *) "User provided memory block is too small"
 207         );
 208
 209       return EFI_BUFFER_TOO_SMALL;
 210     }
 211   }
 212
 213   return EFI_SUCCESS;
 214 }
 215
 216
 217 /**
 218   Function to process the received data packets. It will save the block
 219   then send back an ACK if it is active.
 220
 221   @param  Instance              The downloading MTFTP session
 222   @param  Packet                The packet received
 223   @param  Len                   The length of the packet
 224   @param  Multicast             Whether this packet is multicast or unicast
 225   @param  Completed             Return whether the download has completed
 226
 227   @retval EFI_SUCCESS           The data packet is successfully processed
 228   @retval EFI_ABORTED           The download is aborted by the user
 229   @retval EFI_BUFFER_TOO_SMALL  The user provided buffer is too small
 230
 231 **/
 232 EFI_STATUS
 233 Mtftp4RrqHandleData (
 234   IN  MTFTP4_PROTOCOL       *Instance,
 235   IN  EFI_MTFTP4_PACKET     *Packet,
 236   IN  UINT32                Len,
 237   IN  BOOLEAN               Multicast,
 238   OUT BOOLEAN               *Completed
 239   )
 240 {
 241   EFI_STATUS                Status;
 242   UINT16                    BlockNum;
 243   INTN                      Expected;
 244
 245   *Completed  = FALSE;
 246   BlockNum    = NTOHS (Packet->Data.Block);
 247   Expected    = Mtftp4GetNextBlockNum (&Instance->Blocks);
 248
 249   ASSERT (Expected >= 0);
 250
 251   //
 252   // If we are active and received an unexpected packet, retransmit
 253   // the last ACK then restart receiving. If we are passive, save
 254   // the block.
 255   //
 256   if (Instance->Master && (Expected != BlockNum)) {
 257     Mtftp4Retransmit (Instance);
 258     return EFI_SUCCESS;
 259   }
 260
 261   Status = Mtftp4RrqSaveBlock (Instance, Packet, Len);
 262
 263   if (EFI_ERROR (Status)) {
 264     return Status;
 265   }
 266
 267   //
 268   // Reset the passive client's timer whenever it received a
 269   // valid data packet.
 270   //
 271   if (!Instance->Master) {
 272     Mtftp4SetTimeout (Instance);
 273   }
 274
 275   //
 276   // Check whether we have received all the blocks. Send the ACK if we
 277   // are active (unicast client or master client for multicast download).
 278   // If we have received all the blocks, send an ACK even if we are passive
 279   // to tell the server that we are done.
 280   //
 281   Expected = Mtftp4GetNextBlockNum (&Instance->Blocks);
 282
 283   if (Instance->Master || (Expected < 0)) {
 284     if (Expected < 0) {
 285       //
 286       // If we are passive client, then the just received Block maybe
 287       // isn't the last block. We need to send an ACK to the last block
 288       // to inform the server that we are done. If we are active client,
 289       // the Block == Instance->LastBlock.
 290       //
 291       BlockNum   = Instance->LastBlock;
 292       *Completed = TRUE;
 293
 294     } else {
 295       BlockNum = (UINT16) (Expected - 1);
 296     }
 297
 298     Mtftp4RrqSendAck (Instance, BlockNum);
 299   }
 300
 301   return EFI_SUCCESS;
 302 }
 303
 304
 305 /**
 306   Validate whether the options received in the server's OACK packet is valid.
 307   The options are valid only if:
 308   1. The server doesn't include options not requested by us
 309   2. The server can only use smaller blksize than that is requested
 310   3. The server can only use the same timeout as requested
 311   4. The server doesn't change its multicast channel.
 312
 313   @param  This                  The downloading Mtftp session
 314   @param  Reply                 The options in the OACK packet
 315   @param  Request               The requested options
 316
 317   @return TRUE if the options in the OACK is OK, otherwise FALSE.
 318
 319 **/
 320 BOOLEAN
 321 Mtftp4RrqOackValid (
 322   IN MTFTP4_PROTOCOL        *This,
 323   IN MTFTP4_OPTION          *Reply,
 324   IN MTFTP4_OPTION          *Request
 325   )
 326 {
 327
 328   //
 329   // It is invalid for server to return options we don't request
 330   //
 331   if ((Reply->Exist &~Request->Exist) != 0) {
 332     return FALSE;
 333   }
 334
 335   //
 336   // Server can only specify a smaller block size to be used and
 337   // return the timeout matches that requested.
 338   //
 339   if (((Reply->Exist & MTFTP4_BLKSIZE_EXIST) && (Reply->BlkSize > Request->BlkSize)) ||
 340       ((Reply->Exist & MTFTP4_TIMEOUT_EXIST) && (Reply->Timeout != Request->Timeout))) {
 341     return FALSE;
 342   }
 343
 344   //
 345   // The server can send ",,master" to client to change its master
 346   // setting. But if it use the specific multicast channel, it can't
 347   // change the setting.
 348   //
 349   if ((Reply->Exist & MTFTP4_MCAST_EXIST) && (This->McastIp != 0)) {
 350     if ((Reply->McastIp != 0) && (Reply->McastIp != This->McastIp)) {
 351       return FALSE;
 352     }
 353
 354     if ((Reply->McastPort != 0) && (Reply->McastPort != This->McastPort)) {
 355       return FALSE;
 356     }
 357   }
 358
 359   return TRUE;
 360 }
 361
 362
 363 /**
 364   Configure a UDP IO port to receive the multicast.
 365
 366   @param  McastIo               The UDP IO port to configure
 367   @param  Context               The opaque parameter to the function which is the
 368                                 MTFTP session.
 369
 370   @retval EFI_SUCCESS           The udp child is successfully configured.
 371   @retval Others                Failed to configure the UDP child.
 372
 373 **/
 374 STATIC
 375 EFI_STATUS
 376 Mtftp4RrqConfigMcastPort (
 377   IN UDP_IO_PORT            *McastIo,
 378   IN VOID                   *Context
 379   )
 380 {
 381   MTFTP4_PROTOCOL           *Instance;
 382   EFI_MTFTP4_CONFIG_DATA    *Config;
 383   EFI_UDP4_CONFIG_DATA      UdpConfig;
 384   EFI_IPv4_ADDRESS          Group;
 385   EFI_STATUS                Status;
 386   IP4_ADDR                  Ip;
 387
 388   Instance                     = (MTFTP4_PROTOCOL *) Context;
 389   Config                       = &Instance->Config;
 390
 391   UdpConfig.AcceptBroadcast    = FALSE;
 392   UdpConfig.AcceptPromiscuous  = FALSE;
 393   UdpConfig.AcceptAnyPort      = FALSE;
 394   UdpConfig.AllowDuplicatePort = FALSE;
 395   UdpConfig.TypeOfService      = 0;
 396   UdpConfig.TimeToLive         = 64;
 397   UdpConfig.DoNotFragment      = FALSE;
 398   UdpConfig.ReceiveTimeout     = 0;
 399   UdpConfig.TransmitTimeout    = 0;
 400   UdpConfig.UseDefaultAddress  = Config->UseDefaultSetting;
 401   UdpConfig.StationAddress     = Config->StationIp;
 402   UdpConfig.SubnetMask         = Config->SubnetMask;
 403   UdpConfig.StationPort        = Instance->McastPort;
 404   UdpConfig.RemotePort         = 0;
 405
 406   Ip = HTONL (Instance->ServerIp);
 407   NetCopyMem (&UdpConfig.RemoteAddress, &Ip, sizeof (EFI_IPv4_ADDRESS));
 408
 409   Status = McastIo->Udp->Configure (McastIo->Udp, &UdpConfig);
 410
 411   if (EFI_ERROR (Status)) {
 412     return Status;
 413   }
 414
 415   //
 416   // join the multicast group
 417   //
 418   Ip = HTONL (Instance->McastIp);
 419   NetCopyMem (&Group, &Ip, sizeof (EFI_IPv4_ADDRESS));
 420
 421   return McastIo->Udp->Groups (McastIo->Udp, TRUE, &Group);
 422 }
 423
 424
 425 /**
 426   Function to process the OACK. It will first validate the OACK
 427   packet, then update the various negotiated parameters.
 428
 429   @param  Instance              The download MTFTP session
 430   @param  Packet                The packet received
 431   @param  Len                   The packet length
 432   @param  Multicast             Whether this packet is received as a multicast
 433   @param  Completed             Returns whether the download has completed. NOT
 434                                 used  by this function.
 435
 436   @retval EFI_DEVICE_ERROR      Failed to create/start a multicast UDP child
 437   @retval EFI_TFTP_ERROR        Some error happened during the process
 438   @retval EFI_SUCCESS           The OACK is successfully processed.
 439
 440 **/
 441 EFI_STATUS
 442 Mtftp4RrqHandleOack (
 443   IN  MTFTP4_PROTOCOL       *Instance,
 444   IN  EFI_MTFTP4_PACKET     *Packet,
 445   IN  UINT32                Len,
 446   IN  BOOLEAN               Multicast,
 447   OUT BOOLEAN               *Completed
 448   )
 449 {
 450   MTFTP4_OPTION             Reply;
 451   EFI_STATUS                Status;
 452   INTN                      Expected;
 453
 454   *Completed = FALSE;
 455
 456   //
 457   // If already started the master download, don't change the
 458   // setting. Master download always succeeds.
 459   //
 460   Expected = Mtftp4GetNextBlockNum (&Instance->Blocks);
 461   ASSERT (Expected != -1);
 462
 463   if (Instance->Master && (Expected != 1)) {
 464     return EFI_SUCCESS;
 465   }
 466
 467   //
 468   // Parse and validate the options from server
 469   //
 470   NetZeroMem (&Reply, sizeof (MTFTP4_OPTION));
 471
 472   Status = Mtftp4ParseOptionOack (Packet, Len, &Reply);
 473
 474   if (EFI_ERROR (Status) ||
 475       !Mtftp4RrqOackValid (Instance, &Reply, &Instance->RequestOption)) {
 476     //
 477     // Don't send an ERROR packet if the error is EFI_OUT_OF_RESOURCES.
 478     //
 479     if (Status != EFI_OUT_OF_RESOURCES) {
 480       Mtftp4SendError (
 481         Instance,
 482         EFI_MTFTP4_ERRORCODE_ILLEGAL_OPERATION,
 483         (UINT8 *) "Mal-formated OACK packet"
 484         );
 485     }
 486
 487     return EFI_TFTP_ERROR;
 488   }
 489
 490   if (Reply.Exist & MTFTP4_MCAST_EXIST) {
 491
 492     //
 493     // Save the multicast info. Always update the Master, only update the
 494     // multicast IP address, block size, timeoute at the first time. If IP
 495     // address is updated, create a UDP child to receive the multicast.
 496     //
 497     Instance->Master = Reply.Master;
 498
 499     if (Instance->McastIp == 0) {
 500       if ((Reply.McastIp == 0) || (Reply.McastPort == 0)) {
 501         Mtftp4SendError (
 502           Instance,
 503           EFI_MTFTP4_ERRORCODE_ILLEGAL_OPERATION,
 504           (UINT8 *) "Illegal multicast setting"
 505           );
 506
 507         return EFI_TFTP_ERROR;
 508       }
 509
 510       //
 511       // Create a UDP child then start receive the multicast from it.
 512       //
 513       Instance->McastIp      = Reply.McastIp;
 514       Instance->McastPort    = Reply.McastPort;
 515       Instance->McastUdpPort = UdpIoCreatePort (
 516                                  Instance->Service->Controller,
 517                                  Instance->Service->Image,
 518                                  Mtftp4RrqConfigMcastPort,
 519                                  Instance
 520                                  );
 521
 522       if (Instance->McastUdpPort == NULL) {
 523         return EFI_DEVICE_ERROR;
 524       }
 525
 526       Status = UdpIoRecvDatagram (Instance->McastUdpPort, Mtftp4RrqInput, Instance, 0);
 527
 528       if (EFI_ERROR (Status)) {
 529         Mtftp4SendError (
 530           Instance,
 531           EFI_MTFTP4_ERRORCODE_ACCESS_VIOLATION,
 532           (UINT8 *) "Failed to create socket to receive multicast packet"
 533           );
 534
 535         return Status;
 536       }
 537
 538       //
 539       // Update the parameters used.
 540       //
 541       if (Reply.BlkSize != 0) {
 542         Instance->BlkSize = Reply.BlkSize;
 543       }
 544
 545       if (Reply.Timeout != 0) {
 546         Instance->Timeout = Reply.Timeout;
 547       }
 548     }
 549
 550   } else {
 551     Instance->Master = TRUE;
 552
 553     if (Reply.BlkSize != 0) {
 554       Instance->BlkSize = Reply.BlkSize;
 555     }
 556
 557     if (Reply.Timeout != 0) {
 558       Instance->Timeout = Reply.Timeout;
 559     }
 560   }
 561
 562   //
 563   // Send an ACK to (Expected - 1) which is 0 for unicast download,
 564   // or tell the server we want to receive the Expected block.
 565   //
 566   return Mtftp4RrqSendAck (Instance, (UINT16) (Expected - 1));
 567 }
 568
 569
 570 /**
 571   The packet process callback for MTFTP download.
 572
 573   @param  UdpPacket             The packet received
 574   @param  Points                The local/remote access point of the packet
 575   @param  IoStatus              The status of the receiving
 576   @param  Context               Opaque parameter, which is the MTFTP session
 577
 578   @return None
 579
 580 **/
 581 VOID
 582 Mtftp4RrqInput (
 583   IN NET_BUF                *UdpPacket,
 584   IN UDP_POINTS             *Points,
 585   IN EFI_STATUS             IoStatus,
 586   IN VOID                   *Context
 587   )
 588 {
 589   MTFTP4_PROTOCOL           *Instance;
 590   EFI_MTFTP4_PACKET         *Packet;
 591   BOOLEAN                   Completed;
 592   BOOLEAN                   Multicast;
 593   EFI_STATUS                Status;
 594   UINT16                    Opcode;
 595   UINT32                    Len;
 596
 597   Instance  = (MTFTP4_PROTOCOL *) Context;
 598   NET_CHECK_SIGNATURE (Instance, MTFTP4_PROTOCOL_SIGNATURE);
 599
 600   Status    = EFI_SUCCESS;
 601   Packet    = NULL;
 602   Completed = FALSE;
 603   Multicast = FALSE;
 604
 605   if (EFI_ERROR (IoStatus)) {
 606     Status = IoStatus;
 607     goto ON_EXIT;
 608   }
 609
 610   ASSERT (UdpPacket != NULL);
 611
 612   //
 613   // Find the port this packet is from to restart receive correctly.
 614   //
 615   Multicast = (BOOLEAN) (Points->LocalAddr == Instance->McastIp);
 616
 617   if (UdpPacket->TotalSize < MTFTP4_OPCODE_LEN) {
 618     goto ON_EXIT;
 619   }
 620
 621   //
 622   // Client send initial request to server's listening port. Server
 623   // will select a UDP port to communicate with the client. The server
 624   // is required to use the same port as RemotePort to multicast the
 625   // data.
 626   //
 627   if (Points->RemotePort != Instance->ConnectedPort) {
 628     if (Instance->ConnectedPort != 0) {
 629       goto ON_EXIT;
 630     } else {
 631       Instance->ConnectedPort = Points->RemotePort;
 632     }
 633   }
 634
 635   //
 636   // Copy the MTFTP packet to a continuous buffer if it isn't already so.
 637   //
 638   Len = UdpPacket->TotalSize;
 639
 640   if (UdpPacket->BlockOpNum > 1) {
 641     Packet = NetAllocatePool (Len);
 642
 643     if (Packet == NULL) {
 644       Status = EFI_OUT_OF_RESOURCES;
 645       goto ON_EXIT;
 646     }
 647
 648     NetbufCopy (UdpPacket, 0, Len, (UINT8 *) Packet);
 649
 650   } else {
 651     Packet = (EFI_MTFTP4_PACKET *) NetbufGetByte (UdpPacket, 0, NULL);
 652   }
 653
 654   Opcode = NTOHS (Packet->OpCode);
 655
 656   //
 657   // Call the user's CheckPacket if provided. Abort the transmission
 658   // if CheckPacket returns an EFI_ERROR code.
 659   //
 660   if ((Instance->Token->CheckPacket != NULL) &&
 661       ((Opcode == EFI_MTFTP4_OPCODE_OACK) || (Opcode == EFI_MTFTP4_OPCODE_ERROR))) {
 662
 663     Status = Instance->Token->CheckPacket (
 664                                 &Instance->Mtftp4,
 665                                 Instance->Token,
 666                                 (UINT16) Len,
 667                                 Packet
 668                                 );
 669
 670     if (EFI_ERROR (Status)) {
 671       //
 672       // Send an error message to the server to inform it
 673       //
 674       if (Opcode != EFI_MTFTP4_OPCODE_ERROR) {
 675         Mtftp4SendError (
 676           Instance,
 677           EFI_MTFTP4_ERRORCODE_REQUEST_DENIED,
 678           (UINT8 *) "User aborted the transfer"
 679           );
 680       }
 681
 682       Status = EFI_ABORTED;
 683       goto ON_EXIT;
 684     }
 685   }
 686
 687   switch (Opcode) {
 688   case EFI_MTFTP4_OPCODE_DATA:
 689     if ((Len > (UINT32) (MTFTP4_DATA_HEAD_LEN + Instance->BlkSize)) ||
 690         (Len < (UINT32) MTFTP4_DATA_HEAD_LEN)) {
 691       goto ON_EXIT;
 692     }
 693
 694     Status = Mtftp4RrqHandleData (Instance, Packet, Len, Multicast, &Completed);
 695     break;
 696
 697   case EFI_MTFTP4_OPCODE_OACK:
 698     if (Multicast || (Len <= MTFTP4_OPCODE_LEN)) {
 699       goto ON_EXIT;
 700     }
 701
 702     Status = Mtftp4RrqHandleOack (Instance, Packet, Len, Multicast, &Completed);
 703     break;
 704
 705   case EFI_MTFTP4_OPCODE_ERROR:
 706     Status = EFI_TFTP_ERROR;
 707     break;
 708   }
 709
 710 ON_EXIT:
 711
 712   //
 713   // Free the resources, then if !EFI_ERROR (Status), restart the
 714   // receive, otherwise end the session.
 715   //
 716   if ((Packet != NULL) && (UdpPacket->BlockOpNum > 1)) {
 717     NetFreePool (Packet);
 718   }
 719
 720   if (UdpPacket != NULL) {
 721     NetbufFree (UdpPacket);
 722   }
 723
 724   if (!EFI_ERROR (Status) && !Completed) {
 725     if (Multicast) {
 726       Status = UdpIoRecvDatagram (Instance->McastUdpPort, Mtftp4RrqInput, Instance, 0);
 727     } else {
 728       Status = UdpIoRecvDatagram (Instance->UnicastPort, Mtftp4RrqInput, Instance, 0);
 729     }
 730   }
 731
 732   if (EFI_ERROR (Status) || Completed) {
 733     Mtftp4CleanOperation (Instance, Status);
 734   }
 735 }