MdeModulePkg/Universal/Network/Ip4Dxe/Ip4Config2Impl.c

   1 /** @file
   2   The implementation of EFI IPv4 Configuration II Protocol.
   3
   4   Copyright (c) 2015 - 2018, Intel Corporation. All rights reserved.<BR>
   5   (C) Copyright 2015-2016 Hewlett Packard Enterprise Development LP<BR>
   6
   7   This program and the accompanying materials
   8   are licensed and made available under the terms and conditions of the BSD License
   9   which accompanies this distribution.  The full text of the license may be found at
  10   http://opensource.org/licenses/bsd-license.php.
  11
  12   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  13   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  14
  15 **/
  16
  17 #include "Ip4Impl.h"
  18
  19 LIST_ENTRY  mIp4Config2InstanceList = {&mIp4Config2InstanceList, &mIp4Config2InstanceList};
  20
  21 /**
  22   The event process routine when the DHCPv4 service binding protocol is installed
  23   in the system.
  24
  25   @param[in]     Event         Not used.
  26   @param[in]     Context       Pointer to the IP4 config2 instance data.
  27
  28 **/
  29 VOID
  30 EFIAPI
  31 Ip4Config2OnDhcp4SbInstalled (
  32   IN EFI_EVENT  Event,
  33   IN VOID       *Context
  34   );
  35
  36 /**
  37   Destroy the Dhcp4 child in IP4_CONFIG2_INSTANCE and release the resources.
  38
  39   @param[in, out] Instance    The buffer of IP4 config2 instance to be freed.
  40
  41   @retval EFI_SUCCESS         The child was successfully destroyed.
  42   @retval Others              Failed to destroy the child.
  43
  44 **/
  45 EFI_STATUS
  46 Ip4Config2DestroyDhcp4 (
  47   IN OUT IP4_CONFIG2_INSTANCE  *Instance
  48   )
  49 {
  50   IP4_SERVICE                 *IpSb;
  51   EFI_STATUS                  Status;
  52   EFI_DHCP4_PROTOCOL          *Dhcp4;
  53
  54   Dhcp4 = Instance->Dhcp4;
  55   ASSERT (Dhcp4 != NULL);
  56
  57   Dhcp4->Stop (Dhcp4);
  58   Dhcp4->Configure (Dhcp4, NULL);
  59   Instance->Dhcp4 = NULL;
  60
  61   IpSb = IP4_SERVICE_FROM_IP4_CONFIG2_INSTANCE (Instance);
  62
  63   //
  64   // Close DHCPv4 protocol and destroy the child.
  65   //
  66   Status = gBS->CloseProtocol (
  67                   Instance->Dhcp4Handle,
  68                   &gEfiDhcp4ProtocolGuid,
  69                   IpSb->Image,
  70                   IpSb->Controller
  71                   );
  72   if (EFI_ERROR (Status)) {
  73     return Status;
  74   }
  75
  76   Status = NetLibDestroyServiceChild (
  77              IpSb->Controller,
  78              IpSb->Image,
  79              &gEfiDhcp4ServiceBindingProtocolGuid,
  80              Instance->Dhcp4Handle
  81              );
  82
  83   Instance->Dhcp4Handle = NULL;
  84
  85   return Status;
  86 }
  87
  88 /**
  89   Update the current policy to NewPolicy. During the transition
  90   period, the default router list
  91   and address list in all interfaces will be released.
  92
  93   @param[in]  IpSb               The IP4 service binding instance.
  94   @param[in]  NewPolicy          The new policy to be updated to.
  95
  96 **/
  97 VOID
  98 Ip4Config2OnPolicyChanged (
  99   IN IP4_SERVICE            *IpSb,
 100   IN EFI_IP4_CONFIG2_POLICY NewPolicy
 101   )
 102 {
 103   IP4_INTERFACE   *IpIf;
 104   IP4_ROUTE_TABLE *RouteTable;
 105
 106   //
 107   // Currently there are only two policies: static and dhcp. Regardless of
 108   // what transition is going on, i.e., static -> dhcp and dhcp ->
 109   // static, we have to free default router table and all addresses.
 110   //
 111
 112   if (IpSb->DefaultInterface != NULL) {
 113     if (IpSb->DefaultRouteTable != NULL) {
 114       Ip4FreeRouteTable (IpSb->DefaultRouteTable);
 115       IpSb->DefaultRouteTable = NULL;
 116     }
 117
 118     Ip4CancelReceive (IpSb->DefaultInterface);
 119
 120     Ip4FreeInterface (IpSb->DefaultInterface, NULL);
 121     IpSb->DefaultInterface = NULL;
 122   }
 123
 124   Ip4CleanAssembleTable (&IpSb->Assemble);
 125
 126   //
 127   // Create new default interface and route table.
 128   //
 129   IpIf = Ip4CreateInterface (IpSb->Mnp, IpSb->Controller, IpSb->Image);
 130   if (IpIf == NULL) {
 131     return ;
 132   }
 133
 134   RouteTable = Ip4CreateRouteTable ();
 135   if (RouteTable == NULL) {
 136     Ip4FreeInterface (IpIf, NULL);
 137     return ;
 138   }
 139
 140   IpSb->DefaultInterface  = IpIf;
 141   InsertHeadList (&IpSb->Interfaces, &IpIf->Link);
 142   IpSb->DefaultRouteTable = RouteTable;
 143   Ip4ReceiveFrame (IpIf, NULL, Ip4AccpetFrame, IpSb);
 144
 145   if (IpSb->State == IP4_SERVICE_CONFIGED || IpSb->State == IP4_SERVICE_STARTED) {
 146     IpSb->State = IP4_SERVICE_UNSTARTED;
 147   }
 148
 149   //
 150   // Start the dhcp configuration.
 151   //
 152   if (NewPolicy == Ip4Config2PolicyDhcp) {
 153     Ip4StartAutoConfig (&IpSb->Ip4Config2Instance);
 154   }
 155
 156 }
 157
 158 /**
 159   Signal the registered event. It is the callback routine for NetMapIterate.
 160
 161   @param[in]  Map    Points to the list of registered event.
 162   @param[in]  Item   The registered event.
 163   @param[in]  Arg    Not used.
 164
 165   @retval EFI_SUCCESS           The event was signaled successfully.
 166 **/
 167 EFI_STATUS
 168 EFIAPI
 169 Ip4Config2SignalEvent (
 170   IN NET_MAP                *Map,
 171   IN NET_MAP_ITEM           *Item,
 172   IN VOID                   *Arg
 173   )
 174 {
 175   gBS->SignalEvent ((EFI_EVENT) Item->Key);
 176
 177   return EFI_SUCCESS;
 178 }
 179
 180 /**
 181   Read the configuration data from variable storage according to the VarName and
 182   gEfiIp4Config2ProtocolGuid. It checks the integrity of variable data. If the
 183   data is corrupted, it clears the variable data to ZERO. Othewise, it outputs the
 184   configuration data to IP4_CONFIG2_INSTANCE.
 185
 186   @param[in]      VarName       The pointer to the variable name
 187   @param[in, out] Instance      The pointer to the IP4 config2 instance data.
 188
 189   @retval EFI_NOT_FOUND         The variable can not be found or already corrupted.
 190   @retval EFI_OUT_OF_RESOURCES  Fail to allocate resource to complete the operation.
 191   @retval EFI_SUCCESS           The configuration data was retrieved successfully.
 192
 193 **/
 194 EFI_STATUS
 195 Ip4Config2ReadConfigData (
 196   IN     CHAR16               *VarName,
 197   IN OUT IP4_CONFIG2_INSTANCE *Instance
 198   )
 199 {
 200   EFI_STATUS              Status;
 201   UINTN                   VarSize;
 202   IP4_CONFIG2_VARIABLE    *Variable;
 203   IP4_CONFIG2_DATA_ITEM   *DataItem;
 204   UINTN                   Index;
 205   IP4_CONFIG2_DATA_RECORD DataRecord;
 206   CHAR8                   *Data;
 207
 208   //
 209   // Try to read the configuration variable.
 210   //
 211   VarSize = 0;
 212   Status  = gRT->GetVariable (
 213                    VarName,
 214                    &gEfiIp4Config2ProtocolGuid,
 215                    NULL,
 216                    &VarSize,
 217                    NULL
 218                    );
 219
 220   if (Status == EFI_BUFFER_TOO_SMALL) {
 221     //
 222     // Allocate buffer and read the config variable.
 223     //
 224     Variable = AllocatePool (VarSize);
 225     if (Variable == NULL) {
 226       return EFI_OUT_OF_RESOURCES;
 227     }
 228
 229     Status = gRT->GetVariable (
 230                     VarName,
 231                     &gEfiIp4Config2ProtocolGuid,
 232                     NULL,
 233                     &VarSize,
 234                     Variable
 235                     );
 236     if (EFI_ERROR (Status) || (UINT16) (~NetblockChecksum ((UINT8 *) Variable, (UINT32) VarSize)) != 0) {
 237       //
 238       // GetVariable still error or the variable is corrupted.
 239       // Fall back to the default value.
 240       //
 241       FreePool (Variable);
 242
 243       //
 244       // Remove the problematic variable and return EFI_NOT_FOUND, a new
 245       // variable will be set again.
 246       //
 247       gRT->SetVariable (
 248              VarName,
 249              &gEfiIp4Config2ProtocolGuid,
 250              IP4_CONFIG2_VARIABLE_ATTRIBUTE,
 251              0,
 252              NULL
 253              );
 254
 255       return EFI_NOT_FOUND;
 256     }
 257
 258
 259     for (Index = 0; Index < Variable->DataRecordCount; Index++) {
 260
 261       CopyMem (&DataRecord, &Variable->DataRecord[Index], sizeof (DataRecord));
 262
 263       DataItem = &Instance->DataItem[DataRecord.DataType];
 264       if (DATA_ATTRIB_SET (DataItem->Attribute, DATA_ATTRIB_SIZE_FIXED) &&
 265           (DataItem->DataSize != DataRecord.DataSize)
 266           ) {
 267         //
 268         // Perhaps a corrupted data record...
 269         //
 270         continue;
 271       }
 272
 273       if (!DATA_ATTRIB_SET (DataItem->Attribute, DATA_ATTRIB_SIZE_FIXED)) {
 274         //
 275         // This data item has variable length data.
 276         //
 277         DataItem->Data.Ptr = AllocatePool (DataRecord.DataSize);
 278         if (DataItem->Data.Ptr == NULL) {
 279           //
 280           // no memory resource
 281           //
 282           continue;
 283         }
 284       }
 285
 286       Data = (CHAR8 *) Variable + DataRecord.Offset;
 287       CopyMem (DataItem->Data.Ptr, Data, DataRecord.DataSize);
 288
 289       DataItem->DataSize = DataRecord.DataSize;
 290       DataItem->Status   = EFI_SUCCESS;
 291     }
 292
 293     FreePool (Variable);
 294     return EFI_SUCCESS;
 295   }
 296
 297   return Status;
 298 }
 299
 300 /**
 301   Write the configuration data from IP4_CONFIG2_INSTANCE to variable storage.
 302
 303   @param[in]      VarName       The pointer to the variable name.
 304   @param[in]      Instance      The pointer to the IP4 config2 instance data.
 305
 306   @retval EFI_OUT_OF_RESOURCES  Fail to allocate resource to complete the operation.
 307   @retval EFI_SUCCESS           The configuration data is written successfully.
 308
 309 **/
 310 EFI_STATUS
 311 Ip4Config2WriteConfigData (
 312   IN CHAR16               *VarName,
 313   IN IP4_CONFIG2_INSTANCE *Instance
 314   )
 315 {
 316   UINTN                   Index;
 317   UINTN                   VarSize;
 318   IP4_CONFIG2_DATA_ITEM   *DataItem;
 319   IP4_CONFIG2_VARIABLE    *Variable;
 320   IP4_CONFIG2_DATA_RECORD *DataRecord;
 321   CHAR8                   *Heap;
 322   EFI_STATUS              Status;
 323
 324   VarSize = sizeof (IP4_CONFIG2_VARIABLE) - sizeof (IP4_CONFIG2_DATA_RECORD);
 325
 326   for (Index = 0; Index < Ip4Config2DataTypeMaximum; Index++) {
 327
 328     DataItem = &Instance->DataItem[Index];
 329     if (!DATA_ATTRIB_SET (DataItem->Attribute, DATA_ATTRIB_VOLATILE) && !EFI_ERROR (DataItem->Status)) {
 330
 331       VarSize += sizeof (IP4_CONFIG2_DATA_RECORD) + DataItem->DataSize;
 332     }
 333   }
 334
 335   Variable = AllocatePool (VarSize);
 336   if (Variable == NULL) {
 337     return EFI_OUT_OF_RESOURCES;
 338   }
 339
 340   Heap                      = (CHAR8 *) Variable + VarSize;
 341   Variable->DataRecordCount = 0;
 342
 343   for (Index = 0; Index < Ip4Config2DataTypeMaximum; Index++) {
 344
 345     DataItem = &Instance->DataItem[Index];
 346     if (!DATA_ATTRIB_SET (DataItem->Attribute, DATA_ATTRIB_VOLATILE) && !EFI_ERROR (DataItem->Status)) {
 347
 348       Heap -= DataItem->DataSize;
 349       CopyMem (Heap, DataItem->Data.Ptr, DataItem->DataSize);
 350
 351       DataRecord           = &Variable->DataRecord[Variable->DataRecordCount];
 352       DataRecord->DataType = (EFI_IP4_CONFIG2_DATA_TYPE) Index;
 353       DataRecord->DataSize = (UINT32) DataItem->DataSize;
 354       DataRecord->Offset   = (UINT16) (Heap - (CHAR8 *) Variable);
 355
 356       Variable->DataRecordCount++;
 357     }
 358   }
 359
 360   Variable->Checksum = 0;
 361   Variable->Checksum = (UINT16) ~NetblockChecksum ((UINT8 *) Variable, (UINT32) VarSize);
 362
 363   Status = gRT->SetVariable (
 364                   VarName,
 365                   &gEfiIp4Config2ProtocolGuid,
 366                   IP4_CONFIG2_VARIABLE_ATTRIBUTE,
 367                   VarSize,
 368                   Variable
 369                   );
 370
 371   FreePool (Variable);
 372
 373   return Status;
 374 }
 375
 376
 377 /**
 378   Build a EFI_IP4_ROUTE_TABLE to be returned to the caller of GetModeData.
 379   The EFI_IP4_ROUTE_TABLE is clumsy to use in the internal operation of the
 380   IP4 driver.
 381
 382   @param[in]   IpSb        The IP4 service binding instance.
 383   @param[out]  Table       The built IP4 route table.
 384
 385   @retval EFI_SUCCESS           The route table is successfully build
 386   @retval EFI_NOT_FOUND         Failed to allocate the memory for the rotue table.
 387
 388 **/
 389 EFI_STATUS
 390 Ip4Config2BuildDefaultRouteTable (
 391   IN  IP4_SERVICE               *IpSb,
 392   OUT EFI_IP4_ROUTE_TABLE       *Table
 393   )
 394 {
 395   LIST_ENTRY                *Entry;
 396   IP4_ROUTE_ENTRY           *RtEntry;
 397   UINT32                    Count;
 398   INT32                     Index;
 399
 400   if (IpSb->DefaultRouteTable == NULL) {
 401     return EFI_NOT_FOUND;
 402   }
 403
 404   Count = IpSb->DefaultRouteTable->TotalNum;
 405
 406   if (Count == 0) {
 407     return EFI_NOT_FOUND;
 408   }
 409
 410   //
 411   // Copy the route entry to EFI route table. Keep the order of
 412   // route entry copied from most specific to default route. That
 413   // is, interlevel the route entry from the instance's route area
 414   // and those from the default route table's route area.
 415   //
 416   Count = 0;
 417
 418   for (Index = IP4_MASK_MAX; Index >= 0; Index--) {
 419
 420     NET_LIST_FOR_EACH (Entry, &(IpSb->DefaultRouteTable->RouteArea[Index])) {
 421       RtEntry = NET_LIST_USER_STRUCT (Entry, IP4_ROUTE_ENTRY, Link);
 422
 423       EFI_IP4 (Table[Count].SubnetAddress)  = HTONL (RtEntry->Dest & RtEntry->Netmask);
 424       EFI_IP4 (Table[Count].SubnetMask)     = HTONL (RtEntry->Netmask);
 425       EFI_IP4 (Table[Count].GatewayAddress) = HTONL (RtEntry->NextHop);
 426
 427       Count++;
 428     }
 429
 430   }
 431
 432   return EFI_SUCCESS;
 433 }
 434
 435 /**
 436   The event process routine when the DHCPv4 service binding protocol is installed
 437   in the system.
 438
 439   @param[in]     Event         Not used.
 440   @param[in]     Context       The pointer to the IP4 config2 instance data.
 441
 442 **/
 443 VOID
 444 EFIAPI
 445 Ip4Config2OnDhcp4SbInstalled (
 446   IN EFI_EVENT  Event,
 447   IN VOID       *Context
 448   )
 449 {
 450   IP4_CONFIG2_INSTANCE  *Instance;
 451
 452   Instance = (IP4_CONFIG2_INSTANCE *) Context;
 453
 454   if ((Instance->Dhcp4Handle != NULL) || (Instance->Policy != Ip4Config2PolicyDhcp)) {
 455     //
 456     // The DHCP4 child is already created or the policy is no longer DHCP.
 457     //
 458     return ;
 459   }
 460
 461   Ip4StartAutoConfig (Instance);
 462 }
 463
 464 /**
 465   Set the station address and subnetmask for the default interface.
 466
 467   @param[in]  IpSb               The pointer to the IP4 service binding instance.
 468   @param[in]  StationAddress     Ip address to be set.
 469   @param[in]  SubnetMask         Subnet to be set.
 470
 471   @retval EFI_SUCCESS   Set default address successful.
 472   @retval Others        Some errors occur in setting.
 473
 474 **/
 475 EFI_STATUS
 476 Ip4Config2SetDefaultAddr (
 477   IN IP4_SERVICE            *IpSb,
 478   IN IP4_ADDR               StationAddress,
 479   IN IP4_ADDR               SubnetMask
 480   )
 481 {
 482   EFI_STATUS                Status;
 483   IP4_INTERFACE             *IpIf;
 484   IP4_PROTOCOL              *Ip4Instance;
 485   EFI_ARP_PROTOCOL          *Arp;
 486   LIST_ENTRY                *Entry;
 487   IP4_ADDR                  Subnet;
 488   IP4_ROUTE_TABLE           *RouteTable;
 489
 490   IpIf = IpSb->DefaultInterface;
 491   ASSERT (IpIf != NULL);
 492
 493   if ((IpIf->Ip == StationAddress) && (IpIf->SubnetMask == SubnetMask)) {
 494     IpSb->State = IP4_SERVICE_CONFIGED;
 495     return EFI_SUCCESS;
 496   }
 497
 498   if (IpSb->Reconfig) {
 499     //
 500     // The default address is changed, free the previous interface first.
 501     //
 502     if (IpSb->DefaultRouteTable != NULL) {
 503       Ip4FreeRouteTable (IpSb->DefaultRouteTable);
 504       IpSb->DefaultRouteTable = NULL;
 505     }
 506
 507     Ip4CancelReceive (IpSb->DefaultInterface);
 508     Ip4FreeInterface (IpSb->DefaultInterface, NULL);
 509     IpSb->DefaultInterface = NULL;
 510     //
 511     // Create new default interface and route table.
 512     //
 513     IpIf = Ip4CreateInterface (IpSb->Mnp, IpSb->Controller, IpSb->Image);
 514     if (IpIf == NULL) {
 515       return EFI_OUT_OF_RESOURCES;
 516     }
 517
 518     RouteTable = Ip4CreateRouteTable ();
 519     if (RouteTable == NULL) {
 520       Ip4FreeInterface (IpIf, NULL);
 521       return EFI_OUT_OF_RESOURCES;
 522     }
 523
 524     IpSb->DefaultInterface  = IpIf;
 525     InsertHeadList (&IpSb->Interfaces, &IpIf->Link);
 526     IpSb->DefaultRouteTable = RouteTable;
 527     Ip4ReceiveFrame (IpIf, NULL, Ip4AccpetFrame, IpSb);
 528   }
 529
 530   if (IpSb->State == IP4_SERVICE_CONFIGED) {
 531     IpSb->State = IP4_SERVICE_UNSTARTED;
 532   }
 533
 534   Status = Ip4SetAddress (IpIf, StationAddress, SubnetMask);
 535   if (EFI_ERROR (Status)) {
 536     return Status;
 537   }
 538
 539   if (IpIf->Arp != NULL) {
 540     //
 541     // A non-NULL IpIf->Arp here means a new ARP child is created when setting default address,
 542     // but some IP children may have referenced the default interface before it is configured,
 543     // these IP instances also consume this ARP protocol so they need to open it BY_CHILD_CONTROLLER.
 544     //
 545     Arp = NULL;
 546     NET_LIST_FOR_EACH (Entry, &IpIf->IpInstances) {
 547       Ip4Instance = NET_LIST_USER_STRUCT_S (Entry, IP4_PROTOCOL, AddrLink, IP4_PROTOCOL_SIGNATURE);
 548       Status = gBS->OpenProtocol (
 549                       IpIf->ArpHandle,
 550                       &gEfiArpProtocolGuid,
 551                       (VOID **) &Arp,
 552                       gIp4DriverBinding.DriverBindingHandle,
 553                       Ip4Instance->Handle,
 554                       EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
 555                       );
 556       if (EFI_ERROR (Status)) {
 557         return Status;
 558       }
 559     }
 560   }
 561
 562   //
 563   // Add a route for the connected network.
 564   //
 565   Subnet = StationAddress & SubnetMask;
 566
 567   Ip4AddRoute (
 568     IpSb->DefaultRouteTable,
 569     Subnet,
 570     SubnetMask,
 571     IP4_ALLZERO_ADDRESS
 572     );
 573
 574   IpSb->State = IP4_SERVICE_CONFIGED;
 575   IpSb->Reconfig = FALSE;
 576
 577   return EFI_SUCCESS;
 578 }
 579
 580 /**
 581   Set the station address, subnetmask and gateway address for the default interface.
 582
 583   @param[in]  Instance         The pointer to the IP4 config2 instance data.
 584   @param[in]  StationAddress   Ip address to be set.
 585   @param[in]  SubnetMask       Subnet to be set.
 586   @param[in]  GatewayAddress   Gateway to be set.
 587
 588   @retval EFI_SUCCESS     Set default If successful.
 589   @retval Others          Errors occur as indicated.
 590
 591 **/
 592 EFI_STATUS
 593 Ip4Config2SetDefaultIf (
 594   IN IP4_CONFIG2_INSTANCE   *Instance,
 595   IN IP4_ADDR               StationAddress,
 596   IN IP4_ADDR               SubnetMask,
 597   IN IP4_ADDR               GatewayAddress
 598   )
 599 {
 600   EFI_STATUS                Status;
 601   IP4_SERVICE               *IpSb;
 602
 603   IpSb = IP4_SERVICE_FROM_IP4_CONFIG2_INSTANCE (Instance);
 604
 605   //
 606   // Check whether the StationAddress/SubnetMask pair is valid.
 607   //
 608   if (!Ip4StationAddressValid (StationAddress, SubnetMask)) {
 609     return EFI_INVALID_PARAMETER;
 610   }
 611
 612   Status = Ip4Config2SetDefaultAddr (IpSb, StationAddress, SubnetMask);
 613   if (EFI_ERROR (Status)) {
 614     return Status;
 615   }
 616
 617   //
 618   // Create a route if there is a default router.
 619   //
 620   if (GatewayAddress != IP4_ALLZERO_ADDRESS) {
 621     Ip4AddRoute (
 622       IpSb->DefaultRouteTable,
 623       IP4_ALLZERO_ADDRESS,
 624       IP4_ALLZERO_ADDRESS,
 625       GatewayAddress
 626       );
 627   }
 628
 629   return EFI_SUCCESS;
 630 }
 631
 632
 633 /**
 634   Release all the DHCP related resources.
 635
 636   @param  Instance              The IP4 config2 instance.
 637
 638   @return None
 639
 640 **/
 641 VOID
 642 Ip4Config2CleanDhcp4 (
 643   IN IP4_CONFIG2_INSTANCE   *Instance
 644   )
 645 {
 646   IP4_SERVICE               *IpSb;
 647
 648   IpSb = IP4_SERVICE_FROM_IP4_CONFIG2_INSTANCE (Instance);
 649
 650   if (Instance->Dhcp4 != NULL) {
 651     Instance->Dhcp4->Stop (Instance->Dhcp4);
 652
 653     gBS->CloseProtocol (
 654           Instance->Dhcp4Handle,
 655           &gEfiDhcp4ProtocolGuid,
 656           IpSb->Image,
 657           IpSb->Controller
 658           );
 659
 660     Instance->Dhcp4 = NULL;
 661   }
 662
 663   if (Instance->Dhcp4Handle != NULL) {
 664     NetLibDestroyServiceChild (
 665       IpSb->Controller,
 666       IpSb->Image,
 667       &gEfiDhcp4ServiceBindingProtocolGuid,
 668       Instance->Dhcp4Handle
 669       );
 670
 671     Instance->Dhcp4Handle = NULL;
 672   }
 673
 674   if (Instance->Dhcp4Event != NULL) {
 675     gBS->CloseEvent (Instance->Dhcp4Event);
 676     Instance->Dhcp4Event = NULL;
 677   }
 678 }
 679
 680 /**
 681   This worker function sets the DNS server list for the EFI IPv4 network
 682   stack running on the communication device that this EFI_IP4_CONFIG2_PROTOCOL
 683   manages. The DNS server addresses must be unicast IPv4 addresses.
 684
 685   @param[in]     Instance        The pointer to the IP4 config2 instance data.
 686   @param[in]     DataSize        The size of the buffer pointed to by Data in bytes.
 687   @param[in]     Data            The data buffer to set, points to an array of
 688                                  EFI_IPv4_ADDRESS instances.
 689
 690   @retval EFI_BAD_BUFFER_SIZE    The DataSize does not match the size of the type.
 691   @retval EFI_INVALID_PARAMETER  One or more fields in Data is invalid.
 692   @retval EFI_OUT_OF_RESOURCES   Failed to allocate resources to complete the operation.
 693   @retval EFI_ABORTED            The DNS server addresses to be set equal the current
 694                                  configuration.
 695   @retval EFI_SUCCESS            The specified configuration data for the EFI IPv4
 696                                  network stack was set.
 697
 698 **/
 699 EFI_STATUS
 700 Ip4Config2SetDnsServerWorker (
 701   IN IP4_CONFIG2_INSTANCE    *Instance,
 702   IN UINTN                   DataSize,
 703   IN VOID                    *Data
 704   )
 705 {
 706   UINTN                 OldIndex;
 707   UINTN                 NewIndex;
 708   EFI_IPv4_ADDRESS      *OldDns;
 709   EFI_IPv4_ADDRESS      *NewDns;
 710   UINTN                 OldDnsCount;
 711   UINTN                 NewDnsCount;
 712   IP4_CONFIG2_DATA_ITEM *Item;
 713   BOOLEAN               OneAdded;
 714   VOID                  *Tmp;
 715   IP4_ADDR              DnsAddress;
 716
 717   if ((DataSize % sizeof (EFI_IPv4_ADDRESS) != 0) || (DataSize == 0)) {
 718     return EFI_BAD_BUFFER_SIZE;
 719   }
 720
 721   Item        = &Instance->DataItem[Ip4Config2DataTypeDnsServer];
 722   NewDns      = (EFI_IPv4_ADDRESS *) Data;
 723   OldDns      = Item->Data.DnsServers;
 724   NewDnsCount = DataSize / sizeof (EFI_IPv4_ADDRESS);
 725   OldDnsCount = Item->DataSize / sizeof (EFI_IPv4_ADDRESS);
 726   OneAdded    = FALSE;
 727
 728   if (NewDnsCount != OldDnsCount) {
 729     Tmp = AllocatePool (DataSize);
 730     if (Tmp == NULL) {
 731       return EFI_OUT_OF_RESOURCES;
 732     }
 733   } else {
 734     Tmp = NULL;
 735   }
 736
 737   for (NewIndex = 0; NewIndex < NewDnsCount; NewIndex++) {
 738     CopyMem (&DnsAddress, NewDns + NewIndex, sizeof (IP4_ADDR));
 739     if (IP4_IS_UNSPECIFIED (NTOHL (DnsAddress)) || IP4_IS_LOCAL_BROADCAST (NTOHL (DnsAddress))) {
 740       //
 741       // The dns server address must be unicast.
 742       //
 743       if (Tmp != NULL) {
 744         FreePool (Tmp);
 745       }
 746       return EFI_INVALID_PARAMETER;
 747     }
 748
 749     if (OneAdded) {
 750       //
 751       // If any address in the new setting is not in the old settings, skip the
 752       // comparision below.
 753       //
 754       continue;
 755     }
 756
 757     for (OldIndex = 0; OldIndex < OldDnsCount; OldIndex++) {
 758       if (EFI_IP4_EQUAL (NewDns + NewIndex, OldDns + OldIndex)) {
 759         //
 760         // If found break out.
 761         //
 762         break;
 763       }
 764     }
 765
 766     if (OldIndex == OldDnsCount) {
 767       OneAdded = TRUE;
 768     }
 769   }
 770
 771   if (!OneAdded && (DataSize == Item->DataSize)) {
 772     //
 773     // No new item is added and the size is the same.
 774     //
 775     Item->Status = EFI_SUCCESS;
 776     return EFI_ABORTED;
 777   } else {
 778     if (Tmp != NULL) {
 779       if (Item->Data.Ptr != NULL) {
 780         FreePool (Item->Data.Ptr);
 781       }
 782       Item->Data.Ptr = Tmp;
 783     }
 784
 785     CopyMem (Item->Data.Ptr, Data, DataSize);
 786     Item->DataSize = DataSize;
 787     Item->Status   = EFI_SUCCESS;
 788     return EFI_SUCCESS;
 789   }
 790 }
 791
 792
 793
 794 /**
 795   Callback function when DHCP process finished. It will save the
 796   retrieved IP configure parameter from DHCP to the NVRam.
 797
 798   @param  Event                  The callback event
 799   @param  Context                Opaque context to the callback
 800
 801   @return None
 802
 803 **/
 804 VOID
 805 EFIAPI
 806 Ip4Config2OnDhcp4Complete (
 807   IN EFI_EVENT              Event,
 808   IN VOID                   *Context
 809   )
 810 {
 811   IP4_CONFIG2_INSTANCE      *Instance;
 812   EFI_DHCP4_MODE_DATA       Dhcp4Mode;
 813   EFI_STATUS                Status;
 814   IP4_ADDR                  StationAddress;
 815   IP4_ADDR                  SubnetMask;
 816   IP4_ADDR                  GatewayAddress;
 817   UINT32                    Index;
 818   UINT32                    OptionCount;
 819   EFI_DHCP4_PACKET_OPTION   **OptionList;
 820
 821   Instance = (IP4_CONFIG2_INSTANCE *) Context;
 822   ASSERT (Instance->Dhcp4 != NULL);
 823
 824   //
 825   // Get the DHCP retrieved parameters
 826   //
 827   Status = Instance->Dhcp4->GetModeData (Instance->Dhcp4, &Dhcp4Mode);
 828
 829   if (EFI_ERROR (Status)) {
 830     goto Exit;
 831   }
 832
 833   if (Dhcp4Mode.State == Dhcp4Bound) {
 834     StationAddress = EFI_NTOHL (Dhcp4Mode.ClientAddress);
 835     SubnetMask = EFI_NTOHL (Dhcp4Mode.SubnetMask);
 836     GatewayAddress = EFI_NTOHL (Dhcp4Mode.RouterAddress);
 837
 838     Status = Ip4Config2SetDefaultIf (Instance, StationAddress, SubnetMask, GatewayAddress);
 839     if (EFI_ERROR (Status)) {
 840       goto Exit;
 841     }
 842
 843     //
 844     // Parse the ACK to get required DNS server information.
 845     //
 846     OptionCount = 0;
 847     OptionList  = NULL;
 848
 849     Status      = Instance->Dhcp4->Parse (Instance->Dhcp4, Dhcp4Mode.ReplyPacket, &OptionCount, OptionList);
 850     if (Status != EFI_BUFFER_TOO_SMALL) {
 851       goto Exit;
 852     }
 853
 854     OptionList = AllocateZeroPool (OptionCount * sizeof (EFI_DHCP4_PACKET_OPTION *));
 855     if (OptionList == NULL) {
 856       goto Exit;
 857     }
 858
 859     Status = Instance->Dhcp4->Parse (Instance->Dhcp4, Dhcp4Mode.ReplyPacket, &OptionCount, OptionList);
 860     if (EFI_ERROR (Status)) {
 861       FreePool (OptionList);
 862       goto Exit;
 863     }
 864
 865     for (Index = 0; Index < OptionCount; Index++) {
 866       //
 867       // Look for DNS Server opcode (6).
 868       //
 869       if (OptionList[Index]->OpCode == DHCP4_TAG_DNS_SERVER) {
 870         if (((OptionList[Index]->Length & 0x3) != 0) || (OptionList[Index]->Length == 0)) {
 871           break;
 872         }
 873
 874         Ip4Config2SetDnsServerWorker (Instance, OptionList[Index]->Length, &OptionList[Index]->Data[0]);
 875         break;
 876       }
 877     }
 878
 879     FreePool (OptionList);
 880
 881     Instance->DhcpSuccess = TRUE;
 882   }
 883
 884 Exit:
 885   Ip4Config2CleanDhcp4 (Instance);
 886   DispatchDpc ();
 887 }
 888
 889
 890 /**
 891   Start the DHCP configuration for this IP service instance.
 892   It will locates the EFI_IP4_CONFIG2_PROTOCOL, then start the
 893   DHCP configuration.
 894
 895   @param[in]  Instance           The IP4 config2 instance to configure
 896
 897   @retval EFI_SUCCESS            The auto configuration is successfully started
 898   @retval Others                 Failed to start auto configuration.
 899
 900 **/
 901 EFI_STATUS
 902 Ip4StartAutoConfig (
 903   IN IP4_CONFIG2_INSTANCE   *Instance
 904   )
 905 {
 906   IP4_SERVICE                    *IpSb;
 907   EFI_DHCP4_PROTOCOL             *Dhcp4;
 908   EFI_DHCP4_MODE_DATA            Dhcp4Mode;
 909   EFI_DHCP4_PACKET_OPTION        *OptionList[1];
 910   IP4_CONFIG2_DHCP4_OPTION       ParaList;
 911   EFI_STATUS                     Status;
 912
 913   IpSb = IP4_SERVICE_FROM_IP4_CONFIG2_INSTANCE (Instance);
 914
 915   if (IpSb->State > IP4_SERVICE_UNSTARTED) {
 916     return EFI_SUCCESS;
 917   }
 918
 919   //
 920   // A host must not invoke DHCP configuration if it is already
 921   // participating in the DHCP configuraiton process.
 922   //
 923   if (Instance->Dhcp4Handle != NULL) {
 924     return EFI_SUCCESS;
 925   }
 926
 927   Status = NetLibCreateServiceChild (
 928              IpSb->Controller,
 929              IpSb->Image,
 930              &gEfiDhcp4ServiceBindingProtocolGuid,
 931              &Instance->Dhcp4Handle
 932              );
 933
 934   if (Status == EFI_UNSUPPORTED) {
 935     //
 936     // No DHCPv4 Service Binding protocol, register a notify.
 937     //
 938     if (Instance->Dhcp4SbNotifyEvent == NULL) {
 939       Instance->Dhcp4SbNotifyEvent = EfiCreateProtocolNotifyEvent (
 940                                        &gEfiDhcp4ServiceBindingProtocolGuid,
 941                                        TPL_CALLBACK,
 942                                        Ip4Config2OnDhcp4SbInstalled,
 943                                        (VOID *) Instance,
 944                                        &Instance->Registration
 945                                        );
 946     }
 947   }
 948
 949   if (EFI_ERROR (Status)) {
 950     return Status;
 951   }
 952
 953   if (Instance->Dhcp4SbNotifyEvent != NULL) {
 954     gBS->CloseEvent (Instance->Dhcp4SbNotifyEvent);
 955   }
 956
 957   Status = gBS->OpenProtocol (
 958                   Instance->Dhcp4Handle,
 959                   &gEfiDhcp4ProtocolGuid,
 960                   (VOID **) &Instance->Dhcp4,
 961                   IpSb->Image,
 962                   IpSb->Controller,
 963                   EFI_OPEN_PROTOCOL_BY_DRIVER
 964                   );
 965   if (EFI_ERROR (Status)) {
 966     NetLibDestroyServiceChild (
 967       IpSb->Controller,
 968       IpSb->Image,
 969       &gEfiDhcp4ServiceBindingProtocolGuid,
 970       Instance->Dhcp4Handle
 971       );
 972
 973     Instance->Dhcp4Handle = NULL;
 974
 975     return Status;
 976   }
 977
 978   //
 979   // Check the current DHCP status, if the DHCP process has
 980   // already finished, return now.
 981   //
 982   Dhcp4  = Instance->Dhcp4;
 983   Status = Dhcp4->GetModeData (Dhcp4, &Dhcp4Mode);
 984   if (Dhcp4Mode.State == Dhcp4Bound) {
 985     Ip4Config2OnDhcp4Complete (NULL, Instance);
 986
 987     return EFI_SUCCESS;
 988   }
 989
 990   //
 991   // Try to start the DHCP process. Use most of the current
 992   // DHCP configuration to avoid problems if some DHCP client
 993   // yields the control of this DHCP service to us.
 994   //
 995   ParaList.Head.OpCode             = DHCP4_TAG_PARA_LIST;
 996   ParaList.Head.Length             = 3;
 997   ParaList.Head.Data[0]            = DHCP4_TAG_NETMASK;
 998   ParaList.Route                   = DHCP4_TAG_ROUTER;
 999   ParaList.Dns                     = DHCP4_TAG_DNS_SERVER;
1000   OptionList[0]                    = &ParaList.Head;
1001   Dhcp4Mode.ConfigData.OptionCount = 1;
1002   Dhcp4Mode.ConfigData.OptionList  = OptionList;
1003
1004   Status = Dhcp4->Configure (Dhcp4, &Dhcp4Mode.ConfigData);
1005   if (EFI_ERROR (Status)) {
1006     gBS->CloseProtocol (
1007            Instance->Dhcp4Handle,
1008            &gEfiDhcp4ProtocolGuid,
1009            IpSb->Image,
1010            IpSb->Controller
1011            );
1012
1013     NetLibDestroyServiceChild (
1014       IpSb->Controller,
1015       IpSb->Image,
1016       &gEfiDhcp4ServiceBindingProtocolGuid,
1017       Instance->Dhcp4Handle
1018       );
1019
1020     Instance->Dhcp4 = NULL;
1021
1022     Instance->Dhcp4Handle = NULL;
1023
1024     return Status;
1025   }
1026
1027   //
1028   // Start the DHCP process
1029   //
1030   Status = gBS->CreateEvent (
1031                   EVT_NOTIFY_SIGNAL,
1032                   TPL_CALLBACK,
1033                   Ip4Config2OnDhcp4Complete,
1034                   Instance,
1035                   &Instance->Dhcp4Event
1036                   );
1037   if (EFI_ERROR (Status)) {
1038     Ip4Config2DestroyDhcp4 (Instance);
1039     return Status;
1040   }
1041
1042   Status = Dhcp4->Start (Dhcp4, Instance->Dhcp4Event);
1043   if (EFI_ERROR (Status)) {
1044     Ip4Config2DestroyDhcp4 (Instance);
1045     gBS->CloseEvent (Instance->Dhcp4Event);
1046     Instance->Dhcp4Event = NULL;
1047
1048     return Status;
1049   }
1050
1051   IpSb->State = IP4_SERVICE_STARTED;
1052   DispatchDpc ();
1053
1054   return EFI_SUCCESS;
1055 }
1056
1057
1058
1059 /**
1060   The work function is to get the interface information of the communication
1061   device this IP4_CONFIG2_INSTANCE manages.
1062
1063   @param[in]      Instance Pointer to the IP4 config2 instance data.
1064   @param[in, out] DataSize On input, in bytes, the size of Data. On output, in
1065                            bytes, the size of buffer required to store the specified
1066                            configuration data.
1067   @param[in]      Data     The data buffer in which the configuration data is returned.
1068                            Ignored if DataSize is ZERO.
1069
1070   @retval EFI_BUFFER_TOO_SMALL The size of Data is too small for the specified
1071                                configuration data, and the required size is
1072                                returned in DataSize.
1073   @retval EFI_SUCCESS          The specified configuration data was obtained.
1074
1075 **/
1076 EFI_STATUS
1077 Ip4Config2GetIfInfo (
1078   IN IP4_CONFIG2_INSTANCE *Instance,
1079   IN OUT UINTN            *DataSize,
1080   IN VOID                 *Data      OPTIONAL
1081   )
1082 {
1083   IP4_SERVICE                    *IpSb;
1084   UINTN                          Length;
1085   IP4_CONFIG2_DATA_ITEM          *Item;
1086   EFI_IP4_CONFIG2_INTERFACE_INFO *IfInfo;
1087   IP4_ADDR                       Address;
1088
1089   IpSb   = IP4_SERVICE_FROM_IP4_CONFIG2_INSTANCE (Instance);
1090   Length = sizeof (EFI_IP4_CONFIG2_INTERFACE_INFO);
1091
1092   if (IpSb->DefaultRouteTable != NULL) {
1093     Length += IpSb->DefaultRouteTable->TotalNum * sizeof (EFI_IP4_ROUTE_TABLE);
1094   }
1095
1096   if (*DataSize < Length) {
1097     *DataSize = Length;
1098     return EFI_BUFFER_TOO_SMALL;
1099   }
1100
1101   //
1102   // Copy the fixed size part of the interface info.
1103   //
1104   Item = &Instance->DataItem[Ip4Config2DataTypeInterfaceInfo];
1105   IfInfo = (EFI_IP4_CONFIG2_INTERFACE_INFO *) Data;
1106   CopyMem (IfInfo, Item->Data.Ptr, sizeof (EFI_IP4_CONFIG2_INTERFACE_INFO));
1107
1108   //
1109   // Update the address info.
1110   //
1111   if (IpSb->DefaultInterface != NULL) {
1112     Address = HTONL (IpSb->DefaultInterface->Ip);
1113     CopyMem (&IfInfo->StationAddress, &Address, sizeof (EFI_IPv4_ADDRESS));
1114     Address = HTONL (IpSb->DefaultInterface->SubnetMask);
1115     CopyMem (&IfInfo->SubnetMask, &Address, sizeof (EFI_IPv4_ADDRESS));
1116   }
1117
1118   if (IpSb->DefaultRouteTable != NULL) {
1119     IfInfo->RouteTableSize = IpSb->DefaultRouteTable->TotalNum;
1120     IfInfo->RouteTable   = (EFI_IP4_ROUTE_TABLE *) ((UINT8 *) Data + sizeof (EFI_IP4_CONFIG2_INTERFACE_INFO));
1121
1122     Ip4Config2BuildDefaultRouteTable (IpSb, IfInfo->RouteTable);
1123   }
1124
1125   return EFI_SUCCESS;
1126 }
1127
1128 /**
1129   The work function is to set the general configuration policy for the EFI IPv4 network
1130   stack that is running on the communication device managed by this IP4_CONFIG2_INSTANCE.
1131   The policy will affect other configuration settings.
1132
1133   @param[in]     Instance Pointer to the IP4 config2 instance data.
1134   @param[in]     DataSize Size of the buffer pointed to by Data in bytes.
1135   @param[in]     Data     The data buffer to set.
1136
1137   @retval EFI_INVALID_PARAMETER The to be set policy is invalid.
1138   @retval EFI_BAD_BUFFER_SIZE   The DataSize does not match the size of the type.
1139   @retval EFI_ABORTED           The new policy equals the current policy.
1140   @retval EFI_SUCCESS           The specified configuration data for the EFI IPv6
1141                                 network stack was set.
1142
1143 **/
1144 EFI_STATUS
1145 Ip4Config2SetPolicy (
1146   IN IP4_CONFIG2_INSTANCE *Instance,
1147   IN UINTN                DataSize,
1148   IN VOID                 *Data
1149   )
1150 {
1151   EFI_IP4_CONFIG2_POLICY NewPolicy;
1152   IP4_CONFIG2_DATA_ITEM  *DataItem;
1153   IP4_SERVICE            *IpSb;
1154
1155   if (DataSize != sizeof (EFI_IP4_CONFIG2_POLICY)) {
1156     return EFI_BAD_BUFFER_SIZE;
1157   }
1158
1159   NewPolicy = *((EFI_IP4_CONFIG2_POLICY *) Data);
1160
1161   if (NewPolicy >= Ip4Config2PolicyMax) {
1162     return EFI_INVALID_PARAMETER;
1163   }
1164
1165   if (NewPolicy == Instance->Policy) {
1166     if (NewPolicy != Ip4Config2PolicyDhcp || Instance->DhcpSuccess) {
1167       return EFI_ABORTED;
1168     }
1169   } else {
1170     //
1171     // The policy is changed. Clean the ManualAddress, Gateway and DnsServers,
1172     // shrink the variable data size, and fire up all the related events.
1173     //
1174     DataItem           = &Instance->DataItem[Ip4Config2DataTypeManualAddress];
1175     if (DataItem->Data.Ptr != NULL) {
1176       FreePool (DataItem->Data.Ptr);
1177     }
1178     DataItem->Data.Ptr = NULL;
1179     DataItem->DataSize = 0;
1180     DataItem->Status   = EFI_NOT_FOUND;
1181     NetMapIterate (&DataItem->EventMap, Ip4Config2SignalEvent, NULL);
1182
1183     DataItem           = &Instance->DataItem[Ip4Config2DataTypeGateway];
1184     if (DataItem->Data.Ptr != NULL) {
1185       FreePool (DataItem->Data.Ptr);
1186     }
1187     DataItem->Data.Ptr = NULL;
1188     DataItem->DataSize = 0;
1189     DataItem->Status   = EFI_NOT_FOUND;
1190     NetMapIterate (&DataItem->EventMap, Ip4Config2SignalEvent, NULL);
1191
1192     DataItem           = &Instance->DataItem[Ip4Config2DataTypeDnsServer];
1193     if (DataItem->Data.Ptr != NULL) {
1194       FreePool (DataItem->Data.Ptr);
1195     }
1196     DataItem->Data.Ptr = NULL;
1197     DataItem->DataSize = 0;
1198     DataItem->Status   = EFI_NOT_FOUND;
1199     NetMapIterate (&DataItem->EventMap, Ip4Config2SignalEvent, NULL);
1200
1201     if (NewPolicy == Ip4Config2PolicyDhcp) {
1202       SET_DATA_ATTRIB (DataItem->Attribute, DATA_ATTRIB_VOLATILE);
1203     } else {
1204       //
1205       // The policy is changed from dhcp to static. Stop the DHCPv4 process
1206       // and destroy the DHCPv4 child.
1207       //
1208       if (Instance->Dhcp4Handle != NULL) {
1209         Ip4Config2DestroyDhcp4 (Instance);
1210       }
1211
1212       //
1213       // Close the event.
1214       //
1215       if (Instance->Dhcp4Event != NULL) {
1216         gBS->CloseEvent (Instance->Dhcp4Event);
1217         Instance->Dhcp4Event = NULL;
1218       }
1219     }
1220   }
1221
1222   IpSb = IP4_SERVICE_FROM_IP4_CONFIG2_INSTANCE (Instance);
1223   Ip4Config2OnPolicyChanged (IpSb, NewPolicy);
1224
1225   Instance->Policy = NewPolicy;
1226
1227   return EFI_SUCCESS;
1228 }
1229
1230 /**
1231   The work function is to set the station addresses manually for the EFI IPv4
1232   network stack. It is only configurable when the policy is Ip4Config2PolicyStatic.
1233
1234   @param[in]     Instance Pointer to the IP4 config2 instance data.
1235   @param[in]     DataSize Size of the buffer pointed to by Data in bytes.
1236   @param[in]     Data     The data buffer to set.
1237
1238   @retval EFI_BAD_BUFFER_SIZE   The DataSize does not match the size of the type.
1239   @retval EFI_WRITE_PROTECTED   The specified configuration data cannot be set
1240                                 under the current policy.
1241   @retval EFI_INVALID_PARAMETER One or more fields in Data is invalid.
1242   @retval EFI_OUT_OF_RESOURCES  Fail to allocate resource to complete the operation.
1243   @retval EFI_NOT_READY         An asynchrous process is invoked to set the specified
1244                                 configuration data, and the process is not finished.
1245   @retval EFI_ABORTED           The manual addresses to be set equal current
1246                                 configuration.
1247   @retval EFI_SUCCESS           The specified configuration data for the EFI IPv6
1248                                 network stack was set.
1249
1250 **/
1251 EFI_STATUS
1252 Ip4Config2SetManualAddress (
1253   IN IP4_CONFIG2_INSTANCE *Instance,
1254   IN UINTN                DataSize,
1255   IN VOID                 *Data
1256   )
1257 {
1258   EFI_IP4_CONFIG2_MANUAL_ADDRESS NewAddress;
1259   IP4_CONFIG2_DATA_ITEM          *DataItem;
1260   EFI_STATUS                     Status;
1261   IP4_ADDR                       StationAddress;
1262   IP4_ADDR                       SubnetMask;
1263   VOID                           *Ptr;
1264   IP4_SERVICE                    *IpSb;
1265   IP4_INTERFACE                  *IpIf;
1266   IP4_ROUTE_TABLE                *RouteTable;
1267
1268   DataItem   = NULL;
1269   Status     = EFI_SUCCESS;
1270   Ptr        = NULL;
1271   IpIf       = NULL;
1272   RouteTable = NULL;
1273
1274   IpSb = IP4_SERVICE_FROM_IP4_CONFIG2_INSTANCE (Instance);
1275
1276   ASSERT (Instance->DataItem[Ip4Config2DataTypeManualAddress].Status != EFI_NOT_READY);
1277
1278   if ((DataSize != 0) && ((DataSize % sizeof (EFI_IP4_CONFIG2_MANUAL_ADDRESS)) != 0)) {
1279     return EFI_BAD_BUFFER_SIZE;
1280   }
1281
1282   if (Instance->Policy != Ip4Config2PolicyStatic) {
1283     return EFI_WRITE_PROTECTED;
1284   }
1285
1286   DataItem = &Instance->DataItem[Ip4Config2DataTypeManualAddress];
1287
1288   if (Data != NULL && DataSize != 0) {
1289     NewAddress = *((EFI_IP4_CONFIG2_MANUAL_ADDRESS *) Data);
1290
1291     StationAddress = EFI_NTOHL (NewAddress.Address);
1292     SubnetMask = EFI_NTOHL (NewAddress.SubnetMask);
1293
1294     //
1295     // Check whether the StationAddress/SubnetMask pair is valid.
1296     //
1297     if (!Ip4StationAddressValid (StationAddress, SubnetMask)) {
1298       return EFI_INVALID_PARAMETER;
1299     }
1300
1301     //
1302     // Store the new data, and init the DataItem status to EFI_NOT_READY because
1303     // we may have an asynchronous configuration process.
1304     //
1305     Ptr = AllocateCopyPool (DataSize, Data);
1306     if (Ptr == NULL) {
1307       return EFI_OUT_OF_RESOURCES;
1308     }
1309
1310     if (DataItem->Data.Ptr != NULL) {
1311       FreePool (DataItem->Data.Ptr);
1312     }
1313
1314     DataItem->Data.Ptr = Ptr;
1315     DataItem->DataSize = DataSize;
1316     DataItem->Status   = EFI_NOT_READY;
1317
1318     IpSb->Reconfig = TRUE;
1319     Status = Ip4Config2SetDefaultAddr (IpSb, StationAddress, SubnetMask);
1320
1321     DataItem->Status = Status;
1322
1323     if (EFI_ERROR (DataItem->Status) && DataItem->Status != EFI_NOT_READY) {
1324       if (Ptr != NULL) {
1325         FreePool (Ptr);
1326       }
1327       DataItem->Data.Ptr = NULL;
1328     }
1329   } else {
1330     //
1331     // DataSize is 0 and Data is NULL, clean up the manual address.
1332     //
1333     if (DataItem->Data.Ptr != NULL) {
1334       FreePool (DataItem->Data.Ptr);
1335     }
1336     DataItem->Data.Ptr = NULL;
1337     DataItem->DataSize = 0;
1338     DataItem->Status   = EFI_NOT_FOUND;
1339
1340     //
1341     // Free the default router table and Interface, clean up the assemble table.
1342     //
1343     if (IpSb->DefaultInterface != NULL) {
1344       if (IpSb->DefaultRouteTable != NULL) {
1345         Ip4FreeRouteTable (IpSb->DefaultRouteTable);
1346         IpSb->DefaultRouteTable = NULL;
1347       }
1348
1349       Ip4CancelReceive (IpSb->DefaultInterface);
1350
1351       Ip4FreeInterface (IpSb->DefaultInterface, NULL);
1352       IpSb->DefaultInterface = NULL;
1353     }
1354
1355     Ip4CleanAssembleTable (&IpSb->Assemble);
1356
1357     //
1358     // Create new default interface and route table.
1359     //
1360     IpIf = Ip4CreateInterface (IpSb->Mnp, IpSb->Controller, IpSb->Image);
1361     if (IpIf == NULL) {
1362       return EFI_OUT_OF_RESOURCES;
1363     }
1364
1365     RouteTable = Ip4CreateRouteTable ();
1366     if (RouteTable == NULL) {
1367       Ip4FreeInterface (IpIf, NULL);
1368       return EFI_OUT_OF_RESOURCES;
1369     }
1370
1371     IpSb->DefaultInterface  = IpIf;
1372     InsertHeadList (&IpSb->Interfaces, &IpIf->Link);
1373     IpSb->DefaultRouteTable = RouteTable;
1374     Ip4ReceiveFrame (IpIf, NULL, Ip4AccpetFrame, IpSb);
1375
1376     //
1377     // Reset the State to unstarted.
1378     //
1379     if (IpSb->State == IP4_SERVICE_CONFIGED || IpSb->State == IP4_SERVICE_STARTED) {
1380       IpSb->State = IP4_SERVICE_UNSTARTED;
1381     }
1382   }
1383
1384   return Status;
1385 }
1386
1387 /**
1388   The work function is to set the gateway addresses manually for the EFI IPv4
1389   network stack that is running on the communication device that this EFI IPv4
1390   Configuration Protocol manages. It is not configurable when the policy is
1391   Ip4Config2PolicyDhcp. The gateway addresses must be unicast IPv4 addresses.
1392
1393   @param[in]     Instance The pointer to the IP4 config2 instance data.
1394   @param[in]     DataSize The size of the buffer pointed to by Data in bytes.
1395   @param[in]     Data     The data buffer to set. This points to an array of
1396                           EFI_IPv6_ADDRESS instances.
1397
1398   @retval EFI_BAD_BUFFER_SIZE   The DataSize does not match the size of the type.
1399   @retval EFI_WRITE_PROTECTED   The specified configuration data cannot be set
1400                                 under the current policy.
1401   @retval EFI_INVALID_PARAMETER One or more fields in Data is invalid.
1402   @retval EFI_OUT_OF_RESOURCES  Failed to allocate resource to complete the operation.
1403   @retval EFI_ABORTED           The manual gateway addresses to be set equal the
1404                                 current configuration.
1405   @retval EFI_SUCCESS           The specified configuration data for the EFI IPv6
1406                                 network stack was set.
1407
1408 **/
1409 EFI_STATUS
1410 Ip4Config2SetGateway (
1411   IN IP4_CONFIG2_INSTANCE *Instance,
1412   IN UINTN                DataSize,
1413   IN VOID                 *Data
1414   )
1415 {
1416   IP4_SERVICE                    *IpSb;
1417   IP4_CONFIG2_DATA_ITEM          *DataItem;
1418   IP4_ADDR                       Gateway;
1419
1420   UINTN                 Index1;
1421   UINTN                 Index2;
1422   EFI_IPv4_ADDRESS      *OldGateway;
1423   EFI_IPv4_ADDRESS      *NewGateway;
1424   UINTN                 OldGatewayCount;
1425   UINTN                 NewGatewayCount;
1426   BOOLEAN               OneRemoved;
1427   BOOLEAN               OneAdded;
1428   VOID                  *Tmp;
1429
1430   OldGateway      = NULL;
1431   NewGateway      = NULL;
1432   OneRemoved      = FALSE;
1433   OneAdded        = FALSE;
1434   Tmp             = NULL;
1435
1436   if ((DataSize != 0) && (DataSize % sizeof (EFI_IPv4_ADDRESS) != 0)) {
1437     return EFI_BAD_BUFFER_SIZE;
1438   }
1439
1440   if (Instance->Policy != Ip4Config2PolicyStatic) {
1441     return EFI_WRITE_PROTECTED;
1442   }
1443
1444   IpSb = IP4_SERVICE_FROM_IP4_CONFIG2_INSTANCE (Instance);
1445
1446   DataItem        = &Instance->DataItem[Ip4Config2DataTypeGateway];
1447   OldGateway      = DataItem->Data.Gateway;
1448   OldGatewayCount = DataItem->DataSize / sizeof (EFI_IPv4_ADDRESS);
1449
1450   for (Index1 = 0; Index1 < OldGatewayCount; Index1++) {
1451     //
1452     // Remove the old route entry.
1453     //
1454     CopyMem (&Gateway, OldGateway + Index1, sizeof (IP4_ADDR));
1455     Ip4DelRoute (
1456       IpSb->DefaultRouteTable,
1457       IP4_ALLZERO_ADDRESS,
1458       IP4_ALLZERO_ADDRESS,
1459       NTOHL (Gateway)
1460       );
1461     OneRemoved = TRUE;
1462   }
1463
1464   if (Data != NULL && DataSize != 0) {
1465     NewGateway      = (EFI_IPv4_ADDRESS *) Data;
1466     NewGatewayCount = DataSize / sizeof (EFI_IPv4_ADDRESS);
1467     for (Index1 = 0; Index1 < NewGatewayCount; Index1++) {
1468       CopyMem (&Gateway, NewGateway + Index1, sizeof (IP4_ADDR));
1469
1470       if ((IpSb->DefaultInterface->SubnetMask != 0) &&
1471           !NetIp4IsUnicast (NTOHL (Gateway), IpSb->DefaultInterface->SubnetMask)) {
1472         return EFI_INVALID_PARAMETER;
1473       }
1474
1475       for (Index2 = Index1 + 1; Index2 < NewGatewayCount; Index2++) {
1476         if (EFI_IP4_EQUAL (NewGateway + Index1, NewGateway + Index2)) {
1477           return EFI_INVALID_PARAMETER;
1478         }
1479       }
1480     }
1481
1482     if (NewGatewayCount != OldGatewayCount) {
1483       Tmp = AllocatePool (DataSize);
1484       if (Tmp == NULL) {
1485         return EFI_OUT_OF_RESOURCES;
1486       }
1487     } else {
1488       Tmp = NULL;
1489     }
1490
1491     for (Index1 = 0; Index1 < NewGatewayCount; Index1++) {
1492       //
1493       // Add the new route entry.
1494       //
1495       CopyMem (&Gateway, NewGateway + Index1, sizeof (IP4_ADDR));
1496       Ip4AddRoute (
1497         IpSb->DefaultRouteTable,
1498         IP4_ALLZERO_ADDRESS,
1499         IP4_ALLZERO_ADDRESS,
1500         NTOHL (Gateway)
1501         );
1502
1503       OneAdded = TRUE;
1504     }
1505
1506     if (!OneRemoved && !OneAdded) {
1507       DataItem->Status = EFI_SUCCESS;
1508       return EFI_ABORTED;
1509     } else {
1510       if (Tmp != NULL) {
1511         if (DataItem->Data.Ptr != NULL) {
1512           FreePool (DataItem->Data.Ptr);
1513         }
1514         DataItem->Data.Ptr = Tmp;
1515       }
1516
1517       CopyMem (DataItem->Data.Ptr, Data, DataSize);
1518       DataItem->DataSize = DataSize;
1519       DataItem->Status   = EFI_SUCCESS;
1520     }
1521   } else {
1522     //
1523     // DataSize is 0 and Data is NULL, clean up the Gateway address.
1524     //
1525     if (DataItem->Data.Ptr != NULL) {
1526       FreePool (DataItem->Data.Ptr);
1527     }
1528     DataItem->Data.Ptr = NULL;
1529     DataItem->DataSize = 0;
1530     DataItem->Status   = EFI_NOT_FOUND;
1531   }
1532
1533   return EFI_SUCCESS;
1534 }
1535
1536 /**
1537   The work function is to set the DNS server list for the EFI IPv4 network
1538   stack running on the communication device that this EFI_IP4_CONFIG2_PROTOCOL
1539   manages. It is not configurable when the policy is Ip4Config2PolicyDhcp.
1540   The DNS server addresses must be unicast IPv4 addresses.
1541
1542   @param[in]     Instance The pointer to the IP4 config2 instance data.
1543   @param[in]     DataSize The size of the buffer pointed to by Data in bytes.
1544   @param[in]     Data     The data buffer to set, points to an array of
1545                           EFI_IPv4_ADDRESS instances.
1546
1547   @retval EFI_BAD_BUFFER_SIZE   The DataSize does not match the size of the type.
1548   @retval EFI_WRITE_PROTECTED   The specified configuration data cannot be set
1549                                 under the current policy.
1550   @retval EFI_INVALID_PARAMETER One or more fields in Data is invalid.
1551   @retval EFI_OUT_OF_RESOURCES  Failed to allocate resources to complete the operation.
1552   @retval EFI_ABORTED           The DNS server addresses to be set equal the current
1553                                 configuration.
1554   @retval EFI_SUCCESS           The specified configuration data for the EFI IPv4
1555                                 network stack was set.
1556
1557 **/
1558 EFI_STATUS
1559 Ip4Config2SetDnsServer (
1560   IN IP4_CONFIG2_INSTANCE *Instance,
1561   IN UINTN                DataSize,
1562   IN VOID                 *Data
1563   )
1564 {
1565   EFI_STATUS                     Status;
1566   IP4_CONFIG2_DATA_ITEM          *Item;
1567
1568   Status = EFI_SUCCESS;
1569   Item   = NULL;
1570
1571   if (Instance->Policy != Ip4Config2PolicyStatic) {
1572     return EFI_WRITE_PROTECTED;
1573   }
1574
1575   Item = &Instance->DataItem[Ip4Config2DataTypeDnsServer];
1576
1577   if (DATA_ATTRIB_SET (Item->Attribute, DATA_ATTRIB_VOLATILE)) {
1578     REMOVE_DATA_ATTRIB (Item->Attribute, DATA_ATTRIB_VOLATILE);
1579   }
1580
1581   if (Data != NULL && DataSize != 0) {
1582     Status = Ip4Config2SetDnsServerWorker (Instance, DataSize, Data);
1583   } else {
1584     //
1585     // DataSize is 0 and Data is NULL, clean up the DnsServer address.
1586     //
1587     if (Item->Data.Ptr != NULL) {
1588       FreePool (Item->Data.Ptr);
1589     }
1590     Item->Data.Ptr = NULL;
1591     Item->DataSize = 0;
1592     Item->Status   = EFI_NOT_FOUND;
1593   }
1594
1595   return Status;
1596 }
1597
1598 /**
1599   Generate the operational state of the interface this IP4 config2 instance manages
1600   and output in EFI_IP4_CONFIG2_INTERFACE_INFO.
1601
1602   @param[in]      IpSb     The pointer to the IP4 service binding instance.
1603   @param[out]     IfInfo   The pointer to the IP4 config2 interface information structure.
1604
1605 **/
1606 VOID
1607 Ip4Config2InitIfInfo (
1608   IN  IP4_SERVICE                    *IpSb,
1609   OUT EFI_IP4_CONFIG2_INTERFACE_INFO *IfInfo
1610   )
1611 {
1612   UnicodeSPrint (
1613     IfInfo->Name,
1614     EFI_IP4_CONFIG2_INTERFACE_INFO_NAME_SIZE,
1615     L"eth%d",
1616     IpSb->Ip4Config2Instance.IfIndex
1617   );
1618
1619   IfInfo->IfType        = IpSb->SnpMode.IfType;
1620   IfInfo->HwAddressSize = IpSb->SnpMode.HwAddressSize;
1621   CopyMem (&IfInfo->HwAddress, &IpSb->SnpMode.CurrentAddress, IfInfo->HwAddressSize);
1622 }
1623
1624
1625
1626 /**
1627   Set the configuration for the EFI IPv4 network stack running on the communication
1628   device this EFI_IP4_CONFIG2_PROTOCOL instance manages.
1629
1630   This function is used to set the configuration data of type DataType for the EFI
1631   IPv4 network stack that is running on the communication device that this EFI IPv4
1632   Configuration Protocol instance manages.
1633
1634   DataSize is used to calculate the count of structure instances in the Data for
1635   a DataType in which multiple structure instances are allowed.
1636
1637   This function is always non-blocking. When setting some type of configuration data,
1638   an asynchronous process is invoked to check the correctness of the data, such as
1639   performing Duplicate Address Detection on the manually set local IPv4 addresses.
1640   EFI_NOT_READY is returned immediately to indicate that such an asynchronous process
1641   is invoked, and the process is not finished yet. The caller wanting to get the result
1642   of the asynchronous process is required to call RegisterDataNotify() to register an
1643   event on the specified configuration data. Once the event is signaled, the caller
1644   can call GetData() to obtain the configuration data and know the result.
1645   For other types of configuration data that do not require an asynchronous configuration
1646   process, the result of the operation is immediately returned.
1647
1648   @param[in]     This           The pointer to the EFI_IP4_CONFIG2_PROTOCOL instance.
1649   @param[in]     DataType       The type of data to set.
1650   @param[in]     DataSize       Size of the buffer pointed to by Data in bytes.
1651   @param[in]     Data           The data buffer to set. The type of the data buffer is
1652                                 associated with the DataType.
1653
1654   @retval EFI_SUCCESS           The specified configuration data for the EFI IPv6
1655                                 network stack was set successfully.
1656   @retval EFI_INVALID_PARAMETER One or more of the following are TRUE:
1657                                 - This is NULL.
1658                                 - One or more fields in Data and DataSize do not match the
1659                                   requirement of the data type indicated by DataType.
1660   @retval EFI_WRITE_PROTECTED   The specified configuration data is read-only or the specified
1661                                 configuration data cannot be set under the current policy.
1662   @retval EFI_ACCESS_DENIED     Another set operation on the specified configuration
1663                                 data is already in process.
1664   @retval EFI_NOT_READY         An asynchronous process was invoked to set the specified
1665                                 configuration data, and the process is not finished yet.
1666   @retval EFI_BAD_BUFFER_SIZE   The DataSize does not match the size of the type
1667                                 indicated by DataType.
1668   @retval EFI_UNSUPPORTED       This DataType is not supported.
1669   @retval EFI_OUT_OF_RESOURCES  Required system resources could not be allocated.
1670   @retval EFI_DEVICE_ERROR      An unexpected system error or network error occurred.
1671
1672 **/
1673 EFI_STATUS
1674 EFIAPI
1675 EfiIp4Config2SetData (
1676   IN EFI_IP4_CONFIG2_PROTOCOL   *This,
1677   IN EFI_IP4_CONFIG2_DATA_TYPE  DataType,
1678   IN UINTN                      DataSize,
1679   IN VOID                       *Data
1680   )
1681 {
1682   EFI_TPL              OldTpl;
1683   EFI_STATUS           Status;
1684   IP4_CONFIG2_INSTANCE *Instance;
1685   IP4_SERVICE          *IpSb;
1686
1687   if ((This == NULL) || (Data == NULL && DataSize != 0) || (Data != NULL && DataSize == 0)) {
1688     return EFI_INVALID_PARAMETER;
1689   }
1690
1691   if (DataType >= Ip4Config2DataTypeMaximum) {
1692     return EFI_UNSUPPORTED;
1693   }
1694
1695   Instance = IP4_CONFIG2_INSTANCE_FROM_PROTOCOL (This);
1696   IpSb     = IP4_SERVICE_FROM_IP4_CONFIG2_INSTANCE (Instance);
1697   NET_CHECK_SIGNATURE (IpSb, IP4_SERVICE_SIGNATURE);
1698
1699
1700   OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
1701
1702   Status = Instance->DataItem[DataType].Status;
1703   if (Status != EFI_NOT_READY) {
1704
1705     if (Instance->DataItem[DataType].SetData == NULL) {
1706       //
1707       // This type of data is readonly.
1708       //
1709       Status = EFI_WRITE_PROTECTED;
1710     } else {
1711
1712       Status = Instance->DataItem[DataType].SetData (Instance, DataSize, Data);
1713       if (!EFI_ERROR (Status)) {
1714         //
1715         // Fire up the events registered with this type of data.
1716         //
1717         NetMapIterate (&Instance->DataItem[DataType].EventMap, Ip4Config2SignalEvent, NULL);
1718         Ip4Config2WriteConfigData (IpSb->MacString, Instance);
1719       } else if (Status == EFI_ABORTED) {
1720         //
1721         // The SetData is aborted because the data to set is the same with
1722         // the one maintained.
1723         //
1724         Status = EFI_SUCCESS;
1725         NetMapIterate (&Instance->DataItem[DataType].EventMap, Ip4Config2SignalEvent, NULL);
1726       }
1727     }
1728   } else {
1729     //
1730     // Another asynchornous process is on the way.
1731     //
1732     Status = EFI_ACCESS_DENIED;
1733   }
1734
1735   gBS->RestoreTPL (OldTpl);
1736
1737   return Status;
1738 }
1739
1740 /**
1741   Get the configuration data for the EFI IPv4 network stack running on the communication
1742   device that this EFI_IP4_CONFIG2_PROTOCOL instance manages.
1743
1744   This function returns the configuration data of type DataType for the EFI IPv4 network
1745   stack running on the communication device that this EFI IPv4 Configuration Protocol instance
1746   manages.
1747
1748   The caller is responsible for allocating the buffer used to return the specified
1749   configuration data. The required size will be returned to the caller if the size of
1750   the buffer is too small.
1751
1752   EFI_NOT_READY is returned if the specified configuration data is not ready due to an
1753   asynchronous configuration process already in progress. The caller can call RegisterDataNotify()
1754   to register an event on the specified configuration data. Once the asynchronous configuration
1755   process is finished, the event will be signaled, and a subsequent GetData() call will return
1756   the specified configuration data.
1757
1758   @param[in]      This           Pointer to the EFI_IP4_CONFIG2_PROTOCOL instance.
1759   @param[in]      DataType       The type of data to get.
1760   @param[in, out] DataSize       On input, in bytes, the size of Data. On output, in bytes, the
1761                                  size of buffer required to store the specified configuration data.
1762   @param[in]     Data            The data buffer in which the configuration data is returned. The
1763                                  type of the data buffer is associated with the DataType.
1764                                  This is an optional parameter that may be NULL.
1765
1766   @retval EFI_SUCCESS           The specified configuration data was obtained successfully.
1767   @retval EFI_INVALID_PARAMETER One or more of the followings are TRUE:
1768                                 - This is NULL.
1769                                 - DataSize is NULL.
1770                                 - Data is NULL if *DataSize is not zero.
1771   @retval EFI_BUFFER_TOO_SMALL  The size of Data is too small for the specified configuration data,
1772                                 and the required size is returned in DataSize.
1773   @retval EFI_NOT_READY         The specified configuration data is not ready due to an
1774                                 asynchronous configuration process already in progress.
1775   @retval EFI_NOT_FOUND         The specified configuration data is not found.
1776
1777 **/
1778 EFI_STATUS
1779 EFIAPI
1780 EfiIp4Config2GetData (
1781   IN EFI_IP4_CONFIG2_PROTOCOL   *This,
1782   IN EFI_IP4_CONFIG2_DATA_TYPE  DataType,
1783   IN OUT UINTN                  *DataSize,
1784   IN VOID                       *Data   OPTIONAL
1785   )
1786 {
1787   EFI_TPL               OldTpl;
1788   EFI_STATUS            Status;
1789   IP4_CONFIG2_INSTANCE  *Instance;
1790   IP4_CONFIG2_DATA_ITEM *DataItem;
1791
1792   if ((This == NULL) || (DataSize == NULL) || ((*DataSize != 0) && (Data == NULL))) {
1793     return EFI_INVALID_PARAMETER;
1794   }
1795
1796   if (DataType >= Ip4Config2DataTypeMaximum) {
1797     return EFI_NOT_FOUND;
1798   }
1799
1800   OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
1801
1802   Instance = IP4_CONFIG2_INSTANCE_FROM_PROTOCOL (This);
1803   DataItem = &Instance->DataItem[DataType];
1804
1805   Status   = Instance->DataItem[DataType].Status;
1806   if (!EFI_ERROR (Status)) {
1807
1808     if (DataItem->GetData != NULL) {
1809
1810       Status = DataItem->GetData (Instance, DataSize, Data);
1811     } else if (*DataSize < Instance->DataItem[DataType].DataSize) {
1812       //
1813       // Update the buffer length.
1814       //
1815       *DataSize = Instance->DataItem[DataType].DataSize;
1816       Status    = EFI_BUFFER_TOO_SMALL;
1817     } else {
1818
1819       *DataSize = Instance->DataItem[DataType].DataSize;
1820       CopyMem (Data, Instance->DataItem[DataType].Data.Ptr, *DataSize);
1821     }
1822   }
1823
1824   gBS->RestoreTPL (OldTpl);
1825
1826   return Status;
1827 }
1828
1829 /**
1830   Register an event that is signaled whenever a configuration process on the specified
1831   configuration data is done.
1832
1833   This function registers an event that is to be signaled whenever a configuration
1834   process on the specified configuration data is performed. An event can be registered
1835   for a different DataType simultaneously. The caller is responsible for determining
1836   which type of configuration data causes the signaling of the event in such an event.
1837
1838   @param[in]     This           Pointer to the EFI_IP4_CONFIG2_PROTOCOL instance.
1839   @param[in]     DataType       The type of data to unregister the event for.
1840   @param[in]     Event          The event to register.
1841
1842   @retval EFI_SUCCESS           The notification event for the specified configuration data is
1843                                 registered.
1844   @retval EFI_INVALID_PARAMETER This is NULL or Event is NULL.
1845   @retval EFI_UNSUPPORTED       The configuration data type specified by DataType is not
1846                                 supported.
1847   @retval EFI_OUT_OF_RESOURCES  Required system resources could not be allocated.
1848   @retval EFI_ACCESS_DENIED     The Event is already registered for the DataType.
1849
1850 **/
1851 EFI_STATUS
1852 EFIAPI
1853 EfiIp4Config2RegisterDataNotify (
1854   IN EFI_IP4_CONFIG2_PROTOCOL   *This,
1855   IN EFI_IP4_CONFIG2_DATA_TYPE  DataType,
1856   IN EFI_EVENT                  Event
1857   )
1858 {
1859   EFI_TPL              OldTpl;
1860   EFI_STATUS           Status;
1861   IP4_CONFIG2_INSTANCE *Instance;
1862   NET_MAP              *EventMap;
1863   NET_MAP_ITEM         *Item;
1864
1865   if ((This == NULL) || (Event == NULL)) {
1866     return EFI_INVALID_PARAMETER;
1867   }
1868
1869   if (DataType >= Ip4Config2DataTypeMaximum) {
1870     return EFI_UNSUPPORTED;
1871   }
1872
1873   OldTpl    = gBS->RaiseTPL (TPL_CALLBACK);
1874
1875   Instance  = IP4_CONFIG2_INSTANCE_FROM_PROTOCOL (This);
1876   EventMap  = &Instance->DataItem[DataType].EventMap;
1877
1878   //
1879   // Check whether this event is already registered for this DataType.
1880   //
1881   Item = NetMapFindKey (EventMap, Event);
1882   if (Item == NULL) {
1883
1884     Status = NetMapInsertTail (EventMap, Event, NULL);
1885
1886     if (EFI_ERROR (Status)) {
1887
1888       Status = EFI_OUT_OF_RESOURCES;
1889     }
1890
1891   } else {
1892
1893     Status = EFI_ACCESS_DENIED;
1894   }
1895
1896   gBS->RestoreTPL (OldTpl);
1897
1898   return Status;
1899 }
1900
1901 /**
1902   Remove a previously registered event for the specified configuration data.
1903
1904   @param  This                   The pointer to the EFI_IP4_CONFIG2_PROTOCOL instance.
1905   @param  DataType               The type of data to remove from the previously
1906                                  registered event.
1907   @param  Event                  The event to be unregistered.
1908
1909   @retval EFI_SUCCESS            The event registered for the specified
1910                                  configuration data was removed.
1911   @retval EFI_INVALID_PARAMETER  This is NULL or Event is NULL.
1912   @retval EFI_NOT_FOUND          The Event has not been registered for the
1913                                  specified DataType.
1914
1915 **/
1916 EFI_STATUS
1917 EFIAPI
1918 EfiIp4Config2UnregisterDataNotify (
1919   IN EFI_IP4_CONFIG2_PROTOCOL   *This,
1920   IN EFI_IP4_CONFIG2_DATA_TYPE  DataType,
1921   IN EFI_EVENT                  Event
1922   )
1923 {
1924   EFI_TPL              OldTpl;
1925   EFI_STATUS           Status;
1926   IP4_CONFIG2_INSTANCE *Instance;
1927   NET_MAP_ITEM         *Item;
1928
1929   if ((This == NULL) || (Event == NULL)) {
1930     return EFI_INVALID_PARAMETER;
1931   }
1932
1933   if (DataType >= Ip4Config2DataTypeMaximum) {
1934     return EFI_NOT_FOUND;
1935   }
1936
1937   OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
1938
1939   Instance = IP4_CONFIG2_INSTANCE_FROM_PROTOCOL (This);
1940
1941   Item = NetMapFindKey (&Instance->DataItem[DataType].EventMap, Event);
1942   if (Item != NULL) {
1943
1944     NetMapRemoveItem (&Instance->DataItem[DataType].EventMap, Item, NULL);
1945     Status = EFI_SUCCESS;
1946   } else {
1947
1948     Status = EFI_NOT_FOUND;
1949   }
1950
1951   gBS->RestoreTPL (OldTpl);
1952
1953   return Status;
1954 }
1955
1956 /**
1957   Initialize an IP4_CONFIG2_INSTANCE.
1958
1959   @param[out]    Instance       The buffer of IP4_CONFIG2_INSTANCE to be initialized.
1960
1961   @retval EFI_OUT_OF_RESOURCES  Failed to allocate resources to complete the operation.
1962   @retval EFI_SUCCESS           The IP4_CONFIG2_INSTANCE initialized successfully.
1963
1964 **/
1965 EFI_STATUS
1966 Ip4Config2InitInstance (
1967   OUT IP4_CONFIG2_INSTANCE  *Instance
1968   )
1969 {
1970   IP4_SERVICE           *IpSb;
1971   IP4_CONFIG2_INSTANCE  *TmpInstance;
1972   LIST_ENTRY            *Entry;
1973   EFI_STATUS            Status;
1974   UINTN                 Index;
1975   UINT16                IfIndex;
1976   IP4_CONFIG2_DATA_ITEM *DataItem;
1977
1978
1979   IpSb = IP4_SERVICE_FROM_IP4_CONFIG2_INSTANCE (Instance);
1980
1981   Instance->Signature = IP4_CONFIG2_INSTANCE_SIGNATURE;
1982
1983
1984   //
1985   // Determine the index of this interface.
1986   //
1987   IfIndex = 0;
1988   NET_LIST_FOR_EACH (Entry, &mIp4Config2InstanceList) {
1989     TmpInstance = NET_LIST_USER_STRUCT_S (Entry, IP4_CONFIG2_INSTANCE, Link, IP4_CONFIG2_INSTANCE_SIGNATURE);
1990
1991     if (TmpInstance->IfIndex > IfIndex) {
1992       //
1993       // There is a sequence hole because some interface is down.
1994       //
1995       break;
1996     }
1997
1998     IfIndex++;
1999   }
2000
2001   Instance->IfIndex = IfIndex;
2002   NetListInsertBefore (Entry, &Instance->Link);
2003
2004   for (Index = 0; Index < Ip4Config2DataTypeMaximum; Index++) {
2005     //
2006     // Initialize the event map for each data item.
2007     //
2008     NetMapInit (&Instance->DataItem[Index].EventMap);
2009   }
2010
2011
2012   //
2013   // Initialize each data type: associate storage and set data size for the
2014   // fixed size data types, hook the SetData function, set the data attribute.
2015   //
2016   DataItem           = &Instance->DataItem[Ip4Config2DataTypeInterfaceInfo];
2017   DataItem->GetData  = Ip4Config2GetIfInfo;
2018   DataItem->Data.Ptr = &Instance->InterfaceInfo;
2019   DataItem->DataSize = sizeof (Instance->InterfaceInfo);
2020   SET_DATA_ATTRIB (DataItem->Attribute, DATA_ATTRIB_SIZE_FIXED | DATA_ATTRIB_VOLATILE);
2021   Ip4Config2InitIfInfo (IpSb, &Instance->InterfaceInfo);
2022
2023   DataItem           = &Instance->DataItem[Ip4Config2DataTypePolicy];
2024   DataItem->SetData  = Ip4Config2SetPolicy;
2025   DataItem->Data.Ptr = &Instance->Policy;
2026   DataItem->DataSize = sizeof (Instance->Policy);
2027   Instance->Policy   = Ip4Config2PolicyStatic;
2028   SET_DATA_ATTRIB (DataItem->Attribute, DATA_ATTRIB_SIZE_FIXED);
2029
2030   DataItem           = &Instance->DataItem[Ip4Config2DataTypeManualAddress];
2031   DataItem->SetData  = Ip4Config2SetManualAddress;
2032   DataItem->Status   = EFI_NOT_FOUND;
2033
2034   DataItem           = &Instance->DataItem[Ip4Config2DataTypeGateway];
2035   DataItem->SetData  = Ip4Config2SetGateway;
2036   DataItem->Status   = EFI_NOT_FOUND;
2037
2038   DataItem           = &Instance->DataItem[Ip4Config2DataTypeDnsServer];
2039   DataItem->SetData  = Ip4Config2SetDnsServer;
2040   DataItem->Status   = EFI_NOT_FOUND;
2041
2042   Instance->Configured  = TRUE;
2043
2044   //
2045   // Try to read the config data from NV variable.
2046   // If not found, write initialized config data into NV variable
2047   // as a default config data.
2048   //
2049   Status = Ip4Config2ReadConfigData (IpSb->MacString, Instance);
2050   if (Status == EFI_NOT_FOUND) {
2051     Status = Ip4Config2WriteConfigData (IpSb->MacString, Instance);
2052   }
2053
2054   if (EFI_ERROR (Status)) {
2055     return Status;
2056   }
2057
2058   Instance->Ip4Config2.SetData              = EfiIp4Config2SetData;
2059   Instance->Ip4Config2.GetData              = EfiIp4Config2GetData;
2060   Instance->Ip4Config2.RegisterDataNotify   = EfiIp4Config2RegisterDataNotify;
2061   Instance->Ip4Config2.UnregisterDataNotify = EfiIp4Config2UnregisterDataNotify;
2062
2063   //
2064   // Publish the IP4 configuration form
2065   //
2066   return Ip4Config2FormInit (Instance);
2067 }
2068
2069
2070 /**
2071   Release an IP4_CONFIG2_INSTANCE.
2072
2073   @param[in, out] Instance    The buffer of IP4_CONFIG2_INSTANCE to be freed.
2074
2075 **/
2076 VOID
2077 Ip4Config2CleanInstance (
2078   IN OUT IP4_CONFIG2_INSTANCE  *Instance
2079   )
2080 {
2081   UINTN                 Index;
2082   IP4_CONFIG2_DATA_ITEM *DataItem;
2083
2084   if (Instance->DeclineAddress != NULL) {
2085     FreePool (Instance->DeclineAddress);
2086   }
2087
2088   if (!Instance->Configured) {
2089     return ;
2090   }
2091
2092   if (Instance->Dhcp4Handle != NULL) {
2093
2094     Ip4Config2DestroyDhcp4 (Instance);
2095   }
2096
2097   //
2098   // Close the event.
2099   //
2100   if (Instance->Dhcp4Event != NULL) {
2101     gBS->CloseEvent (Instance->Dhcp4Event);
2102     Instance->Dhcp4Event = NULL;
2103   }
2104
2105   for (Index = 0; Index < Ip4Config2DataTypeMaximum; Index++) {
2106
2107     DataItem = &Instance->DataItem[Index];
2108
2109     if (!DATA_ATTRIB_SET (DataItem->Attribute, DATA_ATTRIB_SIZE_FIXED)) {
2110       if (DataItem->Data.Ptr != NULL) {
2111         FreePool (DataItem->Data.Ptr);
2112       }
2113       DataItem->Data.Ptr = NULL;
2114       DataItem->DataSize = 0;
2115     }
2116
2117     NetMapClean (&Instance->DataItem[Index].EventMap);
2118   }
2119
2120   Ip4Config2FormUnload (Instance);
2121
2122   RemoveEntryList (&Instance->Link);
2123 }
2124
2125 /**
2126   The event handle for IP4 auto reconfiguration. The original default
2127   interface and route table will be removed as the default.
2128
2129   @param[in]  Context                The IP4 service binding instance.
2130
2131 **/
2132 VOID
2133 EFIAPI
2134 Ip4AutoReconfigCallBackDpc (
2135   IN VOID                   *Context
2136   )
2137 {
2138   IP4_SERVICE               *IpSb;
2139
2140   IpSb      = (IP4_SERVICE *) Context;
2141   NET_CHECK_SIGNATURE (IpSb, IP4_SERVICE_SIGNATURE);
2142
2143   if (IpSb->State > IP4_SERVICE_UNSTARTED) {
2144     IpSb->State = IP4_SERVICE_UNSTARTED;
2145   }
2146
2147   IpSb->Reconfig = TRUE;
2148
2149   Ip4StartAutoConfig (&IpSb->Ip4Config2Instance);
2150
2151   return ;
2152 }
2153
2154
2155 /**
2156   Request Ip4AutoReconfigCallBackDpc as a DPC at TPL_CALLBACK.
2157
2158   @param Event     The event that is signalled.
2159   @param Context   The IP4 service binding instance.
2160
2161 **/
2162 VOID
2163 EFIAPI
2164 Ip4AutoReconfigCallBack (
2165   IN EFI_EVENT              Event,
2166   IN VOID                   *Context
2167   )
2168 {
2169   //
2170   // Request Ip4AutoReconfigCallBackDpc as a DPC at TPL_CALLBACK
2171   //
2172   QueueDpc (TPL_CALLBACK, Ip4AutoReconfigCallBackDpc, Context);
2173 }
2174