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   if (!Config->UseDefaultSetting && !EFI_IP4_EQUAL (&mZeroIp4Addr, &Config->GatewayIp)) {
 416     //
 417     // The station IP address is manually configured and the Gateway IP is not 0.
 418     // Add the default route for this UDP instance.
 419     //
 420     Status = McastIo->Udp->Routes (McastIo->Udp, FALSE, &mZeroIp4Addr, &mZeroIp4Addr, &Config->GatewayIp);
 421     if (EFI_ERROR (Status)) {
 422       McastIo->Udp->Configure (McastIo->Udp, NULL);
 423       return Status;
 424     }
 425   }
 426
 427   //
 428   // join the multicast group
 429   //
 430   Ip = HTONL (Instance->McastIp);
 431   NetCopyMem (&Group, &Ip, sizeof (EFI_IPv4_ADDRESS));
 432
 433   return McastIo->Udp->Groups (McastIo->Udp, TRUE, &Group);
 434 }
 435
 436
 437 /**
 438   Function to process the OACK. It will first validate the OACK
 439   packet, then update the various negotiated parameters.
 440
 441   @param  Instance              The download MTFTP session
 442   @param  Packet                The packet received
 443   @param  Len                   The packet length
 444   @param  Multicast             Whether this packet is received as a multicast
 445   @param  Completed             Returns whether the download has completed. NOT
 446                                 used  by this function.
 447
 448   @retval EFI_DEVICE_ERROR      Failed to create/start a multicast UDP child
 449   @retval EFI_TFTP_ERROR        Some error happened during the process
 450   @retval EFI_SUCCESS           The OACK is successfully processed.
 451
 452 **/
 453 EFI_STATUS
 454 Mtftp4RrqHandleOack (
 455   IN  MTFTP4_PROTOCOL       *Instance,
 456   IN  EFI_MTFTP4_PACKET     *Packet,
 457   IN  UINT32                Len,
 458   IN  BOOLEAN               Multicast,
 459   OUT BOOLEAN               *Completed
 460   )
 461 {
 462   MTFTP4_OPTION             Reply;
 463   EFI_STATUS                Status;
 464   INTN                      Expected;
 465
 466   *Completed = FALSE;
 467
 468   //
 469   // If already started the master download, don't change the
 470   // setting. Master download always succeeds.
 471   //
 472   Expected = Mtftp4GetNextBlockNum (&Instance->Blocks);
 473   ASSERT (Expected != -1);
 474
 475   if (Instance->Master && (Expected != 1)) {
 476     return EFI_SUCCESS;
 477   }
 478
 479   //
 480   // Parse and validate the options from server
 481   //
 482   NetZeroMem (&Reply, sizeof (MTFTP4_OPTION));
 483
 484   Status = Mtftp4ParseOptionOack (Packet, Len, &Reply);
 485
 486   if (EFI_ERROR (Status) ||
 487       !Mtftp4RrqOackValid (Instance, &Reply, &Instance->RequestOption)) {
 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       Mtftp4SendError (
 493         Instance,
 494         EFI_MTFTP4_ERRORCODE_ILLEGAL_OPERATION,
 495         (UINT8 *) "Mal-formated OACK packet"
 496         );
 497     }
 498
 499     return EFI_TFTP_ERROR;
 500   }
 501
 502   if (Reply.Exist & MTFTP4_MCAST_EXIST) {
 503
 504     //
 505     // Save the multicast info. Always update the Master, only update the
 506     // multicast IP address, block size, timeoute at the first time. If IP
 507     // address is updated, create a UDP child to receive the multicast.
 508     //
 509     Instance->Master = Reply.Master;
 510
 511     if (Instance->McastIp == 0) {
 512       if ((Reply.McastIp == 0) || (Reply.McastPort == 0)) {
 513         Mtftp4SendError (
 514           Instance,
 515           EFI_MTFTP4_ERRORCODE_ILLEGAL_OPERATION,
 516           (UINT8 *) "Illegal multicast setting"
 517           );
 518
 519         return EFI_TFTP_ERROR;
 520       }
 521
 522       //
 523       // Create a UDP child then start receive the multicast from it.
 524       //
 525       Instance->McastIp      = Reply.McastIp;
 526       Instance->McastPort    = Reply.McastPort;
 527       Instance->McastUdpPort = UdpIoCreatePort (
 528                                  Instance->Service->Controller,
 529                                  Instance->Service->Image,
 530                                  Mtftp4RrqConfigMcastPort,
 531                                  Instance
 532                                  );
 533
 534       if (Instance->McastUdpPort == NULL) {
 535         return EFI_DEVICE_ERROR;
 536       }
 537
 538       Status = UdpIoRecvDatagram (Instance->McastUdpPort, Mtftp4RrqInput, Instance, 0);
 539
 540       if (EFI_ERROR (Status)) {
 541         Mtftp4SendError (
 542           Instance,
 543           EFI_MTFTP4_ERRORCODE_ACCESS_VIOLATION,
 544           (UINT8 *) "Failed to create socket to receive multicast packet"
 545           );
 546
 547         return Status;
 548       }
 549
 550       //
 551       // Update the parameters used.
 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   } else {
 563     Instance->Master = TRUE;
 564
 565     if (Reply.BlkSize != 0) {
 566       Instance->BlkSize = Reply.BlkSize;
 567     }
 568
 569     if (Reply.Timeout != 0) {
 570       Instance->Timeout = Reply.Timeout;
 571     }
 572   }
 573
 574   //
 575   // Send an ACK to (Expected - 1) which is 0 for unicast download,
 576   // or tell the server we want to receive the Expected block.
 577   //
 578   return Mtftp4RrqSendAck (Instance, (UINT16) (Expected - 1));
 579 }
 580
 581
 582 /**
 583   The packet process callback for MTFTP download.
 584
 585   @param  UdpPacket             The packet received
 586   @param  Points                The local/remote access point of the packet
 587   @param  IoStatus              The status of the receiving
 588   @param  Context               Opaque parameter, which is the MTFTP session
 589
 590   @return None
 591
 592 **/
 593 VOID
 594 Mtftp4RrqInput (
 595   IN NET_BUF                *UdpPacket,
 596   IN UDP_POINTS             *Points,
 597   IN EFI_STATUS             IoStatus,
 598   IN VOID                   *Context
 599   )
 600 {
 601   MTFTP4_PROTOCOL           *Instance;
 602   EFI_MTFTP4_PACKET         *Packet;
 603   BOOLEAN                   Completed;
 604   BOOLEAN                   Multicast;
 605   EFI_STATUS                Status;
 606   UINT16                    Opcode;
 607   UINT32                    Len;
 608
 609   Instance  = (MTFTP4_PROTOCOL *) Context;
 610   NET_CHECK_SIGNATURE (Instance, MTFTP4_PROTOCOL_SIGNATURE);
 611
 612   Status    = EFI_SUCCESS;
 613   Packet    = NULL;
 614   Completed = FALSE;
 615   Multicast = FALSE;
 616
 617   if (EFI_ERROR (IoStatus)) {
 618     Status = IoStatus;
 619     goto ON_EXIT;
 620   }
 621
 622   ASSERT (UdpPacket != NULL);
 623
 624   //
 625   // Find the port this packet is from to restart receive correctly.
 626   //
 627   Multicast = (BOOLEAN) (Points->LocalAddr == Instance->McastIp);
 628
 629   if (UdpPacket->TotalSize < MTFTP4_OPCODE_LEN) {
 630     goto ON_EXIT;
 631   }
 632
 633   //
 634   // Client send initial request to server's listening port. Server
 635   // will select a UDP port to communicate with the client. The server
 636   // is required to use the same port as RemotePort to multicast the
 637   // data.
 638   //
 639   if (Points->RemotePort != Instance->ConnectedPort) {
 640     if (Instance->ConnectedPort != 0) {
 641       goto ON_EXIT;
 642     } else {
 643       Instance->ConnectedPort = Points->RemotePort;
 644     }
 645   }
 646
 647   //
 648   // Copy the MTFTP packet to a continuous buffer if it isn't already so.
 649   //
 650   Len = UdpPacket->TotalSize;
 651
 652   if (UdpPacket->BlockOpNum > 1) {
 653     Packet = NetAllocatePool (Len);
 654
 655     if (Packet == NULL) {
 656       Status = EFI_OUT_OF_RESOURCES;
 657       goto ON_EXIT;
 658     }
 659
 660     NetbufCopy (UdpPacket, 0, Len, (UINT8 *) Packet);
 661
 662   } else {
 663     Packet = (EFI_MTFTP4_PACKET *) NetbufGetByte (UdpPacket, 0, NULL);
 664   }
 665
 666   Opcode = NTOHS (Packet->OpCode);
 667
 668   //
 669   // Call the user's CheckPacket if provided. Abort the transmission
 670   // if CheckPacket returns an EFI_ERROR code.
 671   //
 672   if ((Instance->Token->CheckPacket != NULL) &&
 673       ((Opcode == EFI_MTFTP4_OPCODE_OACK) || (Opcode == EFI_MTFTP4_OPCODE_ERROR))) {
 674
 675     Status = Instance->Token->CheckPacket (
 676                                 &Instance->Mtftp4,
 677                                 Instance->Token,
 678                                 (UINT16) Len,
 679                                 Packet
 680                                 );
 681
 682     if (EFI_ERROR (Status)) {
 683       //
 684       // Send an error message to the server to inform it
 685       //
 686       if (Opcode != EFI_MTFTP4_OPCODE_ERROR) {
 687         Mtftp4SendError (
 688           Instance,
 689           EFI_MTFTP4_ERRORCODE_REQUEST_DENIED,
 690           (UINT8 *) "User aborted the transfer"
 691           );
 692       }
 693
 694       Status = EFI_ABORTED;
 695       goto ON_EXIT;
 696     }
 697   }
 698
 699   switch (Opcode) {
 700   case EFI_MTFTP4_OPCODE_DATA:
 701     if ((Len > (UINT32) (MTFTP4_DATA_HEAD_LEN + Instance->BlkSize)) ||
 702         (Len < (UINT32) MTFTP4_DATA_HEAD_LEN)) {
 703       goto ON_EXIT;
 704     }
 705
 706     Status = Mtftp4RrqHandleData (Instance, Packet, Len, Multicast, &Completed);
 707     break;
 708
 709   case EFI_MTFTP4_OPCODE_OACK:
 710     if (Multicast || (Len <= MTFTP4_OPCODE_LEN)) {
 711       goto ON_EXIT;
 712     }
 713
 714     Status = Mtftp4RrqHandleOack (Instance, Packet, Len, Multicast, &Completed);
 715     break;
 716
 717   case EFI_MTFTP4_OPCODE_ERROR:
 718     Status = EFI_TFTP_ERROR;
 719     break;
 720   }
 721
 722 ON_EXIT:
 723
 724   //
 725   // Free the resources, then if !EFI_ERROR (Status), restart the
 726   // receive, otherwise end the session.
 727   //
 728   if ((Packet != NULL) && (UdpPacket->BlockOpNum > 1)) {
 729     NetFreePool (Packet);
 730   }
 731
 732   if (UdpPacket != NULL) {
 733     NetbufFree (UdpPacket);
 734   }
 735
 736   if (!EFI_ERROR (Status) && !Completed) {
 737     if (Multicast) {
 738       Status = UdpIoRecvDatagram (Instance->McastUdpPort, Mtftp4RrqInput, Instance, 0);
 739     } else {
 740       Status = UdpIoRecvDatagram (Instance->UnicastPort, Mtftp4RrqInput, Instance, 0);
 741     }
 742   }
 743
 744   if (EFI_ERROR (Status) || Completed) {
 745     Mtftp4CleanOperation (Instance, Status);
 746   }
 747 }