//;******************************************************************************
//;* Copyright (c) 1983-2020, Insyde Software Corp. All Rights Reserved.
//;*
//;* You may not reproduce, distribute, publish, display, perform, modify, adapt,
//;* transmit, broadcast, present, recite, release, license or otherwise exploit
//;* any part of this publication in any form, by any means, without the prior
//;* written permission of Insyde Software Corporation.
//;*
//;******************************************************************************
//;
//; Module Name:
//;
//;   DhcpDummy.h
//;
//; Abstract:
//;
//;    Refer DhcpDummy.c
//;

#include "PxeDummy.h"
#include <Guid/BdsHii.h>

BOOLEAN                                gDeviceConnecting;
EFI_HII_DATABASE_NEW_PACK              gOldNewPackFunction;
EFI_HII_DATABASE_PROTOCOL              *gHiiDataBaseProtocol;

EFI_STATUS
PxeNetworkStackCallback (
  NETWORK_STACK_CALLBACK_IDENTIFIER    Identifier
  )
{
  if (Identifier == NetworkStackSnpCallback) {
    return EFI_SUCCESS;
  }
  return EFI_UNSUPPORTED;
}

EFI_STATUS
FindRealPxeEntry (
  IN   FAKE_LOAD_FILE_INSTANCE         *LoadFileInstance,
  OUT  EFI_LOAD_FILE_PROTOCOL          **RealLoadFile OPTIONAL
  )
{
  EFI_STATUS                           Status;
  EFI_DEVICE_PATH                      *DevicePath;
  EFI_LOAD_FILE_PROTOCOL               *LoadFile;
  EFI_HANDLE                           LoadFileHandle;

  EFI_DEVICE_PATH                      *CallerDevicePath;

  EFI_PXE_BASE_CODE_PROTOCOL           *PxeBc;
  EFI_SIMPLE_NETWORK_PROTOCOL          *Snp;

  VOID                                 *MnpSb;

  if (LoadFileInstance->RealEntry != NULL) {
    if (RealLoadFile != NULL) {
      *RealLoadFile = LoadFileInstance->RealEntry;
    }
    return EFI_SUCCESS;
  }

  CallerDevicePath = LoadFileInstance->FakePxeDevicePath;
  Status = gBS->LocateDevicePath (
                  &gEfiLoadFileProtocolGuid,
                  &CallerDevicePath,
                  &LoadFileHandle
                  );
  if (EFI_ERROR (Status)) {
    return Status;
  }

  Status = gBS->HandleProtocol (
                  LoadFileHandle,
                  &gEfiDevicePathProtocolGuid,
                  (VOID **) &DevicePath
                  );
  if (EFI_ERROR (Status)) {
    return Status;
  }

  Status = gBS->HandleProtocol (
                  LoadFileHandle,
                  &gEfiLoadFileProtocolGuid,
                  (VOID **) &LoadFile
                  );
  if (EFI_ERROR (Status)) {
    return Status;
  }

  //
  // Because uninstall device path from real handle will cause it UninsatllMultipleProtocol failed.
  // So keep the real PXE handle, PxeDummy can try to uninstall protocol from it.
  // To keep original handle, and install CallerIdGuid on it.
  //
  LoadFileInstance->RealPxeHandle     = LoadFileHandle;
  LoadFileInstance->RealPxeDevicePath = DevicePath;
  LoadFileInstance->RealEntry         = LoadFile;
  Status = gBS->InstallProtocolInterface (
                  &LoadFileHandle,
                  &gEfiCallerIdGuid,
                  EFI_NATIVE_INTERFACE,
                  (VOID *) LoadFileInstance->RealEntry
                  );
  ASSERT_EFI_ERROR (Status);
      
  //
  // Bypass PxeBc and SNP protocol to FakeLoadFileHandle
  //
  Status = gBS->HandleProtocol (
                  LoadFileHandle,
                  &gEfiPxeBaseCodeProtocolGuid,
                  (VOID **) &PxeBc
                  );
  if (!EFI_ERROR (Status)) {
    gBS->InstallProtocolInterface (
           &LoadFileInstance->FakePxeHandle,
           &gEfiPxeBaseCodeProtocolGuid,
           EFI_NATIVE_INTERFACE,
           (VOID *) PxeBc
           );
  }

  Status = gBS->HandleProtocol (
                  LoadFileHandle,
                  &gEfiSimpleNetworkProtocolGuid,
                  (VOID **) &Snp
                  );
  if (!EFI_ERROR (Status)) {
    Status = gBS->InstallProtocolInterface (
                    &LoadFileInstance->FakePxeHandle,
                    &gEfiSimpleNetworkProtocolGuid,
                    EFI_NATIVE_INTERFACE,
                    (VOID *) Snp
                    );
    if (!EFI_ERROR (Status)) {
      gBS->OpenProtocol (
             LoadFileInstance->FakePxeHandle,
             &gEfiSimpleNetworkProtocolGuid,
             (VOID **) &Snp,
             LoadFileInstance->Instance->ImageHandle,
             LoadFileInstance->FakePxeHandle,
             EFI_OPEN_PROTOCOL_BY_DRIVER
             );
    }
  }

  //
  // Uninstall real LoadFile protocol and DevicePath and store real LoadFileProtocol address
  //
  gBS->UninstallMultipleProtocolInterfaces (
         LoadFileHandle,
         &gEfiDevicePathProtocolGuid,
         DevicePath,
         &gEfiLoadFileProtocolGuid,
         LoadFile,
         NULL,
         NULL
         );

  //
  // Find the parent handle of PXE LoadFile, if VLAN enabled, the ManagedNetworkProtocol will be remove.
  // The fake PXE loader handle must be remove too. The MnpSb will be closed when DummyPxeDestroyFakeHandle function was be executed (Binding.stop).
  //
  if (LoadFileInstance->Instance->RealMnpSb == NULL) {
    Status = gBS->HandleProtocol (
                    LoadFileInstance->Instance->UndiHandle,
                    &gEfiManagedNetworkServiceBindingProtocolGuid,
                    &MnpSb
                    );
    if (!EFI_ERROR (Status)) {
      Status = gBS->OpenProtocol (
                    LoadFileInstance->Instance->UndiHandle,
                    &gEfiManagedNetworkServiceBindingProtocolGuid,
                    (VOID **) &MnpSb,
                    LoadFileInstance->Instance->ImageHandle,
                    LoadFileInstance->FakePxeHandle,
                    EFI_OPEN_PROTOCOL_BY_DRIVER
                    );
      //
      // If this ASSERT trigged, system maybe hang when boot to the PXE when VLAN configuration is enabled and not reboot.
      //
      ASSERT_EFI_ERROR (Status);
      LoadFileInstance->Instance->RealMnpSb = MnpSb;
    }
  }
  
  if (RealLoadFile != NULL) {
    *RealLoadFile = LoadFileInstance->RealEntry;
  }
  return EFI_SUCCESS;
}

EFI_STATUS
UninstallFakeDevice (
  IN   COMMON_INSTANCE                 *Instance
  )
{
  DUMMY_PXE_INSTANCE                   *DummyPxeInstance;
  DUMMY_IP_INSTANCE                    *DummyIpInstance;

  if (Instance == NULL) {
    return EFI_NOT_READY;
  }

  DummyPxeInstance = &(Instance->Pxe);
  DummyIpInstance  = &(Instance->Ip);

  gBS->CloseProtocol (
         Instance->UndiHandle,
         &gEfiSimpleNetworkProtocolGuid,
         Instance->ImageHandle,
         Instance->UndiHandle
         );

  //
  // Kill the Fake device path first, make sure the real protocol can be binding success.
  //
  if (DummyPxeInstance->Ip4.Enable) {
    gBS->UninstallProtocolInterface (
           DummyPxeInstance->Ip4.FakePxeHandle,
           &gEfiDevicePathProtocolGuid,
           DummyPxeInstance->Ip4.FakePxeDevicePath
           );
  }
  if (DummyPxeInstance->Ip6.Enable) {
    gBS->UninstallProtocolInterface (
           DummyPxeInstance->Ip6.FakePxeHandle,
           &gEfiDevicePathProtocolGuid,
           DummyPxeInstance->Ip6.FakePxeDevicePath
           );
  }
  if (DummyPxeInstance->Http4.Enable) {
    gBS->UninstallProtocolInterface (
           DummyPxeInstance->Http4.FakePxeHandle,
           &gEfiDevicePathProtocolGuid,
           DummyPxeInstance->Http4.FakePxeDevicePath
           );
  }
  if (DummyPxeInstance->Http6.Enable) {
    gBS->UninstallProtocolInterface (
           DummyPxeInstance->Http6.FakePxeHandle,
           &gEfiDevicePathProtocolGuid,
           DummyPxeInstance->Http6.FakePxeDevicePath
           );
  }

  //
  // Kill the fake IP services.
  //
  gBS->CloseProtocol (
         Instance->UndiHandle,
         &gEfiManagedNetworkServiceBindingProtocolGuid,
         Instance->ImageHandle,
         DummyIpInstance->MnpSB.Ip4ChildHandle
         );

  gBS->UninstallMultipleProtocolInterfaces (
         Instance->UndiHandle,
         &gEfiManagedNetworkServiceBindingProtocolGuid,
         &(DummyIpInstance->MnpSB.MnpSB),
         NULL
         );

  gBS->UninstallMultipleProtocolInterfaces (
         Instance->UndiHandle,
         &gEfiVlanConfigProtocolGuid,
         &(DummyIpInstance->VlanConfig.VlanConfig),
         NULL
         );

  gBS->UninstallMultipleProtocolInterfaces (
         Instance->UndiHandle,
         &gEfiIp4ServiceBindingProtocolGuid,
         &(DummyIpInstance->Ip4SB.Ip4SB),
         &gEfiDhcp4ServiceBindingProtocolGuid,
         &(DummyIpInstance->Dhcp4SB.Dhcp4SB),
         &gEfiIp4ConfigProtocolGuid,
         &(DummyIpInstance->Ip4Config.Ip4Config),
         &gEfiIp4Config2ProtocolGuid,
         &(DummyIpInstance->Ip4Config2.Ip4Config2),
         &gEfiIp6ServiceBindingProtocolGuid,
         &(DummyIpInstance->Ip6SB.Ip6SB),
         &gEfiDhcp6ServiceBindingProtocolGuid,
         &(DummyIpInstance->Dhcp6SB.Dhcp6SB),
         &gEfiIp6ConfigProtocolGuid,
         &(DummyIpInstance->Ip6Config.Ip6Config),
         NULL
         );

  return EFI_SUCCESS;
}

