Ip4Config2Impl.c

Go to the documentation of this file.

 
#include "Ip4Impl.h"
 
LIST_ENTRY  mIp4Config2InstanceList = { &mIp4Config2InstanceList, &mIp4Config2InstanceList };
 
VOID
EFIAPI
Ip4Config2OnDhcp4SbInstalled (
  IN EFI_EVENT  Event,
  IN VOID       *Context
  );
 
EFI_STATUS
Ip4Config2DestroyDhcp4 (
  IN OUT IP4_CONFIG2_INSTANCE  *Instance
  )
{
  IP4_SERVICE         *IpSb;
  EFI_STATUS          Status;
  EFI_DHCP4_PROTOCOL  *Dhcp4;
 
  Dhcp4 = Instance->Dhcp4;
  ASSERT (Dhcp4 != NULL);
 
  Dhcp4->Stop (Dhcp4);
  Dhcp4->Configure (Dhcp4, NULL);
  Instance->Dhcp4 = NULL;
 
  IpSb = IP4_SERVICE_FROM_IP4_CONFIG2_INSTANCE (Instance);
 
  //
  // Close DHCPv4 protocol and destroy the child.
  //
  Status = gBS->CloseProtocol (
                  Instance->Dhcp4Handle,
                  &gEfiDhcp4ProtocolGuid,
                  IpSb->Image,
                  IpSb->Controller
                  );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  Status = NetLibDestroyServiceChild (
             IpSb->Controller,
             IpSb->Image,
             &gEfiDhcp4ServiceBindingProtocolGuid,
             Instance->Dhcp4Handle
             );
 
  Instance->Dhcp4Handle = NULL;
 
  return Status;
}
 
VOID
Ip4Config2OnPolicyChanged (
  IN IP4_SERVICE             *IpSb,
  IN EFI_IP4_CONFIG2_POLICY  NewPolicy
  )
{
  IP4_INTERFACE    *IpIf;
  IP4_ROUTE_TABLE  *RouteTable;
 
  //
  // Currently there are only two policies: static and dhcp. Regardless of
  // what transition is going on, i.e., static -> dhcp and dhcp ->
  // static, we have to free default router table and all addresses.
  //
 
  if (IpSb->DefaultInterface != NULL) {
    if (IpSb->DefaultRouteTable != NULL) {
      Ip4FreeRouteTable (IpSb->DefaultRouteTable);
      IpSb->DefaultRouteTable = NULL;
    }
 
    Ip4CancelReceive (IpSb->DefaultInterface);
 
    Ip4FreeInterface (IpSb->DefaultInterface, NULL);
    IpSb->DefaultInterface = NULL;
  }
 
  Ip4CleanAssembleTable (&IpSb->Assemble);
 
  //
  // Create new default interface and route table.
  //
  IpIf = Ip4CreateInterface (IpSb->Mnp, IpSb->Controller, IpSb->Image);
  if (IpIf == NULL) {
    return;
  }
 
  RouteTable = Ip4CreateRouteTable ();
  if (RouteTable == NULL) {
    Ip4FreeInterface (IpIf, NULL);
    return;
  }
 
  IpSb->DefaultInterface = IpIf;
  InsertHeadList (&IpSb->Interfaces, &IpIf->Link);
  IpSb->DefaultRouteTable = RouteTable;
  Ip4ReceiveFrame (IpIf, NULL, Ip4AccpetFrame, IpSb);
 
  if ((IpSb->State == IP4_SERVICE_CONFIGED) || (IpSb->State == IP4_SERVICE_STARTED)) {
    IpSb->State = IP4_SERVICE_UNSTARTED;
  }
 
  //
  // Start the dhcp configuration.
  //
  if (NewPolicy == Ip4Config2PolicyDhcp) {
    Ip4StartAutoConfig (&IpSb->Ip4Config2Instance);
  }
}
 
