MdeModulePkg/Universal/Network/Udp4Dxe/Udp4Main.c

   1 /** @file
   2
   3 Copyright (c) 2006 - 2009, Intel Corporation. All rights reserved.<BR>
   4 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 **/
  13
  14 #include "Udp4Impl.h"
  15
  16 EFI_UDP4_PROTOCOL  mUdp4Protocol = {
  17   Udp4GetModeData,
  18   Udp4Configure,
  19   Udp4Groups,
  20   Udp4Routes,
  21   Udp4Transmit,
  22   Udp4Receive,
  23   Udp4Cancel,
  24   Udp4Poll
  25 };
  26
  27
  28 /**
  29   Reads the current operational settings.
  30
  31   The GetModeData() function copies the current operational settings of this EFI
  32   UDPv4 Protocol instance into user-supplied buffers. This function is used
  33   optionally to retrieve the operational mode data of underlying networks or
  34   drivers.
  35
  36   @param[in]  This              Pointer to the EFI_UDP4_PROTOCOL instance.
  37   @param[out] Udp4ConfigData    Pointer to the buffer to receive the current configuration data.
  38   @param[out] Ip4ModeData       Pointer to the EFI IPv4 Protocol mode data structure.
  39   @param[out] MnpConfigData     Pointer to the managed network configuration data structure.
  40   @param[out] SnpModeData       Pointer to the simple network mode data structure.
  41
  42   @retval EFI_SUCCESS           The mode data was read.
  43   @retval EFI_NOT_STARTED       When Udp4ConfigData is queried, no configuration data is
  44                                 available because this instance has not been started.
  45   @retval EFI_INVALID_PARAMETER This is NULL.
  46
  47 **/
  48 EFI_STATUS
  49 EFIAPI
  50 Udp4GetModeData (
  51   IN  EFI_UDP4_PROTOCOL                *This,
  52   OUT EFI_UDP4_CONFIG_DATA             *Udp4ConfigData OPTIONAL,
  53   OUT EFI_IP4_MODE_DATA                *Ip4ModeData    OPTIONAL,
  54   OUT EFI_MANAGED_NETWORK_CONFIG_DATA  *MnpConfigData  OPTIONAL,
  55   OUT EFI_SIMPLE_NETWORK_MODE          *SnpModeData    OPTIONAL
  56   )
  57 {
  58   UDP4_INSTANCE_DATA  *Instance;
  59   EFI_IP4_PROTOCOL    *Ip;
  60   EFI_TPL             OldTpl;
  61   EFI_STATUS          Status;
  62
  63   if (This == NULL) {
  64     return EFI_INVALID_PARAMETER;
  65   }
  66
  67   Instance = UDP4_INSTANCE_DATA_FROM_THIS (This);
  68
  69   if (!Instance->Configured && (Udp4ConfigData != NULL)) {
  70     return EFI_NOT_STARTED;
  71   }
  72
  73   OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
  74
  75   if (Udp4ConfigData != NULL) {
  76     //
  77     // Set the Udp4ConfigData.
  78     //
  79     CopyMem (Udp4ConfigData, &Instance->ConfigData, sizeof (*Udp4ConfigData));
  80   }
  81
  82   Ip = Instance->IpInfo->Ip.Ip4;
  83
  84   //
  85   // Get the underlying Ip4ModeData, MnpConfigData and SnpModeData.
  86   //
  87   Status = Ip->GetModeData (Ip, Ip4ModeData, MnpConfigData, SnpModeData);
  88
  89   gBS->RestoreTPL (OldTpl);
  90
  91   return Status;
  92 }
  93
  94
  95 /**
  96   Initializes, changes, or resets the operational parameters for this instance of the EFI UDPv4
  97   Protocol.
  98
  99   The Configure() function is used to do the following:
 100   * Initialize and start this instance of the EFI UDPv4 Protocol.
 101   * Change the filtering rules and operational parameters.
 102   * Reset this instance of the EFI UDPv4 Protocol.
 103   Until these parameters are initialized, no network traffic can be sent or
 104   received by this instance. This instance can be also reset by calling Configure()
 105   with UdpConfigData set to NULL. Once reset, the receiving queue and transmitting
 106   queue are flushed and no traffic is allowed through this instance.
 107   With different parameters in UdpConfigData, Configure() can be used to bind
 108   this instance to specified port.
 109
 110   @param[in]  This              Pointer to the EFI_UDP4_PROTOCOL instance.
 111   @param[in]  UdpConfigData     Pointer to the buffer to receive the current configuration data.
 112
 113   @retval EFI_SUCCESS           The configuration settings were set, changed, or reset successfully.
 114   @retval EFI_NO_MAPPING        When using a default address, configuration (DHCP, BOOTP,
 115                                 RARP, etc.) is not finished yet.
 116   @retval EFI_INVALID_PARAMETER One or more following conditions are TRUE:
 117   @retval EFI_ALREADY_STARTED   The EFI UDPv4 Protocol instance is already started/configured
 118                                 and must be stopped/reset before it can be reconfigured.
 119   @retval EFI_ACCESS_DENIED     UdpConfigData. AllowDuplicatePort is FALSE
 120                                 and UdpConfigData.StationPort is already used by
 121                                 other instance.
 122   @retval EFI_OUT_OF_RESOURCES  The EFI UDPv4 Protocol driver cannot allocate memory for this
 123                                 EFI UDPv4 Protocol instance.
 124   @retval EFI_DEVICE_ERROR      An unexpected network or system error occurred and this instance
 125                                  was not opened.
 126
 127 **/
 128 EFI_STATUS
 129 EFIAPI
 130 Udp4Configure (
 131   IN EFI_UDP4_PROTOCOL     *This,
 132   IN EFI_UDP4_CONFIG_DATA  *UdpConfigData OPTIONAL
 133   )
 134 {
 135   EFI_STATUS           Status;
 136   UDP4_INSTANCE_DATA   *Instance;
 137   UDP4_SERVICE_DATA    *Udp4Service;
 138   EFI_TPL              OldTpl;
 139   IP4_ADDR             StationAddress;
 140   IP4_ADDR             SubnetMask;
 141   IP4_ADDR             RemoteAddress;
 142   EFI_IP4_CONFIG_DATA  Ip4ConfigData;
 143   IP4_ADDR             LocalAddr;
 144   IP4_ADDR             RemoteAddr;
 145
 146   if (This == NULL) {
 147     return EFI_INVALID_PARAMETER;
 148   }
 149
 150   Instance = UDP4_INSTANCE_DATA_FROM_THIS (This);
 151
 152   if (!Instance->Configured && (UdpConfigData == NULL)) {
 153     return EFI_SUCCESS;
 154   }
 155
 156   Udp4Service = Instance->Udp4Service;
 157   Status      = EFI_SUCCESS;
 158
 159   OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 160
 161   if (UdpConfigData != NULL) {
 162
 163     CopyMem (&StationAddress, &UdpConfigData->StationAddress, sizeof (IP4_ADDR));
 164     CopyMem (&SubnetMask, &UdpConfigData->SubnetMask, sizeof (IP4_ADDR));
 165     CopyMem (&RemoteAddress, &UdpConfigData->RemoteAddress, sizeof (IP4_ADDR));
 166
 167     StationAddress = NTOHL (StationAddress);
 168     SubnetMask     = NTOHL (SubnetMask);
 169     RemoteAddress  = NTOHL (RemoteAddress);
 170
 171
 172     if (!UdpConfigData->UseDefaultAddress &&
 173       (!IP4_IS_VALID_NETMASK (SubnetMask) ||
 174       !((StationAddress == 0) || NetIp4IsUnicast (StationAddress, SubnetMask)) ||
 175       !((RemoteAddress  == 0) || NetIp4IsUnicast (RemoteAddress, 0)))) {
 176       //
 177       // Don't use default address, and subnet mask is invalid or StationAddress is not
 178       // a valid unicast IPv4 address or RemoteAddress is not a valid unicast IPv4 address
 179       // if it is not 0.
 180       //
 181       Status = EFI_INVALID_PARAMETER;
 182       goto ON_EXIT;
 183     }
 184
 185     if (Instance->Configured) {
 186       //
 187       // The instance is already configured, try to do the re-configuration.
 188       //
 189       if (!Udp4IsReconfigurable (&Instance->ConfigData, UdpConfigData)) {
 190         //
 191         // If the new configuration data wants to change some unreconfigurable
 192         // settings, return EFI_ALREADY_STARTED.
 193         //
 194         Status = EFI_ALREADY_STARTED;
 195         goto ON_EXIT;
 196       }
 197
 198       //
 199       // Save the reconfigurable parameters.
 200       //
 201       Instance->ConfigData.TypeOfService   = UdpConfigData->TypeOfService;
 202       Instance->ConfigData.TimeToLive      = UdpConfigData->TimeToLive;
 203       Instance->ConfigData.DoNotFragment   = UdpConfigData->DoNotFragment;
 204       Instance->ConfigData.ReceiveTimeout  = UdpConfigData->ReceiveTimeout;
 205       Instance->ConfigData.TransmitTimeout = UdpConfigData->TransmitTimeout;
 206     } else {
 207       //
 208       // Construct the Ip configuration data from the UdpConfigData.
 209       //
 210       Udp4BuildIp4ConfigData (UdpConfigData, &Ip4ConfigData);
 211
 212       //
 213       // Configure the Ip instance wrapped in the IpInfo.
 214       //
 215       Status = IpIoConfigIp (Instance->IpInfo, &Ip4ConfigData);
 216       if (EFI_ERROR (Status)) {
 217         if (Status == EFI_NO_MAPPING) {
 218           Instance->IsNoMapping = TRUE;
 219         }
 220
 221         goto ON_EXIT;
 222       }
 223
 224       Instance->IsNoMapping = FALSE;
 225
 226       //
 227       // Save the configuration data.
 228       //
 229       CopyMem (&Instance->ConfigData, UdpConfigData, sizeof (Instance->ConfigData));
 230       Instance->ConfigData.StationAddress = Ip4ConfigData.StationAddress;
 231       Instance->ConfigData.SubnetMask     = Ip4ConfigData.SubnetMask;
 232
 233       //
 234       // Try to allocate the required port resource.
 235       //
 236       Status = Udp4Bind (&Udp4Service->ChildrenList, &Instance->ConfigData);
 237       if (EFI_ERROR (Status)) {
 238         //
 239         // Reset the ip instance if bind fails.
 240         //
 241         IpIoConfigIp (Instance->IpInfo, NULL);
 242         goto ON_EXIT;
 243       }
 244
 245       //
 246       // Pre calculate the checksum for the pseudo head, ignore the UDP length first.
 247       //
 248       CopyMem (&LocalAddr, &Instance->ConfigData.StationAddress, sizeof (IP4_ADDR));
 249       CopyMem (&RemoteAddr, &Instance->ConfigData.RemoteAddress, sizeof (IP4_ADDR));
 250       Instance->HeadSum = NetPseudoHeadChecksum (
 251                             LocalAddr,
 252                             RemoteAddr,
 253                             EFI_IP_PROTO_UDP,
 254                             0
 255                             );
 256
 257       Instance->Configured = TRUE;
 258     }
 259   } else {
 260     //
 261     // UdpConfigData is NULL, reset the instance.
 262     //
 263     Instance->Configured  = FALSE;
 264     Instance->IsNoMapping = FALSE;
 265
 266     //
 267     // Reset the Ip instance wrapped in the IpInfo.
 268     //
 269     IpIoConfigIp (Instance->IpInfo, NULL);
 270
 271     //
 272     // Cancel all the user tokens.
 273     //
 274     Instance->Udp4Proto.Cancel (&Instance->Udp4Proto, NULL);
 275
 276     //
 277     // Remove the buffered RxData for this instance.
 278     //
 279     Udp4FlushRcvdDgram (Instance);
 280
 281     ASSERT (IsListEmpty (&Instance->DeliveredDgramQue));
 282   }
 283
 284   Udp4SetVariableData (Instance->Udp4Service);
 285
 286 ON_EXIT:
 287
 288   gBS->RestoreTPL (OldTpl);
 289
 290   return Status;
 291 }
 292
 293
 294 /**
 295   Joins and leaves multicast groups.
 296
 297   The Groups() function is used to enable and disable the multicast group
 298   filtering. If the JoinFlag is FALSE and the MulticastAddress is NULL, then all
 299   currently joined groups are left.
 300
 301   @param[in]  This              Pointer to the EFI_UDP4_PROTOCOL instance.
 302   @param[in]  JoinFlag          Set to TRUE to join a multicast group. Set to FALSE to leave one
 303                                 or all multicast groups.
 304   @param[in]  MulticastAddress  Pointer to multicast group address to join or leave.
 305
 306   @retval EFI_SUCCESS           The operation completed successfully.
 307   @retval EFI_NOT_STARTED       The EFI UDPv4 Protocol instance has not been started.
 308   @retval EFI_NO_MAPPING        When using a default address, configuration (DHCP, BOOTP,
 309                                 RARP, etc.) is not finished yet.
 310   @retval EFI_OUT_OF_RESOURCES  Could not allocate resources to join the group.
 311   @retval EFI_INVALID_PARAMETER One or more of the following conditions is TRUE:
 312                                 - This is NULL.
 313                                 - JoinFlag is TRUE and MulticastAddress is NULL.
 314                                 - JoinFlag is TRUE and *MulticastAddress is not
 315                                   a valid multicast address.
 316   @retval EFI_ALREADY_STARTED   The group address is already in the group table (when
 317                                 JoinFlag is TRUE).
 318   @retval EFI_NOT_FOUND         The group address is not in the group table (when JoinFlag is
 319                                 FALSE).
 320   @retval EFI_DEVICE_ERROR      An unexpected system or network error occurred.
 321
 322 **/
 323 EFI_STATUS
 324 EFIAPI
 325 Udp4Groups (
 326   IN EFI_UDP4_PROTOCOL  *This,
 327   IN BOOLEAN            JoinFlag,
 328   IN EFI_IPv4_ADDRESS   *MulticastAddress OPTIONAL
 329   )
 330 {
 331   EFI_STATUS          Status;
 332   UDP4_INSTANCE_DATA  *Instance;
 333   EFI_IP4_PROTOCOL    *Ip;
 334   EFI_TPL             OldTpl;
 335   IP4_ADDR            McastIp;
 336
 337   if ((This == NULL) || (JoinFlag && (MulticastAddress == NULL))) {
 338     return EFI_INVALID_PARAMETER;
 339   }
 340
 341   McastIp = 0;
 342   if (JoinFlag) {
 343     CopyMem (&McastIp, MulticastAddress, sizeof (IP4_ADDR));
 344
 345     if (!IP4_IS_MULTICAST (NTOHL (McastIp))) {
 346       return EFI_INVALID_PARAMETER;
 347     }
 348   }
 349
 350   Instance = UDP4_INSTANCE_DATA_FROM_THIS (This);
 351
 352   if (Instance->IsNoMapping) {
 353     return EFI_NO_MAPPING;
 354   }
 355
 356   if (!Instance->Configured) {
 357     return EFI_NOT_STARTED;
 358   }
 359
 360   Ip = Instance->IpInfo->Ip.Ip4;
 361
 362   OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 363
 364   //
 365   // Invoke the Ip instance the Udp4 instance consumes to do the group operation.
 366   //
 367   Status = Ip->Groups (Ip, JoinFlag, MulticastAddress);
 368
 369   if (EFI_ERROR (Status)) {
 370     goto ON_EXIT;
 371   }
 372
 373   //
 374   // Keep a local copy of the configured multicast IPs because IpIo receives
 375   // datagrams from the 0 station address IP instance and then UDP delivers to
 376   // the matched instance. This copy of multicast IPs is used to avoid receive
 377   // the mutlicast datagrams destined to multicast IPs the other instances configured.
 378   //
 379   if (JoinFlag) {
 380
 381     NetMapInsertTail (&Instance->McastIps, (VOID *) (UINTN) McastIp, NULL);
 382   } else {
 383
 384     NetMapIterate (&Instance->McastIps, Udp4LeaveGroup, MulticastAddress);
 385   }
 386
 387 ON_EXIT:
 388
 389   gBS->RestoreTPL (OldTpl);
 390
 391   return Status;
 392 }
 393
 394
 395 /**
 396   Adds and deletes routing table entries.
 397
 398   The Routes() function adds a route to or deletes a route from the routing table.
 399   Routes are determined by comparing the SubnetAddress with the destination IP
 400   address and arithmetically AND-ing it with the SubnetMask. The gateway address
 401   must be on the same subnet as the configured station address.
 402   The default route is added with SubnetAddress and SubnetMask both set to 0.0.0.0.
 403   The default route matches all destination IP addresses that do not match any
 404   other routes.
 405   A zero GatewayAddress is a nonroute. Packets are sent to the destination IP
 406   address if it can be found in the Address Resolution Protocol (ARP) cache or
 407   on the local subnet. One automatic nonroute entry will be inserted into the
 408   routing table for outgoing packets that are addressed to a local subnet
 409   (gateway address of 0.0.0.0).
 410   Each instance of the EFI UDPv4 Protocol has its own independent routing table.
 411   Instances of the EFI UDPv4 Protocol that use the default IP address will also
 412   have copies of the routing table provided by the EFI_IP4_CONFIG_PROTOCOL. These
 413   copies will be updated automatically whenever the IP driver reconfigures its
 414   instances; as a result, the previous modification to these copies will be lost.
 415
 416   @param[in]  This              Pointer to the EFI_UDP4_PROTOCOL instance.
 417   @param[in]  DeleteRoute       Set to TRUE to delete this route from the routing table.
 418                                 Set to FALSE to add this route to the routing table.
 419   @param[in]  SubnetAddress     The destination network address that needs to be routed.
 420   @param[in]  SubnetMask        The subnet mask of SubnetAddress.
 421   @param[in]  GatewayAddress    The gateway IP address for this route.
 422
 423   @retval EFI_SUCCESS           The operation completed successfully.
 424   @retval EFI_NOT_STARTED       The EFI UDPv4 Protocol instance has not been started.
 425   @retval EFI_NO_MAPPING        When using a default address, configuration (DHCP, BOOTP,
 426                                 - RARP, etc.) is not finished yet.
 427   @retval EFI_INVALID_PARAMETER One or more parameters are invalid.
 428   @retval EFI_OUT_OF_RESOURCES  Could not add the entry to the routing table.
 429   @retval EFI_NOT_FOUND         This route is not in the routing table.
 430   @retval EFI_ACCESS_DENIED     The route is already defined in the routing table.
 431
 432 **/
 433 EFI_STATUS
 434 EFIAPI
 435 Udp4Routes (
 436   IN EFI_UDP4_PROTOCOL  *This,
 437   IN BOOLEAN            DeleteRoute,
 438   IN EFI_IPv4_ADDRESS   *SubnetAddress,
 439   IN EFI_IPv4_ADDRESS   *SubnetMask,
 440   IN EFI_IPv4_ADDRESS   *GatewayAddress
 441   )
 442 {
 443   UDP4_INSTANCE_DATA  *Instance;
 444   EFI_IP4_PROTOCOL    *Ip;
 445
 446   if (This == NULL) {
 447     return EFI_INVALID_PARAMETER;
 448   }
 449
 450   Instance = UDP4_INSTANCE_DATA_FROM_THIS (This);
 451
 452   if (Instance->IsNoMapping) {
 453     return EFI_NO_MAPPING;
 454   }
 455
 456   if (!Instance->Configured) {
 457     return EFI_NOT_STARTED;
 458   }
 459
 460   Ip = Instance->IpInfo->Ip.Ip4;
 461
 462   //
 463   // Invoke the Ip instance the Udp4 instance consumes to do the actual operation.
 464   //
 465   return Ip->Routes (Ip, DeleteRoute, SubnetAddress, SubnetMask, GatewayAddress);
 466 }
 467
 468
 469 /**
 470   Queues outgoing data packets into the transmit queue.
 471
 472   The Transmit() function places a sending request to this instance of the EFI
 473   UDPv4 Protocol, alongside the transmit data that was filled by the user. Whenever
 474   the packet in the token is sent out or some errors occur, the Token.Event will
 475   be signaled and Token.Status is updated. Providing a proper notification function
 476   and context for the event will enable the user to receive the notification and
 477   transmitting status.
 478
 479   @param[in]  This              Pointer to the EFI_UDP4_PROTOCOL instance.
 480   @param[in]  Token             Pointer to the completion token that will be placed into the
 481                                 transmit queue.
 482
 483   @retval EFI_SUCCESS           The data has been queued for transmission.
 484   @retval EFI_NOT_STARTED       This EFI UDPv4 Protocol instance has not been started.
 485   @retval EFI_NO_MAPPING        When using a default address, configuration (DHCP, BOOTP,
 486                                 RARP, etc.) is not finished yet.
 487   @retval EFI_INVALID_PARAMETER One or more parameters are invalid.
 488   @retval EFI_ACCESS_DENIED     The transmit completion token with the same
 489                                 Token.Event was already in the transmit queue.
 490   @retval EFI_NOT_READY         The completion token could not be queued because the
 491                                 transmit queue is full.
 492   @retval EFI_OUT_OF_RESOURCES  Could not queue the transmit data.
 493   @retval EFI_NOT_FOUND         There is no route to the destination network or address.
 494   @retval EFI_BAD_BUFFER_SIZE   The data length is greater than the maximum UDP packet
 495                                 size. Or the length of the IP header + UDP header + data
 496                                 length is greater than MTU if DoNotFragment is TRUE.
 497
 498 **/
 499 EFI_STATUS
 500 EFIAPI
 501 Udp4Transmit (
 502   IN EFI_UDP4_PROTOCOL          *This,
 503   IN EFI_UDP4_COMPLETION_TOKEN  *Token
 504   )
 505 {
 506   EFI_STATUS              Status;
 507   UDP4_INSTANCE_DATA      *Instance;
 508   EFI_TPL                 OldTpl;
 509   NET_BUF                 *Packet;
 510   EFI_UDP_HEADER         *Udp4Header;
 511   EFI_UDP4_CONFIG_DATA    *ConfigData;
 512   IP4_ADDR                Source;
 513   IP4_ADDR                Destination;
 514   EFI_UDP4_TRANSMIT_DATA  *TxData;
 515   EFI_UDP4_SESSION_DATA   *UdpSessionData;
 516   UDP4_SERVICE_DATA       *Udp4Service;
 517   IP_IO_OVERRIDE          Override;
 518   UINT16                  HeadSum;
 519   EFI_IP_ADDRESS          IpDestAddr;
 520
 521   if ((This == NULL) || (Token == NULL)) {
 522     return EFI_INVALID_PARAMETER;
 523   }
 524
 525   Instance = UDP4_INSTANCE_DATA_FROM_THIS (This);
 526
 527   if (Instance->IsNoMapping) {
 528     return EFI_NO_MAPPING;
 529   }
 530
 531   if (!Instance->Configured) {
 532     return EFI_NOT_STARTED;
 533   }
 534
 535   OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 536
 537   //
 538   // Validate the Token, if the token is invalid return the error code.
 539   //
 540   Status = Udp4ValidateTxToken (Instance, Token);
 541   if (EFI_ERROR (Status)) {
 542     goto ON_EXIT;
 543   }
 544
 545   if (EFI_ERROR (NetMapIterate (&Instance->TxTokens, Udp4TokenExist, Token)) ||
 546     EFI_ERROR (NetMapIterate (&Instance->RxTokens, Udp4TokenExist, Token))) {
 547     //
 548     // Try to find a duplicate token in the two token maps, if found, return
 549     // EFI_ACCESS_DENIED.
 550     //
 551     Status = EFI_ACCESS_DENIED;
 552     goto ON_EXIT;
 553   }
 554
 555   TxData = Token->Packet.TxData;
 556
 557   //
 558   // Create a net buffer to hold the user buffer and the udp header.
 559   //
 560   Packet = NetbufFromExt (
 561              (NET_FRAGMENT *)TxData->FragmentTable,
 562              TxData->FragmentCount,
 563              UDP4_HEADER_SIZE,
 564              0,
 565              Udp4NetVectorExtFree,
 566              NULL
 567              );
 568   if (Packet == NULL) {
 569     Status = EFI_OUT_OF_RESOURCES;
 570     goto ON_EXIT;
 571   }
 572
 573   //
 574   // Store the IpIo in ProtoData.
 575   //
 576   Udp4Service = Instance->Udp4Service;
 577   *((UINTN *) &Packet->ProtoData[0]) = (UINTN) (Udp4Service->IpIo);
 578
 579   Udp4Header = (EFI_UDP_HEADER *) NetbufAllocSpace (Packet, UDP4_HEADER_SIZE, TRUE);
 580   ASSERT (Udp4Header != NULL);
 581
 582   ConfigData = &Instance->ConfigData;
 583
 584   //
 585   // Fill the udp header.
 586   //
 587   Udp4Header->SrcPort      = HTONS (ConfigData->StationPort);
 588   Udp4Header->DstPort      = HTONS (ConfigData->RemotePort);
 589   Udp4Header->Length       = HTONS ((UINT16) Packet->TotalSize);
 590   Udp4Header->Checksum     = 0;
 591
 592   UdpSessionData = TxData->UdpSessionData;
 593   Override.Ip4OverrideData.SourceAddress = ConfigData->StationAddress;
 594
 595   if (UdpSessionData != NULL) {
 596     //
 597     // Set the SourceAddress, SrcPort and Destination according to the specified
 598     // UdpSessionData.
 599     //
 600     if (!EFI_IP4_EQUAL (&UdpSessionData->SourceAddress, &mZeroIp4Addr)) {
 601       CopyMem (&Override.Ip4OverrideData.SourceAddress, &UdpSessionData->SourceAddress, sizeof (EFI_IPv4_ADDRESS));
 602     }
 603
 604     if (UdpSessionData->SourcePort != 0) {
 605       Udp4Header->SrcPort = HTONS (UdpSessionData->SourcePort);
 606     }
 607
 608     if (UdpSessionData->DestinationPort != 0) {
 609       Udp4Header->DstPort = HTONS (UdpSessionData->DestinationPort);
 610     }
 611
 612     CopyMem (&Source, &Override.Ip4OverrideData.SourceAddress, sizeof (IP4_ADDR));
 613     CopyMem (&Destination, &UdpSessionData->DestinationAddress, sizeof (IP4_ADDR));
 614
 615     //
 616     // calculate the pseudo head checksum using the overridden parameters.
 617     //
 618     HeadSum = NetPseudoHeadChecksum (
 619                 Source,
 620                 Destination,
 621                 EFI_IP_PROTO_UDP,
 622                 0
 623                 );
 624   } else {
 625     //
 626     // UdpSessionData is NULL, use the address and port information previously configured.
 627     //
 628     CopyMem (&Destination, &ConfigData->RemoteAddress, sizeof (IP4_ADDR));
 629
 630     HeadSum = Instance->HeadSum;
 631   }
 632
 633   //
 634   // calculate the checksum.
 635   //
 636   Udp4Header->Checksum = Udp4Checksum (Packet, HeadSum);
 637   if (Udp4Header->Checksum == 0) {
 638     //
 639     // If the calculated checksum is 0, fill the Checksum field with all ones.
 640     //
 641     Udp4Header->Checksum = 0xffff;
 642   }
 643
 644   //
 645   // Fill the IpIo Override data.
 646   //
 647   if (TxData->GatewayAddress != NULL) {
 648     CopyMem (&Override.Ip4OverrideData.GatewayAddress, TxData->GatewayAddress, sizeof (EFI_IPv4_ADDRESS));
 649   } else {
 650     ZeroMem (&Override.Ip4OverrideData.GatewayAddress, sizeof (EFI_IPv4_ADDRESS));
 651   }
 652
 653   Override.Ip4OverrideData.Protocol                 = EFI_IP_PROTO_UDP;
 654   Override.Ip4OverrideData.TypeOfService            = ConfigData->TypeOfService;
 655   Override.Ip4OverrideData.TimeToLive               = ConfigData->TimeToLive;
 656   Override.Ip4OverrideData.DoNotFragment            = ConfigData->DoNotFragment;
 657
 658   //
 659   // Save the token into the TxToken map.
 660   //
 661   Status = NetMapInsertTail (&Instance->TxTokens, Token, Packet);
 662   if (EFI_ERROR (Status)) {
 663     goto FREE_PACKET;
 664   }
 665
 666   //
 667   // Send out this datagram through IpIo.
 668   //
 669   IpDestAddr.Addr[0] = Destination;
 670   Status = IpIoSend (
 671              Udp4Service->IpIo,
 672              Packet,
 673              Instance->IpInfo,
 674              Instance,
 675              Token,
 676              &IpDestAddr,
 677              &Override
 678              );
 679   if (EFI_ERROR (Status)) {
 680     //
 681     // Remove this token from the TxTokens.
 682     //
 683     Udp4RemoveToken (&Instance->TxTokens, Token);
 684   }
 685
 686 FREE_PACKET:
 687
 688   NetbufFree (Packet);
 689
 690 ON_EXIT:
 691
 692   gBS->RestoreTPL (OldTpl);
 693
 694   return Status;
 695 }
 696
 697
 698 /**
 699   Places an asynchronous receive request into the receiving queue.
 700
 701   The Receive() function places a completion token into the receive packet queue.
 702   This function is always asynchronous.
 703   The caller must fill in the Token.Event field in the completion token, and this
 704   field cannot be NULL. When the receive operation completes, the EFI UDPv4 Protocol
 705   driver updates the Token.Status and Token.Packet.RxData fields and the Token.Event
 706   is signaled. Providing a proper notification function and context for the event
 707   will enable the user to receive the notification and receiving status. That
 708   notification function is guaranteed to not be re-entered.
 709
 710   @param[in]  This              Pointer to the EFI_UDP4_PROTOCOL instance.
 711   @param[in]  Token             Pointer to a token that is associated with
 712                                 the receive data descriptor.
 713
 714   @retval EFI_SUCCESS           The receive completion token was cached.
 715   @retval EFI_NOT_STARTED       This EFI UDPv4 Protocol instance has not been started.
 716   @retval EFI_NO_MAPPING        When using a default address, configuration (DHCP, BOOTP, RARP, etc.)
 717                                 is not finished yet.
 718   @retval EFI_INVALID_PARAMETER One or more of the following conditions is TRUE:
 719   @retval EFI_OUT_OF_RESOURCES  The receive completion token could not be queued due to a lack of system
 720                                 resources (usually memory).
 721   @retval EFI_DEVICE_ERROR      An unexpected system or network error occurred.
 722   @retval EFI_ACCESS_DENIED     A receive completion token with the same Token.Event was already in
 723                                 the receive queue.
 724   @retval EFI_NOT_READY         The receive request could not be queued because the receive queue is full.
 725
 726 **/
 727 EFI_STATUS
 728 EFIAPI
 729 Udp4Receive (
 730   IN EFI_UDP4_PROTOCOL          *This,
 731   IN EFI_UDP4_COMPLETION_TOKEN  *Token
 732   )
 733 {
 734   EFI_STATUS          Status;
 735   UDP4_INSTANCE_DATA  *Instance;
 736   EFI_TPL             OldTpl;
 737
 738   if ((This == NULL) || (Token == NULL) || (Token->Event == NULL)) {
 739     return EFI_INVALID_PARAMETER;
 740   }
 741
 742   Instance = UDP4_INSTANCE_DATA_FROM_THIS (This);
 743
 744   if (Instance->IsNoMapping) {
 745     return EFI_NO_MAPPING;
 746   }
 747
 748   if (!Instance->Configured) {
 749     return EFI_NOT_STARTED;
 750   }
 751
 752   OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 753
 754   if (EFI_ERROR (NetMapIterate (&Instance->RxTokens, Udp4TokenExist, Token))||
 755     EFI_ERROR (NetMapIterate (&Instance->TxTokens, Udp4TokenExist, Token))) {
 756     //
 757     // Return EFI_ACCESS_DENIED if the specified token is already in the TxTokens or
 758     // RxTokens map.
 759     //
 760     Status = EFI_ACCESS_DENIED;
 761     goto ON_EXIT;
 762   }
 763
 764   Token->Packet.RxData = NULL;
 765
 766   //
 767   // Save the token into the RxTokens map.
 768   //
 769   Status = NetMapInsertTail (&Instance->RxTokens, Token, NULL);
 770   if (EFI_ERROR (Status)) {
 771     Status = EFI_NOT_READY;
 772     goto ON_EXIT;
 773   }
 774
 775   //
 776   // If there is an icmp error, report it.
 777   //
 778   Udp4ReportIcmpError (Instance);
 779
 780   //
 781   // Try to deliver the received datagrams.
 782   //
 783   Udp4InstanceDeliverDgram (Instance);
 784
 785   //
 786   // Dispatch the DPC queued by the NotifyFunction of Token->Event.
 787   //
 788   DispatchDpc ();
 789
 790 ON_EXIT:
 791
 792   gBS->RestoreTPL (OldTpl);
 793
 794   return Status;
 795 }
 796
 797
 798 /**
 799   Aborts an asynchronous transmit or receive request.
 800
 801   The Cancel() function is used to abort a pending transmit or receive request.
 802   If the token is in the transmit or receive request queues, after calling this
 803   function, Token.Status will be set to EFI_ABORTED and then Token.Event will be
 804   signaled. If the token is not in one of the queues, which usually means that
 805   the asynchronous operation has completed, this function will not signal the
 806   token and EFI_NOT_FOUND is returned.
 807
 808   @param[in]  This  Pointer to the EFI_UDP4_PROTOCOL instance.
 809   @param[in]  Token Pointer to a token that has been issued by
 810                     EFI_UDP4_PROTOCOL.Transmit() or
 811                     EFI_UDP4_PROTOCOL.Receive().If NULL, all pending
 812                     tokens are aborted.
 813
 814   @retval  EFI_SUCCESS           The asynchronous I/O request was aborted and Token.Event
 815                                  was signaled. When Token is NULL, all pending requests are
 816                                  aborted and their events are signaled.
 817   @retval  EFI_INVALID_PARAMETER This is NULL.
 818   @retval  EFI_NOT_STARTED       This instance has not been started.
 819   @retval  EFI_NO_MAPPING        When using the default address, configuration (DHCP, BOOTP,
 820                                  RARP, etc.) is not finished yet.
 821   @retval  EFI_NOT_FOUND         When Token is not NULL, the asynchronous I/O request was
 822                                  not found in the transmit or receive queue. It has either completed
 823                                  or was not issued by Transmit() and Receive().
 824
 825 **/
 826 EFI_STATUS
 827 EFIAPI
 828 Udp4Cancel (
 829   IN EFI_UDP4_PROTOCOL          *This,
 830   IN EFI_UDP4_COMPLETION_TOKEN  *Token OPTIONAL
 831   )
 832 {
 833   EFI_STATUS          Status;
 834   UDP4_INSTANCE_DATA  *Instance;
 835   EFI_TPL             OldTpl;
 836
 837   if (This == NULL) {
 838     return EFI_INVALID_PARAMETER;
 839   }
 840
 841   Instance = UDP4_INSTANCE_DATA_FROM_THIS (This);
 842
 843   if (Instance->IsNoMapping) {
 844     return EFI_NO_MAPPING;
 845   }
 846
 847   if (!Instance->Configured) {
 848     return EFI_NOT_STARTED;
 849   }
 850
 851   OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 852
 853   //
 854   // Cancle the tokens specified by Token for this instance.
 855   //
 856   Status = Udp4InstanceCancelToken (Instance, Token);
 857
 858   //
 859   // Dispatch the DPC queued by the NotifyFunction of the cancelled token's events.
 860   //
 861   DispatchDpc ();
 862
 863   gBS->RestoreTPL (OldTpl);
 864
 865   return Status;
 866 }
 867
 868
 869 /**
 870   Polls for incoming data packets and processes outgoing data packets.
 871
 872   The Poll() function can be used by network drivers and applications to increase
 873   the rate that data packets are moved between the communications device and the
 874   transmit and receive queues.
 875   In some systems, the periodic timer event in the managed network driver may not
 876   poll the underlying communications device fast enough to transmit and/or receive
 877   all data packets without missing incoming packets or dropping outgoing packets.
 878   Drivers and applications that are experiencing packet loss should try calling
 879   the Poll() function more often.
 880
 881   @param[in]  This  Pointer to the EFI_UDP4_PROTOCOL instance.
 882
 883   @retval EFI_SUCCESS           Incoming or outgoing data was processed.
 884   @retval EFI_INVALID_PARAMETER This is NULL.
 885   @retval EFI_DEVICE_ERROR      An unexpected system or network error occurred.
 886   @retval EFI_TIMEOUT           Data was dropped out of the transmit and/or receive queue.
 887
 888 **/
 889 EFI_STATUS
 890 EFIAPI
 891 Udp4Poll (
 892   IN EFI_UDP4_PROTOCOL  *This
 893   )
 894 {
 895   UDP4_INSTANCE_DATA  *Instance;
 896   EFI_IP4_PROTOCOL    *Ip;
 897
 898   if (This == NULL) {
 899     return EFI_INVALID_PARAMETER;
 900   }
 901
 902   Instance = UDP4_INSTANCE_DATA_FROM_THIS (This);
 903   Ip       = Instance->IpInfo->Ip.Ip4;
 904
 905   //
 906   // Invode the Ip instance consumed by the udp instance to do the poll operation.
 907   //
 908   return Ip->Poll (Ip);
 909 }