EFI_STATUS
ReinstallFakeDevicePath (
  COMMON_INSTANCE                      *Instance
  )
{
  DUMMY_PXE_INSTANCE                   *DummyPxeInstance;

  if (Instance == NULL) {
    return EFI_SUCCESS;
  }

  DummyPxeInstance = &(Instance->Pxe);

  if (DummyPxeInstance->Ip4.Enable) {
    FindRealPxeEntry (&DummyPxeInstance->Ip4, NULL);
    gBS->InstallMultipleProtocolInterfaces (
           &(DummyPxeInstance->Ip4.FakePxeHandle),
           &gEfiDevicePathProtocolGuid,
           DummyPxeInstance->Ip4.FakePxeDevicePath,
           &gEfiLoadFileProtocolGuid,
           (VOID **) &DummyPxeInstance->Ip4.LoadFile,
           NULL,
           NULL
           );
  }
  if (DummyPxeInstance->Ip6.Enable) {
    FindRealPxeEntry (&DummyPxeInstance->Ip6, NULL);
    gBS->InstallMultipleProtocolInterfaces (
           &(DummyPxeInstance->Ip6.FakePxeHandle),
           &gEfiDevicePathProtocolGuid,
           DummyPxeInstance->Ip6.FakePxeDevicePath,
           &gEfiLoadFileProtocolGuid,
           (VOID **) &DummyPxeInstance->Ip6.LoadFile,
           NULL,
           NULL
           );
  }
  if (DummyPxeInstance->Http4.Enable) {
    FindRealPxeEntry (&DummyPxeInstance->Http4, NULL);
    gBS->InstallMultipleProtocolInterfaces (
           &(DummyPxeInstance->Http4.FakePxeHandle),
           &gEfiDevicePathProtocolGuid,
           DummyPxeInstance->Http4.FakePxeDevicePath,
           &gEfiLoadFileProtocolGuid,
           (VOID **) &DummyPxeInstance->Http4.LoadFile,
           NULL,
           NULL
           );
  }
  if (DummyPxeInstance->Http6.Enable) {
    FindRealPxeEntry (&DummyPxeInstance->Http6, NULL);
    gBS->InstallMultipleProtocolInterfaces (
           &(DummyPxeInstance->Http6.FakePxeHandle),
           &gEfiDevicePathProtocolGuid,
           DummyPxeInstance->Http6.FakePxeDevicePath,
           &gEfiLoadFileProtocolGuid,
           (VOID **) &DummyPxeInstance->Http6.LoadFile,
           NULL,
           NULL
           );
  }
  return EFI_SUCCESS;
}

EFI_STATUS
ReinstallFakeDevice (
  COMMON_INSTANCE                      *Instance
  )
{
  DUMMY_PXE_INSTANCE                   *DummyPxeInstance;
  DUMMY_IP_INSTANCE                    *DummyIpInstance;

  DummyPxeInstance = &(Instance->Pxe);
  DummyIpInstance  = &(Instance->Ip);

  //
  // If connect failed, restore Device path to make sure fake entry valid.
  //
  if (DummyPxeInstance->Ip4.Enable) {
    gBS->InstallProtocolInterface (
           &(DummyPxeInstance->Ip4.FakePxeHandle),
           &gEfiDevicePathProtocolGuid,
           EFI_NATIVE_INTERFACE,
           DummyPxeInstance->Ip4.FakePxeDevicePath
           );
  }
  if (DummyPxeInstance->Ip6.Enable) {
    gBS->InstallProtocolInterface (
           &(DummyPxeInstance->Ip6.FakePxeHandle),
           &gEfiDevicePathProtocolGuid,
           EFI_NATIVE_INTERFACE,
           DummyPxeInstance->Ip6.FakePxeDevicePath
           );
  }
  if (DummyPxeInstance->Http4.Enable) {
    gBS->InstallProtocolInterface (
           &(DummyPxeInstance->Http4.FakePxeHandle),
           &gEfiDevicePathProtocolGuid,
           EFI_NATIVE_INTERFACE,
           DummyPxeInstance->Http4.FakePxeDevicePath
           );
  }
  if (DummyPxeInstance->Http6.Enable) {
    gBS->InstallProtocolInterface (
           &(DummyPxeInstance->Http6.FakePxeHandle),
           &gEfiDevicePathProtocolGuid,
           EFI_NATIVE_INTERFACE,
           DummyPxeInstance->Http6.FakePxeDevicePath
           );
  }
  gBS->InstallMultipleProtocolInterfaces (
         &Instance->UndiHandle,
         &gEfiIp4ServiceBindingProtocolGuid,
         &(DummyIpInstance->Ip4SB.Ip4SB),
         &gEfiDhcp4ServiceBindingProtocolGuid,
         &(DummyIpInstance->Dhcp4SB.Dhcp4SB),
         &gEfiIp4ConfigProtocolGuid,
         &(DummyIpInstance->Ip4Config.Ip4Config),
         &gEfiIp4Config2ProtocolGuid,
         &(DummyIpInstance->Ip4Config2.Ip4Config2),
         &gEfiIp6ServiceBindingProtocolGuid,
         &(DummyIpInstance->Ip6SB.Ip6SB),
         &gEfiDhcp6ServiceBindingProtocolGuid,
         &(DummyIpInstance->Dhcp6SB.Dhcp6SB),
         &gEfiIp6ConfigProtocolGuid,
         &(DummyIpInstance->Ip6Config.Ip6Config),
         NULL,
         NULL
         );

  return EFI_SUCCESS;
}

EFI_STATUS
RelocateAllFunction (
  COMMON_INSTANCE                      *Instance
  )
{
  DUMMY_PXE_INSTANCE                   *DummyPxeInstance;
  DUMMY_IP_INSTANCE                    *DummyIpInstance;
  EFI_STATUS                           Status;

  if (Instance == NULL) {
    return EFI_SUCCESS;
  }

  DummyPxeInstance = &(Instance->Pxe);
  DummyIpInstance  = &(Instance->Ip);

  //
  // Kill fake PXE entry.
  //
  if (DummyPxeInstance->Ip4.Enable) {
    gBS->UninstallProtocolInterface (
           DummyPxeInstance->Ip4.FakePxeHandle,
           &gEfiLoadFileProtocolGuid,
           &(DummyPxeInstance->Ip4.LoadFile)
           );
  }
  if (DummyPxeInstance->Ip6.Enable) {
    gBS->UninstallProtocolInterface (
           DummyPxeInstance->Ip6.FakePxeHandle,
           &gEfiLoadFileProtocolGuid,
           &(DummyPxeInstance->Ip6.LoadFile)
           );
  }
  if (DummyPxeInstance->Http4.Enable) {
    gBS->UninstallProtocolInterface (
           DummyPxeInstance->Http4.FakePxeHandle,
           &gEfiLoadFileProtocolGuid,
           &(DummyPxeInstance->Http4.LoadFile)
           );
  }
  if (DummyPxeInstance->Http6.Enable) {
    gBS->UninstallProtocolInterface (
           DummyPxeInstance->Http6.FakePxeHandle,
           &gEfiLoadFileProtocolGuid,
           &(DummyPxeInstance->Http6.LoadFile)
           );
  }

  //
  // Check Network Stack behavior.
  // If protocol is not ready, return failed to exit PxeDummy.
  //
  Status = gBS->HandleProtocol (
                  Instance->UndiHandle,
                  &gEfiManagedNetworkServiceBindingProtocolGuid,
                  (VOID **) &(DummyIpInstance->MnpSB.RealMnpSB)
                  );

  if (EFI_ERROR(Status)) {
    return Status;
  }

  //
  // Try to get Vlan config protocol.
  //
  Status = gBS->HandleProtocol (
                  Instance->UndiHandle,
                  &gEfiVlanConfigProtocolGuid,
                  (VOID **) &(DummyIpInstance->VlanConfig.RealVlanConfig)
                  );
  DEBUG ((EFI_D_ERROR, "RelocateAllFunction: Get VlanConfigProtocol on Handle %x - %r\n", Instance->UndiHandle, Status));

  Status = gBS->HandleProtocol (
                  Instance->UndiHandle,
                  &gEfiIp4ServiceBindingProtocolGuid,
                  (VOID **) &(DummyIpInstance->Ip4SB.RealIp4SB)
                  );
  DEBUG ((EFI_D_ERROR, "RelocateAllFunction: Get Ip4ServiceBindingProtocol on Handle %x - %r\n", Instance->UndiHandle, Status));

  Status = gBS->HandleProtocol (
                  Instance->UndiHandle,
                  &gEfiDhcp4ServiceBindingProtocolGuid,
                  (VOID **) &(DummyIpInstance->Dhcp4SB.RealDhcp4SB)
                  );
  DEBUG ((EFI_D_ERROR, "RelocateAllFunction: Get Dhcp4ServiceBindingProtocol on Handle %x - %r\n", Instance->UndiHandle, Status));

  //
  // Ip4Config protocol will be remove after Ip4Config2 implement.
  // Do not check it when PxeDummy find real instance.
  //
  Status = gBS->HandleProtocol (
                  Instance->UndiHandle,
                  &gEfiIp4ConfigProtocolGuid,
                  (VOID **) &(DummyIpInstance->Ip4Config.RealIp4Config)
                  );
  DEBUG ((EFI_D_ERROR, "RelocateAllFunction: Get Ip4ConfigProtocol on Handle %x - %r\n", Instance->UndiHandle, Status));

  //
  // Try to locate Ip4Config2
  //
  Status =  gBS->HandleProtocol (
                   Instance->UndiHandle,
                   &gEfiIp4Config2ProtocolGuid,
                   (VOID **) &(DummyIpInstance->Ip4Config2.RealIp4Config2)
                   );
  DEBUG ((EFI_D_ERROR, "RelocateAllFunction: Get Ip4Config2Protocol on Handle %x - %r\n", Instance->UndiHandle, Status));

  Status = gBS->HandleProtocol (
                  Instance->UndiHandle,
                  &gEfiIp6ServiceBindingProtocolGuid,
                  (VOID **) &(DummyIpInstance->Ip6SB.RealIp6SB)
                  );
  DEBUG ((EFI_D_ERROR, "RelocateAllFunction: Get Ip6ServiceBindingProtocol on Handle %x - %r\n", Instance->UndiHandle, Status));

  Status = gBS->HandleProtocol (
                  Instance->UndiHandle,
                  &gEfiDhcp6ServiceBindingProtocolGuid,
                  (VOID **) &(DummyIpInstance->Dhcp6SB.RealDhcp6SB)
                  );
  DEBUG ((EFI_D_ERROR, "RelocateAllFunction: Get Dhcp6ServiceBindingProtocol on Handle %x - %r\n", Instance->UndiHandle, Status));

  Status = gBS->HandleProtocol (
                  Instance->UndiHandle,
                  &gEfiIp6ConfigProtocolGuid,
                  (VOID **) &(DummyIpInstance->Ip6Config.RealIp6Config)
                   );
  DEBUG ((EFI_D_ERROR, "RelocateAllFunction: Get Ip6ConfigProtocol on Handle %x - %r\n", Instance->UndiHandle, Status));

  return EFI_SUCCESS;
}

EFI_STATUS
ConnectDevice (
  IN   COMMON_INSTANCE                 *Instance
  )
{
  EFI_STATUS                           Status;

  if (Instance == NULL) {
    return EFI_SUCCESS;
  }

  if (gDeviceConnecting) {
    return EFI_SUCCESS;
  }

  if (Instance->DeviceConnected) {
    return EFI_SUCCESS;
  }

  Instance->DeviceConnected = TRUE;
  gDeviceConnecting         = TRUE;

  UninstallFakeDevice (Instance);

  //
  // re-binding Network Stack services.
  //
  gNetworkLocker->NetworkStackCallback = gOldNetworkLockerCallback;
  gBS->ConnectController (Instance->UndiHandle, NULL, NULL, TRUE);
  Status = RelocateAllFunction (Instance);
  if (EFI_ERROR(Status)) {
    goto CONNECT_FAILED;
  }

  if (gOldNewPackFunction != NULL) {
    gHiiDataBaseProtocol->NewPackageList = gOldNewPackFunction;
  }
  gDeviceConnecting = FALSE;

  //
  // Reinstall DevicePath to make sure LoadFile can be loaded.
  // And stop event of ReadyToBoot to avoid Mnp DestroyChild Failed.
  //
  ReinstallFakeDevicePath (Instance);
  if (Instance->Ip.MnpSB.ReadyToBootEvent != NULL) {
    gBS->CloseEvent (Instance->Ip.MnpSB.ReadyToBootEvent);
  }

  //
  // Waitting for next trigger of network stack callers.
  // To avoid some driver will binding on Ip.CreateChildren function, this lock should be backup.
  //
  gNetworkLocker->NetworkStackCallback = PxeNetworkStackCallback;
  return Status;

CONNECT_FAILED:
  //
  // Reinstall PxeDummy to make sure fake PXE can be calling.
  //
  ReinstallFakeDevice (Instance);
  Instance->DeviceConnected = FALSE;
  gDeviceConnecting = FALSE;
  return Status;
}

VOID
RemoveDuplicatedDevicePath (
  FAKE_LOAD_FILE_INSTANCE              *LoadInstance
  )
{
  EFI_STATUS                           Status;
  EFI_DEVICE_PATH_PROTOCOL             *UpdatedDevicePath;

  //
  // To avoid Locate.c (499) assert, Finding the same device path installed in two handles.
  //
  UpdatedDevicePath = NULL;
  Status = gBS->HandleProtocol (
                  LoadInstance->RealPxeHandle,
                  &gEfiDevicePathProtocolGuid,
                  (VOID **) &UpdatedDevicePath
                  );
  if (EFI_ERROR (Status)) {
    return;
  }

  if (LoadInstance->RealPxeDevicePath != UpdatedDevicePath) {
    LoadInstance->RealPxeDevicePath = UpdatedDevicePath;
    LoadInstance->FakePxeDevicePath = UpdatedDevicePath;
  }

  gBS->UninstallProtocolInterface (
         LoadInstance->RealPxeHandle,
         &gEfiDevicePathProtocolGuid,
         (VOID *) UpdatedDevicePath
         );

  gBS->InstallProtocolInterface (
         &LoadInstance->FakePxeHandle,
         &gEfiDevicePathProtocolGuid,
         EFI_NATIVE_INTERFACE,
         (VOID *) LoadInstance->FakePxeDevicePath
         );
}

///
// For PXE LoadFile Protocol
//
EFI_STATUS
EFIAPI
FakePxeLoadFile (
  IN     EFI_LOAD_FILE_PROTOCOL        *This,
  IN     EFI_DEVICE_PATH_PROTOCOL      *CallerDevicePath,
  IN     BOOLEAN                       BootPolicy,
  IN OUT UINTN                         *BufferSize,
  IN     VOID                          *Buffer       OPTIONAL
  )
{
  COMMON_INSTANCE                      *Instance;
  DUMMY_PXE_INSTANCE                   *DummyPxeInstance;
  FAKE_LOAD_FILE_INSTANCE              *LoadInstance;
  EFI_STATUS                           Status;
  EFI_LOAD_FILE_PROTOCOL               *RealEntry;

  //
  // Only support BootPolicy
  //
  if (!BootPolicy) {
    return EFI_UNSUPPORTED;
  }

  LoadInstance = (VOID *) This;
  Instance = LoadInstance->Instance;
  if (Instance->Signature != DUMMY_PXE_INSTANCE_SIGNATURE) {
    return EFI_INVALID_PARAMETER;
  }
  DummyPxeInstance = &(Instance->Pxe);

  if (LoadInstance->RealEntry != NULL) {
    RealEntry = LoadInstance->RealEntry;
    return RealEntry->LoadFile (RealEntry, CallerDevicePath, BootPolicy, BufferSize, Buffer);
  }

  Status = ConnectDevice (Instance);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  //
  // Find real PXE entry.
  //
  Status = FindRealPxeEntry (LoadInstance, &RealEntry);
  if (EFI_ERROR (Status)) {
    goto FUNCTION_FAILED;
  }

  if (RealEntry == NULL) {
    return EFI_NOT_READY;
  }

  //
  // Bypass to real PXE entry.
  //
  LoadInstance->RealEntry = RealEntry;
  return RealEntry->LoadFile (RealEntry, CallerDevicePath, BootPolicy, BufferSize, Buffer);

FUNCTION_FAILED:
  return Status;
}

//
// For HTTP LoadFile Protocol
//
EFI_STATUS
EFIAPI
FakeHttpLoadFile (
  IN     EFI_LOAD_FILE_PROTOCOL        *This,
  IN     EFI_DEVICE_PATH_PROTOCOL      *CallerDevicePath,
  IN     BOOLEAN                       BootPolicy,
  IN OUT UINTN                         *BufferSize,
  IN     VOID                          *Buffer       OPTIONAL
  )
{
  EFI_STATUS                           Status;
  COMMON_INSTANCE                      *Instance;
  DUMMY_PXE_INSTANCE                   *DummyPxeInstance;
  FAKE_LOAD_FILE_INSTANCE              *LoadInstance;
  EFI_LOAD_FILE_PROTOCOL               *RealEntry;
  EFI_DEVICE_PATH_PROTOCOL             *RealDevicePath;

  if (This == NULL || BufferSize == NULL || CallerDevicePath == NULL) {
    return EFI_INVALID_PARAMETER;
  }

  //
  // Only support BootPolicy
  //
  if (!BootPolicy) {
    return EFI_UNSUPPORTED;
  }

  LoadInstance = (VOID *) This;
  Instance = LoadInstance->Instance;
  if (Instance->Signature != DUMMY_PXE_INSTANCE_SIGNATURE) {
    return EFI_INVALID_PARAMETER;
  }
  DummyPxeInstance = &(Instance->Pxe);

  if (LoadInstance->RealEntry != NULL) {
    RealEntry = LoadInstance->RealEntry;
    goto BOOT_TO_HTTP_BOOT_LOAD_FILE;
  }

  Status = ConnectDevice (Instance);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  //
  // Find real PXE entry.
  //
  Status = FindRealPxeEntry (LoadInstance, &RealEntry);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  if (RealEntry == NULL) {
    return EFI_NOT_READY;
  }

  LoadInstance->RealEntry = RealEntry;

BOOT_TO_HTTP_BOOT_LOAD_FILE:
  //
  // Because HttpBootDxe will ReInstall DevicePath to append finded file path.
  // Copy device path to original HttpBoot handle.
  //
  Status = gBS->HandleProtocol (
                  LoadInstance->RealPxeHandle,
                  &gEfiDevicePathProtocolGuid,
                  (VOID **) &RealDevicePath
                  );
  if (EFI_ERROR (Status)) {
    //
    // Install original DevicePath back when there is no DevicePath protocol.
    //
    Status = gBS->InstallProtocolInterface (
                    &LoadInstance->RealPxeHandle,
                    &gEfiDevicePathProtocolGuid,
                    EFI_NATIVE_INTERFACE,
                    LoadInstance->RealPxeDevicePath
                    );
    ASSERT_EFI_ERROR (Status);
  }

  //
  // Try to avoid RegisterRamDisk failed when install device path protocol.
  //
  gBS->UninstallProtocolInterface (
         LoadInstance->FakePxeHandle,
         &gEfiDevicePathProtocolGuid,
         LoadInstance->FakePxeDevicePath
         );

  //
  // Boot to real HTTP boot entry.
  // Maybe ReturnStatus is WARN_FILE_SYSTEM
  //
  Status = RealEntry->LoadFile (RealEntry, CallerDevicePath, BootPolicy, BufferSize, Buffer);
  RemoveDuplicatedDevicePath (LoadInstance);
  return Status;
}

