TlsDriver.c

Go to the documentation of this file.

 
#include "TlsImpl.h"
 
EFI_SERVICE_BINDING_PROTOCOL  mTlsServiceBinding = {
  TlsServiceBindingCreateChild,
  TlsServiceBindingDestroyChild
};
 
VOID
TlsCleanInstance (
  IN TLS_INSTANCE  *Instance
  )
{
  if (Instance != NULL) {
    if (Instance->TlsConn != NULL) {
      TlsFree (Instance->TlsConn);
    }
 
    FreePool (Instance);
  }
}
 
EFI_STATUS
TlsCreateInstance (
  IN  TLS_SERVICE   *Service,
  OUT TLS_INSTANCE  **Instance
  )
{
  TLS_INSTANCE  *TlsInstance;
 
  *Instance = NULL;
 
  TlsInstance = AllocateZeroPool (sizeof (TLS_INSTANCE));
  if (TlsInstance == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  TlsInstance->Signature = TLS_INSTANCE_SIGNATURE;
  InitializeListHead (&TlsInstance->Link);
  TlsInstance->InDestroy = FALSE;
  TlsInstance->Service   = Service;
 
  CopyMem (&TlsInstance->Tls, &mTlsProtocol, sizeof (TlsInstance->Tls));
  CopyMem (&TlsInstance->TlsConfig, &mTlsConfigurationProtocol, sizeof (TlsInstance->TlsConfig));
 
  TlsInstance->TlsSessionState = EfiTlsSessionNotStarted;
 
  *Instance = TlsInstance;
 
  return EFI_SUCCESS;
}
 
VOID
TlsCleanService (
  IN TLS_SERVICE  *Service
  )
{
  if (Service != NULL) {
    if (Service->TlsCtx != NULL) {
      TlsCtxFree (Service->TlsCtx);
    }
 
    FreePool (Service);
  }
}
 
EFI_STATUS
TlsCreateService (
  IN  EFI_HANDLE   Image,
  OUT TLS_SERVICE  **Service
  )
{
  TLS_SERVICE  *TlsService;
 
  ASSERT (Service != NULL);
 
  *Service = NULL;
 
  //
  // Allocate a TLS Service Data
  //
  TlsService = AllocateZeroPool (sizeof (TLS_SERVICE));
  if (TlsService == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  //
  // Initialize TLS Service Data
  //
  TlsService->Signature = TLS_SERVICE_SIGNATURE;
  CopyMem (&TlsService->ServiceBinding, &mTlsServiceBinding, sizeof (TlsService->ServiceBinding));
  TlsService->TlsChildrenNum = 0;
  InitializeListHead (&TlsService->TlsChildrenList);
  TlsService->ImageHandle = Image;
 
  *Service = TlsService;
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
TlsUnload (
  IN EFI_HANDLE  ImageHandle
  )
{
  EFI_STATUS                    Status;
  UINTN                         HandleNum;
  EFI_HANDLE                    *HandleBuffer;
  UINT32                        Index;
  EFI_SERVICE_BINDING_PROTOCOL  *ServiceBinding;
  TLS_SERVICE                   *TlsService;
 
  HandleBuffer   = NULL;
  ServiceBinding = NULL;
  TlsService     = NULL;
 
  //
  // Locate all the handles with Tls service binding protocol.
  //
  Status = gBS->LocateHandleBuffer (
                  ByProtocol,
                  &gEfiTlsServiceBindingProtocolGuid,
                  NULL,
                  &HandleNum,
                  &HandleBuffer
                  );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  for (Index = 0; Index < HandleNum; Index++) {
    //
    // Firstly, find ServiceBinding interface
    //
    Status = gBS->OpenProtocol (
                    HandleBuffer[Index],
                    &gEfiTlsServiceBindingProtocolGuid,
                    (VOID **)&ServiceBinding,
                    ImageHandle,
                    NULL,
                    EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL
                    );
    if (EFI_ERROR (Status)) {
      return Status;
    }
 
    TlsService = TLS_SERVICE_FROM_THIS (ServiceBinding);
 
    //
    // Then, uninstall ServiceBinding interface
    //
    Status = gBS->UninstallMultipleProtocolInterfaces (
                    HandleBuffer[Index],
                    &gEfiTlsServiceBindingProtocolGuid,
                    ServiceBinding,
                    NULL
                    );
    if (EFI_ERROR (Status)) {
      return Status;
    }
 
    TlsCleanService (TlsService);
  }
 
  if (HandleBuffer != NULL) {
    FreePool (HandleBuffer);
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
TlsDriverEntryPoint (
  IN EFI_HANDLE        ImageHandle,
  IN EFI_SYSTEM_TABLE  *SystemTable
  )
{
  EFI_STATUS  Status;
 
  TLS_SERVICE  *TlsService;
 
  //
  // Create TLS Service
  //
  Status = TlsCreateService (ImageHandle, &TlsService);
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  ASSERT (TlsService != NULL);
 
  //
  // Initializes the OpenSSL library.
  //
  TlsInitialize ();
 
  //
  // Create a new SSL_CTX object as framework to establish TLS/SSL enabled
  // connections. TLS 1.0 is used as the default version.
  //
  TlsService->TlsCtx = TlsCtxNew (TLS10_PROTOCOL_VERSION_MAJOR, TLS10_PROTOCOL_VERSION_MINOR);
  if (TlsService->TlsCtx == NULL) {
    FreePool (TlsService);
    return EFI_ABORTED;
  }
 
  //
  // Install the TlsServiceBinding Protocol onto Handle
  //
  Status = gBS->InstallMultipleProtocolInterfaces (
                  &TlsService->Handle,
                  &gEfiTlsServiceBindingProtocolGuid,
                  &TlsService->ServiceBinding,
                  NULL
                  );
  if (EFI_ERROR (Status)) {
    goto ON_CLEAN_SERVICE;
  }
 
  return Status;
 
ON_CLEAN_SERVICE:
  TlsCleanService (TlsService);
 
  return Status;
}
 
EFI_STATUS
EFIAPI
TlsServiceBindingCreateChild (
  IN EFI_SERVICE_BINDING_PROTOCOL  *This,
  IN EFI_HANDLE                    *ChildHandle
  )
{
  TLS_SERVICE   *TlsService;
  TLS_INSTANCE  *TlsInstance;
  EFI_STATUS    Status;
  EFI_TPL       OldTpl;
 
  if ((This == NULL) || (ChildHandle == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  TlsService = TLS_SERVICE_FROM_THIS (This);
 
  Status = TlsCreateInstance (TlsService, &TlsInstance);
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  ASSERT (TlsInstance != NULL);
 
  //
  // Create a new TLS connection object.
  //
  TlsInstance->TlsConn = TlsNew (TlsService->TlsCtx);
  if (TlsInstance->TlsConn == NULL) {
    Status = EFI_ABORTED;
    goto ON_ERROR;
  }
 
  //
  // Set default ConnectionEnd to EfiTlsClient
  //
  Status = TlsSetConnectionEnd (TlsInstance->TlsConn, EfiTlsClient);
  if (EFI_ERROR (Status)) {
    goto ON_ERROR;
  }
 
  //
  // Install TLS protocol and configuration protocol onto ChildHandle
  //
  Status = gBS->InstallMultipleProtocolInterfaces (
                  ChildHandle,
                  &gEfiTlsProtocolGuid,
                  &TlsInstance->Tls,
                  &gEfiTlsConfigurationProtocolGuid,
                  &TlsInstance->TlsConfig,
                  NULL
                  );
  if (EFI_ERROR (Status)) {
    goto ON_ERROR;
  }
 
  TlsInstance->ChildHandle = *ChildHandle;
 
  //
  // Add it to the TLS service's child list.
  //
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  InsertTailList (&TlsService->TlsChildrenList, &TlsInstance->Link);
  TlsService->TlsChildrenNum++;
 
  gBS->RestoreTPL (OldTpl);
 
  return EFI_SUCCESS;
 
ON_ERROR:
  TlsCleanInstance (TlsInstance);
  return Status;
}
 
EFI_STATUS
EFIAPI
TlsServiceBindingDestroyChild (
  IN EFI_SERVICE_BINDING_PROTOCOL  *This,
  IN EFI_HANDLE                    ChildHandle
  )
{
  TLS_SERVICE   *TlsService;
  TLS_INSTANCE  *TlsInstance;
 
  EFI_TLS_PROTOCOL                *Tls;
  EFI_TLS_CONFIGURATION_PROTOCOL  *TlsConfig;
  EFI_STATUS                      Status;
  EFI_TPL                         OldTpl;
 
  if ((This == NULL) || (ChildHandle == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  TlsService = TLS_SERVICE_FROM_THIS (This);
 
  //
  // Find TLS protocol interface installed in ChildHandle
  //
  Status = gBS->OpenProtocol (
                  ChildHandle,
                  &gEfiTlsProtocolGuid,
                  (VOID **)&Tls,
                  TlsService->ImageHandle,
                  NULL,
                  EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL
                  );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  //
  // Find TLS configuration protocol interface installed in ChildHandle
  //
  Status = gBS->OpenProtocol (
                  ChildHandle,
                  &gEfiTlsConfigurationProtocolGuid,
                  (VOID **)&TlsConfig,
                  TlsService->ImageHandle,
                  NULL,
                  EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL
                  );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  TlsInstance = TLS_INSTANCE_FROM_PROTOCOL (Tls);
 
  if (TlsInstance->Service != TlsService) {
    return EFI_INVALID_PARAMETER;
  }
 
  if (TlsInstance->InDestroy) {
    return EFI_SUCCESS;
  }
 
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  TlsInstance->InDestroy = TRUE;
 
  //
  // Uninstall the TLS protocol and TLS Configuration Protocol interface installed in ChildHandle.
  //
  Status = gBS->UninstallMultipleProtocolInterfaces (
                  ChildHandle,
                  &gEfiTlsProtocolGuid,
                  Tls,
                  &gEfiTlsConfigurationProtocolGuid,
                  TlsConfig,
                  NULL
                  );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  RemoveEntryList (&TlsInstance->Link);
  TlsService->TlsChildrenNum--;
 
  gBS->RestoreTPL (OldTpl);
 
  TlsCleanInstance (TlsInstance);
 
  return EFI_SUCCESS;
}