\r
#include "RedfishDiscoverInternal.h"\r
\r
-LIST_ENTRY mRedfishDiscoverList;\r
-LIST_ENTRY mRedfishInstanceList;\r
-EFI_SMBIOS_PROTOCOL *mSmbios = NULL;\r
+LIST_ENTRY mRedfishDiscoverList;\r
+LIST_ENTRY mRedfishInstanceList;\r
+EFI_SMBIOS_PROTOCOL *mSmbios = NULL;\r
\r
-UINTN mNumNetworkInterface = 0;\r
-UINTN mNumRestExInstance = 0;\r
-LIST_ENTRY mEfiRedfishDiscoverNetworkInterface;\r
-LIST_ENTRY mEfiRedfishDiscoverRestExInstance;\r
+UINTN mNumNetworkInterface = 0;\r
+UINTN mNumRestExInstance = 0;\r
+LIST_ENTRY mEfiRedfishDiscoverNetworkInterface;\r
+LIST_ENTRY mEfiRedfishDiscoverRestExInstance;\r
\r
-EFI_GUID mRedfishDiscoverTcp4InstanceGuid = EFI_REDFISH_DISCOVER_TCP4_INSTANCE_GUID;\r
-EFI_GUID mRedfishDiscoverTcp6InstanceGuid = EFI_REDFISH_DISCOVER_TCP6_INSTANCE_GUID;\r
-EFI_GUID mRedfishDiscoverRestExInstanceGuid = EFI_REDFISH_DISCOVER_REST_EX_INSTANCE_GUID;\r
+EFI_GUID mRedfishDiscoverTcp4InstanceGuid = EFI_REDFISH_DISCOVER_TCP4_INSTANCE_GUID;\r
+EFI_GUID mRedfishDiscoverTcp6InstanceGuid = EFI_REDFISH_DISCOVER_TCP6_INSTANCE_GUID;\r
+EFI_GUID mRedfishDiscoverRestExInstanceGuid = EFI_REDFISH_DISCOVER_REST_EX_INSTANCE_GUID;\r
\r
-EFI_HANDLE EfiRedfishDiscoverProtocolHandle = NULL;\r
+EFI_HANDLE EfiRedfishDiscoverProtocolHandle = NULL;\r
\r
EFI_STATUS\r
EFIAPI\r
Tcp4GetSubnetInfo (\r
- IN EFI_HANDLE ImageHandle,\r
- IN EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *Instance\r
-);\r
+ IN EFI_HANDLE ImageHandle,\r
+ IN EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *Instance\r
+ );\r
\r
EFI_STATUS\r
EFIAPI\r
Tcp6GetSubnetInfo (\r
- IN EFI_HANDLE ImageHandle,\r
- IN EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *Instance\r
-);\r
+ IN EFI_HANDLE ImageHandle,\r
+ IN EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *Instance\r
+ );\r
\r
-static REDFISH_DISCOVER_REQUIRED_PROTOCOL gRequiredProtocol[] = {\r
+static REDFISH_DISCOVER_REQUIRED_PROTOCOL gRequiredProtocol[] = {\r
{\r
ProtocolTypeTcp4,\r
L"TCP4 Service Binding Protocol",\r
**/\r
EFI_STATUS\r
CreateRestExInstance (\r
- IN EFI_REDFISH_DISCOVERED_INTERNAL_INSTANCE *Instance,\r
- IN EFI_REDFISH_DISCOVERED_TOKEN *Token\r
+ IN EFI_REDFISH_DISCOVERED_INTERNAL_INSTANCE *Instance,\r
+ IN EFI_REDFISH_DISCOVERED_TOKEN *Token\r
)\r
{\r
- EFI_STATUS Status;\r
+ EFI_STATUS Status;\r
\r
Status = RestExLibCreateChild (\r
- Instance->Owner,\r
- FixedPcdGetBool (PcdRedfishDiscoverAccessModeInBand)? EfiRestExServiceInBandAccess: EfiRestExServiceOutOfBandAccess,\r
- EfiRestExConfigHttp,\r
- EfiRestExServiceRedfish,\r
- &Token->DiscoverList.RedfishInstances->Information.RedfishRestExHandle\r
- );\r
+ Instance->Owner,\r
+ FixedPcdGetBool (PcdRedfishDiscoverAccessModeInBand) ? EfiRestExServiceInBandAccess : EfiRestExServiceOutOfBandAccess,\r
+ EfiRestExConfigHttp,\r
+ EfiRestExServiceRedfish,\r
+ &Token->DiscoverList.RedfishInstances->Information.RedfishRestExHandle\r
+ );\r
return Status;\r
}\r
\r
**/\r
EFI_REDFISH_DISCOVERED_INTERNAL_INSTANCE *\r
GetInstanceByOwner (\r
- IN EFI_HANDLE ImageHandle,\r
- IN EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *TargetNetworkInterface,\r
- IN EFI_REDFISH_DISCOVER_FLAG DiscoverFlags\r
+ IN EFI_HANDLE ImageHandle,\r
+ IN EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *TargetNetworkInterface,\r
+ IN EFI_REDFISH_DISCOVER_FLAG DiscoverFlags\r
)\r
{\r
- EFI_REDFISH_DISCOVERED_INTERNAL_INSTANCE *ThisInstance;\r
+ EFI_REDFISH_DISCOVERED_INTERNAL_INSTANCE *ThisInstance;\r
\r
if (IsListEmpty (&mRedfishDiscoverList)) {\r
return NULL;\r
}\r
+\r
ThisInstance =\r
(EFI_REDFISH_DISCOVERED_INTERNAL_INSTANCE *)GetFirstNode (&mRedfishDiscoverList);\r
while (TRUE) {\r
if ((ThisInstance->Owner == ImageHandle) &&\r
- (ThisInstance->DiscoverFlags == DiscoverFlags) &&\r
- (ThisInstance->NetworkInterface == TargetNetworkInterface)) {\r
+ (ThisInstance->DiscoverFlags == DiscoverFlags) &&\r
+ (ThisInstance->NetworkInterface == TargetNetworkInterface))\r
+ {\r
return ThisInstance;\r
}\r
+\r
if (IsNodeAtEnd (&mRedfishDiscoverList, &ThisInstance->Entry)) {\r
break;\r
}\r
+\r
ThisInstance =\r
(EFI_REDFISH_DISCOVERED_INTERNAL_INSTANCE *)GetNextNode (&mRedfishDiscoverList, &ThisInstance->Entry);\r
- };\r
+ }\r
+\r
return NULL;\r
}\r
\r
EFI_STATUS\r
EFIAPI\r
Tcp4GetSubnetInfo (\r
- IN EFI_HANDLE ImageHandle,\r
- IN EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *Instance\r
-)\r
+ IN EFI_HANDLE ImageHandle,\r
+ IN EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *Instance\r
+ )\r
{\r
- EFI_STATUS Status;\r
- EFI_TCP4_PROTOCOL *Tcp4;\r
- EFI_TCP4_CONFIG_DATA Tcp4CfgData;\r
- EFI_TCP4_OPTION Tcp4Option;\r
- EFI_IP4_MODE_DATA IpModedata;\r
- UINT8 SubnetMaskIndex;\r
- UINT8 BitMask;\r
- UINT8 PrefixLength;\r
- BOOLEAN GotPrefixLength;\r
+ EFI_STATUS Status;\r
+ EFI_TCP4_PROTOCOL *Tcp4;\r
+ EFI_TCP4_CONFIG_DATA Tcp4CfgData;\r
+ EFI_TCP4_OPTION Tcp4Option;\r
+ EFI_IP4_MODE_DATA IpModedata;\r
+ UINT8 SubnetMaskIndex;\r
+ UINT8 BitMask;\r
+ UINT8 PrefixLength;\r
+ BOOLEAN GotPrefixLength;\r
\r
if (Instance == NULL) {\r
return EFI_INVALID_PARAMETER;\r
}\r
+\r
Tcp4 = (EFI_TCP4_PROTOCOL *)Instance->NetworkInterfaceProtocolInfo.NetworkProtocolInterface;\r
\r
ZeroMem ((VOID *)&Tcp4CfgData, sizeof (EFI_TCP4_CONFIG_DATA));\r
ZeroMem ((VOID *)&Tcp4Option, sizeof (EFI_TCP4_OPTION));\r
// Give a local host IP address just for getting subnet information.\r
- Tcp4CfgData.AccessPoint.UseDefaultAddress = TRUE;\r
- Tcp4CfgData.AccessPoint.RemoteAddress.Addr [0] = 127;\r
- Tcp4CfgData.AccessPoint.RemoteAddress.Addr [1] = 0;\r
- Tcp4CfgData.AccessPoint.RemoteAddress.Addr [2] = 0;\r
- Tcp4CfgData.AccessPoint.RemoteAddress.Addr [3] = 1;\r
- Tcp4CfgData.AccessPoint.RemotePort = 80;\r
- Tcp4CfgData.AccessPoint.ActiveFlag = TRUE;\r
-\r
- Tcp4CfgData.ControlOption = &Tcp4Option;\r
- Tcp4Option.ReceiveBufferSize = 65535;\r
- Tcp4Option.SendBufferSize = 65535;\r
- Tcp4Option.MaxSynBackLog = 5;\r
- Tcp4Option.ConnectionTimeout = 60;\r
- Tcp4Option.DataRetries = 12;\r
- Tcp4Option.FinTimeout = 2;\r
- Tcp4Option.KeepAliveProbes = 6;\r
- Tcp4Option.KeepAliveTime = 7200;\r
- Tcp4Option.KeepAliveInterval = 30;\r
- Tcp4Option.EnableNagle = TRUE;\r
- Status = Tcp4->Configure (Tcp4, &Tcp4CfgData);\r
+ Tcp4CfgData.AccessPoint.UseDefaultAddress = TRUE;\r
+ Tcp4CfgData.AccessPoint.RemoteAddress.Addr[0] = 127;\r
+ Tcp4CfgData.AccessPoint.RemoteAddress.Addr[1] = 0;\r
+ Tcp4CfgData.AccessPoint.RemoteAddress.Addr[2] = 0;\r
+ Tcp4CfgData.AccessPoint.RemoteAddress.Addr[3] = 1;\r
+ Tcp4CfgData.AccessPoint.RemotePort = 80;\r
+ Tcp4CfgData.AccessPoint.ActiveFlag = TRUE;\r
+\r
+ Tcp4CfgData.ControlOption = &Tcp4Option;\r
+ Tcp4Option.ReceiveBufferSize = 65535;\r
+ Tcp4Option.SendBufferSize = 65535;\r
+ Tcp4Option.MaxSynBackLog = 5;\r
+ Tcp4Option.ConnectionTimeout = 60;\r
+ Tcp4Option.DataRetries = 12;\r
+ Tcp4Option.FinTimeout = 2;\r
+ Tcp4Option.KeepAliveProbes = 6;\r
+ Tcp4Option.KeepAliveTime = 7200;\r
+ Tcp4Option.KeepAliveInterval = 30;\r
+ Tcp4Option.EnableNagle = TRUE;\r
+ Status = Tcp4->Configure (Tcp4, &Tcp4CfgData);\r
if (EFI_ERROR (Status)) {\r
DEBUG ((DEBUG_ERROR, "%a: Can't get subnet information\n", __FUNCTION__));\r
return Status;\r
}\r
+\r
Status = Tcp4->GetModeData (Tcp4, NULL, NULL, &IpModedata, NULL, NULL);\r
if (EFI_ERROR (Status)) {\r
DEBUG ((DEBUG_ERROR, "%a: Can't get IP mode data information\n", __FUNCTION__));\r
return Status;\r
}\r
+\r
IP4_COPY_ADDRESS (&Instance->SubnetMask, &IpModedata.ConfigData.SubnetMask);\r
- Instance->SubnetAddr.v4.Addr [0] = IpModedata.ConfigData.StationAddress.Addr [0] & Instance->SubnetMask.v4.Addr [0];\r
- Instance->SubnetAddr.v4.Addr [1] = IpModedata.ConfigData.StationAddress.Addr [1] & Instance->SubnetMask.v4.Addr [1];\r
- Instance->SubnetAddr.v4.Addr [2] = IpModedata.ConfigData.StationAddress.Addr [2] & Instance->SubnetMask.v4.Addr [2];\r
- Instance->SubnetAddr.v4.Addr [3] = IpModedata.ConfigData.StationAddress.Addr [3] & Instance->SubnetMask.v4.Addr [3];\r
+ Instance->SubnetAddr.v4.Addr[0] = IpModedata.ConfigData.StationAddress.Addr[0] & Instance->SubnetMask.v4.Addr[0];\r
+ Instance->SubnetAddr.v4.Addr[1] = IpModedata.ConfigData.StationAddress.Addr[1] & Instance->SubnetMask.v4.Addr[1];\r
+ Instance->SubnetAddr.v4.Addr[2] = IpModedata.ConfigData.StationAddress.Addr[2] & Instance->SubnetMask.v4.Addr[2];\r
+ Instance->SubnetAddr.v4.Addr[3] = IpModedata.ConfigData.StationAddress.Addr[3] & Instance->SubnetMask.v4.Addr[3];\r
//\r
// Calculate the subnet mask prefix.\r
//\r
GotPrefixLength = FALSE;\r
- PrefixLength = 0;\r
+ PrefixLength = 0;\r
SubnetMaskIndex = 0;\r
while (GotPrefixLength == FALSE && SubnetMaskIndex < 4) {\r
BitMask = 0x80;\r
while (BitMask != 0) {\r
- if ((Instance->SubnetMask.v4.Addr [SubnetMaskIndex] & BitMask) != 0) {\r
- PrefixLength ++;\r
+ if ((Instance->SubnetMask.v4.Addr[SubnetMaskIndex] & BitMask) != 0) {\r
+ PrefixLength++;\r
} else {\r
GotPrefixLength = TRUE;\r
break;\r
}\r
+\r
BitMask = BitMask >> 1;\r
- };\r
- SubnetMaskIndex ++;\r
- };\r
+ }\r
+\r
+ SubnetMaskIndex++;\r
+ }\r
+\r
Instance->SubnetPrefixLength = PrefixLength;\r
return EFI_SUCCESS;\r
}\r
EFI_STATUS\r
EFIAPI\r
Tcp6GetSubnetInfo (\r
- IN EFI_HANDLE ImageHandle,\r
- IN EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *Instance\r
-)\r
+ IN EFI_HANDLE ImageHandle,\r
+ IN EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *Instance\r
+ )\r
{\r
- EFI_STATUS Status;\r
- EFI_TCP6_PROTOCOL *Tcp6;\r
- EFI_IP6_MODE_DATA IpModedata;\r
+ EFI_STATUS Status;\r
+ EFI_TCP6_PROTOCOL *Tcp6;\r
+ EFI_IP6_MODE_DATA IpModedata;\r
\r
if (Instance == NULL) {\r
return EFI_INVALID_PARAMETER;\r
}\r
+\r
Tcp6 = (EFI_TCP6_PROTOCOL *)Instance->NetworkInterfaceProtocolInfo.NetworkProtocolInterface;\r
\r
Status = Tcp6->GetModeData (Tcp6, NULL, NULL, &IpModedata, NULL, NULL);\r
DEBUG ((DEBUG_ERROR, "%a: Can't get IP mode data information\n"));\r
return Status;\r
}\r
+\r
if (IpModedata.AddressCount == 0) {\r
DEBUG ((DEBUG_INFO, "%a: No IPv6 address configured.\n"));\r
}\r
+\r
if (Instance->SubnetAddrInfoIPv6 != NULL) {\r
FreePool (Instance->SubnetAddrInfoIPv6);\r
}\r
+\r
Instance->SubnetAddrInfoIPv6 = AllocateZeroPool (IpModedata.AddressCount * sizeof (EFI_IP6_ADDRESS_INFO));\r
if (Instance->SubnetAddrInfoIPv6 == NULL) {\r
DEBUG ((DEBUG_ERROR, "%a: Failed to allocate memory fir IPv6 subnet address information\n"));\r
return EFI_OUT_OF_RESOURCES;\r
}\r
+\r
Instance->SubnetAddrInfoIPv6Number = IpModedata.AddressCount;\r
CopyMem (\r
(VOID *)Instance->SubnetAddrInfoIPv6,\r
IN EFI_REDFISH_DISCOVER_NETWORK_INTERFACE *TargetNetworkInterface\r
)\r
{\r
- EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *ThisNetworkInterface;\r
+ EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *ThisNetworkInterface;\r
\r
ThisNetworkInterface = (EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *)GetFirstNode (&mEfiRedfishDiscoverNetworkInterface);\r
while (TRUE) {\r
- if (CompareMem((VOID *)&ThisNetworkInterface->MacAddress, &TargetNetworkInterface->MacAddress, ThisNetworkInterface->HwAddressSize) == 0) {\r
+ if (CompareMem ((VOID *)&ThisNetworkInterface->MacAddress, &TargetNetworkInterface->MacAddress, ThisNetworkInterface->HwAddressSize) == 0) {\r
return ThisNetworkInterface;\r
}\r
+\r
if (IsNodeAtEnd (&mEfiRedfishDiscoverNetworkInterface, &ThisNetworkInterface->Entry)) {\r
return NULL;\r
}\r
- ThisNetworkInterface = (EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *)GetNextNode(&mEfiRedfishDiscoverNetworkInterface, &ThisNetworkInterface->Entry);\r
- };\r
+\r
+ ThisNetworkInterface = (EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *)GetNextNode (&mEfiRedfishDiscoverNetworkInterface, &ThisNetworkInterface->Entry);\r
+ }\r
+\r
return NULL;\r
}\r
\r
EFI_STATUS\r
ValidateTargetNetworkInterface (\r
IN EFI_REDFISH_DISCOVER_NETWORK_INTERFACE *TargetNetworkInterface,\r
- IN EFI_REDFISH_DISCOVER_FLAG Flags\r
+ IN EFI_REDFISH_DISCOVER_FLAG Flags\r
)\r
{\r
- EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *ThisNetworkInterface;\r
+ EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *ThisNetworkInterface;\r
\r
- if (IsListEmpty (&mEfiRedfishDiscoverNetworkInterface) && TargetNetworkInterface == NULL) {\r
+ if (IsListEmpty (&mEfiRedfishDiscoverNetworkInterface) && (TargetNetworkInterface == NULL)) {\r
return EFI_UNSUPPORTED;\r
}\r
+\r
if (TargetNetworkInterface == NULL) {\r
return EFI_SUCCESS; // Return EFI_SUCCESS if no network interface is specified.\r
}\r
\r
- ThisNetworkInterface = (EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *)GetFirstNode(&mEfiRedfishDiscoverNetworkInterface);\r
+ ThisNetworkInterface = (EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *)GetFirstNode (&mEfiRedfishDiscoverNetworkInterface);\r
while (TRUE) {\r
- if (CompareMem((VOID *)&ThisNetworkInterface->MacAddress, &TargetNetworkInterface->MacAddress, ThisNetworkInterface->HwAddressSize) == 0) {\r
+ if (CompareMem ((VOID *)&ThisNetworkInterface->MacAddress, &TargetNetworkInterface->MacAddress, ThisNetworkInterface->HwAddressSize) == 0) {\r
break;\r
}\r
+\r
if (IsNodeAtEnd (&mEfiRedfishDiscoverNetworkInterface, &ThisNetworkInterface->Entry)) {\r
return EFI_UNSUPPORTED;\r
}\r
- ThisNetworkInterface = (EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *)GetNextNode(&mEfiRedfishDiscoverNetworkInterface, &ThisNetworkInterface->Entry);\r
- };\r
+\r
+ ThisNetworkInterface = (EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *)GetNextNode (&mEfiRedfishDiscoverNetworkInterface, &ThisNetworkInterface->Entry);\r
+ }\r
+\r
if ((Flags & EFI_REDFISH_DISCOVER_SSDP) != 0) {\r
// Validate if UDP4/6 is supported on the given network interface.\r
// SSDP is not supported.\r
\r
return EFI_SUCCESS;\r
}\r
+\r
if (ThisNetworkInterface->NetworkInterfaceProtocolInfo.ProtocolControllerHandle == NULL) {\r
return EFI_UNSUPPORTED; // The required protocol on this network interface is not found.\r
}\r
+\r
return EFI_SUCCESS;\r
}\r
+\r
/**\r
This function returns number of network interface instance.\r
\r
@retval UINTN Number of network interface instances.\r
**/\r
UINTN\r
-NumberOfNetworkInterface (VOID)\r
+NumberOfNetworkInterface (\r
+ VOID\r
+ )\r
{\r
- UINTN Num;\r
- EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *ThisNetworkInterface;\r
+ UINTN Num;\r
+ EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *ThisNetworkInterface;\r
\r
if (IsListEmpty (&mEfiRedfishDiscoverNetworkInterface)) {\r
return 0;\r
}\r
\r
- Num = 1;\r
+ Num = 1;\r
ThisNetworkInterface = (EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *)GetFirstNode (&mEfiRedfishDiscoverNetworkInterface);\r
while (TRUE) {\r
if (IsNodeAtEnd (&mEfiRedfishDiscoverNetworkInterface, &ThisNetworkInterface->Entry)) {\r
break;\r
}\r
- ThisNetworkInterface = (EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *)GetNextNode(&mEfiRedfishDiscoverNetworkInterface, &ThisNetworkInterface->Entry);\r
- Num ++;\r
- };\r
+\r
+ ThisNetworkInterface = (EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *)GetNextNode (&mEfiRedfishDiscoverNetworkInterface, &ThisNetworkInterface->Entry);\r
+ Num++;\r
+ }\r
+\r
return Num;\r
}\r
\r
**/\r
BOOLEAN\r
CheckIsIpVersion6 (\r
- IN EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *ThisNetworkInterface\r
-)\r
+ IN EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *ThisNetworkInterface\r
+ )\r
{\r
if (ThisNetworkInterface->NetworkProtocolType == ProtocolTypeTcp6) {\r
return TRUE;\r
}\r
+\r
return FALSE;\r
}\r
\r
\r
**/\r
EFI_STATUS\r
-DiscoverRedfishHostInterface (IN EFI_REDFISH_DISCOVERED_INTERNAL_INSTANCE *Instance)\r
+DiscoverRedfishHostInterface (\r
+ IN EFI_REDFISH_DISCOVERED_INTERNAL_INSTANCE *Instance\r
+ )\r
{\r
- EFI_STATUS Status;\r
- REDFISH_OVER_IP_PROTOCOL_DATA *Data;\r
- REDFISH_INTERFACE_DATA *DeviceDescriptor;\r
- CHAR8 UuidStr[sizeof"00000000-0000-0000-0000-000000000000" + 1];\r
- CHAR16 Ipv6Str [sizeof"ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff" + 1];\r
- CHAR8 RedfishServiceLocateStr [sizeof"ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff" + 1];\r
- UINTN StrSize;\r
- UINTN MacCompareStstus;\r
- BOOLEAN IsHttps;\r
-\r
- Data = NULL;\r
+ EFI_STATUS Status;\r
+ REDFISH_OVER_IP_PROTOCOL_DATA *Data;\r
+ REDFISH_INTERFACE_DATA *DeviceDescriptor;\r
+ CHAR8 UuidStr[sizeof "00000000-0000-0000-0000-000000000000" + 1];\r
+ CHAR16 Ipv6Str[sizeof "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff" + 1];\r
+ CHAR8 RedfishServiceLocateStr[sizeof "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff" + 1];\r
+ UINTN StrSize;\r
+ UINTN MacCompareStstus;\r
+ BOOLEAN IsHttps;\r
+\r
+ Data = NULL;\r
DeviceDescriptor = NULL;\r
\r
if (mSmbios == NULL) {\r
- Status = gBS->LocateProtocol(&gEfiSmbiosProtocolGuid, NULL, (VOID **)&mSmbios);\r
+ Status = gBS->LocateProtocol (&gEfiSmbiosProtocolGuid, NULL, (VOID **)&mSmbios);\r
if (EFI_ERROR (Status)) {\r
return Status;\r
}\r
}\r
+\r
Status = RedfishGetHostInterfaceProtocolData (mSmbios, &DeviceDescriptor, &Data); // Search for SMBIOS type 42h\r
- if (!EFI_ERROR (Status) && Data != NULL && DeviceDescriptor != NULL) {\r
+ if (!EFI_ERROR (Status) && (Data != NULL) && (DeviceDescriptor != NULL)) {\r
//\r
// Chceck if we can reach out Redfish service using this network interface.\r
// Check with MAC address using Device Descroptor Data Device Type 04 and Type 05.\r
// Those two types of Redfish host interface device has MAC information.\r
//\r
if (DeviceDescriptor->DeviceType == REDFISH_HOST_INTERFACE_DEVICE_TYPE_PCI_PCIE_V2) {\r
- MacCompareStstus = CompareMem(&Instance->NetworkInterface->MacAddress, &DeviceDescriptor->DeviceDescriptor.PciPcieDeviceV2.MacAddress, 6);\r
- } else if (DeviceDescriptor->DeviceType == REDFISH_HOST_INTERFACE_DEVICE_TYPE_USB_V2){\r
- MacCompareStstus = CompareMem(&Instance->NetworkInterface->MacAddress, &DeviceDescriptor->DeviceDescriptor.UsbDeviceV2.MacAddress, 6);\r
+ MacCompareStstus = CompareMem (&Instance->NetworkInterface->MacAddress, &DeviceDescriptor->DeviceDescriptor.PciPcieDeviceV2.MacAddress, 6);\r
+ } else if (DeviceDescriptor->DeviceType == REDFISH_HOST_INTERFACE_DEVICE_TYPE_USB_V2) {\r
+ MacCompareStstus = CompareMem (&Instance->NetworkInterface->MacAddress, &DeviceDescriptor->DeviceDescriptor.UsbDeviceV2.MacAddress, 6);\r
} else {\r
return EFI_UNSUPPORTED;\r
}\r
+\r
if (MacCompareStstus != 0) {\r
return EFI_UNSUPPORTED;\r
}\r
}\r
\r
if (Instance->HostIntfValidation) {\r
- DEBUG ((DEBUG_ERROR,"%a:Send UPnP unicast SSDP to validate this Redfish Host Interface is not supported.\n", __FUNCTION__));\r
+ DEBUG ((DEBUG_ERROR, "%a:Send UPnP unicast SSDP to validate this Redfish Host Interface is not supported.\n", __FUNCTION__));\r
Status = EFI_UNSUPPORTED;\r
} else {\r
//\r
if (Data->RedfishServiceIpPort == 443) {\r
IsHttps = TRUE;\r
}\r
- StrSize = sizeof(UuidStr);\r
- AsciiSPrint(UuidStr, StrSize, "%g", &Data->ServiceUuid);\r
+\r
+ StrSize = sizeof (UuidStr);\r
+ AsciiSPrint (UuidStr, StrSize, "%g", &Data->ServiceUuid);\r
//\r
// Generate Redfish service location string.\r
//\r
if (Data->RedfishServiceIpAddressFormat == REDFISH_HOST_INTERFACE_HOST_IP_ADDRESS_FORMAT_IP6) {\r
- NetLibIp6ToStr((IPv6_ADDRESS *)&Data->RedfishServiceIpAddress, Ipv6Str, sizeof (Ipv6Str));\r
- if (Data->RedfishServiceIpPort == 0 || IsHttps == TRUE) {\r
- AsciiSPrintUnicodeFormat (\r
- RedfishServiceLocateStr,\r
- sizeof (RedfishServiceLocateStr),\r
- L"%s",\r
- Ipv6Str\r
+ NetLibIp6ToStr ((IPv6_ADDRESS *)&Data->RedfishServiceIpAddress, Ipv6Str, sizeof (Ipv6Str));\r
+ if ((Data->RedfishServiceIpPort == 0) || (IsHttps == TRUE)) {\r
+ AsciiSPrintUnicodeFormat (\r
+ RedfishServiceLocateStr,\r
+ sizeof (RedfishServiceLocateStr),\r
+ L"%s",\r
+ Ipv6Str\r
);\r
} else {\r
- AsciiSPrintUnicodeFormat(\r
- RedfishServiceLocateStr,\r
- sizeof (RedfishServiceLocateStr),\r
- L"[%s]:%d",\r
- Ipv6Str,\r
- Data->RedfishServiceIpPort\r
+ AsciiSPrintUnicodeFormat (\r
+ RedfishServiceLocateStr,\r
+ sizeof (RedfishServiceLocateStr),\r
+ L"[%s]:%d",\r
+ Ipv6Str,\r
+ Data->RedfishServiceIpPort\r
);\r
}\r
} else {\r
- if (Data->RedfishServiceIpPort == 0 || IsHttps == TRUE) {\r
- AsciiSPrint(\r
+ if ((Data->RedfishServiceIpPort == 0) || (IsHttps == TRUE)) {\r
+ AsciiSPrint (\r
RedfishServiceLocateStr,\r
sizeof (RedfishServiceLocateStr),\r
"%d.%d.%d.%d",\r
- Data->RedfishServiceIpAddress [0],\r
- Data->RedfishServiceIpAddress [1],\r
- Data->RedfishServiceIpAddress [2],\r
- Data->RedfishServiceIpAddress [3]\r
+ Data->RedfishServiceIpAddress[0],\r
+ Data->RedfishServiceIpAddress[1],\r
+ Data->RedfishServiceIpAddress[2],\r
+ Data->RedfishServiceIpAddress[3]\r
);\r
} else {\r
- AsciiSPrint(\r
+ AsciiSPrint (\r
RedfishServiceLocateStr,\r
sizeof (RedfishServiceLocateStr),\r
"%d.%d.%d.%d:%d",\r
- Data->RedfishServiceIpAddress [0],\r
- Data->RedfishServiceIpAddress [1],\r
- Data->RedfishServiceIpAddress [2],\r
- Data->RedfishServiceIpAddress [3],\r
+ Data->RedfishServiceIpAddress[0],\r
+ Data->RedfishServiceIpAddress[1],\r
+ Data->RedfishServiceIpAddress[2],\r
+ Data->RedfishServiceIpAddress[3],\r
Data->RedfishServiceIpPort\r
);\r
}\r
- }\r
+ }\r
+\r
Status = AddAndSignalNewRedfishService (\r
- Instance,\r
- NULL,\r
- RedfishServiceLocateStr,\r
- UuidStr,\r
- NULL,\r
- NULL,\r
- NULL,\r
- NULL,\r
- IsHttps\r
- );\r
+ Instance,\r
+ NULL,\r
+ RedfishServiceLocateStr,\r
+ UuidStr,\r
+ NULL,\r
+ NULL,\r
+ NULL,\r
+ NULL,\r
+ IsHttps\r
+ );\r
}\r
}\r
+\r
return Status;\r
}\r
\r
**/\r
EFI_STATUS\r
AddAndSignalNewRedfishService (\r
- IN EFI_REDFISH_DISCOVERED_INTERNAL_INSTANCE *Instance,\r
- IN UINTN *RedfishVersion OPTIONAL,\r
- IN CHAR8 *RedfishLocation OPTIONAL,\r
- IN CHAR8 *Uuid OPTIONAL,\r
- IN CHAR8 *Os OPTIONAL,\r
- IN CHAR8 *OsVer OPTIONAL,\r
- IN CHAR8 *Product OPTIONAL,\r
- IN CHAR8 *ProductVer OPTIONAL,\r
- IN BOOLEAN UseHttps\r
+ IN EFI_REDFISH_DISCOVERED_INTERNAL_INSTANCE *Instance,\r
+ IN UINTN *RedfishVersion OPTIONAL,\r
+ IN CHAR8 *RedfishLocation OPTIONAL,\r
+ IN CHAR8 *Uuid OPTIONAL,\r
+ IN CHAR8 *Os OPTIONAL,\r
+ IN CHAR8 *OsVer OPTIONAL,\r
+ IN CHAR8 *Product OPTIONAL,\r
+ IN CHAR8 *ProductVer OPTIONAL,\r
+ IN BOOLEAN UseHttps\r
)\r
{\r
- BOOLEAN NewFound;\r
- BOOLEAN InfoRefresh;\r
- BOOLEAN RestExOpened;\r
- BOOLEAN DeleteRestEx;\r
- EFI_STATUS Status;\r
- EFI_REDFISH_DISCOVERED_INTERNAL_LIST *DiscoveredList;\r
- EFI_REDFISH_DISCOVERED_INSTANCE *DiscoveredInstance;\r
- CHAR16 *Char16Uuid;\r
- EFI_REST_EX_PROTOCOL *RestEx;\r
- EFI_REST_EX_HTTP_CONFIG_DATA *RestExHttpConfigData;\r
- EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *NetworkInterface;\r
-\r
- NewFound = TRUE;\r
- InfoRefresh = FALSE;\r
- Char16Uuid = NULL;\r
+ BOOLEAN NewFound;\r
+ BOOLEAN InfoRefresh;\r
+ BOOLEAN RestExOpened;\r
+ BOOLEAN DeleteRestEx;\r
+ EFI_STATUS Status;\r
+ EFI_REDFISH_DISCOVERED_INTERNAL_LIST *DiscoveredList;\r
+ EFI_REDFISH_DISCOVERED_INSTANCE *DiscoveredInstance;\r
+ CHAR16 *Char16Uuid;\r
+ EFI_REST_EX_PROTOCOL *RestEx;\r
+ EFI_REST_EX_HTTP_CONFIG_DATA *RestExHttpConfigData;\r
+ EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *NetworkInterface;\r
+\r
+ NewFound = TRUE;\r
+ InfoRefresh = FALSE;\r
+ Char16Uuid = NULL;\r
RestExOpened = FALSE;\r
DeleteRestEx = FALSE;\r
\r
- DEBUG ((DEBUG_INFO,"%a:Add this instance to Redfish instance list.\n", __FUNCTION__));\r
+ DEBUG ((DEBUG_INFO, "%a:Add this instance to Redfish instance list.\n", __FUNCTION__));\r
\r
if (Uuid != NULL) {\r
- Char16Uuid = (CHAR16 *)AllocateZeroPool(AsciiStrSize((const CHAR8 *)Uuid) * sizeof(CHAR16));\r
- AsciiStrToUnicodeStrS ((const CHAR8 *)Uuid, Char16Uuid, AsciiStrSize((const CHAR8 *)Uuid) * sizeof(CHAR16));\r
+ Char16Uuid = (CHAR16 *)AllocateZeroPool (AsciiStrSize ((const CHAR8 *)Uuid) * sizeof (CHAR16));\r
+ AsciiStrToUnicodeStrS ((const CHAR8 *)Uuid, Char16Uuid, AsciiStrSize ((const CHAR8 *)Uuid) * sizeof (CHAR16));\r
}\r
- DiscoveredList = NULL;\r
- DiscoveredInstance = NULL;\r
+\r
+ DiscoveredList = NULL;\r
+ DiscoveredInstance = NULL;\r
RestExHttpConfigData = NULL;\r
\r
NetworkInterface = Instance->NetworkInterface;\r
// Is this a duplicate redfish service.\r
//\r
DiscoveredList = (EFI_REDFISH_DISCOVERED_INTERNAL_LIST *)GetFirstNode (&mRedfishInstanceList);\r
- NewFound = FALSE;\r
+ NewFound = FALSE;\r
do {\r
- if (Char16Uuid == NULL || DiscoveredList->Instance->Information.Uuid == NULL) {\r
+ if ((Char16Uuid == NULL) || (DiscoveredList->Instance->Information.Uuid == NULL)) {\r
//\r
// Check if this Redfish instance already found using IP addrress.\r
//\r
- if (!CheckIsIpVersion6(NetworkInterface)) {\r
- if (CompareMem ((VOID *)&Instance->TargetIpAddress.v4,\r
- (VOID *)&DiscoveredList->Instance->Information.RedfishHostIpAddress.v4,\r
- sizeof (EFI_IPv4_ADDRESS)\r
- ) == 0)\r
+ if (!CheckIsIpVersion6 (NetworkInterface)) {\r
+ if (CompareMem (\r
+ (VOID *)&Instance->TargetIpAddress.v4,\r
+ (VOID *)&DiscoveredList->Instance->Information.RedfishHostIpAddress.v4,\r
+ sizeof (EFI_IPv4_ADDRESS)\r
+ ) == 0)\r
{\r
DiscoveredInstance = DiscoveredList->Instance;\r
- if (DiscoveredList->Instance->Information.Uuid == NULL &&\r
- Char16Uuid != NULL) {\r
- InfoRefresh = TRUE;\r
+ if ((DiscoveredList->Instance->Information.Uuid == NULL) &&\r
+ (Char16Uuid != NULL))\r
+ {\r
+ InfoRefresh = TRUE;\r
DiscoveredInstance = DiscoveredList->Instance;\r
- DEBUG((DEBUG_INFO,"*** This Redfish Service information refresh ***\n"));\r
+ DEBUG ((DEBUG_INFO, "*** This Redfish Service information refresh ***\n"));\r
}\r
+\r
break;\r
}\r
} else {\r
- if (CompareMem ((VOID *)&Instance->TargetIpAddress.v6,\r
- (VOID *)&DiscoveredList->Instance->Information.RedfishHostIpAddress.v6,\r
- sizeof (EFI_IPv6_ADDRESS)\r
- ) == 0)\r
+ if (CompareMem (\r
+ (VOID *)&Instance->TargetIpAddress.v6,\r
+ (VOID *)&DiscoveredList->Instance->Information.RedfishHostIpAddress.v6,\r
+ sizeof (EFI_IPv6_ADDRESS)\r
+ ) == 0)\r
{\r
DiscoveredInstance = DiscoveredList->Instance;\r
break;\r
//\r
// Check if this Redfish instance already found using UUID.\r
//\r
- if (StrCmp((const CHAR16 *)Char16Uuid, (const CHAR16 *)DiscoveredList->Instance->Information.Uuid) == 0) {\r
+ if (StrCmp ((const CHAR16 *)Char16Uuid, (const CHAR16 *)DiscoveredList->Instance->Information.Uuid) == 0) {\r
DiscoveredInstance = DiscoveredList->Instance;\r
break;\r
}\r
}\r
+\r
if (IsNodeAtEnd (&mRedfishInstanceList, &DiscoveredList->NextInstance)) {\r
NewFound = TRUE;\r
break;\r
}\r
+\r
DiscoveredList = (EFI_REDFISH_DISCOVERED_INTERNAL_LIST *)GetNextNode (&mRedfishInstanceList, &DiscoveredList->NextInstance);\r
} while (TRUE);\r
}\r
+\r
if (NewFound || InfoRefresh) {\r
if (!InfoRefresh) {\r
- DiscoveredList = (EFI_REDFISH_DISCOVERED_INTERNAL_LIST *)AllocateZeroPool(sizeof(EFI_REDFISH_DISCOVERED_INTERNAL_LIST));\r
+ DiscoveredList = (EFI_REDFISH_DISCOVERED_INTERNAL_LIST *)AllocateZeroPool (sizeof (EFI_REDFISH_DISCOVERED_INTERNAL_LIST));\r
if (DiscoveredList == NULL) {\r
return EFI_OUT_OF_RESOURCES;\r
}\r
+\r
InitializeListHead (&DiscoveredList->NextInstance);\r
- DiscoveredInstance = (EFI_REDFISH_DISCOVERED_INSTANCE *)AllocateZeroPool(sizeof(EFI_REDFISH_DISCOVERED_INSTANCE));\r
+ DiscoveredInstance = (EFI_REDFISH_DISCOVERED_INSTANCE *)AllocateZeroPool (sizeof (EFI_REDFISH_DISCOVERED_INSTANCE));\r
if (DiscoveredInstance == NULL) {\r
FreePool ((VOID *)DiscoveredList);\r
return EFI_OUT_OF_RESOURCES;\r
}\r
}\r
- DEBUG ((DEBUG_INFO,"*** Redfish Service Information ***\n"));\r
+\r
+ DEBUG ((DEBUG_INFO, "*** Redfish Service Information ***\n"));\r
\r
DiscoveredInstance->Information.UseHttps = UseHttps;\r
if (RedfishVersion != NULL) {\r
DiscoveredInstance->Information.RedfishVersion = *RedfishVersion;\r
- DEBUG ((DEBUG_INFO,"Redfish service version: %d.\n", DiscoveredInstance->Information.RedfishVersion));\r
+ DEBUG ((DEBUG_INFO, "Redfish service version: %d.\n", DiscoveredInstance->Information.RedfishVersion));\r
}\r
+\r
if (RedfishLocation != NULL) {\r
- DiscoveredInstance->Information.Location = (CHAR16 *)AllocatePool(AsciiStrSize((const CHAR8 *)RedfishLocation) * sizeof(CHAR16));\r
- AsciiStrToUnicodeStrS ((const CHAR8 *)RedfishLocation, DiscoveredInstance->Information.Location, AsciiStrSize((const CHAR8 *)RedfishLocation) * sizeof(CHAR16));\r
- DEBUG ((DEBUG_INFO,"Redfish service location: %s.\n", DiscoveredInstance->Information.Location));\r
+ DiscoveredInstance->Information.Location = (CHAR16 *)AllocatePool (AsciiStrSize ((const CHAR8 *)RedfishLocation) * sizeof (CHAR16));\r
+ AsciiStrToUnicodeStrS ((const CHAR8 *)RedfishLocation, DiscoveredInstance->Information.Location, AsciiStrSize ((const CHAR8 *)RedfishLocation) * sizeof (CHAR16));\r
+ DEBUG ((DEBUG_INFO, "Redfish service location: %s.\n", DiscoveredInstance->Information.Location));\r
}\r
+\r
if (Uuid != NULL) {\r
- DiscoveredInstance->Information.Uuid = (CHAR16 *)AllocatePool(AsciiStrSize((const CHAR8 *)Uuid) * sizeof(CHAR16));\r
- AsciiStrToUnicodeStrS ((const CHAR8 *)Uuid, DiscoveredInstance->Information.Uuid, AsciiStrSize((const CHAR8 *)Uuid) * sizeof(CHAR16));\r
- DEBUG ((DEBUG_INFO,"Service UUID: %s.\n", DiscoveredInstance->Information.Uuid));\r
+ DiscoveredInstance->Information.Uuid = (CHAR16 *)AllocatePool (AsciiStrSize ((const CHAR8 *)Uuid) * sizeof (CHAR16));\r
+ AsciiStrToUnicodeStrS ((const CHAR8 *)Uuid, DiscoveredInstance->Information.Uuid, AsciiStrSize ((const CHAR8 *)Uuid) * sizeof (CHAR16));\r
+ DEBUG ((DEBUG_INFO, "Service UUID: %s.\n", DiscoveredInstance->Information.Uuid));\r
}\r
+\r
if (Os != NULL) {\r
- DiscoveredInstance->Information.Os = (CHAR16 *)AllocatePool(AsciiStrSize((const CHAR8 *)Os) * sizeof(CHAR16));\r
- AsciiStrToUnicodeStrS ((const CHAR8 *)Os, DiscoveredInstance->Information.Os, AsciiStrSize((const CHAR8 *)Os) * sizeof(CHAR16));\r
- DEBUG ((DEBUG_INFO,"Redfish service OS: %s, Version:%s.\n", DiscoveredInstance->Information.Os, DiscoveredInstance->Information.OsVersion));\r
+ DiscoveredInstance->Information.Os = (CHAR16 *)AllocatePool (AsciiStrSize ((const CHAR8 *)Os) * sizeof (CHAR16));\r
+ AsciiStrToUnicodeStrS ((const CHAR8 *)Os, DiscoveredInstance->Information.Os, AsciiStrSize ((const CHAR8 *)Os) * sizeof (CHAR16));\r
+ DEBUG ((DEBUG_INFO, "Redfish service OS: %s, Version:%s.\n", DiscoveredInstance->Information.Os, DiscoveredInstance->Information.OsVersion));\r
}\r
+\r
if (OsVer != NULL) {\r
- DiscoveredInstance->Information.OsVersion = (CHAR16 *)AllocatePool(AsciiStrSize((const CHAR8 *)OsVer) * sizeof(CHAR16));\r
- AsciiStrToUnicodeStrS ((const CHAR8 *)OsVer, DiscoveredInstance->Information.OsVersion, AsciiStrSize((const CHAR8 *)OsVer) * sizeof(CHAR16));\r
+ DiscoveredInstance->Information.OsVersion = (CHAR16 *)AllocatePool (AsciiStrSize ((const CHAR8 *)OsVer) * sizeof (CHAR16));\r
+ AsciiStrToUnicodeStrS ((const CHAR8 *)OsVer, DiscoveredInstance->Information.OsVersion, AsciiStrSize ((const CHAR8 *)OsVer) * sizeof (CHAR16));\r
}\r
- if (Product != NULL && ProductVer != NULL) {\r
- DiscoveredInstance->Information.Product = (CHAR16 *)AllocatePool(AsciiStrSize((const CHAR8 *)Product) * sizeof(CHAR16));\r
- AsciiStrToUnicodeStrS ((const CHAR8 *)Product, DiscoveredInstance->Information.Product, AsciiStrSize((const CHAR8 *)Product) * sizeof(CHAR16));\r
- DiscoveredInstance->Information.ProductVer = (CHAR16 *)AllocatePool(AsciiStrSize((const CHAR8 *)ProductVer) * sizeof(CHAR16));\r
- AsciiStrToUnicodeStrS ((const CHAR8 *)ProductVer, DiscoveredInstance->Information.ProductVer, AsciiStrSize((const CHAR8 *)ProductVer) * sizeof(CHAR16));\r
- DEBUG ((DEBUG_INFO,"Redfish service product: %s, Version:%s.\n", DiscoveredInstance->Information.Product, DiscoveredInstance->Information.ProductVer));\r
+\r
+ if ((Product != NULL) && (ProductVer != NULL)) {\r
+ DiscoveredInstance->Information.Product = (CHAR16 *)AllocatePool (AsciiStrSize ((const CHAR8 *)Product) * sizeof (CHAR16));\r
+ AsciiStrToUnicodeStrS ((const CHAR8 *)Product, DiscoveredInstance->Information.Product, AsciiStrSize ((const CHAR8 *)Product) * sizeof (CHAR16));\r
+ DiscoveredInstance->Information.ProductVer = (CHAR16 *)AllocatePool (AsciiStrSize ((const CHAR8 *)ProductVer) * sizeof (CHAR16));\r
+ AsciiStrToUnicodeStrS ((const CHAR8 *)ProductVer, DiscoveredInstance->Information.ProductVer, AsciiStrSize ((const CHAR8 *)ProductVer) * sizeof (CHAR16));\r
+ DEBUG ((DEBUG_INFO, "Redfish service product: %s, Version:%s.\n", DiscoveredInstance->Information.Product, DiscoveredInstance->Information.ProductVer));\r
}\r
\r
if (RedfishLocation == NULL) {\r
// This is the Redfish reported from SMBIOS 42h\r
// without validation.\r
\r
- IP4_COPY_ADDRESS((VOID *)&DiscoveredInstance->Information.RedfishHostIpAddress.v4, (VOID *)&Instance->TargetIpAddress.v4);\r
+ IP4_COPY_ADDRESS ((VOID *)&DiscoveredInstance->Information.RedfishHostIpAddress.v4, (VOID *)&Instance->TargetIpAddress.v4);\r
}\r
+\r
if (!InfoRefresh) {\r
DiscoveredList->Instance = DiscoveredInstance;\r
- InsertTailList(&mRedfishInstanceList, &DiscoveredList->NextInstance);\r
+ InsertTailList (&mRedfishInstanceList, &DiscoveredList->NextInstance);\r
}\r
+\r
DiscoveredInstance->Status = EFI_SUCCESS;\r
} else {\r
if (DiscoveredList != NULL) {\r
- DEBUG((DEBUG_INFO,"*** This Redfish Service was already found ***\n"));\r
+ DEBUG ((DEBUG_INFO, "*** This Redfish Service was already found ***\n"));\r
if (DiscoveredInstance->Information.Uuid != NULL) {\r
- DEBUG((DEBUG_INFO,"Service UUID: %s.\n", DiscoveredInstance->Information.Uuid));\r
+ DEBUG ((DEBUG_INFO, "Service UUID: %s.\n", DiscoveredInstance->Information.Uuid));\r
} else {\r
- DEBUG((DEBUG_INFO,"Service UUID: unknown.\n"));\r
+ DEBUG ((DEBUG_INFO, "Service UUID: unknown.\n"));\r
}\r
}\r
}\r
+\r
if (Char16Uuid != NULL) {\r
- FreePool((VOID *)Char16Uuid);\r
+ FreePool ((VOID *)Char16Uuid);\r
}\r
\r
Status = EFI_SUCCESS;\r
// Build up EFI_REDFISH_DISCOVERED_LIST in token.\r
//\r
Instance->DiscoverToken->DiscoverList.NumberOfServiceFound = 1;\r
- Instance->DiscoverToken->DiscoverList.RedfishInstances = DiscoveredInstance;\r
- DiscoveredInstance->Status = EFI_SUCCESS;\r
+ Instance->DiscoverToken->DiscoverList.RedfishInstances = DiscoveredInstance;\r
+ DiscoveredInstance->Status = EFI_SUCCESS;\r
if (!InfoRefresh) {\r
Status = CreateRestExInstance (Instance, Instance->DiscoverToken); // Create REST EX child.\r
if (EFI_ERROR (Status)) {\r
- DEBUG ((DEBUG_ERROR, "%a:Can't create REST EX child instance.\n",__FUNCTION__));\r
+ DEBUG ((DEBUG_ERROR, "%a:Can't create REST EX child instance.\n", __FUNCTION__));\r
goto ON_EXIT;\r
}\r
- Status = gBS->OpenProtocol ( // Configure local host information.\r
- Instance->DiscoverToken->DiscoverList.RedfishInstances->Information.RedfishRestExHandle,\r
- &gEfiRestExProtocolGuid,\r
- (VOID **)&RestEx,\r
- Instance->NetworkInterface->OpenDriverAgentHandle,\r
- Instance->NetworkInterface->OpenDriverControllerHandle,\r
- EFI_OPEN_PROTOCOL_BY_DRIVER\r
- );\r
+\r
+ Status = gBS->OpenProtocol (\r
+ // Configure local host information.\r
+ Instance->DiscoverToken->DiscoverList.RedfishInstances->Information.RedfishRestExHandle,\r
+ &gEfiRestExProtocolGuid,\r
+ (VOID **)&RestEx,\r
+ Instance->NetworkInterface->OpenDriverAgentHandle,\r
+ Instance->NetworkInterface->OpenDriverControllerHandle,\r
+ EFI_OPEN_PROTOCOL_BY_DRIVER\r
+ );\r
if (EFI_ERROR (Status)) {\r
DeleteRestEx = TRUE;\r
goto ERROR_EXIT;\r
}\r
- RestExOpened = TRUE;\r
+\r
+ RestExOpened = TRUE;\r
RestExHttpConfigData = AllocateZeroPool (sizeof (EFI_REST_EX_HTTP_CONFIG_DATA));\r
if (RestExHttpConfigData == NULL) {\r
- Status = EFI_OUT_OF_RESOURCES;\r
+ Status = EFI_OUT_OF_RESOURCES;\r
DeleteRestEx = TRUE;\r
goto EXIT_FREE_CONFIG_DATA;\r
}\r
- RestExHttpConfigData->SendReceiveTimeout = 5000;\r
- RestExHttpConfigData->HttpConfigData.HttpVersion = HttpVersion11;\r
- RestExHttpConfigData->HttpConfigData.LocalAddressIsIPv6 = CheckIsIpVersion6(NetworkInterface);\r
+\r
+ RestExHttpConfigData->SendReceiveTimeout = 5000;\r
+ RestExHttpConfigData->HttpConfigData.HttpVersion = HttpVersion11;\r
+ RestExHttpConfigData->HttpConfigData.LocalAddressIsIPv6 = CheckIsIpVersion6 (NetworkInterface);\r
if (RestExHttpConfigData->HttpConfigData.LocalAddressIsIPv6) {\r
RestExHttpConfigData->HttpConfigData.AccessPoint.IPv6Node = AllocateZeroPool (sizeof (EFI_HTTPv6_ACCESS_POINT));\r
if (RestExHttpConfigData->HttpConfigData.AccessPoint.IPv6Node == NULL) {\r
Status = EFI_OUT_OF_RESOURCES;\r
goto EXIT_FREE_CONFIG_DATA;\r
}\r
+\r
RestExHttpConfigData->HttpConfigData.AccessPoint.IPv4Node->UseDefaultAddress = TRUE;\r
}\r
+\r
Status = RestEx->Configure (\r
- RestEx,\r
- (EFI_REST_EX_CONFIG_DATA)(UINT8 *)RestExHttpConfigData\r
- );\r
+ RestEx,\r
+ (EFI_REST_EX_CONFIG_DATA)(UINT8 *)RestExHttpConfigData\r
+ );\r
if (EFI_ERROR (Status)) {\r
- DEBUG ((DEBUG_ERROR,"%a:REST EX configured..\n", __FUNCTION__));\r
+ DEBUG ((DEBUG_ERROR, "%a:REST EX configured..\n", __FUNCTION__));\r
DeleteRestEx = TRUE;\r
goto EXIT_FREE_ALL;\r
}\r
+\r
//\r
// Signal client, close REST EX before signaling client.\r
//\r
if (RestExOpened) {\r
- gBS->CloseProtocol(\r
- Instance->DiscoverToken->DiscoverList.RedfishInstances->Information.RedfishRestExHandle,\r
- &gEfiRestExProtocolGuid,\r
- Instance->NetworkInterface->OpenDriverAgentHandle,\r
- Instance->NetworkInterface->OpenDriverControllerHandle\r
- );\r
+ gBS->CloseProtocol (\r
+ Instance->DiscoverToken->DiscoverList.RedfishInstances->Information.RedfishRestExHandle,\r
+ &gEfiRestExProtocolGuid,\r
+ Instance->NetworkInterface->OpenDriverAgentHandle,\r
+ Instance->NetworkInterface->OpenDriverControllerHandle\r
+ );\r
RestExOpened = FALSE;\r
}\r
}\r
- Status = gBS->SignalEvent(Instance->DiscoverToken->Event);\r
+\r
+ Status = gBS->SignalEvent (Instance->DiscoverToken->Event);\r
if (!EFI_ERROR (Status)) {\r
- DEBUG ((DEBUG_ERROR,"%a:No event to signal!\n", __FUNCTION__));\r
+ DEBUG ((DEBUG_ERROR, "%a:No event to signal!\n", __FUNCTION__));\r
}\r
}\r
\r
EXIT_FREE_ALL:;\r
- if (RestExHttpConfigData != NULL && RestExHttpConfigData->HttpConfigData.AccessPoint.IPv4Node != NULL) {\r
+ if ((RestExHttpConfigData != NULL) && (RestExHttpConfigData->HttpConfigData.AccessPoint.IPv4Node != NULL)) {\r
FreePool (RestExHttpConfigData->HttpConfigData.AccessPoint.IPv4Node);\r
}\r
\r
EXIT_FREE_CONFIG_DATA:;\r
if (RestExHttpConfigData != NULL) {\r
- FreePool((VOID *)RestExHttpConfigData);\r
+ FreePool ((VOID *)RestExHttpConfigData);\r
}\r
+\r
if (RestExOpened) {\r
- gBS->CloseProtocol(\r
+ gBS->CloseProtocol (\r
Instance->DiscoverToken->DiscoverList.RedfishInstances->Information.RedfishRestExHandle,\r
&gEfiRestExProtocolGuid,\r
Instance->NetworkInterface->OpenDriverAgentHandle,\r
Instance->NetworkInterface->OpenDriverControllerHandle\r
- );\r
+ );\r
}\r
+\r
ERROR_EXIT:;\r
- if (DeleteRestEx && RestExOpened) {\r
- gBS->CloseProtocol(\r
+ if (DeleteRestEx && RestExOpened) {\r
+ gBS->CloseProtocol (\r
Instance->DiscoverToken->DiscoverList.RedfishInstances->Information.RedfishRestExHandle,\r
&gEfiRestExProtocolGuid,\r
Instance->NetworkInterface->OpenDriverAgentHandle,\r
Instance->NetworkInterface->OpenDriverControllerHandle\r
- );\r
- }\r
+ );\r
+ }\r
+\r
ON_EXIT:;\r
return Status;\r
}\r
**/\r
EFI_STATUS\r
NetworkInterfaceGetSubnetInfo (\r
- IN EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *Instance,\r
- IN EFI_HANDLE ImageHandle\r
+ IN EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *Instance,\r
+ IN EFI_HANDLE ImageHandle\r
)\r
{\r
- EFI_STATUS Status;\r
- UINT32 ProtocolType;\r
- UINT32 IPv6InfoIndex;\r
- EFI_IP6_ADDRESS_INFO *ThisSubnetAddrInfoIPv6;\r
- EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *NewNetworkInterface;\r
+ EFI_STATUS Status;\r
+ UINT32 ProtocolType;\r
+ UINT32 IPv6InfoIndex;\r
+ EFI_IP6_ADDRESS_INFO *ThisSubnetAddrInfoIPv6;\r
+ EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *NewNetworkInterface;\r
\r
if (Instance->GotSubnetInfo) {\r
return EFI_SUCCESS;\r
}\r
\r
ProtocolType = Instance->NetworkProtocolType;\r
- if (gRequiredProtocol [ProtocolType].GetSubnetInfo != NULL && Instance->GotSubnetInfo == FALSE) {\r
- Status = gRequiredProtocol [ProtocolType].GetSubnetInfo (\r
- ImageHandle,\r
- Instance\r
- );\r
+ if ((gRequiredProtocol[ProtocolType].GetSubnetInfo != NULL) && (Instance->GotSubnetInfo == FALSE)) {\r
+ Status = gRequiredProtocol[ProtocolType].GetSubnetInfo (\r
+ ImageHandle,\r
+ Instance\r
+ );\r
if (EFI_ERROR (Status)) {\r
- DEBUG ((DEBUG_ERROR,"%a:Faile to get Subnet infomation.\n", __FUNCTION__));\r
+ DEBUG ((DEBUG_ERROR, "%a:Faile to get Subnet infomation.\n", __FUNCTION__));\r
return Status;\r
} else {\r
- DEBUG ((DEBUG_INFO,"%a:MAC address: %s\n", __FUNCTION__, Instance->StrMacAddr));\r
+ DEBUG ((DEBUG_INFO, "%a:MAC address: %s\n", __FUNCTION__, Instance->StrMacAddr));\r
if (CheckIsIpVersion6 (Instance)) {\r
if (Instance->SubnetAddrInfoIPv6Number == 0) {\r
- DEBUG ((DEBUG_ERROR,"%a: There is no Subnet infomation for IPv6 network interface.\n", __FUNCTION__));\r
+ DEBUG ((DEBUG_ERROR, "%a: There is no Subnet infomation for IPv6 network interface.\n", __FUNCTION__));\r
return EFI_NOT_FOUND;\r
}\r
+\r
ThisSubnetAddrInfoIPv6 = Instance->SubnetAddrInfoIPv6; // First IPv6 address information.\r
IP6_COPY_ADDRESS (&Instance->SubnetAddr.v6, &ThisSubnetAddrInfoIPv6->Address);\r
Instance->SubnetPrefixLength = ThisSubnetAddrInfoIPv6->PrefixLength;\r
- DEBUG((DEBUG_INFO," IPv6 Subnet ID:%d, Prefix length: %d.\n",\r
- ThisSubnetAddrInfoIPv6->Address.Addr [7] + (UINT16)ThisSubnetAddrInfoIPv6->Address.Addr [6] * 256,\r
- ThisSubnetAddrInfoIPv6->PrefixLength)\r
- );\r
+ DEBUG ((\r
+ DEBUG_INFO,\r
+ " IPv6 Subnet ID:%d, Prefix length: %d.\n",\r
+ ThisSubnetAddrInfoIPv6->Address.Addr[7] + (UINT16)ThisSubnetAddrInfoIPv6->Address.Addr[6] * 256,\r
+ ThisSubnetAddrInfoIPv6->PrefixLength\r
+ )\r
+ );\r
//\r
// If this is IPv6, then we may have to propagate network interface for IPv6 network scopes\r
// according to the Ipv6 address information.\r
//\r
- ThisSubnetAddrInfoIPv6 ++;\r
+ ThisSubnetAddrInfoIPv6++;\r
for (IPv6InfoIndex = 0; IPv6InfoIndex < Instance->SubnetAddrInfoIPv6Number - 1; IPv6InfoIndex++) {\r
//\r
// Build up addtional EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL instances.\r
CopyMem ((VOID *)NewNetworkInterface, (VOID *)Instance, sizeof (EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL)); // Clone information of first instance.\r
IP6_COPY_ADDRESS (&NewNetworkInterface->SubnetAddr.v6, &ThisSubnetAddrInfoIPv6->Address);\r
NewNetworkInterface->SubnetPrefixLength = ThisSubnetAddrInfoIPv6->PrefixLength;\r
- NewNetworkInterface->GotSubnetInfo = TRUE;\r
+ NewNetworkInterface->GotSubnetInfo = TRUE;\r
InsertTailList (&mEfiRedfishDiscoverNetworkInterface, &NewNetworkInterface->Entry);\r
- ThisSubnetAddrInfoIPv6 ++;\r
- mNumNetworkInterface ++;\r
- DEBUG((DEBUG_INFO," IPv6 Subnet ID:%d, Prefix length: %d.\n",\r
- ThisSubnetAddrInfoIPv6->Address.Addr [7] + (UINT16)ThisSubnetAddrInfoIPv6->Address.Addr [6] * 256,\r
- ThisSubnetAddrInfoIPv6->PrefixLength)\r
- );\r
+ ThisSubnetAddrInfoIPv6++;\r
+ mNumNetworkInterface++;\r
+ DEBUG ((\r
+ DEBUG_INFO,\r
+ " IPv6 Subnet ID:%d, Prefix length: %d.\n",\r
+ ThisSubnetAddrInfoIPv6->Address.Addr[7] + (UINT16)ThisSubnetAddrInfoIPv6->Address.Addr[6] * 256,\r
+ ThisSubnetAddrInfoIPv6->PrefixLength\r
+ )\r
+ );\r
} else {\r
return EFI_OUT_OF_RESOURCES;\r
}\r
}\r
} else {\r
- DEBUG ((DEBUG_INFO," IPv4 Subnet:%d.%d.%d.%d Subnet mask: %d.%d.%d.%d.\n",\r
- Instance->SubnetAddr.v4.Addr [0],\r
- Instance->SubnetAddr.v4.Addr [1],\r
- Instance->SubnetAddr.v4.Addr [2],\r
- Instance->SubnetAddr.v4.Addr [3],\r
- Instance->SubnetMask.v4.Addr [0],\r
- Instance->SubnetMask.v4.Addr [1],\r
- Instance->SubnetMask.v4.Addr [2],\r
- Instance->SubnetMask.v4.Addr [3]\r
- ));\r
+ DEBUG ((\r
+ DEBUG_INFO,\r
+ " IPv4 Subnet:%d.%d.%d.%d Subnet mask: %d.%d.%d.%d.\n",\r
+ Instance->SubnetAddr.v4.Addr[0],\r
+ Instance->SubnetAddr.v4.Addr[1],\r
+ Instance->SubnetAddr.v4.Addr[2],\r
+ Instance->SubnetAddr.v4.Addr[3],\r
+ Instance->SubnetMask.v4.Addr[0],\r
+ Instance->SubnetMask.v4.Addr[1],\r
+ Instance->SubnetMask.v4.Addr[2],\r
+ Instance->SubnetMask.v4.Addr[3]\r
+ ));\r
}\r
}\r
}\r
+\r
Instance->GotSubnetInfo = TRUE; // Only try to get Subnet Info once.\r
return EFI_SUCCESS;\r
}\r
EFI_STATUS\r
EFIAPI\r
RedfishServiceGetNetworkInterface (\r
- IN EFI_REDFISH_DISCOVER_PROTOCOL *This,\r
- IN EFI_HANDLE ImageHandle,\r
- OUT UINTN *NumberOfNetworkIntfs,\r
- OUT EFI_REDFISH_DISCOVER_NETWORK_INTERFACE **NetworkIntfInstances\r
-)\r
+ IN EFI_REDFISH_DISCOVER_PROTOCOL *This,\r
+ IN EFI_HANDLE ImageHandle,\r
+ OUT UINTN *NumberOfNetworkIntfs,\r
+ OUT EFI_REDFISH_DISCOVER_NETWORK_INTERFACE **NetworkIntfInstances\r
+ )\r
{\r
- EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *ThisNetworkInterfaceIntn;\r
- EFI_REDFISH_DISCOVER_NETWORK_INTERFACE *ThisNetworkInterface;\r
+ EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *ThisNetworkInterfaceIntn;\r
+ EFI_REDFISH_DISCOVER_NETWORK_INTERFACE *ThisNetworkInterface;\r
\r
- if (NetworkIntfInstances == NULL || NumberOfNetworkIntfs == NULL || ImageHandle == NULL) {\r
+ if ((NetworkIntfInstances == NULL) || (NumberOfNetworkIntfs == NULL) || (ImageHandle == NULL)) {\r
return EFI_INVALID_PARAMETER;\r
}\r
\r
*NumberOfNetworkIntfs = 0;\r
*NetworkIntfInstances = NULL;\r
\r
- if (IsListEmpty ((const LIST_ENTRY*)&mEfiRedfishDiscoverNetworkInterface)) {\r
+ if (IsListEmpty ((const LIST_ENTRY *)&mEfiRedfishDiscoverNetworkInterface)) {\r
return EFI_NOT_FOUND;\r
}\r
\r
if (ThisNetworkInterface == NULL) {\r
return EFI_OUT_OF_RESOURCES;\r
}\r
- *NetworkIntfInstances = ThisNetworkInterface;\r
+\r
+ *NetworkIntfInstances = ThisNetworkInterface;\r
ThisNetworkInterfaceIntn = (EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *)GetFirstNode (&mEfiRedfishDiscoverNetworkInterface);\r
while (TRUE) {\r
ThisNetworkInterface->IsIpv6 = FALSE;\r
if (CheckIsIpVersion6 (ThisNetworkInterfaceIntn)) {\r
ThisNetworkInterface->IsIpv6 = TRUE;\r
}\r
- CopyMem((VOID *)&ThisNetworkInterface->MacAddress, &ThisNetworkInterfaceIntn->MacAddress, ThisNetworkInterfaceIntn->HwAddressSize);\r
- NetworkInterfaceGetSubnetInfo(ThisNetworkInterfaceIntn, ImageHandle); // Get subnet info.\r
+\r
+ CopyMem ((VOID *)&ThisNetworkInterface->MacAddress, &ThisNetworkInterfaceIntn->MacAddress, ThisNetworkInterfaceIntn->HwAddressSize);\r
+ NetworkInterfaceGetSubnetInfo (ThisNetworkInterfaceIntn, ImageHandle); // Get subnet info.\r
if (!ThisNetworkInterface->IsIpv6) {\r
- IP4_COPY_ADDRESS(&ThisNetworkInterface->SubnetId.v4, &ThisNetworkInterfaceIntn->SubnetAddr.v4); // IPv4 subnet information.\r
+ IP4_COPY_ADDRESS (&ThisNetworkInterface->SubnetId.v4, &ThisNetworkInterfaceIntn->SubnetAddr.v4); // IPv4 subnet information.\r
} else {\r
IP6_COPY_ADDRESS (&ThisNetworkInterface->SubnetId.v6, &ThisNetworkInterfaceIntn->SubnetAddr.v6); // IPv6 subnet information in IPv6 address information.\r
}\r
+\r
ThisNetworkInterface->SubnetPrefixLength = ThisNetworkInterfaceIntn->SubnetPrefixLength;\r
- ThisNetworkInterface->VlanId = ThisNetworkInterfaceIntn->VlanId;\r
- (*NumberOfNetworkIntfs) ++;\r
+ ThisNetworkInterface->VlanId = ThisNetworkInterfaceIntn->VlanId;\r
+ (*NumberOfNetworkIntfs)++;\r
if (IsNodeAtEnd (&mEfiRedfishDiscoverNetworkInterface, &ThisNetworkInterfaceIntn->Entry)) {\r
break;\r
}\r
- ThisNetworkInterfaceIntn = (EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *)GetNextNode(&mEfiRedfishDiscoverNetworkInterface, &ThisNetworkInterfaceIntn->Entry);\r
- ThisNetworkInterface ++;\r
- };\r
+\r
+ ThisNetworkInterfaceIntn = (EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *)GetNextNode (&mEfiRedfishDiscoverNetworkInterface, &ThisNetworkInterfaceIntn->Entry);\r
+ ThisNetworkInterface++;\r
+ }\r
+\r
return EFI_SUCCESS;\r
}\r
+\r
/**\r
This function acquires Redfish services by discovering static Redfish setting\r
according to Redfish Host Interface or through SSDP. Returns a list of EFI\r
EFI_STATUS\r
EFIAPI\r
RedfishServiceAcquireService (\r
- IN EFI_REDFISH_DISCOVER_PROTOCOL *This,\r
- IN EFI_HANDLE ImageHandle,\r
+ IN EFI_REDFISH_DISCOVER_PROTOCOL *This,\r
+ IN EFI_HANDLE ImageHandle,\r
IN EFI_REDFISH_DISCOVER_NETWORK_INTERFACE *TargetNetworkInterface,\r
- IN EFI_REDFISH_DISCOVER_FLAG Flags,\r
- IN EFI_REDFISH_DISCOVERED_TOKEN *Token\r
+ IN EFI_REDFISH_DISCOVER_FLAG Flags,\r
+ IN EFI_REDFISH_DISCOVERED_TOKEN *Token\r
)\r
{\r
- EFI_REDFISH_DISCOVERED_INTERNAL_INSTANCE *Instance;\r
- EFI_STATUS Status1;\r
- EFI_STATUS Status2;\r
- BOOLEAN NewInstance;\r
- UINTN NumNetworkInterfaces;\r
- UINTN NetworkInterfacesIndex;\r
- EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *TargetNetworkInterfaceInternal;\r
+ EFI_REDFISH_DISCOVERED_INTERNAL_INSTANCE *Instance;\r
+ EFI_STATUS Status1;\r
+ EFI_STATUS Status2;\r
+ BOOLEAN NewInstance;\r
+ UINTN NumNetworkInterfaces;\r
+ UINTN NetworkInterfacesIndex;\r
+ EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *TargetNetworkInterfaceInternal;\r
\r
- DEBUG ((DEBUG_INFO,"%a:Entry.\n", __FUNCTION__));\r
+ DEBUG ((DEBUG_INFO, "%a:Entry.\n", __FUNCTION__));\r
\r
//\r
// Validate parameters.\r
//\r
- if (ImageHandle == NULL || Token == NULL || ((Flags & ~EFI_REDFISH_DISCOVER_VALIDATION) == 0)) {\r
- DEBUG ((DEBUG_ERROR,"%a:Invalid parameters.\n", __FUNCTION__));\r
+ if ((ImageHandle == NULL) || (Token == NULL) || ((Flags & ~EFI_REDFISH_DISCOVER_VALIDATION) == 0)) {\r
+ DEBUG ((DEBUG_ERROR, "%a:Invalid parameters.\n", __FUNCTION__));\r
return EFI_INVALID_PARAMETER;\r
}\r
+\r
//\r
// Validate target network interface.\r
//\r
if (EFI_ERROR (ValidateTargetNetworkInterface (TargetNetworkInterface, Flags))) {\r
- return EFI_UNSUPPORTED;\r
+ return EFI_UNSUPPORTED;\r
}\r
+\r
if (TargetNetworkInterface != NULL) {\r
TargetNetworkInterfaceInternal = GetTargetNetworkInterfaceInternal (TargetNetworkInterface);\r
- NumNetworkInterfaces = 1;\r
+ NumNetworkInterfaces = 1;\r
} else {\r
TargetNetworkInterfaceInternal = (EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *)GetFirstNode (&mEfiRedfishDiscoverNetworkInterface);\r
- NumNetworkInterfaces = NumberOfNetworkInterface ();\r
+ NumNetworkInterfaces = NumberOfNetworkInterface ();\r
if (NumNetworkInterfaces == 0) {\r
- DEBUG ((DEBUG_ERROR,"%a:No network interface on platform.\n", __FUNCTION__));\r
+ DEBUG ((DEBUG_ERROR, "%a:No network interface on platform.\n", __FUNCTION__));\r
return EFI_UNSUPPORTED;\r
}\r
}\r
- for (NetworkInterfacesIndex = 0; NetworkInterfacesIndex < NumNetworkInterfaces; NetworkInterfacesIndex ++) {\r
- Status1 = EFI_SUCCESS;\r
- Status2 = EFI_SUCCESS;\r
+\r
+ for (NetworkInterfacesIndex = 0; NetworkInterfacesIndex < NumNetworkInterfaces; NetworkInterfacesIndex++) {\r
+ Status1 = EFI_SUCCESS;\r
+ Status2 = EFI_SUCCESS;\r
NewInstance = FALSE;\r
- Instance = GetInstanceByOwner (ImageHandle, TargetNetworkInterfaceInternal, Flags & ~EFI_REDFISH_DISCOVER_VALIDATION); // Check if we can re-use previous instance.\r
+ Instance = GetInstanceByOwner (ImageHandle, TargetNetworkInterfaceInternal, Flags & ~EFI_REDFISH_DISCOVER_VALIDATION); // Check if we can re-use previous instance.\r
if (Instance == NULL) {\r
- DEBUG ((DEBUG_INFO,"%a:Create new EFI_REDFISH_DISCOVERED_INTERNAL_INSTANCE.\n", __FUNCTION__));\r
- Instance = (EFI_REDFISH_DISCOVERED_INTERNAL_INSTANCE *)AllocateZeroPool(sizeof(EFI_REDFISH_DISCOVERED_INTERNAL_INSTANCE));\r
+ DEBUG ((DEBUG_INFO, "%a:Create new EFI_REDFISH_DISCOVERED_INTERNAL_INSTANCE.\n", __FUNCTION__));\r
+ Instance = (EFI_REDFISH_DISCOVERED_INTERNAL_INSTANCE *)AllocateZeroPool (sizeof (EFI_REDFISH_DISCOVERED_INTERNAL_INSTANCE));\r
if (Instance == NULL) {\r
- DEBUG ((DEBUG_ERROR,"%a:Memory allocation fail.\n", __FUNCTION__));\r
+ DEBUG ((DEBUG_ERROR, "%a:Memory allocation fail.\n", __FUNCTION__));\r
}\r
+\r
InitializeListHead (&Instance->Entry);\r
- Instance->Owner = ImageHandle;\r
- Instance->DiscoverFlags = Flags & ~EFI_REDFISH_DISCOVER_VALIDATION;\r
+ Instance->Owner = ImageHandle;\r
+ Instance->DiscoverFlags = Flags & ~EFI_REDFISH_DISCOVER_VALIDATION;\r
Instance->NetworkInterface = TargetNetworkInterfaceInternal;\r
//\r
// Get subnet information in case subnet information is not set because\r
NetworkInterfaceGetSubnetInfo (TargetNetworkInterfaceInternal, ImageHandle);\r
NewInstance = TRUE;\r
}\r
+\r
if (TargetNetworkInterfaceInternal->StrMacAddr != NULL) {\r
- DEBUG((DEBUG_INFO,"%a:Acquire Redfish service on network interface MAC address:%s.\n", __FUNCTION__, TargetNetworkInterfaceInternal->StrMacAddr));\r
+ DEBUG ((DEBUG_INFO, "%a:Acquire Redfish service on network interface MAC address:%s.\n", __FUNCTION__, TargetNetworkInterfaceInternal->StrMacAddr));\r
} else {\r
- DEBUG((DEBUG_INFO,"%a:WARNING: No MAC address on this network interface.\n", __FUNCTION__));\r
+ DEBUG ((DEBUG_INFO, "%a:WARNING: No MAC address on this network interface.\n", __FUNCTION__));\r
}\r
\r
Instance->DiscoverToken = Token; // Always use the latest Token passed by caller.\r
if ((Flags & EFI_REDFISH_DISCOVER_HOST_INTERFACE) != 0) {\r
- DEBUG ((DEBUG_INFO,"%a:Redfish HOST interface discovery.\n", __FUNCTION__));\r
+ DEBUG ((DEBUG_INFO, "%a:Redfish HOST interface discovery.\n", __FUNCTION__));\r
Instance->HostIntfValidation = FALSE;\r
if ((Flags & EFI_REDFISH_DISCOVER_VALIDATION) != 0) {\r
Instance->HostIntfValidation = TRUE;\r
}\r
+\r
Status1 = DiscoverRedfishHostInterface (Instance); // Discover Redfish service through Redfish Host Interface.\r
}\r
+\r
if ((Flags & EFI_REDFISH_DISCOVER_SSDP) != 0) {\r
- DEBUG ((DEBUG_ERROR,"%a:Redfish service discovery through SSDP is not supported\n", __FUNCTION__));\r
+ DEBUG ((DEBUG_ERROR, "%a:Redfish service discovery through SSDP is not supported\n", __FUNCTION__));\r
return EFI_UNSUPPORTED;\r
} else {\r
if (EFI_ERROR (Status1) && EFI_ERROR (Status2)) {\r
FreePool ((VOID *)Instance);\r
- DEBUG ((DEBUG_ERROR,"%a:Something wrong on Redfish service discovery Status1=%x, Status2=%x.\n", __FUNCTION__, Status1, Status2));\r
+ DEBUG ((DEBUG_ERROR, "%a:Something wrong on Redfish service discovery Status1=%x, Status2=%x.\n", __FUNCTION__, Status1, Status2));\r
} else {\r
if (NewInstance) {\r
- InsertTailList(&mRedfishDiscoverList, &Instance->Entry);\r
+ InsertTailList (&mRedfishDiscoverList, &Instance->Entry);\r
}\r
}\r
}\r
+\r
if (TargetNetworkInterface == NULL) {\r
//\r
// Discover Redfish services on all of network interfaces.\r
//\r
- TargetNetworkInterfaceInternal = (EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *)GetNextNode(&mEfiRedfishDiscoverNetworkInterface, &TargetNetworkInterfaceInternal->Entry);\r
+ TargetNetworkInterfaceInternal = (EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *)GetNextNode (&mEfiRedfishDiscoverNetworkInterface, &TargetNetworkInterfaceInternal->Entry);\r
}\r
}\r
+\r
return EFI_SUCCESS;\r
}\r
\r
EFI_STATUS\r
EFIAPI\r
RedfishServiceAbortAcquire (\r
- IN EFI_REDFISH_DISCOVER_PROTOCOL *This,\r
+ IN EFI_REDFISH_DISCOVER_PROTOCOL *This,\r
IN EFI_REDFISH_DISCOVER_NETWORK_INTERFACE *TargetNetworkInterface OPTIONAL\r
-)\r
+ )\r
{\r
// This function is used to abort Redfish service discovery through SSDP\r
// on the network interface. SSDP is optionally supprted by EFI_REDFISH_DISCOVER_PROTOCOL,\r
EFI_STATUS\r
EFIAPI\r
RedfishServiceReleaseService (\r
- IN EFI_REDFISH_DISCOVER_PROTOCOL *This,\r
- IN EFI_REDFISH_DISCOVERED_LIST *InstanceList\r
+ IN EFI_REDFISH_DISCOVER_PROTOCOL *This,\r
+ IN EFI_REDFISH_DISCOVERED_LIST *InstanceList\r
)\r
{\r
- UINTN NumService;\r
- BOOLEAN AnyFailRelease;\r
- EFI_REDFISH_DISCOVERED_INSTANCE *ThisRedfishInstance;\r
- EFI_REDFISH_DISCOVERED_INTERNAL_LIST *DiscoveredRedfishInstance;\r
+ UINTN NumService;\r
+ BOOLEAN AnyFailRelease;\r
+ EFI_REDFISH_DISCOVERED_INSTANCE *ThisRedfishInstance;\r
+ EFI_REDFISH_DISCOVERED_INTERNAL_LIST *DiscoveredRedfishInstance;\r
\r
if (IsListEmpty (&mRedfishInstanceList)) {\r
- DEBUG ((DEBUG_ERROR,"%a:No any discovered Redfish service.\n", __FUNCTION__));\r
+ DEBUG ((DEBUG_ERROR, "%a:No any discovered Redfish service.\n", __FUNCTION__));\r
return EFI_NOT_FOUND;\r
}\r
- AnyFailRelease = FALSE;\r
+\r
+ AnyFailRelease = FALSE;\r
ThisRedfishInstance = InstanceList->RedfishInstances;\r
- for (NumService = 0; NumService < InstanceList->NumberOfServiceFound; NumService ++) {\r
- DiscoveredRedfishInstance = (EFI_REDFISH_DISCOVERED_INTERNAL_LIST *)GetFirstNode(&mRedfishInstanceList);\r
+ for (NumService = 0; NumService < InstanceList->NumberOfServiceFound; NumService++) {\r
+ DiscoveredRedfishInstance = (EFI_REDFISH_DISCOVERED_INTERNAL_LIST *)GetFirstNode (&mRedfishInstanceList);\r
do {\r
if (DiscoveredRedfishInstance->Instance == ThisRedfishInstance) {\r
RemoveEntryList (&DiscoveredRedfishInstance->NextInstance);\r
if (ThisRedfishInstance->Information.Location != NULL) {\r
FreePool (ThisRedfishInstance->Information.Location);\r
}\r
+\r
if (ThisRedfishInstance->Information.Uuid != NULL) {\r
FreePool (ThisRedfishInstance->Information.Uuid);\r
}\r
+\r
if (ThisRedfishInstance->Information.Os != NULL) {\r
FreePool (ThisRedfishInstance->Information.Os);\r
}\r
+\r
if (ThisRedfishInstance->Information.OsVersion != NULL) {\r
FreePool (ThisRedfishInstance->Information.OsVersion);\r
}\r
+\r
if (ThisRedfishInstance->Information.Product != NULL) {\r
FreePool (ThisRedfishInstance->Information.Product);\r
}\r
+\r
if (ThisRedfishInstance->Information.ProductVer != NULL) {\r
FreePool (ThisRedfishInstance->Information.ProductVer);\r
}\r
- FreePool((VOID *)ThisRedfishInstance);\r
+\r
+ FreePool ((VOID *)ThisRedfishInstance);\r
goto ReleaseNext;\r
}\r
\r
- if (IsNodeAtEnd(&mRedfishInstanceList, &DiscoveredRedfishInstance->NextInstance)) {\r
+ if (IsNodeAtEnd (&mRedfishInstanceList, &DiscoveredRedfishInstance->NextInstance)) {\r
break;\r
}\r
- DiscoveredRedfishInstance = (EFI_REDFISH_DISCOVERED_INTERNAL_LIST *)GetNextNode(&mRedfishInstanceList, &DiscoveredRedfishInstance->NextInstance);\r
+\r
+ DiscoveredRedfishInstance = (EFI_REDFISH_DISCOVERED_INTERNAL_LIST *)GetNextNode (&mRedfishInstanceList, &DiscoveredRedfishInstance->NextInstance);\r
} while (TRUE);\r
+\r
AnyFailRelease = TRUE;\r
ReleaseNext:;\r
//\r
//\r
ThisRedfishInstance = (EFI_REDFISH_DISCOVERED_INSTANCE *)((UINT8 *)ThisRedfishInstance + sizeof (EFI_REDFISH_DISCOVERED_INSTANCE));\r
}\r
+\r
if (AnyFailRelease) {\r
return EFI_NOT_FOUND;\r
} else {\r
}\r
}\r
\r
-EFI_REDFISH_DISCOVER_PROTOCOL mRedfishDiscover = {\r
+EFI_REDFISH_DISCOVER_PROTOCOL mRedfishDiscover = {\r
RedfishServiceGetNetworkInterface,\r
RedfishServiceAcquireService,\r
RedfishServiceAbortAcquire,\r
**/\r
EFI_STATUS\r
CreateRedfishDiscoverNetworkInterface (\r
- IN EFI_HANDLE ControllerHandle,\r
- IN UINT32 NetworkProtocolType,\r
- OUT BOOLEAN *IsNewInstance,\r
- OUT EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL **NetworkInterface\r
+ IN EFI_HANDLE ControllerHandle,\r
+ IN UINT32 NetworkProtocolType,\r
+ OUT BOOLEAN *IsNewInstance,\r
+ OUT EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL **NetworkInterface\r
)\r
{\r
- EFI_MAC_ADDRESS MacAddress;\r
- UINTN HwAddressSize;\r
- EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *ThisNetworkInterface;\r
- EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *NewNetworkInterface;\r
+ EFI_MAC_ADDRESS MacAddress;\r
+ UINTN HwAddressSize;\r
+ EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *ThisNetworkInterface;\r
+ EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *NewNetworkInterface;\r
\r
NetLibGetMacAddress (ControllerHandle, &MacAddress, &HwAddressSize);\r
NewNetworkInterface = NULL;\r
- *IsNewInstance = TRUE;\r
- if (!IsListEmpty ((const LIST_ENTRY*)&mEfiRedfishDiscoverNetworkInterface)) {\r
+ *IsNewInstance = TRUE;\r
+ if (!IsListEmpty ((const LIST_ENTRY *)&mEfiRedfishDiscoverNetworkInterface)) {\r
//\r
// Check if this instance already exist.\r
//\r
if (ThisNetworkInterface != NULL) {\r
while (TRUE) {\r
if ((CompareMem ((CONST VOID *)&ThisNetworkInterface->MacAddress.Addr, (CONST VOID *)&MacAddress.Addr, HwAddressSize) == 0) &&\r
- (ThisNetworkInterface->NetworkProtocolType == NetworkProtocolType)){\r
+ (ThisNetworkInterface->NetworkProtocolType == NetworkProtocolType))\r
+ {\r
NewNetworkInterface = ThisNetworkInterface;\r
- *IsNewInstance = FALSE;\r
+ *IsNewInstance = FALSE;\r
break;\r
}\r
+\r
if (IsNodeAtEnd (&mEfiRedfishDiscoverNetworkInterface, &ThisNetworkInterface->Entry)) {\r
NewNetworkInterface = NULL;\r
break;\r
}\r
- ThisNetworkInterface = (EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *)GetNextNode(&mEfiRedfishDiscoverNetworkInterface, &ThisNetworkInterface->Entry);\r
- };\r
+\r
+ ThisNetworkInterface = (EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *)GetNextNode (&mEfiRedfishDiscoverNetworkInterface, &ThisNetworkInterface->Entry);\r
+ }\r
}\r
}\r
+\r
if (NewNetworkInterface == NULL) {\r
//\r
// Create a new instance.\r
if (NewNetworkInterface == NULL) {\r
return EFI_OUT_OF_RESOURCES;\r
}\r
+\r
NewNetworkInterface->HwAddressSize = HwAddressSize;\r
CopyMem (&NewNetworkInterface->MacAddress.Addr, &MacAddress.Addr, NewNetworkInterface->HwAddressSize);\r
NetLibGetMacString (ControllerHandle, NULL, &NewNetworkInterface->StrMacAddr);\r
NewNetworkInterface->VlanId = NetLibGetVlanId (ControllerHandle);\r
}\r
+\r
*NetworkInterface = NewNetworkInterface;\r
return EFI_SUCCESS;\r
}\r
**/\r
EFI_STATUS\r
DestroyRedfishNetwrokInterface (\r
- IN EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *ThisNetworkInterface\r
+ IN EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *ThisNetworkInterface\r
)\r
{\r
- EFI_STATUS Status;\r
+ EFI_STATUS Status;\r
\r
- Status = gBS->UninstallProtocolInterface(\r
+ Status = gBS->UninstallProtocolInterface (\r
ThisNetworkInterface->OpenDriverControllerHandle,\r
- gRequiredProtocol [ThisNetworkInterface->NetworkProtocolType].DiscoveredProtocolGuid,\r
+ gRequiredProtocol[ThisNetworkInterface->NetworkProtocolType].DiscoveredProtocolGuid,\r
&ThisNetworkInterface->NetworkInterfaceProtocolInfo.ProtocolDiscoverId\r
);\r
RemoveEntryList (&ThisNetworkInterface->Entry);\r
- mNumNetworkInterface --;\r
+ mNumNetworkInterface--;\r
FreePool (ThisNetworkInterface);\r
return Status;\r
}\r
EFI_STATUS\r
TestForRequiredProtocols (\r
IN EFI_DRIVER_BINDING_PROTOCOL *This,\r
- IN EFI_HANDLE ControllerHandle\r
+ IN EFI_HANDLE ControllerHandle\r
)\r
{\r
- UINT32 Id;\r
- UINTN Index;\r
- EFI_STATUS Status;\r
+ UINT32 Id;\r
+ UINTN Index;\r
+ EFI_STATUS Status;\r
\r
- for (Index = 0; Index < (sizeof (gRequiredProtocol) / sizeof (REDFISH_DISCOVER_REQUIRED_PROTOCOL)); Index ++) {\r
+ for (Index = 0; Index < (sizeof (gRequiredProtocol) / sizeof (REDFISH_DISCOVER_REQUIRED_PROTOCOL)); Index++) {\r
Status = gBS->OpenProtocol (\r
- ControllerHandle,\r
- gRequiredProtocol [Index].RequiredServiceBindingProtocolGuid,\r
- NULL,\r
- This->DriverBindingHandle,\r
- ControllerHandle,\r
- EFI_OPEN_PROTOCOL_TEST_PROTOCOL\r
- );\r
+ ControllerHandle,\r
+ gRequiredProtocol[Index].RequiredServiceBindingProtocolGuid,\r
+ NULL,\r
+ This->DriverBindingHandle,\r
+ ControllerHandle,\r
+ EFI_OPEN_PROTOCOL_TEST_PROTOCOL\r
+ );\r
if (!EFI_ERROR (Status)) {\r
Status = gBS->OpenProtocol (\r
ControllerHandle,\r
- gRequiredProtocol [Index].DiscoveredProtocolGuid,\r
- (VOID **) &Id,\r
+ gRequiredProtocol[Index].DiscoveredProtocolGuid,\r
+ (VOID **)&Id,\r
This->DriverBindingHandle,\r
ControllerHandle,\r
EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
);\r
if (EFI_ERROR (Status)) {\r
- DEBUG((DEBUG_ERROR, "%a: %s is found on this controller handle.\n", __FUNCTION__, gRequiredProtocol [Index].ProtocolName));\r
+ DEBUG ((DEBUG_ERROR, "%a: %s is found on this controller handle.\n", __FUNCTION__, gRequiredProtocol[Index].ProtocolName));\r
return EFI_SUCCESS;\r
}\r
}\r
}\r
+\r
return EFI_UNSUPPORTED;\r
}\r
\r
EFI_STATUS\r
BuildupNetworkInterface (\r
IN EFI_DRIVER_BINDING_PROTOCOL *This,\r
- IN EFI_HANDLE ControllerHandle\r
+ IN EFI_HANDLE ControllerHandle\r
)\r
{\r
- UINT32 Id;\r
- UINT32 Index;\r
- EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *NetworkInterface;\r
- BOOLEAN IsNew;\r
- EFI_STATUS Status;\r
- VOID *TempInterface;\r
- VOID **Interface;\r
- UINT32 *ProtocolDiscoverIdPtr;\r
- EFI_HANDLE OpenDriverAgentHandle;\r
- EFI_HANDLE OpenDriverControllerHandle;\r
- EFI_HANDLE *HandleOfProtocolInterfacePtr;\r
- EFI_REDFISH_DISCOVER_REST_EX_INSTANCE_INTERNAL *RestExInstance;\r
- EFI_TPL OldTpl;\r
- BOOLEAN NewNetworkInterfaceInstalled;\r
+ UINT32 Id;\r
+ UINT32 Index;\r
+ EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *NetworkInterface;\r
+ BOOLEAN IsNew;\r
+ EFI_STATUS Status;\r
+ VOID *TempInterface;\r
+ VOID **Interface;\r
+ UINT32 *ProtocolDiscoverIdPtr;\r
+ EFI_HANDLE OpenDriverAgentHandle;\r
+ EFI_HANDLE OpenDriverControllerHandle;\r
+ EFI_HANDLE *HandleOfProtocolInterfacePtr;\r
+ EFI_REDFISH_DISCOVER_REST_EX_INSTANCE_INTERNAL *RestExInstance;\r
+ EFI_TPL OldTpl;\r
+ BOOLEAN NewNetworkInterfaceInstalled;\r
\r
NewNetworkInterfaceInstalled = FALSE;\r
- Index = 0;\r
+ Index = 0;\r
do {\r
- Status = gBS->OpenProtocol ( // Already in list?\r
+ Status = gBS->OpenProtocol (\r
+ // Already in list?\r
ControllerHandle,\r
- gRequiredProtocol [Index].DiscoveredProtocolGuid,\r
- (VOID **) &Id,\r
+ gRequiredProtocol[Index].DiscoveredProtocolGuid,\r
+ (VOID **)&Id,\r
This->DriverBindingHandle,\r
ControllerHandle,\r
EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
);\r
if (!EFI_ERROR (Status)) {\r
- Index ++;\r
- if (Index == (sizeof(gRequiredProtocol) / sizeof(REDFISH_DISCOVER_REQUIRED_PROTOCOL))) {\r
+ Index++;\r
+ if (Index == (sizeof (gRequiredProtocol) / sizeof (REDFISH_DISCOVER_REQUIRED_PROTOCOL))) {\r
break;\r
}\r
+\r
continue;\r
}\r
\r
Status = gBS->OpenProtocol (\r
ControllerHandle,\r
- gRequiredProtocol [Index].RequiredServiceBindingProtocolGuid,\r
+ gRequiredProtocol[Index].RequiredServiceBindingProtocolGuid,\r
&TempInterface,\r
This->DriverBindingHandle,\r
ControllerHandle,\r
EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
);\r
if (EFI_ERROR (Status)) {\r
- Index ++;\r
- if (Index == (sizeof(gRequiredProtocol) / sizeof(REDFISH_DISCOVER_REQUIRED_PROTOCOL))) {\r
+ Index++;\r
+ if (Index == (sizeof (gRequiredProtocol) / sizeof (REDFISH_DISCOVER_REQUIRED_PROTOCOL))) {\r
break;\r
}\r
+\r
continue;\r
}\r
- if (gRequiredProtocol [Index].ProtocolType != ProtocolTypeRestEx) {\r
+\r
+ if (gRequiredProtocol[Index].ProtocolType != ProtocolTypeRestEx) {\r
OldTpl = gBS->RaiseTPL (EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_TPL);\r
- Status = CreateRedfishDiscoverNetworkInterface(ControllerHandle, gRequiredProtocol [Index].ProtocolType, &IsNew, &NetworkInterface);\r
+ Status = CreateRedfishDiscoverNetworkInterface (ControllerHandle, gRequiredProtocol[Index].ProtocolType, &IsNew, &NetworkInterface);\r
if (EFI_ERROR (Status)) {\r
gBS->RestoreTPL (OldTpl);\r
return Status;\r
}\r
- NetworkInterface->NetworkProtocolType = gRequiredProtocol [Index].ProtocolType;\r
- NetworkInterface->OpenDriverAgentHandle = This->DriverBindingHandle;\r
- NetworkInterface->OpenDriverControllerHandle = ControllerHandle;\r
+\r
+ NetworkInterface->NetworkProtocolType = gRequiredProtocol[Index].ProtocolType;\r
+ NetworkInterface->OpenDriverAgentHandle = This->DriverBindingHandle;\r
+ NetworkInterface->OpenDriverControllerHandle = ControllerHandle;\r
NetworkInterface->NetworkInterfaceProtocolInfo.ProtocolGuid = \\r
- *gRequiredProtocol [Index].RequiredProtocolGuid;\r
+ *gRequiredProtocol[Index].RequiredProtocolGuid;\r
NetworkInterface->NetworkInterfaceProtocolInfo.ProtocolServiceGuid = \\r
- *gRequiredProtocol [Index].RequiredServiceBindingProtocolGuid;\r
- ProtocolDiscoverIdPtr = &NetworkInterface->NetworkInterfaceProtocolInfo.ProtocolDiscoverId;\r
- OpenDriverAgentHandle = NetworkInterface->OpenDriverAgentHandle;\r
- OpenDriverControllerHandle = NetworkInterface->OpenDriverControllerHandle;\r
+ *gRequiredProtocol[Index].RequiredServiceBindingProtocolGuid;\r
+ ProtocolDiscoverIdPtr = &NetworkInterface->NetworkInterfaceProtocolInfo.ProtocolDiscoverId;\r
+ OpenDriverAgentHandle = NetworkInterface->OpenDriverAgentHandle;\r
+ OpenDriverControllerHandle = NetworkInterface->OpenDriverControllerHandle;\r
HandleOfProtocolInterfacePtr = &NetworkInterface->NetworkInterfaceProtocolInfo.ProtocolControllerHandle;\r
- Interface = &NetworkInterface->NetworkInterfaceProtocolInfo.NetworkProtocolInterface;\r
+ Interface = &NetworkInterface->NetworkInterfaceProtocolInfo.NetworkProtocolInterface;\r
NewNetworkInterfaceInstalled = TRUE;\r
if (IsNew) {\r
InsertTailList (&mEfiRedfishDiscoverNetworkInterface, &NetworkInterface->Entry);\r
- mNumNetworkInterface ++;\r
+ mNumNetworkInterface++;\r
}\r
+\r
gBS->RestoreTPL (OldTpl);\r
} else {\r
// Record REST_EX instance. REST_EX is created when clinet asks for Redfish service discovery.\r
if (RestExInstance == NULL) {\r
return EFI_OUT_OF_RESOURCES;\r
}\r
- RestExInstance->OpenDriverAgentHandle = This->DriverBindingHandle;\r
+\r
+ RestExInstance->OpenDriverAgentHandle = This->DriverBindingHandle;\r
RestExInstance->OpenDriverControllerHandle = ControllerHandle;\r
- RestExInstance->RestExControllerHandle = ControllerHandle;\r
+ RestExInstance->RestExControllerHandle = ControllerHandle;\r
InitializeListHead (&RestExInstance->Entry);\r
InsertTailList (&mEfiRedfishDiscoverRestExInstance, &RestExInstance->Entry);\r
- mNumRestExInstance ++;\r
- ProtocolDiscoverIdPtr = &RestExInstance->RestExId;\r
- OpenDriverAgentHandle = RestExInstance->OpenDriverAgentHandle;\r
- OpenDriverControllerHandle = RestExInstance->OpenDriverControllerHandle;\r
+ mNumRestExInstance++;\r
+ ProtocolDiscoverIdPtr = &RestExInstance->RestExId;\r
+ OpenDriverAgentHandle = RestExInstance->OpenDriverAgentHandle;\r
+ OpenDriverControllerHandle = RestExInstance->OpenDriverControllerHandle;\r
HandleOfProtocolInterfacePtr = &RestExInstance->RestExChildHandle;\r
- Interface = (VOID **)&RestExInstance->RestExProtocolInterface;\r
+ Interface = (VOID **)&RestExInstance->RestExProtocolInterface;\r
}\r
+\r
Status = gBS->InstallProtocolInterface (\r
&ControllerHandle,\r
- gRequiredProtocol [Index].DiscoveredProtocolGuid,\r
+ gRequiredProtocol[Index].DiscoveredProtocolGuid,\r
EFI_NATIVE_INTERFACE,\r
ProtocolDiscoverIdPtr\r
);\r
if (EFI_ERROR (Status)) {\r
- Index ++;\r
- if (Index == (sizeof(gRequiredProtocol) / sizeof(REDFISH_DISCOVER_REQUIRED_PROTOCOL))) {\r
+ Index++;\r
+ if (Index == (sizeof (gRequiredProtocol) / sizeof (REDFISH_DISCOVER_REQUIRED_PROTOCOL))) {\r
break;\r
}\r
+\r
continue;\r
}\r
+\r
//\r
// Create service binding child and open it BY_DRIVER.\r
//\r
Status = NetLibCreateServiceChild (\r
- ControllerHandle,\r
- This->ImageHandle,\r
- gRequiredProtocol [Index].RequiredServiceBindingProtocolGuid,\r
- HandleOfProtocolInterfacePtr\r
- );\r
+ ControllerHandle,\r
+ This->ImageHandle,\r
+ gRequiredProtocol[Index].RequiredServiceBindingProtocolGuid,\r
+ HandleOfProtocolInterfacePtr\r
+ );\r
if (!EFI_ERROR (Status)) {\r
Status = gBS->OpenProtocol (\r
- *HandleOfProtocolInterfacePtr,\r
- gRequiredProtocol [Index].RequiredProtocolGuid,\r
- Interface,\r
- OpenDriverAgentHandle,\r
- OpenDriverControllerHandle,\r
- EFI_OPEN_PROTOCOL_BY_DRIVER\r
- );\r
+ *HandleOfProtocolInterfacePtr,\r
+ gRequiredProtocol[Index].RequiredProtocolGuid,\r
+ Interface,\r
+ OpenDriverAgentHandle,\r
+ OpenDriverControllerHandle,\r
+ EFI_OPEN_PROTOCOL_BY_DRIVER\r
+ );\r
if (!EFI_ERROR (Status)) {\r
- if (EfiRedfishDiscoverProtocolHandle == NULL &&\r
- (gRequiredProtocol [Index].ProtocolType == ProtocolTypeRestEx) &&\r
+ if ((EfiRedfishDiscoverProtocolHandle == NULL) &&\r
+ (gRequiredProtocol[Index].ProtocolType == ProtocolTypeRestEx) &&\r
!IsListEmpty (&mEfiRedfishDiscoverNetworkInterface)\r
- ) {\r
+ )\r
+ {\r
// Install the fisrt Redfish Discover Protocol when EFI REST EX protcol is discovered.\r
// This ensures EFI REST EX is ready while EFI_REDFISH_DISCOVER_PROTOCOL consumer acquires\r
// Redfish serivce over network interface.\r
EFI_NATIVE_INTERFACE,\r
(VOID *)&mRedfishDiscover\r
);\r
- } else if (EfiRedfishDiscoverProtocolHandle != NULL && NewNetworkInterfaceInstalled) {\r
- Status = gBS->ReinstallProtocolInterface (\r
- EfiRedfishDiscoverProtocolHandle,\r
- &gEfiRedfishDiscoverProtocolGuid,\r
- (VOID *)&mRedfishDiscover,\r
- (VOID *)&mRedfishDiscover\r
- );\r
- NewNetworkInterfaceInstalled = FALSE;\r
+ } else if ((EfiRedfishDiscoverProtocolHandle != NULL) && NewNetworkInterfaceInstalled) {\r
+ Status = gBS->ReinstallProtocolInterface (\r
+ EfiRedfishDiscoverProtocolHandle,\r
+ &gEfiRedfishDiscoverProtocolGuid,\r
+ (VOID *)&mRedfishDiscover,\r
+ (VOID *)&mRedfishDiscover\r
+ );\r
+ NewNetworkInterfaceInstalled = FALSE;\r
}\r
}\r
+\r
return Status;\r
} else {\r
- Index ++;\r
- if (Index == (sizeof(gRequiredProtocol) / sizeof(REDFISH_DISCOVER_REQUIRED_PROTOCOL))) {\r
+ Index++;\r
+ if (Index == (sizeof (gRequiredProtocol) / sizeof (REDFISH_DISCOVER_REQUIRED_PROTOCOL))) {\r
break;\r
}\r
+\r
continue;\r
}\r
- } while (Index < (sizeof(gRequiredProtocol) / sizeof(REDFISH_DISCOVER_REQUIRED_PROTOCOL)));\r
+ } while (Index < (sizeof (gRequiredProtocol) / sizeof (REDFISH_DISCOVER_REQUIRED_PROTOCOL)));\r
+\r
return EFI_UNSUPPORTED;\r
}\r
+\r
/**\r
Close the protocol opened for Redfish discovery. This function also destories\r
the network services.\r
**/\r
EFI_STATUS\r
CloseProtocolService (\r
- IN EFI_DRIVER_BINDING_PROTOCOL *ThisBindingProtocol,\r
- IN EFI_HANDLE ControllerHandle,\r
- IN REDFISH_DISCOVER_REQUIRED_PROTOCOL *ThisRequiredProtocol,\r
- IN EFI_HANDLE DriverAgentHandle,\r
- IN EFI_HANDLE DriverControllerHandle\r
-)\r
+ IN EFI_DRIVER_BINDING_PROTOCOL *ThisBindingProtocol,\r
+ IN EFI_HANDLE ControllerHandle,\r
+ IN REDFISH_DISCOVER_REQUIRED_PROTOCOL *ThisRequiredProtocol,\r
+ IN EFI_HANDLE DriverAgentHandle,\r
+ IN EFI_HANDLE DriverControllerHandle\r
+ )\r
{\r
- EFI_STATUS Status;\r
+ EFI_STATUS Status;\r
\r
Status = gBS->CloseProtocol (\r
- ControllerHandle,\r
- ThisRequiredProtocol->RequiredProtocolGuid,\r
- DriverAgentHandle,\r
- DriverControllerHandle\r
- );\r
+ ControllerHandle,\r
+ ThisRequiredProtocol->RequiredProtocolGuid,\r
+ DriverAgentHandle,\r
+ DriverControllerHandle\r
+ );\r
if (!EFI_ERROR (Status)) {\r
- NetLibDestroyServiceChild(\r
+ NetLibDestroyServiceChild (\r
ControllerHandle,\r
ThisBindingProtocol->ImageHandle,\r
ThisRequiredProtocol->RequiredServiceBindingProtocolGuid,\r
ControllerHandle\r
);\r
}\r
+\r
return Status;\r
}\r
+\r
/**\r
Stop the services on network interface.\r
\r
EFI_STATUS\r
StopServiceOnNetworkInterface (\r
IN EFI_DRIVER_BINDING_PROTOCOL *ThisBindingProtocol,\r
- IN EFI_HANDLE ControllerHandle\r
+ IN EFI_HANDLE ControllerHandle\r
)\r
{\r
- UINT32 Index;\r
- EFI_STATUS Status;\r
- VOID *Interface;\r
- EFI_TPL OldTpl;\r
- EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *ThisNetworkInterface;\r
- EFI_REDFISH_DISCOVER_REST_EX_INSTANCE_INTERNAL *RestExInstance;\r
-\r
- for (Index = 0; Index < (sizeof (gRequiredProtocol) / sizeof (REDFISH_DISCOVER_REQUIRED_PROTOCOL)); Index ++) {\r
+ UINT32 Index;\r
+ EFI_STATUS Status;\r
+ VOID *Interface;\r
+ EFI_TPL OldTpl;\r
+ EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *ThisNetworkInterface;\r
+ EFI_REDFISH_DISCOVER_REST_EX_INSTANCE_INTERNAL *RestExInstance;\r
+\r
+ for (Index = 0; Index < (sizeof (gRequiredProtocol) / sizeof (REDFISH_DISCOVER_REQUIRED_PROTOCOL)); Index++) {\r
Status = gBS->HandleProtocol (\r
- ControllerHandle,\r
- gRequiredProtocol [Index].RequiredProtocolGuid,\r
- (VOID **)&Interface\r
- );\r
+ ControllerHandle,\r
+ gRequiredProtocol[Index].RequiredProtocolGuid,\r
+ (VOID **)&Interface\r
+ );\r
if (!EFI_ERROR (Status)) {\r
- if (gRequiredProtocol [Index].ProtocolType != ProtocolTypeRestEx) {\r
+ if (gRequiredProtocol[Index].ProtocolType != ProtocolTypeRestEx) {\r
if (IsListEmpty (&mEfiRedfishDiscoverNetworkInterface)) {\r
return EFI_NOT_FOUND;\r
}\r
- OldTpl = gBS->RaiseTPL (EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_TPL);\r
+\r
+ OldTpl = gBS->RaiseTPL (EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_TPL);\r
ThisNetworkInterface = (EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *)GetFirstNode (&mEfiRedfishDiscoverNetworkInterface);\r
while (TRUE) {\r
if (ThisNetworkInterface->NetworkInterfaceProtocolInfo.ProtocolControllerHandle == ControllerHandle) {\r
-\r
- Status = CloseProtocolService ( // Close protocol and destroy service.\r
+ Status = CloseProtocolService (\r
+ // Close protocol and destroy service.\r
ThisBindingProtocol,\r
ControllerHandle,\r
- &gRequiredProtocol [Index],\r
+ &gRequiredProtocol[Index],\r
ThisNetworkInterface->OpenDriverAgentHandle,\r
ThisNetworkInterface->OpenDriverControllerHandle\r
);\r
if (!EFI_ERROR (Status)) {\r
Status = DestroyRedfishNetwrokInterface (ThisNetworkInterface);\r
}\r
+\r
gBS->RestoreTPL (OldTpl);\r
// Reinstall Redfish Discover protocol to notify network\r
// interface change.\r
(VOID *)&mRedfishDiscover\r
);\r
if (EFI_ERROR (Status)) {\r
- DEBUG((DEBUG_ERROR, "%a: Reinstall gEfiRedfishDiscoverProtocolGuid fail.", __FUNCTION__));\r
+ DEBUG ((DEBUG_ERROR, "%a: Reinstall gEfiRedfishDiscoverProtocolGuid fail.", __FUNCTION__));\r
}\r
+\r
return Status;\r
}\r
+\r
if (IsNodeAtEnd (&mEfiRedfishDiscoverNetworkInterface, &ThisNetworkInterface->Entry)) {\r
break;\r
}\r
- ThisNetworkInterface = (EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *)GetNextNode(&mEfiRedfishDiscoverNetworkInterface, &ThisNetworkInterface->Entry);\r
- };\r
+\r
+ ThisNetworkInterface = (EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *)GetNextNode (&mEfiRedfishDiscoverNetworkInterface, &ThisNetworkInterface->Entry);\r
+ }\r
+\r
gBS->RestoreTPL (OldTpl);\r
} else {\r
if (IsListEmpty (&mEfiRedfishDiscoverRestExInstance)) {\r
return EFI_NOT_FOUND;\r
}\r
- OldTpl = gBS->RaiseTPL (EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_TPL);\r
+\r
+ OldTpl = gBS->RaiseTPL (EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_TPL);\r
RestExInstance = (EFI_REDFISH_DISCOVER_REST_EX_INSTANCE_INTERNAL *)GetFirstNode (&mEfiRedfishDiscoverRestExInstance);\r
while (TRUE) {\r
if (RestExInstance->RestExChildHandle == ControllerHandle) {\r
- Status = CloseProtocolService ( // Close REST_EX protocol.\r
+ Status = CloseProtocolService (\r
+ // Close REST_EX protocol.\r
ThisBindingProtocol,\r
ControllerHandle,\r
- &gRequiredProtocol [Index],\r
+ &gRequiredProtocol[Index],\r
RestExInstance->OpenDriverAgentHandle,\r
RestExInstance->OpenDriverControllerHandle\r
);\r
RemoveEntryList (&RestExInstance->Entry);\r
FreePool ((VOID *)RestExInstance);\r
- mNumRestExInstance --;\r
+ mNumRestExInstance--;\r
gBS->RestoreTPL (OldTpl);\r
return Status;\r
}\r
+\r
if (IsNodeAtEnd (&mEfiRedfishDiscoverRestExInstance, &RestExInstance->Entry)) {\r
break;\r
}\r
- RestExInstance = (EFI_REDFISH_DISCOVER_REST_EX_INSTANCE_INTERNAL *)GetNextNode(&mEfiRedfishDiscoverRestExInstance, &RestExInstance->Entry);\r
- };\r
+\r
+ RestExInstance = (EFI_REDFISH_DISCOVER_REST_EX_INSTANCE_INTERNAL *)GetNextNode (&mEfiRedfishDiscoverRestExInstance, &RestExInstance->Entry);\r
+ }\r
+\r
gBS->RestoreTPL (OldTpl);\r
}\r
}\r
}\r
+\r
return EFI_NOT_FOUND;\r
}\r
+\r
/**\r
Tests to see if this driver supports a given controller. If a child device is provided,\r
it further tests to see if this driver supports creating a handle for the specified child device.\r
return StopServiceOnNetworkInterface (This, ControllerHandle);\r
}\r
\r
-EFI_DRIVER_BINDING_PROTOCOL gRedfishDiscoverDriverBinding = {\r
+EFI_DRIVER_BINDING_PROTOCOL gRedfishDiscoverDriverBinding = {\r
RedfishDiscoverDriverBindingSupported,\r
RedfishDiscoverDriverBindingStart,\r
RedfishDiscoverDriverBindingStop,\r
IN EFI_SYSTEM_TABLE *SystemTable\r
)\r
{\r
- EFI_STATUS Status;\r
+ EFI_STATUS Status;\r
\r
Status = EFI_SUCCESS;\r
InitializeListHead (&mRedfishDiscoverList);\r
EFI_STATUS\r
EFIAPI\r
RedfishDiscoverUnload (\r
- IN EFI_HANDLE ImageHandle\r
+ IN EFI_HANDLE ImageHandle\r
)\r
{\r
- EFI_STATUS Status;\r
- EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *ThisNetworkInterface;\r
+ EFI_STATUS Status;\r
+ EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *ThisNetworkInterface;\r
\r
Status = EFI_SUCCESS;\r
// Destroy all network interfaces found by EFI Redfish Discover driver and\r
while (!IsListEmpty (&mEfiRedfishDiscoverNetworkInterface)) {\r
ThisNetworkInterface = (EFI_REDFISH_DISCOVER_NETWORK_INTERFACE_INTERNAL *)GetFirstNode (&mEfiRedfishDiscoverNetworkInterface);\r
StopServiceOnNetworkInterface (&gRedfishDiscoverDriverBinding, ThisNetworkInterface->NetworkInterfaceProtocolInfo.ProtocolControllerHandle);\r
- };\r
+ }\r
+\r
// Disconnect EFI Redfish discover driver controller to notify the\r
// clinet which uses .EFI Redfish discover protocol.\r
\r
// Notify user EFI_REDFISH_DISCOVER_PROTOCOL is unloaded.\r
//\r
gBS->DisconnectController (EfiRedfishDiscoverProtocolHandle, NULL, NULL);\r
- Status = gBS->UninstallProtocolInterface(\r
+ Status = gBS->UninstallProtocolInterface (\r
EfiRedfishDiscoverProtocolHandle,\r
&gEfiRedfishDiscoverProtocolGuid,\r
(VOID *)&mRedfishDiscover\r
);\r
}\r
+\r
return Status;\r
}\r
projects / mirror_edk2.git / blobdiff