MdeModulePkg/Universal/Network/Ip4Dxe/Ip4Config2Impl.c

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