//
// For Ip4Config protocol
//
EFI_STATUS
FakeIp4ConfigStart (
  IN EFI_IP4_CONFIG_PROTOCOL           *This,
  IN EFI_EVENT                         DoneEvent,
  IN EFI_EVENT                         ReconfigEvent
  )
{
  EFI_STATUS                           Status;
  COMMON_INSTANCE                      *Instance;
  FAKE_IP_IP4_CONFIG_INSATNCE          *Ip4ConfigInstance;

  Ip4ConfigInstance = (VOID *) This;
  Instance = Ip4ConfigInstance->Instance;
  if (Instance->Signature != DUMMY_PXE_INSTANCE_SIGNATURE) {
    return EFI_INVALID_PARAMETER;
  }

  Status = ConnectDevice (Instance);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  if (Ip4ConfigInstance->RealIp4Config == NULL) {
    return EFI_NOT_READY;
  }

  return Ip4ConfigInstance->RealIp4Config->Start (Ip4ConfigInstance->RealIp4Config, DoneEvent, ReconfigEvent);
}

EFI_STATUS
FakeIp4ConfigStop(
  IN EFI_IP4_CONFIG_PROTOCOL           *This
  )
{
  EFI_STATUS                           Status;
  COMMON_INSTANCE                      *Instance;
  FAKE_IP_IP4_CONFIG_INSATNCE          *Ip4ConfigInstance;

  Ip4ConfigInstance = (VOID *) This;
  Instance = Ip4ConfigInstance->Instance;
  if (Instance->Signature != DUMMY_PXE_INSTANCE_SIGNATURE) {
    return EFI_INVALID_PARAMETER;
  }

  Status = ConnectDevice (Instance);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  if (Ip4ConfigInstance->RealIp4Config == NULL) {
    return EFI_NOT_READY;
  }

  return Ip4ConfigInstance->RealIp4Config->Stop (Ip4ConfigInstance->RealIp4Config);
}

EFI_STATUS
FakeIp4ConfigGetData (
  IN EFI_IP4_CONFIG_PROTOCOL           *This,
  IN OUT UINTN                         *IpConfigDataSize,
  OUT EFI_IP4_IPCONFIG_DATA            *IpConfigData    OPTIONAL
  )
{
  EFI_STATUS                           Status;
  COMMON_INSTANCE                      *Instance;
  FAKE_IP_IP4_CONFIG_INSATNCE          *Ip4ConfigInstance;

  Ip4ConfigInstance = (VOID *) This;
  Instance = Ip4ConfigInstance->Instance;
  if (Instance->Signature != DUMMY_PXE_INSTANCE_SIGNATURE) {
    return EFI_INVALID_PARAMETER;
  }

  Status = ConnectDevice (Instance);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  if (Ip4ConfigInstance->RealIp4Config == NULL) {
    return EFI_NOT_READY;
  }

  return Ip4ConfigInstance->RealIp4Config->GetData (Ip4ConfigInstance->RealIp4Config, IpConfigDataSize, IpConfigData);
}

//
// For Ip6Config protocol
//
EFI_STATUS
FakeIp4Config2SetData (
  IN EFI_IP4_CONFIG2_PROTOCOL   *This,
  IN EFI_IP4_CONFIG2_DATA_TYPE  DataType,
  IN UINTN                      DataSize,
  IN VOID                       *Data
  )
{
  EFI_STATUS                           Status;
  COMMON_INSTANCE                      *Instance;
  FAKE_IP_IP4_CONFIG2_INSATNCE         *Ip4Config2Instance;

  Ip4Config2Instance = (VOID *) This;
  Instance = Ip4Config2Instance->Instance;
  if (Instance->Signature != DUMMY_PXE_INSTANCE_SIGNATURE) {
    return EFI_INVALID_PARAMETER;
  }

  Status = ConnectDevice (Instance);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  if (Ip4Config2Instance->RealIp4Config2 == NULL) {
    return EFI_NOT_READY;
  }

  return Ip4Config2Instance->RealIp4Config2->SetData (Ip4Config2Instance->RealIp4Config2, DataType, DataSize, Data);
}

EFI_STATUS
FakeIp4Config2GetData (
  IN EFI_IP4_CONFIG2_PROTOCOL   *This,
  IN EFI_IP4_CONFIG2_DATA_TYPE  DataType,
  IN OUT UINTN                  *DataSize,
  IN VOID                       *Data   OPTIONAL
  )
{
  EFI_STATUS                           Status;
  COMMON_INSTANCE                      *Instance;
  FAKE_IP_IP4_CONFIG2_INSATNCE         *Ip4Config2Instance;

  Ip4Config2Instance = (VOID *) This;
  Instance = Ip4Config2Instance->Instance;
  if (Instance->Signature != DUMMY_PXE_INSTANCE_SIGNATURE) {
    return EFI_INVALID_PARAMETER;
  }

  Status = ConnectDevice (Instance);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  if (Ip4Config2Instance->RealIp4Config2 == NULL) {
    return EFI_NOT_READY;
  }

  return Ip4Config2Instance->RealIp4Config2->GetData (Ip4Config2Instance->RealIp4Config2, DataType, DataSize, Data);
}

EFI_STATUS
FakeIp4Config2RegisterDataNotify (
  IN EFI_IP4_CONFIG2_PROTOCOL   *This,
  IN EFI_IP4_CONFIG2_DATA_TYPE  DataType,
  IN EFI_EVENT                  Event
  )
{
  EFI_STATUS                           Status;
  COMMON_INSTANCE                      *Instance;
  FAKE_IP_IP4_CONFIG2_INSATNCE         *Ip4Config2Instance;

  Ip4Config2Instance = (VOID *) This;
  Instance = Ip4Config2Instance->Instance;
  if (Instance->Signature != DUMMY_PXE_INSTANCE_SIGNATURE) {
    return EFI_INVALID_PARAMETER;
  }

  Status = ConnectDevice (Instance);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  if (Ip4Config2Instance->RealIp4Config2 == NULL) {
    return EFI_NOT_READY;
  }

  return Ip4Config2Instance->RealIp4Config2->RegisterDataNotify (Ip4Config2Instance->RealIp4Config2, DataType, Event);
}

EFI_STATUS
FakeIp4Config2UnregisterDataNotify(
  IN EFI_IP4_CONFIG2_PROTOCOL   *This,
  IN EFI_IP4_CONFIG2_DATA_TYPE  DataType,
  IN EFI_EVENT                  Event
  )
{
  EFI_STATUS                           Status;
  COMMON_INSTANCE                      *Instance;
  FAKE_IP_IP4_CONFIG2_INSATNCE         *Ip4Config2Instance;

  Ip4Config2Instance = (VOID *) This;
  Instance = Ip4Config2Instance->Instance;
  if (Instance->Signature != DUMMY_PXE_INSTANCE_SIGNATURE) {
    return EFI_INVALID_PARAMETER;
  }

  Status = ConnectDevice (Instance);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  if (Ip4Config2Instance->RealIp4Config2 == NULL) {
    return EFI_NOT_READY;
  }

  return Ip4Config2Instance->RealIp4Config2->UnregisterDataNotify (Ip4Config2Instance->RealIp4Config2, DataType, Event);
}

//
// For Ip6Config protocol
//
EFI_STATUS
FakeIp6ConfigSetData (
  IN EFI_IP6_CONFIG_PROTOCOL    *This,
  IN EFI_IP6_CONFIG_DATA_TYPE   DataType,
  IN UINTN                      DataSize,
  IN VOID                       *Data
  )
{
  EFI_STATUS                           Status;
  COMMON_INSTANCE                      *Instance;
  FAKE_IP_IP6_CONFIG_INSATNCE          *Ip6ConfigInstance;

  Ip6ConfigInstance = (VOID *) This;
  Instance = Ip6ConfigInstance->Instance;
  if (Instance->Signature != DUMMY_PXE_INSTANCE_SIGNATURE) {
    return EFI_INVALID_PARAMETER;
  }

  Status = ConnectDevice (Instance);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  if (Ip6ConfigInstance->RealIp6Config == NULL) {
    return EFI_NOT_READY;
  }

  return Ip6ConfigInstance->RealIp6Config->SetData (Ip6ConfigInstance->RealIp6Config, DataType, DataSize, Data);
}

EFI_STATUS
FakeIp6ConfigGetData (
  IN EFI_IP6_CONFIG_PROTOCOL    *This,
  IN EFI_IP6_CONFIG_DATA_TYPE   DataType,
  IN OUT UINTN                  *DataSize,
  IN VOID                       *Data   OPTIONAL
  )
{
  EFI_STATUS                           Status;
  COMMON_INSTANCE                      *Instance;
  FAKE_IP_IP6_CONFIG_INSATNCE          *Ip6ConfigInstance;

  Ip6ConfigInstance = (VOID *) This;
  Instance = Ip6ConfigInstance->Instance;
  if (Instance->Signature != DUMMY_PXE_INSTANCE_SIGNATURE) {
    return EFI_INVALID_PARAMETER;
  }

  Status = ConnectDevice (Instance);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  if (Ip6ConfigInstance->RealIp6Config == NULL) {
    return EFI_NOT_READY;
  }

  return Ip6ConfigInstance->RealIp6Config->GetData (Ip6ConfigInstance->RealIp6Config, DataType, DataSize, Data);
}

