NetworkPkg/Ip6Dxe/Ip6Impl.c

   1 /** @file
   2   Implementation of EFI_IP6_PROTOCOL protocol interfaces.
   3
   4   Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved.<BR>
   5
   6   This program and the accompanying materials
   7   are licensed and made available under the terms and conditions of the BSD License
   8   which accompanies this distribution.  The full text of the license may be found at
   9   http://opensource.org/licenses/bsd-license.php.
  10
  11   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  12   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  13
  14 **/
  15
  16 #include "Ip6Impl.h"
  17
  18 EFI_IPSEC2_PROTOCOL    *mIpSec = NULL;
  19
  20 EFI_IP6_PROTOCOL mEfiIp6ProtocolTemplete = {
  21   EfiIp6GetModeData,
  22   EfiIp6Configure,
  23   EfiIp6Groups,
  24   EfiIp6Routes,
  25   EfiIp6Neighbors,
  26   EfiIp6Transmit,
  27   EfiIp6Receive,
  28   EfiIp6Cancel,
  29   EfiIp6Poll
  30 };
  31
  32 /**
  33   Gets the current operational settings for this instance of the EFI IPv6 Protocol driver.
  34
  35   The GetModeData() function returns the current operational mode data for this driver instance.
  36   The data fields in EFI_IP6_MODE_DATA are read only. This function is used optionally to
  37   retrieve the operational mode data of underlying networks or drivers.
  38
  39   @param[in]  This               Pointer to the EFI_IP6_PROTOCOL instance.
  40   @param[out] Ip6ModeData        Pointer to the EFI IPv6 Protocol mode data structure.
  41   @param[out] MnpConfigData      Pointer to the managed network configuration data structure.
  42   @param[out] SnpModeData        Pointer to the simple network mode data structure.
  43
  44   @retval EFI_SUCCESS            The operation completed successfully.
  45   @retval EFI_INVALID_PARAMETER  This is NULL.
  46   @retval EFI_OUT_OF_RESOURCES   The required mode data could not be allocated.
  47
  48 **/
  49 EFI_STATUS
  50 EFIAPI
  51 EfiIp6GetModeData (
  52   IN EFI_IP6_PROTOCOL                 *This,
  53   OUT EFI_IP6_MODE_DATA               *Ip6ModeData     OPTIONAL,
  54   OUT EFI_MANAGED_NETWORK_CONFIG_DATA *MnpConfigData   OPTIONAL,
  55   OUT EFI_SIMPLE_NETWORK_MODE         *SnpModeData     OPTIONAL
  56   )
  57 {
  58   IP6_PROTOCOL              *IpInstance;
  59   IP6_SERVICE               *IpSb;
  60   IP6_INTERFACE             *IpIf;
  61   EFI_IP6_CONFIG_DATA       *Config;
  62   EFI_STATUS                Status;
  63   EFI_TPL                   OldTpl;
  64
  65   if (This == NULL) {
  66     return EFI_INVALID_PARAMETER;
  67   }
  68
  69   OldTpl     = gBS->RaiseTPL (TPL_CALLBACK);
  70   IpInstance = IP6_INSTANCE_FROM_PROTOCOL (This);
  71   IpSb       = IpInstance->Service;
  72   IpIf       = IpInstance->Interface;
  73
  74   if (IpSb->LinkLocalDadFail) {
  75     return EFI_INVALID_PARAMETER;
  76   }
  77
  78   if (Ip6ModeData != NULL) {
  79     //
  80     // IsStarted is "whether the EfiIp6Configure has been called".
  81     // IsConfigured is "whether the station address has been configured"
  82     //
  83     Ip6ModeData->IsStarted     = (BOOLEAN) (IpInstance->State == IP6_STATE_CONFIGED);
  84     Ip6ModeData->MaxPacketSize = IpSb->MaxPacketSize;
  85     CopyMem (&Ip6ModeData->ConfigData, &IpInstance->ConfigData, sizeof (EFI_IP6_CONFIG_DATA));
  86     Ip6ModeData->IsConfigured  = FALSE;
  87
  88     Ip6ModeData->AddressCount  = 0;
  89     Ip6ModeData->AddressList   = NULL;
  90
  91     Ip6ModeData->GroupCount    = IpInstance->GroupCount;
  92     Ip6ModeData->GroupTable    = NULL;
  93
  94     Ip6ModeData->RouteCount    = 0;
  95     Ip6ModeData->RouteTable    = NULL;
  96
  97     Ip6ModeData->NeighborCount = 0;
  98     Ip6ModeData->NeighborCache = NULL;
  99
 100     Ip6ModeData->PrefixCount   = 0;
 101     Ip6ModeData->PrefixTable   = NULL;
 102
 103     Ip6ModeData->IcmpTypeCount = 23;
 104     Ip6ModeData->IcmpTypeList  = AllocateCopyPool (
 105                                    Ip6ModeData->IcmpTypeCount * sizeof (EFI_IP6_ICMP_TYPE),
 106                                    mIp6SupportedIcmp
 107                                    );
 108     if (Ip6ModeData->IcmpTypeList == NULL) {
 109       Status = EFI_OUT_OF_RESOURCES;
 110       goto Error;
 111     }
 112
 113     //
 114     // Return the currently configured IPv6 addresses and corresponding prefix lengths.
 115     //
 116     Status = Ip6BuildEfiAddressList (
 117                IpSb,
 118                &Ip6ModeData->AddressCount,
 119                &Ip6ModeData->AddressList
 120                );
 121     if (EFI_ERROR (Status)) {
 122       goto Error;
 123     }
 124
 125     //
 126     // Return the current station address for this IP child.
 127     // If UseAnyStationAddress is set to TRUE, IP6 driver will
 128     // select a source address from its address list. Otherwise use the
 129     // StationAddress in config data.
 130     //
 131     if (Ip6ModeData->IsStarted) {
 132       Config = &Ip6ModeData->ConfigData;
 133
 134       if (IpIf->Configured || NetIp6IsUnspecifiedAddr (&Config->DestinationAddress)) {
 135         Ip6ModeData->IsConfigured = TRUE;
 136       } else {
 137         Ip6ModeData->IsConfigured = FALSE;
 138       }
 139
 140       //
 141       // Build a EFI route table for user from the internal route table.
 142       //
 143       Status = Ip6BuildEfiRouteTable (
 144                  IpSb->RouteTable,
 145                  &Ip6ModeData->RouteCount,
 146                  &Ip6ModeData->RouteTable
 147                  );
 148
 149       if (EFI_ERROR (Status)) {
 150         goto Error;
 151       }
 152     }
 153
 154     if (Ip6ModeData->IsConfigured) {
 155       //
 156       // Return the joined multicast group addresses.
 157       //
 158       if (IpInstance->GroupCount != 0) {
 159         Ip6ModeData->GroupTable = AllocateCopyPool (
 160                                     IpInstance->GroupCount * sizeof (EFI_IPv6_ADDRESS),
 161                                     IpInstance->GroupList
 162                                     );
 163         if (Ip6ModeData->GroupTable == NULL) {
 164           Status = EFI_OUT_OF_RESOURCES;
 165           goto Error;
 166         }
 167       }
 168       //
 169       // Return the neighbor cache entries
 170       //
 171       Status = Ip6BuildEfiNeighborCache (
 172                  IpInstance,
 173                  &Ip6ModeData->NeighborCount,
 174                  &Ip6ModeData->NeighborCache
 175                  );
 176       if (EFI_ERROR (Status)) {
 177         goto Error;
 178       }
 179
 180       //
 181       // Return the prefix table entries
 182       //
 183       Status = Ip6BuildPrefixTable (
 184                  IpInstance,
 185                  &Ip6ModeData->PrefixCount,
 186                  &Ip6ModeData->PrefixTable
 187                  );
 188       if (EFI_ERROR (Status)) {
 189         goto Error;
 190       }
 191
 192     }
 193   }
 194
 195   //
 196   // Get fresh mode data from MNP, since underlying media status may change
 197   //
 198   Status = IpSb->Mnp->GetModeData (IpSb->Mnp, MnpConfigData, SnpModeData);
 199
 200   goto Exit;
 201
 202 Error:
 203   if (Ip6ModeData != NULL) {
 204     if (Ip6ModeData->AddressList != NULL) {
 205       FreePool (Ip6ModeData->AddressList);
 206     }
 207
 208     if (Ip6ModeData->GroupTable != NULL) {
 209       FreePool (Ip6ModeData->GroupTable);
 210     }
 211
 212     if (Ip6ModeData->RouteTable != NULL) {
 213       FreePool (Ip6ModeData->RouteTable);
 214     }
 215
 216     if (Ip6ModeData->NeighborCache != NULL) {
 217       FreePool (Ip6ModeData->NeighborCache);
 218     }
 219
 220     if (Ip6ModeData->PrefixTable != NULL) {
 221       FreePool (Ip6ModeData->PrefixTable);
 222     }
 223
 224     if (Ip6ModeData->IcmpTypeList != NULL) {
 225       FreePool (Ip6ModeData->IcmpTypeList);
 226     }
 227   }
 228
 229 Exit:
 230   gBS->RestoreTPL (OldTpl);
 231   return Status;
 232 }
 233
 234 /**
 235   Validate that Ipv6 address is OK to be used as station address or next hop address/ neighbor.
 236
 237   @param[in]  IpSb               The IP6 service instance.
 238   @param[in]  Ip                 The IPv6 address to validate.
 239   @param[in]  Flag               If TRUE, validate if the address is OK to be used
 240                                  as station address. If FALSE, validate if the
 241                                  address is OK to be used as the next hop address/
 242                                  neighbor.
 243
 244   @retval TRUE                   The Ip address is valid and could be used.
 245   @retval FALSE                  Invalid Ip address.
 246
 247 **/
 248 BOOLEAN
 249 Ip6IsValidAddress (
 250   IN IP6_SERVICE            *IpSb,
 251   IN EFI_IPv6_ADDRESS       *Ip,
 252   IN BOOLEAN                Flag
 253   )
 254 {
 255   if (!NetIp6IsUnspecifiedAddr (Ip)) {
 256     if (!NetIp6IsValidUnicast(Ip)) {
 257       return FALSE;
 258     }
 259     if (Ip6IsOneOfSetAddress (IpSb, Ip, NULL, NULL)) {
 260       return Flag;
 261     }
 262   } else {
 263     return Flag;
 264   }
 265
 266   return (BOOLEAN) !Flag;
 267 }
 268
 269 /**
 270   Validate whether the value of protocol is illegal or not. Protocol is the 'Next Header' field
 271   in the last IPv6 extension header, or basic IPv6 header is there's no extension header.
 272
 273   @param[in]  Protocol           Default value of 'Next Header'
 274
 275   @retval TRUE                   The protocol is illegal.
 276   @retval FALSE                  The protocol is legal.
 277
 278 **/
 279 BOOLEAN
 280 Ip6IsIllegalProtocol (
 281   IN UINT8                  Protocol
 282   )
 283 {
 284   if (Protocol == IP6_HOP_BY_HOP || Protocol == EFI_IP_PROTO_ICMP || Protocol == IP4_PROTO_IGMP) {
 285     return TRUE;
 286   }
 287
 288   if (Protocol == 41 || Protocol == 43 || Protocol == 44 || Protocol == 59 || Protocol == 60 || Protocol == 124) {
 289     return TRUE;
 290   }
 291
 292   return FALSE;
 293 }
 294
 295 /**
 296   Intiialize the IP6_PROTOCOL structure to the unconfigured states.
 297
 298   @param[in]       IpSb                   The IP6 service instance.
 299   @param[in, out]  IpInstance             The IP6 child instance.
 300
 301 **/
 302 VOID
 303 Ip6InitProtocol (
 304   IN IP6_SERVICE            *IpSb,
 305   IN OUT IP6_PROTOCOL       *IpInstance
 306   )
 307 {
 308   ASSERT ((IpSb != NULL) && (IpInstance != NULL));
 309
 310   ZeroMem (IpInstance, sizeof (IP6_PROTOCOL));
 311
 312   IpInstance->Signature = IP6_PROTOCOL_SIGNATURE;
 313   IpInstance->State     = IP6_STATE_UNCONFIGED;
 314   IpInstance->Service   = IpSb;
 315   IpInstance->GroupList = NULL;
 316   CopyMem (&IpInstance->Ip6Proto, &mEfiIp6ProtocolTemplete, sizeof (EFI_IP6_PROTOCOL));
 317
 318   NetMapInit  (&IpInstance->RxTokens);
 319   NetMapInit  (&IpInstance->TxTokens);
 320   InitializeListHead (&IpInstance->Received);
 321   InitializeListHead (&IpInstance->Delivered);
 322
 323   EfiInitializeLock (&IpInstance->RecycleLock, TPL_NOTIFY);
 324 }
 325
 326 /**
 327   Configure the IP6 child. If the child is already configured,
 328   change the configuration parameter. Otherwise, configure it
 329   for the first time. The caller should validate the configuration
 330   before deliver them to it. It also don't do configure NULL.
 331
 332   @param[in, out]  IpInstance         The IP6 child to configure.
 333   @param[in]       Config             The configure data.
 334
 335   @retval EFI_SUCCESS            The IP6 child is successfully configured.
 336   @retval EFI_DEVICE_ERROR       Failed to free the pending transive or to
 337                                  configure  underlying MNP, or other errors.
 338   @retval EFI_NO_MAPPING         The IP6 child is configured to use the default
 339                                  address, but the default address hasn't been
 340                                  configured. The IP6 child doesn't need to be
 341                                  reconfigured when the default address is configured.
 342   @retval EFI_OUT_OF_RESOURCES   No more memory space is available.
 343   @retval other                  Other error occurs.
 344
 345 **/
 346 EFI_STATUS
 347 Ip6ConfigProtocol (
 348   IN OUT IP6_PROTOCOL        *IpInstance,
 349   IN     EFI_IP6_CONFIG_DATA *Config
 350   )
 351 {
 352   IP6_SERVICE               *IpSb;
 353   IP6_INTERFACE             *IpIf;
 354   EFI_STATUS                Status;
 355   EFI_IP6_CONFIG_DATA       *Current;
 356   IP6_ADDRESS_INFO          *AddressInfo;
 357   BOOLEAN                   StationZero;
 358   BOOLEAN                   DestZero;
 359   EFI_IPv6_ADDRESS          Source;
 360   BOOLEAN                   AddrOk;
 361
 362   IpSb    = IpInstance->Service;
 363   Current = &IpInstance->ConfigData;
 364
 365   //
 366   // User is changing packet filters. It must be stopped
 367   // before the station address can be changed.
 368   //
 369   if (IpInstance->State == IP6_STATE_CONFIGED) {
 370     //
 371     // Cancel all the pending transmit/receive from upper layer
 372     //
 373     Status = Ip6Cancel (IpInstance, NULL);
 374
 375     if (EFI_ERROR (Status)) {
 376       return EFI_DEVICE_ERROR;
 377     }
 378
 379     CopyMem (Current, Config, sizeof (EFI_IP6_CONFIG_DATA));
 380     return EFI_SUCCESS;
 381   }
 382
 383   //
 384   // Set up the interface.
 385   //
 386   StationZero = NetIp6IsUnspecifiedAddr (&Config->StationAddress);
 387   DestZero    = NetIp6IsUnspecifiedAddr (&Config->DestinationAddress);
 388
 389   if (StationZero && DestZero) {
 390     //
 391     // StationAddress is still zero.
 392     //
 393
 394     NET_GET_REF (IpSb->DefaultInterface);
 395     IpInstance->Interface = IpSb->DefaultInterface;
 396     InsertTailList (&IpSb->DefaultInterface->IpInstances, &IpInstance->AddrLink);
 397
 398     CopyMem (Current, Config, sizeof (EFI_IP6_CONFIG_DATA));
 399     IpInstance->State = IP6_STATE_CONFIGED;
 400
 401     return EFI_SUCCESS;
 402   }
 403
 404   if (StationZero && !DestZero) {
 405     Status = Ip6SelectSourceAddress (IpSb, &Config->DestinationAddress, &Source);
 406     if (EFI_ERROR (Status)) {
 407       return Status;
 408     }
 409   } else {
 410     IP6_COPY_ADDRESS (&Source, &Config->StationAddress);
 411   }
 412
 413   AddrOk = Ip6IsOneOfSetAddress (IpSb, &Source, &IpIf, &AddressInfo);
 414   if (AddrOk) {
 415     if (AddressInfo != NULL) {
 416       IpInstance->PrefixLength = AddressInfo->PrefixLength;
 417     } else {
 418       IpInstance->PrefixLength = IP6_LINK_LOCAL_PREFIX_LENGTH;
 419     }
 420   } else {
 421     //
 422     // The specified source address is not one of the addresses IPv6 maintains.
 423     //
 424     return EFI_INVALID_PARAMETER;
 425   }
 426
 427
 428   NET_GET_REF (IpIf);
 429   IpInstance->Interface = IpIf;
 430   InsertTailList (&IpIf->IpInstances, &IpInstance->AddrLink);
 431
 432   CopyMem (Current, Config, sizeof (EFI_IP6_CONFIG_DATA));
 433   IP6_COPY_ADDRESS (&Current->StationAddress, &Source);
 434   IpInstance->State = IP6_STATE_CONFIGED;
 435
 436   return EFI_SUCCESS;
 437 }
 438
 439 /**
 440   Clean up the IP6 child, and release all the resources used by it.
 441
 442   @param[in, out]  IpInstance    The IP6 child to clean up.
 443
 444   @retval EFI_SUCCESS            The IP6 child is cleaned up.
 445   @retval EFI_DEVICE_ERROR       Some resources failed to be released.
 446
 447 **/
 448 EFI_STATUS
 449 Ip6CleanProtocol (
 450   IN OUT IP6_PROTOCOL            *IpInstance
 451   )
 452 {
 453   if (EFI_ERROR (Ip6Cancel (IpInstance, NULL))) {
 454     return EFI_DEVICE_ERROR;
 455   }
 456
 457   if (EFI_ERROR (Ip6Groups (IpInstance, FALSE, NULL))) {
 458     return EFI_DEVICE_ERROR;
 459   }
 460
 461   //
 462   // Some packets haven't been recycled. It is because either the
 463   // user forgets to recycle the packets, or because the callback
 464   // hasn't been called. Just leave it alone.
 465   //
 466   if (!IsListEmpty (&IpInstance->Delivered)) {
 467     ;
 468   }
 469
 470   if (IpInstance->Interface != NULL) {
 471     RemoveEntryList (&IpInstance->AddrLink);
 472     Ip6CleanInterface (IpInstance->Interface, IpInstance);
 473     IpInstance->Interface = NULL;
 474   }
 475
 476   if (IpInstance->GroupList != NULL) {
 477     FreePool (IpInstance->GroupList);
 478     IpInstance->GroupList   = NULL;
 479     IpInstance->GroupCount  = 0;
 480   }
 481
 482   NetMapClean (&IpInstance->TxTokens);
 483
 484   NetMapClean (&IpInstance->RxTokens);
 485
 486   return EFI_SUCCESS;
 487 }
 488
 489 /**
 490   Configure the MNP parameter used by IP. The IP driver uses one MNP
 491   child to transmit/receive frames. By default, it configures MNP
 492   to receive unicast/multicast/broadcast. Also, it will enable/disable
 493   the promiscuous receive according to whether there is IP child
 494   enable that or not. If Force is FALSE, it will iterate through
 495   all the IP children to check whether the promiscuous receive
 496   setting has been changed. If it hasn't been changed, it won't
 497   reconfigure the MNP. If Force is TRUE, the MNP is configured
 498   whether that is changed or not.
 499
 500   @param[in]  IpSb               The IP6 service instance that is to be changed.
 501   @param[in]  Force              Force the configuration or not.
 502
 503   @retval EFI_SUCCESS            The MNP successfully configured/reconfigured.
 504   @retval Others                 Configuration failed.
 505
 506 **/
 507 EFI_STATUS
 508 Ip6ServiceConfigMnp (
 509   IN IP6_SERVICE            *IpSb,
 510   IN BOOLEAN                Force
 511   )
 512 {
 513   LIST_ENTRY                *Entry;
 514   LIST_ENTRY                *ProtoEntry;
 515   IP6_INTERFACE             *IpIf;
 516   IP6_PROTOCOL              *IpInstance;
 517   BOOLEAN                   Reconfig;
 518   BOOLEAN                   PromiscReceive;
 519   EFI_STATUS                Status;
 520
 521   Reconfig       = FALSE;
 522   PromiscReceive = FALSE;
 523
 524   if (!Force) {
 525     //
 526     // Iterate through the IP children to check whether promiscuous
 527     // receive setting has been changed. Update the interface's receive
 528     // filter also.
 529     //
 530     NET_LIST_FOR_EACH (Entry, &IpSb->Interfaces) {
 531
 532       IpIf              = NET_LIST_USER_STRUCT (Entry, IP6_INTERFACE, Link);
 533       IpIf->PromiscRecv = FALSE;
 534
 535       NET_LIST_FOR_EACH (ProtoEntry, &IpIf->IpInstances) {
 536         IpInstance = NET_LIST_USER_STRUCT (ProtoEntry, IP6_PROTOCOL, AddrLink);
 537
 538         if (IpInstance->ConfigData.AcceptPromiscuous) {
 539           IpIf->PromiscRecv = TRUE;
 540           PromiscReceive    = TRUE;
 541         }
 542       }
 543     }
 544
 545     //
 546     // If promiscuous receive isn't changed, it isn't necessary to reconfigure.
 547     //
 548     if (PromiscReceive == IpSb->MnpConfigData.EnablePromiscuousReceive) {
 549       return EFI_SUCCESS;
 550     }
 551
 552     Reconfig  = TRUE;
 553     IpSb->MnpConfigData.EnablePromiscuousReceive = PromiscReceive;
 554   }
 555
 556   Status = IpSb->Mnp->Configure (IpSb->Mnp, &IpSb->MnpConfigData);
 557
 558   //
 559   // recover the original configuration if failed to set the configure.
 560   //
 561   if (EFI_ERROR (Status) && Reconfig) {
 562     IpSb->MnpConfigData.EnablePromiscuousReceive = (BOOLEAN) !PromiscReceive;
 563   }
 564
 565   return Status;
 566 }
 567
 568 /**
 569   Assigns an IPv6 address and subnet mask to this EFI IPv6 Protocol driver instance.
 570
 571   The Configure() function is used to set, change, or reset the operational parameters and filter
 572   settings for this EFI IPv6 Protocol instance. Until these parameters have been set, no network traffic
 573   can be sent or received by this instance. Once the parameters have been reset (by calling this
 574   function with Ip6ConfigData set to NULL), no more traffic can be sent or received until these
 575   parameters have been set again. Each EFI IPv6 Protocol instance can be started and stopped
 576   independently of each other by enabling or disabling their receive filter settings with the
 577   Configure() function.
 578
 579   If Ip6ConfigData.StationAddress is a valid non-zero IPv6 unicast address, it is required
 580   to be one of the currently configured IPv6 addresses listed in the EFI IPv6 drivers, or else
 581   EFI_INVALID_PARAMETER will be returned. If Ip6ConfigData.StationAddress is
 582   unspecified, the IPv6 driver will bind a source address according to the source address selection
 583   algorithm. Clients could frequently call GetModeData() to check get currently configured IPv6
 584   address list in the EFI IPv6 driver. If both Ip6ConfigData.StationAddress and
 585   Ip6ConfigData.Destination are unspecified, when transmitting the packet afterwards, the
 586   source address filled in each outgoing IPv6 packet is decided based on the destination of this packet.
 587
 588   If operational parameters are reset or changed, any pending transmit and receive requests will be
 589   cancelled. Their completion token status will be set to EFI_ABORTED and their events will be
 590   signaled.
 591
 592   @param[in]  This               Pointer to the EFI_IP6_PROTOCOL instance.
 593   @param[in]  Ip6ConfigData      Pointer to the EFI IPv6 Protocol configuration data structure.
 594                                  If NULL, reset the configuration data.
 595
 596   @retval EFI_SUCCESS            The driver instance was successfully opened.
 597   @retval EFI_INVALID_PARAMETER  One or more of the following conditions is TRUE:
 598                                  - This is NULL.
 599                                  - Ip6ConfigData.StationAddress is neither zero nor
 600                                    a unicast IPv6 address.
 601                                  - Ip6ConfigData.StationAddress is neither zero nor
 602                                    one of the configured IP addresses in the EFI IPv6 driver.
 603                                  - Ip6ConfigData.DefaultProtocol is illegal.
 604   @retval EFI_OUT_OF_RESOURCES   The EFI IPv6 Protocol driver instance data could not be allocated.
 605   @retval EFI_NO_MAPPING         The IPv6 driver was responsible for choosing a source address for
 606                                  this instance, but no source address was available for use.
 607   @retval EFI_ALREADY_STARTED    The interface is already open and must be stopped before the IPv6
 608                                  address or prefix length can be changed.
 609   @retval EFI_DEVICE_ERROR       An unexpected system or network error occurred. The EFI IPv6
 610                                  Protocol driver instance was not opened.
 611   @retval EFI_UNSUPPORTED        Default protocol specified through
 612                                  Ip6ConfigData.DefaulProtocol isn't supported.
 613
 614 **/
 615 EFI_STATUS
 616 EFIAPI
 617 EfiIp6Configure (
 618   IN EFI_IP6_PROTOCOL          *This,
 619   IN EFI_IP6_CONFIG_DATA       *Ip6ConfigData OPTIONAL
 620   )
 621 {
 622   IP6_PROTOCOL              *IpInstance;
 623   EFI_IP6_CONFIG_DATA       *Current;
 624   EFI_TPL                   OldTpl;
 625   EFI_STATUS                Status;
 626   IP6_SERVICE               *IpSb;
 627
 628   //
 629   // First, validate the parameters
 630   //
 631   if (This == NULL) {
 632     return EFI_INVALID_PARAMETER;
 633   }
 634
 635   IpInstance = IP6_INSTANCE_FROM_PROTOCOL (This);
 636   IpSb       = IpInstance->Service;
 637
 638   if (IpSb->LinkLocalDadFail) {
 639     return EFI_DEVICE_ERROR;
 640   }
 641
 642   OldTpl     = gBS->RaiseTPL (TPL_CALLBACK);
 643
 644   Status     = EFI_INVALID_PARAMETER;
 645
 646   //
 647   // Validate the configuration first.
 648   //
 649   if (Ip6ConfigData != NULL) {
 650     //
 651     // Check whether the station address is valid.
 652     //
 653     if (!Ip6IsValidAddress (IpSb, &Ip6ConfigData->StationAddress, TRUE)) {
 654        goto Exit;
 655     }
 656     //
 657     // Check whether the default protocol is valid.
 658     //
 659     if (Ip6IsIllegalProtocol (Ip6ConfigData->DefaultProtocol)) {
 660       goto Exit;
 661     }
 662
 663     //
 664     // User can only update packet filters when already configured.
 665     // If it wants to change the station address, it must configure(NULL)
 666     // the instance firstly.
 667     //
 668     if (IpInstance->State == IP6_STATE_CONFIGED) {
 669       Current = &IpInstance->ConfigData;
 670
 671       if (!EFI_IP6_EQUAL (&Current->StationAddress, &Ip6ConfigData->StationAddress)) {
 672         Status = EFI_ALREADY_STARTED;
 673         goto Exit;
 674       }
 675
 676       if (NetIp6IsUnspecifiedAddr (&Current->StationAddress) && IP6_NO_MAPPING (IpInstance)) {
 677         Status = EFI_NO_MAPPING;
 678         goto Exit;
 679       }
 680     }
 681   }
 682
 683   //
 684   // Configure the instance or clean it up.
 685   //
 686   if (Ip6ConfigData != NULL) {
 687     Status = Ip6ConfigProtocol (IpInstance, Ip6ConfigData);
 688   } else {
 689     Status = Ip6CleanProtocol (IpInstance);
 690
 691     //
 692     // Don't change the state if it is DESTORY, consider the following
 693     // valid sequence: Mnp is unloaded-->Ip Stopped-->Udp Stopped,
 694     // Configure (ThisIp, NULL). If the state is changed to UNCONFIGED,
 695     // the unload fails miserably.
 696     //
 697     if (IpInstance->State == IP6_STATE_CONFIGED) {
 698       IpInstance->State = IP6_STATE_UNCONFIGED;
 699     }
 700   }
 701
 702   //
 703   // Update the MNP's configure data. Ip6ServiceConfigMnp will check
 704   // whether it is necessary to reconfigure the MNP.
 705   //
 706   Ip6ServiceConfigMnp (IpInstance->Service, FALSE);
 707
 708   //
 709   // Update the variable data.
 710   //
 711   Ip6SetVariableData (IpInstance->Service);
 712
 713 Exit:
 714   gBS->RestoreTPL (OldTpl);
 715   return Status;
 716 }
 717
 718 /**
 719   Joins and leaves multicast groups.
 720
 721   The Groups() function is used to join and leave multicast group sessions. Joining a group will
 722   enable reception of matching multicast packets. Leaving a group will disable reception of matching
 723   multicast packets. Source-Specific Multicast isn't required to be supported.
 724
 725   If JoinFlag is FALSE and GroupAddress is NULL, all joined groups will be left.
 726
 727   @param[in]  This               Pointer to the EFI_IP6_PROTOCOL instance.
 728   @param[in]  JoinFlag           Set to TRUE to join the multicast group session, and FALSE to leave.
 729   @param[in]  GroupAddress       Pointer to the IPv6 multicast address.
 730                                  This is an optional parameter that may be NULL.
 731
 732   @retval EFI_SUCCESS            The operation completed successfully.
 733   @retval EFI_INVALID_PARAMETER  One or more of the following is TRUE:
 734                                  - This is NULL.
 735                                  - JoinFlag is TRUE and GroupAddress is NULL.
 736                                  - GroupAddress is not NULL and *GroupAddress is
 737                                    not a multicast IPv6 address.
 738                                  - GroupAddress is not NULL and *GroupAddress is in the
 739                                    range of SSM destination address.
 740   @retval EFI_NOT_STARTED        This instance has not been started.
 741   @retval EFI_OUT_OF_RESOURCES   System resources could not be allocated.
 742   @retval EFI_UNSUPPORTED        This EFI IPv6 Protocol implementation does not support multicast groups.
 743   @retval EFI_ALREADY_STARTED    The group address is already in the group table (when
 744                                  JoinFlag is TRUE).
 745   @retval EFI_NOT_FOUND          The group address is not in the group table (when JoinFlag is FALSE).
 746   @retval EFI_DEVICE_ERROR       An unexpected system or network error occurred.
 747
 748 **/
 749 EFI_STATUS
 750 EFIAPI
 751 EfiIp6Groups (
 752   IN EFI_IP6_PROTOCOL  *This,
 753   IN BOOLEAN           JoinFlag,
 754   IN EFI_IPv6_ADDRESS  *GroupAddress  OPTIONAL
 755   )
 756 {
 757   EFI_TPL                   OldTpl;
 758   EFI_STATUS                Status;
 759   IP6_PROTOCOL              *IpInstance;
 760   IP6_SERVICE               *IpSb;
 761
 762   if ((This == NULL) || (JoinFlag && GroupAddress == NULL)) {
 763     return EFI_INVALID_PARAMETER;
 764   }
 765
 766   if (GroupAddress != NULL && !IP6_IS_MULTICAST (GroupAddress)) {
 767     return EFI_INVALID_PARAMETER;
 768   }
 769
 770   IpInstance = IP6_INSTANCE_FROM_PROTOCOL (This);
 771   IpSb       = IpInstance->Service;
 772
 773   if (IpSb->LinkLocalDadFail) {
 774     return EFI_DEVICE_ERROR;
 775   }
 776
 777   OldTpl     = gBS->RaiseTPL (TPL_CALLBACK);
 778
 779   if (IpInstance->State != IP6_STATE_CONFIGED) {
 780     Status = EFI_NOT_STARTED;
 781     goto ON_EXIT;
 782   }
 783
 784   Status = Ip6Groups (IpInstance, JoinFlag, GroupAddress);
 785
 786 ON_EXIT:
 787   gBS->RestoreTPL (OldTpl);
 788   return Status;
 789 }
 790
 791 /**
 792   Adds and deletes routing table entries.
 793
 794   The Routes() function adds a route to, or deletes a route from, the routing table.
 795
 796   Routes are determined by comparing the leftmost PrefixLength bits of Destination with
 797   the destination IPv6 address arithmetically. The gateway address must be on the same subnet as the
 798   configured station address.
 799
 800   The default route is added with Destination and PrefixLegth both set to all zeros. The
 801   default route matches all destination IPv6 addresses that do not match any other routes.
 802
 803   All EFI IPv6 Protocol instances share a routing table.
 804
 805   @param[in]  This               Pointer to the EFI_IP6_PROTOCOL instance.
 806   @param[in]  DeleteRoute        Set to TRUE to delete this route from the routing table. Set to
 807                                  FALSE to add this route to the routing table. Destination,
 808                                  PrefixLength and Gateway are used as the key to each
 809                                  route entry.
 810   @param[in]  Destination        The address prefix of the subnet that needs to be routed.
 811                                  This is an optional parameter that may be NULL.
 812   @param[in]  PrefixLength       The prefix length of Destination. Ignored if Destination
 813                                  is NULL.
 814   @param[in]  GatewayAddress     The unicast gateway IPv6 address for this route.
 815                                  This is an optional parameter that may be NULL.
 816
 817   @retval EFI_SUCCESS            The operation completed successfully.
 818   @retval EFI_NOT_STARTED        The driver instance has not been started.
 819   @retval EFI_INVALID_PARAMETER  One or more of the following conditions is TRUE:
 820                                  - This is NULL.
 821                                  - When DeleteRoute is TRUE, both Destination and
 822                                    GatewayAddress are NULL.
 823                                  - When DeleteRoute is FALSE, either Destination or
 824                                    GatewayAddress is NULL.
 825                                  - *GatewayAddress is not a valid unicast IPv6 address.
 826                                  - *GatewayAddress is one of the local configured IPv6
 827                                    addresses.
 828   @retval EFI_OUT_OF_RESOURCES   Could not add the entry to the routing table.
 829   @retval EFI_NOT_FOUND          This route is not in the routing table (when DeleteRoute is TRUE).
 830   @retval EFI_ACCESS_DENIED      The route is already defined in the routing table (when
 831                                  DeleteRoute is FALSE).
 832
 833 **/
 834 EFI_STATUS
 835 EFIAPI
 836 EfiIp6Routes (
 837   IN EFI_IP6_PROTOCOL    *This,
 838   IN BOOLEAN             DeleteRoute,
 839   IN EFI_IPv6_ADDRESS    *Destination    OPTIONAL,
 840   IN UINT8               PrefixLength,
 841   IN EFI_IPv6_ADDRESS    *GatewayAddress OPTIONAL
 842   )
 843 {
 844   IP6_PROTOCOL              *IpInstance;
 845   EFI_STATUS                Status;
 846   EFI_TPL                   OldTpl;
 847   IP6_SERVICE               *IpSb;
 848
 849   if ((This == NULL) || (PrefixLength >= IP6_PREFIX_NUM)) {
 850     return EFI_INVALID_PARAMETER;
 851   }
 852
 853   IpInstance = IP6_INSTANCE_FROM_PROTOCOL (This);
 854   IpSb       = IpInstance->Service;
 855
 856   if (IpSb->LinkLocalDadFail) {
 857     return EFI_DEVICE_ERROR;
 858   }
 859
 860   if (IpInstance->State != IP6_STATE_CONFIGED) {
 861     return EFI_NOT_STARTED;
 862   }
 863
 864   if (DeleteRoute && (Destination == NULL) && (GatewayAddress == NULL)) {
 865     return EFI_INVALID_PARAMETER;
 866   }
 867
 868   if (!DeleteRoute && (Destination == NULL || GatewayAddress == NULL)) {
 869     return EFI_INVALID_PARAMETER;
 870   }
 871
 872   if (GatewayAddress != NULL) {
 873     if (!Ip6IsValidAddress (IpSb, GatewayAddress, FALSE)) {
 874       return EFI_INVALID_PARAMETER;
 875     }
 876
 877     if (!NetIp6IsUnspecifiedAddr (GatewayAddress) &&
 878         !NetIp6IsNetEqual (GatewayAddress, &IpInstance->ConfigData.StationAddress, PrefixLength)
 879           ) {
 880       return EFI_INVALID_PARAMETER;
 881     }
 882   }
 883
 884   OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 885
 886   //
 887   // Update the route table
 888   //
 889   if (DeleteRoute) {
 890     Status = Ip6DelRoute (IpSb->RouteTable, Destination, PrefixLength, GatewayAddress);
 891   } else {
 892     Status = Ip6AddRoute (IpSb->RouteTable, Destination, PrefixLength, GatewayAddress);
 893   }
 894
 895   gBS->RestoreTPL (OldTpl);
 896   return Status;
 897 }
 898
 899 /**
 900   Add or delete Neighbor cache entries.
 901
 902   The Neighbors() function is used to add, update, or delete an entry from neighbor cache.
 903   IPv6 neighbor cache entries are typically inserted and updated by the network protocol driver as
 904   network traffic is processed. Most neighbor cache entries will timeout and be deleted if the network
 905   traffic stops. Neighbor cache entries that were inserted by Neighbors() may be static (will not
 906   timeout) or dynamic (will timeout).
 907
 908   The implementation should follow the neighbor cache timeout mechanism which is defined in
 909   RFC4861. The default neighbor cache timeout value should be tuned for the expected network
 910   environment
 911
 912   @param[in]  This               Pointer to the EFI_IP6_PROTOCOL instance.
 913   @param[in]  DeleteFlag         Set to TRUE to delete the specified cache entry, set to FALSE to
 914                                  add (or update, if it already exists and Override is TRUE) the
 915                                  specified cache entry. TargetIp6Address is used as the key
 916                                  to find the requested cache entry.
 917   @param[in]  TargetIp6Address   Pointer to the Target IPv6 address.
 918   @param[in]  TargetLinkAddress  Pointer to the link-layer address of the target. Ignored if NULL.
 919   @param[in]  Timeout            Time in 100-ns units that this entry will remain in the neighbor
 920                                  cache, it will be deleted after Timeout. A value of zero means that
 921                                  the entry is permanent. A non-zero value means that the entry is
 922                                  dynamic.
 923   @param[in]  Override           If TRUE, the cached link-layer address of the matching entry will
 924                                  be overridden and updated; if FALSE, EFI_ACCESS_DENIED
 925                                  will be returned if a corresponding cache entry already existed.
 926
 927   @retval  EFI_SUCCESS           The data has been queued for transmission.
 928   @retval  EFI_NOT_STARTED       This instance has not been started.
 929   @retval  EFI_INVALID_PARAMETER One or more of the following conditions is TRUE:
 930                                  - This is NULL.
 931                                  - TargetIpAddress is NULL.
 932                                  - *TargetLinkAddress is invalid when not NULL.
 933                                  - *TargetIpAddress is not a valid unicast IPv6 address.
 934                                  - *TargetIpAddress is one of the local configured IPv6
 935                                    addresses.
 936   @retval  EFI_OUT_OF_RESOURCES  Could not add the entry to the neighbor cache.
 937   @retval  EFI_NOT_FOUND         This entry is not in the neighbor cache (when DeleteFlag  is
 938                                  TRUE or when DeleteFlag  is FALSE while
 939                                  TargetLinkAddress is NULL.).
 940   @retval  EFI_ACCESS_DENIED     The to-be-added entry is already defined in the neighbor cache,
 941                                  and that entry is tagged as un-overridden (when Override
 942                                  is FALSE).
 943
 944 **/
 945 EFI_STATUS
 946 EFIAPI
 947 EfiIp6Neighbors (
 948   IN EFI_IP6_PROTOCOL          *This,
 949   IN BOOLEAN                   DeleteFlag,
 950   IN EFI_IPv6_ADDRESS          *TargetIp6Address,
 951   IN EFI_MAC_ADDRESS           *TargetLinkAddress OPTIONAL,
 952   IN UINT32                    Timeout,
 953   IN BOOLEAN                   Override
 954   )
 955 {
 956   EFI_TPL                   OldTpl;
 957   EFI_STATUS                Status;
 958   IP6_PROTOCOL              *IpInstance;
 959   IP6_SERVICE               *IpSb;
 960
 961   if (This == NULL || TargetIp6Address == NULL) {
 962     return EFI_INVALID_PARAMETER;
 963   }
 964
 965   if (NetIp6IsUnspecifiedAddr (TargetIp6Address)) {
 966     return EFI_INVALID_PARAMETER;
 967   }
 968
 969   IpInstance = IP6_INSTANCE_FROM_PROTOCOL (This);
 970   IpSb       = IpInstance->Service;
 971
 972   if (IpSb->LinkLocalDadFail) {
 973     return EFI_DEVICE_ERROR;
 974   }
 975
 976   if (!Ip6IsValidAddress (IpSb, TargetIp6Address, FALSE)) {
 977     return EFI_INVALID_PARAMETER;
 978   }
 979
 980   if (TargetLinkAddress != NULL) {
 981     if (!Ip6IsValidLinkAddress (IpSb, TargetLinkAddress)) {
 982       return EFI_INVALID_PARAMETER;
 983     }
 984   }
 985
 986   if (Ip6IsOneOfSetAddress (IpSb, TargetIp6Address, NULL, NULL)) {
 987     return EFI_INVALID_PARAMETER;
 988   }
 989
 990   OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 991   if (IpInstance->State != IP6_STATE_CONFIGED) {
 992     Status = EFI_NOT_STARTED;
 993     goto Exit;
 994   }
 995
 996   if (DeleteFlag) {
 997     Status = Ip6DelNeighbor (IpInstance->Service, TargetIp6Address, TargetLinkAddress, Timeout, Override);
 998   } else {
 999     Status = Ip6AddNeighbor (IpInstance->Service, TargetIp6Address, TargetLinkAddress, Timeout, Override);
1000   }
1001
1002 Exit:
1003   gBS->RestoreTPL (OldTpl);
1004   return Status;
1005 }
1006
1007 /**
1008   Check whether the user's token or event has already
1009   been enqueue on IP6's list.
1010
1011   @param[in]  Map                The container of either user's transmit or receive
1012                                  token.
1013   @param[in]  Item               Current item to check against.
1014   @param[in]  Context            The Token to check againist.
1015
1016   @retval EFI_ACCESS_DENIED      The token or event has already been enqueued in IP
1017   @retval EFI_SUCCESS            The current item isn't the same token/event as the
1018                                  context.
1019
1020 **/
1021 EFI_STATUS
1022 EFIAPI
1023 Ip6TokenExist (
1024   IN NET_MAP                *Map,
1025   IN NET_MAP_ITEM           *Item,
1026   IN VOID                   *Context
1027   )
1028 {
1029   EFI_IP6_COMPLETION_TOKEN  *Token;
1030   EFI_IP6_COMPLETION_TOKEN  *TokenInItem;
1031
1032   Token       = (EFI_IP6_COMPLETION_TOKEN *) Context;
1033   TokenInItem = (EFI_IP6_COMPLETION_TOKEN *) Item->Key;
1034
1035   if (Token == TokenInItem || Token->Event == TokenInItem->Event) {
1036     return EFI_ACCESS_DENIED;
1037   }
1038
1039   return EFI_SUCCESS;
1040 }
1041
1042 /**
1043   Validate the user's token against the current station address.
1044
1045   @param[in]  Token              User's token to validate.
1046
1047   @retval EFI_INVALID_PARAMETER  Some parameters are invalid.
1048   @retval EFI_BAD_BUFFER_SIZE    The user's option/data is too long.
1049   @retval EFI_SUCCESS            The token is OK.
1050
1051 **/
1052 EFI_STATUS
1053 Ip6TxTokenValid (
1054   IN EFI_IP6_COMPLETION_TOKEN   *Token
1055   )
1056 {
1057   EFI_IP6_TRANSMIT_DATA     *TxData;
1058   UINT32                    Index;
1059   UINT32                    DataLength;
1060
1061   if (Token == NULL || Token->Event == NULL) {
1062     return EFI_INVALID_PARAMETER;
1063   }
1064
1065   TxData = Token->Packet.TxData;
1066
1067   if (TxData == NULL || (TxData->ExtHdrsLength != 0 && TxData->ExtHdrs == NULL)) {
1068     return EFI_INVALID_PARAMETER;
1069   }
1070
1071   if (TxData->FragmentCount == 0 || TxData->DataLength == 0) {
1072     return EFI_INVALID_PARAMETER;
1073   }
1074
1075   for (DataLength = 0, Index = 0; Index < TxData->FragmentCount; Index++) {
1076     if (TxData->FragmentTable[Index].FragmentLength == 0 || TxData->FragmentTable[Index].FragmentBuffer == NULL) {
1077       return EFI_INVALID_PARAMETER;
1078     }
1079
1080     DataLength += TxData->FragmentTable[Index].FragmentLength;
1081   }
1082
1083   if (TxData->DataLength != DataLength) {
1084     return EFI_INVALID_PARAMETER;
1085   }
1086
1087   //
1088   // TODO: Token.Packet.TxData.DataLength is too short to transmit.
1089   // return EFI_BUFFER_TOO_SMALL;
1090   //
1091
1092   //
1093   // If Token.Packet.TxData.DataLength is beyond the maximum that which can be
1094   // described through the Fragment Offset field in Fragment header when performing
1095   // fragmentation.
1096   //
1097   if (TxData->DataLength > 64 * 1024) {
1098     return EFI_BAD_BUFFER_SIZE;
1099   }
1100
1101   return EFI_SUCCESS;
1102 }
1103
1104 /**
1105   The callback function for the net buffer which wraps the user's
1106   transmit token. Although  this function seems simple, there
1107   are some subtle aspects.
1108   When user requests the IP to transmit a packet by passing it a
1109   token, the token is wrapped in an IP6_TXTOKEN_WRAP and the data
1110   is wrapped in an net buffer. The net buffer's Free function is
1111   set to Ip6FreeTxToken. The Token and token wrap are added to the
1112   IP child's TxToken map. Then the buffer is passed to Ip6Output for
1113   transmission. If an error happened before that, the buffer
1114   is freed, which in turn frees the token wrap. The wrap may
1115   have been added to the TxToken map or not, and the user's event
1116   shouldn't be fired because we are still in the EfiIp6Transmit. If
1117   the buffer has been sent by Ip6Output, it should be removed from
1118   the TxToken map and user's event signaled. The token wrap and buffer
1119   are bound together. Check the comments in Ip6Output for information
1120   about IP fragmentation.
1121
1122   @param[in]  Context                The token's wrap.
1123
1124 **/
1125 VOID
1126 EFIAPI
1127 Ip6FreeTxToken (
1128   IN VOID                   *Context
1129   )
1130 {
1131   IP6_TXTOKEN_WRAP          *Wrap;
1132   NET_MAP_ITEM              *Item;
1133
1134   Wrap = (IP6_TXTOKEN_WRAP *) Context;
1135
1136   //
1137   // Signal IpSecRecycleEvent to inform IPsec free the memory
1138   //
1139   if (Wrap->IpSecRecycleSignal != NULL) {
1140     gBS->SignalEvent (Wrap->IpSecRecycleSignal);
1141   }
1142
1143   //
1144   // Find the token in the instance's map. EfiIp6Transmit put the
1145   // token to the map. If that failed, NetMapFindKey will return NULL.
1146   //
1147   Item = NetMapFindKey (&Wrap->IpInstance->TxTokens, Wrap->Token);
1148
1149   if (Item != NULL) {
1150     NetMapRemoveItem (&Wrap->IpInstance->TxTokens, Item, NULL);
1151   }
1152
1153   if (Wrap->Sent) {
1154     gBS->SignalEvent (Wrap->Token->Event);
1155
1156     //
1157     // Dispatch the DPC queued by the NotifyFunction of Token->Event.
1158     //
1159     DispatchDpc ();
1160   }
1161
1162   FreePool (Wrap);
1163 }
1164
1165
1166 /**
1167   The callback function to Ip6Output to update the transmit status.
1168
1169   @param[in]  Packet           The user's transmit packet.
1170   @param[in]  IoStatus         The result of the transmission.
1171   @param[in]  Flag             Not used during transmission.
1172   @param[in]  Context          The token's wrap.
1173
1174 **/
1175 VOID
1176 Ip6OnPacketSent (
1177   IN NET_BUF                   *Packet,
1178   IN EFI_STATUS                IoStatus,
1179   IN UINT32                    Flag,
1180   IN VOID                      *Context
1181   )
1182 {
1183   IP6_TXTOKEN_WRAP             *Wrap;
1184
1185   //
1186   // This is the transmission request from upper layer,
1187   // not the IP6 driver itself.
1188   //
1189   Wrap                = (IP6_TXTOKEN_WRAP *) Context;
1190   Wrap->Token->Status = IoStatus;
1191
1192   NetbufFree (Wrap->Packet);
1193 }
1194
1195 /**
1196   Places outgoing data packets into the transmit queue.
1197
1198   The Transmit() function places a sending request in the transmit queue of this
1199   EFI IPv6 Protocol instance. Whenever the packet in the token is sent out or some
1200   errors occur, the event in the token will be signaled, and the status is updated.
1201
1202   @param[in]  This               Pointer to the EFI_IP6_PROTOCOL instance.
1203   @param[in]  Token              Pointer to the transmit token.
1204
1205   @retval  EFI_SUCCESS           The data has been queued for transmission.
1206   @retval  EFI_NOT_STARTED       This instance has not been started.
1207   @retval  EFI_NO_MAPPING        The IPv6 driver was responsible for choosing
1208                                  a source address for this transmission,
1209                                  but no source address was available for use.
1210   @retval  EFI_INVALID_PARAMETER One or more of the following is TRUE:
1211                                  - This is NULL.
1212                                  - Token is NULL.
1213                                  - Token.Event is NULL.
1214                                  - Token.Packet.TxData is NULL.
1215                                  - Token.Packet.ExtHdrsLength is not zero and
1216                                    Token.Packet.ExtHdrs is NULL.
1217                                  - Token.Packet.FragmentCount is zero.
1218                                  - One or more of the Token.Packet.TxData.
1219                                    FragmentTable[].FragmentLength fields is zero.
1220                                  - One or more of the Token.Packet.TxData.
1221                                    FragmentTable[].FragmentBuffer fields is NULL.
1222                                  - Token.Packet.TxData.DataLength is zero or not
1223                                    equal to the sum of fragment lengths.
1224                                  - Token.Packet.TxData.DestinationAddress is non
1225                                    zero when DestinationAddress is configured as
1226                                    non-zero when doing Configure() for this
1227                                    EFI IPv6 protocol instance.
1228                                  - Token.Packet.TxData.DestinationAddress is
1229                                    unspecified when DestinationAddress is unspecified
1230                                    when doing Configure() for this EFI IPv6 protocol
1231                                    instance.
1232   @retval  EFI_ACCESS_DENIED     The transmit completion token with the same Token.
1233                                  Event was already in the transmit queue.
1234   @retval  EFI_NOT_READY         The completion token could not be queued because
1235                                  the transmit queue is full.
1236   @retval  EFI_NOT_FOUND         Not route is found to destination address.
1237   @retval  EFI_OUT_OF_RESOURCES  Could not queue the transmit data.
1238   @retval  EFI_BUFFER_TOO_SMALL  Token.Packet.TxData.TotalDataLength is too
1239                                  short to transmit.
1240   @retval  EFI_BAD_BUFFER_SIZE   If Token.Packet.TxData.DataLength is beyond the
1241                                  maximum that which can be described through the
1242                                  Fragment Offset field in Fragment header when
1243                                  performing fragmentation.
1244   @retval EFI_DEVICE_ERROR       An unexpected system or network error occurred.
1245
1246 **/
1247 EFI_STATUS
1248 EFIAPI
1249 EfiIp6Transmit (
1250   IN EFI_IP6_PROTOCOL          *This,
1251   IN EFI_IP6_COMPLETION_TOKEN  *Token
1252   )
1253 {
1254   IP6_SERVICE               *IpSb;
1255   IP6_PROTOCOL              *IpInstance;
1256   EFI_IP6_CONFIG_DATA       *Config;
1257   EFI_STATUS                Status;
1258   EFI_TPL                   OldTpl;
1259   EFI_IP6_HEADER            Head;
1260   EFI_IP6_TRANSMIT_DATA     *TxData;
1261   EFI_IP6_OVERRIDE_DATA     *Override;
1262   IP6_TXTOKEN_WRAP          *Wrap;
1263   UINT8                     *ExtHdrs;
1264
1265   //
1266   // Check input parameters.
1267   //
1268   if (This == NULL) {
1269     return EFI_INVALID_PARAMETER;
1270   }
1271
1272   ExtHdrs = NULL;
1273
1274   Status = Ip6TxTokenValid (Token);
1275   if (EFI_ERROR (Status)) {
1276     return Status;
1277   }
1278
1279   IpInstance = IP6_INSTANCE_FROM_PROTOCOL (This);
1280   IpSb       = IpInstance->Service;
1281
1282   if (IpSb->LinkLocalDadFail) {
1283     return EFI_DEVICE_ERROR;
1284   }
1285
1286   OldTpl     = gBS->RaiseTPL (TPL_CALLBACK);
1287
1288   if (IpInstance->State != IP6_STATE_CONFIGED) {
1289     Status = EFI_NOT_STARTED;
1290     goto Exit;
1291   }
1292
1293   Config = &IpInstance->ConfigData;
1294
1295   //
1296   // Check whether the token or signal already existed.
1297   //
1298   if (EFI_ERROR (NetMapIterate (&IpInstance->TxTokens, Ip6TokenExist, Token))) {
1299     Status = EFI_ACCESS_DENIED;
1300     goto Exit;
1301   }
1302
1303   //
1304   // Build the IP header, fill in the information from ConfigData or OverrideData
1305   //
1306   ZeroMem (&Head, sizeof(EFI_IP6_HEADER));
1307   TxData = Token->Packet.TxData;
1308   IP6_COPY_ADDRESS (&Head.SourceAddress, &Config->StationAddress);
1309   IP6_COPY_ADDRESS (&Head.DestinationAddress, &Config->DestinationAddress);
1310
1311   Status = EFI_INVALID_PARAMETER;
1312
1313   if (NetIp6IsUnspecifiedAddr (&TxData->DestinationAddress)) {
1314     if (NetIp6IsUnspecifiedAddr (&Config->DestinationAddress)) {
1315       goto Exit;
1316     }
1317
1318     ASSERT (!NetIp6IsUnspecifiedAddr (&Config->StationAddress));
1319
1320   } else {
1321     //
1322     // StationAddress is unspecified only when ConfigData.Dest is unspecified.
1323     // Use TxData.Dest to override the DestinationAddress.
1324     //
1325     if (!NetIp6IsUnspecifiedAddr (&Config->DestinationAddress)) {
1326       goto Exit;
1327     }
1328
1329     if (NetIp6IsUnspecifiedAddr (&Config->StationAddress)) {
1330       Status = Ip6SelectSourceAddress (
1331                  IpSb,
1332                  &TxData->DestinationAddress,
1333                  &Head.SourceAddress
1334                  );
1335       if (EFI_ERROR (Status)) {
1336         goto Exit;
1337       }
1338     }
1339
1340     IP6_COPY_ADDRESS (&Head.DestinationAddress, &TxData->DestinationAddress);
1341   }
1342
1343   //
1344   // Fill in Head infos.
1345   //
1346   Head.NextHeader = Config->DefaultProtocol;
1347   if (TxData->ExtHdrsLength != 0) {
1348     Head.NextHeader = TxData->NextHeader;
1349   }
1350
1351   if (TxData->OverrideData != NULL) {
1352     Override        = TxData->OverrideData;
1353     Head.NextHeader = Override->Protocol;
1354     Head.HopLimit   = Override->HopLimit;
1355     Head.FlowLabelL = HTONS ((UINT16) Override->FlowLabel);
1356     Head.FlowLabelH = (UINT8) ((Override->FlowLabel >> 16) & 0x0F);
1357   } else {
1358     Head.HopLimit   = Config->HopLimit;
1359     Head.FlowLabelL = HTONS ((UINT16) Config->FlowLabel);
1360     Head.FlowLabelH = (UINT8) ((Config->FlowLabel >> 16) & 0x0F);
1361   }
1362
1363   Head.PayloadLength = HTONS ((UINT16) (TxData->ExtHdrsLength + TxData->DataLength));
1364
1365   //
1366   // OK, it survives all the validation check. Wrap the token in
1367   // a IP6_TXTOKEN_WRAP and the data in a netbuf
1368   //
1369   Status = EFI_OUT_OF_RESOURCES;
1370   Wrap   = AllocateZeroPool (sizeof (IP6_TXTOKEN_WRAP));
1371   if (Wrap == NULL) {
1372     goto Exit;
1373   }
1374
1375   Wrap->IpInstance  = IpInstance;
1376   Wrap->Token       = Token;
1377   Wrap->Sent        = FALSE;
1378   Wrap->Life        = IP6_US_TO_SEC (Config->TransmitTimeout);
1379   Wrap->Packet      = NetbufFromExt (
1380                         (NET_FRAGMENT *) TxData->FragmentTable,
1381                         TxData->FragmentCount,
1382                         IP6_MAX_HEADLEN,
1383                         0,
1384                         Ip6FreeTxToken,
1385                         Wrap
1386                         );
1387
1388   if (Wrap->Packet == NULL) {
1389     FreePool (Wrap);
1390     goto Exit;
1391   }
1392
1393   Token->Status = EFI_NOT_READY;
1394
1395   Status = NetMapInsertTail (&IpInstance->TxTokens, Token, Wrap);
1396   if (EFI_ERROR (Status)) {
1397     //
1398     // NetbufFree will call Ip6FreeTxToken, which in turn will
1399     // free the IP6_TXTOKEN_WRAP. Now, the token wrap hasn't been
1400     // enqueued.
1401     //
1402     NetbufFree (Wrap->Packet);
1403     goto Exit;
1404   }
1405
1406   //
1407   // Allocate a new buffer to store IPv6 extension headers to avoid updating
1408   // the original data in EFI_IP6_COMPLETION_TOKEN.
1409   //
1410   if (TxData->ExtHdrsLength != 0 && TxData->ExtHdrs != NULL) {
1411     ExtHdrs = (UINT8 *) AllocateCopyPool (TxData->ExtHdrsLength, TxData->ExtHdrs);
1412     if (ExtHdrs == NULL) {
1413       Status = EFI_OUT_OF_RESOURCES;
1414       goto Exit;
1415     }
1416   }
1417
1418   //
1419   // Mark the packet sent before output it. Mark it not sent again if the
1420   // returned status is not EFI_SUCCESS;
1421   //
1422   Wrap->Sent = TRUE;
1423
1424   Status = Ip6Output (
1425              IpSb,
1426              NULL,
1427              IpInstance,
1428              Wrap->Packet,
1429              &Head,
1430              ExtHdrs,
1431              TxData->ExtHdrsLength,
1432              Ip6OnPacketSent,
1433              Wrap
1434              );
1435   if (EFI_ERROR (Status)) {
1436     Wrap->Sent = FALSE;
1437     NetbufFree (Wrap->Packet);
1438   }
1439
1440 Exit:
1441   gBS->RestoreTPL (OldTpl);
1442
1443   if (ExtHdrs != NULL) {
1444     FreePool (ExtHdrs);
1445   }
1446
1447   return Status;
1448 }
1449
1450 /**
1451   Places a receiving request into the receiving queue.
1452
1453   The Receive() function places a completion token into the receive packet queue.
1454   This function is always asynchronous.
1455
1456   The Token.Event field in the completion token must be filled in by the caller
1457   and cannot be NULL. When the receive operation completes, the EFI IPv6 Protocol
1458   driver updates the Token.Status and Token.Packet.RxData fields and the Token.Event
1459   is signaled.
1460
1461   Current Udp implementation creates an IP child for each Udp child.
1462   It initates a asynchronous receive immediately no matter whether
1463   there is no mapping or not. Therefore, disable the returning EFI_NO_MAPPING for now.
1464   To enable it, the following check must be performed:
1465
1466   if (NetIp6IsUnspecifiedAddr (&Config->StationAddress) && IP6_NO_MAPPING (IpInstance)) {
1467     Status = EFI_NO_MAPPING;
1468     goto Exit;
1469   }
1470
1471   @param[in]  This               Pointer to the EFI_IP6_PROTOCOL instance.
1472   @param[in]  Token              Pointer to a token that is associated with the receive data descriptor.
1473
1474   @retval EFI_SUCCESS            The receive completion token was cached.
1475   @retval EFI_NOT_STARTED        This EFI IPv6 Protocol instance has not been started.
1476   @retval EFI_NO_MAPPING         When IP6 driver responsible for binding source address to this instance,
1477                                  while no source address is available for use.
1478   @retval EFI_INVALID_PARAMETER  One or more of the following conditions is TRUE:
1479                                  - This is NULL.
1480                                  - Token is NULL.
1481                                  - Token.Event is NULL.
1482   @retval EFI_OUT_OF_RESOURCES   The receive completion token could not be queued due to a lack of system
1483                                  resources (usually memory).
1484   @retval EFI_DEVICE_ERROR       An unexpected system or network error occurred.
1485                                  The EFI IPv6 Protocol instance has been reset to startup defaults.
1486   @retval EFI_ACCESS_DENIED      The receive completion token with the same Token.Event was already
1487                                  in the receive queue.
1488   @retval EFI_NOT_READY          The receive request could not be queued because the receive queue is full.
1489
1490 **/
1491 EFI_STATUS
1492 EFIAPI
1493 EfiIp6Receive (
1494   IN EFI_IP6_PROTOCOL          *This,
1495   IN EFI_IP6_COMPLETION_TOKEN  *Token
1496   )
1497 {
1498   IP6_PROTOCOL              *IpInstance;
1499   EFI_STATUS                Status;
1500   EFI_TPL                   OldTpl;
1501   IP6_SERVICE               *IpSb;
1502
1503   if (This == NULL || Token == NULL || Token->Event == NULL) {
1504     return EFI_INVALID_PARAMETER;
1505   }
1506
1507   IpInstance = IP6_INSTANCE_FROM_PROTOCOL (This);
1508   IpSb       = IpInstance->Service;
1509
1510   if (IpSb->LinkLocalDadFail) {
1511     return EFI_DEVICE_ERROR;
1512   }
1513
1514   OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
1515
1516   if (IpInstance->State != IP6_STATE_CONFIGED) {
1517     Status = EFI_NOT_STARTED;
1518     goto Exit;
1519   }
1520
1521   //
1522   // Check whether the toke is already on the receive queue.
1523   //
1524   Status = NetMapIterate (&IpInstance->RxTokens, Ip6TokenExist, Token);
1525
1526   if (EFI_ERROR (Status)) {
1527     Status = EFI_ACCESS_DENIED;
1528     goto Exit;
1529   }
1530
1531   //
1532   // Queue the token then check whether there is pending received packet.
1533   //
1534   Status = NetMapInsertTail (&IpInstance->RxTokens, Token, NULL);
1535
1536   if (EFI_ERROR (Status)) {
1537     goto Exit;
1538   }
1539
1540   Status = Ip6InstanceDeliverPacket (IpInstance);
1541
1542   //
1543   // Dispatch the DPC queued by the NotifyFunction of this instane's receive
1544   // event.
1545   //
1546   DispatchDpc ();
1547
1548 Exit:
1549   gBS->RestoreTPL (OldTpl);
1550   return Status;
1551 }
1552
1553
1554 /**
1555   Cancel the transmitted but not recycled packet. If a matching
1556   token is found, it will call Ip6CancelPacket to cancel the
1557   packet. Ip6CancelPacket cancels all the fragments of the
1558   packet. When all the fragments are freed, the IP6_TXTOKEN_WRAP
1559   is deleted from the Map, and user's event is signalled.
1560   Because Ip6CancelPacket and other functions are all called in
1561   line, after Ip6CancelPacket returns, the Item has been freed.
1562
1563   @param[in]  Map                The IP6 child's transmit queue.
1564   @param[in]  Item               The current transmitted packet to test.
1565   @param[in]  Context            The user's token to cancel.
1566
1567   @retval EFI_SUCCESS            Continue to check the next Item.
1568   @retval EFI_ABORTED            The user's Token (Token != NULL) is cancelled.
1569
1570 **/
1571 EFI_STATUS
1572 EFIAPI
1573 Ip6CancelTxTokens (
1574   IN NET_MAP                *Map,
1575   IN NET_MAP_ITEM           *Item,
1576   IN VOID                   *Context
1577   )
1578 {
1579   EFI_IP6_COMPLETION_TOKEN  *Token;
1580   IP6_TXTOKEN_WRAP          *Wrap;
1581
1582   Token = (EFI_IP6_COMPLETION_TOKEN *) Context;
1583
1584   //
1585   // Return EFI_SUCCESS to check the next item in the map if
1586   // this one doesn't match.
1587   //
1588   if ((Token != NULL) && (Token != Item->Key)) {
1589     return EFI_SUCCESS;
1590   }
1591
1592   Wrap = (IP6_TXTOKEN_WRAP *) Item->Value;
1593   ASSERT (Wrap != NULL);
1594
1595   //
1596   // Don't access the Item, Wrap and Token's members after this point.
1597   // Item and wrap has been freed. And we no longer own the Token.
1598   //
1599   Ip6CancelPacket (Wrap->IpInstance->Interface, Wrap->Packet, EFI_ABORTED);
1600
1601   //
1602   // If only one item is to be cancel, return EFI_ABORTED to stop
1603   // iterating the map any more.
1604   //
1605   if (Token != NULL) {
1606     return EFI_ABORTED;
1607   }
1608
1609   return EFI_SUCCESS;
1610 }
1611
1612
1613 /**
1614   Cancel the receive request. This is simple, because
1615   it is only enqueued in our local receive map.
1616
1617   @param[in]  Map                The IP6 child's receive queue.
1618   @param[in]  Item               Current receive request to cancel.
1619   @param[in]  Context            The user's token to cancel.
1620
1621
1622   @retval EFI_SUCCESS            Continue to check the next receive request on the
1623                                  queue.
1624   @retval EFI_ABORTED            The user's token (token != NULL) has been
1625                                  cancelled.
1626
1627 **/
1628 EFI_STATUS
1629 EFIAPI
1630 Ip6CancelRxTokens (
1631   IN NET_MAP                *Map,
1632   IN NET_MAP_ITEM           *Item,
1633   IN VOID                   *Context
1634   )
1635 {
1636   EFI_IP6_COMPLETION_TOKEN  *Token;
1637   EFI_IP6_COMPLETION_TOKEN  *This;
1638
1639   Token = (EFI_IP6_COMPLETION_TOKEN *) Context;
1640   This  = Item->Key;
1641
1642   if ((Token != NULL) && (Token != This)) {
1643     return EFI_SUCCESS;
1644   }
1645
1646   NetMapRemoveItem (Map, Item, NULL);
1647
1648   This->Status        = EFI_ABORTED;
1649   This->Packet.RxData = NULL;
1650   gBS->SignalEvent (This->Event);
1651
1652   if (Token != NULL) {
1653     return EFI_ABORTED;
1654   }
1655
1656   return EFI_SUCCESS;
1657 }
1658
1659 /**
1660   Cancel the user's receive/transmit request. It is the worker function of
1661   EfiIp6Cancel API.
1662
1663   @param[in]  IpInstance         The IP6 child.
1664   @param[in]  Token              The token to cancel. If NULL, all token will be
1665                                  cancelled.
1666
1667   @retval EFI_SUCCESS            The token is cancelled.
1668   @retval EFI_NOT_FOUND          The token isn't found on either the
1669                                  transmit/receive queue.
1670   @retval EFI_DEVICE_ERROR       Not all tokens are cancelled when Token is NULL.
1671
1672 **/
1673 EFI_STATUS
1674 Ip6Cancel (
1675   IN IP6_PROTOCOL             *IpInstance,
1676   IN EFI_IP6_COMPLETION_TOKEN *Token          OPTIONAL
1677   )
1678 {
1679   EFI_STATUS                Status;
1680
1681   //
1682   // First check the transmitted packet. Ip6CancelTxTokens returns
1683   // EFI_ABORTED to mean that the token has been cancelled when
1684   // token != NULL. So, return EFI_SUCCESS for this condition.
1685   //
1686   Status = NetMapIterate (&IpInstance->TxTokens, Ip6CancelTxTokens, Token);
1687   if (EFI_ERROR (Status)) {
1688     if ((Token != NULL) && (Status == EFI_ABORTED)) {
1689       return EFI_SUCCESS;
1690     }
1691
1692     return Status;
1693   }
1694
1695   //
1696   // Check the receive queue. Ip6CancelRxTokens also returns EFI_ABORT
1697   // for Token!=NULL and it is cancelled.
1698   //
1699   Status = NetMapIterate (&IpInstance->RxTokens, Ip6CancelRxTokens, Token);
1700   //
1701   // Dispatch the DPCs queued by the NotifyFunction of the canceled rx token's
1702   // events.
1703   //
1704   DispatchDpc ();
1705   if (EFI_ERROR (Status)) {
1706     if ((Token != NULL) && (Status == EFI_ABORTED)) {
1707       return EFI_SUCCESS;
1708     }
1709
1710     return Status;
1711   }
1712
1713   //
1714   // OK, if the Token is found when Token != NULL, the NetMapIterate
1715   // will return EFI_ABORTED, which has been interrupted as EFI_SUCCESS.
1716   //
1717   if (Token != NULL) {
1718     return EFI_NOT_FOUND;
1719   }
1720
1721   //
1722   // If Token == NULL, cancel all the tokens. return error if not
1723   // all of them are cancelled.
1724   //
1725   if (!NetMapIsEmpty (&IpInstance->TxTokens) || !NetMapIsEmpty (&IpInstance->RxTokens)) {
1726
1727     return EFI_DEVICE_ERROR;
1728   }
1729
1730   return EFI_SUCCESS;
1731 }
1732
1733 /**
1734   Abort an asynchronous transmit or receive request.
1735
1736   The Cancel() function is used to abort a pending transmit or receive request.
1737   If the token is in the transmit or receive request queues, after calling this
1738   function, Token->Status will be set to EFI_ABORTED, and then Token->Event will
1739   be signaled. If the token is not in one of the queues, which usually means the
1740   asynchronous operation has completed, this function will not signal the token,
1741   and EFI_NOT_FOUND is returned.
1742
1743   @param[in]  This               Pointer to the EFI_IP6_PROTOCOL instance.
1744   @param[in]  Token              Pointer to a token that has been issued by
1745                                  EFI_IP6_PROTOCOL.Transmit() or
1746                                  EFI_IP6_PROTOCOL.Receive(). If NULL, all pending
1747                                  tokens are aborted. Type EFI_IP6_COMPLETION_TOKEN is
1748                                  defined in EFI_IP6_PROTOCOL.Transmit().
1749
1750   @retval EFI_SUCCESS            The asynchronous I/O request was aborted and
1751                                  Token->Event was signaled. When Token is NULL, all
1752                                  pending requests were aborted, and their events were signaled.
1753   @retval EFI_INVALID_PARAMETER  This is NULL.
1754   @retval EFI_NOT_STARTED        This instance has not been started.
1755   @retval EFI_NOT_FOUND          When Token is not NULL, the asynchronous I/O request was
1756                                  not found in the transmit or receive queue. It has either completed
1757                                  or was not issued by Transmit() and Receive().
1758   @retval EFI_DEVICE_ERROR       An unexpected system or network error occurred.
1759
1760 **/
1761 EFI_STATUS
1762 EFIAPI
1763 EfiIp6Cancel (
1764   IN EFI_IP6_PROTOCOL          *This,
1765   IN EFI_IP6_COMPLETION_TOKEN  *Token    OPTIONAL
1766   )
1767 {
1768   IP6_PROTOCOL              *IpInstance;
1769   IP6_SERVICE               *IpSb;
1770   EFI_STATUS                Status;
1771   EFI_TPL                   OldTpl;
1772
1773   if (This == NULL) {
1774     return EFI_INVALID_PARAMETER;
1775   }
1776
1777   IpInstance = IP6_INSTANCE_FROM_PROTOCOL (This);
1778   IpSb       = IpInstance->Service;
1779
1780   if (IpSb->LinkLocalDadFail) {
1781     return EFI_DEVICE_ERROR;
1782   }
1783
1784   OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
1785
1786   if (IpInstance->State != IP6_STATE_CONFIGED) {
1787     Status = EFI_NOT_STARTED;
1788     goto Exit;
1789   }
1790
1791   Status = Ip6Cancel (IpInstance, Token);
1792
1793 Exit:
1794   gBS->RestoreTPL (OldTpl);
1795   return Status;
1796 }
1797
1798 /**
1799   Polls for incoming data packets, and processes outgoing data packets.
1800
1801   The Poll() function polls for incoming data packets and processes outgoing data
1802   packets. Network drivers and applications can call the EFI_IP6_PROTOCOL.Poll()
1803   function to increase the rate that data packets are moved between the communications
1804   device and the transmit and receive queues.
1805
1806   In some systems the periodic timer event may not poll the underlying communications
1807   device fast enough to transmit and/or receive all data packets without missing
1808   incoming packets or dropping outgoing packets. Drivers and applications that are
1809   experiencing packet loss should try calling the EFI_IP6_PROTOCOL.Poll() function
1810   more often.
1811
1812   @param[in]  This               Pointer to the EFI_IP6_PROTOCOL instance.
1813
1814   @retval  EFI_SUCCESS           Incoming or outgoing data was processed.
1815   @retval  EFI_NOT_STARTED       This EFI IPv6 Protocol instance has not been started.
1816   @retval  EFI_INVALID_PARAMETER This is NULL.
1817   @retval  EFI_DEVICE_ERROR      An unexpected system error or network error occurred.
1818   @retval  EFI_NOT_READY         No incoming or outgoing data was processed.
1819   @retval  EFI_TIMEOUT           Data was dropped out of the transmit and/or receive queue.
1820                                  Consider increasing the polling rate.
1821
1822 **/
1823 EFI_STATUS
1824 EFIAPI
1825 EfiIp6Poll (
1826   IN EFI_IP6_PROTOCOL          *This
1827   )
1828 {
1829   IP6_PROTOCOL                  *IpInstance;
1830   IP6_SERVICE                   *IpSb;
1831   EFI_MANAGED_NETWORK_PROTOCOL  *Mnp;
1832
1833   if (This == NULL) {
1834     return EFI_INVALID_PARAMETER;
1835   }
1836
1837   IpInstance = IP6_INSTANCE_FROM_PROTOCOL (This);
1838   IpSb       = IpInstance->Service;
1839
1840   if (IpSb->LinkLocalDadFail) {
1841     return EFI_DEVICE_ERROR;
1842   }
1843
1844   if (IpInstance->State == IP6_STATE_UNCONFIGED) {
1845     return EFI_NOT_STARTED;
1846   }
1847
1848   Mnp = IpInstance->Service->Mnp;
1849
1850   //
1851   // Don't lock the Poll function to enable the deliver of
1852   // the packet polled up.
1853   //
1854   return Mnp->Poll (Mnp);
1855
1856 }
1857