MdeModulePkg/Universal/Network/Mtftp4Dxe/Mtftp4Rrq.c

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