EFI_STATUS
FakeIp6ConfigRegisterDataNotify (
  IN EFI_IP6_CONFIG_PROTOCOL    *This,
  IN EFI_IP6_CONFIG_DATA_TYPE   DataType,
  IN EFI_EVENT                  Event
  )
{
  EFI_STATUS                           Status;
  COMMON_INSTANCE                      *Instance;
  FAKE_IP_IP6_CONFIG_INSATNCE          *Ip6ConfigInstance;

  Ip6ConfigInstance = (VOID *) This;
  Instance = Ip6ConfigInstance->Instance;
  if (Instance->Signature != DUMMY_PXE_INSTANCE_SIGNATURE) {
    return EFI_INVALID_PARAMETER;
  }

  Status = ConnectDevice (Instance);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  if (Ip6ConfigInstance->RealIp6Config == NULL) {
    return EFI_NOT_READY;
  }

  return Ip6ConfigInstance->RealIp6Config->RegisterDataNotify (Ip6ConfigInstance->RealIp6Config, DataType, Event);
}

EFI_STATUS
FakeIp6ConfigUnregisterDataNotify(
  IN EFI_IP6_CONFIG_PROTOCOL    *This,
  IN EFI_IP6_CONFIG_DATA_TYPE   DataType,
  IN EFI_EVENT                  Event
  )
{
  EFI_STATUS                           Status;
  COMMON_INSTANCE                      *Instance;
  FAKE_IP_IP6_CONFIG_INSATNCE          *Ip6ConfigInstance;

  Ip6ConfigInstance = (VOID *) This;
  Instance = Ip6ConfigInstance->Instance;
  if (Instance->Signature != DUMMY_PXE_INSTANCE_SIGNATURE) {
    return EFI_INVALID_PARAMETER;
  }

  Status = ConnectDevice (Instance);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  if (Ip6ConfigInstance->RealIp6Config == NULL) {
    return EFI_NOT_READY;
  }

  return Ip6ConfigInstance->RealIp6Config->UnregisterDataNotify (Ip6ConfigInstance->RealIp6Config, DataType, Event);
}

//
// For Ip4 protocol
//
EFI_STATUS
FakeIp4GetModeData (
  IN CONST  EFI_IP4_PROTOCOL                *This,
  OUT       EFI_IP4_MODE_DATA               *Ip4ModeData     OPTIONAL,
  OUT       EFI_MANAGED_NETWORK_CONFIG_DATA *MnpConfigData   OPTIONAL,
  OUT       EFI_SIMPLE_NETWORK_MODE         *SnpModeData     OPTIONAL
  )
{
  EFI_STATUS                           Status;
  COMMON_INSTANCE                      *Instance;
  FAKE_IP_IP4_INSATNCE                 *Ip4Instance;

  Ip4Instance = (VOID *) This;
  Instance = Ip4Instance->Instance;
  if (Instance->Signature != DUMMY_PXE_INSTANCE_SIGNATURE) {
    return EFI_INVALID_PARAMETER;
  }

  Status = ConnectDevice (Instance);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  if (Ip4Instance->RealIp4 == NULL) {
    return EFI_NOT_READY;
  }

  return Ip4Instance->RealIp4->GetModeData (Ip4Instance->RealIp4, Ip4ModeData, MnpConfigData, SnpModeData);
}

EFI_STATUS
FakeIp4Configure (
  IN EFI_IP4_PROTOCOL    *This,
  IN EFI_IP4_CONFIG_DATA *IpConfigData     OPTIONAL
  )
{
  EFI_STATUS                           Status;
  COMMON_INSTANCE                      *Instance;
  FAKE_IP_IP4_INSATNCE                 *Ip4Instance;

  Ip4Instance = (VOID *) This;
  Instance = Ip4Instance->Instance;
  if (Instance->Signature != DUMMY_PXE_INSTANCE_SIGNATURE) {
    return EFI_INVALID_PARAMETER;
  }

  Status = ConnectDevice (Instance);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  if (Ip4Instance->RealIp4 == NULL) {
    return EFI_NOT_READY;
  }

  return Ip4Instance->RealIp4->Configure (Ip4Instance->RealIp4, IpConfigData);
}

EFI_STATUS
FakeIp4Groups (
  IN EFI_IP4_PROTOCOL    *This,
  IN BOOLEAN             JoinFlag,
  IN EFI_IPv4_ADDRESS    *GroupAddress  OPTIONAL
  )
{
  EFI_STATUS                           Status;
  COMMON_INSTANCE                      *Instance;
  FAKE_IP_IP4_INSATNCE                 *Ip4Instance;

  Ip4Instance = (VOID *) This;
  Instance = Ip4Instance->Instance;
  if (Instance->Signature != DUMMY_PXE_INSTANCE_SIGNATURE) {
    return EFI_INVALID_PARAMETER;
  }

  Status = ConnectDevice (Instance);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  if (Ip4Instance->RealIp4 == NULL) {
    return EFI_NOT_READY;
  }

  return Ip4Instance->RealIp4->Groups (Ip4Instance->RealIp4, JoinFlag, GroupAddress);
}

EFI_STATUS
FakeIp4Routes (
  IN EFI_IP4_PROTOCOL    *This,
  IN BOOLEAN             DeleteRoute,
  IN EFI_IPv4_ADDRESS    *SubnetAddress,
  IN EFI_IPv4_ADDRESS    *SubnetMask,
  IN EFI_IPv4_ADDRESS    *GatewayAddress
  )
{
  EFI_STATUS                           Status;
  COMMON_INSTANCE                      *Instance;
  FAKE_IP_IP4_INSATNCE                 *Ip4Instance;

  Ip4Instance = (VOID *) This;
  Instance = Ip4Instance->Instance;
  if (Instance->Signature != DUMMY_PXE_INSTANCE_SIGNATURE) {
    return EFI_INVALID_PARAMETER;
  }

  Status = ConnectDevice (Instance);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  if (Ip4Instance->RealIp4 == NULL) {
    return EFI_NOT_READY;
  }

  return Ip4Instance->RealIp4->Routes (Ip4Instance->RealIp4, DeleteRoute, SubnetAddress, SubnetMask, GatewayAddress);
}

EFI_STATUS
FakeIp4Transmit (
  IN EFI_IP4_PROTOCOL          *This,
  IN EFI_IP4_COMPLETION_TOKEN  *Token
  )
{
  EFI_STATUS                           Status;
  COMMON_INSTANCE                      *Instance;
  FAKE_IP_IP4_INSATNCE                 *Ip4Instance;

  Ip4Instance = (VOID *) This;
  Instance = Ip4Instance->Instance;
  if (Instance->Signature != DUMMY_PXE_INSTANCE_SIGNATURE) {
    return EFI_INVALID_PARAMETER;
  }

  Status = ConnectDevice (Instance);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  if (Ip4Instance->RealIp4 == NULL) {
    return EFI_NOT_READY;
  }

  return Ip4Instance->RealIp4->Transmit (Ip4Instance->RealIp4, Token);
}

EFI_STATUS
FakeIp4Receive (
  IN EFI_IP4_PROTOCOL          *This,
  IN EFI_IP4_COMPLETION_TOKEN  *Token
  )
{
  EFI_STATUS                           Status;
  COMMON_INSTANCE                      *Instance;
  FAKE_IP_IP4_INSATNCE                 *Ip4Instance;

  Ip4Instance = (VOID *) This;
  Instance = Ip4Instance->Instance;
  if (Instance->Signature != DUMMY_PXE_INSTANCE_SIGNATURE) {
    return EFI_INVALID_PARAMETER;
  }

  Status = ConnectDevice (Instance);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  if (Ip4Instance->RealIp4 == NULL) {
    return EFI_NOT_READY;
  }

  return Ip4Instance->RealIp4->Receive (Ip4Instance->RealIp4, Token);
}

EFI_STATUS
FakeIp4Cancel (
  IN EFI_IP4_PROTOCOL          *This,
  IN EFI_IP4_COMPLETION_TOKEN  *Token OPTIONAL
  )
{
  EFI_STATUS                           Status;
  COMMON_INSTANCE                      *Instance;
  FAKE_IP_IP4_INSATNCE                 *Ip4Instance;

  Ip4Instance = (VOID *) This;
  Instance = Ip4Instance->Instance;
  if (Instance->Signature != DUMMY_PXE_INSTANCE_SIGNATURE) {
    return EFI_INVALID_PARAMETER;
  }

  Status = ConnectDevice (Instance);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  if (Ip4Instance->RealIp4 == NULL) {
    return EFI_NOT_READY;
  }

  return Ip4Instance->RealIp4->Cancel (Ip4Instance->RealIp4, Token);
}

EFI_STATUS
FakeIp4Poll (
  IN EFI_IP4_PROTOCOL          *This
  )
{
  EFI_STATUS                           Status;
  COMMON_INSTANCE                      *Instance;
  FAKE_IP_IP4_INSATNCE                 *Ip4Instance;

  Ip4Instance = (VOID *) This;
  Instance = Ip4Instance->Instance;
  if (Instance->Signature != DUMMY_PXE_INSTANCE_SIGNATURE) {
    return EFI_INVALID_PARAMETER;
  }

  Status = ConnectDevice (Instance);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  if (Ip4Instance->RealIp4 == NULL) {
    return EFI_NOT_READY;
  }

  return Ip4Instance->RealIp4->Poll (Ip4Instance->RealIp4);
}

//
// For Ip6 protocol
//
EFI_STATUS
FakeIp6GetModeData (
  IN EFI_IP6_PROTOCOL                 *This,
  OUT EFI_IP6_MODE_DATA               *Ip6ModeData     OPTIONAL,
  OUT EFI_MANAGED_NETWORK_CONFIG_DATA *MnpConfigData   OPTIONAL,
  OUT EFI_SIMPLE_NETWORK_MODE         *SnpModeData     OPTIONAL
  )
{
  EFI_STATUS                           Status;
  COMMON_INSTANCE                      *Instance;
  FAKE_IP_IP6_INSATNCE                 *Ip6Instance;

  Ip6Instance = (VOID *) This;
  Instance = Ip6Instance->Instance;
  if (Instance->Signature != DUMMY_PXE_INSTANCE_SIGNATURE) {
    return EFI_INVALID_PARAMETER;
  }

  Status = ConnectDevice (Instance);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  if (Ip6Instance->RealIp6 == NULL) {
    return EFI_NOT_READY;
  }

  return Ip6Instance->RealIp6->GetModeData (Ip6Instance->RealIp6, Ip6ModeData, MnpConfigData, SnpModeData);
}

EFI_STATUS
FakeIp6Configure (
  IN EFI_IP6_PROTOCOL            *This,
  IN EFI_IP6_CONFIG_DATA         *Ip6ConfigData OPTIONAL
  )
{
  EFI_STATUS                           Status;
  COMMON_INSTANCE                      *Instance;
  FAKE_IP_IP6_INSATNCE                 *Ip6Instance;

  Ip6Instance = (VOID *) This;
  Instance = Ip6Instance->Instance;
  if (Instance->Signature != DUMMY_PXE_INSTANCE_SIGNATURE) {
    return EFI_INVALID_PARAMETER;
  }

  Status = ConnectDevice (Instance);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  if (Ip6Instance->RealIp6== NULL) {
    return EFI_NOT_READY;
  }

  return Ip6Instance->RealIp6->Configure (Ip6Instance->RealIp6, Ip6ConfigData);
}

EFI_STATUS
FakeIp6Groups (
  IN EFI_IP6_PROTOCOL            *This,
  IN BOOLEAN                     JoinFlag,
  IN EFI_IPv6_ADDRESS            *GroupAddress  OPTIONAL
  )
{
  EFI_STATUS                           Status;
  COMMON_INSTANCE                      *Instance;
  FAKE_IP_IP6_INSATNCE                 *Ip6Instance;

  Ip6Instance = (VOID *) This;
  Instance = Ip6Instance->Instance;
  if (Instance->Signature != DUMMY_PXE_INSTANCE_SIGNATURE) {
    return EFI_INVALID_PARAMETER;
  }

  Status = ConnectDevice (Instance);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  if (Ip6Instance->RealIp6 == NULL) {
    return EFI_NOT_READY;
  }

  return Ip6Instance->RealIp6->Groups (Ip6Instance->RealIp6, JoinFlag, GroupAddress);
}

EFI_STATUS
FakeIp6Routes (
  IN EFI_IP6_PROTOCOL            *This,
  IN BOOLEAN                     DeleteRoute,
  IN EFI_IPv6_ADDRESS            *Destination OPTIONAL,
  IN UINT8                       PrefixLength,
  IN EFI_IPv6_ADDRESS            *GatewayAddress OPTIONAL
  )
{
  EFI_STATUS                           Status;
  COMMON_INSTANCE                      *Instance;
  FAKE_IP_IP6_INSATNCE                 *Ip6Instance;

  Ip6Instance = (VOID *) This;
  Instance = Ip6Instance->Instance;
  if (Instance->Signature != DUMMY_PXE_INSTANCE_SIGNATURE) {
    return EFI_INVALID_PARAMETER;
  }

  Status = ConnectDevice (Instance);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  if (Ip6Instance->RealIp6 == NULL) {
    return EFI_NOT_READY;
  }

  return Ip6Instance->RealIp6->Routes (Ip6Instance->RealIp6, DeleteRoute, Destination, PrefixLength, GatewayAddress);
}

EFI_STATUS
FakeIp6Neighbors (
  IN EFI_IP6_PROTOCOL            *This,
  IN BOOLEAN                     DeleteFlag,
  IN EFI_IPv6_ADDRESS            *TargetIp6Address,
  IN EFI_MAC_ADDRESS             *TargetLinkAddress,
  IN UINT32                      Timeout,
  IN BOOLEAN                     Override
  )
{
  EFI_STATUS                           Status;
  COMMON_INSTANCE                      *Instance;
  FAKE_IP_IP6_INSATNCE                 *Ip6Instance;

  Ip6Instance = (VOID *) This;
  Instance = Ip6Instance->Instance;
  if (Instance->Signature != DUMMY_PXE_INSTANCE_SIGNATURE) {
    return EFI_INVALID_PARAMETER;
  }

  Status = ConnectDevice (Instance);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  if (Ip6Instance->RealIp6 == NULL) {
    return EFI_NOT_READY;
  }

  return Ip6Instance->RealIp6->Neighbors (Ip6Instance->RealIp6, DeleteFlag, TargetIp6Address, TargetLinkAddress, Timeout, Override);
}

EFI_STATUS
FakeIp6Transmit (
  IN EFI_IP6_PROTOCOL            *This,
  IN EFI_IP6_COMPLETION_TOKEN    *Token
  )
{
  EFI_STATUS                           Status;
  COMMON_INSTANCE                      *Instance;
  FAKE_IP_IP6_INSATNCE                 *Ip6Instance;

  Ip6Instance = (VOID *) This;
  Instance = Ip6Instance->Instance;
  if (Instance->Signature != DUMMY_PXE_INSTANCE_SIGNATURE) {
    return EFI_INVALID_PARAMETER;
  }

  Status = ConnectDevice (Instance);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  if (Ip6Instance->RealIp6 == NULL) {
    return EFI_NOT_READY;
  }

  return Ip6Instance->RealIp6->Transmit (Ip6Instance->RealIp6, Token);
}

EFI_STATUS
FakeIp6Receive (
  IN EFI_IP6_PROTOCOL            *This,
  IN EFI_IP6_COMPLETION_TOKEN    *Token
  )
{
  EFI_STATUS                           Status;
  COMMON_INSTANCE                      *Instance;
  FAKE_IP_IP6_INSATNCE                 *Ip6Instance;

  Ip6Instance = (VOID *) This;
  Instance = Ip6Instance->Instance;
  if (Instance->Signature != DUMMY_PXE_INSTANCE_SIGNATURE) {
    return EFI_INVALID_PARAMETER;
  }

  Status = ConnectDevice (Instance);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  if (Ip6Instance->RealIp6 == NULL) {
    return EFI_NOT_READY;
  }

  return Ip6Instance->RealIp6->Receive (Ip6Instance->RealIp6, Token);
}

EFI_STATUS
FakeIp6Cancel (
  IN EFI_IP6_PROTOCOL            *This,
  IN EFI_IP6_COMPLETION_TOKEN    *Token    OPTIONAL
  )
{
  EFI_STATUS                           Status;
  COMMON_INSTANCE                      *Instance;
  FAKE_IP_IP6_INSATNCE                 *Ip6Instance;

  Ip6Instance = (VOID *) This;
  Instance = Ip6Instance->Instance;
  if (Instance->Signature != DUMMY_PXE_INSTANCE_SIGNATURE) {
    return EFI_INVALID_PARAMETER;
  }

  Status = ConnectDevice (Instance);
  if (EFI_ERROR (Status)) {
    return Status;
  }
  if (Ip6Instance->RealIp6 == NULL) {
    return EFI_NOT_READY;
  }

  return Ip6Instance->RealIp6->Cancel (Ip6Instance->RealIp6, Token);
}

EFI_STATUS
FakeIp6Poll (
  IN EFI_IP6_PROTOCOL            *This
  )
{
  EFI_STATUS                           Status;
  COMMON_INSTANCE                      *Instance;
  FAKE_IP_IP6_INSATNCE                 *Ip6Instance;

  Ip6Instance = (VOID *) This;
  Instance = Ip6Instance->Instance;
  if (Instance->Signature != DUMMY_PXE_INSTANCE_SIGNATURE) {
    return EFI_INVALID_PARAMETER;
  }

  Status = ConnectDevice (Instance);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  if (Ip6Instance->RealIp6 == NULL) {
    return EFI_NOT_READY;
  }

  return Ip6Instance->RealIp6->Poll (Ip6Instance->RealIp6);
}

//
// For Ip4 ServiceBinding protocol
//
EFI_STATUS
FakeIp4CreateChild (
  IN     EFI_SERVICE_BINDING_PROTOCOL  *This,
  IN OUT EFI_HANDLE                    *ChildHandle
  )
{
  EFI_STATUS                           Status;
  COMMON_INSTANCE                      *Instance;
  FAKE_IP_IP4_SB_INSATNCE              *Ip4SBInstance;

  Ip4SBInstance = (VOID *) This;
  Instance = Ip4SBInstance->Instance;
  if (Instance->Signature != DUMMY_PXE_INSTANCE_SIGNATURE) {
    return EFI_INVALID_PARAMETER;
  }

  if (gDeviceConnecting) {
    return EFI_NOT_READY;
  }

  Status = ConnectDevice (Instance);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  if (Ip4SBInstance->RealIp4SB == NULL) {
    return EFI_NOT_READY;
  }

  return Ip4SBInstance->RealIp4SB->CreateChild (Ip4SBInstance->RealIp4SB, ChildHandle);
}

EFI_STATUS
FakeIp4DestroyChild (
  IN EFI_SERVICE_BINDING_PROTOCOL          *This,
  IN EFI_HANDLE                            ChildHandle
  )
{
  EFI_STATUS                           Status;
  COMMON_INSTANCE                      *Instance;
  FAKE_IP_IP4_SB_INSATNCE              *Ip4SBInstance;

  Ip4SBInstance = (VOID *) This;
  Instance = Ip4SBInstance->Instance;
  if (Instance->Signature != DUMMY_PXE_INSTANCE_SIGNATURE) {
    return EFI_INVALID_PARAMETER;
  }

  if (gDeviceConnecting) {
    return EFI_NOT_READY;
  }

  Status = ConnectDevice (Instance);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  if (Ip4SBInstance->RealIp4SB == NULL) {
    return EFI_NOT_READY;
  }

  return Ip4SBInstance->RealIp4SB->DestroyChild (Ip4SBInstance->RealIp4SB, ChildHandle);
}

