Changeset 58459 for trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network – Oracle VirtualBox

trunk/src/VBox/Devices/EFI/Firmware

Property svn:mergeinfo set to (toggle deleted branches)
/vendor/edk2/current 103735-103757

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/ArpDxe/ArpDriver.c

-              r48674
+              r58459
   ARP driver functions.
 Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
       );
+  }
+}
+/**
+  Callback function which provided by user to remove one node in NetDestroyLinkList process.
+  @param[in]    Entry           The entry to be removed.
+  @param[in]    Context         Pointer to the callback context corresponds to the Context in NetDestroyLinkList.
+  @retval EFI_SUCCESS           The entry has been removed successfully.
+  @retval Others                Fail to remove the entry.
+**/
+EFI_STATUS
+EFIAPI
+ArpDestroyChildEntryInHandleBuffer (
+  IN LIST_ENTRY         *Entry,
+  IN VOID               *Context
+  )
+{
+  ARP_INSTANCE_DATA             *Instance;
+  EFI_SERVICE_BINDING_PROTOCOL  *ServiceBinding;
+  if (Entry == NULL || Context == NULL) {
+    return EFI_INVALID_PARAMETER;
+  }
+  Instance = NET_LIST_USER_STRUCT_S (Entry, ARP_INSTANCE_DATA, List, ARP_INSTANCE_DATA_SIGNATURE);
+  ServiceBinding    = (EFI_SERVICE_BINDING_PROTOCOL *) Context;
+  return ServiceBinding->DestroyChild (ServiceBinding, Instance->Handle);
+}
 …
   EFI_SERVICE_BINDING_PROTOCOL  *ServiceBinding;
   ARP_SERVICE_DATA              *ArpService;
   ARP_INSTANCE_DATA             *Instance;
+  LIST_ENTRY                    *List;
   //
 …
   NicHandle = NetLibGetNicHandle (ControllerHandle, &gEfiManagedNetworkProtocolGuid);
   if (NicHandle == NULL) {
     return EFI_DEVICE_ERROR;
+    return EFI_SUCCESS;
+  }
 …
   ArpService = ARP_SERVICE_DATA_FROM_THIS (ServiceBinding);
+  if (NumberOfChildren == 0) {
+  if (NumberOfChildren != 0) {
+    //
+    // NumberOfChildren is not zero, destroy all the ARP children instances.
+    //
+    List = &ArpService->ChildrenList;
+    Status = NetDestroyLinkList (
+               List,
+               ArpDestroyChildEntryInHandleBuffer,
+               ServiceBinding,
+               NULL
+               );
+    ASSERT (IsListEmpty (&ArpService->PendingRequestTable));
+    ASSERT (IsListEmpty (&ArpService->DeniedCacheTable));
+    ASSERT (IsListEmpty (&ArpService->ResolvedCacheTable));
+  } else if (IsListEmpty (&ArpService->ChildrenList)) {
     //
     // Uninstall the ARP ServiceBinding protocol.
 …
     FreePool (ArpService);
-  } else {
-    while (!IsListEmpty (&ArpService->ChildrenList)) {
-      Instance = NET_LIST_HEAD (&ArpService->ChildrenList, ARP_INSTANCE_DATA, List);
-      ServiceBinding->DestroyChild (ServiceBinding, Instance->Handle);
+    }
-    ASSERT (IsListEmpty (&ArpService->PendingRequestTable));
-    ASSERT (IsListEmpty (&ArpService->DeniedCacheTable));
-    ASSERT (IsListEmpty (&ArpService->ResolvedCacheTable));
+  }
 …
   Instance = ARP_INSTANCE_DATA_FROM_THIS (Arp);
   if (Instance->Destroyed) {
+  if (Instance->InDestroy) {
     return EFI_SUCCESS;
+  }
   //
   // Use the Destroyed as a flag to avoid re-entrance.
   //
   Instance->Destroyed = TRUE;
+  // Use the InDestroy as a flag to avoid re-entrance.
+  //
+  Instance->InDestroy = TRUE;
   //
 …
       Status));
     Instance->Destroyed = FALSE;
+    Instance->InDestroy = FALSE;
     return Status;
+  }

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/ArpDxe/ArpDxe.inf

-              r48674
+              r58459
 ## @file
 # Component description file for ARP module
+#  This module produces EFI ARP Protocol and EFI ARP Service Binding Protocol.
+#
+# Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
+#  This module produces EFI ARP Protocol upon EFI MNP Protocol, to provide a generic
+#  implementation of the Address Resolution Protocol that is described in RFCs 826
+#  and 1122.
+#
+#   This program and the accompanying materials
+#   are licensed and made available under the terms and conditions of the BSD License
+#   which accompanies this distribution.  The full text of the license may be found at
+#   http://opensource.org/licenses/bsd-license.php
+#  Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>
+#  This program and the accompanying materials
+#  are licensed and made available under the terms and conditions of the BSD License
+#  which accompanies this distribution. The full text of the license may be found at
+#  http://opensource.org/licenses/bsd-license.php
+#
 #  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
 …
   INF_VERSION                    = 0x00010005
   BASE_NAME                      = ArpDxe
+  MODULE_UNI_FILE                = ArpDxe.uni
   FILE_GUID                      = 529D3F93-E8E9-4e73-B1E1-BDF6A9D50113
   MODULE_TYPE                    = UEFI_DRIVER
 …
 [Protocols]
+  gEfiManagedNetworkServiceBindingProtocolGuid  # PROTOCOL ALWAYS_CONSUMED
+  gEfiArpServiceBindingProtocolGuid             # PROTOCOL ALWAYS_CONSUMED
+  gEfiManagedNetworkProtocolGuid                # PROTOCOL ALWAYS_CONSUMED
+  gEfiArpProtocolGuid                           # PROTOCOL ALWAYS_CONSUMED
+  gEfiArpServiceBindingProtocolGuid             ## BY_START
+  gEfiManagedNetworkServiceBindingProtocolGuid  ## TO_START
+  gEfiArpProtocolGuid                           ## BY_START
+  gEfiManagedNetworkProtocolGuid                ## TO_START
+[UserExtensions.TianoCore."ExtraFiles"]
+  ArpDxeExtra.uni

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/ArpDxe/ArpImpl.c

-              r48674
+              r58459
   The implementation of the ARP protocol.
 Copyright (c) 2006 - 2009, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
   Instance->Configured = FALSE;
   Instance->Destroyed  = FALSE;
+  Instance->InDestroy  = FALSE;
   InitializeListHead (&Instance->List);

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/ArpDxe/ArpImpl.h

-              r48674
+              r58459
   EFI Address Resolution Protocol (ARP) Protocol interface header file.
 Copyright (c) 2006 - 2009, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
   EFI_ARP_CONFIG_DATA  ConfigData;
   BOOLEAN              Configured;
   BOOLEAN              Destroyed;
+  BOOLEAN              InDestroy;
 } ARP_INSTANCE_DATA;

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/ArpDxe/ComponentName.c

-              r48674
+              r58459
   UEFI Component Name(2) protocol implementation for ArpDxe driver.
 Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
 GLOBAL_REMOVE_IF_UNREFERENCED EFI_UNICODE_STRING_TABLE mArpDriverNameTable[] = {
   { "eng;en", L"ARP Network Service Driver" },
+  { NULL, NULL }
+};
+GLOBAL_REMOVE_IF_UNREFERENCED EFI_UNICODE_STRING_TABLE mArpControllerNameTable[] = {
+  { "eng;en", L"ARP Controller" },
   { NULL, NULL }
 };
 …
+  )
+{
+  return EFI_UNSUPPORTED;
+  EFI_STATUS                    Status;
+  EFI_ARP_PROTOCOL              *Arp;
+  //
+  // Only provide names for child handles.
+  //
+  if (ChildHandle == NULL) {
+    return EFI_UNSUPPORTED;
+  }
+  //
+  // Make sure this driver produced ChildHandle
+  //
+  Status = EfiTestChildHandle (
+             ControllerHandle,
+             ChildHandle,
+             &gEfiManagedNetworkProtocolGuid
+             );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+  //
+  // Retrieve an instance of a produced protocol from ChildHandle
+  //
+  Status = gBS->OpenProtocol (
+                  ChildHandle,
+                  &gEfiArpProtocolGuid,
+                 (VOID **)&Arp,
+                  NULL,
+                  NULL,
+                  EFI_OPEN_PROTOCOL_GET_PROTOCOL
+                  );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+  return LookupUnicodeString2 (
+           Language,
+           This->SupportedLanguages,
+           mArpControllerNameTable,
+           ControllerName,
+           (BOOLEAN)(This == &gArpComponentName)
+           );
+}

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Dhcp4Dxe/ComponentName.c

-              r48674
+              r58459
 /** @file
 Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
     NULL
+  }
+};
+GLOBAL_REMOVE_IF_UNREFERENCED EFI_UNICODE_STRING_TABLE    *gDhcpControllerNameTable = NULL;
+CHAR16 *mDhcp4ControllerName[] = {
+  L"DHCPv4 (State=0, Stopped)",
+  L"DHCPv4 (State=1, Init)",
+  L"DHCPv4 (State=2, Selecting)",
+  L"DHCPv4 (State=3, Requesting)",
+  L"DHCPv4 (State=4, Bound)",
+  L"DHCPv4 (State=5, Renewing)",
+  L"DHCPv4 (State=6, Rebinding)",
+  L"DHCPv4 (State=7, InitReboot)",
+  L"DHCPv4 (State=8, Rebooting)"
 };
 …
 /**
+  Update the component name for the Dhcp4 child handle.
+  @param  Dhcp4[in]               A pointer to the EFI_DHCP4_PROTOCOL.
+  @retval EFI_SUCCESS             Update the ControllerNameTable of this instance successfully.
+  @retval EFI_INVALID_PARAMETER   The input parameter is invalid.
+  @retval EFI_DEVICE_ERROR        DHCP is in unknown state.
+**/
+EFI_STATUS
+UpdateName (
+  IN     EFI_DHCP4_PROTOCOL             *Dhcp4
+  )
+{
+  EFI_STATUS                       Status;
+  EFI_DHCP4_MODE_DATA              Dhcp4ModeData;
+  if (Dhcp4 == NULL) {
+    return EFI_INVALID_PARAMETER;
+  }
+  //
+  // Format the child name into the string buffer.
+  //
+  Status = Dhcp4->GetModeData (Dhcp4, &Dhcp4ModeData);
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+  if (gDhcpControllerNameTable != NULL) {
+    FreeUnicodeStringTable (gDhcpControllerNameTable);
+    gDhcpControllerNameTable = NULL;
+  }
+  if (Dhcp4ModeData.State > Dhcp4Rebooting) {
+    return EFI_DEVICE_ERROR;
+  }
+  Status = AddUnicodeString2 (
+             "eng",
+             gDhcp4ComponentName.SupportedLanguages,
+             &gDhcpControllerNameTable,
+             mDhcp4ControllerName[Dhcp4ModeData.State],
+             TRUE
+             );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+  return AddUnicodeString2 (
+           "en",
+           gDhcp4ComponentName2.SupportedLanguages,
+           &gDhcpControllerNameTable,
+           mDhcp4ControllerName[Dhcp4ModeData.State],
+           FALSE
+           );
+}
+/**
   Retrieves a Unicode string that is the user readable name of the controller
   that is being managed by a driver.
 …
+  )
+{
+  return EFI_UNSUPPORTED;
+  EFI_STATUS                    Status;
+  EFI_DHCP4_PROTOCOL            *Dhcp4;
+  //
+  // Only provide names for child handles.
+  //
+  if (ChildHandle == NULL) {
+    return EFI_UNSUPPORTED;
+  }
+  //
+  // Make sure this driver produced ChildHandle
+  //
+  Status = EfiTestChildHandle (
+             ControllerHandle,
+             ChildHandle,
+             &gEfiUdp4ProtocolGuid
+             );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+  //
+  // Retrieve an instance of a produced protocol from ChildHandle
+  //
+  Status = gBS->OpenProtocol (
+                  ChildHandle,
+                  &gEfiDhcp4ProtocolGuid,
+                  (VOID **)&Dhcp4,
+                  NULL,
+                  NULL,
+                  EFI_OPEN_PROTOCOL_GET_PROTOCOL
+                  );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+  //
+  // Update the component name for this child handle.
+  //
+  Status = UpdateName (Dhcp4);
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+  return LookupUnicodeString2 (
+           Language,
+           This->SupportedLanguages,
+           gDhcpControllerNameTable,
+           ControllerName,
+           (BOOLEAN)(This == &gDhcp4ComponentName)
+           );
+}

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Dhcp4Dxe/Dhcp4Driver.c

-              r48674
+              r58459
 /** @file
 Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
 /**
   Destory the DHCP service. The Dhcp4 service may be partly initialized,
+  Destroy the DHCP service. The Dhcp4 service may be partly initialized,
   or partly destroyed. If a resource is destroyed, it is marked as so in
   case the destroy failed and being called again later.
   @param[in]  DhcpSb                 The DHCP service instance to destory.
+  @param[in]  DhcpSb                 The DHCP service instance to destroy.
   @retval EFI_SUCCESS            Always return success.
 …
   DhcpSb->Signature       = DHCP_SERVICE_SIGNATURE;
   DhcpSb->ServiceState    = DHCP_UNCONFIGED;
-  DhcpSb->InDestory       = FALSE;
   DhcpSb->Controller      = Controller;
   DhcpSb->Image           = ImageHandle;
 …
+}
+/**
+  Callback function which provided by user to remove one node in NetDestroyLinkList process.
+  @param[in]    Entry           The entry to be removed.
+  @param[in]    Context         Pointer to the callback context corresponds to the Context in NetDestroyLinkList.
+  @retval EFI_SUCCESS           The entry has been removed successfully.
+  @retval Others                Fail to remove the entry.
+**/
+EFI_STATUS
+EFIAPI
+Dhcp4DestroyChildEntry (
+  IN LIST_ENTRY         *Entry,
+  IN VOID               *Context
+  )
+{
+  DHCP_PROTOCOL                    *Instance;
+  EFI_SERVICE_BINDING_PROTOCOL     *ServiceBinding;
+  if (Entry == NULL || Context == NULL) {
+    return EFI_INVALID_PARAMETER;
+  }
+  Instance = NET_LIST_USER_STRUCT_S (Entry, DHCP_PROTOCOL, Link, DHCP_PROTOCOL_SIGNATURE);
+  ServiceBinding = (EFI_SERVICE_BINDING_PROTOCOL *) Context;
+  return ServiceBinding->DestroyChild (ServiceBinding, Instance->Handle);
+}
 /**
 …
   EFI_SERVICE_BINDING_PROTOCOL  *ServiceBinding;
   DHCP_SERVICE                  *DhcpSb;
-  DHCP_PROTOCOL                 *Instance;
   EFI_HANDLE                    NicHandle;
   EFI_STATUS                    Status;
+  EFI_TPL                       OldTpl;
+  LIST_ENTRY                    *List;
+  UINTN                         ListLength;
   //
 …
   if (NicHandle == NULL) {
     return EFI_DEVICE_ERROR;
+    return EFI_SUCCESS;
+  }
 …
   DhcpSb = DHCP_SERVICE_FROM_THIS (ServiceBinding);
+  if (DhcpSb->InDestory) {
+    return EFI_SUCCESS;
+  }
+  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
+  if (NumberOfChildren == 0) {
+    DhcpSb->InDestory    = TRUE;
+    DhcpSb->ServiceState = DHCP_DESTORY;
+  if (!IsListEmpty (&DhcpSb->Children)) {
+    //
+    // Destroy all the children instances before destory the service.
+    //
+    List = &DhcpSb->Children;
+    Status = NetDestroyLinkList (
+               List,
+               Dhcp4DestroyChildEntry,
+               ServiceBinding,
+               &ListLength
+               );
+    if (EFI_ERROR (Status) || ListLength != 0) {
+      Status = EFI_DEVICE_ERROR;
+    }
+  }
+  if (NumberOfChildren == 0 && !IsListEmpty (&DhcpSb->Children)) {
+    Status = EFI_DEVICE_ERROR;
+  }
+  if (NumberOfChildren == 0 && IsListEmpty (&DhcpSb->Children)) {
+    //
+    // Destroy the service itself if no child instance left.
+    //
+    DhcpSb->ServiceState = DHCP_DESTROY;
     gBS->UninstallProtocolInterface (
 …
     Dhcp4CloseService (DhcpSb);
+    if (gDhcpControllerNameTable != NULL) {
+      FreeUnicodeStringTable (gDhcpControllerNameTable);
+      gDhcpControllerNameTable = NULL;
+    }
     FreePool (DhcpSb);
+  } else {
+    //
+    // Don't use NET_LIST_FOR_EACH_SAFE here, Dhcp4ServiceBindingDestoryChild
+    // may cause other child to be deleted.
+    //
+    while (!IsListEmpty (&DhcpSb->Children)) {
+      Instance = NET_LIST_HEAD (&DhcpSb->Children, DHCP_PROTOCOL, Link);
+      ServiceBinding->DestroyChild (ServiceBinding, Instance->Handle);
+    }
+    if (DhcpSb->NumChildren != 0) {
+      Status = EFI_DEVICE_ERROR;
+    }
+  }
+  gBS->RestoreTPL (OldTpl);
+    Status = EFI_SUCCESS;
+  }
   return Status;
 …
   Instance->Handle            = NULL;
   Instance->Service           = DhcpSb;
   Instance->InDestory         = FALSE;
+  Instance->InDestroy         = FALSE;
   Instance->CompletionEvent   = NULL;
   Instance->RenewRebindEvent  = NULL;
 …
   // A child can be destroyed more than once. For example,
   // Dhcp4DriverBindingStop will destroy all of its children.
   // when caller driver is being stopped, it will destory the
+  // when caller driver is being stopped, it will destroy the
   // dhcp child it opens.
   //
   if (Instance->InDestory) {
+  if (Instance->InDestroy) {
     return EFI_SUCCESS;
+  }
   OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
   Instance->InDestory = TRUE;
+  Instance->InDestroy = TRUE;
   //
 …
   // Uninstall the DHCP4 protocol first to enable a top down destruction.
   //
+  gBS->RestoreTPL (OldTpl);
   Status = gBS->UninstallProtocolInterface (
                   ChildHandle,
 …
                   Dhcp
                   );
   if (EFI_ERROR (Status)) {
     Instance->InDestory = FALSE;
+  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
+  if (EFI_ERROR (Status)) {
+    Instance->InDestroy = FALSE;
     gBS->RestoreTPL (OldTpl);

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Dhcp4Dxe/Dhcp4Driver.h

-              r48674
+              r58459
   Header for the DHCP4 driver.
 Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
 extern EFI_COMPONENT_NAME_PROTOCOL  gDhcp4ComponentName;
 extern EFI_COMPONENT_NAME2_PROTOCOL gDhcp4ComponentName2;
+extern EFI_UNICODE_STRING_TABLE     *gDhcpControllerNameTable;
 /**

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Dhcp4Dxe/Dhcp4Dxe.inf

-              r48674
+              r58459
 ## @file
 # Component name for module Dhcp4
+#  This module produces EFI DHCPv4 Protocol and EFI DHCPv4 Service Binding Protocol.
+#
+# Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>
+#  This module produces EFI DHCPv4 Protocol upon EFI UDPv4 Protocol, to provide the
+#  capability to collect configuration information for the EFI IPv4 Protocol drivers
+#  and to provide DHCPv4 server and PXE boot server discovery services.
+#
+#  Copyright (c) 2007 - 2014, Intel Corporation. All rights reserved.<BR>
 #  This program and the accompanying materials
 #  are licensed and made available under the terms and conditions of the BSD License
 …
   INF_VERSION                    = 0x00010005
   BASE_NAME                      = Dhcp4Dxe
+  MODULE_UNI_FILE                = Dhcp4Dxe.uni
   FILE_GUID                      = 94734718-0BBC-47fb-96A5-EE7A5AE6A2AD
   MODULE_TYPE                    = UEFI_DRIVER
 …
 [Protocols]
   gEfiUdp4ServiceBindingProtocolGuid            # PROTOCOL ALWAYS_CONSUMED
   gEfiDhcp4ServiceBindingProtocolGuid           # PROTOCOL ALWAYS_CONSUMED
   gEfiUdp4ProtocolGuid                          # PROTOCOL ALWAYS_CONSUMED
   gEfiDhcp4ProtocolGuid                         # PROTOCOL ALWAYS_CONSUMED
+  gEfiDhcp4ServiceBindingProtocolGuid           ## BY_START
+  gEfiUdp4ServiceBindingProtocolGuid            ## TO_START
+  gEfiDhcp4ProtocolGuid                         ## BY_START
+  gEfiUdp4ProtocolGuid                          ## TO_START
+[UserExtensions.TianoCore."ExtraFiles"]
+  Dhcp4DxeExtra.uni

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Dhcp4Dxe/Dhcp4Impl.c

-              r48674
+              r58459
   This file implement the EFI_DHCP4_PROTOCOL interface.
 Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
+{
   DHCP_SERVICE  *DhcpSb;
+  EFI_STATUS    Status;
+  VOID          *Udp4;
   ASSERT (Instance->Token != NULL);
 …
     return EFI_OUT_OF_RESOURCES;
   } else {
+    return EFI_SUCCESS;
+    Status = gBS->OpenProtocol (
+                    Instance->UdpIo->UdpHandle,
+                    &gEfiUdp4ProtocolGuid,
+                    (VOID **) &Udp4,
+                    Instance->Service->Image,
+                    Instance->Handle,
+                    EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
+                    );
+    if (EFI_ERROR (Status)) {
+      UdpIoFreeIo (Instance->UdpIo);
+      Instance->UdpIo = NULL;
+    }
+    return Status;
+  }
+}
 …
   NetbufQueFlush (&Instance->ResponseQueue);
   UdpIoCleanIo (Instance->UdpIo);
+  gBS->CloseProtocol (
+         Instance->UdpIo->UdpHandle,
+         &gEfiUdp4ProtocolGuid,
+         Instance->Service->Image,
+         Instance->Handle
+         );
   UdpIoFreeIo (Instance->UdpIo);
   Instance->UdpIo = NULL;
 …
   if (EFI_ERROR (Status) && (Instance->UdpIo != NULL)) {
     UdpIoCleanIo (Instance->UdpIo);
+    gBS->CloseProtocol (
+           Instance->UdpIo->UdpHandle,
+           &gEfiUdp4ProtocolGuid,
+           Instance->Service->Image,
+           Instance->Handle
+           );
     UdpIoFreeIo (Instance->UdpIo);
     Instance->UdpIo = NULL;

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Dhcp4Dxe/Dhcp4Impl.h

-              r48674
+              r58459
   RFC 3396: Encoding Long Options in DHCP.
 Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
 // and active child configures the service successfully, it
 // goes to CONFIGED. If the active child configures NULL, it
 // goes back to UNCONFIGED. It becomes DESTORY if it is (partly)
 // destoried.
+// goes back to UNCONFIGED. It becomes DESTROY if it is (partly)
+// destroyed.
 //
 #define DHCP_UNCONFIGED          0
 #define DHCP_CONFIGED            1
 #define DHCP_DESTORY             2
+#define DHCP_DESTROY             2
 …
   DHCP_SERVICE                      *Service;
   BOOLEAN                           InDestory;
+  BOOLEAN                           InDestroy;
   EFI_EVENT                         CompletionEvent;
 …
   EFI_SERVICE_BINDING_PROTOCOL  ServiceBinding;
+  INTN                          ServiceState; // CONFIGED, UNCONFIGED, and DESTORY
+  BOOLEAN                       InDestory;
+  INTN                          ServiceState; // CONFIGED, UNCONFIGED, and DESTROY
   EFI_HANDLE                    Controller;

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Dhcp4Dxe/Dhcp4Io.c

-              r48674
+              r58459
   EFI DHCP protocol implementation.
 Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
   if (DhcpSb->Netmask == 0) {
     Class           = NetGetIpClass (DhcpSb->ClientAddr);
+    ASSERT (Class < IP4_ADDR_CLASSE);
     DhcpSb->Netmask = gIp4AllMasks[Class << 3];
+  }
 …
   //
   // Don't restart receive if error occurs or DHCP is destoried.
+  // Don't restart receive if error occurs or DHCP is destroyed.
   //
   if (EFI_ERROR (IoStatus)) {
     return ;
   } else if (DhcpSb->ServiceState == DHCP_DESTORY) {
+  } else if (DhcpSb->ServiceState == DHCP_DESTROY) {
     NetbufFree (UdpPacket);
     return ;

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/DpcDxe/DpcDxe.inf

-              r48674
+              r58459
 ## @file
 # Component description file for DPC module
+#  This module produces Deferred Procedure Call Protocol.
+#
+# Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>
+#
+#   This program and the accompanying materials
+#   are licensed and made available under the terms and conditions of the BSD License
+#   which accompanies this distribution.  The full text of the license may be found at
+#   http://opensource.org/licenses/bsd-license.php
+#  Copyright (c) 2007 - 2014, Intel Corporation. All rights reserved.<BR>
+#  This program and the accompanying materials
+#  are licensed and made available under the terms and conditions of the BSD License
+#  which accompanies this distribution.  The full text of the license may be found at
+#  http://opensource.org/licenses/bsd-license.php
+#
 #  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
 …
   INF_VERSION               = 0x00010005
   BASE_NAME                 = DpcDxe
+  MODULE_UNI_FILE           = DpcDxe.uni
   FILE_GUID                 = A210F973-229D-4f4d-AA37-9895E6C9EABA
   MODULE_TYPE               = DXE_DRIVER
 …
 [Protocols]
   gEfiDpcProtocolGuid                           # PROTOCOL ALWAYS_PRODUCED
+  gEfiDpcProtocolGuid                           ## PRODUCES
 [Depex]
   TRUE
+[UserExtensions.TianoCore."ExtraFiles"]
+  DpcDxeExtra.uni

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/IScsiDxe/ComponentName.c

-              r48674
+              r58459
   UEFI Component Name(2) protocol implementation for iSCSI.
 Copyright (c) 2004 - 2011, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2004 - 2015, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
   {NULL, NULL}
 };
+GLOBAL_REMOVE_IF_UNREFERENCED EFI_UNICODE_STRING_TABLE  *mIScsiControllerNameTable = NULL;
 /**
 …
           (BOOLEAN)(This == &gIScsiComponentName)
           );
+}
+/**
+  Update the component name for the iSCSI instance.
+  @param[in]  IScsiExtScsiPassThru  A pointer to the EFI_EXT_SCSI_PASS_THRU_PROTOCOL instance.
+  @retval EFI_SUCCESS               Update the ControllerNameTable of this instance successfully.
+  @retval EFI_INVALID_PARAMETER     The input parameter is invalid.
+  @retval EFI_UNSUPPORTED           Can't get the corresponding NIC info from the Controller handle.
+**/
+EFI_STATUS
+UpdateName (
+  IN   EFI_EXT_SCSI_PASS_THRU_PROTOCOL *IScsiExtScsiPassThru
+  )
+{
+  EFI_STATUS                       Status;
+  CHAR16                           HandleName[150];
+  ISCSI_DRIVER_DATA                *Private;
+  EFI_MAC_ADDRESS                  MacAddress;
+  UINTN                            HwAddressSize;
+  UINT16                           VlanId;
+  CHAR16                           MacString[70];
+  if (IScsiExtScsiPassThru == NULL) {
+    return EFI_INVALID_PARAMETER;
+  }
+  Private  = ISCSI_DRIVER_DATA_FROM_EXT_SCSI_PASS_THRU (IScsiExtScsiPassThru);
+  //
+  // Get the mac string, it's the name of various variable
+  //
+  Status = NetLibGetMacAddress (Private->Controller, &MacAddress, &HwAddressSize);
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+  VlanId = NetLibGetVlanId (Private->Controller);
+  IScsiMacAddrToStr (&MacAddress, (UINT32) HwAddressSize, VlanId, MacString);
+  UnicodeSPrint (
+    HandleName,
+    sizeof (HandleName),
+    L"iSCSI IPv4 (MacString=%s)",
+    MacString
+  );
+  if (mIScsiControllerNameTable != NULL) {
+    FreeUnicodeStringTable (mIScsiControllerNameTable);
+    mIScsiControllerNameTable = NULL;
+  }
+  Status = AddUnicodeString2 (
+             "eng",
+             gIScsiComponentName.SupportedLanguages,
+             &mIScsiControllerNameTable,
+             HandleName,
+             TRUE
+             );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+  return AddUnicodeString2 (
+           "en",
+           gIScsiComponentName2.SupportedLanguages,
+           &mIScsiControllerNameTable,
+           HandleName,
+           FALSE
+           );
+}
 …
+  )
+{
+  return EFI_UNSUPPORTED;
+  EFI_STATUS                      Status;
+  EFI_HANDLE                      IScsiController;
+  ISCSI_PRIVATE_PROTOCOL          *IScsiIdentifier;
+  EFI_EXT_SCSI_PASS_THRU_PROTOCOL *IScsiExtScsiPassThru;
+  if (ControllerHandle == NULL) {
+    return EFI_UNSUPPORTED;
+  }
+  //
+  // Get the handle of the controller we are controling.
+  //
+  IScsiController = NetLibGetNicHandle (ControllerHandle, &gEfiTcp4ProtocolGuid);
+  if (IScsiController == NULL) {
+    return EFI_UNSUPPORTED;
+  }
+  Status = gBS->OpenProtocol (
+                  IScsiController,
+                  &gEfiCallerIdGuid,
+                  (VOID **)&IScsiIdentifier,
+                  NULL,
+                  NULL,
+                  EFI_OPEN_PROTOCOL_GET_PROTOCOL
+                  );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+  if (ChildHandle != NULL) {
+    //
+    // Make sure this driver produced ChildHandle
+    //
+    Status = EfiTestChildHandle (
+               ControllerHandle,
+               ChildHandle,
+               &gEfiTcp4ProtocolGuid
+               );
+    if (!EFI_ERROR (Status)) {
+      //
+      // Retrieve an instance of a produced protocol from ChildHandle
+      //
+      Status = gBS->OpenProtocol (
+                      ChildHandle,
+                      &gEfiExtScsiPassThruProtocolGuid,
+                     (VOID **)&IScsiExtScsiPassThru,
+                      NULL,
+                      NULL,
+                      EFI_OPEN_PROTOCOL_GET_PROTOCOL
+                      );
+      if (EFI_ERROR (Status)) {
+        return Status;
+      }
+      //
+      // Update the component name for this child handle.
+      //
+      Status = UpdateName (IScsiExtScsiPassThru);
+      if (EFI_ERROR (Status)) {
+        return Status;
+      }
+    } else {
+      return Status;
+    }
+  }
+  return LookupUnicodeString2 (
+           Language,
+           This->SupportedLanguages,
+           mIScsiControllerNameTable,
+           ControllerName,
+           (BOOLEAN)(This == &gIScsiComponentName)
+           );
+}

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/IScsiDxe/IScsiCHAP.c

-              r48674
+              r58459
   AuthData    = &Session->AuthData;
   LoginReq    = (ISCSI_LOGIN_REQUEST *) NetbufGetByte (Pdu, 0, 0);
+  if (LoginReq == NULL) {
+    return EFI_PROTOCOL_ERROR;
+  }
   Status      = EFI_SUCCESS;

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/IScsiDxe/IScsiConfig.c

-              r48674
+              r58459
   Helper functions for configuring or getting the parameters relating to iSCSI.
 Copyright (c) 2004 - 2011, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2004 - 2014, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
     UnicodeSPrint (
       PortString,
       (UINTN) ISCSI_NAME_IFR_MAX_SIZE,
+      (UINTN) sizeof (PortString),
       L"Error! Input is incorrect, please input 6 hex numbers!\n"
       );
 …
   if (Status == EFI_BUFFER_TOO_SMALL) {
     DeviceList = (ISCSI_DEVICE_LIST *) AllocatePool (DataSize);
+    ASSERT (DeviceList != NULL);
     gRT->GetVariable (
 …
   DeviceListSize        = sizeof (ISCSI_DEVICE_LIST) + (NumHandles - 1) * sizeof (ISCSI_MAC_INFO);
   DeviceList            = (ISCSI_DEVICE_LIST *) AllocatePool (DeviceListSize);
+  ASSERT (DeviceList != NULL);
   DeviceList->NumDevice = (UINT8) NumHandles;
 …
       ASSERT (ConfigFormEntry != NULL);
       UnicodeSPrint (PortString, (UINTN) 128, L"Port %s", ConfigFormEntry->MacString);
+      UnicodeSPrint (PortString, (UINTN) sizeof (PortString), L"Port %s", ConfigFormEntry->MacString);
       DeviceFormTitleToken = (EFI_STRING_ID) STR_ISCSI_DEVICE_FORM_TITLE;
       HiiSetString (Private->RegisteredHandle, DeviceFormTitleToken, PortString, NULL);
 …
+      }
+      *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_APPLY;
       break;
 …
       // Compose the Port string and create a new EFI_STRING_ID.
       //
       UnicodeSPrint (PortString, 128, L"Port %s", ConfigFormEntry->MacString);
+      UnicodeSPrint (PortString, sizeof (PortString), L"Port %s", ConfigFormEntry->MacString);
       ConfigFormEntry->PortTitleToken = HiiSetString (mCallbackInfo->RegisteredHandle, 0, PortString, NULL);
 …
       // Compose the help string of this port and create a new EFI_STRING_ID.
       //
       UnicodeSPrint (PortString, 128, L"Set the iSCSI parameters on port %s", ConfigFormEntry->MacString);
+      UnicodeSPrint (PortString, sizeof (PortString), L"Set the iSCSI parameters on port %s", ConfigFormEntry->MacString);
       ConfigFormEntry->PortTitleHelpToken = HiiSetString (mCallbackInfo->RegisteredHandle, 0, PortString, NULL);
 …
                                      &gIp4IScsiConfigGuid,
                                      CallbackInfo->DriverHandle,
                                      IScsiDxeStrings,
+                                     IScsi4DxeStrings,
                                      IScsiConfigDxeBin,
                                      NULL

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/IScsiDxe/IScsiConfig.h

-              r48674
+              r58459
   The header file of IScsiConfig.c.
 Copyright (c) 2004 - 2009, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2004 - 2014, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
 extern UINT8  IScsiConfigDxeBin[];
 extern UINT8  IScsiDxeStrings[];
+extern UINT8  IScsi4DxeStrings[];
 #define ISCSI_INITATOR_NAME_VAR_NAME        L"I_NAME"

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/IScsiDxe/IScsiConfigDxe.vfr

r48674	r58459
208	208	help = STRING_TOKEN (STR_SAVE_CHANGES),
209	209	text = STRING_TOKEN (STR_SAVE_CHANGES),
210		~~text = STRING_TOKEN (STR_SAVE_CHANGES),~~
211	210	flags = INTERACTIVE,
212	211	key = KEY_SAVE_CHANGES;

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/IScsiDxe/IScsiDriver.c

-              r48674
+              r58459
   The entry point of IScsi driver.
 Copyright (c) 2004 - 2011, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2004 - 2015, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
   NULL
 };
