RedfishMisc.c

Go to the documentation of this file.

 
#include "RedfishMisc.h"
 
EDKII_REDFISH_CREDENTIAL_PROTOCOL  *mCredentialProtocol = NULL;
 
EFI_STATUS
RedfishGetServiceVersion (
  IN  REDFISH_SERVICE  RedfishService,
  OUT CHAR8            **ServiceVersionStr
  )
{
  redfishService  *Redfish;
  CHAR8           **KeysArray;
  UINTN           KeysNum;
 
  if ((RedfishService == NULL) || (ServiceVersionStr == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  Redfish = (redfishService *)RedfishService;
  if (Redfish->versions == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  KeysArray = JsonObjectGetKeys (Redfish->versions, &KeysNum);
  if ((KeysNum == 0) || (KeysArray  == NULL)) {
    return EFI_NOT_FOUND;
  }
 
  *ServiceVersionStr = *KeysArray;
  return EFI_SUCCESS;
}
 
REDFISH_SERVICE
RedfishCreateLibredfishService (
  IN  REDFISH_CONFIG_SERVICE_INFORMATION  *RedfishConfigServiceInfo,
  IN  EDKII_REDFISH_AUTH_METHOD           AuthMethod,
  IN  CHAR8                               *UserId,
  IN  CHAR8                               *Password
  )
{
  UINTN                     Flags;
  enumeratorAuthentication  Auth;
  redfishService            *Redfish;
 
  Redfish = NULL;
 
  ZeroMem (&Auth, sizeof (Auth));
  if (AuthMethod == AuthMethodHttpBasic) {
    Auth.authType = REDFISH_AUTH_BASIC;
  } else if (AuthMethod == AuthMethodRedfishSession) {
    Auth.authType = REDFISH_AUTH_SESSION;
  }
 
  Auth.authCodes.userPass.username = UserId;
  Auth.authCodes.userPass.password = Password;
 
  Flags = REDFISH_FLAG_SERVICE_NO_VERSION_DOC;
 
  if (AuthMethod != AuthMethodNone) {
    Redfish = createServiceEnumerator (RedfishConfigServiceInfo, NULL, &Auth, (unsigned int)Flags);
  } else {
    Redfish = createServiceEnumerator (RedfishConfigServiceInfo, NULL, NULL, (unsigned int)Flags);
  }
 
  //
  // Zero the Password after use.
  //
  if (Password != NULL) {
    ZeroMem (Password, AsciiStrLen (Password));
  }
 
  return (REDFISH_SERVICE)Redfish;
}
 
EFI_STATUS
RedfishGetAuthInfo (
  OUT  EDKII_REDFISH_AUTH_METHOD  *AuthMethod,
  OUT  CHAR8                      **UserId,
  OUT  CHAR8                      **Password
  )
{
  EFI_STATUS  Status;
 
  if ((AuthMethod == NULL) || (UserId == NULL) || (Password == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  //
  // Locate Redfish Credential Protocol.
  //
  if (mCredentialProtocol == NULL) {
    Status = gBS->LocateProtocol (&gEdkIIRedfishCredentialProtocolGuid, NULL, (VOID **)&mCredentialProtocol);
    if (EFI_ERROR (Status)) {
      return EFI_UNSUPPORTED;
    }
  }
 
  ASSERT (mCredentialProtocol != NULL);
 
  Status = mCredentialProtocol->GetAuthInfo (mCredentialProtocol, AuthMethod, UserId, Password);
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR, "RedfishGetAuthInfo: failed to retrieve Redfish credential - %r\n", Status));
    return Status;
  }
 
  return Status;
}
 
EFI_STATUS
RedfishBuildRedpathUseId (
  IN  CHAR8  *ServiceVersionStr,
  IN  CHAR8  *Url,
  IN  CHAR8  *Id,
  OUT CHAR8  **Redpath
  )
{
  UINTN  RedpathSize;
 
  if ((Redpath == NULL) || (ServiceVersionStr == NULL) || (Url == NULL) || (Id == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  RedpathSize = AsciiStrLen ("/") +
                AsciiStrLen (ServiceVersionStr) +
                AsciiStrLen (Url) +
                AsciiStrLen ("[Id=]") +
                AsciiStrLen (Id) + 1;
  *Redpath = AllocatePool (RedpathSize);
  if (*Redpath == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  AsciiSPrint (*Redpath, RedpathSize, "/%a%a[Id=%a]", ServiceVersionStr, Url, Id);
  return EFI_SUCCESS;
}