//
// For Ip6 ServiceBinding protocol
//
EFI_STATUS
FakeIp6CreateChild (
  IN     EFI_SERVICE_BINDING_PROTOCOL  *This,
  IN OUT EFI_HANDLE                    *ChildHandle
  )
{
  EFI_STATUS                           Status;
  COMMON_INSTANCE                      *Instance;
  FAKE_IP_IP6_SB_INSATNCE              *Ip6SBInstance;

  Ip6SBInstance = (VOID *) This;
  Instance = Ip6SBInstance->Instance;
  if (Instance->Signature != DUMMY_PXE_INSTANCE_SIGNATURE) {
    return EFI_INVALID_PARAMETER;
  }

  if (gDeviceConnecting) {
    return EFI_NOT_READY;
  }

  Status = ConnectDevice (Instance);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  if (Ip6SBInstance->RealIp6SB == NULL) {
    return EFI_NOT_READY;
  }

  return Ip6SBInstance->RealIp6SB->CreateChild (Ip6SBInstance->RealIp6SB, ChildHandle);
}

EFI_STATUS
FakeIp6DestroyChild (
  IN EFI_SERVICE_BINDING_PROTOCOL          *This,
  IN EFI_HANDLE                            ChildHandle
  )
{
  EFI_STATUS                           Status;
  COMMON_INSTANCE                      *Instance;
  FAKE_IP_IP6_SB_INSATNCE              *Ip6SBInstance;

  Ip6SBInstance = (VOID *) This;
  Instance = Ip6SBInstance->Instance;
  if (Instance->Signature != DUMMY_PXE_INSTANCE_SIGNATURE) {
    return EFI_INVALID_PARAMETER;
  }

  if (gDeviceConnecting) {
    return EFI_NOT_READY;
  }

  Status = ConnectDevice (Instance);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  if (Ip6SBInstance->RealIp6SB == NULL) {
    return EFI_NOT_READY;
  }

  return Ip6SBInstance->RealIp6SB->DestroyChild (Ip6SBInstance->RealIp6SB, ChildHandle);
}

//
// For Dhcp4 ServiceBinding protocol
//
EFI_STATUS
FakeDhcp4CreateChild (
  IN     EFI_SERVICE_BINDING_PROTOCOL  *This,
  IN OUT EFI_HANDLE                    *ChildHandle
  )
{
  EFI_STATUS                           Status;
  COMMON_INSTANCE                      *Instance;
  FAKE_IP_DHCP4_SB_INSATNCE            *Dhcp4SBInstance;

  Dhcp4SBInstance = (VOID *) This;
  Instance = Dhcp4SBInstance->Instance;
  if (Instance->Signature != DUMMY_PXE_INSTANCE_SIGNATURE) {
    return EFI_INVALID_PARAMETER;
  }

  Status = ConnectDevice (Instance);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  if (Dhcp4SBInstance->RealDhcp4SB == NULL) {
    return EFI_NOT_READY;
  }

  return Dhcp4SBInstance->RealDhcp4SB->CreateChild (Dhcp4SBInstance->RealDhcp4SB, ChildHandle);
}

EFI_STATUS
FakeDhcp4DestroyChild (
  IN EFI_SERVICE_BINDING_PROTOCOL          *This,
  IN EFI_HANDLE                            ChildHandle
  )
{
  EFI_STATUS                           Status;
  COMMON_INSTANCE                      *Instance;
  FAKE_IP_DHCP4_SB_INSATNCE            *Dhcp4SBInstance;

  Dhcp4SBInstance = (VOID *) This;
  Instance = Dhcp4SBInstance->Instance;
  if (Instance->Signature != DUMMY_PXE_INSTANCE_SIGNATURE) {
    return EFI_INVALID_PARAMETER;
  }

  Status = ConnectDevice (Instance);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  if (Dhcp4SBInstance->RealDhcp4SB == NULL) {
    return EFI_NOT_READY;
  }

  return Dhcp4SBInstance->RealDhcp4SB->DestroyChild (Dhcp4SBInstance->RealDhcp4SB, ChildHandle);
}

//
// For Dhcp6 ServiceBinding protocol
//
EFI_STATUS
FakeDhcp6CreateChild (
  IN     EFI_SERVICE_BINDING_PROTOCOL  *This,
  IN OUT EFI_HANDLE                    *ChildHandle
  )
{
  EFI_STATUS                           Status;
  COMMON_INSTANCE                      *Instance;
  FAKE_IP_DHCP6_SB_INSATNCE            *Dhcp6SBInstance;

  Dhcp6SBInstance = (VOID *) This;
  Instance = Dhcp6SBInstance->Instance;
  if (Instance->Signature != DUMMY_PXE_INSTANCE_SIGNATURE) {
    return EFI_INVALID_PARAMETER;
  }

  if (gDeviceConnecting) {
    return EFI_NOT_READY;
  }

  Status = ConnectDevice (Instance);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  if (Dhcp6SBInstance->RealDhcp6SB == NULL) {
    return EFI_NOT_READY;
  }

  return Dhcp6SBInstance->RealDhcp6SB->CreateChild (Dhcp6SBInstance->RealDhcp6SB, ChildHandle);
}

EFI_STATUS
FakeDhcp6DestroyChild (
  IN EFI_SERVICE_BINDING_PROTOCOL          *This,
  IN EFI_HANDLE                            ChildHandle
  )
{
  EFI_STATUS                           Status;
  COMMON_INSTANCE                      *Instance;
  FAKE_IP_DHCP6_SB_INSATNCE            *Dhcp6SBInstance;

  Dhcp6SBInstance = (VOID *) This;
  Instance = Dhcp6SBInstance->Instance;
  if (Instance->Signature != DUMMY_PXE_INSTANCE_SIGNATURE) {
    return EFI_INVALID_PARAMETER;
  }

  if (gDeviceConnecting) {
    return EFI_NOT_READY;
  }

  Status = ConnectDevice (Instance);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  if (Dhcp6SBInstance->RealDhcp6SB == NULL) {
    return EFI_NOT_READY;
  }

  return Dhcp6SBInstance->RealDhcp6SB->DestroyChild (Dhcp6SBInstance->RealDhcp6SB, ChildHandle);
}

//
// For MNP ServiceBinding protocol
//
EFI_STATUS
FakeMnpCreateChild (
  IN     EFI_SERVICE_BINDING_PROTOCOL  *This,
  IN OUT EFI_HANDLE                    *ChildHandle
  )
{
  EFI_STATUS                           Status;
  COMMON_INSTANCE                      *Instance;
  FAKE_MNP_SB_INSATNCE                 *MnpSBInstance;

  MnpSBInstance = (VOID *) This;
  Instance = MnpSBInstance->Instance;
  if (Instance->Signature != DUMMY_PXE_INSTANCE_SIGNATURE) {
    return EFI_INVALID_PARAMETER;
  }

  if (gDeviceConnecting) {
    return EFI_NOT_READY;
  }

  Status = ConnectDevice (Instance);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  if (MnpSBInstance->RealMnpSB == NULL) {
    return EFI_NOT_READY;
  }

  return MnpSBInstance->RealMnpSB->CreateChild (MnpSBInstance->RealMnpSB, ChildHandle);
}

EFI_STATUS
FakeMnpDestroyChild (
  IN EFI_SERVICE_BINDING_PROTOCOL          *This,
  IN EFI_HANDLE                            ChildHandle
  )
{
//  EFI_STATUS                           Status;
//  COMMON_INSTANCE                      *Instance;
//  FAKE_MNP_SB_INSATNCE                 *MnpSBInstance;
//
//  MnpSBInstance = (VOID *) This;
//  Instance = MnpSBInstance->Instance;
//  if (Instance->Signature != DUMMY_PXE_INSTANCE_SIGNATURE) {
//    return EFI_INVALID_PARAMETER;
//  }
//
//  if (!gAllDeviceConnected) {
//    Status = ConnectDevice ();
//    if (EFI_ERROR (Status)) {
//      return Status;
//    }
//    gAllDeviceConnected = TRUE;
//  }
//
//  return MnpSBInstance->RealMnpSB->DestroyChild (MnpSBInstance->RealMnpSB, ChildHandle);
  return EFI_SUCCESS;
}


EFI_STATUS
EFIAPI
Ip4DeviceExtractConfig (
  IN  CONST EFI_HII_CONFIG_ACCESS_PROTOCOL   *This,
  IN  CONST EFI_STRING                       Request,
  OUT EFI_STRING                             *Progress,
  OUT EFI_STRING                             *Results
  )
{
  return EFI_NOT_READY;
}

EFI_STATUS
EFIAPI
Ip4DeviceRouteConfig (
  IN  CONST EFI_HII_CONFIG_ACCESS_PROTOCOL   *This,
  IN  CONST EFI_STRING                       Configuration,
  OUT EFI_STRING                             *Progress
  )
{
  return EFI_NOT_READY;
}

EFI_STATUS
EFIAPI
Ip4FormCallback (
  IN  CONST EFI_HII_CONFIG_ACCESS_PROTOCOL   *This,
  IN  EFI_BROWSER_ACTION                     Action,
  IN  EFI_QUESTION_ID                        QuestionId,
  IN  UINT8                                  Type,
  IN  EFI_IFR_TYPE_VALUE                     *Value,
  OUT EFI_BROWSER_ACTION_REQUEST             *ActionRequest
  )
{
  return EFI_NOT_READY;
}

EFI_STATUS
FakeHiiDatabaseNewList (
  IN CONST  EFI_HII_DATABASE_PROTOCOL   *This,
  IN CONST  EFI_HII_PACKAGE_LIST_HEADER *PackageList,
  IN        EFI_HANDLE                  DriverHandle, OPTIONAL
  OUT       EFI_HII_HANDLE               *Handle
  )
{
  UINTN                                Index;
  COMMON_INSTANCE                      *Instance;

  if (!CompareGuid (&(PackageList->PackageListGuid), &gDeviceManagerFormSetGuid)) {
    return gOldNewPackFunction (This, PackageList, DriverHandle, Handle);
  }

  for (Index = 0; Index < gDriverInstance->BindedCount; Index++) {
    Instance = (COMMON_INSTANCE *) gDriverInstance->BindedList[Index];
    ConnectDevice (Instance);
  }

  return gOldNewPackFunction (This, PackageList, DriverHandle, Handle);
}