+/**
+  Tests to see if this driver supports the RemainingDevicePath.
+  @param[in]  RemainingDevicePath  A pointer to the remaining portion of a device path.  This
+                                   parameter is ignored by device drivers, and is optional for bus
+                                   drivers. For bus drivers, if this parameter is not NULL, then
+                                   the bus driver must determine if the bus controller specified
+                                   by ControllerHandle and the child controller specified
+                                   by RemainingDevicePath are both supported by this
+                                   bus driver.
+  @retval EFI_SUCCESS              The RemainingDevicePath is supported or NULL.
+  @retval EFI_UNSUPPORTED          The device specified by ControllerHandle and
+                                   RemainingDevicePath is not supported by the driver specified by This.
+**/
+EFI_STATUS
+IScsiIsDevicePathSupported (
+  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL
+  )
+{
+  EFI_DEVICE_PATH_PROTOCOL  *CurrentDevicePath;
+  CurrentDevicePath = RemainingDevicePath;
+  if (CurrentDevicePath != NULL) {
+    while (!IsDevicePathEnd (CurrentDevicePath)) {
+      if ((CurrentDevicePath->Type == MESSAGING_DEVICE_PATH) && (CurrentDevicePath->SubType == MSG_ISCSI_DP)) {
+        return EFI_SUCCESS;
+      }
+      CurrentDevicePath = NextDevicePathNode (CurrentDevicePath);
+    }
+    return EFI_UNSUPPORTED;
+  }
+  return EFI_SUCCESS;
+}
 /**
 …
+{
   EFI_STATUS                Status;
-  EFI_DEVICE_PATH_PROTOCOL  *CurrentDevicePath;
   Status = gBS->OpenProtocol (
 …
+  }
+  CurrentDevicePath = RemainingDevicePath;
+  if (CurrentDevicePath != NULL) {
+    while (!IsDevicePathEnd (CurrentDevicePath)) {
+      if ((CurrentDevicePath->Type == MESSAGING_DEVICE_PATH) && (CurrentDevicePath->SubType == MSG_ISCSI_DP)) {
+        return EFI_SUCCESS;
+      }
+      CurrentDevicePath = NextDevicePathNode (CurrentDevicePath);
+    }
+  Status = IScsiIsDevicePathSupported (RemainingDevicePath);
+  if (EFI_ERROR (Status)) {
     return EFI_UNSUPPORTED;
+  }
+  if (IScsiDhcpIsConfigured (ControllerHandle)) {
+    Status = gBS->OpenProtocol (
+                    ControllerHandle,
+                    &gEfiDhcp4ServiceBindingProtocolGuid,
+                    NULL,
+                    This->DriverBindingHandle,
+                    ControllerHandle,
+                    EFI_OPEN_PROTOCOL_TEST_PROTOCOL
+                    );
+    if (EFI_ERROR (Status)) {
+      return EFI_UNSUPPORTED;
+    }
+  }
 …
                   );
   if (EFI_ERROR (Status)) {
+    goto ON_ERROR;
+  }
+  //
+  // ISCSI children should share the default Tcp child, just open the default Tcp child via BY_CHILD_CONTROLLER.
+  //
+  Status = gBS->OpenProtocol (
+                  Private->ChildHandle, /// Default Tcp child
+                  &gEfiTcp4ProtocolGuid,
+                  &Interface,
+                  This->DriverBindingHandle,
+                  Private->ExtScsiPassThruHandle,
+                  EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
+                  );
+  if (EFI_ERROR (Status)) {
+    gBS->UninstallMultipleProtocolInterfaces (
+           Private->ExtScsiPassThruHandle,
+           &gEfiExtScsiPassThruProtocolGuid,
+           &Private->IScsiExtScsiPassThru,
+           &gEfiDevicePathProtocolGuid,
+           Private->DevicePath,
+           NULL
+           );
     goto ON_ERROR;
+  }
 …
     //
     gBS->CloseProtocol (
+           Private->ChildHandle,
+           &gEfiTcp4ProtocolGuid,
+           Private->Image,
+           Private->ExtScsiPassThruHandle
+           );
+    gBS->CloseProtocol (
           Conn->Tcp4Io.Handle,
           &gEfiTcp4ProtocolGuid,
 …
+  )
+{
+  EFI_STATUS  Status;
+  UINTN       DeviceHandleCount;
+  EFI_HANDLE  *DeviceHandleBuffer;
+  UINTN       Index;
+  EFI_STATUS                        Status;
+  UINTN                             DeviceHandleCount;
+  EFI_HANDLE                        *DeviceHandleBuffer;
+  UINTN                             Index;
+  EFI_COMPONENT_NAME_PROTOCOL       *ComponentName;
+  EFI_COMPONENT_NAME2_PROTOCOL      *ComponentName2;
   //
 …
                   &DeviceHandleBuffer
                   );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+  for (Index = 0; Index < DeviceHandleCount; Index++) {
+    Status = IScsiTestManagedDevice (
+               DeviceHandleBuffer[Index],
+               gIScsiDriverBinding.DriverBindingHandle,
+               &gEfiTcp4ProtocolGuid
+               );
+    if (EFI_ERROR (Status)) {
+      continue;
+    }
+    Status = gBS->DisconnectController (
+                    DeviceHandleBuffer[Index],
+                    gIScsiDriverBinding.DriverBindingHandle,
+                    NULL
+                    );
+    if (EFI_ERROR (Status)) {
+      goto ON_EXIT;
+    }
+  }
+  //
+  // Unload the iSCSI configuration form.
+  //
+  Status = IScsiConfigFormUnload (gIScsiDriverBinding.DriverBindingHandle);
+  if (EFI_ERROR (Status)) {
+    goto ON_EXIT;
+  }
+  //
+  // Uninstall the ComponentName and ComponentName2 protocol from iSCSI4 driver binding handle
+  // if it has been installed.
+  //
+  Status = gBS->HandleProtocol (
+                  gIScsiDriverBinding.DriverBindingHandle,
+                  &gEfiComponentNameProtocolGuid,
+                  (VOID **) &ComponentName
+                  );
   if (!EFI_ERROR (Status)) {
+    for (Index = 0; Index < DeviceHandleCount; Index++) {
+      Status = gBS->DisconnectController (
+                      DeviceHandleBuffer[Index],
+                      ImageHandle,
+                      NULL
+                      );
+    }
+    if (DeviceHandleBuffer != NULL) {
+      FreePool (DeviceHandleBuffer);
+    }
+  }
+  //
+  // Unload the iSCSI configuration form.
+  //
+  IScsiConfigFormUnload (gIScsiDriverBinding.DriverBindingHandle);
+  //
+  // Uninstall the protocols installed by iSCSI driver.
+  //
+    Status = gBS->UninstallMultipleProtocolInterfaces (
+           gIScsiDriverBinding.DriverBindingHandle,
+           &gEfiComponentNameProtocolGuid,
+           ComponentName,
+           NULL
+           );
+    if (EFI_ERROR (Status)) {
+      goto ON_EXIT;
+    }
+  }
+  Status = gBS->HandleProtocol (
+                  gIScsiDriverBinding.DriverBindingHandle,
+                  &gEfiComponentName2ProtocolGuid,
+                  (VOID **) &ComponentName2
+                  );
+  if (!EFI_ERROR (Status)) {
+    gBS->UninstallMultipleProtocolInterfaces (
+           gIScsiDriverBinding.DriverBindingHandle,
+           &gEfiComponentName2ProtocolGuid,
+           ComponentName2,
+           NULL
+           );
+    if (EFI_ERROR (Status)) {
+      goto ON_EXIT;
+    }
+  }
   Status = gBS->UninstallMultipleProtocolInterfaces (
                   ImageHandle,
                   &gEfiDriverBindingProtocolGuid,
                   &gIScsiDriverBinding,
-                  &gEfiComponentName2ProtocolGuid,
-                  &gIScsiComponentName2,
-                  &gEfiComponentNameProtocolGuid,
-                  &gIScsiComponentName,
                   &gEfiIScsiInitiatorNameProtocolGuid,
                   &gIScsiInitiatorName,
                   NULL
                   );
+ON_EXIT:
+  if (DeviceHandleBuffer != NULL) {
+    FreePool (DeviceHandleBuffer);
+  }
   return Status;
+}

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/IScsiDxe/IScsiDxe.inf

-              r48674
+              r58459
 ## @file
 #  Component description file for IScsi module.
+#  This module produces EFI iSCSI Initiator Name Protocol.
+#
+# Copyright (c) 2004 - 2011, Intel Corporation. All rights reserved.<BR>
+# This program and the accompanying materials
+# are licensed and made available under the terms and conditions of the BSD License
+# which accompanies this distribution.  The full text of the license may be found at
+# http://opensource.org/licenses/bsd-license.php
+#  This module produces EFI iSCSI Initiator Name Protocol upon EFI TCPv4 Protocol
+#  and EFI DHCPv4 Protocol, to provide the capability to do the transport for SCSI
+#  data over TCP/IP. It installs EFI HII Configuration Access Protocol to provide
+#  one way to configurate the iSCSI setting.
+#
+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+#  Copyright (c) 2004 - 2014, Intel Corporation. All rights reserved.<BR>
+#  This program and the accompanying materials
+#  are licensed and made available under the terms and conditions of the BSD License
+#  which accompanies this distribution.  The full text of the license may be found at
+#  http://opensource.org/licenses/bsd-license.php
+#
+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+#
 ##
 …
 [Defines]
   INF_VERSION                    = 0x00010005
+  BASE_NAME                      = IScsiDxe
+  BASE_NAME                      = IScsi4Dxe
+  MODULE_UNI_FILE                = IScsi4Dxe.uni
   FILE_GUID                      = 4579B72D-7EC4-4dd4-8486-083C86B182A7
   MODULE_TYPE                    = UEFI_DRIVER
 …
 [Protocols]
+  ## PRODUCES
+  ## UNDEFINED # Variable
   gEfiIScsiInitiatorNameProtocolGuid
+  gEfiTcp4ProtocolGuid
+  gEfiExtScsiPassThruProtocolGuid
+  gEfiExtScsiPassThruProtocolGuid               ## BY_START
+  gEfiTcp4ProtocolGuid                          ## TO_START
+  gEfiTcp4ServiceBindingProtocolGuid            ## TO_START
+  gEfiDhcp4ProtocolGuid                         ## TO_START
+  gEfiDhcp4ServiceBindingProtocolGuid           ## TO_START
+  ## TO_START
+  ## PRODUCES
   gEfiDevicePathProtocolGuid
+  gEfiTcp4ServiceBindingProtocolGuid
+  gEfiHiiDatabaseProtocolGuid
+  gEfiHiiConfigAccessProtocolGuid
+  gEfiPciIoProtocolGuid
+  gEfiAcpiTableProtocolGuid
+  gEfiDhcp4ProtocolGuid
+  gEfiDhcp4ServiceBindingProtocolGuid
+  gEfiHiiConfigAccessProtocolGuid               ## PRODUCES
+  gEfiHiiDatabaseProtocolGuid                   ## CONSUMES
+  gEfiPciIoProtocolGuid                         ## SOMETIMES_CONSUMES
+  gEfiAcpiTableProtocolGuid                     ## SOMETIMES_CONSUMES
 [Guids]
+  gEfiEventExitBootServicesGuid
+  gEfiIfrTianoGuid                              ## CONSUMES ## GUID
+  gEfiAcpiTableGuid                             ## CONSUMES ## GUID
+  gEfiAcpi10TableGuid                           ## CONSUMES ## GUID
+  gEfiAcpi20TableGuid                           ## CONSUMES ## GUID
+  gIp4IScsiConfigGuid                           ## PRODUCES ## GUID
+  gEfiEventExitBootServicesGuid                 ## SOMETIMES_CONSUMES ## Event
+  gEfiIfrTianoGuid                              ## SOMETIMES_PRODUCES ## UNDEFINED
+  gEfiAcpiTableGuid                             ## SOMETIMES_CONSUMES ## SystemTable
+  gEfiAcpi10TableGuid                           ## SOMETIMES_CONSUMES ## SystemTable
+  gEfiAcpi20TableGuid                           ## SOMETIMES_CONSUMES ## SystemTable
+  ## SOMETIMES_PRODUCES ## Variable:L"iSCSIDeviceList"
+  ## SOMETIMES_CONSUMES ## Variable:L"iSCSIDeviceList"
+  ## SOMETIMES_CONSUMES ## UNDEFINED # HiiIsConfigHdrMatch   mVendorStorageName
+  ## SOMETIMES_PRODUCES ## UNDEFINED # HiiConstructConfigHdr mVendorStorageName
+  ## SOMETIMES_PRODUCES ## UNDEFINED # HiiGetBrowserData     mVendorStorageName
+  ## SOMETIMES_CONSUMES ## UNDEFINED # HiiSetBrowserData     mVendorStorageName
+  ## SOMETIMES_CONSUMES ## HII
+  gIp4IScsiConfigGuid
+  ## SOMETIMES_PRODUCES ## Variable
+  ## SOMETIMES_CONSUMES ## Variable
   gIScsiCHAPAuthInfoGuid
+[UserExtensions.TianoCore."ExtraFiles"]
+  IScsi4DxeExtra.uni

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/IScsiDxe/IScsiExtScsiPassThru.c

-              r48674
+              r58459
   The IScsi's EFI_EXT_SCSI_PASS_THRU_PROTOCOL driver.
 Copyright (c) 2004 - 2007, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2004 - 2014, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
   ISCSI_DRIVER_DATA           *Private;
   ISCSI_SESSION_CONFIG_NVDATA *ConfigNvData;
+  EFI_STATUS                  Status;
   Private       = ISCSI_DRIVER_DATA_FROM_EXT_SCSI_PASS_THRU (This);
 …
+  }
+  return IScsiExecuteScsiCommand (This, Target, Lun, Packet);
+  Status = IScsiExecuteScsiCommand (This, Target, Lun, Packet);
+  if ((Status != EFI_SUCCESS) && (Status != EFI_NOT_READY)) {
+    //
+    // Try to reinstate the session and re-execute the Scsi command.
+    //
+    if (EFI_ERROR (IScsiSessionReinstatement (Private))) {
+      return EFI_DEVICE_ERROR;
+    }
+    Status = IScsiExecuteScsiCommand (This, Target, Lun, Packet);
+  }
+  return Status;
+}

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/IScsiDxe/IScsiIbft.c

-              r48674
+              r58459
   Implementation for iSCSI Boot Firmware Table publication.
 Copyright (c) 2004 - 2011, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2004 - 2013, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
   Header->Revision  = EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_REVISION;
   Header->Checksum  = 0;
-  Header->OemId[0]  = 'I';
-  Header->OemId[1]  = 'N';
-  Header->OemId[2]  = 'T';
-  Header->OemId[3]  = 'E';
-  Header->OemId[4]  = 'L';
   CopyMem (Header->OemId, OemId, sizeof (Header->OemId));
 …
     Target->Header.Flags        = EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_TARGET_STRUCTURE_FLAG_BLOCK_VALID | EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_TARGET_STRUCTURE_FLAG_BOOT_SELECTED;
     Target->Port                = SessionConfigData->NvData.TargetPort;
-    Target->CHAPType            = AuthConfig->CHAPType;
     Target->NicIndex            = (UINT8) Index;
+    if (AuthConfig->CHAPType == ISCSI_CHAP_NONE) {
+      Target->CHAPType = EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_TARGET_STRUCTURE_CHAP_TYPE_NO_CHAP;
+    } if (AuthConfig->CHAPType == ISCSI_CHAP_UNI) {
+      Target->CHAPType = EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_TARGET_STRUCTURE_CHAP_TYPE_CHAP;
+    } else if (AuthConfig->CHAPType == ISCSI_CHAP_MUTUAL) {
+      Target->CHAPType = EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_TARGET_STRUCTURE_CHAP_TYPE_MUTUAL_CHAP;
+    }
     IScsiMapV4ToV6Addr (&SessionConfigData->NvData.TargetIp, &Target->Ip);
 …
     Target->IScsiNameOffset = (UINT16) ((UINTN) *Heap - (UINTN) Table);
     if (Target->CHAPType != ISCSI_CHAP_NONE) {
+    if (Target->CHAPType != EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_TARGET_STRUCTURE_CHAP_TYPE_NO_CHAP) {
       //
       // CHAP Name
 …
       Target->CHAPSecretOffset  = (UINT16) ((UINTN) *Heap - (UINTN) Table);
       if (Target->CHAPType == ISCSI_CHAP_MUTUAL) {
+      if (Target->CHAPType == EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_TARGET_STRUCTURE_CHAP_TYPE_MUTUAL_CHAP) {
         //
         // Reverse CHAP Name

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/IScsiDxe/IScsiMisc.c

-              r48674
+              r58459
   Miscellaneous routines for iSCSI driver.
 Copyright (c) 2004 - 2011, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2004 - 2014, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
+  }
+  ASSERT (StrLen(Str) >= 1);
   Str[StrLen (Str) - 1] = 0;
 …
 /**
+  Check wheather the Controller is configured to use DHCP protocol.
+  @param[in]  Controller           The handle of the controller.
+  @retval TRUE                     The handle of the controller need the Dhcp protocol.
+  @retval FALSE                    The handle of the controller does not need the Dhcp protocol.
+**/
+BOOLEAN
+IScsiDhcpIsConfigured (
+  IN EFI_HANDLE  Controller
+  )
+{
+  EFI_STATUS                  Status;
+  EFI_MAC_ADDRESS             MacAddress;
+  UINTN                       HwAddressSize;
+  UINT16                      VlanId;
+  CHAR16                      MacString[70];
+  ISCSI_SESSION_CONFIG_NVDATA *ConfigDataTmp;
+  //
+  // Get the mac string, it's the name of various variable
+  //
+  Status = NetLibGetMacAddress (Controller, &MacAddress, &HwAddressSize);
+  if (EFI_ERROR (Status)) {
+    return FALSE;
+  }
+  VlanId = NetLibGetVlanId (Controller);
+  IScsiMacAddrToStr (&MacAddress, (UINT32) HwAddressSize, VlanId, MacString);
+  //
+  // Get the normal configuration.
+  //
+  Status = GetVariable2 (
+             MacString,
+             &gEfiIScsiInitiatorNameProtocolGuid,
+             (VOID**)&ConfigDataTmp,
+             NULL
+             );
+  if (ConfigDataTmp == NULL || EFI_ERROR (Status)) {
+    return FALSE;
+  }
+  if (ConfigDataTmp->Enabled && ConfigDataTmp->InitiatorInfoFromDhcp) {
+    FreePool (ConfigDataTmp);
+    return TRUE;
+  }
+  FreePool (ConfigDataTmp);
+  return FALSE;
+}
+/**
   Get the various configuration data of this iSCSI instance.
 …
   IScsiSessionAbort (&Private->Session);
+}
+/**
+  Tests whether a controller handle is being managed by IScsi driver.
+  This function tests whether the driver specified by DriverBindingHandle is
+  currently managing the controller specified by ControllerHandle.  This test
+  is performed by evaluating if the the protocol specified by ProtocolGuid is
+  present on ControllerHandle and is was opened by DriverBindingHandle and Nic
+  Device handle with an attribute of EFI_OPEN_PROTOCOL_BY_DRIVER.
+  If ProtocolGuid is NULL, then ASSERT().
+  @param  ControllerHandle     A handle for a controller to test.
+  @param  DriverBindingHandle  Specifies the driver binding handle for the
+                               driver.
+  @param  ProtocolGuid         Specifies the protocol that the driver specified
+                               by DriverBindingHandle opens in its Start()
+                               function.
+  @retval EFI_SUCCESS          ControllerHandle is managed by the driver
+                               specified by DriverBindingHandle.
+  @retval EFI_UNSUPPORTED      ControllerHandle is not managed by the driver
+                               specified by DriverBindingHandle.
+**/
+EFI_STATUS
+EFIAPI
+IScsiTestManagedDevice (
+  IN  EFI_HANDLE       ControllerHandle,
+  IN  EFI_HANDLE       DriverBindingHandle,
+  IN  EFI_GUID         *ProtocolGuid
+  )
+{
+  EFI_STATUS     Status;
+  VOID           *ManagedInterface;
+  EFI_HANDLE     NicControllerHandle;
+  ASSERT (ProtocolGuid != NULL);
+  NicControllerHandle = NetLibGetNicHandle (ControllerHandle, ProtocolGuid);
+  if (NicControllerHandle == NULL) {
+    return EFI_UNSUPPORTED;
+  }
+  Status = gBS->OpenProtocol (
+                  ControllerHandle,
+                  (EFI_GUID *) ProtocolGuid,
+                  &ManagedInterface,
+                  DriverBindingHandle,
+                  NicControllerHandle,
+                  EFI_OPEN_PROTOCOL_BY_DRIVER
+                  );
+  if (!EFI_ERROR (Status)) {
+    gBS->CloseProtocol (
+           ControllerHandle,
+           (EFI_GUID *) ProtocolGuid,
+           DriverBindingHandle,
+           NicControllerHandle
+           );
+    return EFI_UNSUPPORTED;
+  }
+  if (Status != EFI_ALREADY_STARTED) {
+    return EFI_UNSUPPORTED;
+  }
+  return EFI_SUCCESS;
+}

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/IScsiDxe/IScsiMisc.h

-              r48674
+              r58459
   Miscellaneous definitions for iSCSI driver.
 Copyright (c) 2004 - 2011, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2004 - 2014, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
 /**
+  Check wheather the Controller is configured to use DHCP protocol.
+  @param[in]  Controller           The handle of the controller.
+  @retval TRUE                     The handle of the controller need the Dhcp protocol.
+  @retval FALSE                    The handle of the controller does not need the Dhcp protocol.
+**/
+BOOLEAN
+IScsiDhcpIsConfigured (
+  IN EFI_HANDLE  Controller
+  );
+/**
   Get the various configuration data of this iSCSI instance.
 …
   );
+/**
+  Tests whether a controller handle is being managed by IScsi driver.
+  This function tests whether the driver specified by DriverBindingHandle is
+  currently managing the controller specified by ControllerHandle.  This test
+  is performed by evaluating if the the protocol specified by ProtocolGuid is
+  present on ControllerHandle and is was opened by DriverBindingHandle and Nic
+  Device handle with an attribute of EFI_OPEN_PROTOCOL_BY_DRIVER.
+  If ProtocolGuid is NULL, then ASSERT().
+  @param  ControllerHandle     A handle for a controller to test.
+  @param  DriverBindingHandle  Specifies the driver binding handle for the
+                               driver.
+  @param  ProtocolGuid         Specifies the protocol that the driver specified
+                               by DriverBindingHandle opens in its Start()
+                               function.
+  @retval EFI_SUCCESS          ControllerHandle is managed by the driver
+                               specified by DriverBindingHandle.
+  @retval EFI_UNSUPPORTED      ControllerHandle is not managed by the driver
+                               specified by DriverBindingHandle.
+**/
+EFI_STATUS
+EFIAPI
+IScsiTestManagedDevice (
+  IN  EFI_HANDLE       ControllerHandle,
+  IN  EFI_HANDLE       DriverBindingHandle,
+  IN  EFI_GUID         *ProtocolGuid
+  );
 #endif

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/IScsiDxe/IScsiProto.c

-              r48674
+              r58459
   The implementation of iSCSI protocol based on RFC3720.
 Copyright (c) 2004 - 2011, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2004 - 2014, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
   NET_BUF     *Pdu;
+  Pdu = NULL;
   //
   // Receive the iSCSI login response.
 …
   LoginReq    = (ISCSI_LOGIN_REQUEST *) NetbufGetByte (Pdu, 0, NULL);
+  if (LoginReq == NULL) {
+    return EFI_PROTOCOL_ERROR;
+  }
   DataSegLen  = NTOH24 (LoginReq->DataSegmentLength);
 …
   LoginRsp  = (ISCSI_LOGIN_RESPONSE *) NetbufGetByte (Pdu, 0, NULL);
+  if (LoginRsp == NULL) {
+    return EFI_PROTOCOL_ERROR;
+  }
   if (!ISCSI_CHECK_OPCODE (LoginRsp, ISCSI_OPCODE_LOGIN_RSP)) {
     //
 …
   ISCSI_CONNECTION    *Conn;
   ISCSI_XFER_CONTEXT  *XferContext;
+  UINT8               *DataOutPacket;
   PduList = AllocatePool (sizeof (LIST_ENTRY));
 …
   // Set the F bit for the last data out PDU in this sequence.
   //
+  ISCSI_SET_FLAG (NetbufGetByte (DataOutPdu, 0, NULL), ISCSI_BHS_FLAG_FINAL);
+  DataOutPacket = NetbufGetByte (DataOutPdu, 0, NULL);
+  if (DataOutPacket == NULL) {
+    IScsiFreeNbufList (PduList);
+    PduList = NULL;
+    goto ON_EXIT;
+  }
+  ISCSI_SET_FLAG (DataOutPacket, ISCSI_BHS_FLAG_FINAL);
 ON_EXIT:
 …
   DataInHdr                   = (ISCSI_SCSI_DATA_IN *) NetbufGetByte (Pdu, 0, NULL);
+  if (DataInHdr == NULL) {
+    return EFI_PROTOCOL_ERROR;
+  }
   DataInHdr->InitiatorTaskTag = NTOHL (DataInHdr->InitiatorTaskTag);
 …
   R2THdr = (ISCSI_READY_TO_TRANSFER *) NetbufGetByte (Pdu, 0, NULL);
+  if (R2THdr == NULL) {
+    return EFI_PROTOCOL_ERROR;
+  }
   R2THdr->InitiatorTaskTag = NTOHL (R2THdr->InitiatorTaskTag);
 …
   ScsiRspHdr                    = (SCSI_RESPONSE *) NetbufGetByte (Pdu, 0, NULL);
+  if (ScsiRspHdr == NULL) {
+    return EFI_PROTOCOL_ERROR;
+  }
   ScsiRspHdr->InitiatorTaskTag  = NTOHL (ScsiRspHdr->InitiatorTaskTag);
 …
   if (DataSegLen != 0) {
     SenseData               = (ISCSI_SENSE_DATA *) NetbufGetByte (Pdu, sizeof (SCSI_RESPONSE), NULL);
+    if (SenseData == NULL) {
+      return EFI_PROTOCOL_ERROR;
+    }
     SenseData->Length       = NTOHS (SenseData->Length);
 …
   NopInHdr            = (ISCSI_NOP_IN *) NetbufGetByte (Pdu, 0, NULL);
+  if (NopInHdr == NULL) {
+    return EFI_PROTOCOL_ERROR;
+  }
   NopInHdr->StatSN    = NTOHL (NopInHdr->StatSN);
 …
   @retval EFI_DEVICE_ERROR     Session state was not as required.
   @retval EFI_OUT_OF_RESOURCES Failed to allocate memory.
+  @retval EFI_NOT_READY        The target can not accept new commands.
   @retval Others               Other errors as indicated.
 **/
 …
   ISCSI_IN_BUFFER_CONTEXT InBufferContext;
   UINT64                  Timeout;
   UINT8                   *Buffer;
+  UINT8                   *PduHdr;
   Private       = ISCSI_DRIVER_DATA_FROM_EXT_SCSI_PASS_THRU (PassThru);
 …
   if (Session->State != SESSION_STATE_LOGGED_IN) {
+    return EFI_DEVICE_ERROR;
+    Status = EFI_DEVICE_ERROR;
+    goto ON_EXIT;
+  }
 …
   XferContext         = &Tcb->XferContext;
+  Buffer              = NetbufGetByte (Pdu, 0, NULL);
+  XferContext->Offset = ISCSI_GET_DATASEG_LEN (Buffer);
+  PduHdr              = NetbufGetByte (Pdu, 0, NULL);
+  if (PduHdr == NULL) {
+    Status = EFI_PROTOCOL_ERROR;
+    NetbufFree (Pdu);
+    goto ON_EXIT;
+  }
+  XferContext->Offset = ISCSI_GET_DATASEG_LEN (PduHdr);
   //
 …
+    }
+    switch (ISCSI_GET_OPCODE (NetbufGetByte (Pdu, 0, NULL))) {
+    PduHdr = NetbufGetByte (Pdu, 0, NULL);
+    if (PduHdr == NULL) {
+      Status = EFI_PROTOCOL_ERROR;
+      NetbufFree (Pdu);
+      goto ON_EXIT;
+    }
+    switch (ISCSI_GET_OPCODE (PduHdr)) {
     case ISCSI_OPCODE_SCSI_DATA_IN:
       Status = IScsiOnDataInRcvd (Pdu, Tcb, Packet);
 …
+  }
-  if ((Status != EFI_SUCCESS) && (Status != EFI_NOT_READY)) {
-    //
-    // Reinstate the session.
-    //
-    if (EFI_ERROR (IScsiSessionReinstatement (Private))) {
-      Status = EFI_DEVICE_ERROR;
+    }
+  }
   return Status;
+}
 …
   Session = &Private->Session;
   ASSERT (Session->State == SESSION_STATE_LOGGED_IN);
+  ASSERT (Session->State != SESSION_STATE_FREE);
   //

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/IScsiDxe/IScsiProto.h

-              r48674
+              r58459
   The header file of iSCSI Protocol that defines many specific data structures.
 Copyright (c) 2004 - 2011, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2004 - 2014, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
   @retval EFI_DEVICE_ERROR     Session state was not as required.
   @retval EFI_OUT_OF_RESOURCES Failed to allocate memory.
+  @retval EFI_NOT_READY        The target can not accept new commands.
   @retval Others               Other errors as indicated.
 **/

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Ip4ConfigDxe/Ip4Config.c

-              r48674
+              r58459
   This code implements the IP4Config and NicIp4Config protocols.
 Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
   //
   if (Reconfig && (Instance->ReconfigEvent != NULL)) {
+    //
+    // When NicConfig is NULL, NIC IP4 configuration parameter is removed,
+    // the auto configuration process should stop running the configuration
+    // policy for the EFI IPv4 Protocol driver.
+    //
+    if (NicConfig == NULL) {
+      Instance->DoNotStart = TRUE;
+    }
     Status = gBS->SignalEvent (Instance->ReconfigEvent);
     DispatchDpc ();
 …
   EFI_IP4_IPCONFIG_DATA     *Ip4Config;
   EFI_STATUS                Status;
   BOOLEAN                   Perment;
+  BOOLEAN                   Permanent;
   IP4_ADDR                  Subnet;
   IP4_ADDR                  Ip1;
 …
     // other user can get that address.
     //
     Perment = FALSE;
+    Permanent = FALSE;
     if (Instance->NicConfig != NULL) {
       ASSERT (Instance->NicConfig->Source == IP4_CONFIG_SOURCE_DHCP);
       Perment = Instance->NicConfig->Perment;
+      Permanent = Instance->NicConfig->Permanent;
       FreePool (Instance->NicConfig);
+    }
 …
     CopyMem (&Instance->NicConfig->NicAddr, &Instance->NicAddr, sizeof (Instance->NicConfig->NicAddr));
     Instance->NicConfig->Source  = IP4_CONFIG_SOURCE_DHCP;
     Instance->NicConfig->Perment = Perment;
+    Instance->NicConfig->Permanent = Permanent;
     Ip4Config                    = &Instance->NicConfig->Ip4Info;
 …
   if (Instance->NicConfig == NULL) {
+    if (Instance->DoNotStart) {
+      Instance->DoNotStart = FALSE;
+      Status = EFI_SUCCESS;
+      goto ON_EXIT;
+    }
     Source = IP4_CONFIG_SOURCE_DHCP;
   } else {

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Ip4ConfigDxe/Ip4Config.h

-              r48674
+              r58459
   Header file for IP4Config driver.
 Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
   // Underlying media present status.
   //
+  BOOLEAN                         MediaPresent;
+  BOOLEAN                         MediaPresent;
+  //
+  // A flag to indicate EfiIp4ConfigStart should not run
+  //
+  BOOLEAN                         DoNotStart;
 } IP4_CONFIG_INSTANCE;

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Ip4ConfigDxe/Ip4ConfigDriver.c

-              r48674
+              r58459
   The driver binding for IP4 CONFIG protocol.
 Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
     FALSE,
+    {
+      {
+      }
     },
+    {
+      {
+      }
     },
+    {
+      {
+      }
+    }
   },
 …
   NULL,
   NULL,
   EFI_NOT_READY,
+,
+  {
 ,
 ,
+    {
+      {
+      }
+    }
   },
 …
   NULL,
   NULL,
+  TRUE
+  TRUE,
+  FALSE
 };
 …
