NetworkPkg/Ip6Dxe/Ip6Impl.c

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