EFI_STATUS 
EFIAPI
Dhcp4DummyGetModeData (
  IN EFI_DHCP4_PROTOCOL     *This,
  OUT EFI_DHCP4_MODE_DATA   *Dhcp4ModeData
  )
{
  return EFI_NOT_READY;
}

EFI_STATUS
EFIAPI
Dhcp4DummyConfigure (
  IN EFI_DHCP4_PROTOCOL     *This,
  IN EFI_DHCP4_CONFIG_DATA  *Dhcp4CfgData  OPTIONAL
  )
{
  return EFI_NOT_READY;
}

EFI_STATUS
EFIAPI
Dhcp4DummyStart (
  IN EFI_DHCP4_PROTOCOL     *This,
  IN EFI_EVENT              CompletionEvent    OPTIONAL
  )
{
  return EFI_NOT_READY;
}

EFI_STATUS
EFIAPI
Dhcp4DummyRenewRebind (
  IN EFI_DHCP4_PROTOCOL     *This,
  IN BOOLEAN                RebindRequest,
  IN EFI_EVENT              CompletionEvent    OPTIONAL
  )
{
  return EFI_NOT_READY;
}

EFI_STATUS
EFIAPI
Dhcp4DummyRelease (
  IN EFI_DHCP4_PROTOCOL     *This
  )
{
  return EFI_NOT_READY;
}

EFI_STATUS
EFIAPI
Dhcp4DummyStop (
  IN EFI_DHCP4_PROTOCOL     *This
  )
{
  return EFI_NOT_READY;
}

EFI_STATUS
EFIAPI
Dhcp4DummyBuild (
  IN EFI_DHCP4_PROTOCOL       *This,
  IN EFI_DHCP4_PACKET         *SeedPacket,
  IN UINT32                   DeleteCount,
  IN UINT8                    *DeleteList        OPTIONAL,
  IN UINT32                   AppendCount,
  IN EFI_DHCP4_PACKET_OPTION  *AppendList[]      OPTIONAL,
  OUT EFI_DHCP4_PACKET        **NewPacket
  )
{
  return EFI_NOT_READY;
}

EFI_STATUS
EFIAPI
Dhcp4DummyTransmitReceive (
  IN EFI_DHCP4_PROTOCOL                *This,
  IN EFI_DHCP4_TRANSMIT_RECEIVE_TOKEN  *Token
  )
{
  return EFI_NOT_READY;
}

EFI_STATUS
EFIAPI
Dhcp4DummyParse (
  IN EFI_DHCP4_PROTOCOL        *This,
  IN EFI_DHCP4_PACKET          *Packet,
  IN OUT UINT32                *OptionCount,
  OUT EFI_DHCP4_PACKET_OPTION  *PacketOptionList[]  OPTIONAL
  )
{
  return EFI_NOT_READY;
}

EFI_DHCP4_PROTOCOL gDhcp4Dummy = {
                     Dhcp4DummyGetModeData,
                     Dhcp4DummyConfigure,
                     Dhcp4DummyStart,
                     Dhcp4DummyRenewRebind,
                     Dhcp4DummyRelease,
                     Dhcp4DummyStop,
                     Dhcp4DummyBuild,
                     Dhcp4DummyTransmitReceive,
                     Dhcp4DummyParse
                     };


EFI_STATUS 
EFIAPI
Dhcp6DummyGetModeData (
  IN EFI_DHCP6_PROTOCOL        *This,
  OUT EFI_DHCP6_MODE_DATA      *Dhcp6ModeData OPTIONAL,
  OUT EFI_DHCP6_CONFIG_DATA    *Dhcp6ConfigData OPTIONAL
  )
{
  return EFI_NOT_READY;
}

EFI_STATUS
EFIAPI
Dhcp6DummyConfigure (
  IN EFI_DHCP6_PROTOCOL        *This,
  IN EFI_DHCP6_CONFIG_DATA     *Dhcp6CfgData OPTIONAL
  )
{
  return EFI_NOT_READY;
}

EFI_STATUS
EFIAPI
Dhcp6DummyStart (
  IN EFI_DHCP6_PROTOCOL        *This
  )
{
  return EFI_NOT_READY;
}

EFI_STATUS
EFIAPI
Dhcp6DummyInfoRequest (
  IN EFI_DHCP6_PROTOCOL        *This,
  IN BOOLEAN                   SendClientId,
  IN EFI_DHCP6_PACKET_OPTION   *OptionRequest,
  IN UINT32                    OptionCount,
  IN EFI_DHCP6_PACKET_OPTION   *OptionList[] OPTIONAL,
  IN EFI_DHCP6_RETRANSMISSION  *Retransmission, 
  IN EFI_EVENT                 TimeoutEvent OPTIONAL,
  IN EFI_DHCP6_INFO_CALLBACK   ReplyCallback,
  IN VOID                      *CallbackContext OPTIONAL
  )
{
  return EFI_NOT_READY;
}

EFI_STATUS
EFIAPI
Dhcp6DummyRenewRebind (
  IN EFI_DHCP6_PROTOCOL        *This,
  IN BOOLEAN                   RebindRequest
  )
{
  return EFI_NOT_READY;
}


EFI_STATUS
EFIAPI
Dhcp6DummyDecline (
  IN EFI_DHCP6_PROTOCOL        *This,
  IN UINT32                    AddressCount,
  IN EFI_IPv6_ADDRESS          *Addresses
  )
{
  return EFI_NOT_READY;
}

EFI_STATUS
EFIAPI
Dhcp6DummyRelease (
  IN EFI_DHCP6_PROTOCOL        *This,
  IN UINT32                    AddressCount,
  IN EFI_IPv6_ADDRESS          *Addresses
  )
{
  return EFI_NOT_READY;
}

EFI_STATUS
EFIAPI
Dhcp6DummyStop (
  IN EFI_DHCP6_PROTOCOL        *This
  )
{
  return EFI_NOT_READY;
}

EFI_STATUS
EFIAPI
Dhcp6DummyParse (
  IN EFI_DHCP6_PROTOCOL        *This,
  IN EFI_DHCP6_PACKET          *Packet,
  IN OUT UINT32                *OptionCount,
  OUT EFI_DHCP6_PACKET_OPTION  *PacketOptionList[] OPTIONAL
  )
{
  return EFI_NOT_READY;
}

EFI_DHCP6_PROTOCOL gDhcp6Dummy = {
                     Dhcp6DummyGetModeData,
                     Dhcp6DummyConfigure,
                     Dhcp6DummyStart,
                     Dhcp6DummyInfoRequest,
                     Dhcp6DummyRenewRebind,
                     Dhcp6DummyDecline,
                     Dhcp6DummyRelease,
                     Dhcp6DummyStop,
                     Dhcp6DummyParse
                     };

EFI_STATUS
PxeDummyDxeVlanConfigSet (
  IN  EFI_VLAN_CONFIG_PROTOCOL     *This,
  IN  UINT16                       VlanId,
  IN  UINT8                        Priority
  )
{
  EFI_STATUS                           Status;
  COMMON_INSTANCE                      *Instance;
  FAKE_VLAN_CONFIG_INSATNCE            *VlanConfigInstance;

  VlanConfigInstance = (VOID *) This;
  Instance = VlanConfigInstance->Instance;
  if (Instance->Signature != DUMMY_PXE_INSTANCE_SIGNATURE) {
    return EFI_INVALID_PARAMETER;
  }

  Status = ConnectDevice (Instance);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  if (VlanConfigInstance->RealVlanConfig == NULL) {
    return EFI_NOT_READY;
  }

  return VlanConfigInstance->RealVlanConfig->Set (VlanConfigInstance->RealVlanConfig, VlanId, Priority);
}

EFI_STATUS
PxeDummyDxeVlanConfigFind (
  IN  EFI_VLAN_CONFIG_PROTOCOL     *This,
  IN  UINT16                       *VlanId  OPTIONAL,
  OUT UINT16                       *NumberOfVlan,
  OUT EFI_VLAN_FIND_DATA           **Entries
  )
{
  EFI_STATUS                           Status;
  COMMON_INSTANCE                      *Instance;
  FAKE_VLAN_CONFIG_INSATNCE            *VlanConfigInstance;

  VlanConfigInstance = (VOID *) This;
  Instance = VlanConfigInstance->Instance;
  if (Instance->Signature != DUMMY_PXE_INSTANCE_SIGNATURE) {
    return EFI_INVALID_PARAMETER;
  }

  Status = ConnectDevice (Instance);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  if (VlanConfigInstance->RealVlanConfig == NULL) {
    return EFI_NOT_READY;
  }

  return VlanConfigInstance->RealVlanConfig->Find (VlanConfigInstance->RealVlanConfig, VlanId, NumberOfVlan, Entries);
}

EFI_STATUS
PxeDummyDxeVlanConfigRemove (
  IN  EFI_VLAN_CONFIG_PROTOCOL     *This,
  IN  UINT16                       VlanId
  )
{
  EFI_STATUS                           Status;
  COMMON_INSTANCE                      *Instance;
  FAKE_VLAN_CONFIG_INSATNCE            *VlanConfigInstance;

  VlanConfigInstance = (VOID *) This;
  Instance = VlanConfigInstance->Instance;
  if (Instance->Signature != DUMMY_PXE_INSTANCE_SIGNATURE) {
    return EFI_INVALID_PARAMETER;
  }

  Status = ConnectDevice (Instance);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  if (VlanConfigInstance->RealVlanConfig == NULL) {
    return EFI_NOT_READY;
  }

  return VlanConfigInstance->RealVlanConfig->Remove (VlanConfigInstance->RealVlanConfig, VlanId);
}