+  )
+{
+  mIp4ConfigTemplate.Result = EFI_NOT_READY;
   return EfiLibInstallDriverBindingComponentName2 (
            ImageHandle,
 …
   NicConfig = Ip4ConfigReadVariable (Instance);
   if (NicConfig != NULL) {
     if (!NicConfig->Perment) {
+    if (!NicConfig->Permanent) {
       //
       // Delete the non-permanent configuration.

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Ip4ConfigDxe/Ip4ConfigDxe.inf

-              r48674
+              r58459
 ## @file
 # Component name for module Ip4Config
+#  This module produces EFI IPv4 Configuration Protocol.
+#
+# Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
+#  This module produces EFI IPv4 Configuration Protocol upon EFI MNP Protocol,
+#  to performs platform- and policy-dependent configuration for the EFI IPv4
+#  Protocol driver. It installs EFI HII Configuration Access Protocol to provide
+#  one way to configurate the IPv4 network setting.
+#
+#  Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>
 #  This program and the accompanying materials
 #  are licensed and made available under the terms and conditions of the BSD License
 …
   INF_VERSION                    = 0x00010005
   BASE_NAME                      = Ip4ConfigDxe
+  MODULE_UNI_FILE                = Ip4ConfigDxe.uni
   FILE_GUID                      = 26841BDE-920A-4e7a-9FBE-637F477143A6
   MODULE_TYPE                    = UEFI_DRIVER
 …
   PrintLib
   DpcLib
+  DevicePathLib
 [Protocols]
+  gEfiDhcp4ServiceBindingProtocolGuid           # PROTOCOL ALWAYS_CONSUMED
+  gEfiManagedNetworkServiceBindingProtocolGuid  # PROTOCOL ALWAYS_CONSUMED
+  gEfiIp4ConfigProtocolGuid                     # PROTOCOL ALWAYS_PRODUCED
+  gEfiManagedNetworkProtocolGuid                # PROTOCOL ALWAYS_CONSUMED
+  gEfiDhcp4ProtocolGuid                         # PROTOCOL ALWAYS_CONSUMED
+  gEfiHiiConfigAccessProtocolGuid               # PROTOCOL ALWAYS_CONSUMED
+  gEfiIp4ConfigProtocolGuid                     ## BY_START
+  gEfiManagedNetworkServiceBindingProtocolGuid  ## TO_START
+  gEfiManagedNetworkProtocolGuid                ## TO_START
+  gEfiDhcp4ServiceBindingProtocolGuid           ## TO_START
+  gEfiDhcp4ProtocolGuid                         ## TO_START
+  gEfiHiiConfigAccessProtocolGuid               ## BY_START
+  ## TO_START
+  ## BY_START
+  gEfiDevicePathProtocolGuid
 [Guids]
+  gEfiNicIp4ConfigVariableGuid                  ## CONSUMES ## Guid
+  gNicIp4ConfigNvDataGuid                       ## PRODUCES ## Guid
+  ## SOMETIMES_CONSUMES ## GUID # HiiIsConfigHdrMatch   EFI_NIC_IP4_CONFIG_VARIABLE
+  ## SOMETIMES_PRODUCES ## GUID # HiiConstructConfigHdr EFI_NIC_IP4_CONFIG_VARIABLE
+  ## SOMETIMES_PRODUCES ## Variable
+  ## SOMETIMES_CONSUMES ## Variable
+  ## SOMETIMES_PRODUCES ## GUID # Device Path Node
+  gEfiNicIp4ConfigVariableGuid
+  ## SOMETIMES_CONSUMES ## GUID # HiiIsConfigHdrMatch   EFI_NIC_IP4_CONFIG_VARIABLE
+  ## SOMETIMES_PRODUCES ## GUID # HiiConstructConfigHdr EFI_NIC_IP4_CONFIG_VARIABLE
+  ## SOMETIMES_PRODUCES ## GUID # HiiGetBrowserData     EFI_NIC_IP4_CONFIG_VARIABLE
+  ## SOMETIMES_CONSUMES ## HII
+  gNicIp4ConfigNvDataGuid
+[UserExtensions.TianoCore."ExtraFiles"]
+  Ip4ConfigDxeExtra.uni

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Ip4ConfigDxe/Ip4ConfigDxe.vfr

r48674	r58459
83	83	help = STRING_TOKEN(STR_SAVE_CHANGES),
84	84	text = STRING_TOKEN(STR_SAVE_CHANGES),
85		~~text = STRING_TOKEN(STR_SAVE_CHANGES),~~
86	85	flags = INTERACTIVE,
87	86	key = KEY_SAVE_CHANGES;

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Ip4ConfigDxe/Ip4ConfigNv.c

-              r48674
+              r58459
   Helper functions for configuring or getting the parameters relating to Ip4.
 Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2009 - 2012, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
+  }
   NicInfo->Perment = TRUE;
+  NicInfo->Permanent = TRUE;
   CopyMem (&NicInfo->NicAddr, &Ip4ConfigInstance->NicAddr, sizeof (NIC_ADDR));

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Ip4ConfigDxe/NicIp4Variable.c

-              r48674
+              r58459
   Routines used to operate the Ip4 configure variable.
 Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
   NIC_IP4_CONFIG_INFO *NicConfig;
   NicConfig = GetVariable (Instance->MacString, &gEfiNicIp4ConfigVariableGuid);
+  GetVariable2 (Instance->MacString, &gEfiNicIp4ConfigVariableGuid, (VOID**)&NicConfig, NULL);
   if (NicConfig != NULL) {
     Ip4ConfigFixRouteTablePointer (&NicConfig->Ip4Info);
 …
+    }
     NicConfig = GetVariable (VariableName, &gEfiNicIp4ConfigVariableGuid);
+    GetVariable2 (VariableName, &gEfiNicIp4ConfigVariableGuid, (VOID**)&NicConfig, NULL);
     if (NicConfig == NULL) {
       break;

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Ip4Dxe/ComponentName.c

-              r48674
+              r58459
 /** @file
 Copyright (c) 2005 - 2011, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2005 - 2012, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
+  }
 };
+GLOBAL_REMOVE_IF_UNREFERENCED EFI_UNICODE_STRING_TABLE  *gIp4ControllerNameTable = NULL;
 /**
 …
 /**
+  Update the component name for the IP4 child handle.
+  @param  Ip4[in]                 A pointer to the EFI_IP4_PROTOCOL.
+  @retval EFI_SUCCESS             Update the ControllerNameTable of this instance successfully.
+  @retval EFI_INVALID_PARAMETER   The input parameter is invalid.
+**/
+EFI_STATUS
+UpdateName (
+  IN     EFI_IP4_PROTOCOL         *Ip4
+  )
+{
+  EFI_STATUS                       Status;
+  CHAR16                           HandleName[80];
+  EFI_IP4_MODE_DATA                Ip4ModeData;
+  if (Ip4 == NULL) {
+    return EFI_INVALID_PARAMETER;
+  }
+  //
+  // Format the child name into the string buffer as:
+  // IPv4 (SrcIP=127.0.0.1, DestIP=127.0.0.1)
+  //
+  Status = Ip4->GetModeData (Ip4, &Ip4ModeData, NULL, NULL);
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+  if (!Ip4ModeData.IsStarted || !Ip4ModeData.IsConfigured) {
+    UnicodeSPrint (HandleName, sizeof (HandleName), L"IPv4 (Not started)");
+  } else {
+    UnicodeSPrint (HandleName, sizeof (HandleName),
+      L"IPv4 (SrcIP=%d.%d.%d.%d)",
+      Ip4ModeData.ConfigData.StationAddress.Addr[0],
+      Ip4ModeData.ConfigData.StationAddress.Addr[1],
+      Ip4ModeData.ConfigData.StationAddress.Addr[2],
+      Ip4ModeData.ConfigData.StationAddress.Addr[3]
+      );
+  }
+  if (gIp4ControllerNameTable != NULL) {
+    FreeUnicodeStringTable (gIp4ControllerNameTable);
+    gIp4ControllerNameTable = NULL;
+  }
+  Status = AddUnicodeString2 (
+             "eng",
+             gIp4ComponentName.SupportedLanguages,
+             &gIp4ControllerNameTable,
+             HandleName,
+             TRUE
+             );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+  return AddUnicodeString2 (
+           "en",
+           gIp4ComponentName2.SupportedLanguages,
+           &gIp4ControllerNameTable,
+           HandleName,
+           FALSE
+           );
+}
+/**
   Retrieves a Unicode string that is the user readable name of the controller
   that is being managed by a driver.
 …
+  )
+{
+  return EFI_UNSUPPORTED;
+  EFI_STATUS                    Status;
+  EFI_IP4_PROTOCOL              *Ip4;
+  //
+  // Only provide names for child handles.
+  //
+  if (ChildHandle == NULL) {
+    return EFI_UNSUPPORTED;
+  }
+  //
+  // Make sure this driver produced ChildHandle
+  //
+  Status = EfiTestChildHandle (
+             ControllerHandle,
+             ChildHandle,
+             &gEfiManagedNetworkProtocolGuid
+             );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+  //
+  // Retrieve an instance of a produced protocol from ChildHandle
+  //
+  Status = gBS->OpenProtocol (
+                  ChildHandle,
+                  &gEfiIp4ProtocolGuid,
+                  (VOID **)&Ip4,
+                  NULL,
+                  NULL,
+                  EFI_OPEN_PROTOCOL_GET_PROTOCOL
+                  );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+  //
+  // Update the component name for this child handle.
+  //
+  Status = UpdateName (Ip4);
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+  return LookupUnicodeString2 (
+           Language,
+           This->SupportedLanguages,
+           gIp4ControllerNameTable,
+           ControllerName,
+           (BOOLEAN)(This == &gIp4ComponentName)
+           );
+}

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Ip4Dxe/Ip4Common.c

-              r48674
+              r58459
 /** @file
 Copyright (c) 2005 - 2009, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2005 - 2014, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
   return Head;
+}
-/**
-  Set the Ip4 variable data.
-  Save the list of all of the IPv4 addresses and subnet masks that are currently
-  being used to volatile variable storage.
-  @param[in]  IpSb                  Ip4 service binding instance
-  @retval EFI_SUCCESS           Successfully set variable.
-  @retval EFI_OUT_OF_RESOURCES  There are not enough resources to set the variable.
-  @retval other                 Set variable failed.
-**/
-EFI_STATUS
-Ip4SetVariableData (
-  IN IP4_SERVICE  *IpSb
+  )
+{
-  UINT32                 NumConfiguredInstance;
-  LIST_ENTRY             *Entry;
-  UINTN                  VariableDataSize;
-  EFI_IP4_VARIABLE_DATA  *Ip4VariableData;
-  EFI_IP4_ADDRESS_PAIR   *Ip4AddressPair;
-  IP4_PROTOCOL           *IpInstance;
-  CHAR16                 *NewMacString;
-  EFI_STATUS             Status;
-  NumConfiguredInstance = 0;
-  //
-  // Go through the children list to count the configured children.
-  //
-  NET_LIST_FOR_EACH (Entry, &IpSb->Children) {
-    IpInstance = NET_LIST_USER_STRUCT_S (Entry, IP4_PROTOCOL, Link, IP4_PROTOCOL_SIGNATURE);
-    if (IpInstance->State == IP4_STATE_CONFIGED) {
-      NumConfiguredInstance++;
+    }
+  }
-  //
-  // Calculate the size of the Ip4VariableData. As there may be no IP child,
-  // we should add extra buffer for the address paris only if the number of configured
-  // children is more than 1.
-  //
-  VariableDataSize = sizeof (EFI_IP4_VARIABLE_DATA);
-  if (NumConfiguredInstance > 1) {
-    VariableDataSize += sizeof (EFI_IP4_ADDRESS_PAIR) * (NumConfiguredInstance - 1);
+  }
-  Ip4VariableData = AllocatePool (VariableDataSize);
-  if (Ip4VariableData == NULL) {
-    return EFI_OUT_OF_RESOURCES;
+  }
-  Ip4VariableData->DriverHandle = IpSb->Image;
-  Ip4VariableData->AddressCount = NumConfiguredInstance;
-  Ip4AddressPair = &Ip4VariableData->AddressPairs[0];
-  //
-  // Go through the children list to fill the configured children's address pairs.
-  //
-  NET_LIST_FOR_EACH (Entry, &IpSb->Children) {
-    IpInstance = NET_LIST_USER_STRUCT_S (Entry, IP4_PROTOCOL, Link, IP4_PROTOCOL_SIGNATURE);
-    if (IpInstance->State == IP4_STATE_CONFIGED) {
-      Ip4AddressPair->InstanceHandle       = IpInstance->Handle;
-      EFI_IP4 (Ip4AddressPair->Ip4Address) = NTOHL (IpInstance->Interface->Ip);
-      EFI_IP4 (Ip4AddressPair->SubnetMask) = NTOHL (IpInstance->Interface->SubnetMask);
-      Ip4AddressPair++;
+    }
+  }
-  //
-  // Get the mac string.
-  //
-  Status = NetLibGetMacString (IpSb->Controller, IpSb->Image, &NewMacString);
-  if (EFI_ERROR (Status)) {
-    goto ON_ERROR;
+  }
-  if (IpSb->MacString != NULL) {
-    //
-    // The variable is set already, we're going to update it.
-    //
-    if (StrCmp (IpSb->MacString, NewMacString) != 0) {
-      //
-      // The mac address is changed, delete the previous variable first.
-      //
-      gRT->SetVariable (
-             IpSb->MacString,
-             &gEfiIp4ServiceBindingProtocolGuid,
-             EFI_VARIABLE_BOOTSERVICE_ACCESS,
-,
-             NULL
-             );
+    }
-    FreePool (IpSb->MacString);
+  }
-  IpSb->MacString = NewMacString;
-  Status = gRT->SetVariable (
-                  IpSb->MacString,
-                  &gEfiIp4ServiceBindingProtocolGuid,
-                  EFI_VARIABLE_BOOTSERVICE_ACCESS,
-                  VariableDataSize,
-                  (VOID *) Ip4VariableData
-                  );
-ON_ERROR:
-  FreePool (Ip4VariableData);
-  return Status;
+}
-/**
-  Clear the variable and free the resource.
-  @param[in]  IpSb                  Ip4 service binding instance
-**/
-VOID
-Ip4ClearVariableData (
-  IN IP4_SERVICE  *IpSb
+  )
+{
-  ASSERT (IpSb->MacString != NULL);
-  gRT->SetVariable (
-         IpSb->MacString,
-         &gEfiIp4ServiceBindingProtocolGuid,
-         EFI_VARIABLE_BOOTSERVICE_ACCESS,
-,
-         NULL
-         );
-  FreePool (IpSb->MacString);
-  IpSb->MacString = NULL;
+}

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Ip4Dxe/Ip4Common.h

-              r48674
+              r58459
   Common definition for IP4.
 Copyright (c) 2005 - 2009, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2005 - 2014, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
           ((BOOLEAN)(((FragmentField) & IP4_HEAD_OFFSET_MASK) == 0))
+#define IP4_DO_NOT_FRAGMENT(FragmentField) \
+          ((BOOLEAN)(((FragmentField) & IP4_HEAD_DF_MASK) == IP4_HEAD_DF_MASK))
 #define IP4_IS_BROADCAST(CastType) ((CastType) >= IP4_LOCAL_BROADCAST)
 …
   );
-/**
-  Set the Ip4 variable data.
-  Save the list of all of the IPv4 addresses and subnet masks that are currently
-  being used to volatile variable storage.
-  @param[in]  IpSb                  Ip4 service binding instance
-  @retval EFI_SUCCESS           Successfully set variable.
-  @retval EFI_OUT_OF_RESOURCES  There are not enough resources to set the variable.
-  @retval other                 Set variable failed.
-**/
-EFI_STATUS
-Ip4SetVariableData (
-  IN IP4_SERVICE  *IpSb
-  );
-/**
-  Clear the variable and free the resource.
-  @param[in]  IpSb                  Ip4 service binding instance
-**/
-VOID
-Ip4ClearVariableData (
-  IN IP4_SERVICE  *IpSb
-  );
 #endif

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Ip4Dxe/Ip4Driver.c

-              r48674
+              r58459
   The driver binding and service binding protocol for IP4 driver.
 Copyright (c) 2005 - 2011, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2005 - 2014, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
   the resource allocated by the instance. The instance may be
   partly initialized, or partly destroyed. If a resource is
   destroyed, it is marked as that in case the destory failed and
+  destroyed, it is marked as that in case the destroy failed and
   being called again later.
 …
   IpSb->ServiceBinding.DestroyChild = Ip4ServiceBindingDestroyChild;
   IpSb->State                       = IP4_SERVICE_UNSTARTED;
-  IpSb->InDestory                   = FALSE;
   IpSb->NumChildren                 = 0;
 …
+  }
   IpSb->OldMaxPacketSize = IpSb->MaxPacketSize;
-  IpSb->MacString = NULL;
   *Service = IpSb;
   return EFI_SUCCESS;
 …
   the resource allocated by the instance. The instance may be
   partly initialized, or partly destroyed. If a resource is
   destroyed, it is marked as that in case the destory failed and
+  destroyed, it is marked as that in case the destroy failed and
   being called again later.
 …
+}
+/**
+  Callback function which provided by user to remove one node in NetDestroyLinkList process.
+  @param[in]    Entry           The entry to be removed.
+  @param[in]    Context         Pointer to the callback context corresponds to the Context in NetDestroyLinkList.
+  @retval EFI_SUCCESS           The entry has been removed successfully.
+  @retval Others                Fail to remove the entry.
+**/
+EFI_STATUS
+EFIAPI
+Ip4DestroyChildEntryInHandleBuffer (
+  IN LIST_ENTRY         *Entry,
+  IN VOID               *Context
+  )
+{
+  IP4_PROTOCOL                  *IpInstance;
+  EFI_SERVICE_BINDING_PROTOCOL  *ServiceBinding;
+  UINTN                         NumberOfChildren;
+  EFI_HANDLE                    *ChildHandleBuffer;
+  if (Entry == NULL || Context == NULL) {
+    return EFI_INVALID_PARAMETER;
+  }
+  IpInstance = NET_LIST_USER_STRUCT_S (Entry, IP4_PROTOCOL, Link, IP4_PROTOCOL_SIGNATURE);
+  ServiceBinding    = ((IP4_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT *) Context)->ServiceBinding;
+  NumberOfChildren  = ((IP4_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT *) Context)->NumberOfChildren;
+  ChildHandleBuffer = ((IP4_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT *) Context)->ChildHandleBuffer;
+  if (!NetIsInHandleBuffer (IpInstance->Handle, NumberOfChildren, ChildHandleBuffer)) {
+    return EFI_SUCCESS;
+  }
+  return ServiceBinding->DestroyChild (ServiceBinding, IpInstance->Handle);
+}
 /**
 …
   mIp4Id = (UINT16)NET_RANDOM (NetRandomInitSeed ());
-  Ip4SetVariableData (IpSb);
   return Status;
 …
+  )
+{
+  EFI_SERVICE_BINDING_PROTOCOL  *ServiceBinding;
+  IP4_SERVICE                   *IpSb;
+  IP4_PROTOCOL                  *IpInstance;
+  EFI_HANDLE                    NicHandle;
+  EFI_STATUS                    Status;
+  EFI_TPL                       OldTpl;
+  INTN                          State;
+  BOOLEAN                       IsArp;
+  EFI_SERVICE_BINDING_PROTOCOL             *ServiceBinding;
+  IP4_SERVICE                              *IpSb;
+  EFI_HANDLE                               NicHandle;
+  EFI_STATUS                               Status;
+  INTN                                     State;
+  LIST_ENTRY                               *List;
+  IP4_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT  Context;
+  IP4_INTERFACE                            *IpIf;
+  IP4_ROUTE_TABLE                          *RouteTable;
   //
 …
                   EFI_OPEN_PROTOCOL_TEST_PROTOCOL
                   );
   if (Status == EFI_SUCCESS) {
     //
 …
                     EFI_OPEN_PROTOCOL_GET_PROTOCOL
                     );
     if (EFI_ERROR (Status)) {
       return EFI_DEVICE_ERROR;
 …
     IpSb = IP4_SERVICE_FROM_PROTOCOL (ServiceBinding);
+    OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
+    if (IpSb->Ip4Config != NULL && (IpSb->State != IP4_SERVICE_DESTORY)) {
+    if (IpSb->Ip4Config != NULL && (IpSb->State != IP4_SERVICE_DESTROY)) {
       IpSb->Ip4Config->Stop (IpSb->Ip4Config);
 …
                       ControllerHandle
                       );
       if (EFI_ERROR (Status)) {
-        gBS->RestoreTPL (OldTpl);
         return Status;
+      }
 …
+    }
-    gBS->RestoreTPL (OldTpl);
     return EFI_SUCCESS;
+  }
 …
   // the protocol info to find the NIC handle.
   //
-  IsArp     = FALSE;
   NicHandle = NetLibGetNicHandle (ControllerHandle, &gEfiManagedNetworkProtocolGuid);
   if (NicHandle == NULL) {
     NicHandle = NetLibGetNicHandle (ControllerHandle, &gEfiArpProtocolGuid);
+    IsArp     = TRUE;
+  }
+  if (NicHandle == NULL) {
+    return EFI_DEVICE_ERROR;
+    if (NicHandle == NULL) {
+      return EFI_SUCCESS;
+    }
+  }
 …
                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
                   );
   if (EFI_ERROR (Status)) {
     return EFI_DEVICE_ERROR;
 …
   IpSb   = IP4_SERVICE_FROM_PROTOCOL (ServiceBinding);
+  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
+  if (IpSb->InDestory) {
+    gBS->RestoreTPL (OldTpl);
+    return EFI_SUCCESS;
+  }
+  if (IsArp) {
+    while (!IsListEmpty (&IpSb->Children)) {
+      IpInstance = NET_LIST_HEAD (&IpSb->Children, IP4_PROTOCOL, Link);
+      ServiceBinding->DestroyChild (ServiceBinding, IpInstance->Handle);
+    }
+    if (IpSb->NumChildren != 0) {
+      Status = EFI_DEVICE_ERROR;
+  if (NumberOfChildren != 0) {
+    List = &IpSb->Children;
+    Context.ServiceBinding    = ServiceBinding;
+    Context.NumberOfChildren  = NumberOfChildren;
+    Context.ChildHandleBuffer = ChildHandleBuffer;
+    Status = NetDestroyLinkList (
+               List,
+               Ip4DestroyChildEntryInHandleBuffer,
+               &Context,
+               NULL
+               );
+  } else if (IpSb->DefaultInterface->ArpHandle == ControllerHandle) {
+    //
+    // The ARP protocol for the default interface is being uninstalled and all
+    // its IP child handles should have been destroyed before. So, release the
+    // default interface and route table, create a new one and mark it as not started.
+    //
+    Ip4CancelReceive (IpSb->DefaultInterface);
+    Ip4FreeInterface (IpSb->DefaultInterface, NULL);
+    Ip4FreeRouteTable (IpSb->DefaultRouteTable);
+    IpIf = Ip4CreateInterface (IpSb->Mnp, IpSb->Controller, IpSb->Image);
+    if (IpIf == NULL) {
       goto ON_ERROR;
+    }
+    IpSb->InDestory = TRUE;
+    RouteTable = Ip4CreateRouteTable ();
+    if (RouteTable == NULL) {
+      Ip4FreeInterface (IpIf, NULL);
+      goto ON_ERROR;;
+    }
+    IpSb->DefaultInterface  = IpIf;
+    InsertHeadList (&IpSb->Interfaces, &IpIf->Link);
+    IpSb->DefaultRouteTable = RouteTable;
+    Ip4ReceiveFrame (IpIf, NULL, Ip4AccpetFrame, IpSb);
+    if (IpSb->Ip4Config != NULL && IpSb->State != IP4_SERVICE_DESTROY) {
+      IpSb->Ip4Config->Stop (IpSb->Ip4Config);
+    }
+    IpSb->State = IP4_SERVICE_UNSTARTED;
+  } else if (IsListEmpty (&IpSb->Children)) {
     State           = IpSb->State;
+    IpSb->State     = IP4_SERVICE_DESTORY;
+    //
+    // Clear the variable data.
+    //
+    Ip4ClearVariableData (IpSb);
+    IpSb->State     = IP4_SERVICE_DESTROY;
     //
 …
     //
     Status = Ip4CleanService (IpSb);
     if (EFI_ERROR (Status)) {
       IpSb->State = State;
 …
            ServiceBinding
            );
+    if (gIp4ControllerNameTable != NULL) {
+      FreeUnicodeStringTable (gIp4ControllerNameTable);
+      gIp4ControllerNameTable = NULL;
+    }
     FreePool (IpSb);
-  } else if (NumberOfChildren == 0) {
-    IpSb->InDestory = TRUE;
-    State           = IpSb->State;
-    IpSb->State     = IP4_SERVICE_DESTORY;
-    //
-    // Clear the variable data.
-    //
-    Ip4ClearVariableData (IpSb);
-    //
-    // OK, clean other resources then uninstall the service binding protocol.
-    //
-    Status = Ip4CleanService (IpSb);
-    if (EFI_ERROR (Status)) {
-      IpSb->State = State;
-      goto ON_ERROR;
+    }
-    gBS->UninstallProtocolInterface (
-           NicHandle,
-           &gEfiIp4ServiceBindingProtocolGuid,
-           ServiceBinding
-           );
-    FreePool (IpSb);
-  } else {
-    while (!IsListEmpty (&IpSb->Children)) {
-      IpInstance = NET_LIST_HEAD (&IpSb->Children, IP4_PROTOCOL, Link);
-      ServiceBinding->DestroyChild (ServiceBinding, IpInstance->Handle);
+    }
-    if (IpSb->NumChildren != 0) {
-      Status = EFI_DEVICE_ERROR;
+    }
+  }
 ON_ERROR:
-  gBS->RestoreTPL (OldTpl);
   return Status;
+}
 …
   //
   // A child can be destoried more than once. For example,
   // Ip4DriverBindingStop will destory all of its children.
   // when UDP driver is being stopped, it will destory all
+  // A child can be destroyed more than once. For example,
+  // Ip4DriverBindingStop will destroy all of its children.
+  // when UDP driver is being stopped, it will destroy all
   // the IP child it opens.
   //
   if (IpInstance->State == IP4_STATE_DESTORY) {
+  if (IpInstance->State == IP4_STATE_DESTROY) {
     gBS->RestoreTPL (OldTpl);
     return EFI_SUCCESS;
 …
   State             = IpInstance->State;
   IpInstance->State = IP4_STATE_DESTORY;
+  IpInstance->State = IP4_STATE_DESTROY;
   //
 …
          ChildHandle
          );
+  if (IpInstance->Interface != NULL && IpInstance->Interface->Arp != NULL) {
+    gBS->CloseProtocol (
+           IpInstance->Interface->ArpHandle,
+           &gEfiArpProtocolGuid,
+           gIp4DriverBinding.DriverBindingHandle,
+           ChildHandle
+           );
+  }
   //
 …
   // that means there is a resource leak.
   //
+  gBS->RestoreTPL (OldTpl);
   Status = gBS->UninstallProtocolInterface (
                   ChildHandle,
 …
                   &IpInstance->Ip4Proto
                   );
+  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
   if (EFI_ERROR (Status)) {
     goto ON_ERROR;
 …
   Status = Ip4CleanProtocol (IpInstance);
-  Ip4SetVariableData (IpSb);
   if (EFI_ERROR (Status)) {
     gBS->InstallMultipleProtocolInterfaces (

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Ip4Dxe/Ip4Driver.h

-              r48674
+              r58459
 /** @file
 Copyright (c) 2005 - 2011, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2005 - 2012, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
 extern EFI_COMPONENT_NAME_PROTOCOL   gIp4ComponentName;
 extern EFI_COMPONENT_NAME2_PROTOCOL  gIp4ComponentName2;
+extern EFI_UNICODE_STRING_TABLE      *gIp4ControllerNameTable;
+typedef struct {
+  EFI_SERVICE_BINDING_PROTOCOL  *ServiceBinding;
+  UINTN                         NumberOfChildren;
+  EFI_HANDLE                    *ChildHandleBuffer;
+} IP4_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT;
 //

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Ip4Dxe/Ip4Dxe.inf

-              r48674
+              r58459
 ## @file
 # Component name for module Ip4
+#  This module produces EFI IPv4 Protocol and EFI IPv4 Service Binding Protocol.
+#
+# Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>
+#  This module produces EFI IPv4 Protocol upon EFI MNP Protocol and EFI ARP Protocol,
+#  to provide basic network IPv4 packet I/O services, which includes support for a
+#  subset of the Internet Control Message Protocol (ICMP) and may include support for
+#  the Internet Group Management Protocol (IGMP).
+#
+#  Copyright (c) 2007 - 2014, Intel Corporation. All rights reserved.<BR>
 #  This program and the accompanying materials
 #  are licensed and made available under the terms and conditions of the BSD License
 …
   INF_VERSION                    = 0x00010005
   BASE_NAME                      = Ip4Dxe
+  MODULE_UNI_FILE                = Ip4Dxe.uni
   FILE_GUID                      = 9FB1A1F3-3B71-4324-B39A-745CBB015FFF
   MODULE_TYPE                    = UEFI_DRIVER
 …
 [Protocols]
+  gEfiIp4ProtocolGuid                           # PROTOCOL ALWAYS_CONSUMED
+  gEfiManagedNetworkServiceBindingProtocolGuid  # PROTOCOL ALWAYS_CONSUMED
+  gEfiIp4ConfigProtocolGuid                     # PROTOCOL ALWAYS_CONSUMED
+  gEfiArpServiceBindingProtocolGuid             # PROTOCOL ALWAYS_CONSUMED
+  gEfiIp4ServiceBindingProtocolGuid             # PROTOCOL ALWAYS_CONSUMED
+  gEfiManagedNetworkProtocolGuid                # PROTOCOL ALWAYS_CONSUMED
+  gEfiArpProtocolGuid                           # PROTOCOL ALWAYS_CONSUMED
+  gEfiIpSec2ProtocolGuid                        # PROTOCOL ALWAYS_CONSUMED
+  ## BY_START
+  ## UNDEFINED # variable
+  gEfiIp4ServiceBindingProtocolGuid
+  gEfiIp4ProtocolGuid                           ## BY_START
+  gEfiManagedNetworkServiceBindingProtocolGuid  ## TO_START
+  gEfiManagedNetworkProtocolGuid                ## TO_START
+  gEfiArpServiceBindingProtocolGuid             ## TO_START
+  gEfiIp4ConfigProtocolGuid                     ## TO_START
+  gEfiArpProtocolGuid                           ## TO_START
+  gEfiIpSec2ProtocolGuid                        ## SOMETIMES_CONSUMES
+[UserExtensions.TianoCore."ExtraFiles"]
+  Ip4DxeExtra.uni

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Ip4Dxe/Ip4Icmp.c

-              r48674
+              r58459
 /** @file
 Copyright (c) 2005 - 2009, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2005 - 2012, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
   IP4_GET_CLIP_INFO (Packet)->Status = EFI_ICMP_ERROR;
   return Ip4Demultiplex (IpSb, Head, Packet);
+  return Ip4Demultiplex (IpSb, Head, Packet, NULL, 0);
+}
 …
   //
   Icmp                = (IP4_ICMP_QUERY_HEAD *) NetbufGetByte (Data, 0, NULL);
+  ASSERT (Icmp != NULL);
   Icmp->Head.Type     = ICMP_ECHO_REPLY;
   Icmp->Head.Checksum = 0;
 …
+  }
   return Ip4Demultiplex (IpSb, Head, Packet);
+  return Ip4Demultiplex (IpSb, Head, Packet, NULL, 0);
+}

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Ip4Dxe/Ip4If.c

-              r48674
+              r58459
   Implement IP4 pesudo interface.
 Copyright (c) 2005 - 2009, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2005 - 2014, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
   Type                      = NetGetIpClass (IpAddr);
+  ASSERT (Type <= IP4_ADDR_CLASSC);
   Len                       = NetGetMaskLength (SubnetMask);
+  Netmask                   = gIp4AllMasks[MIN ((Len - 1), Type << 3)];
+  ASSERT (Len < IP4_MASK_NUM);
+  Netmask                   = gIp4AllMasks[MIN (Len, Type << 3)];
   Interface->NetBrdcast     = (IpAddr | ~Netmask);
 …
   //
   // Destory the interface if this is the last IP instance that
+  // Destroy the interface if this is the last IP instance that
   // has the address. Remove all the system transmitted packets
   // from this interface, cancel the receive request if there is
   // one, and destory the ARP requests.
+  // one, and destroy the ARP requests.
   //
   Ip4CancelFrames (Interface, EFI_ABORTED, Ip4CancelInstanceFrame, NULL);

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Ip4Dxe/Ip4If.h

-              r48674
+              r58459
   Definition for IP4 pesudo interface structure.
 Copyright (c) 2005 - 2009, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2005 - 2012, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
   //
   // Handle used to create/destory ARP child. All the IP children
+  // Handle used to create/destroy ARP child. All the IP children
   // share one MNP which is owned by IP service binding.
   //

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Ip4Dxe/Ip4Impl.c

-              r48674
+              r58459
 /** @file
 Copyright (c) 2005 - 2010, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2005 - 2014, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
   IP4_ADDR                  SubnetAddress;
   IP4_ADDR                  GatewayAddress;
+  IP4_PROTOCOL              *Ip4Instance;
+  EFI_ARP_PROTOCOL          *Arp;
+  LIST_ENTRY                *Entry;
   IpSb      = (IP4_SERVICE *) Context;
 …
   SubnetMask = EFI_NTOHL (Data->SubnetMask);
   Status = Ip4SetAddress (IpIf, StationAddress, SubnetMask);
   if (EFI_ERROR (Status)) {
     goto ON_EXIT;
+  }
+  if (IpIf->Arp != NULL) {
+    //
+    // A non-NULL IpIf->Arp here means a new ARP child is created when setting default address,
+    // but some IP children may have referenced the default interface before it is configured,
+    // these IP instances also consume this ARP protocol so they need to open it BY_CHILD_CONTROLLER.
+    //
+    Arp = NULL;
+    NET_LIST_FOR_EACH (Entry, &IpIf->IpInstances) {
+      Ip4Instance = NET_LIST_USER_STRUCT_S (Entry, IP4_PROTOCOL, AddrLink, IP4_PROTOCOL_SIGNATURE);
+      Status = gBS->OpenProtocol (
+                      IpIf->ArpHandle,
+                      &gEfiArpProtocolGuid,
+                      (VOID **) &Arp,
+                      gIp4DriverBinding.DriverBindingHandle,
+                      Ip4Instance->Handle,
+                      EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
+                      );
+      if (EFI_ERROR (Status)) {
+        goto ON_EXIT;
+      }
+    }
+  }
 …
   IpSb->State = IP4_SERVICE_CONFIGED;
-  Ip4SetVariableData (IpSb);
 ON_EXIT:
 …
   IP4_ADDR                  Ip;
   IP4_ADDR                  Netmask;
+  EFI_ARP_PROTOCOL          *Arp;
   IpSb = IpInstance->Service;
 …
   IpInstance->Interface = IpIf;
+  if (IpIf->Arp != NULL) {
+    Arp = NULL;
+    Status = gBS->OpenProtocol (
+                    IpIf->ArpHandle,
+                    &gEfiArpProtocolGuid,
+                    (VOID **) &Arp,
+                    gIp4DriverBinding.DriverBindingHandle,
+                    IpInstance->Handle,
+                    EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
+                    );
+    if (EFI_ERROR (Status)) {
+      goto ON_ERROR;
+    }
+  }
   InsertTailList (&IpIf->IpInstances, &IpInstance->AddrLink);
 …
   if (IpInstance->Interface != NULL) {
     RemoveEntryList (&IpInstance->AddrLink);
+    if (IpInstance->Interface->Arp != NULL) {
+      gBS->CloseProtocol (
+             IpInstance->Interface->ArpHandle,
+             &gEfiArpProtocolGuid,
+             gIp4DriverBinding.DriverBindingHandle,
+             IpInstance->Handle
+             );
+    }
     Ip4FreeInterface (IpInstance->Interface, IpInstance);
     IpInstance->Interface = NULL;
 …
   //
   if (IpConfigData != NULL) {
-    //
-    // This implementation doesn't support RawData
-    //
-    if (IpConfigData->RawData) {
-      Status = EFI_UNSUPPORTED;
-      goto ON_EXIT;
+    }
     CopyMem (&IpAddress, &IpConfigData->StationAddress, sizeof (IP4_ADDR));
 …
     //
     // Don't change the state if it is DESTORY, consider the following
+    // Don't change the state if it is DESTROY, consider the following
     // valid sequence: Mnp is unloaded-->Ip Stopped-->Udp Stopped,
     // Configure (ThisIp, NULL). If the state is changed to UNCONFIGED,
 …
   //
   Ip4ServiceConfigMnp (IpInstance->Service, FALSE);
-  //
-  // Update the variable data.
-  //
-  Ip4SetVariableData (IpInstance->Service);
 ON_EXIT:
 …
+}
 /**
   Validate the user's token against current station address.
+  @param[in]  Token                  User's token to validate
+  @param[in]  IpIf                   The IP4 child's interface.
+  @retval EFI_INVALID_PARAMETER  Some parameters are invalid
+  @param[in]  Token              User's token to validate.
+  @param[in]  IpIf               The IP4 child's interface.
+  @param[in]  RawData            Set to TRUE to send unformatted packets.
+  @retval EFI_INVALID_PARAMETER  Some parameters are invalid.
   @retval EFI_BAD_BUFFER_SIZE    The user's option/data is too long.
   @retval EFI_SUCCESS            The token is OK
+  @retval EFI_SUCCESS            The token is valid.
 **/
 …
 Ip4TxTokenValid (
   IN EFI_IP4_COMPLETION_TOKEN   *Token,
+  IN IP4_INTERFACE              *IpIf
+  IN IP4_INTERFACE              *IpIf,
+  IN BOOLEAN                    RawData
+  )
+{
 …
   //
+  // Check the fragment table: no empty fragment, and length isn't bogus.
+  //
+  if ((TxData->TotalDataLength == 0) || (TxData->FragmentCount == 0)) {
+    return EFI_INVALID_PARAMETER;
+  }
+  Offset = TxData->TotalDataLength;
+  if (Offset > IP4_MAX_PACKET_SIZE) {
+    return EFI_BAD_BUFFER_SIZE;
+  }
+  for (Index = 0; Index < TxData->FragmentCount; Index++) {
+    if ((TxData->FragmentTable[Index].FragmentBuffer == NULL) ||
+        (TxData->FragmentTable[Index].FragmentLength == 0)) {
+      return EFI_INVALID_PARAMETER;
+    }
+    Offset -= TxData->FragmentTable[Index].FragmentLength;
+  }
+  if (Offset != 0) {
+    return EFI_INVALID_PARAMETER;
+  }
+  //
+  // NOTE that OptionsLength/OptionsBuffer/OverrideData are ignored if RawData
+  // is TRUE.
+  //
+  if (RawData) {
+    return EFI_SUCCESS;
+  }
+  //
   // Check the IP options: no more than 40 bytes and format is OK
   //
 …
       return EFI_INVALID_PARAMETER;
+    }
+  }
-  //
-  // Check the fragment table: no empty fragment, and length isn't bogus
-  //
-  if ((TxData->TotalDataLength == 0) || (TxData->FragmentCount == 0)) {
-    return EFI_INVALID_PARAMETER;
+  }
-  Offset = TxData->TotalDataLength;
-  for (Index = 0; Index < TxData->FragmentCount; Index++) {
-    if ((TxData->FragmentTable[Index].FragmentBuffer == NULL) ||
-        (TxData->FragmentTable[Index].FragmentLength == 0)) {
-      return EFI_INVALID_PARAMETER;
+    }
-    Offset -= TxData->FragmentTable[Index].FragmentLength;
+  }
-  if (Offset != 0) {
-    return EFI_INVALID_PARAMETER;
+  }
 …
   BOOLEAN                   DontFragment;
   UINT32                    HeadLen;
+  UINT8                     RawHdrLen;
+  UINT32                    OptionsLength;
+  UINT8                     *OptionsBuffer;
+  VOID                      *FirstFragment;
   if (This == NULL) {
 …
   // make sure that token is properly formated
   //
   Status = Ip4TxTokenValid (Token, IpIf);
+  Status = Ip4TxTokenValid (Token, IpIf, Config->RawData);
   if (EFI_ERROR (Status)) {
 …
   TxData = Token->Packet.TxData;
+  CopyMem (&Head.Dst, &TxData->DestinationAddress, sizeof (IP4_ADDR));
+  Head.Dst = NTOHL (Head.Dst);
+  if (TxData->OverrideData != NULL) {
+    Override      = TxData->OverrideData;
+    Head.Protocol = Override->Protocol;
+    Head.Tos      = Override->TypeOfService;
+    Head.Ttl      = Override->TimeToLive;
+    DontFragment  = Override->DoNotFragment;
+    CopyMem (&Head.Src, &Override->SourceAddress, sizeof (IP4_ADDR));
+    CopyMem (&GateWay, &Override->GatewayAddress, sizeof (IP4_ADDR));
+    Head.Src = NTOHL (Head.Src);
+    GateWay  = NTOHL (GateWay);
+  FirstFragment = NULL;
+  if (Config->RawData) {
+    //
+    // When RawData is TRUE, first buffer in FragmentTable points to a raw
+    // IPv4 fragment including IPv4 header and options.
+    //
+    FirstFragment = TxData->FragmentTable[0].FragmentBuffer;
+    CopyMem (&RawHdrLen, FirstFragment, sizeof (UINT8));
+    RawHdrLen = (UINT8) (RawHdrLen & 0x0f);
+    if (RawHdrLen < 5) {
+      Status = EFI_INVALID_PARAMETER;
+      goto ON_EXIT;
+    }
+    RawHdrLen = (UINT8) (RawHdrLen << 2);
+    CopyMem (&Head, FirstFragment, IP4_MIN_HEADLEN);
+    Ip4NtohHead (&Head);
+    HeadLen      = 0;
+    DontFragment = IP4_DO_NOT_FRAGMENT (Head.Fragment);
+    if (!DontFragment) {
+      Status = EFI_INVALID_PARAMETER;
+      goto ON_EXIT;
+    }
+    GateWay = IP4_ALLZERO_ADDRESS;
+    //
+    // Get IPv4 options from first fragment.
+    //
+    if (RawHdrLen == IP4_MIN_HEADLEN) {
+      OptionsLength = 0;
+      OptionsBuffer = NULL;
+    } else {
+      OptionsLength = RawHdrLen - IP4_MIN_HEADLEN;
+      OptionsBuffer = (UINT8 *) FirstFragment + IP4_MIN_HEADLEN;
+    }
+    //
+    // Trim off IPv4 header and options from first fragment.
+    //
+    TxData->FragmentTable[0].FragmentBuffer = (UINT8 *) FirstFragment + RawHdrLen;
+    TxData->FragmentTable[0].FragmentLength = TxData->FragmentTable[0].FragmentLength - RawHdrLen;
   } else {
+    Head.Src      = IpIf->Ip;
+    GateWay       = IP4_ALLZERO_ADDRESS;
+    Head.Protocol = Config->DefaultProtocol;
+    Head.Tos      = Config->TypeOfService;
+    Head.Ttl      = Config->TimeToLive;
+    DontFragment  = Config->DoNotFragment;
+  }
+  Head.Fragment = IP4_HEAD_FRAGMENT_FIELD (DontFragment, FALSE, 0);
+  HeadLen       = (TxData->OptionsLength + 3) & (~0x03);
+    CopyMem (&Head.Dst, &TxData->DestinationAddress, sizeof (IP4_ADDR));
+    Head.Dst = NTOHL (Head.Dst);
+    if (TxData->OverrideData != NULL) {
+      Override      = TxData->OverrideData;
+      Head.Protocol = Override->Protocol;
+      Head.Tos      = Override->TypeOfService;
+      Head.Ttl      = Override->TimeToLive;
+      DontFragment  = Override->DoNotFragment;
+      CopyMem (&Head.Src, &Override->SourceAddress, sizeof (IP4_ADDR));
+      CopyMem (&GateWay, &Override->GatewayAddress, sizeof (IP4_ADDR));
+      Head.Src = NTOHL (Head.Src);
+      GateWay  = NTOHL (GateWay);
+    } else {
+      Head.Src      = IpIf->Ip;
+      GateWay       = IP4_ALLZERO_ADDRESS;
+      Head.Protocol = Config->DefaultProtocol;
+      Head.Tos      = Config->TypeOfService;
+      Head.Ttl      = Config->TimeToLive;
+      DontFragment  = Config->DoNotFragment;
+    }
+    Head.Fragment = IP4_HEAD_FRAGMENT_FIELD (DontFragment, FALSE, 0);
+    HeadLen       = (TxData->OptionsLength + 3) & (~0x03);
+    OptionsLength = TxData->OptionsLength;
+    OptionsBuffer = (UINT8 *) (TxData->OptionsBuffer);
+  }
   //
 …
     // enqueued.
     //
+    if (Config->RawData) {
+      //
+      // Restore pointer of first fragment in RawData mode.
+      //
+      TxData->FragmentTable[0].FragmentBuffer = (UINT8 *) FirstFragment;
+    }
     NetbufFree (Wrap->Packet);
     goto ON_EXIT;
 …
              Wrap->Packet,
              &Head,
              TxData->OptionsBuffer,
              TxData->OptionsLength,
+             OptionsBuffer,
+             OptionsLength,
              GateWay,
              Ip4OnPacketSent,
 …
   if (EFI_ERROR (Status)) {
     Wrap->Sent = FALSE;
+    if (Config->RawData) {
+      //
+      // Restore pointer of first fragment in RawData mode.
+      //
+      TxData->FragmentTable[0].FragmentBuffer = (UINT8 *) FirstFragment;
+    }
     NetbufFree (Wrap->Packet);
+  }
+  if (Config->RawData) {
+    //
+    // Restore pointer of first fragment in RawData mode.
+    //
+    TxData->FragmentTable[0].FragmentBuffer = (UINT8 *) FirstFragment;
+  }

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Ip4Dxe/Ip4Impl.h

-              r48674
+              r58459
   Ip4 internal functions and type defintions.
 Copyright (c) 2005 - 2009, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2005 - 2014, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
 #include <Library/MemoryAllocationLib.h>
 #include <Library/DpcLib.h>
+#include <Library/PrintLib.h>
 #include "Ip4Common.h"
 …
 // The state of IP4 protocol. It starts from UNCONFIGED. if it is
 // successfully configured, it goes to CONFIGED. if configure NULL
 // is called, it becomes UNCONFIGED again. If (partly) destoried, it
 // becomes DESTORY.
+// is called, it becomes UNCONFIGED again. If (partly) destroyed, it
+// becomes DESTROY.
 //
 #define IP4_STATE_UNCONFIGED    0
 #define IP4_STATE_CONFIGED      1
 #define IP4_STATE_DESTORY       2
+#define IP4_STATE_DESTROY       2
 //
 // The state of IP4 service. It starts from UNSTARTED. It transits
 // to STARTED if autoconfigure is started. If default address is
 // configured, it becomes CONFIGED. and if partly destoried, it goes
 // to DESTORY.
+// configured, it becomes CONFIGED. and if partly destroyed, it goes
+// to DESTROY.
 //
 #define IP4_SERVICE_UNSTARTED   0
 #define IP4_SERVICE_STARTED     1
 #define IP4_SERVICE_CONFIGED    2
 #define IP4_SERVICE_DESTORY     3
+#define IP4_SERVICE_DESTROY     3
 …
   EFI_SERVICE_BINDING_PROTOCOL    ServiceBinding;
   INTN                            State;
-  BOOLEAN                         InDestory;
   //
 …
   EFI_EVENT                       ActiveEvent;
-  //
-  // The string representation of the current mac address of the
-  // NIC this IP4_SERVICE works on.
-  //
-  CHAR16                          *MacString;
   UINT32                          MaxPacketSize;
   UINT32                          OldMaxPacketSize; ///< The MTU before IPsec enable.

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Ip4Dxe/Ip4Input.c

-              r48674
+              r58459
   IP4 input process.
 Copyright (c) 2005 - 2011, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2005 - 2014, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
   // overlaps, trim the overlapped part off THIS fragment.
   //
   if ((Cur != Head) && ((Prev = Cur->BackLink) != Head)) {
+  if ((Prev = Cur->BackLink) != Head) {
     Fragment  = NET_LIST_USER_STRUCT (Prev, NET_BUF, List);
     Node      = IP4_GET_CLIP_INFO (Fragment);
 …
   //
   // Check that the IP4 header is correctly formatted
+  // Check if the IP4 header is correctly formatted.
   //
   if ((*Packet)->TotalSize < IP4_MIN_HEADLEN) {
 …
   //
   // Trim the head off, after this point, the packet is headless.
+  // Trim the head off, after this point, the packet is headless,
   // and Packet->TotalLen == Info->Length.
   //
 …
   Option = NULL;
   if (EFI_ERROR (IoStatus) || (IpSb->State == IP4_SERVICE_DESTORY)) {
+  if (EFI_ERROR (IoStatus) || (IpSb->State == IP4_SERVICE_DESTROY)) {
     goto DROP;
+  }
+  Head      = (IP4_HEAD *) NetbufGetByte (Packet, 0, NULL);
+  Head      = (IP4_HEAD *) NetbufGetByte (Packet, 0, NULL);
+  ASSERT (Head != NULL);
   OptionLen = (Head->HeadLen << 2) - IP4_MIN_HEADLEN;
   if (OptionLen > 0) {
 …
   //
     Head = (IP4_HEAD *) NetbufGetByte (Packet, 0, NULL);
+    ASSERT (Head != NULL);
     Status = Ip4PreProcessPacket (
                IpSb,
 …
   default:
     Ip4Demultiplex (IpSb, Head, Packet);
+    Ip4Demultiplex (IpSb, Head, Packet, Option, OptionLen);
+  }
 …
   it when it is done with the packet.
   @param[in]  IpInstance             The IP4 child to receive the packet
   @param[in]  Packet                 The packet to deliver up.
+  @param[in]  IpInstance    The IP4 child to receive the packet.
+  @param[in]  Packet        The packet to deliver up.
   @retval Wrap              if warp the packet succeed.
 …
   EFI_IP4_RECEIVE_DATA      *RxData;
   EFI_STATUS                Status;
+  BOOLEAN                   RawData;
   Wrap = AllocatePool (IP4_RXDATA_WRAP_SIZE (Packet->BlockOpNum));
 …
   RxData            = &Wrap->RxData;
   ZeroMem (&RxData->TimeStamp, sizeof (EFI_TIME));
+  ZeroMem (RxData, sizeof (EFI_IP4_RECEIVE_DATA));
   Status = gBS->CreateEvent (
 …
   ASSERT (Packet->Ip.Ip4 != NULL);
+  ASSERT (IpInstance != NULL);
+  RawData = IpInstance->ConfigData.RawData;
   //
   // The application expects a network byte order header.
   //
+  RxData->HeaderLength  = (Packet->Ip.Ip4->HeadLen << 2);
+  RxData->Header        = (EFI_IP4_HEADER *) Ip4NtohHead (Packet->Ip.Ip4);
+  RxData->OptionsLength = RxData->HeaderLength - IP4_MIN_HEADLEN;
+  RxData->Options       = NULL;
+  if (RxData->OptionsLength != 0) {
+    RxData->Options = (VOID *) (RxData->Header + 1);
+  if (!RawData) {
+    RxData->HeaderLength  = (Packet->Ip.Ip4->HeadLen << 2);
+    RxData->Header        = (EFI_IP4_HEADER *) Ip4NtohHead (Packet->Ip.Ip4);
+    RxData->OptionsLength = RxData->HeaderLength - IP4_MIN_HEADLEN;
+    RxData->Options       = NULL;
+    if (RxData->OptionsLength != 0) {
+      RxData->Options = (VOID *) (RxData->Header + 1);
+    }
+  }
 …
   NET_BUF                   *Dup;
   UINT8                     *Head;
+  UINT32                    HeadLen;
   //
 …
       // Create a duplicated packet if this packet is shared
       //
+      Dup = NetbufDuplicate (Packet, NULL, IP4_MAX_HEADLEN);
+      if (IpInstance->ConfigData.RawData) {
+        HeadLen = 0;
+      } else {
+        HeadLen = IP4_MAX_HEADLEN;
+      }
+      Dup = NetbufDuplicate (Packet, NULL, HeadLen);
       if (Dup == NULL) {
 …
+      }
+      //
+      // Copy the IP head over. The packet to deliver up is
+      // headless. Trim the head off after copy. The IP head
+      // may be not continuous before the data.
+      //
+      Head = NetbufAllocSpace (Dup, IP4_MAX_HEADLEN, NET_BUF_HEAD);
+      ASSERT (Head != NULL);
+      Dup->Ip.Ip4 = (IP4_HEAD *) Head;
+      CopyMem (Head, Packet->Ip.Ip4, Packet->Ip.Ip4->HeadLen << 2);
+      NetbufTrim (Dup, IP4_MAX_HEADLEN, TRUE);
+      if (!IpInstance->ConfigData.RawData) {
+        //
+        // Copy the IP head over. The packet to deliver up is
+        // headless. Trim the head off after copy. The IP head
+        // may be not continuous before the data.
+        //
+        Head = NetbufAllocSpace (Dup, IP4_MAX_HEADLEN, NET_BUF_HEAD);
+        ASSERT (Head != NULL);
+        Dup->Ip.Ip4 = (IP4_HEAD *) Head;
+        CopyMem (Head, Packet->Ip.Ip4, Packet->Ip.Ip4->HeadLen << 2);
+        NetbufTrim (Dup, IP4_MAX_HEADLEN, TRUE);
+      }
       Wrap = Ip4WrapRxData (IpInstance, Dup);
 …
   the same interface.
+  @param[in]  IpSb                   The IP4 service instance that receive the packet
+  @param[in]  Head                   The header of the received packet
+  @param[in]  Packet                 The data of the received packet
+  @param[in]  IpIf                   The interface to enqueue the packet to
+  @param[in]  IpSb               The IP4 service instance that receive the packet.
+  @param[in]  Head               The header of the received packet.
+  @param[in]  Packet             The data of the received packet.
+  @param[in]  Option             Point to the IP4 packet header options.
+  @param[in]  OptionLen          Length of the IP4 packet header options.
+  @param[in]  IpIf               The interface to enqueue the packet to.
   @return The number of the IP4 children that accepts the packet
 …
   IN IP4_HEAD               *Head,
   IN NET_BUF                *Packet,
+  IN UINT8                  *Option,
+  IN UINT32                 OptionLen,
   IN IP4_INTERFACE          *IpIf
+  )
 …
     IpInstance = NET_LIST_USER_STRUCT (Entry, IP4_PROTOCOL, AddrLink);
     NET_CHECK_SIGNATURE (IpInstance, IP4_PROTOCOL_SIGNATURE);
+    //
+    // In RawData mode, add IPv4 headers and options back to packet.
+    //
+    if ((IpInstance->ConfigData.RawData) && (Option != NULL) && (OptionLen != 0)){
+      Ip4PrependHead (Packet, Head, Option, OptionLen);
+    }
     if (Ip4InstanceEnquePacket (IpInstance, Head, Packet) == EFI_SUCCESS) {
 …
   its own copy of the packet to make changes.
+  @param[in]  IpSb                   The IP4 service instance that received the packet
+  @param[in]  Head                   The header of the received packet
+  @param[in]  Packet                 The data of the received packet
+  @retval EFI_NOT_FOUND          No IP child accepts the packet
+  @param[in]  IpSb               The IP4 service instance that received the packet.
+  @param[in]  Head               The header of the received packet.
+  @param[in]  Packet             The data of the received packet.
+  @param[in]  Option             Point to the IP4 packet header options.
+  @param[in]  OptionLen          Length of the IP4 packet header options.
+  @retval EFI_NOT_FOUND          No IP child accepts the packet.
   @retval EFI_SUCCESS            The packet is enqueued or delivered to some IP
                                  children.
 …
   IN IP4_SERVICE            *IpSb,
   IN IP4_HEAD               *Head,
+  IN NET_BUF                *Packet
+  IN NET_BUF                *Packet,
+  IN UINT8                  *Option,
+  IN UINT32                 OptionLen
+  )
+{
 …
     if (IpIf->Configured) {
+      Enqueued += Ip4InterfaceEnquePacket (IpSb, Head, Packet, IpIf);
+      Enqueued += Ip4InterfaceEnquePacket (
+                    IpSb,
+                    Head,
+                    Packet,
+                    Option,
+                    OptionLen,
+                    IpIf
+                    );
+    }
+  }

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Ip4Dxe/Ip4Input.h

-              r48674
+              r58459
 /** @file
 Copyright (c) 2005 - 2009, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2005 - 2012, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
   its own copy of the packet to make changes.
+  @param[in]  IpSb                   The IP4 service instance that received the packet
+  @param[in]  Head                   The header of the received packet
+  @param[in]  Packet                 The data of the received packet
+  @retval EFI_NOT_FOUND          No IP child accepts the packet
+  @param[in]  IpSb               The IP4 service instance that received the packet.
+  @param[in]  Head               The header of the received packet.
+  @param[in]  Packet             The data of the received packet.
+  @param[in]  Option             Point to the IP4 packet header options.
+  @param[in]  OptionLen          Length of the IP4 packet header options.
+  @retval EFI_NOT_FOUND          No IP child accepts the packet.
   @retval EFI_SUCCESS            The packet is enqueued or delivered to some IP
                                  children.
 …
   IN IP4_SERVICE            *IpSb,
   IN IP4_HEAD               *Head,
+  IN NET_BUF                *Packet
+  IN NET_BUF                *Packet,
+  IN UINT8                  *Option,
+  IN UINT32                 OptionLen
   );
 …
   the same interface.
+  @param[in]  IpSb                   The IP4 service instance that receive the packet
+  @param[in]  Head                   The header of the received packet
+  @param[in]  Packet                 The data of the received packet
+  @param[in]  IpIf                   The interface to enqueue the packet to
+  @param[in]  IpSb               The IP4 service instance that receive the packet.
+  @param[in]  Head               The header of the received packet.
+  @param[in]  Packet             The data of the received packet.
+  @param[in]  Option             Point to the IP4 packet header options.
+  @param[in]  OptionLen          Length of the IP4 packet header options.
+  @param[in]  IpIf               The interface to enqueue the packet to.
   @return The number of the IP4 children that accepts the packet
 …
   IN IP4_HEAD               *Head,
   IN NET_BUF                *Packet,
+  IN UINT8                  *Option,
+  IN UINT32                 OptionLen,
   IN IP4_INTERFACE          *IpIf
   );

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Ip4Dxe/Ip4Output.c

-              r48674
+              r58459
   Transmit the IP4 packet.
 Copyright (c) 2005 - 2009, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2005 - 2013, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
   @retval EFI_NOT_FOUND        There is no route to the destination
   @retval EFI_SUCCESS          The packet is successfully transmitted.
+  @retval EFI_BAD_BUFFER_SIZE  The length of the IPv4 header + option length +
+                               total data length is greater than MTU (or greater
+                               than the maximum packet size if Token.Packet.TxData.
+                               OverrideData.DoNotFragment is TRUE.)
   @retval Others               Failed to transmit the packet.
 …
   UINT32                    Mtu;
   UINT32                    Num;
+  BOOLEAN                   RawData;
   //
 …
   //
   // Before IPsec process, prepared the IP head.
+  //
+  HeadLen        = sizeof (IP4_HEAD) + ((OptLen + 3) & (~0x03));
+  Head->HeadLen  = (UINT8) (HeadLen >> 2);
+  Head->Id       = mIp4Id++;
+  Head->Ver      = 4;
+  // If Ip4Output is transmitting RawData, don't update IPv4 header.
+  //
+  HeadLen = sizeof (IP4_HEAD) + ((OptLen + 3) & (~0x03));
+  if ((IpInstance != NULL) && IpInstance->ConfigData.RawData) {
+    RawData        = TRUE;
+  } else {
+    Head->HeadLen  = (UINT8) (HeadLen >> 2);
+    Head->Id       = mIp4Id++;
+    Head->Ver      = 4;
+    RawData        = FALSE;
+  }
   //
 …
     return Status;
+  }
+  //
+  // Route the packet unless overrided, that is, GateWay isn't zero.
+  //
+  if (GateWay == IP4_ALLZERO_ADDRESS) {
+    Dest = Head->Dst;
+    if (IP4_IS_BROADCAST (Ip4GetNetCast (Dest, IpIf)) || (Dest == IP4_ALLONE_ADDRESS)) {
+      //
+      // Set the gateway to local broadcast if the Dest is
+      // the broadcast address for the connected network or
+      // it is local broadcast.
+      //
+      GateWay = IP4_ALLONE_ADDRESS;
+    } else if (IP4_IS_MULTICAST (Dest)) {
+      //
+      // Set the gateway to the destination if it is an multicast
+      // address. The IP4_INTERFACE won't consult ARP to send local
+      // broadcast and multicast.
+      //
+      GateWay = Head->Dst;
+  Dest = Head->Dst;
+  if (IP4_IS_BROADCAST (Ip4GetNetCast (Dest, IpIf)) || (Dest == IP4_ALLONE_ADDRESS)) {
+    //
+    // Set the gateway to local broadcast if the Dest is
+    // the broadcast address for the connected network or
+    // it is local broadcast.
+    //
+    GateWay = IP4_ALLONE_ADDRESS;
+  } else if (IP4_IS_MULTICAST (Dest)) {
+    //
+    // Set the gateway to the destination if it is an multicast
+    // address. The IP4_INTERFACE won't consult ARP to send local
+    // broadcast and multicast.
+    //
+    GateWay = Head->Dst;
+  } else if (GateWay == IP4_ALLZERO_ADDRESS) {
+    //
+    // Route the packet unless overrided, that is, GateWay isn't zero.
+    //
+    if (IpInstance == NULL) {
+      CacheEntry = Ip4Route (IpSb->DefaultRouteTable, Head->Dst, Head->Src);
     } else {
+      //
+      // Consult the route table to route the packet
+      //
+      if (IpInstance == NULL) {
+        CacheEntry = Ip4Route (IpSb->DefaultRouteTable, Head->Dst, Head->Src);
+      } else {
+        CacheEntry = Ip4Route (IpInstance->RouteTable, Head->Dst, Head->Src);
+      }
+      if (CacheEntry == NULL) {
+        return EFI_NOT_FOUND;
+      }
+      GateWay = CacheEntry->NextHop;
+      Ip4FreeRouteCacheEntry (CacheEntry);
+      CacheEntry = Ip4Route (IpInstance->RouteTable, Head->Dst, Head->Src);
+    }
+    if (CacheEntry == NULL) {
+      return EFI_NOT_FOUND;
+    }
+    GateWay = CacheEntry->NextHop;
+    Ip4FreeRouteCacheEntry (CacheEntry);
+  }
 …
   if (Packet->TotalSize + HeadLen > Mtu) {
+    //
+    // Fragmentation is diabled for RawData mode.
+    //
+    if (RawData) {
+      return EFI_BAD_BUFFER_SIZE;
+    }
     //
     // Packet is fragmented from the tail to the head, that is, the

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/MnpDxe/ComponentName.c

-              r48674
+              r58459
   UEFI Component Name(2) protocol implementation for MnpDxe driver.
 Copyright (c) 2005 - 2011, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2005 - 2014, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions
 …
 **/
 #include  "MnpDriver.h"
+#include  "MnpImpl.h"
 //
 …
+  }
 };
+GLOBAL_REMOVE_IF_UNREFERENCED EFI_UNICODE_STRING_TABLE    *gMnpControllerNameTable = NULL;
 /**
 …
 /**
+  Update the component name for the MNP child handle.
+  @param  Mnp[in]                 A pointer to the EFI_MANAGED_NETWORK_PROTOCOL.
+  @retval EFI_SUCCESS             Update the ControllerNameTable of this instance successfully.
+  @retval EFI_INVALID_PARAMETER   The input parameter is invalid.
+**/
+EFI_STATUS
+UpdateName (
+  IN   EFI_MANAGED_NETWORK_PROTOCOL     *Mnp
+  )
+{
+  EFI_STATUS                       Status;
+  MNP_INSTANCE_DATA                *Instance;
+  CHAR16                           HandleName[80];
+  EFI_MANAGED_NETWORK_CONFIG_DATA  MnpConfigData;
+  EFI_SIMPLE_NETWORK_MODE          SnpModeData;
+  UINTN                            OffSet;
+  UINTN                            Index;
+  if (Mnp == NULL) {
+    return EFI_INVALID_PARAMETER;
+  }
+  Instance = MNP_INSTANCE_DATA_FROM_THIS (Mnp);
+  //
+  // Format the child name into the string buffer as:
+  // MNP (MAC=FF-FF-FF-FF-FF-FF, ProtocolType=0x0800, VlanId=0)
+  //
+  Status = Mnp->GetModeData (Mnp, &MnpConfigData, &SnpModeData);
+  if (!EFI_ERROR (Status)) {
+    OffSet = 0;
+    //
+    // Print the MAC address.
+    //
+    OffSet += UnicodeSPrint (
+                HandleName,
+                sizeof (HandleName),
+                L"MNP (MAC="
+                );
+    for (Index = 0; Index < SnpModeData.HwAddressSize; Index++) {
+      OffSet += UnicodeSPrint (
+                  HandleName + OffSet,
+                  sizeof (HandleName) - OffSet * sizeof (CHAR16),
+                  L"%02X-",
+                  SnpModeData.CurrentAddress.Addr[Index]
+                  );
+    }
+    ASSERT (OffSet > 0);
+    //
+    // Remove the last '-'
+    //
+    OffSet--;
+    //
+    // Print the ProtocolType and VLAN ID for this instance.
+    //
+    OffSet += UnicodeSPrint (
+                HandleName + OffSet,
+                sizeof (HandleName) - OffSet * sizeof (CHAR16),
+                L", ProtocolType=0x%X, VlanId=%d)",
+                MnpConfigData.ProtocolTypeFilter,
+                Instance->MnpServiceData->VlanId
+                );
+  } else if (Status == EFI_NOT_STARTED) {
+    UnicodeSPrint (
+      HandleName,
+      sizeof (HandleName),
+      L"MNP (Not started)"
+      );
+  } else {
+    return Status;
+  }
+  if (gMnpControllerNameTable != NULL) {
+    FreeUnicodeStringTable (gMnpControllerNameTable);
+    gMnpControllerNameTable = NULL;
+  }
+  Status = AddUnicodeString2 (
+             "eng",
+             gMnpComponentName.SupportedLanguages,
+             &gMnpControllerNameTable,
+             HandleName,
+             TRUE
+             );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+  return AddUnicodeString2 (
+           "en",
+           gMnpComponentName2.SupportedLanguages,
+           &gMnpControllerNameTable,
+           HandleName,
+           FALSE
+           );
+}
+/**
   Retrieves a Unicode string that is the user readable name of the controller
   that is being managed by a driver.
 …
+  )
+{
+  return EFI_UNSUPPORTED;
+  EFI_STATUS                    Status;
+  EFI_MANAGED_NETWORK_PROTOCOL  *Mnp;
+  //
+  // Only provide names for MNP child handles.
+  //
+  if (ChildHandle == NULL) {
+    return EFI_UNSUPPORTED;
+  }
+  //
+  // Make sure this driver is currently managing ControllerHandle
+  //
+  Status = EfiTestManagedDevice (
+             ControllerHandle,
+             gMnpDriverBinding.DriverBindingHandle,
+             &gEfiSimpleNetworkProtocolGuid
+             );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+  //
+  // Make sure this driver produced ChildHandle
+  //
+  Status = EfiTestChildHandle (
+             ControllerHandle,
+             ChildHandle,
+             &gEfiManagedNetworkServiceBindingProtocolGuid
+             );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+  //
+  // Retrieve an instance of a produced protocol from ChildHandle
+  //
+  Status = gBS->OpenProtocol (
+                  ChildHandle,
+                  &gEfiManagedNetworkProtocolGuid,
+                  (VOID **)&Mnp,
+                  NULL,
+                  NULL,
+                  EFI_OPEN_PROTOCOL_GET_PROTOCOL
+                  );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+  //
+  // Update the component name for this child handle.
+  //
+  Status = UpdateName (Mnp);
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+  return LookupUnicodeString2 (
+           Language,
+           This->SupportedLanguages,
+           gMnpControllerNameTable,
+           ControllerName,
+           (BOOLEAN)(This == &gMnpComponentName)
+           );
+}

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/MnpDxe/ComponentName.h

-              r48674
+              r58459
   The header file of UEFI Component Name(2) protocol.
 Copyright (c) 2004 - 2011, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2004 - 2012, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions
 …
 extern EFI_COMPONENT_NAME2_PROTOCOL gMnpComponentName2;
 extern EFI_COMPONENT_NAME_PROTOCOL  gMnpComponentName;
+extern EFI_UNICODE_STRING_TABLE     *gMnpControllerNameTable;
 /**

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/MnpDxe/MnpConfig.c

-              r48674
+              r58459
   Implementation of Managed Network Protocol private services.
 Copyright (c) 2005 - 2010, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2005 - 2012, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions
 …
 };
 /**
   Add Count of net buffers to MnpDeviceData->FreeNbufQue. The length of the net
 …
 /**
+  Callback function which provided by user to remove one node in NetDestroyLinkList process.
+  @param[in]    Entry           The entry to be removed.
+  @param[in]    Context         Pointer to the callback context corresponds to the Context in NetDestroyLinkList.
+  @retval EFI_SUCCESS           The entry has been removed successfully.
+  @retval Others                Fail to remove the entry.
+**/
+EFI_STATUS
+EFIAPI
+MnpDestoryChildEntry (
+  IN LIST_ENTRY         *Entry,
+  IN VOID               *Context
+  )
+{
+  MNP_INSTANCE_DATA             *Instance;
+  EFI_SERVICE_BINDING_PROTOCOL  *ServiceBinding;
+  ServiceBinding = (EFI_SERVICE_BINDING_PROTOCOL *) Context;
+  Instance = CR (Entry, MNP_INSTANCE_DATA, InstEntry, MNP_INSTANCE_DATA_SIGNATURE);
+  return ServiceBinding->DestroyChild (ServiceBinding, Instance->Handle);
+}
+/**
   Destroy all child of the MNP service data.
 …
+  )
+{
+  EFI_STATUS                    Status;
+  MNP_INSTANCE_DATA             *Instance;
+  EFI_SERVICE_BINDING_PROTOCOL  *ServiceBinding;
+  ServiceBinding = &MnpServiceData->ServiceBinding;
+  while (!IsListEmpty (&MnpServiceData->ChildrenList)) {
+    //
+    // Don't use NetListRemoveHead here, the remove opreration will be done
+    // in ServiceBindingDestroyChild.
+    //
+    Instance = NET_LIST_HEAD (
+                 &MnpServiceData->ChildrenList,
+                 MNP_INSTANCE_DATA,
+                 InstEntry
+                 );
+    Status = ServiceBinding->DestroyChild (ServiceBinding, Instance->Handle);
+    if (EFI_ERROR (Status)) {
+      return Status;
+    }
+  LIST_ENTRY                         *List;
+  EFI_STATUS                         Status;
+  UINTN                              ListLength;
+  List = &MnpServiceData->ChildrenList;
+  Status = NetDestroyLinkList (
+             List,
+             MnpDestoryChildEntry,
+             &MnpServiceData->ServiceBinding,
+             &ListLength
+             );
+  if (EFI_ERROR (Status) || ListLength != 0) {
+    return EFI_DEVICE_ERROR;
+  }

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/MnpDxe/MnpDriver.c

-              r48674
+              r58459
   Implementation of driver entry point and driver binding protocol.
 Copyright (c) 2005 - 2011, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2005 - 2012, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions
 …
 /**
+  Callback function which provided by user to remove one node in NetDestroyLinkList process.
+  @param[in]    Entry           The entry to be removed.
+  @param[in]    Context         Pointer to the callback context corresponds to the Context in NetDestroyLinkList.
+  @retval EFI_SUCCESS           The entry has been removed successfully.
+  @retval Others                Fail to remove the entry.
+**/
+EFI_STATUS
+EFIAPI
+MnpDestroyServiceDataEntry (
+  IN LIST_ENTRY         *Entry,
+  IN VOID               *Context
+  )
+{
+  MNP_SERVICE_DATA              *MnpServiceData;
+  MnpServiceData = MNP_SERVICE_DATA_FROM_LINK (Entry);
+  return MnpDestroyServiceData (MnpServiceData);
+}
+/**
+  Callback function which provided by user to remove one node in NetDestroyLinkList process.
+  @param[in]    Entry           The entry to be removed.
+  @param[in]    Context         Pointer to the callback context corresponds to the Context in NetDestroyLinkList.
+  @retval EFI_SUCCESS           The entry has been removed successfully.
+  @retval Others                Fail to remove the entry.
+**/
+EFI_STATUS
+EFIAPI
+MnpDestroyServiceChildEntry (
+  IN LIST_ENTRY         *Entry,
+  IN VOID               *Context
+  )
+{
+  MNP_SERVICE_DATA              *MnpServiceData;
+  MnpServiceData = MNP_SERVICE_DATA_FROM_LINK (Entry);
+  return MnpDestroyServiceChild (MnpServiceData);
+}
+/**
   Test to see if this driver supports ControllerHandle. This service
   is called by the EFI boot service ConnectController(). In
 …
   MNP_DEVICE_DATA               *MnpDeviceData;
   MNP_SERVICE_DATA              *MnpServiceData;
   BOOLEAN                       AllChildrenStopped;
   LIST_ENTRY                    *Entry;
+  LIST_ENTRY                    *List;
+  UINTN                         ListLength;
   //
 …
     // Destroy all MNP service data
     //
+    while (!IsListEmpty (&MnpDeviceData->ServiceList)) {
+      Entry = GetFirstNode (&MnpDeviceData->ServiceList);
+      MnpServiceData = MNP_SERVICE_DATA_FROM_LINK (Entry);
+      MnpDestroyServiceData (MnpServiceData);
+    List = &MnpDeviceData->ServiceList;
+    Status = NetDestroyLinkList (
+               List,
+               MnpDestroyServiceDataEntry,
+               NULL,
+               &ListLength
+               );
+    if (EFI_ERROR (Status) || ListLength !=0) {
+      return EFI_DEVICE_ERROR;
+    }
 …
     FreePool (MnpDeviceData);
+    if (gMnpControllerNameTable != NULL) {
+      FreeUnicodeStringTable (gMnpControllerNameTable);
+      gMnpControllerNameTable = NULL;
+    }
     return EFI_SUCCESS;
+  }
 …
   // Stop all MNP child
   //
+  AllChildrenStopped = TRUE;
+  NET_LIST_FOR_EACH (Entry, &MnpDeviceData->ServiceList) {
+    MnpServiceData = MNP_SERVICE_DATA_FROM_LINK (Entry);
+    Status = MnpDestroyServiceChild (MnpServiceData);
+    if (EFI_ERROR (Status)) {
+      AllChildrenStopped = FALSE;
+    }
+  }
+  if (!AllChildrenStopped) {
+  List = &MnpDeviceData->ServiceList;
+  Status = NetDestroyLinkList (
+             List,
+             MnpDestroyServiceChildEntry,
+             NULL,
+             &ListLength
+             );
+  if (EFI_ERROR (Status)) {
     return EFI_DEVICE_ERROR;
+  }

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/MnpDxe/MnpDriver.h

-              r48674
+              r58459
   Declaration of strctures and functions for MnpDxe driver.
 Copyright (c) 2005 - 2011, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2005 - 2012, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions
 …
 #include <Library/UefiRuntimeServicesTableLib.h>
 #include <Library/DevicePathLib.h>
+#include <Library/PrintLib.h>
 #include "ComponentName.h"
 #define MNP_DEVICE_DATA_SIGNATURE  SIGNATURE_32 ('M', 'n', 'p', 'D')
+//
+// Global Variables
+//
+extern  EFI_DRIVER_BINDING_PROTOCOL gMnpDriverBinding;
 typedef struct {

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/MnpDxe/MnpDxe.inf

-              r48674
+              r58459
 ## @file
 #  Component description file for Mnp module.
+#  This module produces EFI MNP Protocol, EFI MNP Servie Binding Protocol and EFI VLAN Protocol.
+#
+#  Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
+#  This module produces EFI Managed Network Protocol upon EFI Simple Network Protocol,
+#  to provide raw asynchronous network I/O services. It also produces EFI VLAN Protocol
+#  to provide manageability interface for VLAN configuration.
+#
+#  Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>
 #  This program and the accompanying materials
 #  are licensed and made available under the terms and conditions of the BSD License
 …
   INF_VERSION                    = 0x00010005
   BASE_NAME                      = MnpDxe
+  MODULE_UNI_FILE                = MnpDxe.uni
   FILE_GUID                      = 025BBFC7-E6A9-4b8b-82AD-6815A1AEAF4A
   MODULE_TYPE                    = UEFI_DRIVER
 …
 [Protocols]
+  gEfiManagedNetworkServiceBindingProtocolGuid  ## PRODUCES
+  gEfiSimpleNetworkProtocolGuid                 ## CONSUMES
+  gEfiManagedNetworkProtocolGuid                ## PRODUCES
+  gEfiVlanConfigProtocolGuid                    ## SOMETIMES_PRODUCES
+  gEfiManagedNetworkServiceBindingProtocolGuid  ## BY_START
+  gEfiSimpleNetworkProtocolGuid                 ## TO_START
+  gEfiManagedNetworkProtocolGuid                ## BY_START
+  ## BY_START
+  ## UNDEFINED # variable
+  gEfiVlanConfigProtocolGuid
+[UserExtensions.TianoCore."ExtraFiles"]
+  MnpDxeExtra.uni

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/MnpDxe/MnpIo.c

-              r48674
+              r58459
   Implementation of Managed Network Protocol I/O functions.
 Copyright (c) 2005 - 2010, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2005 - 2014, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions
 …
   MnpDerviceData = MnpServiceData->MnpDeviceData;
+  //
+  // Reserve space for vlan tag.
+  //
+  *PktBuf = MnpDerviceData->TxBuf + NET_VLAN_TAG_LEN;
   if ((TxData->DestinationAddress == NULL) && (TxData->FragmentCount == 1)) {
+    //
+    // Media header is in FragmentTable and there is only one fragment,
+    // use fragment buffer directly.
+    //
+    *PktBuf = TxData->FragmentTable[0].FragmentBuffer;
+    CopyMem (
+        *PktBuf,
+        TxData->FragmentTable[0].FragmentBuffer,
+        TxData->FragmentTable[0].FragmentLength
+        );
     *PktLen = TxData->FragmentTable[0].FragmentLength;
   } else {
 …
     // media header space if necessary.
     //
+    SnpMode = MnpDerviceData->Snp->Mode;
+    DstPos  = MnpDerviceData->TxBuf;
+    SnpMode = MnpDerviceData->Snp->Mode;
+    DstPos  = *PktBuf;
     *PktLen = 0;
     if (TxData->DestinationAddress != NULL) {
 …
     //
+    // Set the buffer pointer and the buffer length.
+    //
+    *PktBuf = MnpDerviceData->TxBuf;
+    // Set the buffer length.
+    //
     *PktLen += TxData->DataLength + TxData->HeaderLength;
+  }
 …
+  }
+  //
+  // Insert VLAN tag
+  //
+  MnpInsertVlanTag (MnpServiceData, TxData, &ProtocolType, &Packet, &Length);
+  if (MnpServiceData->VlanId != 0) {
+    //
+    // Insert VLAN tag
+    //
+    MnpInsertVlanTag (MnpServiceData, TxData, &ProtocolType, &Packet, &Length);
+  } else {
+    ProtocolType = TxData->ProtocolType;
+  }
   for (;;) {

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/MnpDxe/MnpVlan.c

-              r48674
+              r58459
   VLAN Config Protocol implementation and VLAN packet process routine.
 Copyright (c) 2009, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2009 - 2014, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions
 …
 /**
   Build the packet to transmit from the TxData passed in.
+  Build the vlan packet to transmit from the TxData passed in.
   @param  MnpServiceData         Pointer to the mnp service context data.
 …
   MNP_DEVICE_DATA         *MnpDeviceData;
   EFI_SIMPLE_NETWORK_MODE *SnpMode;
-  if (MnpServiceData->VlanId == 0) {
-    *ProtocolType = TxData->ProtocolType;
-    return ;
+  }
   MnpDeviceData = MnpServiceData->MnpDeviceData;
 …
                 MnpDeviceData->MacString,
                 &gEfiVlanConfigProtocolGuid,
                 EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
+                EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS,
                 NumberOfVlan * sizeof (VLAN_TCI),
                 VlanVariable

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/MnpDxe/MnpVlan.h

-              r48674
+              r58459
   Header file to be included by MnpVlan.c.
 Copyright (c) 2009, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2009 - 2013, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions
 …
 /**
   Build the packet to transmit from the TxData passed in.
+  Build the vlan packet to transmit from the TxData passed in.
   @param  MnpServiceData         Pointer to the mnp service context data.

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Mtftp4Dxe/ComponentName.c

-              r48674
+              r58459
   UEFI Component Name(2) protocol implementation for Mtftp4Dxe driver.
 Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
 **/
 #include "Mtftp4Driver.h"
+#include "Mtftp4Impl.h"
 //
 …
+  }
 };
+GLOBAL_REMOVE_IF_UNREFERENCED EFI_UNICODE_STRING_TABLE *gMtftp4ControllerNameTable = NULL;
 /**
 …
 /**
+  Update the component name for the Mtftp4 child handle.
+  @param  Mtftp4[in]                A pointer to the EFI_MTFTP4_PROTOCOL.
+  @retval EFI_SUCCESS               Update the ControllerNameTable of this instance successfully.
+  @retval EFI_INVALID_PARAMETER     The input parameter is invalid.
+**/
+EFI_STATUS
+UpdateName (
+  IN   EFI_MTFTP4_PROTOCOL             *Mtftp4
+  )
+{
+  EFI_STATUS                       Status;
+  CHAR16                           HandleName[80];
+  EFI_MTFTP4_MODE_DATA             ModeData;
+  if (Mtftp4 == NULL) {
+    return EFI_INVALID_PARAMETER;
+  }
+  //
+  // Format the child name into the string buffer as:
+  // MTFTPv4 (ServerIp=192.168.1.10, ServerPort=69)
+  //
+  Status = Mtftp4->GetModeData (Mtftp4, &ModeData);
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+  UnicodeSPrint (HandleName, sizeof (HandleName),
+    L"MTFTPv4 (ServerIp=%d.%d.%d.%d, ServerPort=%d)",
+    ModeData.ConfigData.ServerIp.Addr[0],
+    ModeData.ConfigData.ServerIp.Addr[1],
+    ModeData.ConfigData.ServerIp.Addr[2],
+    ModeData.ConfigData.ServerIp.Addr[3],
+    ModeData.ConfigData.InitialServerPort
+    );
+  if (gMtftp4ControllerNameTable != NULL) {
+    FreeUnicodeStringTable (gMtftp4ControllerNameTable);
+    gMtftp4ControllerNameTable = NULL;
+  }
+  Status = AddUnicodeString2 (
+             "eng",
+             gMtftp4ComponentName.SupportedLanguages,
+             &gMtftp4ControllerNameTable,
+             HandleName,
+             TRUE
+             );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+  return AddUnicodeString2 (
+           "en",
+           gMtftp4ComponentName2.SupportedLanguages,
+           &gMtftp4ControllerNameTable,
+           HandleName,
+           FALSE
+           );
+}
+/**
   Retrieves a Unicode string that is the user readable name of the controller
   that is being managed by a driver.
 …
+  )
+{
+  return EFI_UNSUPPORTED;
+  EFI_STATUS                    Status;
+  EFI_MTFTP4_PROTOCOL           *Mtftp4;
+  //
+  // Only provide names for child handles.
+  //
+  if (ChildHandle == NULL) {
+    return EFI_UNSUPPORTED;
+  }
+  //
+  // Make sure this driver produced ChildHandle
+  //
+  Status = EfiTestChildHandle (
+             ControllerHandle,
+             ChildHandle,
+             &gEfiUdp4ProtocolGuid
+             );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+  //
+  // Retrieve an instance of a produced protocol from ChildHandle
+  //
+  Status = gBS->OpenProtocol (
+                  ChildHandle,
+                  &gEfiMtftp4ProtocolGuid,
+                  (VOID **)&Mtftp4,
+                  NULL,
+                  NULL,
+                  EFI_OPEN_PROTOCOL_GET_PROTOCOL
+                  );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+  //
+  // Update the component name for this child handle.
+  //
+  Status = UpdateName (Mtftp4);
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+  return LookupUnicodeString2 (
+           Language,
+           This->SupportedLanguages,
+           gMtftp4ControllerNameTable,
+           ControllerName,
+           (BOOLEAN)(This == &gMtftp4ComponentName)
+           );
+}

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Mtftp4Dxe/Mtftp4Driver.c

-              r48674
+              r58459
   Implementation of Mtftp drivers.
 Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
   MtftpSb->Signature      = MTFTP4_SERVICE_SIGNATURE;
   MtftpSb->ServiceBinding = gMtftp4ServiceBindingTemplete;
-  MtftpSb->InDestory      = FALSE;
   MtftpSb->ChildrenNum    = 0;
   InitializeListHead (&MtftpSb->Children);
 …
+}
+/**
+  Callback function which provided by user to remove one node in NetDestroyLinkList process.
+  @param[in]    Entry           The entry to be removed.
+  @param[in]    Context         Pointer to the callback context corresponds to the Context in NetDestroyLinkList.
+  @retval EFI_SUCCESS           The entry has been removed successfully.
+  @retval Others                Fail to remove the entry.
+**/
+EFI_STATUS
+EFIAPI
+Mtftp4DestroyChildEntryInHandleBuffer (
+  IN LIST_ENTRY         *Entry,
+  IN VOID               *Context
+  )
+{
+  MTFTP4_PROTOCOL               *Instance;
+  EFI_SERVICE_BINDING_PROTOCOL  *ServiceBinding;
+  UINTN                         NumberOfChildren;
+  EFI_HANDLE                    *ChildHandleBuffer;
+  if (Entry == NULL || Context == NULL) {
+    return EFI_INVALID_PARAMETER;
+  }
+  Instance = NET_LIST_USER_STRUCT_S (Entry, MTFTP4_PROTOCOL, Link, MTFTP4_PROTOCOL_SIGNATURE);
+  ServiceBinding    = ((MTFTP4_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT *) Context)->ServiceBinding;
+  NumberOfChildren  = ((MTFTP4_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT *) Context)->NumberOfChildren;
+  ChildHandleBuffer = ((MTFTP4_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT *) Context)->ChildHandleBuffer;
+  if (!NetIsInHandleBuffer (Instance->Handle, NumberOfChildren, ChildHandleBuffer)) {
+    return EFI_SUCCESS;
+  }
+  return ServiceBinding->DestroyChild (ServiceBinding, Instance->Handle);
+}
 /**
 …
+  )
+{
   EFI_SERVICE_BINDING_PROTOCOL  *ServiceBinding;
   MTFTP4_SERVICE                *MtftpSb;
   MTFTP4_PROTOCOL               *Instance;
   EFI_HANDLE                    NicHandle;
   EFI_STATUS                    Status;
   EFI_TPL                       OldTpl;
+  EFI_SERVICE_BINDING_PROTOCOL               *ServiceBinding;
+  MTFTP4_SERVICE                             *MtftpSb;
+  EFI_HANDLE                                 NicHandle;
+  EFI_STATUS                                 Status;
+  LIST_ENTRY                                 *List;
+  MTFTP4_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT Context;
   //
 …
   if (NicHandle == NULL) {
     return EFI_DEVICE_ERROR;
+    return EFI_SUCCESS;
+  }
 …
   MtftpSb = MTFTP4_SERVICE_FROM_THIS (ServiceBinding);
+  if (MtftpSb->InDestory) {
+    return EFI_SUCCESS;
+  }
+  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
+  if (NumberOfChildren == 0) {
+    MtftpSb->InDestory = TRUE;
+  if (!IsListEmpty (&MtftpSb->Children)) {
+    //
+    // Destroy the Mtftp4 child instance in ChildHandleBuffer.
+    //
+    List = &MtftpSb->Children;
+    Context.ServiceBinding    = ServiceBinding;
+    Context.NumberOfChildren  = NumberOfChildren;
+    Context.ChildHandleBuffer = ChildHandleBuffer;
+    Status = NetDestroyLinkList (
+               List,
+               Mtftp4DestroyChildEntryInHandleBuffer,
+               &Context,
+               NULL
+               );
+  }
+  if (NumberOfChildren == 0 && IsListEmpty (&MtftpSb->Children)) {
     gBS->UninstallProtocolInterface (
            NicHandle,
 …
     Mtftp4CleanService (MtftpSb);
+    if (gMtftp4ControllerNameTable != NULL) {
+      FreeUnicodeStringTable (gMtftp4ControllerNameTable);
+      gMtftp4ControllerNameTable = NULL;
+    }
     FreePool (MtftpSb);
+  } else {
+    while (!IsListEmpty (&MtftpSb->Children)) {
+      Instance = NET_LIST_HEAD (&MtftpSb->Children, MTFTP4_PROTOCOL, Link);
+      Mtftp4ServiceBindingDestroyChild (ServiceBinding, Instance->Handle);
+    }
+    if (MtftpSb->ChildrenNum != 0) {
+      Status = EFI_DEVICE_ERROR;
+    }
+  }
+  gBS->RestoreTPL (OldTpl);
+    Status = EFI_SUCCESS;
+  }
   return Status;
+}
 …
   CopyMem (&Instance->Mtftp4, &gMtftp4ProtocolTemplate, sizeof (Instance->Mtftp4));
   Instance->State     = MTFTP4_STATE_UNCONFIGED;
-  Instance->InDestory = FALSE;
   Instance->Service   = MtftpSb;
 …
   if (EFI_ERROR (Status)) {
+    goto ON_ERROR;
+    UdpIoFreeIo (Instance->UnicastPort);
+    FreePool (Instance);
+    return Status;
+  }
 …
                   );
   if (EFI_ERROR (Status)) {
+    goto ON_ERROR;
+  }
+  //
+  // Open the Udp4 protocol by child.
+  //
+  Status = gBS->OpenProtocol (
+                  Instance->UnicastPort->UdpHandle,
+                  &gEfiUdp4ProtocolGuid,
+                  (VOID **) &Udp4,
+                  gMtftp4DriverBinding.DriverBindingHandle,
+                  Instance->Handle,
+                  EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
+                  );
+  if (EFI_ERROR (Status)) {
+    //
+    // Close the Udp4 protocol.
+    //
+    gBS->CloseProtocol (
+           MtftpSb->ConnectUdp->UdpHandle,
+           &gEfiUdp4ProtocolGuid,
+           gMtftp4DriverBinding.DriverBindingHandle,
+           ChildHandle
+           );
+    goto ON_ERROR;
+  }
+  //
+  // Add it to the parent's child list.
+  //
+  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
+  InsertTailList (&MtftpSb->Children, &Instance->Link);
+  MtftpSb->ChildrenNum++;
+  gBS->RestoreTPL (OldTpl);
+  return EFI_SUCCESS;
+ON_ERROR:
+  if (Instance->Handle != NULL) {
     gBS->UninstallMultipleProtocolInterfaces (
            Instance->Handle,
 …
            NULL
            );
+    goto ON_ERROR;
+  }
+  //
+  // Add it to the parent's child list.
+  //
+  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
+  InsertTailList (&MtftpSb->Children, &Instance->Link);
+  MtftpSb->ChildrenNum++;
+  gBS->RestoreTPL (OldTpl);
+ON_ERROR:
+  if (EFI_ERROR (Status)) {
+    UdpIoFreeIo (Instance->UnicastPort);
+    FreePool (Instance);
+  }
+  }
+  UdpIoFreeIo (Instance->UnicastPort);
+  FreePool (Instance);
   return Status;
 …
 /**
   Destory one of the service binding's child.
+  Destroy one of the service binding's child.
   @param  This                   The service binding instance
   @param  ChildHandle            The child handle to destory
+  @param  ChildHandle            The child handle to destroy
   @retval EFI_INVALID_PARAMETER  The parameter is invaid.
   @retval EFI_UNSUPPORTED        The child may have already been destoried.
   @retval EFI_SUCCESS            The child is destoried and removed from the
+  @retval EFI_UNSUPPORTED        The child may have already been destroyed.
+  @retval EFI_SUCCESS            The child is destroyed and removed from the
                                  parent's child list.
 …
+  }
   if (Instance->InDestory) {
+  if (Instance->InDestroy) {
     return EFI_SUCCESS;
+  }
   Instance->InDestory = TRUE;
+  Instance->InDestroy = TRUE;
   //
 …
          );
+  gBS->CloseProtocol (
+         Instance->UnicastPort->UdpHandle,
+         &gEfiUdp4ProtocolGuid,
+         gMtftp4DriverBinding.DriverBindingHandle,
+         ChildHandle
+         );
+  if (Instance->McastUdpPort != NULL) {
+    gBS->CloseProtocol (
+           Instance->McastUdpPort->UdpHandle,
+           &gEfiUdp4ProtocolGuid,
+           gMtftp4DriverBinding.DriverBindingHandle,
+           ChildHandle
+           );
+  }
   //
   // Uninstall the MTFTP4 protocol first to enable a top down destruction.
 …
   if (EFI_ERROR (Status)) {
     Instance->InDestory = FALSE;
+    Instance->InDestroy = FALSE;
     return Status;
+  }

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Mtftp4Dxe/Mtftp4Driver.h

-              r48674
+              r58459
   Mtftp drivers function header.
 Copyright (c) 2006 - 2007, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
 extern EFI_COMPONENT_NAME2_PROTOCOL  gMtftp4ComponentName2;
 extern EFI_DRIVER_BINDING_PROTOCOL   gMtftp4DriverBinding;
+extern EFI_UNICODE_STRING_TABLE      *gMtftp4ControllerNameTable;
 /**
 …
 /**
   Destory one of the service binding's child.
+  Destroy one of the service binding's child.
   @param  This                   The service binding instance
   @param  ChildHandle            The child handle to destory
+  @param  ChildHandle            The child handle to destroy
   @retval EFI_INVALID_PARAMETER  The parameter is invaid.
   @retval EFI_UNSUPPORTED        The child may have already been destoried.
   @retval EFI_SUCCESS            The child is destoried and removed from the
+  @retval EFI_UNSUPPORTED        The child may have already been destroyed.
+  @retval EFI_SUCCESS            The child is destroyed and removed from the
                                  parent's child list.

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Mtftp4Dxe/Mtftp4Dxe.inf

-              r48674
+              r58459
 ## @file
 # Component name for module Mtftp4
+#  This module produces EFI MTFTPv4 Protocol and EFI MTFTPv4 Service Binding Protocol.
+#
+# Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>
+#  This module produces EFI MTFTPv4 Protocol upon EFI UDPv4 Protocol, to provide
+#  basic services for client-side unicast and/or multicase TFTP operations.
+#
+#  Copyright (c) 2007 - 2014, Intel Corporation. All rights reserved.<BR>
 #  This program and the accompanying materials
 #  are licensed and made available under the terms and conditions of the BSD License
 …
   INF_VERSION                    = 0x00010005
   BASE_NAME                      = Mtftp4Dxe
+  MODULE_UNI_FILE                = Mtftp4Dxe.uni
   FILE_GUID                      = DC3641B8-2FA8-4ed3-BC1F-F9962A03454B
   MODULE_TYPE                    = UEFI_DRIVER
 …
 [Protocols]
   gEfiMtftp4ServiceBindingProtocolGuid          # PROTOCOL ALWAYS_CONSUMED
   gEfiMtftp4ProtocolGuid                        # PROTOCOL ALWAYS_CONSUMED
   gEfiUdp4ServiceBindingProtocolGuid            # PROTOCOL ALWAYS_CONSUMED
   gEfiUdp4ProtocolGuid                          # PROTOCOL ALWAYS_CONSUMED
+  gEfiMtftp4ServiceBindingProtocolGuid          ## BY_START
+  gEfiUdp4ServiceBindingProtocolGuid            ## TO_START
+  gEfiMtftp4ProtocolGuid                        ## BY_START
+  gEfiUdp4ProtocolGuid                          ## TO_START
+[UserExtensions.TianoCore."ExtraFiles"]
+  Mtftp4DxeExtra.uni

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Mtftp4Dxe/Mtftp4Impl.c

-              r48674
+              r58459
   Interface routine for Mtftp4.
 Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
   if (Instance->McastUdpPort != NULL) {
+    gBS->CloseProtocol (
+           Instance->McastUdpPort->UdpHandle,
+           &gEfiUdp4ProtocolGuid,
+           gMtftp4DriverBinding.DriverBindingHandle,
+           Instance->Handle
+           );
     UdpIoFreeIo (Instance->McastUdpPort);
     Instance->McastUdpPort = NULL;
 …
   EFI_STATUS                Status;
   UINT16                    OpCode;
+  EFI_MTFTP4_ERROR_HEADER  *ErrorHeader;
   State   = (MTFTP4_GETINFO_STATE *) Token->Context;
 …
   switch (OpCode) {
   case EFI_MTFTP4_OPCODE_ERROR:
+    ErrorHeader = (EFI_MTFTP4_ERROR_HEADER *) Packet;
+    if (ErrorHeader->ErrorCode == EFI_MTFTP4_ERRORCODE_FILE_NOT_FOUND) {
+      DEBUG ((EFI_D_ERROR, "TFTP error code 1 (File Not Found)\n"));
+    } else {
+      DEBUG ((EFI_D_ERROR, "TFTP error code %d\n", ErrorHeader->ErrorCode));
+    }
     State->Status = EFI_TFTP_ERROR;
     break;
 …
   if (Instance->State == MTFTP4_STATE_UNCONFIGED) {
     return EFI_NOT_STARTED;
   } else if (Instance->State == MTFTP4_STATE_DESTORY) {
+  } else if (Instance->State == MTFTP4_STATE_DESTROY) {
     return EFI_DEVICE_ERROR;
+  }

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Mtftp4Dxe/Mtftp4Impl.h

-              r48674
+              r58459
   RFC2349 - TFTP Timeout Interval and Transfer Size Options
 Copyright (c) 2006 - 2009, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
 #include <Library/UefiBootServicesTableLib.h>
 #include <Library/UdpIoLib.h>
+#include <Library/PrintLib.h>
 extern EFI_MTFTP4_PROTOCOL  gMtftp4ProtocolTemplate;
 …
 #define MTFTP4_STATE_UNCONFIGED     0
 #define MTFTP4_STATE_CONFIGED       1
 #define MTFTP4_STATE_DESTORY        2
+#define MTFTP4_STATE_DESTROY        2
 ///
 …
   UINT32                        Signature;
   EFI_SERVICE_BINDING_PROTOCOL  ServiceBinding;
-  BOOLEAN                       InDestory;
   UINT16                        ChildrenNum;
 …
   INTN                          State;
   BOOLEAN                       InDestory;
+  BOOLEAN                       InDestroy;
   MTFTP4_SERVICE                *Service;
 …
 };
+typedef struct {
+  EFI_SERVICE_BINDING_PROTOCOL  *ServiceBinding;
+  UINTN                         NumberOfChildren;
+  EFI_HANDLE                    *ChildHandleBuffer;
+} MTFTP4_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT;
 /**
   Clean up the MTFTP session to get ready for new operation.

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Mtftp4Dxe/Mtftp4Rrq.c

-              r48674
+              r58459
   Routines to process Rrq (download).
 Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
   EFI_STATUS                Status;
   INTN                      Expected;
+  EFI_UDP4_PROTOCOL         *Udp4;
   *Completed = FALSE;
 …
       Instance->McastIp      = Reply.McastIp;
       Instance->McastPort    = Reply.McastPort;
+      Instance->McastUdpPort = UdpIoCreateIo (
+                                 Instance->Service->Controller,
+                                 Instance->Service->Image,
+                                 Mtftp4RrqConfigMcastPort,
+                                 UDP_IO_UDP4_VERSION,
+                                 Instance
+                                 );
+      if (Instance->McastUdpPort == NULL) {
+        Instance->McastUdpPort = UdpIoCreateIo (
+                                   Instance->Service->Controller,
+                                   Instance->Service->Image,
+                                   Mtftp4RrqConfigMcastPort,
+                                   UDP_IO_UDP4_VERSION,
+                                   Instance
+                                   );
+        if (Instance->McastUdpPort != NULL) {
+          Status = gBS->OpenProtocol (
+                          Instance->McastUdpPort->UdpHandle,
+                          &gEfiUdp4ProtocolGuid,
+                          (VOID **) &Udp4,
+                          Instance->Service->Image,
+                          Instance->Handle,
+                          EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
+                          );
+          if (EFI_ERROR (Status)) {
+            UdpIoFreeIo (Instance->McastUdpPort);
+            Instance->McastUdpPort = NULL;
+            return EFI_DEVICE_ERROR;
+          }
+        }
+      }
       if (Instance->McastUdpPort == NULL) {
 …
   } else {
     Packet = (EFI_MTFTP4_PACKET *) NetbufGetByte (UdpPacket, 0, NULL);
+    ASSERT (Packet != NULL);
+  }

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Mtftp4Dxe/Mtftp4Support.c

-              r48674
+              r58459
   EFI_STATUS                Status;
   UINT16                    OpCode;
   UINT16                    Value;
+  UINT8                     *Buffer;
   //
 …
   // to the connected port
   //
+  Value = *((UINT16 *) NetbufGetByte (Packet, 0, NULL));
+  OpCode = NTOHS (Value);
+  Buffer = NetbufGetByte (Packet, 0, NULL);
+  ASSERT (Buffer != NULL);
+  OpCode = NTOHS (*(UINT16 *)Buffer);
   if ((OpCode == EFI_MTFTP4_OPCODE_RRQ) ||
 …
   EFI_STATUS                Status;
   UINT16                    OpCode;
   UINT16                    Value;
+  UINT8                     *Buffer;
   ASSERT (Instance->LastPacket != NULL);
 …
   // Set the requests to the listening port, other packets to the connected port
   //
+  Value = *(UINT16 *) NetbufGetByte (Instance->LastPacket, 0, NULL);
+  OpCode = NTOHS (Value);
+  Buffer = NetbufGetByte (Instance->LastPacket, 0, NULL);
+  ASSERT (Buffer != NULL);
+  OpCode = NTOHS (*(UINT16 *) Buffer);
   if ((OpCode == EFI_MTFTP4_OPCODE_RRQ) || (OpCode == EFI_MTFTP4_OPCODE_DIR) ||

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Mtftp4Dxe/Mtftp4Wrq.c

-              r48674
+              r58459
   Routines to process Wrq (upload).
 Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
   } else {
     Packet = (EFI_MTFTP4_PACKET *) NetbufGetByte (UdpPacket, 0, NULL);
+    ASSERT (Packet != NULL);
+  }

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/SnpDxe/Callback.c

-              r48674
+              r58459
 /** @file
   This file contains two sets of callback routines for undi3.0 and undi3.1.
+  This file contains the callback routines for undi3.1.
   the callback routines for Undi3.1 have an extra parameter UniqueId which
   stores the interface context for the NIC that snp is trying to talk.
 Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
 #include "Snp.h"
-//
-// Global variables
-// these 2 global variables are used only for 3.0 undi. we could not place
-// them in the snp structure because we will not know which snp structure
-// in the callback context!
-//
-BOOLEAN              mInitializeLock = TRUE;
-EFI_LOCK             mLock;
-//
-// End Global variables
-//
-extern EFI_PCI_IO_PROTOCOL  *mPciIo;
-/**
-  Convert a virtual or CPU address provided by SNP to a physical or device
-  address.
-  This is a callback routine supplied to UNDI at undi_start time. Since EFI uses
-  the identical mapping, this routine returns the physical address same as the
-  virtual address for most of the addresses. an address above 4GB cannot
-  generally be used as a device address, it needs to be mapped to a lower
-  physical address. This routine does not call the map routine itself, but it
-  assumes that the mapping was done at the time of providing the address to
-  UNDI. This routine just looks up the address in a map table (which is the v2p
-  structure chain).
-  @param  CpuAddr        Virtual address.
-  @param  DeviceAddrPtr  Pointer to the physical address, or 0 in case of any
-                         error.
-**/
-VOID
-EFIAPI
-SnpUndi32CallbackV2p30 (
-  IN UINT64     CpuAddr,
-  IN OUT UINT64 DeviceAddrPtr
+  )
+{
-  V2P  *V2p;
-  //
-  // Do nothing if virtual address is zero or physical pointer is NULL.
-  // No need to map if the virtual address is within 4GB limit since
-  // EFI uses identical mapping
-  //
-  if ((CpuAddr == 0) || (DeviceAddrPtr == 0)) {
-    DEBUG ((EFI_D_NET, "\nv2p: Null virtual address or physical pointer.\n"));
-    return ;
+  }
-  if (CpuAddr < FOUR_GIGABYTES) {
-    *(UINT64 *) (UINTN) DeviceAddrPtr = CpuAddr;
-    return ;
+  }
-  //
-  // SNP creates a vaddr tp paddr mapping at the time of calling undi with any
-  // big address, this callback routine just looks up in the v2p list and
-  // returns the physical address for any given virtual address.
-  //
-  if (FindV2p (&V2p, (VOID *) (UINTN) CpuAddr) != EFI_SUCCESS) {
-    *(UINT64 *) (UINTN) DeviceAddrPtr = CpuAddr;
-  } else {
-    *(UINT64 *) (UINTN) DeviceAddrPtr = V2p->PhysicalAddress;
+  }
+}
-/**
-  Acquire or release a lock of an exclusive access to a critical section of the
-  code/data.
-  This is a callback routine supplied to UNDI at undi_start time.
-  @param Enable   Non-zero indicates acquire; Zero indicates release.
-**/
-VOID
-EFIAPI
-SnpUndi32CallbackBlock30 (
-  IN UINT32 Enable
+  )
+{
-  //
-  // tcpip was calling snp at tpl_notify and if we acquire a lock that was
-  // created at a lower level (TPL_CALLBACK) it gives an assert!
-  //
-  if (mInitializeLock) {
-    EfiInitializeLock (&mLock, TPL_NOTIFY);
-    mInitializeLock = FALSE;
+  }
-  if (Enable != 0) {
-    EfiAcquireLock (&mLock);
-  } else {
-    EfiReleaseLock (&mLock);
+  }
+}
-/**
-  Delay MicroSeconds of micro seconds.
-  This is a callback routine supplied to UNDI at undi_start time.
-  @param MicroSeconds  Number of micro seconds to pause, ususlly multiple of 10.
-**/
-VOID
-EFIAPI
-SnpUndi32CallbackDelay30 (
-  IN UINT64 MicroSeconds
+  )
+{
-  if (MicroSeconds != 0) {
-    gBS->Stall ((UINTN) MicroSeconds);
+  }
+}
-/**
-  IO routine for UNDI.
-  This is a callback routine supplied to UNDI at undi_start time. This is not
-  currently being used by UNDI3.0 because Undi3.0 uses io/mem offsets relative
-  to the beginning of the device io/mem address and so it needs to use the
-  PCI_IO_FUNCTION that abstracts the start of the device's io/mem addresses.
-  Since SNP cannot retrive the context of the undi3.0 interface it cannot use
-  the PCI_IO_FUNCTION that specific for that NIC and uses one global IO
-  functions structure, this does not work. This however works fine for EFI1.0
-  Undis because they use absolute addresses for io/mem access.
-  @param ReadOrWrite  Indicates read or write, IO or Memory.
-  @param NumBytes     Number of bytes to read or write.
-  @param Address      IO or memory address to read from or write to.
-  @param BufferAddr   Memory location to read into or that contains the bytes to
-                      write.
-**/
-VOID
-EFIAPI
-SnpUndi32CallbackMemio30 (
-  IN UINT8      ReadOrWrite,
-  IN UINT8      NumBytes,
-  IN UINT64     Address,
-  IN OUT UINT64 BufferAddr
+  )
+{
-  EFI_PCI_IO_PROTOCOL_WIDTH Width;
-  switch (NumBytes) {
-  case 2:
-    Width = (EFI_PCI_IO_PROTOCOL_WIDTH) 1;
-    break;
-  case 4:
-    Width = (EFI_PCI_IO_PROTOCOL_WIDTH) 2;
-    break;
-  case 8:
-    Width = (EFI_PCI_IO_PROTOCOL_WIDTH) 3;
-    break;
-  default:
-    Width = (EFI_PCI_IO_PROTOCOL_WIDTH) 0;
+  }
-  switch (ReadOrWrite) {
-  case PXE_IO_READ:
-    mPciIo->Io.Read (
-                 mPciIo,
-                 Width,
-,    // BAR 1, IO base address
-                 Address,
-,    // count
-                 (VOID *) (UINTN) BufferAddr
-                 );
-    break;
-  case PXE_IO_WRITE:
-    mPciIo->Io.Write (
-                 mPciIo,
-                 Width,
-,    // BAR 1, IO base address
-                 Address,
-,    // count
-                 (VOID *) (UINTN) BufferAddr
-                 );
-    break;
-  case PXE_MEM_READ:
-    mPciIo->Mem.Read (
-                  mPciIo,
-                  Width,
-,  // BAR 0, Memory base address
-                  Address,
-,  // count
-                  (VOID *) (UINTN) BufferAddr
-                  );
-    break;
-  case PXE_MEM_WRITE:
-    mPciIo->Mem.Write (
-                  mPciIo,
-                  Width,
-,  // BAR 0, Memory base address
-                  Address,
-,  // count
-                  (VOID *) (UINTN) BufferAddr
-                  );
-    break;
+  }
-  return ;
+}
 /**

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/SnpDxe/ComponentName.c

-              r48674
+              r58459
     UEFI Component Name(2) protocol implementation for SnpDxe driver.
 Copyright (c) 2004 - 2011, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2004 - 2014, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials are licensed
 and made available under the terms and conditions of the BSD License which
 …
+  }
 };
+GLOBAL_REMOVE_IF_UNREFERENCED EFI_UNICODE_STRING_TABLE *gSimpleNetworkControllerNameTable = NULL;
 /**
 …
 /**
+  Update the component name for the Snp child handle.
+  @param  Snp[in]                   A pointer to the EFI_SIMPLE_NETWORK_PROTOCOL.
+  @retval EFI_SUCCESS               Update the ControllerNameTable of this instance successfully.
+  @retval EFI_INVALID_PARAMETER     The input parameter is invalid.
+**/
+EFI_STATUS
+UpdateName (
+  IN  EFI_SIMPLE_NETWORK_PROTOCOL   *Snp
+  )
+{
+  EFI_STATUS                       Status;
+  CHAR16                           HandleName[80];
+  UINTN                            OffSet;
+  UINTN                            Index;
+  if (Snp == NULL) {
+    return EFI_INVALID_PARAMETER;
+  }
+  OffSet = 0;
+  OffSet += UnicodeSPrint (
+              HandleName,
+              sizeof (HandleName),
+              L"SNP (MAC="
+              );
+  for (Index = 0; Index < Snp->Mode->HwAddressSize; Index++) {
+    OffSet += UnicodeSPrint (
+                HandleName + OffSet,
+                sizeof (HandleName) - OffSet * sizeof (CHAR16),
+                L"%02X-",
+                Snp->Mode->CurrentAddress.Addr[Index]
+                );
+  }
+  ASSERT (OffSet > 0);
+  //
+  // Remove the last '-'
+  //
+  OffSet--;
+  OffSet += UnicodeSPrint (
+              HandleName + OffSet,
+              sizeof (HandleName) - OffSet * sizeof (CHAR16),
+              L")"
+              );
+  if (gSimpleNetworkControllerNameTable != NULL) {
+    FreeUnicodeStringTable (gSimpleNetworkControllerNameTable);
+    gSimpleNetworkControllerNameTable = NULL;
+  }
+  Status = AddUnicodeString2 (
+             "eng",
+             gSimpleNetworkComponentName.SupportedLanguages,
+             &gSimpleNetworkControllerNameTable,
+             HandleName,
+             TRUE
+             );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+  return AddUnicodeString2 (
+           "en",
+           gSimpleNetworkComponentName2.SupportedLanguages,
+           &gSimpleNetworkControllerNameTable,
+           HandleName,
+           FALSE
+           );
+}
+/**
   Retrieves a Unicode string that is the user readable name of the controller
   that is being managed by a driver.
 …
+  )
+{
+  return EFI_UNSUPPORTED;
+  EFI_STATUS                    Status;
+  EFI_SIMPLE_NETWORK_PROTOCOL   *Snp;
+  if (ChildHandle != NULL) {
+    return EFI_UNSUPPORTED;
+  }
+  //
+  // Make sure this driver is currently managing ControllHandle
+  //
+  Status = EfiTestManagedDevice (
+             ControllerHandle,
+             gSimpleNetworkDriverBinding.DriverBindingHandle,
+             &gEfiSimpleNetworkProtocolGuid
+             );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+  //
+  // Retrieve an instance of a produced protocol from ControllerHandle
+  //
+  Status = gBS->OpenProtocol (
+                  ControllerHandle,
+                  &gEfiSimpleNetworkProtocolGuid,
+                  (VOID **)&Snp,
+                  NULL,
+                  NULL,
+                  EFI_OPEN_PROTOCOL_GET_PROTOCOL
+                  );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+  //
+  // Update the component name for this child handle.
+  //
+  Status = UpdateName (Snp);
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+  return LookupUnicodeString2 (
+           Language,
+           This->SupportedLanguages,
+           gSimpleNetworkControllerNameTable,
+           ControllerName,
+           (BOOLEAN)(This == &gSimpleNetworkComponentName)
+           );
+}

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/SnpDxe/Snp.c

-              r48674
+              r58459
   Implementation of driver entry point and driver binding protocol.
 Copyright (c) 2004 - 2011, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2004 - 2014, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials are licensed
 and made available under the terms and conditions of the BSD License which
 …
 #include "Snp.h"
-//
-//  Module global variables needed to support undi 3.0 interface
-//
-EFI_PCI_IO_PROTOCOL         *mPciIo;
-V2P                         *mV2p = NULL; // undi3.0 map_list head
-// End Global variables
-//
 /**
   One notified function to stop UNDI device when gBS->ExitBootServices() called.
   @param  Event                   Pointer to this event
   @param  Context                 Event hanlder private data
+  @param  Context                 Event handler private data
 **/
 …
   @retval EFI_SUCCESS          This driver is added to ControllerHandle
   @retval EFI_ALREADY_STARTED  This driver is already running on ControllerHandle
+  @retval EFI_DEVICE_ERROR     This driver could not be started due to a device error
   @retval other                This driver does not support this device
 …
   VOID                                      *Address;
   EFI_HANDLE                                Handle;
-  PXE_PCI_CONFIG_INFO                       ConfigInfo;
-  PCI_TYPE00                                *ConfigHeader;
-  UINT32                                    *TempBar;
   UINT8                                     BarIndex;
   PXE_STATFLAGS                             InitStatFlags;
+  EFI_PCI_IO_PROTOCOL                       *PciIo;
+  EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR         *BarDesc;
   DEBUG ((EFI_D_NET, "\nSnpNotifyNetworkInterfaceIdentifier()  "));
 …
                   Handle,
                   &gEfiPciIoProtocolGuid,
                   (VOID **) &mPciIo,
+                  (VOID **) &PciIo,
                   This->DriverBindingHandle,
                   Controller,
 …
   // Allocate and initialize a new simple network protocol structure.
   //
   Status = mPciIo->AllocateBuffer (
                         mPciIo,
                         AllocateAnyPages,
                         EfiBootServicesData,
                         SNP_MEM_PAGES (sizeof (SNP_DRIVER)),
                         &Address,
                         );
+  Status = PciIo->AllocateBuffer (
+                    PciIo,
+                    AllocateAnyPages,
+                    EfiBootServicesData,
+                    SNP_MEM_PAGES (sizeof (SNP_DRIVER)),
+                    &Address,
+                    );
   if (Status != EFI_SUCCESS) {
 …
   ZeroMem (Snp, sizeof (SNP_DRIVER));
   Snp->PciIo      = mPciIo;
+  Snp->PciIo      = PciIo;
   Snp->Signature  = SNP_DRIVER_SIGNATURE;
 …
   Snp->TxRxBufferSize     = 0;
   Snp->TxRxBuffer         = NULL;
+  Snp->IfNum              = Nii->IfNum;
+  if (Nii->Revision >= EFI_NETWORK_INTERFACE_IDENTIFIER_PROTOCOL_REVISION) {
+        Snp->IfNum = Nii->IfNum;
+  } else {
+    Snp->IfNum = (UINT8) (Nii->IfNum & 0xFF);
+  }
   if ((Pxe->hw.Implementation & PXE_ROMID_IMP_HW_UNDI) != 0) {
 …
   // interface as EFI does not multi-task and so SNP will not be re-entered!
   //
   Status = mPciIo->AllocateBuffer (
                         mPciIo,
                         AllocateAnyPages,
                         EfiBootServicesData,
                         SNP_MEM_PAGES (4096),
                         &Address,
                         );
+  Status = PciIo->AllocateBuffer (
+                    PciIo,
+                    AllocateAnyPages,
+                    EfiBootServicesData,
+                    SNP_MEM_PAGES (4096),
+                    &Address,
+                    );
   if (Status != EFI_SUCCESS) {
 …
   //
+  // PxeStart call is going to give the callback functions to UNDI, these callback
+  // functions use the BarIndex values from the snp structure, so these must be initialized
+  // with default values before doing a PxeStart. The correct values can be obtained after
+  // getting the config information from UNDI
+  // Find the correct BAR to do IO.
+  //
+  // Enumerate through the PCI BARs for the device to determine which one is
+  // the IO BAR.  Save the index of the BAR into the adapter info structure.
+  // for regular 32bit BARs, 0 is memory mapped, 1 is io mapped
   //
   Snp->MemoryBarIndex = 0;
   Snp->IoBarIndex     = 1;
+  //
+  // we need the undi init information many times in this snp code, just get it
+  // once here and store it in the snp driver structure. to get Init Info
+  // from UNDI we have to start undi first.
+  //
+  for (BarIndex = 0; BarIndex < PCI_MAX_BAR; BarIndex++) {
+    Status = PciIo->GetBarAttributes (
+                      PciIo,
+                      BarIndex,
+                      NULL,
+                      (VOID**) &BarDesc
+                      );
+    if (Status == EFI_UNSUPPORTED) {
+      continue;
+    } else if (EFI_ERROR (Status)) {
+      goto Error_DeleteSNP;
+    }
+    if (BarDesc->ResType == ACPI_ADDRESS_SPACE_TYPE_MEM) {
+      Snp->MemoryBarIndex = BarIndex;
+    } else if (BarDesc->ResType == ACPI_ADDRESS_SPACE_TYPE_IO) {
+      Snp->IoBarIndex = BarIndex;
+    }
+    FreePool (BarDesc);
+  }
   Status = PxeStart (Snp);
 …
     PxeStop (Snp);
     goto Error_DeleteSNP;
+  }
-  Snp->Cdb.OpCode     = PXE_OPCODE_GET_CONFIG_INFO;
-  Snp->Cdb.OpFlags    = PXE_OPFLAGS_NOT_USED;
-  Snp->Cdb.CPBsize    = PXE_CPBSIZE_NOT_USED;
-  Snp->Cdb.CPBaddr    = PXE_DBADDR_NOT_USED;
-  Snp->Cdb.DBsize     = (UINT16) sizeof (ConfigInfo);
-  Snp->Cdb.DBaddr     = (UINT64)(UINTN) &ConfigInfo;
-  Snp->Cdb.StatCode   = PXE_STATCODE_INITIALIZE;
-  Snp->Cdb.StatFlags  = PXE_STATFLAGS_INITIALIZE;
-  Snp->Cdb.IFnum      = Snp->IfNum;
-  Snp->Cdb.Control    = PXE_CONTROL_LAST_CDB_IN_LIST;
-  DEBUG ((EFI_D_NET, "\nSnp->undi.get_config_info()  "));
-  (*Snp->IssueUndi32Command) ((UINT64)(UINTN) &Snp->Cdb);
-  if (Snp->Cdb.StatCode != PXE_STATCODE_SUCCESS) {
-    DEBUG ((EFI_D_NET, "\nSnp->undi.config_info()  %xh:%xh\n", Snp->Cdb.StatFlags, Snp->Cdb.StatCode));
-    PxeStop (Snp);
-    goto Error_DeleteSNP;
+  }
-  //
-  // Find the correct BAR to do IO.
-  //
-  //
-  // Enumerate through the PCI BARs for the device to determine which one is
-  // the IO BAR.  Save the index of the BAR into the adapter info structure.
-  // for  regular 32bit BARs, 0 is memory mapped, 1 is io mapped
-  //
-  ConfigHeader  = (PCI_TYPE00 *) &ConfigInfo.Config.Byte[0];
-  TempBar       = (UINT32 *) &ConfigHeader->Device.Bar[0];
-  for (BarIndex = 0; BarIndex <= 5; BarIndex++) {
-    if ((*TempBar & PCI_BAR_MEM_MASK) == PCI_BAR_MEM_64BIT) {
-      //
-      // This is a 64-bit memory bar, skip this and the
-      // next bar as well.
-      //
-      TempBar++;
+    }
-    if ((*TempBar & PCI_BAR_IO_MASK) == PCI_BAR_IO_MODE) {
-      Snp->IoBarIndex = BarIndex;
-      break;
+    }
-    TempBar++;
+  }
 …
+  }
   Status = mPciIo->FreeBuffer (
                         mPciIo,
                         SNP_MEM_PAGES (4096),
                         Snp->Cpb
                         );
+  PciIo->FreeBuffer (
+           PciIo,
+           SNP_MEM_PAGES (4096),
+           Snp->Cpb
+           );
 Error_DeleteSNP:
   mPciIo->FreeBuffer (
                 mPciIo,
                 SNP_MEM_PAGES (sizeof (SNP_DRIVER)),
                 Snp
                 );
+  PciIo->FreeBuffer (
+           PciIo,
+           SNP_MEM_PAGES (sizeof (SNP_DRIVER)),
+           Snp
+           );
 NiiError:
   gBS->CloseProtocol (
 …
         Controller
         );
+  //
+  // If we got here that means we are in error state.
+  //
+  if (!EFI_ERROR (Status)) {
+    Status = EFI_DEVICE_ERROR;
+  }
   return Status;
 …
   EFI_SIMPLE_NETWORK_PROTOCOL *SnpProtocol;
   SNP_DRIVER                  *Snp;
+  EFI_PCI_IO_PROTOCOL         *PciIo;
   //
 …
   PxeStop (Snp);
+  mPciIo->FreeBuffer (
+                mPciIo,
+                SNP_MEM_PAGES (4096),
+                Snp->Cpb
+                );
+  mPciIo->FreeBuffer (
+                mPciIo,
+                SNP_MEM_PAGES (sizeof (SNP_DRIVER)),
+                Snp
+                );
+  PciIo = Snp->PciIo;
+  PciIo->FreeBuffer (
+           PciIo,
+           SNP_MEM_PAGES (4096),
+           Snp->Cpb
+           );
+  PciIo->FreeBuffer (
+           PciIo,
+           SNP_MEM_PAGES (sizeof (SNP_DRIVER)),
+           Snp
+           );
   return Status;
 …
 // Simple Network Protocol Driver Global Variables
 //
 EFI_DRIVER_BINDING_PROTOCOL mSimpleNetworkDriverBinding = {
+EFI_DRIVER_BINDING_PROTOCOL gSimpleNetworkDriverBinding = {
   SimpleNetworkDriverSupported,
   SimpleNetworkDriverStart,
 …
   NULL
 };
-/**
-  This routine maps the given CPU address to a Device address. It creates a
-  an entry in the map list with the virtual and physical addresses and the
-  un map cookie.
-  @param  V2p                  pointer to return a map list node pointer.
-  @param  Type                 the direction in which the data flows from the given
-                               virtual address device->cpu or cpu->device or both
-                               ways.
-  @param  VirtualAddress       virtual address (or CPU address) to be mapped.
-  @param  BufferSize           size of the buffer to be mapped.
-  @retval EFI_SUCEESS           routine has completed the mapping.
-  @retval EFI_INVALID_PARAMETER invalid parameter.
-  @retval EFI_OUT_OF_RESOURCES  out of resource.
-  @retval other                 error as indicated.
-**/
-EFI_STATUS
-AddV2P (
-  IN OUT V2P                    **V2p,
-  EFI_PCI_IO_PROTOCOL_OPERATION Type,
-  VOID                          *VirtualAddress,
-  UINTN                         BufferSize
+  )
+{
-  EFI_STATUS  Status;
-  if ((V2p == NULL) || (VirtualAddress == NULL) || (BufferSize == 0)) {
-    return EFI_INVALID_PARAMETER;
+  }
-  *V2p = AllocatePool (sizeof (V2P));
-  if (*V2p == NULL) {
-    return EFI_OUT_OF_RESOURCES;
+  }
-  Status = mPciIo->Map (
-                     mPciIo,
-                     Type,
-                     VirtualAddress,
-                     &BufferSize,
-                     &(*V2p)->PhysicalAddress,
-                     &(*V2p)->Unmap
-                     );
-  if (Status != EFI_SUCCESS) {
-    FreePool (*V2p);
-    return Status;
+  }
-  (*V2p)->VirtualAddress = VirtualAddress;
-  (*V2p)->BufferSize     = BufferSize;
-  (*V2p)->Next           = mV2p;
-  mV2p                   = *V2p;
-  return EFI_SUCCESS;
+}
-/**
-  This routine searches the linked list of mapped address nodes (for undi3.0
-  interface) to find the node that corresponds to the given virtual address and
-  returns a pointer to that node.
-  @param  V2p                  pointer to return a map list node pointer.
-  @param  VirtualAddr          virtual address (or CPU address) to be searched in
-                               the map list
-  @retval EFI_SUCEESS          A match was found.
-  @retval Other                A match cannot be found.
-**/
-EFI_STATUS
-FindV2p (
-  V2P          **V2p,
-  VOID         *VirtualAddr
+  )
+{
-  V2P    *Ptr;
-  if (V2p == NULL || VirtualAddr == NULL) {
-    return EFI_INVALID_PARAMETER;
+  }
-  for (Ptr = mV2p; Ptr != NULL; Ptr = Ptr->Next) {
-    if (Ptr->VirtualAddress == VirtualAddr) {
-      *V2p = Ptr;
-      return EFI_SUCCESS;
+    }
+  }
-  return EFI_NOT_FOUND;
+}
-/**
-  Unmap the given virtual address and free the memory allocated for the map list
-  node corresponding to that address.
-  @param  VirtualAddress       virtual address (or CPU address) to be unmapped.
-  @retval EFI_SUCEESS          Successfully unmapped.
-  @retval Other                Other errors as indicated.
-**/
-EFI_STATUS
-DelV2p (
-  VOID *VirtualAddress
+  )
+{
-  V2P           *Current;
-  V2P           *Next;
-  EFI_STATUS    Status;
-  if (VirtualAddress == NULL) {
-    return EFI_INVALID_PARAMETER;
+  }
-  if (mV2p == NULL) {
-    return EFI_NOT_FOUND;
+  }
-  //
-  // Is our node at the head of the list??
-  //
-  if ((Current = mV2p)->VirtualAddress == VirtualAddress) {
-    mV2p    = mV2p->Next;
-    Status  = mPciIo->Unmap (mPciIo, Current->Unmap);
-    FreePool (Current);
-    if (EFI_ERROR (Status)) {
-      DEBUG ((EFI_D_ERROR, "Unmap failed with status = %r\n", Status));
+    }
-    return Status;
+  }
-  for (; Current->Next != NULL; Current = Next) {
-    if ((Next = Current->Next)->VirtualAddress == VirtualAddress) {
-      Current->Next = Next->Next;
-      Status  = mPciIo->Unmap (mPciIo, Next->Unmap);
-      FreePool (Next);
-      if (EFI_ERROR (Status)) {
-        DEBUG ((EFI_D_ERROR, "Unmap failed with status = %r\n", Status));
+      }
-      return Status;
+    }
+  }
-  return EFI_NOT_FOUND;
+}
 /**
 …
            ImageHandle,
            SystemTable,
            &mSimpleNetworkDriverBinding,
+           &gSimpleNetworkDriverBinding,
            ImageHandle,
            &gSimpleNetworkComponentName,

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/SnpDxe/Snp.h

-              r48674
+              r58459
     Declaration of strctures and functions for SnpDxe driver.
 Copyright (c) 2004 - 2011, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2004 - 2014, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials are licensed
 and made available under the terms and conditions of the BSD License which
 …
 #include <Library/UefiLib.h>
 #include <Library/MemoryAllocationLib.h>
+#include <Library/PrintLib.h>
 #include <IndustryStandard/Pci.h>
+#include <IndustryStandard/Acpi.h>
 #define FOUR_GIGABYTES  (UINT64) 0x100000000ULL
 …
 // Global Variables
 //
+extern EFI_DRIVER_BINDING_PROTOCOL    gSimpleNetworkDriverBinding;
 extern EFI_COMPONENT_NAME_PROTOCOL    gSimpleNetworkComponentName;
 extern EFI_COMPONENT_NAME2_PROTOCOL   gSimpleNetworkComponentName2;
-//
-//  Virtual to physical mapping for all UNDI 3.0s.
-//
-typedef struct _V2P V2P;
-struct _V2P {
-  V2P                   *Next;
-  VOID                  *VirtualAddress;
-  UINTN                 BufferSize;
-  EFI_PHYSICAL_ADDRESS  PhysicalAddress;
-  VOID                  *Unmap;
-};
-/**
-  This routine maps the given CPU address to a Device address. It creates a
-  an entry in the map list with the virtual and physical addresses and the
-  un map cookie.
-  @param  V2p                  pointer to return a map list node pointer.
-  @param  Type                 the direction in which the data flows from the given
-                               virtual address device->cpu or cpu->device or both
-                               ways.
-  @param  VirtualAddress       virtual address (or CPU address) to be mapped.
-  @param  BufferSize           size of the buffer to be mapped.
-  @retval EFI_SUCEESS          routine has completed the mapping.
-  @retval other                error as indicated.
-**/
-EFI_STATUS
-AddV2p (
-  V2P                           **V2p,
-  EFI_PCI_IO_PROTOCOL_OPERATION Type,
-  VOID                          *VirtualAddress,
-  UINTN                         BufferSize
-  );
-/**
-  This routine searches the linked list of mapped address nodes (for undi3.0
-  interface) to find the node that corresponds to the given virtual address and
-  returns a pointer to that node.
-  @param  V2p                  pointer to return a map list node pointer.
-  @param  VirtualAddress                virtual address (or CPU address) to be searched in
-                               the map list
-  @retval EFI_SUCEESS          if a match found!
-  @retval Other                match not found
-**/
-EFI_STATUS
-FindV2p (
-  V2P          **V2p,
-  VOID         *VirtualAddress
-  );
 /**
 …
 PxeGetStnAddr (
   SNP_DRIVER *Snp
-  );
-/**
-  This routine unmaps the given virtual address and frees the memory allocated
-  for the map list node corresponding to that address.
-  @param  VirtualAddress       virtual address (or CPU address) to be unmapped
-  @retval EFI_SUCEESS          if successfully unmapped
-  @retval Other                as indicated by the error
-**/
-EFI_STATUS
-DelV2p (
-  VOID *VirtualAddress
-  );
-/**
-  This is a callback routine supplied to UNDI at undi_start time.
-  UNDI call this routine when it wants to have exclusive access to a critical
-  section of the code/data.
-  @param Enable   non-zero indicates acquire
-                  zero indicates release
-**/
-VOID
-EFIAPI
-SnpUndi32CallbackBlock30 (
-  IN UINT32 Enable
-  );
-/**
-  This is a callback routine supplied to UNDI at undi_start time.
-  UNDI call this routine with the number of micro seconds when it wants to
-  pause.
-  @param MicroSeconds  number of micro seconds to pause, ususlly multiple of 10.
-**/
-VOID
-EFIAPI
-SnpUndi32CallbackDelay30 (
-  IN UINT64 MicroSeconds
-  );
-/**
-  This is a callback routine supplied to UNDI at undi_start time.
-  This is the IO routine for UNDI. This is not currently being used by UNDI3.0
-  because Undi3.0 uses io/mem offsets relative to the beginning of the device
-  io/mem address and so it needs to use the PCI_IO_FUNCTION that abstracts the
-  start of the device's io/mem addresses. Since SNP cannot retrive the context
-  of the undi3.0 interface it cannot use the PCI_IO_FUNCTION that specific for
-  that NIC and uses one global IO functions structure, this does not work.
-  This however works fine for EFI1.0 Undis because they use absolute addresses
-  for io/mem access.
-  @param ReadOrWrite  indicates read or write, IO or Memory
-  @param NumBytes     number of bytes to read or write
-  @param Address      IO or memory address to read from or write to
-  @param BufferAddr   memory location to read into or that contains the bytes to
-                      write
-**/
-VOID
-EFIAPI
-SnpUndi32CallbackMemio30 (
-  IN UINT8      ReadOrWrite,
-  IN UINT8      NumBytes,
-  IN UINT64     Address,
-  IN OUT UINT64 BufferAddr
-  );
-/**
-  This is a callback routine supplied to UNDI at undi_start time.
-  UNDI call this routine with a virtual or CPU address that SNP provided to
-  convert it to a physical or device address. Since EFI uses the identical
-  mapping, this routine returns the physical address same as the virtual address
-  for most of the addresses. an address above 4GB cannot generally be used as a
-  device address, it needs to be mapped to a lower physical address. This
-  routine does not call the map routine itself, but it assumes that the mapping
-  was done at the time of providing the address to UNDI. This routine just
-  looks up the address in a map table (which is the v2p structure chain).
-  @param  CpuAddr        virtual address of a buffer.
-  @param  DeviceAddrPtr  pointer to the physical address.
-                         The DeviceAddrPtr will contain 0 in case of any error.
-**/
-VOID
-EFIAPI
-SnpUndi32CallbackV2p30 (
-  IN UINT64     CpuAddr,
-  IN OUT UINT64 DeviceAddrPtr
   );

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/SnpDxe/SnpDxe.inf

-              r48674
+              r58459
 ## @file
 #    Component description file for SNP module.
+#  This module produces EFI SNP Protocol.
+#
+# Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
+# This program and the accompanying materials are licensed
+# and made available under the terms and conditions of the BSD License which
+# accompanies this distribution. The full text of the license may be found at
+# http://opensource.org/licenses/bsd-license.php
+#  This module produces Simple Network Protocol upon EFI Network Interface
+#  Identifier Protocol, to provide a packet level interface to a network adapter.
+#
+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+#  Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>
+#  This program and the accompanying materials are licensed
+#  and made available under the terms and conditions of the BSD License which
+#  accompanies this distribution. The full text of the license may be found at
+#  http://opensource.org/licenses/bsd-license.php
+#
+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+#
 ##
 …
   INF_VERSION                    = 0x00010005
   BASE_NAME                      = SnpDxe
+  MODULE_UNI_FILE                = SnpDxe.uni
   FILE_GUID                      = A2f436EA-A127-4EF8-957C-8048606FF670
   MODULE_TYPE                    = UEFI_DRIVER
 …
 [Guids]
+  gEfiEventExitBootServicesGuid                 ## CONSUMES
+  gEfiEventExitBootServicesGuid                 ## SOMETIMES_CONSUMES ## Event
 [Protocols]
+  gEfiPciIoProtocolGuid                         # PROTOCOL ALWAYS_CONSUMED
+  gEfiSimpleNetworkProtocolGuid                 # PROTOCOL ALWAYS_CONSUMED
+  gEfiDevicePathProtocolGuid                    # PROTOCOL ALWAYS_CONSUMED
+  gEfiNetworkInterfaceIdentifierProtocolGuid_31 # PROTOCOL ALWAYS_CONSUMED
+  gEfiSimpleNetworkProtocolGuid                 ## BY_START
+  gEfiDevicePathProtocolGuid                    ## TO_START
+  gEfiNetworkInterfaceIdentifierProtocolGuid_31 ## TO_START
+  gEfiPciIoProtocolGuid                         ## TO_START
+[UserExtensions.TianoCore."ExtraFiles"]
+  SnpDxeExtra.uni

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/SnpDxe/Station_address.c

-              r48674
+              r58459
     Implementation of reading the MAC address of a network adapter.
 Copyright (c) 2004 - 2007, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2004 - 2014, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials are licensed
 and made available under the terms and conditions of the BSD License which
 …
     Snp->Cdb.CPBaddr  = PXE_CPBADDR_NOT_USED;
   } else {
+    Snp->Cdb.OpFlags = PXE_OPFLAGS_STATION_ADDRESS_READ;
+    //
+    // even though the OPFLAGS are set to READ, supplying a new address
+    // in the CPB will make undi change the mac address to the new one.
+    Snp->Cdb.OpFlags = PXE_OPFLAGS_STATION_ADDRESS_WRITE;
+    //
+    // Supplying a new address in the CPB will make undi change the mac address to the new one.
     //
     CopyMem (&Cpb->StationAddr, NewMacAddr, Snp->Mode.HwAddressSize);

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Tcp4Dxe/ComponentName.c

-              r48674
+              r58459
   UEFI Component Name(2) protocol implementation for Tcp4Dxe driver.
 Copyright (c) 2005 - 2011, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2005 - 2015, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
+  }
 };
+GLOBAL_REMOVE_IF_UNREFERENCED EFI_UNICODE_STRING_TABLE *gTcpControllerNameTable = NULL;
 /**
 …
 /**
+  Update the component name for the Tcp4 child handle.
+  @param  Tcp4[in]                   A pointer to the EFI_TCP4_PROTOCOL.
+  @retval EFI_SUCCESS                Update the ControllerNameTable of this instance successfully.
+  @retval EFI_INVALID_PARAMETER      The input parameter is invalid.
+**/
+EFI_STATUS
+UpdateName (
+  IN  EFI_TCP4_PROTOCOL             *Tcp4
+  )
+{
+  EFI_STATUS                       Status;
+  CHAR16                           HandleName[80];
+  EFI_TCP4_CONFIG_DATA             Tcp4ConfigData;
+  if (Tcp4 == NULL) {
+    return EFI_INVALID_PARAMETER;
+  }
+  //
+  // Format the child name into the string buffer as:
+  // TCPv4 (SrcPort=59, DestPort=60, ActiveFlag=TRUE)
+  //
+  ZeroMem (&Tcp4ConfigData, sizeof (Tcp4ConfigData));
+  Status = Tcp4->GetModeData (Tcp4, NULL, &Tcp4ConfigData, NULL, NULL, NULL);
+  if (!EFI_ERROR (Status)) {
+    UnicodeSPrint (HandleName, sizeof (HandleName),
+      L"TCPv4 (SrcPort=%d, DestPort=%d, ActiveFlag=%s)",
+      Tcp4ConfigData.AccessPoint.StationPort,
+      Tcp4ConfigData.AccessPoint.RemotePort,
+      (Tcp4ConfigData.AccessPoint.ActiveFlag ? L"TRUE" : L"FALSE")
+      );
+  } else if (Status == EFI_NOT_STARTED) {
+    UnicodeSPrint (
+      HandleName,
+      sizeof (HandleName),
+      L"TCPv4 (Not started)"
+      );
+  } else {
+    return Status;
+  }
+  if (gTcpControllerNameTable != NULL) {
+    FreeUnicodeStringTable (gTcpControllerNameTable);
+    gTcpControllerNameTable = NULL;
+  }
+  Status = AddUnicodeString2 (
+             "eng",
+             gTcp4ComponentName.SupportedLanguages,
+             &gTcpControllerNameTable,
+             HandleName,
+             TRUE
+             );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+  return AddUnicodeString2 (
+           "en",
+           gTcp4ComponentName2.SupportedLanguages,
+           &gTcpControllerNameTable,
+           HandleName,
+           FALSE
+           );
+}
+/**
   Retrieves a Unicode string that is the user readable name of the controller
   that is being managed by a driver.
 …
+  )
+{
+  return EFI_UNSUPPORTED;
+  EFI_STATUS                    Status;
+  EFI_TCP4_PROTOCOL             *Tcp4;
+  //
+  // Only provide names for child handles.
+  //
+  if (ChildHandle == NULL) {
+    return EFI_UNSUPPORTED;
+  }
+  //
+  // Make sure this driver produced ChildHandle
+  //
+  Status = EfiTestChildHandle (
+             ControllerHandle,
+             ChildHandle,
+             &gEfiIp4ProtocolGuid
+             );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+  //
+  // Retrieve an instance of a produced protocol from ChildHandle
+  //
+  Status = gBS->OpenProtocol (
+                  ChildHandle,
+                  &gEfiTcp4ProtocolGuid,
+                  (VOID **)&Tcp4,
+                  NULL,
+                  NULL,
+                  EFI_OPEN_PROTOCOL_GET_PROTOCOL
+                  );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+  //
+  // Update the component name for this child handle.
+  //
+  Status = UpdateName (Tcp4);
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+  return LookupUnicodeString2 (
+           Language,
+           This->SupportedLanguages,
+           gTcpControllerNameTable,
+           ControllerName,
+           (BOOLEAN)(This == &gTcp4ComponentName)
+           );
+}

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Tcp4Dxe/SockImpl.c

-              r48674
+              r58459
   Implementation of the Socket.
 Copyright (c) 2005 - 2009, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2005 - 2012, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
+  }
   //
   // Destory the RcvBuffer Queue and SendBuffer Queue
+  // Destroy the RcvBuffer Queue and SendBuffer Queue
   //
   NetbufQueFree (Sock->RcvBuffer.DataQueue);
 …
     DEBUG (
       (EFI_D_INFO,
       "SockDestory: Delete a unaccepted socket from parent"
+      "SockDestroy: Delete a unaccepted socket from parent"
       "now conncnt is %d\n",
       Sock->Parent->ConnCnt)

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Tcp4Dxe/SockInterface.c

-              r48674
+              r58459
   Interface function of the Socket.
 Copyright (c) 2005 - 2011, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2005 - 2012, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
 /**
   Destory the socket Sock and its associated protocol control block.
+  Destroy the socket Sock and its associated protocol control block.
   @param  Sock                 The socket to be destroyed.
 …
   ASSERT ((Sock != NULL) && (Sock->ProtoHandler != NULL));
   if (Sock->IsDestroyed) {
+  if (Sock->InDestroy) {
     return EFI_SUCCESS;
+  }
   Sock->IsDestroyed = TRUE;
+  Sock->InDestroy = TRUE;
   Status = EfiAcquireLockOrFail (&(Sock->Lock));
 …
       " failed with %r\n", Status));
     Sock->IsDestroyed = FALSE;
+    Sock->InDestroy = FALSE;
   } else if (SOCK_IS_CONFIGURED (Sock)) {

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Tcp4Dxe/Socket.h

-              r48674
+              r58459
   Socket header file.
 Copyright (c) 2005 - 2009, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2005 - 2012, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
 #include <Library/UefiLib.h>
 #include <Library/DpcLib.h>
+#include <Library/PrintLib.h>
 #define SOCK_SND_BUF        0
 …
   SOCK_BUFFER           RcvBuffer;  ///< Receive buffer of received data
   EFI_STATUS            SockError;  ///< The error returned by low layer protocol
   BOOLEAN               IsDestroyed;
+  BOOLEAN               InDestroy;
   //
 …
 /**
   Destory the socket Sock and its associated protocol control block.
+  Destroy the socket Sock and its associated protocol control block.
   @param  Sock                 The socket to be destroyed.

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Tcp4Dxe/Tcp4Dispatcher.c

-              r48674
+              r58459
   Tcp request dispatcher implementation.
 Copyright (c) 2005 - 2011, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2005 - 2014, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
+{
   SOCKET           *Sock;
-  TCP4_PROTO_DATA  *TcpProto;
   IpIoConfigIp (Tcb->IpInfo, NULL);
   Sock     = Tcb->Sk;
-  TcpProto = (TCP4_PROTO_DATA *) Sock->ProtoReserved;
   if (SOCK_IS_CONFIGURED (Sock)) {
 …
       FreePool (Sock->DevicePath);
+    }
-    TcpSetVariableData (TcpProto->TcpService);
+  }
 …
   TCP4_PROTO_DATA   *ProtoData;
   IP_IO             *IpIo;
+  EFI_STATUS        Status;
+  VOID              *Ip;
   Tcb = AllocateZeroPool (sizeof (TCP_CB));
 …
     FreePool (Tcb);
     return EFI_OUT_OF_RESOURCES;
+  }
+  //
+  // Open the new created IP instance BY_CHILD.
+  //
+  Status = gBS->OpenProtocol (
+                  Tcb->IpInfo->ChildHandle,
+                  &gEfiIp4ProtocolGuid,
+                  &Ip,
+                  IpIo->Image,
+                  Sk->SockHandle,
+                  EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
+                  );
+  if (EFI_ERROR (Status)) {
+    IpIoRemoveIp (IpIo, Tcb->IpInfo);
+    return Status;
+  }
 …
   Tcp4FlushPcb (Tcb);
+  //
+  // Close the IP protocol.
+  //
+  gBS->CloseProtocol (
+         Tcb->IpInfo->ChildHandle,
+         &gEfiIp4ProtocolGuid,
+         ProtoData->TcpService->IpIo->Image,
+         Sk->SockHandle
+         );
   IpIoRemoveIp (ProtoData->TcpService->IpIo, Tcb->IpInfo);
 …
     return Tcp4AttachPcb (Sock);
-    break;
   case SOCK_FLUSH:
 …
             );
-    break;
   case SOCK_MODE:
 …
     return Tcp4GetMode (Tcb, (TCP4_MODE_DATA *) Data);
-    break;
   case SOCK_ROUTE:

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Tcp4Dxe/Tcp4Driver.c

-              r48674
+              r58459
   Tcp driver function.
 Copyright (c) 2005 - 2011, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2005 - 2014, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
 extern EFI_COMPONENT_NAME_PROTOCOL    gTcp4ComponentName;
 extern EFI_COMPONENT_NAME2_PROTOCOL   gTcp4ComponentName2;
+extern EFI_UNICODE_STRING_TABLE       *gTcpControllerNameTable;
 TCP4_HEARTBEAT_TIMER  mTcp4Timer = {
 …
 /**
+  Callback function which provided by user to remove one node in NetDestroyLinkList process.
+  @param[in]    Entry           The entry to be removed.
+  @param[in]    Context         Pointer to the callback context corresponds to the Context in NetDestroyLinkList.
+  @retval EFI_SUCCESS           The entry has been removed successfully.
+  @retval Others                Fail to remove the entry.
+**/
+EFI_STATUS
+EFIAPI
+Tcp4DestroyChildEntryInHandleBuffer (
+  IN LIST_ENTRY         *Entry,
+  IN VOID               *Context
+  )
+{
+  SOCKET                        *Sock;
+  EFI_SERVICE_BINDING_PROTOCOL  *ServiceBinding;
+  UINTN                         NumberOfChildren;
+  EFI_HANDLE                    *ChildHandleBuffer;
+  if (Entry == NULL || Context == NULL) {
+    return EFI_INVALID_PARAMETER;
+  }
+  Sock = NET_LIST_USER_STRUCT_S (Entry, SOCKET, Link, SOCK_SIGNATURE);
+  ServiceBinding    = ((TCP4_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT *) Context)->ServiceBinding;
+  NumberOfChildren  = ((TCP4_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT *) Context)->NumberOfChildren;
+  ChildHandleBuffer = ((TCP4_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT *) Context)->ChildHandleBuffer;
+  if (!NetIsInHandleBuffer (Sock->SockHandle, NumberOfChildren, ChildHandleBuffer)) {
+    return EFI_SUCCESS;
+  }
+  return ServiceBinding->DestroyChild (ServiceBinding, Sock->SockHandle);
+}
+/**
   The entry point for Tcp4 driver, used to install Tcp4 driver on the ImageHandle.
 …
   InitializeListHead (&TcpServiceData->SocketList);
-  TcpSetVariableData (TcpServiceData);
   return EFI_SUCCESS;
 …
   if (TcpServiceData->IpIo != NULL) {
     IpIoDestroy (TcpServiceData->IpIo);
+    TcpServiceData->IpIo = NULL;
+  }
 …
+  )
+{
+  EFI_STATUS                          Status;
+  EFI_HANDLE                          NicHandle;
+  EFI_SERVICE_BINDING_PROTOCOL        *ServiceBinding;
+  TCP4_SERVICE_DATA                   *TcpServiceData;
+  SOCKET                              *Sock;
+  EFI_STATUS                                Status;
+  EFI_HANDLE                                NicHandle;
+  EFI_SERVICE_BINDING_PROTOCOL              *ServiceBinding;
+  TCP4_SERVICE_DATA                         *TcpServiceData;
+  LIST_ENTRY                                *List;
+  TCP4_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT  Context;
   // Find the NicHandle where Tcp4 ServiceBinding Protocol is installed.
 …
   NicHandle = NetLibGetNicHandle (ControllerHandle, &gEfiIp4ProtocolGuid);
   if (NicHandle == NULL) {
     return EFI_DEVICE_ERROR;
+    return EFI_SUCCESS;
+  }
 …
   TcpServiceData = TCP4_FROM_THIS (ServiceBinding);
+  if (NumberOfChildren == 0) {
+  if (NumberOfChildren != 0) {
+    List = &TcpServiceData->SocketList;
+    Context.ServiceBinding = ServiceBinding;
+    Context.NumberOfChildren = NumberOfChildren;
+    Context.ChildHandleBuffer = ChildHandleBuffer;
+    Status = NetDestroyLinkList (
+               List,
+               Tcp4DestroyChildEntryInHandleBuffer,
+               &Context,
+               NULL
+               );
+  } else if (IsListEmpty (&TcpServiceData->SocketList)) {
     //
     // Uninstall TCP servicebinding protocol
 …
     //
     IpIoDestroy (TcpServiceData->IpIo);
+    TcpServiceData->IpIo = NULL;
     //
 …
     Tcp4DestroyTimer ();
     //
     // Clear the variable.
     //
     TcpClearVariableData (TcpServiceData);
+    if (gTcpControllerNameTable != NULL) {
+      FreeUnicodeStringTable (gTcpControllerNameTable);
+      gTcpControllerNameTable = NULL;
+    }
     //
     // Release the TCP service data
     //
     FreePool (TcpServiceData);
+  } else {
+    while (!IsListEmpty (&TcpServiceData->SocketList)) {
+      Sock = NET_LIST_HEAD (&TcpServiceData->SocketList, SOCKET, Link);
+      ServiceBinding->DestroyChild (ServiceBinding, Sock->SockHandle);
+    }
+    Status = EFI_SUCCESS;
+  }
 …
                   TcpServiceData->DriverBindingHandle,
                   This->SockHandle,
                   EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
+                  EFI_OPEN_PROTOCOL_GET_PROTOCOL
                   );
   if (EFI_ERROR (Status)) {
 …
   //
-  // Close the device path protocol
-  //
-  gBS->CloseProtocol (
-         TcpServiceData->ControllerHandle,
-         &gEfiDevicePathProtocolGuid,
-         TcpServiceData->DriverBindingHandle,
-         This->SockHandle
-         );
-  //
   // Close the Ip4 protocol.
   //
 …
   EFI_TCP4_PROTOCOL  *Tcp4;
   SOCKET             *Sock;
-  EFI_TPL            OldTpl;
   if (NULL == This || NULL == ChildHandle) {
     return EFI_INVALID_PARAMETER;
+  }
-  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
   //
 …
+  }
-  gBS->RestoreTPL (OldTpl);
   return Status;
+}

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Tcp4Dxe/Tcp4Driver.h

-              r48674
+              r58459
   Tcp driver function header.
 Copyright (c) 2005 - 2011, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2005 - 2014, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
   EFI_SERVICE_BINDING_PROTOCOL  Tcp4ServiceBinding;
   EFI_HANDLE                    DriverBindingHandle;
-  CHAR16                        *MacString;
   LIST_ENTRY                    SocketList;
 } TCP4_SERVICE_DATA;

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Tcp4Dxe/Tcp4Dxe.inf

-              r48674
+              r58459
 ## @file
 # Component name for module Tcp4
+#  This module produces EFI TCPv4 Protocol and EFI TCPv4 Service Binding Protocol.
+#
 # FIX ME!
 # Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
+#  This module produces EFI TCPv4(Transmission Control Protocol version 4) Protocol
+#  upon EFI IPv4 Protocol, to provide basic TCPv4 I/O services.
+#
+#  Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>
 #  This program and the accompanying materials
 #  are licensed and made available under the terms and conditions of the BSD License
 …
   INF_VERSION                    = 0x00010005
   BASE_NAME                      = Tcp4Dxe
+  MODULE_UNI_FILE                = Tcp4Dxe.uni
   FILE_GUID                      = 6d6963ab-906d-4a65-a7ca-bd40e5d6af4d
   MODULE_TYPE                    = UEFI_DRIVER
 …
 [Protocols]
+  gEfiIp4ProtocolGuid                           # PROTOCOL ALWAYS_CONSUMED
+  gEfiTcp4ServiceBindingProtocolGuid            # PROTOCOL ALWAYS_PRODUCED
+  gEfiIp4ServiceBindingProtocolGuid             # PROTOCOL ALWAYS_CONSUMED
+  gEfiTcp4ProtocolGuid                          # PROTOCOL SOMETIMES_PRODUCED
+  gEfiTcp4ServiceBindingProtocolGuid            ## BY_START
+  gEfiIp4ServiceBindingProtocolGuid             ## TO_START
+  gEfiTcp4ProtocolGuid                          ## BY_START
+  gEfiIp4ProtocolGuid                           ## TO_START
+[UserExtensions.TianoCore."ExtraFiles"]
+  Tcp4DxeExtra.uni

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Tcp4Dxe/Tcp4Func.h

-              r48674
+              r58459
   Tcp function header file.
 Copyright (c) 2005 - 2009, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2005 - 2014, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
 /**
-  Set the Tdp4 variable data.
-  @param  Tcp4Service           Pointer to Tcp4 service data.
-  @retval EFI_OUT_OF_RESOURCES  There are not enough resources to set the variable.
-  @retval other                 Set variable failed.
-**/
-EFI_STATUS
-TcpSetVariableData (
-  IN TCP4_SERVICE_DATA  *Tcp4Service
-  );
-/**
-  Clear the variable and free the resource.
-  @param  Tcp4Service           Pointer to Tcp4 service data.
-**/
-VOID
-TcpClearVariableData (
-  IN TCP4_SERVICE_DATA  *Tcp4Service
-  );
-/**
   Install the device path protocol on the TCP instance.

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Tcp4Dxe/Tcp4Input.c

-              r48674
+              r58459
         NetbufFree (Nbuf);
         return -1;
-        break;
       default:
         break;
 …
   Head    = (TCP_HEAD *) NetbufGetByte (Nbuf, 0, NULL);
+  ASSERT (Head != NULL);
   Len     = Nbuf->TotalSize - (Head->HeadLen << 2);
 …
   Head = (TCP_HEAD *) NetbufGetByte (Nbuf, 0, NULL);
+  ASSERT (Head != NULL);
   Tcb = TcpLocateTcb (
           Head->DstPort,

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Tcp4Dxe/Tcp4Main.h

-              r48674
+              r58459
   TCP4 protocol services header file.
 Copyright (c) 2005 - 2011, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2005 - 2012, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
   EFI_IPv4_ADDRESS  *GatewayAddress;
 } TCP4_ROUTE_INFO;
+typedef struct {
+  EFI_SERVICE_BINDING_PROTOCOL  *ServiceBinding;
+  UINTN                         NumberOfChildren;
+  EFI_HANDLE                    *ChildHandleBuffer;
+} TCP4_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT;
 /**

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Tcp4Dxe/Tcp4Misc.c

-              r48674
+              r58459
   Misc support routines for tcp.
 Copyright (c) 2005 - 2011, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2005 - 2014, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
   LIST_ENTRY       *Head;
   TCP_CB           *Node;
-  TCP4_PROTO_DATA  *TcpProto;
   ASSERT (
 …
   InsertHeadList (Head, &Tcb->List);
-  TcpProto = (TCP4_PROTO_DATA *) Tcb->Sk->ProtoReserved;
-  TcpSetVariableData (TcpProto->TcpService);
   return 0;
+}
 …
   Seg       = TCPSEG_NETBUF (Nbuf);
   Head      = (TCP_HEAD *) NetbufGetByte (Nbuf, 0, NULL);
+  ASSERT (Head != NULL);
   Nbuf->Tcp = Head;
 …
   TcpSetState (Tcb, TCP_CLOSED);
+}
-/**
-  Set the Tdp4 variable data.
-  @param  Tcp4Service           Pointer to Tcp4 service data.
-  @retval EFI_OUT_OF_RESOURCES  There are not enough resources to set the variable.
-  @retval other                 Set variable failed.
-**/
-EFI_STATUS
-TcpSetVariableData (
-  IN TCP4_SERVICE_DATA  *Tcp4Service
+  )
+{
-  UINT32                  NumConfiguredInstance;
-  LIST_ENTRY              *Entry;
-  TCP_CB                  *TcpPcb;
-  TCP4_PROTO_DATA         *TcpProto;
-  UINTN                   VariableDataSize;
-  EFI_TCP4_VARIABLE_DATA  *Tcp4VariableData;
-  EFI_TCP4_SERVICE_POINT  *Tcp4ServicePoint;
-  CHAR16                  *NewMacString;
-  EFI_STATUS              Status;
-  NumConfiguredInstance = 0;
-  //
-  // Go through the running queue to count the instances.
-  //
-  NET_LIST_FOR_EACH (Entry, &mTcpRunQue) {
-    TcpPcb = NET_LIST_USER_STRUCT (Entry, TCP_CB, List);
-    TcpProto = (TCP4_PROTO_DATA *) TcpPcb->Sk->ProtoReserved;
-    if (TcpProto->TcpService == Tcp4Service) {
-      //
-      // This tcp instance belongs to the Tcp4Service.
-      //
-      NumConfiguredInstance++;
+    }
+  }
-  //
-  // Go through the listening queue to count the instances.
-  //
-  NET_LIST_FOR_EACH (Entry, &mTcpListenQue) {
-    TcpPcb = NET_LIST_USER_STRUCT (Entry, TCP_CB, List);
-    TcpProto = (TCP4_PROTO_DATA *) TcpPcb->Sk->ProtoReserved;
-    if (TcpProto->TcpService == Tcp4Service) {
-      //
-      // This tcp instance belongs to the Tcp4Service.
-      //
-      NumConfiguredInstance++;
+    }
+  }
-  //
-  // Calculate the size of the Tcp4VariableData. As there may be no Tcp4 child,
-  // we should add extra buffer for the service points only if the number of configured
-  // children is more than 1.
-  //
-  VariableDataSize = sizeof (EFI_TCP4_VARIABLE_DATA);
-  if (NumConfiguredInstance > 1) {
-    VariableDataSize += sizeof (EFI_TCP4_SERVICE_POINT) * (NumConfiguredInstance - 1);
+  }
-  Tcp4VariableData = AllocatePool (VariableDataSize);
-  if (Tcp4VariableData == NULL) {
-    return EFI_OUT_OF_RESOURCES;
+  }
-  Tcp4VariableData->DriverHandle = Tcp4Service->DriverBindingHandle;
-  Tcp4VariableData->ServiceCount = NumConfiguredInstance;
-  Tcp4ServicePoint = &Tcp4VariableData->Services[0];
-  //
-  // Go through the running queue to fill the service points.
-  //
-  NET_LIST_FOR_EACH (Entry, &mTcpRunQue) {
-    TcpPcb = NET_LIST_USER_STRUCT (Entry, TCP_CB, List);
-    TcpProto = (TCP4_PROTO_DATA *) TcpPcb->Sk->ProtoReserved;
-    if (TcpProto->TcpService == Tcp4Service) {
-      //
-      // This tcp instance belongs to the Tcp4Service.
-      //
-      Tcp4ServicePoint->InstanceHandle          = TcpPcb->Sk->SockHandle;
-      CopyMem (&Tcp4ServicePoint->LocalAddress, &TcpPcb->LocalEnd.Ip, sizeof (EFI_IPv4_ADDRESS));
-      Tcp4ServicePoint->LocalPort               = NTOHS (TcpPcb->LocalEnd.Port);
-      CopyMem (&Tcp4ServicePoint->RemoteAddress, &TcpPcb->RemoteEnd.Ip, sizeof (EFI_IPv4_ADDRESS));
-      Tcp4ServicePoint->RemotePort              = NTOHS (TcpPcb->RemoteEnd.Port);
-      Tcp4ServicePoint++;
+    }
+  }
-  //
-  // Go through the listening queue to fill the service points.
-  //
-  NET_LIST_FOR_EACH (Entry, &mTcpListenQue) {
-    TcpPcb = NET_LIST_USER_STRUCT (Entry, TCP_CB, List);
-    TcpProto = (TCP4_PROTO_DATA *) TcpPcb->Sk->ProtoReserved;
-    if (TcpProto->TcpService == Tcp4Service) {
-      //
-      // This tcp instance belongs to the Tcp4Service.
-      //
-      Tcp4ServicePoint->InstanceHandle          = TcpPcb->Sk->SockHandle;
-      CopyMem (&Tcp4ServicePoint->LocalAddress, &TcpPcb->LocalEnd.Ip, sizeof (EFI_IPv4_ADDRESS));
-      Tcp4ServicePoint->LocalPort               = NTOHS (TcpPcb->LocalEnd.Port);
-      CopyMem (&Tcp4ServicePoint->RemoteAddress, &TcpPcb->RemoteEnd.Ip, sizeof (EFI_IPv4_ADDRESS));
-      Tcp4ServicePoint->RemotePort              = NTOHS (TcpPcb->RemoteEnd.Port);
-      Tcp4ServicePoint++;
+    }
+  }
-  //
-  // Get the mac string.
-  //
-  Status = NetLibGetMacString (
-             Tcp4Service->ControllerHandle,
-             Tcp4Service->DriverBindingHandle,
-             &NewMacString
-             );
-  if (EFI_ERROR (Status)) {
-    goto ON_ERROR;
+  }
-  if (Tcp4Service->MacString != NULL) {
-    //
-    // The variable is set already, we're going to update it.
-    //
-    if (StrCmp (Tcp4Service->MacString, NewMacString) != 0) {
-      //
-      // The mac address is changed, delete the previous variable first.
-      //
-      gRT->SetVariable (
-             Tcp4Service->MacString,
-             &gEfiTcp4ServiceBindingProtocolGuid,
-             EFI_VARIABLE_BOOTSERVICE_ACCESS,
-,
-             NULL
-             );
+    }
-    FreePool (Tcp4Service->MacString);
+  }
-  Tcp4Service->MacString = NewMacString;
-  Status = gRT->SetVariable (
-                  Tcp4Service->MacString,
-                  &gEfiTcp4ServiceBindingProtocolGuid,
-                  EFI_VARIABLE_BOOTSERVICE_ACCESS,
-                  VariableDataSize,
-                  (VOID *) Tcp4VariableData
-                  );
-ON_ERROR:
-  FreePool (Tcp4VariableData);
-  return Status;
+}
-/**
-  Clear the variable and free the resource.
-  @param  Tcp4Service           Pointer to Tcp4 service data.
-**/
-VOID
-TcpClearVariableData (
-  IN TCP4_SERVICE_DATA  *Tcp4Service
+  )
+{
-  ASSERT (Tcp4Service->MacString != NULL);
-  gRT->SetVariable (
-         Tcp4Service->MacString,
-         &gEfiTcp4ServiceBindingProtocolGuid,
-         EFI_VARIABLE_BOOTSERVICE_ACCESS,
-,
-         NULL
-         );
-  FreePool (Tcp4Service->MacString);
-  Tcp4Service->MacString = NULL;
+}

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Udp4Dxe/ComponentName.c

-              r48674
+              r58459
 /** @file
 Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
 };
+GLOBAL_REMOVE_IF_UNREFERENCED EFI_UNICODE_STRING_TABLE *gUdpControllerNameTable = NULL;
 /**
   Retrieves a Unicode string that is the user readable name of the driver.
 …
 /**
+  Update the component name for the Udp4 child handle.
+  @param  Udp4[in]                   A pointer to the EFI_UDP4_PROTOCOL.
+  @retval EFI_SUCCESS                Update the ControllerNameTable of this instance successfully.
+  @retval EFI_INVALID_PARAMETER      The input parameter is invalid.
+**/
+EFI_STATUS
+UpdateName (
+  EFI_UDP4_PROTOCOL             *Udp4
+  )
+{
+  EFI_STATUS                       Status;
+  CHAR16                           HandleName[64];
+  EFI_UDP4_CONFIG_DATA             Udp4ConfigData;
+  if (Udp4 == NULL) {
+    return EFI_INVALID_PARAMETER;
+  }
+  //
+  // Format the child name into the string buffer as:
+  // UDPv4 (SrcPort=59, DestPort=60)
+  //
+  Status = Udp4->GetModeData (Udp4, &Udp4ConfigData, NULL, NULL, NULL);
+  if (!EFI_ERROR (Status)) {
+    UnicodeSPrint (HandleName, sizeof (HandleName),
+      L"UDPv4 (SrcPort=%d, DestPort=%d)",
+      Udp4ConfigData.StationPort,
+      Udp4ConfigData.RemotePort
+      );
+  } else if (Status == EFI_NOT_STARTED) {
+    UnicodeSPrint (
+      HandleName,
+      sizeof (HandleName),
+      L"UDPv4 (Not started)"
+      );
+  } else {
+    return Status;
+  }
+  if (gUdpControllerNameTable != NULL) {
+    FreeUnicodeStringTable (gUdpControllerNameTable);
+    gUdpControllerNameTable = NULL;
+  }
+  Status = AddUnicodeString2 (
+             "eng",
+             gUdp4ComponentName.SupportedLanguages,
+             &gUdpControllerNameTable,
+             HandleName,
+             TRUE
+             );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+  return AddUnicodeString2 (
+           "en",
+           gUdp4ComponentName2.SupportedLanguages,
+           &gUdpControllerNameTable,
+           HandleName,
+           FALSE
+           );
+}
+/**
   Retrieves a Unicode string that is the user readable name of the controller
   that is being managed by a driver.
 …
+  )
+{
+  return EFI_UNSUPPORTED;
+  EFI_STATUS                    Status;
+  EFI_UDP4_PROTOCOL             *Udp4;
+  //
+  // Only provide names for child handles.
+  //
+  if (ChildHandle == NULL) {
+    return EFI_UNSUPPORTED;
+  }
+  //
+  // Make sure this driver produced ChildHandle
+  //
+  Status = EfiTestChildHandle (
+             ControllerHandle,
+             ChildHandle,
+             &gEfiIp4ProtocolGuid
+             );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+  //
+  // Retrieve an instance of a produced protocol from ChildHandle
+  //
+  Status = gBS->OpenProtocol (
+                  ChildHandle,
+                  &gEfiUdp4ProtocolGuid,
+                  (VOID **)&Udp4,
+                  NULL,
+                  NULL,
+                  EFI_OPEN_PROTOCOL_GET_PROTOCOL
+                  );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+  //
+  // Update the component name for this child handle.
+  //
+  Status = UpdateName (Udp4);
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+  return LookupUnicodeString2 (
+           Language,
+           This->SupportedLanguages,
+           gUdpControllerNameTable,
+           ControllerName,
+           (BOOLEAN)(This == &gUdp4ComponentName)
+           );
+}

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Udp4Dxe/Udp4Driver.c

-              r48674
+              r58459
 /** @file
 Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
 };
+/**
+  Callback function which provided by user to remove one node in NetDestroyLinkList process.
+  @param[in]    Entry           The entry to be removed.
+  @param[in]    Context         Pointer to the callback context corresponds to the Context in NetDestroyLinkList.
+  @retval EFI_SUCCESS           The entry has been removed successfully.
+  @retval Others                Fail to remove the entry.
+**/
+EFI_STATUS
+EFIAPI
+Udp4DestroyChildEntryInHandleBuffer (
+  IN LIST_ENTRY         *Entry,
+  IN VOID               *Context
+  )
+{
+  UDP4_INSTANCE_DATA            *Instance;
+  EFI_SERVICE_BINDING_PROTOCOL  *ServiceBinding;
+  UINTN                         NumberOfChildren;
+  EFI_HANDLE                    *ChildHandleBuffer;
+  if (Entry == NULL || Context == NULL) {
+    return EFI_INVALID_PARAMETER;
+  }
+  Instance = NET_LIST_USER_STRUCT_S (Entry, UDP4_INSTANCE_DATA, Link, UDP4_INSTANCE_DATA_SIGNATURE);
+  ServiceBinding    = ((UDP4_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT *) Context)->ServiceBinding;
+  NumberOfChildren  = ((UDP4_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT *) Context)->NumberOfChildren;
+  ChildHandleBuffer = ((UDP4_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT *) Context)->ChildHandleBuffer;
+  if (!NetIsInHandleBuffer (Instance->ChildHandle, NumberOfChildren, ChildHandleBuffer)) {
+    return EFI_SUCCESS;
+  }
+  return ServiceBinding->DestroyChild (ServiceBinding, Instance->ChildHandle);
+}
 /**
 …
     Udp4CleanService (Udp4Service);
     FreePool (Udp4Service);
-  } else {
-    Udp4SetVariableData (Udp4Service);
+  }
 …
+  )
+{
+  EFI_STATUS                    Status;
+  EFI_HANDLE                    NicHandle;
+  EFI_SERVICE_BINDING_PROTOCOL  *ServiceBinding;
+  UDP4_SERVICE_DATA             *Udp4Service;
+  UDP4_INSTANCE_DATA            *Instance;
+  EFI_STATUS                                Status;
+  EFI_HANDLE                                NicHandle;
+  EFI_SERVICE_BINDING_PROTOCOL              *ServiceBinding;
+  UDP4_SERVICE_DATA                         *Udp4Service;
+  UDP4_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT  Context;
+  LIST_ENTRY                                *List;
   //
 …
   NicHandle = NetLibGetNicHandle (ControllerHandle, &gEfiIp4ProtocolGuid);
   if (NicHandle == NULL) {
     return EFI_DEVICE_ERROR;
+    return EFI_SUCCESS;
+  }
 …
   Udp4Service = UDP4_SERVICE_DATA_FROM_THIS (ServiceBinding);
+  if (NumberOfChildren == 0) {
+  if (NumberOfChildren != 0) {
+    //
+    // NumberOfChildren is not zero, destroy the children instances in ChildHandleBuffer.
+    //
+    List = &Udp4Service->ChildrenList;
+    Context.ServiceBinding    = ServiceBinding;
+    Context.NumberOfChildren  = NumberOfChildren;
+    Context.ChildHandleBuffer = ChildHandleBuffer;
+    Status = NetDestroyLinkList (
+               List,
+               Udp4DestroyChildEntryInHandleBuffer,
+               &Context,
+               NULL
+               );
+  } else {
     gBS->UninstallMultipleProtocolInterfaces (
            NicHandle,
 …
            NULL
            );
+    Udp4ClearVariableData (Udp4Service);
     Udp4CleanService (Udp4Service);
+    if (gUdpControllerNameTable != NULL) {
+      FreeUnicodeStringTable (gUdpControllerNameTable);
+      gUdpControllerNameTable = NULL;
+    }
     FreePool (Udp4Service);
-  } else {
-    while (!IsListEmpty (&Udp4Service->ChildrenList)) {
-      Instance = NET_LIST_HEAD (&Udp4Service->ChildrenList, UDP4_INSTANCE_DATA, Link);
-      ServiceBinding->DestroyChild (ServiceBinding, Instance->ChildHandle);
+    }
+  }
 …
+  }
+  //
+  // Open this instance's Ip4 protocol in the IpInfo BY_CHILD.
+  //
+  Status = gBS->OpenProtocol (
+                  Instance->IpInfo->ChildHandle,
+                  &gEfiIp4ProtocolGuid,
+                  (VOID **) &Ip4,
+                  gUdp4DriverBinding.DriverBindingHandle,
+                  Instance->ChildHandle,
+                  EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
+                  );
+  if (EFI_ERROR (Status)) {
+    goto ON_ERROR;
+  }
   OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 …
   Instance = UDP4_INSTANCE_DATA_FROM_THIS (Udp4Proto);
   if (Instance->Destroyed) {
+  if (Instance->InDestroy) {
     return EFI_SUCCESS;
+  }
 …
   // Use the Destroyed flag to avoid the re-entering of the following code.
   //
   Instance->Destroyed = TRUE;
+  Instance->InDestroy = TRUE;
   //
 …
          Instance->ChildHandle
          );
+  //
+  // Close the Ip4 protocol on this instance's IpInfo.
+  //
+  gBS->CloseProtocol (
+         Instance->IpInfo->ChildHandle,
+         &gEfiIp4ProtocolGuid,
+         gUdp4DriverBinding.DriverBindingHandle,
+         Instance->ChildHandle
+         );
   //
 …
                   );
   if (EFI_ERROR (Status)) {
     Instance->Destroyed = FALSE;
+    Instance->InDestroy = FALSE;
     return Status;
+  }

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Udp4Dxe/Udp4Dxe.inf

-              r48674
+              r58459
 ## @file
 # Component name for module Udp4
+#  This module produces EFI UDP Protocol and EFI UDPv4 Service Binding Protocol.
+#
 # FIX ME!
 # Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
+#  This module produces EFI UDP(User Datagram Protocol) Protocol upon EFI IPv4
+#  Protocol, to provide basic UDPv4 I/O services.
+#
+#  Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>
 #  This program and the accompanying materials
 #  are licensed and made available under the terms and conditions of the BSD License
 …
   INF_VERSION                    = 0x00010005
   BASE_NAME                      = Udp4Dxe
+  MODULE_UNI_FILE                = Udp4Dxe.uni
   FILE_GUID                      = 6d6963ab-906d-4a65-a7ca-bd40e5d6af2b
   MODULE_TYPE                    = UEFI_DRIVER
 …
 [Protocols]
+  gEfiIp4ProtocolGuid                           # PROTOCOL ALWAYS_CONSUMED
+  gEfiUdp4ServiceBindingProtocolGuid            # PROTOCOL ALWAYS_CONSUMED
+  gEfiIp4ServiceBindingProtocolGuid             # PROTOCOL ALWAYS_CONSUMED
+  gEfiUdp4ProtocolGuid                          # PROTOCOL ALWAYS_CONSUMED
+  gEfiUdp4ServiceBindingProtocolGuid            ## BY_START
+  gEfiIp4ServiceBindingProtocolGuid             ## TO_START
+  gEfiUdp4ProtocolGuid                          ## BY_START
+  gEfiIp4ProtocolGuid                           ## TO_START
+[UserExtensions.TianoCore."ExtraFiles"]
+  Udp4DxeExtra.uni

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Udp4Dxe/Udp4Impl.c

-              r48674
+              r58459
   The implementation of the Udp4 protocol.
 Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
   Instance->Configured  = FALSE;
   Instance->IsNoMapping = FALSE;
   Instance->Destroyed   = FALSE;
+  Instance->InDestroy   = FALSE;
+}
 …
   //
   Udp4Header = (EFI_UDP_HEADER *) NetbufGetByte (Packet, 0, NULL);
+  ASSERT (Udp4Header != NULL);
   if (Udp4Header->Checksum != 0) {
 …
+    }
+  }
-  gRT->GetTime (&RxData.TimeStamp, NULL);
   Udp4Session                  = &RxData.UdpSession;
 …
   Udp4Header = (EFI_UDP_HEADER *) NetbufGetByte (Packet, 0, NULL);
+  ASSERT (Udp4Header != NULL);
   CopyMem (&Udp4Session.SourceAddress, &NetSession->Source, sizeof (EFI_IPv4_ADDRESS));
 …
+}
-/**
-  Set the Udp4 variable data.
-  @param[in] Udp4Service         Udp4 service data.
-  @retval EFI_OUT_OF_RESOURCES   There are not enough resources to set the
-                                 variable.
-  @retval EFI_SUCCESS            Set variable successfully.
-  @retval other                  Set variable failed.
-**/
-EFI_STATUS
-Udp4SetVariableData (
-  IN UDP4_SERVICE_DATA  *Udp4Service
+  )
+{
-  UINT32                  NumConfiguredInstance;
-  LIST_ENTRY              *Entry;
-  UINTN                   VariableDataSize;
-  EFI_UDP4_VARIABLE_DATA  *Udp4VariableData;
-  EFI_UDP4_SERVICE_POINT  *Udp4ServicePoint;
-  UDP4_INSTANCE_DATA      *Udp4Instance;
-  CHAR16                  *NewMacString;
-  EFI_STATUS              Status;
-  NumConfiguredInstance = 0;
-  //
-  // Go through the children list to count the configured children.
-  //
-  NET_LIST_FOR_EACH (Entry, &Udp4Service->ChildrenList) {
-    Udp4Instance = NET_LIST_USER_STRUCT_S (
-                     Entry,
-                     UDP4_INSTANCE_DATA,
-                     Link,
-                     UDP4_INSTANCE_DATA_SIGNATURE
-                     );
-    if (Udp4Instance->Configured) {
-      NumConfiguredInstance++;
+    }
+  }
-  //
-  // Calculate the size of the Udp4VariableData. As there may be no Udp4 child,
-  // we should add extra buffer for the service points only if the number of configured
-  // children is more than 1.
-  //
-  VariableDataSize = sizeof (EFI_UDP4_VARIABLE_DATA);
-  if (NumConfiguredInstance > 1) {
-    VariableDataSize += sizeof (EFI_UDP4_SERVICE_POINT) * (NumConfiguredInstance - 1);
+  }
-  Udp4VariableData = AllocatePool (VariableDataSize);
-  if (Udp4VariableData == NULL) {
-    return EFI_OUT_OF_RESOURCES;
+  }
-  Udp4VariableData->DriverHandle = Udp4Service->ImageHandle;
-  Udp4VariableData->ServiceCount = NumConfiguredInstance;
-  Udp4ServicePoint = &Udp4VariableData->Services[0];
-  //
-  // Go through the children list to fill the configured children's address pairs.
-  //
-  NET_LIST_FOR_EACH (Entry, &Udp4Service->ChildrenList) {
-    Udp4Instance = NET_LIST_USER_STRUCT_S (
-                     Entry,
-                     UDP4_INSTANCE_DATA,
-                     Link,
-                     UDP4_INSTANCE_DATA_SIGNATURE
-                     );
-    if (Udp4Instance->Configured) {
-      Udp4ServicePoint->InstanceHandle = Udp4Instance->ChildHandle;
-      Udp4ServicePoint->LocalAddress   = Udp4Instance->ConfigData.StationAddress;
-      Udp4ServicePoint->LocalPort      = Udp4Instance->ConfigData.StationPort;
-      Udp4ServicePoint->RemoteAddress  = Udp4Instance->ConfigData.RemoteAddress;
-      Udp4ServicePoint->RemotePort     = Udp4Instance->ConfigData.RemotePort;
-      Udp4ServicePoint++;
+    }
+  }
-  //
-  // Get the mac string.
-  //
-  Status = NetLibGetMacString (
-             Udp4Service->ControllerHandle,
-             Udp4Service->ImageHandle,
-             &NewMacString
-             );
-  if (EFI_ERROR (Status)) {
-    goto ON_ERROR;
+  }
-  if (Udp4Service->MacString != NULL) {
-    //
-    // The variable is set already, we're going to update it.
-    //
-    if (StrCmp (Udp4Service->MacString, NewMacString) != 0) {
-      //
-      // The mac address is changed, delete the previous variable first.
-      //
-      gRT->SetVariable (
-             Udp4Service->MacString,
-             &gEfiUdp4ServiceBindingProtocolGuid,
-             EFI_VARIABLE_BOOTSERVICE_ACCESS,
-,
-             NULL
-             );
+    }
-    FreePool (Udp4Service->MacString);
+  }
-  Udp4Service->MacString = NewMacString;
-  Status = gRT->SetVariable (
-                  Udp4Service->MacString,
-                  &gEfiUdp4ServiceBindingProtocolGuid,
-                  EFI_VARIABLE_BOOTSERVICE_ACCESS,
-                  VariableDataSize,
-                  (VOID *) Udp4VariableData
-                  );
-ON_ERROR:
-  FreePool (Udp4VariableData);
-  return Status;
+}
-/**
-  Clear the variable and free the resource.
-  @param[[in]  Udp4Service            Udp4 service data.
-**/
-VOID
-Udp4ClearVariableData (
-  IN UDP4_SERVICE_DATA  *Udp4Service
+  )
+{
-  ASSERT (Udp4Service->MacString != NULL);
-  gRT->SetVariable (
-         Udp4Service->MacString,
-         &gEfiUdp4ServiceBindingProtocolGuid,
-         EFI_VARIABLE_BOOTSERVICE_ACCESS,
-,
-         NULL
-         );
-  FreePool (Udp4Service->MacString);
-  Udp4Service->MacString = NULL;
+}

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Udp4Dxe/Udp4Impl.h

-              r48674
+              r58459
   EFI UDPv4 protocol implementation.
 Copyright (c) 2006 - 2009, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
 #include <Library/TimerLib.h>
 #include <Library/DpcLib.h>
+#include <Library/PrintLib.h>
 #include "Udp4Driver.h"
 …
 extern EFI_COMPONENT_NAME_PROTOCOL     gUdp4ComponentName;
 extern EFI_COMPONENT_NAME2_PROTOCOL    gUdp4ComponentName2;
+extern EFI_UNICODE_STRING_TABLE        *gUdpControllerNameTable;
 extern EFI_SERVICE_BINDING_PROTOCOL    mUdp4ServiceBinding;
 extern EFI_UDP4_PROTOCOL               mUdp4Protocol;
 …
   EFI_EVENT                     TimeoutEvent;
-  CHAR16                        *MacString;
 } UDP4_SERVICE_DATA;
 …
   IP_IO_IP_INFO         *IpInfo;
   BOOLEAN               Destroyed;
+  BOOLEAN               InDestroy;
 } UDP4_INSTANCE_DATA;
 …
   EFI_UDP4_RECEIVE_DATA  RxData;
 } UDP4_RXDATA_WRAP;
+typedef struct {
+  EFI_SERVICE_BINDING_PROTOCOL  *ServiceBinding;
+  UINTN                         NumberOfChildren;
+  EFI_HANDLE                    *ChildHandleBuffer;
+} UDP4_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT;
 /**
 …
   VOID  *Context
   );
+/**
+  Set the Udp4 variable data.
+  @param[in] Udp4Service         Udp4 service data.
+  @retval EFI_OUT_OF_RESOURCES   There are not enough resources to set the
+                                 variable.
+  @retval EFI_SUCCESS            Set variable successfully.
+  @retval other                  Set variable failed.
+**/
+EFI_STATUS
+Udp4SetVariableData (
+  IN UDP4_SERVICE_DATA  *Udp4Service
+  );
+/**
+  Clear the variable and free the resource.
+  @param[[in]  Udp4Service            Udp4 service data.
+**/
+VOID
+Udp4ClearVariableData (
+  IN UDP4_SERVICE_DATA  *Udp4Service
+  );
 #endif

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/Udp4Dxe/Udp4Main.c

-              r48674
+              r58459
 /** @file
 Copyright (c) 2006 - 2009, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
     ASSERT (IsListEmpty (&Instance->DeliveredDgramQue));
+  }
+  Udp4SetVariableData (Instance->Udp4Service);
 ON_EXIT:

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/UefiPxeBcDxe/ComponentName.c

-              r48674
+              r58459
 /** @file
 Copyright (c) 2007 - 2011, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2007 - 2012, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
     "eng;en",
     L"UEFI PXE Base Code Driver"
+  },
+  {
+    NULL,
+    NULL
+  }
+};
+GLOBAL_REMOVE_IF_UNREFERENCED EFI_UNICODE_STRING_TABLE mPxeBcControllerNameTable[] = {
+  {
+    "eng;en",
+    L"PXE Controller"
   },
+  {
 …
+  )
+{
+  return EFI_UNSUPPORTED;
+  EFI_PXE_BASE_CODE_PROTOCOL  *PxeBc;
+  EFI_HANDLE                  NicHandle;
+  EFI_STATUS                  Status;
+  if (ControllerHandle == NULL || ChildHandle != NULL) {
+    return EFI_UNSUPPORTED;
+  }
+  NicHandle = NetLibGetNicHandle (ControllerHandle, &gEfiArpProtocolGuid);
+  if (NicHandle == NULL) {
+    NicHandle = NetLibGetNicHandle (ControllerHandle, &gEfiDhcp4ProtocolGuid);
+    if (NicHandle == NULL) {
+      NicHandle = NetLibGetNicHandle (ControllerHandle, &gEfiIp4ProtocolGuid);
+      if (NicHandle == NULL) {
+        NicHandle = NetLibGetNicHandle (ControllerHandle, &gEfiUdp4ProtocolGuid);
+        if (NicHandle == NULL) {
+          NicHandle = NetLibGetNicHandle (ControllerHandle, &gEfiMtftp4ProtocolGuid);
+          if (NicHandle == NULL) {
+            return EFI_UNSUPPORTED;
+          }
+        }
+      }
+    }
+  }
+  Status = gBS->OpenProtocol (
+                  NicHandle,
+                  &gEfiPxeBaseCodeProtocolGuid,
+                  (VOID **) &PxeBc,
+                  NULL,
+                  NULL,
+                  EFI_OPEN_PROTOCOL_GET_PROTOCOL
+                  );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+  return LookupUnicodeString2 (
+           Language,
+           This->SupportedLanguages,
+           mPxeBcControllerNameTable,
+           ControllerName,
+           (BOOLEAN)(This == &gPxeBcComponentName)
+           );
+}

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/UefiPxeBcDxe/PxeBcDhcp.c

-              r48674
+              r58459
   Support for PxeBc dhcp functions.
+Copyright (c) 2007 - 2011, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2013, Red Hat, Inc.
+Copyright (c) 2007 - 2014, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
   //
   // Parse interested dhcp options and store their pointers in CachedPacket->Dhcp4Option.
+  // First, try to parse DHCPv4 options from the DHCP optional parameters field.
   //
   for (Index = 0; Index < PXEBC_DHCP4_TAG_INDEX_MAX; Index++) {
     Options[Index] = PxeBcParseExtendOptions (
+                      Offer->Dhcp4.Option,
+                      GET_OPTION_BUFFER_LEN (Offer),
+                      mInterestedDhcp4Tags[Index]
+                      );
+                       Offer->Dhcp4.Option,
+                       GET_OPTION_BUFFER_LEN (Offer),
+                       mInterestedDhcp4Tags[Index]
+                       );
+  }
+  //
+  // Second, Check if bootfilename and serverhostname is overloaded to carry DHCP options refers to rfc-2132.
+  // If yes, try to parse options from the BootFileName field, then ServerName field.
+  //
+  Option = Options[PXEBC_DHCP4_TAG_INDEX_OVERLOAD];
+  if (Option != NULL) {
+    if ((Option->Data[0] & PXEBC_DHCP4_OVERLOAD_FILE) != 0) {
+      for (Index = 0; Index < PXEBC_DHCP4_TAG_INDEX_MAX; Index++) {
+        if (Options[Index] == NULL) {
+          Options[Index] = PxeBcParseExtendOptions (
+                             (UINT8 *) Offer->Dhcp4.Header.BootFileName,
+                             sizeof (Offer->Dhcp4.Header.BootFileName),
+                             mInterestedDhcp4Tags[Index]
+                             );
+        }
+      }
+    }
+    if ((Option->Data[0] & PXEBC_DHCP4_OVERLOAD_SERVER_NAME) != 0) {
+      for (Index = 0; Index < PXEBC_DHCP4_TAG_INDEX_MAX; Index++) {
+        if (Options[Index] == NULL) {
+          Options[Index] = PxeBcParseExtendOptions (
+                             (UINT8 *) Offer->Dhcp4.Header.ServerName,
+                             sizeof (Offer->Dhcp4.Header.ServerName),
+                             mInterestedDhcp4Tags[Index]
+                             );
+        }
+      }
+    }
+  }
 …
+  }
+  //
+  // Check whether bootfilename/serverhostname overloaded (See details in dhcp spec).
+  // If overloaded, parse this buffer as nested dhcp options, or just parse bootfilename/
+  // serverhostname option.
+  //
+  Option = Options[PXEBC_DHCP4_TAG_INDEX_OVERLOAD];
+  if ((Option != NULL) && ((Option->Data[0] & PXEBC_DHCP4_OVERLOAD_FILE) != 0)) {
+    Options[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] = PxeBcParseExtendOptions (
+                                                (UINT8 *) Offer->Dhcp4.Header.BootFileName,
+                                                sizeof (Offer->Dhcp4.Header.BootFileName),
+                                                PXEBC_DHCP4_TAG_BOOTFILE
+                                                );
+  //
+  // Parse PXE boot file name:
+  // According to PXE spec, boot file name should be read from DHCP option 67 (bootfile name) if present.
+  // Otherwise, read from boot file field in DHCP header.
+  //
+  if (Options[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] != NULL) {
     //
     // RFC 2132, Section 9.5 does not strictly state Bootfile name (option 67) is null
     // terminated string. So force to append null terminated character at the end of string.
     //
+    if (Options[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] != NULL) {
+      Ptr8 =  (UINT8*)&Options[PXEBC_DHCP4_TAG_INDEX_BOOTFILE]->Data[0];
+      Ptr8 += Options[PXEBC_DHCP4_TAG_INDEX_BOOTFILE]->Length;
+      *Ptr8 =  '\0';
+    }
+  } else if ((Options[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] == NULL) &&
+            (Offer->Dhcp4.Header.BootFileName[0] != 0)) {
+    Ptr8 =  (UINT8*)&Options[PXEBC_DHCP4_TAG_INDEX_BOOTFILE]->Data[0];
+    Ptr8 += Options[PXEBC_DHCP4_TAG_INDEX_BOOTFILE]->Length;
+    if (*(Ptr8 - 1) != '\0') {
+      *Ptr8 = '\0';
+    }
+  } else if (Offer->Dhcp4.Header.BootFileName[0] != 0) {
     //
     // If the bootfile is not present and bootfilename is present in dhcp packet, just parse it.
     // And do not count dhcp option header, or else will destory the serverhostname.
+    // And do not count dhcp option header, or else will destroy the serverhostname.
     //
     Options[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] = (EFI_DHCP4_PACKET_OPTION *) (&Offer->Dhcp4.Header.BootFileName[0] -
 …
         Status = EFI_NO_RESPONSE;
+        ASSERT (Private->NumOffers < PXEBC_MAX_OFFER_NUM);
         for (Index = 0; Index < Private->NumOffers; Index++) {
 …
   VendorOpt = &Packet->PxeVendorOption;
+  //
+  // According to the PXE specification 2.1, Table 2-1 PXE DHCP Options  (Full
+  // List), we must not consider a boot prompt or boot menu if all of the
+  // following hold:
+  // - the PXE_DISCOVERY_CONTROL PXE tag is present inside the Vendor Options
+  //   (=43) DHCP tag, and
+  // - the PXE_DISCOVERY_CONTROL PXE tag has bit 3 set, and
+  // - a boot file name has been presented with DHCP option 67.
+  //
+  if (IS_DISABLE_PROMPT_MENU (VendorOpt->DiscoverCtrl) &&
+      Packet->Dhcp4Option[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] != NULL) {
+    return EFI_ABORTED;
+  }
   if (!IS_VALID_BOOT_PROMPT (VendorOpt->BitMap)) {

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/UefiPxeBcDxe/PxeBcDhcp.h

-              r48674
+              r58459
   Dhcp and Discover routines for PxeBc.
+Copyright (c) 2013, Red Hat, Inc.
 Copyright (c) 2007 - 2011, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 …
 #define IS_DISABLE_MCAST_DISCOVER(x)    (((x) & BIT (1)) == BIT (1))
 #define IS_ENABLE_USE_SERVER_LIST(x)    (((x) & BIT (2)) == BIT (2))
 #define IS_ENABLE_BOOT_FILE_NAME(x)     (((x) & BIT (3)) == BIT (3))
+#define IS_DISABLE_PROMPT_MENU(x)       (((x) & BIT (3)) == BIT (3))
 #define SET_VENDOR_OPTION_BIT_MAP(x, y) (((x)[(y) / 32]) = (UINT32) ((x)[(y) / 32]) | BIT ((y) % 32))

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/UefiPxeBcDxe/PxeBcDriver.c

-              r48674
+              r58459
   The driver binding for UEFI PXEBC protocol.
 Copyright (c) 2007 - 2011, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2007 - 2012, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
           if (NicHandle == NULL) {
             return EFI_DEVICE_ERROR;
+            return EFI_SUCCESS;
+          }
+        }

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/UefiPxeBcDxe/PxeBcImpl.c

-              r48674
+              r58459
   Interface routines for PxeBc.
 Copyright (c) 2007 - 2011, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2007 - 2013, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
   //
   Status = PxeBcCheckSelectedOffer (Private);
-  if (!EFI_ERROR (Status)) {
-    goto ON_EXIT;
+  }
 ON_EXIT:
 …
   //   use the cached DhcpAck and ProxyOffer packets.
   //
+  ZeroMem (&DefaultInfo, sizeof (EFI_PXE_BASE_CODE_DISCOVER_INFO));
   if (*Layer != EFI_PXE_BASE_CODE_BOOT_LAYER_INITIAL) {

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/UefiPxeBcDxe/PxeBcMtftp.c

-              r48674
+              r58459
   PxeBc MTFTP functions.
 Copyright (c) 2007 - 2009, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2007 - 2014, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
     Private->Mode.TftpErrorReceived = TRUE;
     Private->Mode.TftpError.ErrorCode = (UINT8) Packet->Error.ErrorCode;
+    AsciiStrnCpy (Private->Mode.TftpError.ErrorString, (CHAR8 *) Packet->Error.ErrorMessage, 127);
+    AsciiStrnCpy (Private->Mode.TftpError.ErrorString, (CHAR8 *) Packet->Error.ErrorMessage, PXE_MTFTP_ERROR_STRING_LENGTH);
+    Private->Mode.TftpError.ErrorString[PXE_MTFTP_ERROR_STRING_LENGTH - 1] = '\0';
+  }
 …
   Status = Mtftp4->GetInfo (
                     Mtftp4,
                     FALSE,
+                    NULL,
                     Filename,
                     NULL,
 …
         Private->Mode.TftpError.ErrorString,
         (CHAR8 *) Packet->Error.ErrorMessage,
+        PXE_MTFTP_ERROR_STRING_LENGTH
         );
+      Private->Mode.TftpError.ErrorString[PXE_MTFTP_ERROR_STRING_LENGTH - 1] = '\0';
+    }
     goto ON_ERROR;

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/UefiPxeBcDxe/PxeBcMtftp.h

-              r48674
+              r58459
   Mtftp routines for PxeBc.
 Copyright (c) 2007 - 2009, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2007 - 2014, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 …
 #define PXE_MTFTP_OPTION_MULTICAST_INDEX 3
 #define PXE_MTFTP_OPTION_MAXIMUM_INDEX   4
+#define PXE_MTFTP_ERROR_STRING_LENGTH    127

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/UefiPxeBcDxe/UefiPxeBcDxe.inf

-              r48674
+              r58459
 ## @file
 # Component name for module UefiPxeBc
+#  This module produces EFI Preboot Execution Environment (PXE) Base Code Protocol.
+#
+# Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>
+#  This module produces EFI PXE Base Code Protocol upon EFI MMP Protocl and IPv4
+#  network stack, used to control PXE-compatible devices. It produces EFI Load File
+#  Protocol to provide one clean way to otain control from the boot manager if the
+#  boot patch is from the remote device.
+#
+#  Copyright (c) 2007 - 2014, Intel Corporation. All rights reserved.<BR>
 #  This program and the accompanying materials
 #  are licensed and made available under the terms and conditions of the BSD License
 …
 [Defines]
   INF_VERSION                    = 0x00010005
+  BASE_NAME                      = UefiPxeBcDxe
+  BASE_NAME                      = UefiPxe4BcDxe
+  MODULE_UNI_FILE                = UefiPxe4BcDxe.uni
   FILE_GUID                      = 3B1DEAB5-C75D-442e-9238-8E2FFB62B0BB
   MODULE_TYPE                    = UEFI_DRIVER
 …
   MdeModulePkg/MdeModulePkg.dec
 [LibraryClasses]
   BaseLib
 …
   PcdLib
-[Guids]
-  gEfiSmbiosTableGuid                              # ALWAYS_CONSUMED
 [Protocols]
+  gEfiArpServiceBindingProtocolGuid                # PROTOCOL ALWAYS_CONSUMED
+  gEfiArpProtocolGuid                              # PROTOCOL ALWAYS_CONSUMED
+  gEfiMtftp4ServiceBindingProtocolGuid             # PROTOCOL ALWAYS_CONSUMED
+  gEfiMtftp4ProtocolGuid                           # PROTOCOL ALWAYS_CONSUMED
+  gEfiUdp4ServiceBindingProtocolGuid               # PROTOCOL ALWAYS_CONSUMED
+  gEfiDhcp4ServiceBindingProtocolGuid              # PROTOCOL ALWAYS_CONSUMED
+  gEfiPxeBaseCodeCallbackProtocolGuid              # PROTOCOL ALWAYS_PRODUCED
+  gEfiPxeBaseCodeProtocolGuid                      # PROTOCOL ALWAYS_PRODUCED
+  gEfiLoadFileProtocolGuid                         # PROTOCOL ALWAYS_PRODUCED
+  gEfiDhcp4ProtocolGuid                            # PROTOCOL ALWAYS_CONSUMED
+  gEfiUdp4ProtocolGuid                             # PROTOCOL ALWAYS_CONSUMED
+  gEfiPxeBaseCodeCallbackProtocolGuid              ## SOMETIMES_PRODUCES
+  gEfiPxeBaseCodeProtocolGuid                      ## BY_START
+  gEfiLoadFileProtocolGuid                         ## BY_START
   gEfiNetworkInterfaceIdentifierProtocolGuid_31    ## SOMETIMES_CONSUMES
+  gEfiIp4ServiceBindingProtocolGuid                # PROTOCOL ALWAYS_CONSUMED
+  gEfiIp4ProtocolGuid                              # PROTOCOL ALWAYS_CONSUMED
+  gEfiArpServiceBindingProtocolGuid                ## TO_START
+  gEfiArpProtocolGuid                              ## TO_START
+  gEfiMtftp4ServiceBindingProtocolGuid             ## TO_START
+  gEfiMtftp4ProtocolGuid                           ## TO_START
+  gEfiUdp4ServiceBindingProtocolGuid               ## TO_START
+  gEfiUdp4ProtocolGuid                             ## TO_START
+  gEfiDhcp4ServiceBindingProtocolGuid              ## TO_START
+  gEfiDhcp4ProtocolGuid                            ## TO_START
+  gEfiIp4ServiceBindingProtocolGuid                ## TO_START
+  gEfiIp4ProtocolGuid                              ## TO_START
 [Pcd]
+  gEfiMdeModulePkgTokenSpaceGuid.PcdTftpBlockSize     ## CONSUMES
+  gEfiMdeModulePkgTokenSpaceGuid.PcdTftpBlockSize  ## SOMETIMES_CONSUMES
+[UserExtensions.TianoCore."ExtraFiles"]
+  UefiPxe4BcDxeExtra.uni

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/VlanConfigDxe/VlanConfigDriver.c

-              r48674
+              r58459
   The driver binding for VLAN configuration module.
 Copyright (c) 2009, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2009 - 2014, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions
 …
   ASSERT (PrivateData->Signature == VLAN_CONFIG_PRIVATE_DATA_SIGNATURE);
+  //
+  // Uninstall VLAN configuration Form
+  //
+  UninstallVlanConfigForm (PrivateData);
+  if (NumberOfChildren != 0) {
+    if (NumberOfChildren != 1 || ChildHandleBuffer[0] != PrivateData->DriverHandle) {
+      return EFI_DEVICE_ERROR;
+    }
+    return UninstallVlanConfigForm (PrivateData);
+  }
   //

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/VlanConfigDxe/VlanConfigDxe.inf

-              r48674
+              r58459
 ## @file
 #  Component description file for VLAN configuration module.
+#  This module provides one way to configurate VALN setting.
+#
+#  Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved.<BR>
+#  This module produces EFI HII Configuration Access Protocol to provide one way to
+#  configurate VALN setting
+#
+#  Copyright (c) 2009 - 2014, Intel Corporation. All rights reserved.<BR>
 #  This program and the accompanying materials
 #  are licensed and made available under the terms and conditions of the BSD License
 …
   INF_VERSION                    = 0x00010005
   BASE_NAME                      = VlanConfigDxe
+  MODULE_UNI_FILE                = VlanConfigDxe.uni
   FILE_GUID                      = E4F61863-FE2C-4b56-A8F4-08519BC439DF
   MODULE_TYPE                    = UEFI_DRIVER
 …
 [Guids]
+  gEfiIfrTianoGuid
+  gEfiIfrTianoGuid                              ## SOMETIMES_PRODUCES ## UNDEFINED
+  ## SOMETIMES_CONSUMES ## UNDEFINED # HiiIsConfigHdrMatch   mVlanStorageName
+  ## SOMETIMES_PRODUCES ## UNDEFINED # HiiConstructConfigHdr mVlanStorageName
+  ## SOMETIMES_PRODUCES ## UNDEFINED # HiiGetBrowserData     mVlanStorageName
+  ## SOMETIMES_CONSUMES ## UNDEFINED # HiiSetBrowserData     mVlanStorageName
+  ## SOMETIMES_CONSUMES ## HII
   gVlanConfigFormSetGuid
 [Protocols]
   gEfiHiiConfigAccessProtocolGuid               ## PRODUCES
+  gEfiHiiConfigAccessProtocolGuid               ## BY_START
   gEfiHiiConfigRoutingProtocolGuid              ## CONSUMES
+  gEfiVlanConfigProtocolGuid                    ## CONSUMES
+  gEfiVlanConfigProtocolGuid                    ## TO_START
+[UserExtensions.TianoCore."ExtraFiles"]
+  VlanConfigDxeExtra.uni

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/VlanConfigDxe/VlanConfigImpl.c

-              r48674
+              r58459
   HII Config Access protocol implementation of VLAN configuration module.
 Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2009 - 2014, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions
 …
   EFI_DEVICE_PATH_PROTOCOL        *ChildDevicePath;
   EFI_HII_CONFIG_ACCESS_PROTOCOL  *ConfigAccess;
+  EFI_VLAN_CONFIG_PROTOCOL        *VlanConfig;
   //
 …
   //
+  // Establish the parent-child relationship between the new created
+  // child handle and the ControllerHandle.
+  //
+  Status = gBS->OpenProtocol (
+                  PrivateData->ControllerHandle,
+                  &gEfiVlanConfigProtocolGuid,
+                  (VOID **)&VlanConfig,
+                  PrivateData->ImageHandle,
+                  PrivateData->DriverHandle,
+                  EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
+                  );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+  //
   // Publish the HII package list
   //
 …
   @param[in, out]  PrivateData   Points to VLAN configuration private data.
+  @retval EFI_SUCCESS            HII Form has been uninstalled successfully.
+  @retval Others                 Other errors as indicated.
 **/
+VOID
+EFI_STATUS
 UninstallVlanConfigForm (
   IN OUT VLAN_CONFIG_PRIVATE_DATA    *PrivateData
+  )
+{
   //
   // Free MAC string
   //
   if (PrivateData->MacString != NULL) {
     FreePool (PrivateData->MacString);
     PrivateData->MacString = NULL;
+  }
   //
   // Uninstall HII package list
   //
   if (PrivateData->HiiHandle != NULL) {
     HiiRemovePackages (PrivateData->HiiHandle);
     PrivateData->HiiHandle = NULL;
+  EFI_STATUS                   Status;
+  EFI_VLAN_CONFIG_PROTOCOL     *VlanConfig;
+  //
+  // End the parent-child relationship.
+  //
+  Status = gBS->CloseProtocol (
+                  PrivateData->ControllerHandle,
+                  &gEfiVlanConfigProtocolGuid,
+                  PrivateData->ImageHandle,
+                  PrivateData->DriverHandle
+                  );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
 …
   //
   if (PrivateData->DriverHandle != NULL) {
+    gBS->UninstallMultipleProtocolInterfaces (
+           PrivateData->DriverHandle,
+           &gEfiDevicePathProtocolGuid,
+           PrivateData->ChildDevicePath,
+           &gEfiHiiConfigAccessProtocolGuid,
+           &PrivateData->ConfigAccess,
+           NULL
+           );
+    Status = gBS->UninstallMultipleProtocolInterfaces (
+                    PrivateData->DriverHandle,
+                    &gEfiDevicePathProtocolGuid,
+                    PrivateData->ChildDevicePath,
+                    &gEfiHiiConfigAccessProtocolGuid,
+                    &PrivateData->ConfigAccess,
+                    NULL
+                    );
+    if (EFI_ERROR (Status)) {
+      gBS->OpenProtocol (
+             PrivateData->ControllerHandle,
+             &gEfiVlanConfigProtocolGuid,
+             (VOID **)&VlanConfig,
+             PrivateData->ImageHandle,
+             PrivateData->DriverHandle,
+             EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
+             );
+      return Status;
+    }
     PrivateData->DriverHandle = NULL;
 …
+    }
+  }
+  //
+  // Free MAC string
+  //
+  if (PrivateData->MacString != NULL) {
+    FreePool (PrivateData->MacString);
+    PrivateData->MacString = NULL;
+  }
+  //
+  // Uninstall HII package list
+  //
+  if (PrivateData->HiiHandle != NULL) {
+    HiiRemovePackages (PrivateData->HiiHandle);
+    PrivateData->HiiHandle = NULL;
+  }
+  return EFI_SUCCESS;
+}

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network/VlanConfigDxe/VlanConfigImpl.h

-              r48674
+              r58459
   Header file for driver binding protocol and HII config access protocol.
 Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2009 - 2014, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions
 …
   @param[in, out]  PrivateData   Points to VLAN configuration private data.
+**/
+VOID
+  @retval EFI_SUCCESS            HII Form has been uninstalled successfully.
+  @retval Others                 Other errors as indicated.
+**/
+EFI_STATUS
 UninstallVlanConfigForm (
   IN OUT VLAN_CONFIG_PRIVATE_DATA    *PrivateData

Changeset 58459 in vbox for trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/Network

Legend:

Download in other formats: