Dhcp6Driver.c

Go to the documentation of this file.

 
#include "Dhcp6Impl.h"
 
EFI_DRIVER_BINDING_PROTOCOL  gDhcp6DriverBinding = {
  Dhcp6DriverBindingSupported,
  Dhcp6DriverBindingStart,
  Dhcp6DriverBindingStop,
  0xa,
  NULL,
  NULL
};
 
EFI_SERVICE_BINDING_PROTOCOL  gDhcp6ServiceBindingTemplate = {
  Dhcp6ServiceBindingCreateChild,
  Dhcp6ServiceBindingDestroyChild
};
 
EFI_STATUS
EFIAPI
Dhcp6ConfigureUdpIo (
  IN UDP_IO  *UdpIo,
  IN VOID    *Context
  )
{
  EFI_UDP6_PROTOCOL     *Udp6;
  EFI_UDP6_CONFIG_DATA  *Config;
 
  Udp6   = UdpIo->Protocol.Udp6;
  Config = &(UdpIo->Config.Udp6);
 
  ZeroMem (Config, sizeof (EFI_UDP6_CONFIG_DATA));
 
  //
  // Set Udp6 configure data for the Dhcp6 instance.
  //
  Config->AcceptPromiscuous  = FALSE;
  Config->AcceptAnyPort      = FALSE;
  Config->AllowDuplicatePort = FALSE;
  Config->TrafficClass       = 0;
  Config->HopLimit           = 128;
  Config->ReceiveTimeout     = 0;
  Config->TransmitTimeout    = 0;
 
  //
  // Configure an endpoint of client(0, 546), server(0, 0), the addresses
  // will be overridden later. Note that we MUST not limit RemotePort.
  // More details, refer to RFC 3315 section 5.2.
  //
  Config->StationPort = DHCP6_PORT_CLIENT;
  Config->RemotePort  = 0;
 
  return Udp6->Configure (Udp6, Config);
}
 
VOID
Dhcp6DestroyService (
  IN OUT DHCP6_SERVICE  *Service
  )
{
  //
  // All children instances should have been already destroyed here.
  //
  ASSERT (Service->NumOfChild == 0);
 
  if (Service->ClientId != NULL) {
    FreePool (Service->ClientId);
  }
 
  if (Service->UdpIo != NULL) {
    UdpIoFreeIo (Service->UdpIo);
  }
 
  FreePool (Service);
}
 
EFI_STATUS
Dhcp6CreateService (
  IN  EFI_HANDLE     Controller,
  IN  EFI_HANDLE     ImageHandle,
  OUT DHCP6_SERVICE  **Service
  )
{
  DHCP6_SERVICE  *Dhcp6Srv;
  EFI_STATUS     Status;
  UINT32         Random;
 
  Status = PseudoRandomU32 (&Random);
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR, "%a failed to generate random number: %r\n", __func__, Status));
    return Status;
  }
 
  *Service = NULL;
  Dhcp6Srv = AllocateZeroPool (sizeof (DHCP6_SERVICE));
 
  if (Dhcp6Srv == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  //
  // Open the SNP protocol to get mode data later.
  //
  Dhcp6Srv->Snp = NULL;
  NetLibGetSnpHandle (Controller, &Dhcp6Srv->Snp);
  if (Dhcp6Srv->Snp == NULL) {
    FreePool (Dhcp6Srv);
    return EFI_DEVICE_ERROR;
  }
 
  //
  // Initialize the fields of the new Dhcp6 service.
  //
  Dhcp6Srv->Signature  = DHCP6_SERVICE_SIGNATURE;
  Dhcp6Srv->Controller = Controller;
  Dhcp6Srv->Image      = ImageHandle;
  Dhcp6Srv->Xid        = (0xffffff & Random);
 
  CopyMem (
    &Dhcp6Srv->ServiceBinding,
    &gDhcp6ServiceBindingTemplate,
    sizeof (EFI_SERVICE_BINDING_PROTOCOL)
    );
 
  //
  // Locate Ip6->Ip6Config and store it for get IP6 Duplicate Address Detection transmits.
  //
  Status = gBS->HandleProtocol (
                  Controller,
                  &gEfiIp6ConfigProtocolGuid,
                  (VOID **)&Dhcp6Srv->Ip6Cfg
                  );
  if (EFI_ERROR (Status)) {
    FreePool (Dhcp6Srv);
    return Status;
  }
 
  //
  // Generate client Duid: If SMBIOS system UUID is located, generate DUID in DUID-UUID format.
  // Otherwise, in DUID-LLT format.
  //
  Dhcp6Srv->ClientId = Dhcp6GenerateClientId (Dhcp6Srv->Snp->Mode);
 
  if (Dhcp6Srv->ClientId == NULL) {
    FreePool (Dhcp6Srv);
    return EFI_DEVICE_ERROR;
  }
 
  //
  // Create an Udp6Io for stateful transmit/receive of each Dhcp6 instance.
  //
  Dhcp6Srv->UdpIo = UdpIoCreateIo (
                      Controller,
                      ImageHandle,
                      Dhcp6ConfigureUdpIo,
                      UDP_IO_UDP6_VERSION,
                      NULL
                      );
 
  if (Dhcp6Srv->UdpIo == NULL) {
    FreePool (Dhcp6Srv->ClientId);
    FreePool (Dhcp6Srv);
    return EFI_DEVICE_ERROR;
  }
 
  InitializeListHead (&Dhcp6Srv->Child);
 
  *Service = Dhcp6Srv;
 
  return EFI_SUCCESS;
}
 