EFI_STATUS
EFIAPI
Ip4Config2SignalEvent (
  IN NET_MAP       *Map,
  IN NET_MAP_ITEM  *Item,
  IN VOID          *Arg
  )
{
  gBS->SignalEvent ((EFI_EVENT)Item->Key);
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
Ip4Config2ReadConfigData (
  IN     CHAR16                *VarName,
  IN OUT IP4_CONFIG2_INSTANCE  *Instance
  )
{
  EFI_STATUS               Status;
  UINTN                    VarSize;
  IP4_CONFIG2_VARIABLE     *Variable;
  IP4_CONFIG2_DATA_ITEM    *DataItem;
  UINTN                    Index;
  IP4_CONFIG2_DATA_RECORD  DataRecord;
  CHAR8                    *Data;
 
  //
  // Try to read the configuration variable.
  //
  VarSize = 0;
  Status  = gRT->GetVariable (
                   VarName,
                   &gEfiIp4Config2ProtocolGuid,
                   NULL,
                   &VarSize,
                   NULL
                   );
 
  if (Status == EFI_BUFFER_TOO_SMALL) {
    //
    // Allocate buffer and read the config variable.
    //
    Variable = AllocatePool (VarSize);
    if (Variable == NULL) {
      return EFI_OUT_OF_RESOURCES;
    }
 
    Status = gRT->GetVariable (
                    VarName,
                    &gEfiIp4Config2ProtocolGuid,
                    NULL,
                    &VarSize,
                    Variable
                    );
    if (EFI_ERROR (Status) || ((UINT16)(~NetblockChecksum ((UINT8 *)Variable, (UINT32)VarSize)) != 0)) {
      //
      // GetVariable still error or the variable is corrupted.
      // Fall back to the default value.
      //
      FreePool (Variable);
 
      //
      // Remove the problematic variable and return EFI_NOT_FOUND, a new
      // variable will be set again.
      //
      gRT->SetVariable (
             VarName,
             &gEfiIp4Config2ProtocolGuid,
             IP4_CONFIG2_VARIABLE_ATTRIBUTE,
             0,
             NULL
             );
 
      return EFI_NOT_FOUND;
    }
 
    for (Index = 0; Index < Variable->DataRecordCount; Index++) {
      CopyMem (&DataRecord, &Variable->DataRecord[Index], sizeof (DataRecord));
 
      DataItem = &Instance->DataItem[DataRecord.DataType];
      if (DATA_ATTRIB_SET (DataItem->Attribute, DATA_ATTRIB_SIZE_FIXED) &&
          (DataItem->DataSize != DataRecord.DataSize)
          )
      {
        //
        // Perhaps a corrupted data record...
        //
        continue;
      }
 
      if (!DATA_ATTRIB_SET (DataItem->Attribute, DATA_ATTRIB_SIZE_FIXED)) {
        //
        // This data item has variable length data.
        //
        DataItem->Data.Ptr = AllocatePool (DataRecord.DataSize);
        if (DataItem->Data.Ptr == NULL) {
          //
          // no memory resource
          //
          continue;
        }
      }
 
      Data = (CHAR8 *)Variable + DataRecord.Offset;
      CopyMem (DataItem->Data.Ptr, Data, DataRecord.DataSize);
 
      DataItem->DataSize = DataRecord.DataSize;
      DataItem->Status   = EFI_SUCCESS;
    }
 
    FreePool (Variable);
    return EFI_SUCCESS;
  }
 
  return Status;
}
 
EFI_STATUS
Ip4Config2WriteConfigData (
  IN CHAR16                *VarName,
  IN IP4_CONFIG2_INSTANCE  *Instance
  )
{
  UINTN                    Index;
  UINTN                    VarSize;
  IP4_CONFIG2_DATA_ITEM    *DataItem;
  IP4_CONFIG2_VARIABLE     *Variable;
  IP4_CONFIG2_DATA_RECORD  *DataRecord;
  CHAR8                    *Heap;
  EFI_STATUS               Status;
 
  VarSize = sizeof (IP4_CONFIG2_VARIABLE) - sizeof (IP4_CONFIG2_DATA_RECORD);
 
  for (Index = 0; Index < Ip4Config2DataTypeMaximum; Index++) {
    DataItem = &Instance->DataItem[Index];
    if (!DATA_ATTRIB_SET (DataItem->Attribute, DATA_ATTRIB_VOLATILE) && !EFI_ERROR (DataItem->Status)) {
      VarSize += sizeof (IP4_CONFIG2_DATA_RECORD) + DataItem->DataSize;
    }
  }
 
  Variable = AllocatePool (VarSize);
  if (Variable == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  Heap                      = (CHAR8 *)Variable + VarSize;
  Variable->DataRecordCount = 0;
 
  for (Index = 0; Index < Ip4Config2DataTypeMaximum; Index++) {
    DataItem = &Instance->DataItem[Index];
    if (!DATA_ATTRIB_SET (DataItem->Attribute, DATA_ATTRIB_VOLATILE) && !EFI_ERROR (DataItem->Status)) {
      Heap -= DataItem->DataSize;
      CopyMem (Heap, DataItem->Data.Ptr, DataItem->DataSize);
 
      DataRecord           = &Variable->DataRecord[Variable->DataRecordCount];
      DataRecord->DataType = (EFI_IP4_CONFIG2_DATA_TYPE)Index;
      DataRecord->DataSize = (UINT32)DataItem->DataSize;
      DataRecord->Offset   = (UINT16)(Heap - (CHAR8 *)Variable);
 
      Variable->DataRecordCount++;
    }
  }
 
  Variable->Checksum = 0;
  Variable->Checksum = (UINT16) ~NetblockChecksum ((UINT8 *)Variable, (UINT32)VarSize);
 
  Status = gRT->SetVariable (
                  VarName,
                  &gEfiIp4Config2ProtocolGuid,
                  IP4_CONFIG2_VARIABLE_ATTRIBUTE,
                  VarSize,
                  Variable
                  );
 
  FreePool (Variable);
 
  return Status;
}
 
EFI_STATUS
Ip4Config2BuildDefaultRouteTable (
  IN  IP4_SERVICE          *IpSb,
  OUT EFI_IP4_ROUTE_TABLE  *Table
  )
{
  LIST_ENTRY       *Entry;
  IP4_ROUTE_ENTRY  *RtEntry;
  UINT32           Count;
  INT32            Index;
 
  if (IpSb->DefaultRouteTable == NULL) {
    return EFI_NOT_FOUND;
  }
 
  Count = IpSb->DefaultRouteTable->TotalNum;
 
  if (Count == 0) {
    return EFI_NOT_FOUND;
  }
 
  //
  // Copy the route entry to EFI route table. Keep the order of
  // route entry copied from most specific to default route. That
  // is, interlevel the route entry from the instance's route area
  // and those from the default route table's route area.
  //
  Count = 0;
 
  for (Index = IP4_MASK_MAX; Index >= 0; Index--) {
    NET_LIST_FOR_EACH (Entry, &(IpSb->DefaultRouteTable->RouteArea[Index])) {
      RtEntry = NET_LIST_USER_STRUCT (Entry, IP4_ROUTE_ENTRY, Link);
 
      EFI_IP4 (Table[Count].SubnetAddress)  = HTONL (RtEntry->Dest & RtEntry->Netmask);
      EFI_IP4 (Table[Count].SubnetMask)     = HTONL (RtEntry->Netmask);
      EFI_IP4 (Table[Count].GatewayAddress) = HTONL (RtEntry->NextHop);
 
      Count++;
    }
  }
 
  return EFI_SUCCESS;
}
 
VOID
EFIAPI
Ip4Config2OnDhcp4SbInstalled (
  IN EFI_EVENT  Event,
  IN VOID       *Context
  )
{
  IP4_CONFIG2_INSTANCE  *Instance;
 
  Instance = (IP4_CONFIG2_INSTANCE *)Context;
 
  if ((Instance->Dhcp4Handle != NULL) || (Instance->Policy != Ip4Config2PolicyDhcp)) {
    //
    // The DHCP4 child is already created or the policy is no longer DHCP.
    //
    return;
  }
 
  Ip4StartAutoConfig (Instance);
}
 
EFI_STATUS
Ip4Config2SetDefaultAddr (
  IN IP4_SERVICE  *IpSb,
  IN IP4_ADDR     StationAddress,
  IN IP4_ADDR     SubnetMask
  )
{
  EFI_STATUS        Status;
  IP4_INTERFACE     *IpIf;
  IP4_PROTOCOL      *Ip4Instance;
  EFI_ARP_PROTOCOL  *Arp;
  LIST_ENTRY        *Entry;
  IP4_ADDR          Subnet;
  IP4_ROUTE_TABLE   *RouteTable;
 
  IpIf = IpSb->DefaultInterface;
  ASSERT (IpIf != NULL);
 
  if ((IpIf->Ip == StationAddress) && (IpIf->SubnetMask == SubnetMask)) {
    IpSb->State = IP4_SERVICE_CONFIGED;
    return EFI_SUCCESS;
  }
 
  if (IpSb->Reconfig) {
    //
    // The default address is changed, free the previous interface first.
    //
    if (IpSb->DefaultRouteTable != NULL) {
      Ip4FreeRouteTable (IpSb->DefaultRouteTable);
      IpSb->DefaultRouteTable = NULL;
    }
 
    Ip4CancelReceive (IpSb->DefaultInterface);
    Ip4FreeInterface (IpSb->DefaultInterface, NULL);
    IpSb->DefaultInterface = NULL;
    //
    // Create new default interface and route table.
    //
    IpIf = Ip4CreateInterface (IpSb->Mnp, IpSb->Controller, IpSb->Image);
    if (IpIf == NULL) {
      return EFI_OUT_OF_RESOURCES;
    }
 
    RouteTable = Ip4CreateRouteTable ();
    if (RouteTable == NULL) {
      Ip4FreeInterface (IpIf, NULL);
      return EFI_OUT_OF_RESOURCES;
    }
 
    IpSb->DefaultInterface = IpIf;
    InsertHeadList (&IpSb->Interfaces, &IpIf->Link);
    IpSb->DefaultRouteTable = RouteTable;
    Ip4ReceiveFrame (IpIf, NULL, Ip4AccpetFrame, IpSb);
  }
 
  if (IpSb->State == IP4_SERVICE_CONFIGED) {
    IpSb->State = IP4_SERVICE_UNSTARTED;
  }
 
  Status = Ip4SetAddress (IpIf, StationAddress, SubnetMask);
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  if (IpIf->Arp != NULL) {
    //
    // A non-NULL IpIf->Arp here means a new ARP child is created when setting default address,
    // but some IP children may have referenced the default interface before it is configured,
    // these IP instances also consume this ARP protocol so they need to open it BY_CHILD_CONTROLLER.
    //
    Arp = NULL;
    NET_LIST_FOR_EACH (Entry, &IpIf->IpInstances) {
      Ip4Instance = NET_LIST_USER_STRUCT_S (Entry, IP4_PROTOCOL, AddrLink, IP4_PROTOCOL_SIGNATURE);
      Status      = gBS->OpenProtocol (
                           IpIf->ArpHandle,
                           &gEfiArpProtocolGuid,
                           (VOID **)&Arp,
                           gIp4DriverBinding.DriverBindingHandle,
                           Ip4Instance->Handle,
                           EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
                           );
      if (EFI_ERROR (Status)) {
        return Status;
      }
    }
  }
 
  //
  // Add a route for the connected network.
  //
  Subnet = StationAddress & SubnetMask;
 
  Ip4AddRoute (
    IpSb->DefaultRouteTable,
    Subnet,
    SubnetMask,
    IP4_ALLZERO_ADDRESS
    );
 
  IpSb->State    = IP4_SERVICE_CONFIGED;
  IpSb->Reconfig = FALSE;
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
Ip4Config2SetDefaultIf (
  IN IP4_CONFIG2_INSTANCE  *Instance,
  IN IP4_ADDR              StationAddress,
  IN IP4_ADDR              SubnetMask,
  IN IP4_ADDR              GatewayAddress
  )
{
  EFI_STATUS   Status;
  IP4_SERVICE  *IpSb;
 
  IpSb = IP4_SERVICE_FROM_IP4_CONFIG2_INSTANCE (Instance);
 
  //
  // Check whether the StationAddress/SubnetMask pair is valid.
  //
  if (!Ip4StationAddressValid (StationAddress, SubnetMask)) {
    return EFI_INVALID_PARAMETER;
  }
 
  Status = Ip4Config2SetDefaultAddr (IpSb, StationAddress, SubnetMask);
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  //
  // Create a route if there is a default router.
  //
  if (GatewayAddress != IP4_ALLZERO_ADDRESS) {
    Ip4AddRoute (
      IpSb->DefaultRouteTable,
      IP4_ALLZERO_ADDRESS,
      IP4_ALLZERO_ADDRESS,
      GatewayAddress
      );
  }
 
  return EFI_SUCCESS;
}
 
VOID
Ip4Config2CleanDhcp4 (
  IN IP4_CONFIG2_INSTANCE  *Instance
  )
{
  IP4_SERVICE  *IpSb;
 
  IpSb = IP4_SERVICE_FROM_IP4_CONFIG2_INSTANCE (Instance);
 
  if (Instance->Dhcp4 != NULL) {
    Instance->Dhcp4->Stop (Instance->Dhcp4);
 
    gBS->CloseProtocol (
           Instance->Dhcp4Handle,
           &gEfiDhcp4ProtocolGuid,
           IpSb->Image,
           IpSb->Controller
           );
 
    Instance->Dhcp4 = NULL;
  }
 
  if (Instance->Dhcp4Handle != NULL) {
    NetLibDestroyServiceChild (
      IpSb->Controller,
      IpSb->Image,
      &gEfiDhcp4ServiceBindingProtocolGuid,
      Instance->Dhcp4Handle
      );
 
    Instance->Dhcp4Handle = NULL;
  }
 
  if (Instance->Dhcp4Event != NULL) {
    gBS->CloseEvent (Instance->Dhcp4Event);
    Instance->Dhcp4Event = NULL;
  }
}
 
EFI_STATUS
Ip4Config2SetDnsServerWorker (
  IN IP4_CONFIG2_INSTANCE  *Instance,
  IN UINTN                 DataSize,
  IN VOID                  *Data
  )
{
  UINTN                  OldIndex;
  UINTN                  NewIndex;
  EFI_IPv4_ADDRESS       *OldDns;
  EFI_IPv4_ADDRESS       *NewDns;
  UINTN                  OldDnsCount;
  UINTN                  NewDnsCount;
  IP4_CONFIG2_DATA_ITEM  *Item;
  BOOLEAN                OneAdded;
  VOID                   *Tmp;
  IP4_ADDR               DnsAddress;
 
  if ((DataSize % sizeof (EFI_IPv4_ADDRESS) != 0) || (DataSize == 0)) {
    return EFI_BAD_BUFFER_SIZE;
  }
 
  Item        = &Instance->DataItem[Ip4Config2DataTypeDnsServer];
  NewDns      = (EFI_IPv4_ADDRESS *)Data;
  OldDns      = Item->Data.DnsServers;
  NewDnsCount = DataSize / sizeof (EFI_IPv4_ADDRESS);
  OldDnsCount = Item->DataSize / sizeof (EFI_IPv4_ADDRESS);
  OneAdded    = FALSE;
 
  if (NewDnsCount != OldDnsCount) {
    Tmp = AllocatePool (DataSize);
    if (Tmp == NULL) {
      return EFI_OUT_OF_RESOURCES;
    }
  } else {
    Tmp = NULL;
  }
 
  for (NewIndex = 0; NewIndex < NewDnsCount; NewIndex++) {
    CopyMem (&DnsAddress, NewDns + NewIndex, sizeof (IP4_ADDR));
    if (IP4_IS_UNSPECIFIED (NTOHL (DnsAddress)) || IP4_IS_LOCAL_BROADCAST (NTOHL (DnsAddress))) {
      //
      // The dns server address must be unicast.
      //
      if (Tmp != NULL) {
        FreePool (Tmp);
      }
 
      return EFI_INVALID_PARAMETER;
    }
 
    if (OneAdded) {
      //
      // If any address in the new setting is not in the old settings, skip the
      // comparision below.
      //
      continue;
    }
 
    for (OldIndex = 0; OldIndex < OldDnsCount; OldIndex++) {
      if (EFI_IP4_EQUAL (NewDns + NewIndex, OldDns + OldIndex)) {
        //
        // If found break out.
        //
        break;
      }
    }
 
    if (OldIndex == OldDnsCount) {
      OneAdded = TRUE;
    }
  }
 
  if (!OneAdded && (DataSize == Item->DataSize)) {
    //
    // No new item is added and the size is the same.
    //
    Item->Status = EFI_SUCCESS;
    return EFI_ABORTED;
  } else {
    if (Tmp != NULL) {
      if (Item->Data.Ptr != NULL) {
        FreePool (Item->Data.Ptr);
      }
 
      Item->Data.Ptr = Tmp;
    }
 
    CopyMem (Item->Data.Ptr, Data, DataSize);
    Item->DataSize = DataSize;
    Item->Status   = EFI_SUCCESS;
    return EFI_SUCCESS;
  }
}
 
VOID
EFIAPI
Ip4Config2OnDhcp4Complete (
  IN EFI_EVENT  Event,
  IN VOID       *Context
  )
{
  IP4_CONFIG2_INSTANCE     *Instance;
  EFI_DHCP4_MODE_DATA      Dhcp4Mode;
  EFI_STATUS               Status;
  IP4_ADDR                 StationAddress;
  IP4_ADDR                 SubnetMask;
  IP4_ADDR                 GatewayAddress;
  UINT32                   Index;
  UINT32                   OptionCount;
  EFI_DHCP4_PACKET_OPTION  **OptionList;
 
  Instance = (IP4_CONFIG2_INSTANCE *)Context;
  ASSERT (Instance->Dhcp4 != NULL);
 
  //
  // Get the DHCP retrieved parameters
  //
  Status = Instance->Dhcp4->GetModeData (Instance->Dhcp4, &Dhcp4Mode);
 
  if (EFI_ERROR (Status)) {
    goto Exit;
  }
 
  if (Dhcp4Mode.State == Dhcp4Bound) {
    StationAddress = EFI_NTOHL (Dhcp4Mode.ClientAddress);
    SubnetMask     = EFI_NTOHL (Dhcp4Mode.SubnetMask);
    GatewayAddress = EFI_NTOHL (Dhcp4Mode.RouterAddress);
 
    Status = Ip4Config2SetDefaultIf (Instance, StationAddress, SubnetMask, GatewayAddress);
    if (EFI_ERROR (Status)) {
      goto Exit;
    }
 
    //
    // Parse the ACK to get required DNS server information.
    //
    OptionCount = 0;
    OptionList  = NULL;
 
    Status = Instance->Dhcp4->Parse (Instance->Dhcp4, Dhcp4Mode.ReplyPacket, &OptionCount, OptionList);
    if (Status != EFI_BUFFER_TOO_SMALL) {
      goto Exit;
    }
 
    OptionList = AllocateZeroPool (OptionCount * sizeof (EFI_DHCP4_PACKET_OPTION *));
    if (OptionList == NULL) {
      goto Exit;
    }
 
    Status = Instance->Dhcp4->Parse (Instance->Dhcp4, Dhcp4Mode.ReplyPacket, &OptionCount, OptionList);
    if (EFI_ERROR (Status)) {
      FreePool (OptionList);
      goto Exit;
    }
 
    for (Index = 0; Index < OptionCount; Index++) {
      //
      // Look for DNS Server opcode (6).
      //
      if (OptionList[Index]->OpCode == DHCP4_TAG_DNS_SERVER) {
        if (((OptionList[Index]->Length & 0x3) != 0) || (OptionList[Index]->Length == 0)) {
          break;
        }
 
        Ip4Config2SetDnsServerWorker (Instance, OptionList[Index]->Length, &OptionList[Index]->Data[0]);
        break;
      }
    }
 
    FreePool (OptionList);
 
    Instance->DhcpSuccess = TRUE;
  }
 
Exit:
  Ip4Config2CleanDhcp4 (Instance);
  DispatchDpc ();
}
 
EFI_STATUS
Ip4StartAutoConfig (
  IN IP4_CONFIG2_INSTANCE  *Instance
  )
{
  IP4_SERVICE               *IpSb;
  EFI_DHCP4_PROTOCOL        *Dhcp4;
  EFI_DHCP4_MODE_DATA       Dhcp4Mode;
  EFI_DHCP4_PACKET_OPTION   *OptionList[1];
  IP4_CONFIG2_DHCP4_OPTION  ParaList;
  EFI_STATUS                Status;
 
  IpSb = IP4_SERVICE_FROM_IP4_CONFIG2_INSTANCE (Instance);
 
  if (IpSb->State > IP4_SERVICE_UNSTARTED) {
    return EFI_SUCCESS;
  }
 
  //
  // A host must not invoke DHCP configuration if it is already
  // participating in the DHCP configuration process.
  //
  if (Instance->Dhcp4Handle != NULL) {
    return EFI_SUCCESS;
  }
 
  Status = NetLibCreateServiceChild (
             IpSb->Controller,
             IpSb->Image,
             &gEfiDhcp4ServiceBindingProtocolGuid,
             &Instance->Dhcp4Handle
             );
 
  if (Status == EFI_UNSUPPORTED) {
    //
    // No DHCPv4 Service Binding protocol, register a notify.
    //
    if (Instance->Dhcp4SbNotifyEvent == NULL) {
      Instance->Dhcp4SbNotifyEvent = EfiCreateProtocolNotifyEvent (
                                       &gEfiDhcp4ServiceBindingProtocolGuid,
                                       TPL_CALLBACK,
                                       Ip4Config2OnDhcp4SbInstalled,
                                       (VOID *)Instance,
                                       &Instance->Registration
                                       );
    }
  }
 
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  if (Instance->Dhcp4SbNotifyEvent != NULL) {
    gBS->CloseEvent (Instance->Dhcp4SbNotifyEvent);
  }
 
  Status = gBS->OpenProtocol (
                  Instance->Dhcp4Handle,
                  &gEfiDhcp4ProtocolGuid,
                  (VOID **)&Instance->Dhcp4,
                  IpSb->Image,
                  IpSb->Controller,
                  EFI_OPEN_PROTOCOL_BY_DRIVER
                  );
  if (EFI_ERROR (Status)) {
    NetLibDestroyServiceChild (
      IpSb->Controller,
      IpSb->Image,
      &gEfiDhcp4ServiceBindingProtocolGuid,
      Instance->Dhcp4Handle
      );
 
    Instance->Dhcp4Handle = NULL;
 
    return Status;
  }
 
  //
  // Check the current DHCP status, if the DHCP process has
  // already finished, return now.
  //
  Dhcp4  = Instance->Dhcp4;
  Status = Dhcp4->GetModeData (Dhcp4, &Dhcp4Mode);
  if (Dhcp4Mode.State == Dhcp4Bound) {
    Ip4Config2OnDhcp4Complete (NULL, Instance);
 
    return EFI_SUCCESS;
  }
 
  //
  // Try to start the DHCP process. Use most of the current
  // DHCP configuration to avoid problems if some DHCP client
  // yields the control of this DHCP service to us.
  //
  ParaList.Head.OpCode             = DHCP4_TAG_PARA_LIST;
  ParaList.Head.Length             = 3;
  ParaList.Head.Data[0]            = DHCP4_TAG_NETMASK;
  ParaList.Route                   = DHCP4_TAG_ROUTER;
  ParaList.Dns                     = DHCP4_TAG_DNS_SERVER;
  OptionList[0]                    = &ParaList.Head;
  Dhcp4Mode.ConfigData.OptionCount = 1;
  Dhcp4Mode.ConfigData.OptionList  = OptionList;
 
  Status = Dhcp4->Configure (Dhcp4, &Dhcp4Mode.ConfigData);
  if (EFI_ERROR (Status)) {
    gBS->CloseProtocol (
           Instance->Dhcp4Handle,
           &gEfiDhcp4ProtocolGuid,
           IpSb->Image,
           IpSb->Controller
           );
 
    NetLibDestroyServiceChild (
      IpSb->Controller,
      IpSb->Image,
      &gEfiDhcp4ServiceBindingProtocolGuid,
      Instance->Dhcp4Handle
      );
 
    Instance->Dhcp4 = NULL;
 
    Instance->Dhcp4Handle = NULL;
 
    return Status;
  }
 
  //
  // Start the DHCP process
  //
  Status = gBS->CreateEvent (
                  EVT_NOTIFY_SIGNAL,
                  TPL_CALLBACK,
                  Ip4Config2OnDhcp4Complete,
                  Instance,
                  &Instance->Dhcp4Event
                  );
  if (EFI_ERROR (Status)) {
    Ip4Config2DestroyDhcp4 (Instance);
    return Status;
  }
 
  Status = Dhcp4->Start (Dhcp4, Instance->Dhcp4Event);
  if (EFI_ERROR (Status)) {
    Ip4Config2DestroyDhcp4 (Instance);
    gBS->CloseEvent (Instance->Dhcp4Event);
    Instance->Dhcp4Event = NULL;
 
    return Status;
  }
 
  IpSb->State = IP4_SERVICE_STARTED;
  DispatchDpc ();
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
Ip4Config2GetIfInfo (
  IN IP4_CONFIG2_INSTANCE  *Instance,
  IN OUT UINTN             *DataSize,
  IN VOID                  *Data      OPTIONAL
  )
{
  IP4_SERVICE                     *IpSb;
  UINTN                           Length;
  IP4_CONFIG2_DATA_ITEM           *Item;
  EFI_IP4_CONFIG2_INTERFACE_INFO  *IfInfo;
  IP4_ADDR                        Address;
 
  IpSb   = IP4_SERVICE_FROM_IP4_CONFIG2_INSTANCE (Instance);
  Length = sizeof (EFI_IP4_CONFIG2_INTERFACE_INFO);
 
  if (IpSb->DefaultRouteTable != NULL) {
    Length += IpSb->DefaultRouteTable->TotalNum * sizeof (EFI_IP4_ROUTE_TABLE);
  }
 
  if (*DataSize < Length) {
    *DataSize = Length;
    return EFI_BUFFER_TOO_SMALL;
  }
 
  //
  // Copy the fixed size part of the interface info.
  //
  Item   = &Instance->DataItem[Ip4Config2DataTypeInterfaceInfo];
  IfInfo = (EFI_IP4_CONFIG2_INTERFACE_INFO *)Data;
  CopyMem (IfInfo, Item->Data.Ptr, sizeof (EFI_IP4_CONFIG2_INTERFACE_INFO));
 
  //
  // Update the address info.
  //
  if (IpSb->DefaultInterface != NULL) {
    Address = HTONL (IpSb->DefaultInterface->Ip);
    CopyMem (&IfInfo->StationAddress, &Address, sizeof (EFI_IPv4_ADDRESS));
    Address = HTONL (IpSb->DefaultInterface->SubnetMask);
    CopyMem (&IfInfo->SubnetMask, &Address, sizeof (EFI_IPv4_ADDRESS));
  }
 
  if (IpSb->DefaultRouteTable != NULL) {
    IfInfo->RouteTableSize = IpSb->DefaultRouteTable->TotalNum;
    IfInfo->RouteTable     = (EFI_IP4_ROUTE_TABLE *)((UINT8 *)Data + sizeof (EFI_IP4_CONFIG2_INTERFACE_INFO));
 
    Ip4Config2BuildDefaultRouteTable (IpSb, IfInfo->RouteTable);
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
Ip4Config2SetPolicy (
  IN IP4_CONFIG2_INSTANCE  *Instance,
  IN UINTN                 DataSize,
  IN VOID                  *Data
  )
{
  EFI_IP4_CONFIG2_POLICY  NewPolicy;
  IP4_CONFIG2_DATA_ITEM   *DataItem;
  IP4_SERVICE             *IpSb;
 
  if (DataSize != sizeof (EFI_IP4_CONFIG2_POLICY)) {
    return EFI_BAD_BUFFER_SIZE;
  }
 
  NewPolicy = *((EFI_IP4_CONFIG2_POLICY *)Data);
 
  if (NewPolicy >= Ip4Config2PolicyMax) {
    return EFI_INVALID_PARAMETER;
  }
 
  if (NewPolicy == Instance->Policy) {
    if ((NewPolicy != Ip4Config2PolicyDhcp) || Instance->DhcpSuccess) {
      return EFI_ABORTED;
    }
  } else {
    //
    // The policy is changed. Clean the ManualAddress, Gateway and DnsServers,
    // shrink the variable data size, and fire up all the related events.
    //
    DataItem = &Instance->DataItem[Ip4Config2DataTypeManualAddress];
    if (DataItem->Data.Ptr != NULL) {
      FreePool (DataItem->Data.Ptr);
    }
 
    DataItem->Data.Ptr = NULL;
    DataItem->DataSize = 0;
    DataItem->Status   = EFI_NOT_FOUND;
    NetMapIterate (&DataItem->EventMap, Ip4Config2SignalEvent, NULL);
 
    DataItem = &Instance->DataItem[Ip4Config2DataTypeGateway];
    if (DataItem->Data.Ptr != NULL) {
      FreePool (DataItem->Data.Ptr);
    }
 
    DataItem->Data.Ptr = NULL;
    DataItem->DataSize = 0;
    DataItem->Status   = EFI_NOT_FOUND;
    NetMapIterate (&DataItem->EventMap, Ip4Config2SignalEvent, NULL);
 
    DataItem = &Instance->DataItem[Ip4Config2DataTypeDnsServer];
    if (DataItem->Data.Ptr != NULL) {
      FreePool (DataItem->Data.Ptr);
    }
 
    DataItem->Data.Ptr = NULL;
    DataItem->DataSize = 0;
    DataItem->Status   = EFI_NOT_FOUND;
    NetMapIterate (&DataItem->EventMap, Ip4Config2SignalEvent, NULL);
 
    if (NewPolicy == Ip4Config2PolicyDhcp) {
      SET_DATA_ATTRIB (DataItem->Attribute, DATA_ATTRIB_VOLATILE);
    } else {
      //
      // The policy is changed from dhcp to static. Stop the DHCPv4 process
      // and destroy the DHCPv4 child.
      //
      if (Instance->Dhcp4Handle != NULL) {
        Ip4Config2DestroyDhcp4 (Instance);
      }
 
      //
      // Close the event.
      //
      if (Instance->Dhcp4Event != NULL) {
        gBS->CloseEvent (Instance->Dhcp4Event);
        Instance->Dhcp4Event = NULL;
      }
    }
  }
 
  IpSb = IP4_SERVICE_FROM_IP4_CONFIG2_INSTANCE (Instance);
  Ip4Config2OnPolicyChanged (IpSb, NewPolicy);
 
  Instance->Policy = NewPolicy;
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
Ip4Config2SetManualAddress (
  IN IP4_CONFIG2_INSTANCE  *Instance,
  IN UINTN                 DataSize,
  IN VOID                  *Data
  )
{
  EFI_IP4_CONFIG2_MANUAL_ADDRESS  NewAddress;
  IP4_CONFIG2_DATA_ITEM           *DataItem;
  EFI_STATUS                      Status;
  IP4_ADDR                        StationAddress;
  IP4_ADDR                        SubnetMask;
  VOID                            *Ptr;
  IP4_SERVICE                     *IpSb;
  IP4_INTERFACE                   *IpIf;
  IP4_ROUTE_TABLE                 *RouteTable;
 
  DataItem   = NULL;
  Status     = EFI_SUCCESS;
  Ptr        = NULL;
  IpIf       = NULL;
  RouteTable = NULL;
 
  IpSb = IP4_SERVICE_FROM_IP4_CONFIG2_INSTANCE (Instance);
 
  ASSERT (Instance->DataItem[Ip4Config2DataTypeManualAddress].Status != EFI_NOT_READY);
 
  if ((DataSize != 0) && ((DataSize % sizeof (EFI_IP4_CONFIG2_MANUAL_ADDRESS)) != 0)) {
    return EFI_BAD_BUFFER_SIZE;
  }
 
  if (Instance->Policy != Ip4Config2PolicyStatic) {
    return EFI_WRITE_PROTECTED;
  }
 
  DataItem = &Instance->DataItem[Ip4Config2DataTypeManualAddress];
 
  if ((Data != NULL) && (DataSize != 0)) {
    NewAddress = *((EFI_IP4_CONFIG2_MANUAL_ADDRESS *)Data);
 
    StationAddress = EFI_NTOHL (NewAddress.Address);
    SubnetMask     = EFI_NTOHL (NewAddress.SubnetMask);
 
    //
    // Check whether the StationAddress/SubnetMask pair is valid.
    //
    if (!Ip4StationAddressValid (StationAddress, SubnetMask)) {
      return EFI_INVALID_PARAMETER;
    }
 
    //
    // Store the new data, and init the DataItem status to EFI_NOT_READY because
    // we may have an asynchronous configuration process.
    //
    Ptr = AllocateCopyPool (DataSize, Data);
    if (Ptr == NULL) {
      return EFI_OUT_OF_RESOURCES;
    }
 
    if (DataItem->Data.Ptr != NULL) {
      FreePool (DataItem->Data.Ptr);
    }
 
    DataItem->Data.Ptr = Ptr;
    DataItem->DataSize = DataSize;
    DataItem->Status   = EFI_NOT_READY;
 
    IpSb->Reconfig = TRUE;
    Status         = Ip4Config2SetDefaultAddr (IpSb, StationAddress, SubnetMask);
 
    DataItem->Status = Status;
 
    if (EFI_ERROR (DataItem->Status) && (DataItem->Status != EFI_NOT_READY)) {
      if (Ptr != NULL) {
        FreePool (Ptr);
      }
 
      DataItem->Data.Ptr = NULL;
    }
  } else {
    //
    // DataSize is 0 and Data is NULL, clean up the manual address.
    //
    if (DataItem->Data.Ptr != NULL) {
      FreePool (DataItem->Data.Ptr);
    }
 
    DataItem->Data.Ptr = NULL;
    DataItem->DataSize = 0;
    DataItem->Status   = EFI_NOT_FOUND;
 
    //
    // Free the default router table and Interface, clean up the assemble table.
    //
    if (IpSb->DefaultInterface != NULL) {
      if (IpSb->DefaultRouteTable != NULL) {
        Ip4FreeRouteTable (IpSb->DefaultRouteTable);
        IpSb->DefaultRouteTable = NULL;
      }
 
      Ip4CancelReceive (IpSb->DefaultInterface);
 
      Ip4FreeInterface (IpSb->DefaultInterface, NULL);
      IpSb->DefaultInterface = NULL;
    }
 
    Ip4CleanAssembleTable (&IpSb->Assemble);
 
    //
    // Create new default interface and route table.
    //
    IpIf = Ip4CreateInterface (IpSb->Mnp, IpSb->Controller, IpSb->Image);
    if (IpIf == NULL) {
      return EFI_OUT_OF_RESOURCES;
    }
 
    RouteTable = Ip4CreateRouteTable ();
    if (RouteTable == NULL) {
      Ip4FreeInterface (IpIf, NULL);
      return EFI_OUT_OF_RESOURCES;
    }
 
    IpSb->DefaultInterface = IpIf;
    InsertHeadList (&IpSb->Interfaces, &IpIf->Link);
    IpSb->DefaultRouteTable = RouteTable;
    Ip4ReceiveFrame (IpIf, NULL, Ip4AccpetFrame, IpSb);
 
    //
    // Reset the State to unstarted.
    //
    if ((IpSb->State == IP4_SERVICE_CONFIGED) || (IpSb->State == IP4_SERVICE_STARTED)) {
      IpSb->State = IP4_SERVICE_UNSTARTED;
    }
  }
 
  return Status;
}
 
EFI_STATUS
Ip4Config2SetGateway (
  IN IP4_CONFIG2_INSTANCE  *Instance,
  IN UINTN                 DataSize,
  IN VOID                  *Data
  )
{
  IP4_SERVICE            *IpSb;
  IP4_CONFIG2_DATA_ITEM  *DataItem;
  IP4_ADDR               Gateway;
 
  UINTN             Index1;
  UINTN             Index2;
  EFI_IPv4_ADDRESS  *OldGateway;
  EFI_IPv4_ADDRESS  *NewGateway;
  UINTN             OldGatewayCount;
  UINTN             NewGatewayCount;
  BOOLEAN           OneRemoved;
  BOOLEAN           OneAdded;
  VOID              *Tmp;
 
  OldGateway = NULL;
  NewGateway = NULL;
  OneRemoved = FALSE;
  OneAdded   = FALSE;
  Tmp        = NULL;
 
  if ((DataSize != 0) && (DataSize % sizeof (EFI_IPv4_ADDRESS) != 0)) {
    return EFI_BAD_BUFFER_SIZE;
  }
 
  if (Instance->Policy != Ip4Config2PolicyStatic) {
    return EFI_WRITE_PROTECTED;
  }
 
  IpSb = IP4_SERVICE_FROM_IP4_CONFIG2_INSTANCE (Instance);
 
  DataItem        = &Instance->DataItem[Ip4Config2DataTypeGateway];
  OldGateway      = DataItem->Data.Gateway;
  OldGatewayCount = DataItem->DataSize / sizeof (EFI_IPv4_ADDRESS);
 
  for (Index1 = 0; Index1 < OldGatewayCount; Index1++) {
    //
    // Remove the old route entry.
    //
    CopyMem (&Gateway, OldGateway + Index1, sizeof (IP4_ADDR));
    Ip4DelRoute (
      IpSb->DefaultRouteTable,
      IP4_ALLZERO_ADDRESS,
      IP4_ALLZERO_ADDRESS,
      NTOHL (Gateway)
      );
    OneRemoved = TRUE;
  }
 
  if ((Data != NULL) && (DataSize != 0)) {
    NewGateway      = (EFI_IPv4_ADDRESS *)Data;
    NewGatewayCount = DataSize / sizeof (EFI_IPv4_ADDRESS);
    for (Index1 = 0; Index1 < NewGatewayCount; Index1++) {
      CopyMem (&Gateway, NewGateway + Index1, sizeof (IP4_ADDR));
 
      if ((IpSb->DefaultInterface->SubnetMask != 0) &&
          !NetIp4IsUnicast (NTOHL (Gateway), IpSb->DefaultInterface->SubnetMask))
      {
        return EFI_INVALID_PARAMETER;
      }
 
      for (Index2 = Index1 + 1; Index2 < NewGatewayCount; Index2++) {
        if (EFI_IP4_EQUAL (NewGateway + Index1, NewGateway + Index2)) {
          return EFI_INVALID_PARAMETER;
        }
      }
    }
 
    if (NewGatewayCount != OldGatewayCount) {
      Tmp = AllocatePool (DataSize);
      if (Tmp == NULL) {
        return EFI_OUT_OF_RESOURCES;
      }
    } else {
      Tmp = NULL;
    }
 
    for (Index1 = 0; Index1 < NewGatewayCount; Index1++) {
      //
      // Add the new route entry.
      //
      CopyMem (&Gateway, NewGateway + Index1, sizeof (IP4_ADDR));
      Ip4AddRoute (
        IpSb->DefaultRouteTable,
        IP4_ALLZERO_ADDRESS,
        IP4_ALLZERO_ADDRESS,
        NTOHL (Gateway)
        );
 
      OneAdded = TRUE;
    }
 
    if (!OneRemoved && !OneAdded) {
      DataItem->Status = EFI_SUCCESS;
      return EFI_ABORTED;
    } else {
      if (Tmp != NULL) {
        if (DataItem->Data.Ptr != NULL) {
          FreePool (DataItem->Data.Ptr);
        }
 
        DataItem->Data.Ptr = Tmp;
      }
 
      CopyMem (DataItem->Data.Ptr, Data, DataSize);
      DataItem->DataSize = DataSize;
      DataItem->Status   = EFI_SUCCESS;
    }
  } else {
    //
    // DataSize is 0 and Data is NULL, clean up the Gateway address.
    //
    if (DataItem->Data.Ptr != NULL) {
      FreePool (DataItem->Data.Ptr);
    }
 
    DataItem->Data.Ptr = NULL;
    DataItem->DataSize = 0;
    DataItem->Status   = EFI_NOT_FOUND;
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
Ip4Config2SetDnsServer (
  IN IP4_CONFIG2_INSTANCE  *Instance,
  IN UINTN                 DataSize,
  IN VOID                  *Data
  )
{
  EFI_STATUS             Status;
  IP4_CONFIG2_DATA_ITEM  *Item;
 
  Status = EFI_SUCCESS;
  Item   = NULL;
 
  if (Instance->Policy != Ip4Config2PolicyStatic) {
    return EFI_WRITE_PROTECTED;
  }
 
  Item = &Instance->DataItem[Ip4Config2DataTypeDnsServer];
 
  if (DATA_ATTRIB_SET (Item->Attribute, DATA_ATTRIB_VOLATILE)) {
    REMOVE_DATA_ATTRIB (Item->Attribute, DATA_ATTRIB_VOLATILE);
  }
 
  if ((Data != NULL) && (DataSize != 0)) {
    Status = Ip4Config2SetDnsServerWorker (Instance, DataSize, Data);
  } else {
    //
    // DataSize is 0 and Data is NULL, clean up the DnsServer address.
    //
    if (Item->Data.Ptr != NULL) {
      FreePool (Item->Data.Ptr);
    }
 
    Item->Data.Ptr = NULL;
    Item->DataSize = 0;
    Item->Status   = EFI_NOT_FOUND;
  }
 
  return Status;
}
 
VOID
Ip4Config2InitIfInfo (
  IN  IP4_SERVICE                     *IpSb,
  OUT EFI_IP4_CONFIG2_INTERFACE_INFO  *IfInfo
  )
{
  UnicodeSPrint (
    IfInfo->Name,
    EFI_IP4_CONFIG2_INTERFACE_INFO_NAME_SIZE,
    L"eth%d",
    IpSb->Ip4Config2Instance.IfIndex
    );
 
  IfInfo->IfType        = IpSb->SnpMode.IfType;
  IfInfo->HwAddressSize = IpSb->SnpMode.HwAddressSize;
  CopyMem (&IfInfo->HwAddress, &IpSb->SnpMode.CurrentAddress, IfInfo->HwAddressSize);
}
 
EFI_STATUS
EFIAPI
EfiIp4Config2SetData (
  IN EFI_IP4_CONFIG2_PROTOCOL   *This,
  IN EFI_IP4_CONFIG2_DATA_TYPE  DataType,
  IN UINTN                      DataSize,
  IN VOID                       *Data
  )
{
  EFI_TPL               OldTpl;
  EFI_STATUS            Status;
  IP4_CONFIG2_INSTANCE  *Instance;
  IP4_SERVICE           *IpSb;
 
  if ((This == NULL) || ((Data == NULL) && (DataSize != 0)) || ((Data != NULL) && (DataSize == 0))) {
    return EFI_INVALID_PARAMETER;
  }
 
  if (DataType >= Ip4Config2DataTypeMaximum) {
    return EFI_UNSUPPORTED;
  }
 
  Instance = IP4_CONFIG2_INSTANCE_FROM_PROTOCOL (This);
  IpSb     = IP4_SERVICE_FROM_IP4_CONFIG2_INSTANCE (Instance);
  NET_CHECK_SIGNATURE (IpSb, IP4_SERVICE_SIGNATURE);
 
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  Status = Instance->DataItem[DataType].Status;
  if (Status != EFI_NOT_READY) {
    if (Instance->DataItem[DataType].SetData == NULL) {
      //
      // This type of data is readonly.
      //
      Status = EFI_WRITE_PROTECTED;
    } else {
      Status = Instance->DataItem[DataType].SetData (Instance, DataSize, Data);
      if (!EFI_ERROR (Status)) {
        //
        // Fire up the events registered with this type of data.
        //
        NetMapIterate (&Instance->DataItem[DataType].EventMap, Ip4Config2SignalEvent, NULL);
        Ip4Config2WriteConfigData (IpSb->MacString, Instance);
      } else if (Status == EFI_ABORTED) {
        //
        // The SetData is aborted because the data to set is the same with
        // the one maintained.
        //
        Status = EFI_SUCCESS;
        NetMapIterate (&Instance->DataItem[DataType].EventMap, Ip4Config2SignalEvent, NULL);
      }
    }
  } else {
    //
    // Another asynchronous process is on the way.
    //
    Status = EFI_ACCESS_DENIED;
  }
 
  gBS->RestoreTPL (OldTpl);
 
  return Status;
}
 
EFI_STATUS
EFIAPI
EfiIp4Config2GetData (
  IN EFI_IP4_CONFIG2_PROTOCOL   *This,
  IN EFI_IP4_CONFIG2_DATA_TYPE  DataType,
  IN OUT UINTN                  *DataSize,
  IN VOID                       *Data   OPTIONAL
  )
{
  EFI_TPL                OldTpl;
  EFI_STATUS             Status;
  IP4_CONFIG2_INSTANCE   *Instance;
  IP4_CONFIG2_DATA_ITEM  *DataItem;
 
  if ((This == NULL) || (DataSize == NULL) || ((*DataSize != 0) && (Data == NULL))) {
    return EFI_INVALID_PARAMETER;
  }
 
  if (DataType >= Ip4Config2DataTypeMaximum) {
    return EFI_NOT_FOUND;
  }
 
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  Instance = IP4_CONFIG2_INSTANCE_FROM_PROTOCOL (This);
  DataItem = &Instance->DataItem[DataType];
 
  Status = Instance->DataItem[DataType].Status;
  if (!EFI_ERROR (Status)) {
    if (DataItem->GetData != NULL) {
      Status = DataItem->GetData (Instance, DataSize, Data);
    } else if (*DataSize < Instance->DataItem[DataType].DataSize) {
      //
      // Update the buffer length.
      //
      *DataSize = Instance->DataItem[DataType].DataSize;
      Status    = EFI_BUFFER_TOO_SMALL;
    } else {
      *DataSize = Instance->DataItem[DataType].DataSize;
      CopyMem (Data, Instance->DataItem[DataType].Data.Ptr, *DataSize);
    }
  }
 
  gBS->RestoreTPL (OldTpl);
 
  return Status;
}
 
EFI_STATUS
EFIAPI
EfiIp4Config2RegisterDataNotify (
  IN EFI_IP4_CONFIG2_PROTOCOL   *This,
  IN EFI_IP4_CONFIG2_DATA_TYPE  DataType,
  IN EFI_EVENT                  Event
  )
{
  EFI_TPL               OldTpl;
  EFI_STATUS            Status;
  IP4_CONFIG2_INSTANCE  *Instance;
  NET_MAP               *EventMap;
  NET_MAP_ITEM          *Item;
 
  if ((This == NULL) || (Event == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  if (DataType >= Ip4Config2DataTypeMaximum) {
    return EFI_UNSUPPORTED;
  }
 
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  Instance = IP4_CONFIG2_INSTANCE_FROM_PROTOCOL (This);
  EventMap = &Instance->DataItem[DataType].EventMap;
 
  //
  // Check whether this event is already registered for this DataType.
  //
  Item = NetMapFindKey (EventMap, Event);
  if (Item == NULL) {
    Status = NetMapInsertTail (EventMap, Event, NULL);
 
    if (EFI_ERROR (Status)) {
      Status = EFI_OUT_OF_RESOURCES;
    }
  } else {
    Status = EFI_ACCESS_DENIED;
  }
 
  gBS->RestoreTPL (OldTpl);
 
  return Status;
}
 
EFI_STATUS
EFIAPI
EfiIp4Config2UnregisterDataNotify (
  IN EFI_IP4_CONFIG2_PROTOCOL   *This,
  IN EFI_IP4_CONFIG2_DATA_TYPE  DataType,
  IN EFI_EVENT                  Event
  )
{
  EFI_TPL               OldTpl;
  EFI_STATUS            Status;
  IP4_CONFIG2_INSTANCE  *Instance;
  NET_MAP_ITEM          *Item;
 
  if ((This == NULL) || (Event == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  if (DataType >= Ip4Config2DataTypeMaximum) {
    return EFI_NOT_FOUND;
  }
 
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  Instance = IP4_CONFIG2_INSTANCE_FROM_PROTOCOL (This);
 
  Item = NetMapFindKey (&Instance->DataItem[DataType].EventMap, Event);
  if (Item != NULL) {
    NetMapRemoveItem (&Instance->DataItem[DataType].EventMap, Item, NULL);
    Status = EFI_SUCCESS;
  } else {
    Status = EFI_NOT_FOUND;
  }
 
  gBS->RestoreTPL (OldTpl);
 
  return Status;
}
 
EFI_STATUS
Ip4Config2InitInstance (
  OUT IP4_CONFIG2_INSTANCE  *Instance
  )
{
  IP4_SERVICE            *IpSb;
  IP4_CONFIG2_INSTANCE   *TmpInstance;
  LIST_ENTRY             *Entry;
  EFI_STATUS             Status;
  UINTN                  Index;
  UINT16                 IfIndex;
  IP4_CONFIG2_DATA_ITEM  *DataItem;
 
  IpSb = IP4_SERVICE_FROM_IP4_CONFIG2_INSTANCE (Instance);
 
  Instance->Signature = IP4_CONFIG2_INSTANCE_SIGNATURE;
 
  //
  // Determine the index of this interface.
  //
  IfIndex = 0;
  NET_LIST_FOR_EACH (Entry, &mIp4Config2InstanceList) {
    TmpInstance = NET_LIST_USER_STRUCT_S (Entry, IP4_CONFIG2_INSTANCE, Link, IP4_CONFIG2_INSTANCE_SIGNATURE);
 
    if (TmpInstance->IfIndex > IfIndex) {
      //
      // There is a sequence hole because some interface is down.
      //
      break;
    }
 
    IfIndex++;
  }
 
  Instance->IfIndex = IfIndex;
  NetListInsertBefore (Entry, &Instance->Link);
 
  for (Index = 0; Index < Ip4Config2DataTypeMaximum; Index++) {
    //
    // Initialize the event map for each data item.
    //
    NetMapInit (&Instance->DataItem[Index].EventMap);
  }
 
  //
  // Initialize each data type: associate storage and set data size for the
  // fixed size data types, hook the SetData function, set the data attribute.
  //
  DataItem           = &Instance->DataItem[Ip4Config2DataTypeInterfaceInfo];
  DataItem->GetData  = Ip4Config2GetIfInfo;
  DataItem->Data.Ptr = &Instance->InterfaceInfo;
  DataItem->DataSize = sizeof (Instance->InterfaceInfo);
  SET_DATA_ATTRIB (DataItem->Attribute, DATA_ATTRIB_SIZE_FIXED | DATA_ATTRIB_VOLATILE);
  Ip4Config2InitIfInfo (IpSb, &Instance->InterfaceInfo);
 
  DataItem           = &Instance->DataItem[Ip4Config2DataTypePolicy];
  DataItem->SetData  = Ip4Config2SetPolicy;
  DataItem->Data.Ptr = &Instance->Policy;
  DataItem->DataSize = sizeof (Instance->Policy);
  Instance->Policy   = Ip4Config2PolicyStatic;
  SET_DATA_ATTRIB (DataItem->Attribute, DATA_ATTRIB_SIZE_FIXED);
 
  DataItem          = &Instance->DataItem[Ip4Config2DataTypeManualAddress];
  DataItem->SetData = Ip4Config2SetManualAddress;
  DataItem->Status  = EFI_NOT_FOUND;
 
  DataItem          = &Instance->DataItem[Ip4Config2DataTypeGateway];
  DataItem->SetData = Ip4Config2SetGateway;
  DataItem->Status  = EFI_NOT_FOUND;
 
  DataItem          = &Instance->DataItem[Ip4Config2DataTypeDnsServer];
  DataItem->SetData = Ip4Config2SetDnsServer;
  DataItem->Status  = EFI_NOT_FOUND;
 
  Instance->Configured = TRUE;
 
  //
  // Try to read the config data from NV variable.
  // If not found, write initialized config data into NV variable
  // as a default config data.
  //
  Status = Ip4Config2ReadConfigData (IpSb->MacString, Instance);
  if (Status == EFI_NOT_FOUND) {
    Status = Ip4Config2WriteConfigData (IpSb->MacString, Instance);
  }
 
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  Instance->Ip4Config2.SetData              = EfiIp4Config2SetData;
  Instance->Ip4Config2.GetData              = EfiIp4Config2GetData;
  Instance->Ip4Config2.RegisterDataNotify   = EfiIp4Config2RegisterDataNotify;
  Instance->Ip4Config2.UnregisterDataNotify = EfiIp4Config2UnregisterDataNotify;
 
  //
  // Publish the IP4 configuration form
  //
  return Ip4Config2FormInit (Instance);
}
 
VOID
Ip4Config2CleanInstance (
  IN OUT IP4_CONFIG2_INSTANCE  *Instance
  )
{
  UINTN                  Index;
  IP4_CONFIG2_DATA_ITEM  *DataItem;
 
  if (Instance->DeclineAddress != NULL) {
    FreePool (Instance->DeclineAddress);
  }
 
  if (!Instance->Configured) {
    return;
  }
 
  if (Instance->Dhcp4Handle != NULL) {
    Ip4Config2DestroyDhcp4 (Instance);
  }
 
  //
  // Close the event.
  //
  if (Instance->Dhcp4Event != NULL) {
    gBS->CloseEvent (Instance->Dhcp4Event);
    Instance->Dhcp4Event = NULL;
  }
 
  for (Index = 0; Index < Ip4Config2DataTypeMaximum; Index++) {
    DataItem = &Instance->DataItem[Index];
 
    if (!DATA_ATTRIB_SET (DataItem->Attribute, DATA_ATTRIB_SIZE_FIXED)) {
      if (DataItem->Data.Ptr != NULL) {
        FreePool (DataItem->Data.Ptr);
      }
 
      DataItem->Data.Ptr = NULL;
      DataItem->DataSize = 0;
    }
 
    NetMapClean (&Instance->DataItem[Index].EventMap);
  }
 
  Ip4Config2FormUnload (Instance);
 
  RemoveEntryList (&Instance->Link);
}
 
VOID
EFIAPI
Ip4AutoReconfigCallBackDpc (
  IN VOID  *Context
  )
{
  IP4_SERVICE  *IpSb;
 
  IpSb = (IP4_SERVICE *)Context;
  NET_CHECK_SIGNATURE (IpSb, IP4_SERVICE_SIGNATURE);
 
  if (IpSb->State > IP4_SERVICE_UNSTARTED) {
    IpSb->State = IP4_SERVICE_UNSTARTED;
  }
 
  IpSb->Reconfig = TRUE;
 
  Ip4StartAutoConfig (&IpSb->Ip4Config2Instance);
 
  return;
}
 
VOID
EFIAPI
Ip4AutoReconfigCallBack (
  IN EFI_EVENT  Event,
  IN VOID       *Context
  )
{
  //
  // Request Ip4AutoReconfigCallBackDpc as a DPC at TPL_CALLBACK
  //
  QueueDpc (TPL_CALLBACK, Ip4AutoReconfigCallBackDpc, Context);
}