HttpDriver.c

Go to the documentation of this file.

 
#include "HttpDriver.h"
 
EFI_HTTP_UTILITIES_PROTOCOL  *mHttpUtilities = NULL;
 
EFI_DRIVER_BINDING_PROTOCOL  gHttpDxeIp4DriverBinding = {
  HttpDxeIp4DriverBindingSupported,
  HttpDxeIp4DriverBindingStart,
  HttpDxeIp4DriverBindingStop,
  HTTP_DRIVER_VERSION,
  NULL,
  NULL
};
 
EFI_DRIVER_BINDING_PROTOCOL  gHttpDxeIp6DriverBinding = {
  HttpDxeIp6DriverBindingSupported,
  HttpDxeIp6DriverBindingStart,
  HttpDxeIp6DriverBindingStop,
  HTTP_DRIVER_VERSION,
  NULL,
  NULL
};
 
EFI_STATUS
HttpCreateService (
  IN  EFI_HANDLE    Controller,
  OUT HTTP_SERVICE  **ServiceData
  )
{
  HTTP_SERVICE  *HttpService;
 
  ASSERT (ServiceData != NULL);
  *ServiceData = NULL;
 
  HttpService = AllocateZeroPool (sizeof (HTTP_SERVICE));
  if (HttpService == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  HttpService->Signature                   = HTTP_SERVICE_SIGNATURE;
  HttpService->ServiceBinding.CreateChild  = HttpServiceBindingCreateChild;
  HttpService->ServiceBinding.DestroyChild = HttpServiceBindingDestroyChild;
  HttpService->ControllerHandle            = Controller;
  HttpService->ChildrenNumber              = 0;
  InitializeListHead (&HttpService->ChildrenList);
 
  *ServiceData = HttpService;
  return EFI_SUCCESS;
}
 
VOID
HttpCleanService (
  IN HTTP_SERVICE  *HttpService,
  IN BOOLEAN       UsingIpv6
  )
{
  if (HttpService == NULL) {
    return;
  }
 
  if (!UsingIpv6) {
    if (HttpService->Tcp4ChildHandle != NULL) {
      gBS->CloseProtocol (
             HttpService->Tcp4ChildHandle,
             &gEfiTcp4ProtocolGuid,
             HttpService->Ip4DriverBindingHandle,
             HttpService->ControllerHandle
             );
 
      NetLibDestroyServiceChild (
        HttpService->ControllerHandle,
        HttpService->Ip4DriverBindingHandle,
        &gEfiTcp4ServiceBindingProtocolGuid,
        HttpService->Tcp4ChildHandle
        );
 
      HttpService->Tcp4ChildHandle = NULL;
    }
  } else {
    if (HttpService->Tcp6ChildHandle != NULL) {
      gBS->CloseProtocol (
             HttpService->Tcp6ChildHandle,
             &gEfiTcp6ProtocolGuid,
             HttpService->Ip6DriverBindingHandle,
             HttpService->ControllerHandle
             );
 
      NetLibDestroyServiceChild (
        HttpService->ControllerHandle,
        HttpService->Ip6DriverBindingHandle,
        &gEfiTcp6ServiceBindingProtocolGuid,
        HttpService->Tcp6ChildHandle
        );
 
      HttpService->Tcp6ChildHandle = NULL;
    }
  }
}
 
VOID
EFIAPI
HttpUtilitiesInstalledCallback (
  IN EFI_EVENT  Event,
  IN VOID       *Context
  )
{
  gBS->LocateProtocol (
         &gEfiHttpUtilitiesProtocolGuid,
         NULL,
         (VOID **)&mHttpUtilities
         );
 
  //
  // Close the event if Http utilities protocol is located.
  //
  if ((mHttpUtilities != NULL) && (Event != NULL)) {
    gBS->CloseEvent (Event);
  }
}
 
EFI_STATUS
EFIAPI
HttpDxeDriverEntryPoint (
  IN EFI_HANDLE        ImageHandle,
  IN EFI_SYSTEM_TABLE  *SystemTable
  )
{
  EFI_STATUS  Status;
  VOID        *Registration;
 
  gBS->LocateProtocol (
         &gEfiHttpUtilitiesProtocolGuid,
         NULL,
         (VOID **)&mHttpUtilities
         );
 
  if (mHttpUtilities == NULL) {
    //
    // No Http utilities protocol, register a notify.
    //
    EfiCreateProtocolNotifyEvent (
      &gEfiHttpUtilitiesProtocolGuid,
      TPL_CALLBACK,
      HttpUtilitiesInstalledCallback,
      NULL,
      &Registration
      );
  }
 
  //
  // Install UEFI Driver Model protocol(s).
  //
  Status = EfiLibInstallDriverBindingComponentName2 (
             ImageHandle,
             SystemTable,
             &gHttpDxeIp4DriverBinding,
             ImageHandle,
             &gHttpDxeComponentName,
             &gHttpDxeComponentName2
             );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  Status = EfiLibInstallDriverBindingComponentName2 (
             ImageHandle,
             SystemTable,
             &gHttpDxeIp6DriverBinding,
             NULL,
             &gHttpDxeComponentName,
             &gHttpDxeComponentName2
             );
  if (EFI_ERROR (Status)) {
    EfiLibUninstallDriverBindingComponentName2 (
      &gHttpDxeIp4DriverBinding,
      &gHttpDxeComponentName,
      &gHttpDxeComponentName2
      );
  }
 
  return Status;
}
 
EFI_STATUS
EFIAPI
HttpDestroyChildEntryInHandleBuffer (
  IN LIST_ENTRY  *Entry,
  IN VOID        *Context
  )
{
  HTTP_PROTOCOL                 *HttpInstance;
  EFI_SERVICE_BINDING_PROTOCOL  *ServiceBinding;
  UINTN                         NumberOfChildren;
  EFI_HANDLE                    *ChildHandleBuffer;
 
  if ((Entry == NULL) || (Context == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  HttpInstance      = NET_LIST_USER_STRUCT_S (Entry, HTTP_PROTOCOL, Link, HTTP_PROTOCOL_SIGNATURE);
  ServiceBinding    = ((HTTP_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT *)Context)->ServiceBinding;
  NumberOfChildren  = ((HTTP_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT *)Context)->NumberOfChildren;
  ChildHandleBuffer = ((HTTP_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT *)Context)->ChildHandleBuffer;
 
  if (!NetIsInHandleBuffer (HttpInstance->Handle, NumberOfChildren, ChildHandleBuffer)) {
    return EFI_SUCCESS;
  }
 
  return ServiceBinding->DestroyChild (ServiceBinding, HttpInstance->Handle);
}
 
EFI_STATUS
EFIAPI
HttpDxeSupported (
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
  IN EFI_HANDLE                   ControllerHandle,
  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL,
  IN UINT8                        IpVersion
  )
{
  EFI_STATUS  Status;
  EFI_GUID    *TcpServiceBindingProtocolGuid;
 
  if (IpVersion == IP_VERSION_4) {
    TcpServiceBindingProtocolGuid = &gEfiTcp4ServiceBindingProtocolGuid;
  } else {
    TcpServiceBindingProtocolGuid = &gEfiTcp6ServiceBindingProtocolGuid;
  }
 
  Status = gBS->OpenProtocol (
                  ControllerHandle,
                  TcpServiceBindingProtocolGuid,
                  NULL,
                  This->DriverBindingHandle,
                  ControllerHandle,
                  EFI_OPEN_PROTOCOL_TEST_PROTOCOL
                  );
 
  if (EFI_ERROR (Status)) {
    return EFI_UNSUPPORTED;
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
HttpDxeStart (
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
  IN EFI_HANDLE                   ControllerHandle,
  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL,
  IN UINT8                        IpVersion
  )
{
  EFI_STATUS                    Status;
  EFI_SERVICE_BINDING_PROTOCOL  *ServiceBinding;
  HTTP_SERVICE                  *HttpService;
  VOID                          *Interface;
  BOOLEAN                       UsingIpv6;
 
  UsingIpv6 = FALSE;
 
  //
  // Test for the Http service binding protocol
  //
  Status = gBS->OpenProtocol (
                  ControllerHandle,
                  &gEfiHttpServiceBindingProtocolGuid,
                  (VOID **)&ServiceBinding,
                  This->DriverBindingHandle,
                  ControllerHandle,
                  EFI_OPEN_PROTOCOL_GET_PROTOCOL
                  );
 
  if (!EFI_ERROR (Status)) {
    HttpService = HTTP_SERVICE_FROM_PROTOCOL (ServiceBinding);
  } else {
    Status = HttpCreateService (ControllerHandle, &HttpService);
    if (EFI_ERROR (Status)) {
      return Status;
    }
 
    ASSERT (HttpService != NULL);
 
    //
    // Install the HttpServiceBinding Protocol onto Controller
    //
    Status = gBS->InstallMultipleProtocolInterfaces (
                    &ControllerHandle,
                    &gEfiHttpServiceBindingProtocolGuid,
                    &HttpService->ServiceBinding,
                    NULL
                    );
 
    if (EFI_ERROR (Status)) {
      goto ON_ERROR;
    }
  }
 
  if (IpVersion == IP_VERSION_4) {
    HttpService->Ip4DriverBindingHandle = This->DriverBindingHandle;
 
    if (HttpService->Tcp4ChildHandle == NULL) {
      //
      // Create a TCP4 child instance, but do not configure it. This will establish the parent-child relationship.
      //
      Status = NetLibCreateServiceChild (
                 ControllerHandle,
                 This->DriverBindingHandle,
                 &gEfiTcp4ServiceBindingProtocolGuid,
                 &HttpService->Tcp4ChildHandle
                 );
 
      if (EFI_ERROR (Status)) {
        goto ON_ERROR;
      }
 
      Status = gBS->OpenProtocol (
                      HttpService->Tcp4ChildHandle,
                      &gEfiTcp4ProtocolGuid,
                      &Interface,
                      This->DriverBindingHandle,
                      ControllerHandle,
                      EFI_OPEN_PROTOCOL_BY_DRIVER
                      );
 
      if (EFI_ERROR (Status)) {
        goto ON_ERROR;
      }
    } else {
      return EFI_ALREADY_STARTED;
    }
  } else {
    UsingIpv6                           = TRUE;
    HttpService->Ip6DriverBindingHandle = This->DriverBindingHandle;
 
    if (HttpService->Tcp6ChildHandle == NULL) {
      //
      // Create a TCP6 child instance, but do not configure it. This will establish the parent-child relationship.
      //
      Status = NetLibCreateServiceChild (
                 ControllerHandle,
                 This->DriverBindingHandle,
                 &gEfiTcp6ServiceBindingProtocolGuid,
                 &HttpService->Tcp6ChildHandle
                 );
 
      if (EFI_ERROR (Status)) {
        goto ON_ERROR;
      }
 
      Status = gBS->OpenProtocol (
                      HttpService->Tcp6ChildHandle,
                      &gEfiTcp6ProtocolGuid,
                      &Interface,
                      This->DriverBindingHandle,
                      ControllerHandle,
                      EFI_OPEN_PROTOCOL_BY_DRIVER
                      );
 
      if (EFI_ERROR (Status)) {
        goto ON_ERROR;
      }
    } else {
      return EFI_ALREADY_STARTED;
    }
  }
 
  return EFI_SUCCESS;
 
ON_ERROR:
 
  if (HttpService != NULL) {
    HttpCleanService (HttpService, UsingIpv6);
    Status = gBS->UninstallMultipleProtocolInterfaces (
                    &ControllerHandle,
                    &gEfiHttpServiceBindingProtocolGuid,
                    &HttpService->ServiceBinding,
                    NULL
                    );
    if (!EFI_ERROR (Status)) {
      if ((HttpService->Tcp4ChildHandle == NULL) && (HttpService->Tcp6ChildHandle == NULL)) {
        FreePool (HttpService);
      }
    }
  }
 
  return Status;
}
 
EFI_STATUS
EFIAPI
HttpDxeStop (
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
  IN EFI_HANDLE                   ControllerHandle,
  IN UINTN                        NumberOfChildren,
  IN EFI_HANDLE                   *ChildHandleBuffer,
  IN UINT8                        IpVersion
  )
{
  EFI_HANDLE                                NicHandle;
  EFI_STATUS                                Status;
  EFI_SERVICE_BINDING_PROTOCOL              *ServiceBinding;
  HTTP_SERVICE                              *HttpService;
  LIST_ENTRY                                *List;
  HTTP_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT  Context;
  BOOLEAN                                   UsingIpv6;
 
  //
  // HTTP driver opens TCP4(6) child, So, Controller is a TCP4(6)
  // child handle. Locate the Nic handle first. Then get the
  // HTTP private data back.
  //
  if (IpVersion == IP_VERSION_4) {
    UsingIpv6 = FALSE;
    NicHandle = NetLibGetNicHandle (ControllerHandle, &gEfiTcp4ProtocolGuid);
  } else {
    UsingIpv6 = TRUE;
    NicHandle = NetLibGetNicHandle (ControllerHandle, &gEfiTcp6ProtocolGuid);
  }
 
  if (NicHandle == NULL) {
    return EFI_SUCCESS;
  }
 
  Status = gBS->OpenProtocol (
                  NicHandle,
                  &gEfiHttpServiceBindingProtocolGuid,
                  (VOID **)&ServiceBinding,
                  This->DriverBindingHandle,
                  NicHandle,
                  EFI_OPEN_PROTOCOL_GET_PROTOCOL
                  );
 
  if (!EFI_ERROR (Status)) {
    HttpService = HTTP_SERVICE_FROM_PROTOCOL (ServiceBinding);
 
    if (NumberOfChildren != 0) {
      //
      // Destroy the HTTP child instance in ChildHandleBuffer.
      //
      List                      = &HttpService->ChildrenList;
      Context.ServiceBinding    = ServiceBinding;
      Context.NumberOfChildren  = NumberOfChildren;
      Context.ChildHandleBuffer = ChildHandleBuffer;
      Status                    = NetDestroyLinkList (
                                    List,
                                    HttpDestroyChildEntryInHandleBuffer,
                                    &Context,
                                    NULL
                                    );
    } else {
      HttpCleanService (HttpService, UsingIpv6);
 
      if ((HttpService->Tcp4ChildHandle == NULL) && (HttpService->Tcp6ChildHandle == NULL)) {
        gBS->UninstallProtocolInterface (
               NicHandle,
               &gEfiHttpServiceBindingProtocolGuid,
               ServiceBinding
               );
        FreePool (HttpService);
      }
 
      Status = EFI_SUCCESS;
    }
  }
 
  return Status;
}
 
EFI_STATUS
EFIAPI
HttpDxeIp4DriverBindingSupported (
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
  IN EFI_HANDLE                   ControllerHandle,
  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL
  )
{
  return HttpDxeSupported (
           This,
           ControllerHandle,
           RemainingDevicePath,
           IP_VERSION_4
           );
}
 
EFI_STATUS
EFIAPI
HttpDxeIp4DriverBindingStart (
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
  IN EFI_HANDLE                   ControllerHandle,
  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL
  )
{
  return HttpDxeStart (
           This,
           ControllerHandle,
           RemainingDevicePath,
           IP_VERSION_4
           );
}
 
EFI_STATUS
EFIAPI
HttpDxeIp4DriverBindingStop (
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
  IN EFI_HANDLE                   ControllerHandle,
  IN UINTN                        NumberOfChildren,
  IN EFI_HANDLE                   *ChildHandleBuffer OPTIONAL
  )
{
  return HttpDxeStop (
           This,
           ControllerHandle,
           NumberOfChildren,
           ChildHandleBuffer,
           IP_VERSION_4
           );
}
 
EFI_STATUS
EFIAPI
HttpDxeIp6DriverBindingSupported (
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
  IN EFI_HANDLE                   ControllerHandle,
  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL
  )
{
  return HttpDxeSupported (
           This,
           ControllerHandle,
           RemainingDevicePath,
           IP_VERSION_6
           );
}
 
EFI_STATUS
EFIAPI
HttpDxeIp6DriverBindingStart (
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
  IN EFI_HANDLE                   ControllerHandle,
  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL
  )
{
  return HttpDxeStart (
           This,
           ControllerHandle,
           RemainingDevicePath,
           IP_VERSION_6
           );
}
 
EFI_STATUS
EFIAPI
HttpDxeIp6DriverBindingStop (
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
  IN EFI_HANDLE                   ControllerHandle,
  IN UINTN                        NumberOfChildren,
  IN EFI_HANDLE                   *ChildHandleBuffer OPTIONAL
  )
{
  return HttpDxeStop (
           This,
           ControllerHandle,
           NumberOfChildren,
           ChildHandleBuffer,
           IP_VERSION_6
           );
}
 
EFI_STATUS
EFIAPI
HttpServiceBindingCreateChild (
  IN EFI_SERVICE_BINDING_PROTOCOL  *This,
  IN OUT EFI_HANDLE                *ChildHandle
  )
{
  HTTP_SERVICE   *HttpService;
  HTTP_PROTOCOL  *HttpInstance;
  EFI_STATUS     Status;
  EFI_TPL        OldTpl;
 
  if ((This == NULL) || (ChildHandle == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  HttpService  = HTTP_SERVICE_FROM_PROTOCOL (This);
  HttpInstance = AllocateZeroPool (sizeof (HTTP_PROTOCOL));
  if (HttpInstance == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  HttpInstance->Signature = HTTP_PROTOCOL_SIGNATURE;
  HttpInstance->Service   = HttpService;
  HttpInstance->Method    = HttpMethodMax;
 
  CopyMem (&HttpInstance->Http, &mEfiHttpTemplate, sizeof (HttpInstance->Http));
  NetMapInit (&HttpInstance->TxTokens);
  NetMapInit (&HttpInstance->RxTokens);
 
  //
  // Install HTTP protocol onto ChildHandle
  //
  Status = gBS->InstallMultipleProtocolInterfaces (
                  ChildHandle,
                  &gEfiHttpProtocolGuid,
                  &HttpInstance->Http,
                  NULL
                  );
 
  if (EFI_ERROR (Status)) {
    goto ON_ERROR;
  }
 
  HttpInstance->Handle = *ChildHandle;
 
  //
  // Add it to the HTTP service's child list.
  //
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  InsertTailList (&HttpService->ChildrenList, &HttpInstance->Link);
  HttpService->ChildrenNumber++;
 
  gBS->RestoreTPL (OldTpl);
 
  return EFI_SUCCESS;
 
ON_ERROR:
 
  NetMapClean (&HttpInstance->TxTokens);
  NetMapClean (&HttpInstance->RxTokens);
  FreePool (HttpInstance);
 
  return Status;
}
 
EFI_STATUS
EFIAPI
HttpServiceBindingDestroyChild (
  IN EFI_SERVICE_BINDING_PROTOCOL  *This,
  IN EFI_HANDLE                    ChildHandle
  )
{
  HTTP_SERVICE       *HttpService;
  HTTP_PROTOCOL      *HttpInstance;
  EFI_HTTP_PROTOCOL  *Http;
  EFI_STATUS         Status;
  EFI_TPL            OldTpl;
 
  if ((This == NULL) || (ChildHandle == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  HttpService = HTTP_SERVICE_FROM_PROTOCOL (This);
  Status      = gBS->OpenProtocol (
                       ChildHandle,
                       &gEfiHttpProtocolGuid,
                       (VOID **)&Http,
                       NULL,
                       NULL,
                       EFI_OPEN_PROTOCOL_GET_PROTOCOL
                       );
  if (EFI_ERROR (Status)) {
    return EFI_UNSUPPORTED;
  }
 
  HttpInstance = HTTP_INSTANCE_FROM_PROTOCOL (Http);
  if (HttpInstance->Service != HttpService) {
    return EFI_INVALID_PARAMETER;
  }
 
  if (HttpInstance->InDestroy) {
    return EFI_SUCCESS;
  }
 
  HttpInstance->InDestroy = TRUE;
 
  //
  // Uninstall the HTTP protocol.
  //
  Status = gBS->UninstallProtocolInterface (
                  ChildHandle,
                  &gEfiHttpProtocolGuid,
                  Http
                  );
 
  if (EFI_ERROR (Status)) {
    HttpInstance->InDestroy = FALSE;
    return Status;
  }
 
  HttpCleanProtocol (HttpInstance);
 
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  RemoveEntryList (&HttpInstance->Link);
  HttpService->ChildrenNumber--;
 
  gBS->RestoreTPL (OldTpl);
 
  FreePool (HttpInstance);
  return EFI_SUCCESS;
}