VOID
Dhcp6DestroyInstance (
  IN OUT DHCP6_INSTANCE  *Instance
  )
{
  //
  // Clean up the retry list first.
  //
  Dhcp6CleanupRetry (Instance, DHCP6_PACKET_ALL);
  gBS->CloseEvent (Instance->Timer);
 
  //
  // Clean up the current configure data.
  //
  if (Instance->Config != NULL) {
    Dhcp6CleanupConfigData (Instance->Config);
    FreePool (Instance->Config);
  }
 
  //
  // Clean up the current Ia.
  //
  if (Instance->IaCb.Ia != NULL) {
    if (Instance->IaCb.Ia->ReplyPacket != NULL) {
      FreePool (Instance->IaCb.Ia->ReplyPacket);
    }
 
    FreePool (Instance->IaCb.Ia);
  }
 
  if (Instance->Unicast != NULL) {
    FreePool (Instance->Unicast);
  }
 
  if (Instance->AdSelect != NULL) {
    FreePool (Instance->AdSelect);
  }
 
  FreePool (Instance);
}
 
EFI_STATUS
Dhcp6CreateInstance (
  IN  DHCP6_SERVICE   *Service,
  OUT DHCP6_INSTANCE  **Instance
  )
{
  EFI_STATUS      Status;
  DHCP6_INSTANCE  *Dhcp6Ins;
 
  *Instance = NULL;
  Dhcp6Ins  = AllocateZeroPool (sizeof (DHCP6_INSTANCE));
 
  if (Dhcp6Ins == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  //
  // Initialize the fields of the new Dhcp6 instance.
  //
  Dhcp6Ins->Signature    = DHCP6_INSTANCE_SIGNATURE;
  Dhcp6Ins->UdpSts       = EFI_ALREADY_STARTED;
  Dhcp6Ins->Service      = Service;
  Dhcp6Ins->InDestroy    = FALSE;
  Dhcp6Ins->MediaPresent = TRUE;
 
  CopyMem (
    &Dhcp6Ins->Dhcp6,
    &gDhcp6ProtocolTemplate,
    sizeof (EFI_DHCP6_PROTOCOL)
    );
 
  InitializeListHead (&Dhcp6Ins->TxList);
  InitializeListHead (&Dhcp6Ins->InfList);
 
  //
  // There is a timer for each Dhcp6 instance, which is used to track the
  // lease time of Ia and the retransmission time of all sent packets.
  //
  Status = gBS->CreateEvent (
                  EVT_NOTIFY_SIGNAL | EVT_TIMER,
                  TPL_CALLBACK,
                  Dhcp6OnTimerTick,
                  Dhcp6Ins,
                  &Dhcp6Ins->Timer
                  );
 
  if (EFI_ERROR (Status)) {
    FreePool (Dhcp6Ins);
    return Status;
  }
 
  *Instance = Dhcp6Ins;
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
Dhcp6DestroyChildEntry (
  IN LIST_ENTRY  *Entry,
  IN VOID        *Context
  )
{
  DHCP6_INSTANCE                *Instance;
  EFI_SERVICE_BINDING_PROTOCOL  *ServiceBinding;
 
  if ((Entry == NULL) || (Context == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  Instance       = NET_LIST_USER_STRUCT_S (Entry, DHCP6_INSTANCE, Link, DHCP6_INSTANCE_SIGNATURE);
  ServiceBinding = (EFI_SERVICE_BINDING_PROTOCOL *)Context;
 
  return ServiceBinding->DestroyChild (ServiceBinding, Instance->Handle);
}
 
EFI_STATUS
EFIAPI
Dhcp6DriverEntryPoint (
  IN EFI_HANDLE        ImageHandle,
  IN EFI_SYSTEM_TABLE  *SystemTable
  )
{
  return EfiLibInstallDriverBindingComponentName2 (
           ImageHandle,
           SystemTable,
           &gDhcp6DriverBinding,
           ImageHandle,
           &gDhcp6ComponentName,
           &gDhcp6ComponentName2
           );
}
 
EFI_STATUS
EFIAPI
Dhcp6DriverBindingSupported (
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
  IN EFI_HANDLE                   ControllerHandle,
  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL
  )
{
  return gBS->OpenProtocol (
                ControllerHandle,
                &gEfiUdp6ServiceBindingProtocolGuid,
                NULL,
                This->DriverBindingHandle,
                ControllerHandle,
                EFI_OPEN_PROTOCOL_TEST_PROTOCOL
                );
}
 
EFI_STATUS
EFIAPI
Dhcp6DriverBindingStart (
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
  IN EFI_HANDLE                   ControllerHandle,
  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL
  )
{
  EFI_STATUS     Status;
  DHCP6_SERVICE  *Service;
 
  //
  // Check the Dhcp6 service whether already started.
  //
  Status = gBS->OpenProtocol (
                  ControllerHandle,
                  &gEfiDhcp6ServiceBindingProtocolGuid,
                  NULL,
                  This->DriverBindingHandle,
                  ControllerHandle,
                  EFI_OPEN_PROTOCOL_TEST_PROTOCOL
                  );
 
  if (!EFI_ERROR (Status)) {
    return EFI_ALREADY_STARTED;
  }
 
  //
  // Create and initialize the Dhcp6 service.
  //
  Status = Dhcp6CreateService (
             ControllerHandle,
             This->DriverBindingHandle,
             &Service
             );
 
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  ASSERT (Service != NULL);
 
  Status = gBS->InstallMultipleProtocolInterfaces (
                  &ControllerHandle,
                  &gEfiDhcp6ServiceBindingProtocolGuid,
                  &Service->ServiceBinding,
                  NULL
                  );
 
  if (EFI_ERROR (Status)) {
    Dhcp6DestroyService (Service);
    return Status;
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
Dhcp6DriverBindingStop (
  IN  EFI_DRIVER_BINDING_PROTOCOL  *This,
  IN  EFI_HANDLE                   ControllerHandle,
  IN  UINTN                        NumberOfChildren,
  IN  EFI_HANDLE                   *ChildHandleBuffer   OPTIONAL
  )
{
  EFI_STATUS                    Status;
  EFI_HANDLE                    NicHandle;
  EFI_SERVICE_BINDING_PROTOCOL  *ServiceBinding;
  DHCP6_SERVICE                 *Service;
  LIST_ENTRY                    *List;
  UINTN                         ListLength;
 
  //
  // Find and check the Nic handle by the controller handle.
  //
  NicHandle = NetLibGetNicHandle (ControllerHandle, &gEfiUdp6ProtocolGuid);
 
  if (NicHandle == NULL) {
    return EFI_SUCCESS;
  }
 
  Status = gBS->OpenProtocol (
                  NicHandle,
                  &gEfiDhcp6ServiceBindingProtocolGuid,
                  (VOID **)&ServiceBinding,
                  This->DriverBindingHandle,
                  NicHandle,
                  EFI_OPEN_PROTOCOL_GET_PROTOCOL
                  );
 
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  Service = DHCP6_SERVICE_FROM_THIS (ServiceBinding);
  if (!IsListEmpty (&Service->Child)) {
    //
    // Destroy all the children instances before destroy the service.
    //
    List   = &Service->Child;
    Status = NetDestroyLinkList (
               List,
               Dhcp6DestroyChildEntry,
               ServiceBinding,
               &ListLength
               );
    if (EFI_ERROR (Status) || (ListLength != 0)) {
      Status = EFI_DEVICE_ERROR;
    }
  }
 
  if ((NumberOfChildren == 0) && !IsListEmpty (&Service->Child)) {
    Status = EFI_DEVICE_ERROR;
  }
 
  if ((NumberOfChildren == 0) && IsListEmpty (&Service->Child)) {
    //
    // Destroy the service itself if no child instance left.
    //
    Status = gBS->UninstallProtocolInterface (
                    NicHandle,
                    &gEfiDhcp6ServiceBindingProtocolGuid,
                    ServiceBinding
                    );
    if (EFI_ERROR (Status)) {
      goto ON_EXIT;
    }
 
    Dhcp6DestroyService (Service);
    Status = EFI_SUCCESS;
  }
 
ON_EXIT:
  return Status;
}
 
EFI_STATUS
EFIAPI
Dhcp6ServiceBindingCreateChild (
  IN     EFI_SERVICE_BINDING_PROTOCOL  *This,
  IN OUT EFI_HANDLE                    *ChildHandle
  )
{
  EFI_STATUS      Status;
  EFI_TPL         OldTpl;
  DHCP6_SERVICE   *Service;
  DHCP6_INSTANCE  *Instance;
  VOID            *Udp6;
 
  if ((This == NULL) || (ChildHandle == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  Service = DHCP6_SERVICE_FROM_THIS (This);
 
  Status = Dhcp6CreateInstance (Service, &Instance);
 
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  ASSERT (Instance != NULL);
 
  //
  // Start the timer when the instance is ready to use.
  //
  Status = gBS->SetTimer (
                  Instance->Timer,
                  TimerPeriodic,
                  TICKS_PER_SECOND
                  );
 
  if (EFI_ERROR (Status)) {
    goto ON_ERROR;
  }
 
  //
  // Install the DHCP6 protocol onto ChildHandle.
  //
  Status = gBS->InstallMultipleProtocolInterfaces (
                  ChildHandle,
                  &gEfiDhcp6ProtocolGuid,
                  &Instance->Dhcp6,
                  NULL
                  );
 
  if (EFI_ERROR (Status)) {
    goto ON_ERROR;
  }
 
  Instance->Handle = *ChildHandle;
 
  //
  // Open the UDP6 protocol BY_CHILD.
  //
  Status = gBS->OpenProtocol (
                  Service->UdpIo->UdpHandle,
                  &gEfiUdp6ProtocolGuid,
                  (VOID **)&Udp6,
                  gDhcp6DriverBinding.DriverBindingHandle,
                  Instance->Handle,
                  EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
                  );
 
  if (EFI_ERROR (Status)) {
    gBS->UninstallMultipleProtocolInterfaces (
           Instance->Handle,
           &gEfiDhcp6ProtocolGuid,
           &Instance->Dhcp6,
           NULL
           );
    goto ON_ERROR;
  }
 
  //
  // Add into the children list of its parent service.
  //
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  InsertTailList (&Service->Child, &Instance->Link);
  Service->NumOfChild++;
 
  gBS->RestoreTPL (OldTpl);
  return EFI_SUCCESS;
 
ON_ERROR:
 
  Dhcp6DestroyInstance (Instance);
  return Status;
}
 
EFI_STATUS
EFIAPI
Dhcp6ServiceBindingDestroyChild (
  IN EFI_SERVICE_BINDING_PROTOCOL  *This,
  IN EFI_HANDLE                    ChildHandle
  )
{
  EFI_STATUS          Status;
  EFI_TPL             OldTpl;
  EFI_DHCP6_PROTOCOL  *Dhcp6;
  DHCP6_SERVICE       *Service;
  DHCP6_INSTANCE      *Instance;
 
  if ((This == NULL) || (ChildHandle == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  //
  // Retrieve the private context data structures
  //
  Status = gBS->OpenProtocol (
                  ChildHandle,
                  &gEfiDhcp6ProtocolGuid,
                  (VOID **)&Dhcp6,
                  gDhcp6DriverBinding.DriverBindingHandle,
                  ChildHandle,
                  EFI_OPEN_PROTOCOL_GET_PROTOCOL
                  );
 
  if (EFI_ERROR (Status)) {
    return EFI_UNSUPPORTED;
  }
 
  Instance = DHCP6_INSTANCE_FROM_THIS (Dhcp6);
  Service  = DHCP6_SERVICE_FROM_THIS (This);
 
  if (Instance->Service != Service) {
    return EFI_INVALID_PARAMETER;
  }
 
  if (Instance->InDestroy) {
    return EFI_SUCCESS;
  }
 
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  Instance->InDestroy = TRUE;
 
  Status = gBS->CloseProtocol (
                  Service->UdpIo->UdpHandle,
                  &gEfiUdp6ProtocolGuid,
                  gDhcp6DriverBinding.DriverBindingHandle,
                  ChildHandle
                  );
 
  if (EFI_ERROR (Status)) {
    Instance->InDestroy = FALSE;
    gBS->RestoreTPL (OldTpl);
    return Status;
  }
 
  //
  // Uninstall the MTFTP6 protocol first to enable a top down destruction.
  //
  gBS->RestoreTPL (OldTpl);
  Status = gBS->UninstallProtocolInterface (
                  ChildHandle,
                  &gEfiDhcp6ProtocolGuid,
                  Dhcp6
                  );
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
  if (EFI_ERROR (Status)) {
    Instance->InDestroy = FALSE;
    gBS->RestoreTPL (OldTpl);
    return Status;
  }
 
  //
  // Remove it from the children list of its parent service.
  //
  RemoveEntryList (&Instance->Link);
  Service->NumOfChild--;
 
  gBS->RestoreTPL (OldTpl);
 
  Dhcp6DestroyInstance (Instance);
  return EFI_SUCCESS;
}