Dhcp6Impl.c

Go to the documentation of this file.

 
#include "Dhcp6Impl.h"
 
//
// Well-known multi-cast address defined in section-24.1 of rfc-3315
//
//   ALL_DHCP_Relay_Agents_and_Servers address: FF02::1:2
//
EFI_IPv6_ADDRESS  mAllDhcpRelayAndServersAddress = {
  { 0xFF, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 2 }
};
 
EFI_DHCP6_PROTOCOL  gDhcp6ProtocolTemplate = {
  EfiDhcp6GetModeData,
  EfiDhcp6Configure,
  EfiDhcp6Start,
  EfiDhcp6InfoRequest,
  EfiDhcp6RenewRebind,
  EfiDhcp6Decline,
  EfiDhcp6Release,
  EfiDhcp6Stop,
  EfiDhcp6Parse
};
 
EFI_STATUS
EFIAPI
EfiDhcp6Start (
  IN EFI_DHCP6_PROTOCOL  *This
  )
{
  EFI_STATUS      Status;
  EFI_TPL         OldTpl;
  DHCP6_INSTANCE  *Instance;
  DHCP6_SERVICE   *Service;
  EFI_STATUS      MediaStatus;
 
  if (This == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  Instance = DHCP6_INSTANCE_FROM_THIS (This);
  Service  = Instance->Service;
 
  //
  // The instance hasn't been configured.
  //
  if (Instance->Config == NULL) {
    return EFI_ACCESS_DENIED;
  }
 
  ASSERT (Instance->IaCb.Ia != NULL);
 
  //
  // The instance has already been started.
  //
  if (Instance->IaCb.Ia->State != Dhcp6Init) {
    return EFI_ALREADY_STARTED;
  }
 
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  //
  // Check Media Status.
  //
  MediaStatus = EFI_SUCCESS;
  NetLibDetectMediaWaitTimeout (Service->Controller, DHCP_CHECK_MEDIA_WAITING_TIME, &MediaStatus);
  if (MediaStatus != EFI_SUCCESS) {
    Status = EFI_NO_MEDIA;
    goto ON_ERROR;
  }
 
  Instance->UdpSts = EFI_ALREADY_STARTED;
 
  //
  // Send the solicit message to start S.A.R.R process.
  //
  Status = Dhcp6SendSolicitMsg (Instance);
 
  if (EFI_ERROR (Status)) {
    goto ON_ERROR;
  }
 
  //
  // Register receive callback for the stateful exchange process.
  //
  Status = UdpIoRecvDatagram (
             Service->UdpIo,
             Dhcp6ReceivePacket,
             Service,
             0
             );
 
  if (EFI_ERROR (Status) && (Status != EFI_ALREADY_STARTED)) {
    goto ON_ERROR;
  }
 
  gBS->RestoreTPL (OldTpl);
 
  //
  // Poll udp out of the net tpl if synchronous call.
  //
  if (Instance->Config->IaInfoEvent == NULL) {
    while (Instance->UdpSts == EFI_ALREADY_STARTED) {
      Service->UdpIo->Protocol.Udp6->Poll (Service->UdpIo->Protocol.Udp6);
    }
 
    return Instance->UdpSts;
  }
 
  return EFI_SUCCESS;
 
ON_ERROR:
 
  gBS->RestoreTPL (OldTpl);
  return Status;
}
 
EFI_STATUS
EFIAPI
EfiDhcp6Stop (
  IN EFI_DHCP6_PROTOCOL  *This
  )
{
  EFI_TPL            OldTpl;
  EFI_STATUS         Status;
  EFI_UDP6_PROTOCOL  *Udp6;
  DHCP6_INSTANCE     *Instance;
  DHCP6_SERVICE      *Service;
 
  if (This == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  Instance = DHCP6_INSTANCE_FROM_THIS (This);
  Service  = Instance->Service;
  Udp6     = Service->UdpIo->Protocol.Udp6;
  Status   = EFI_SUCCESS;
 
  //
  // The instance hasn't been configured.
  //
  if (Instance->Config == NULL) {
    return Status;
  }
 
  ASSERT (Instance->IaCb.Ia != NULL);
 
  //
  // No valid REPLY message received yet, cleanup this instance directly.
  //
  if ((Instance->IaCb.Ia->State == Dhcp6Init) ||
      (Instance->IaCb.Ia->State == Dhcp6Selecting) ||
      (Instance->IaCb.Ia->State == Dhcp6Requesting)
      )
  {
    goto ON_EXIT;
  }
 
  //
  // Release the current ready Ia.
  //
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  Instance->UdpSts = EFI_ALREADY_STARTED;
  Status           = Dhcp6SendReleaseMsg (Instance, Instance->IaCb.Ia);
  gBS->RestoreTPL (OldTpl);
  if (EFI_ERROR (Status)) {
    goto ON_EXIT;
  }
 
  //
  // Poll udp out of the net tpl if synchronous call.
  //
  if (Instance->Config->IaInfoEvent == NULL) {
    ASSERT (Udp6 != NULL);
    while (Instance->UdpSts == EFI_ALREADY_STARTED) {
      Udp6->Poll (Udp6);
    }
 
    Status = Instance->UdpSts;
  }
 
ON_EXIT:
  //
  // Clean up the session data for the released Ia.
  //
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
  Dhcp6CleanupSession (Instance, EFI_SUCCESS);
  gBS->RestoreTPL (OldTpl);
 
  return Status;
}
 
EFI_STATUS
EFIAPI
EfiDhcp6GetModeData (
  IN  EFI_DHCP6_PROTOCOL     *This,
  OUT EFI_DHCP6_MODE_DATA    *Dhcp6ModeData      OPTIONAL,
  OUT EFI_DHCP6_CONFIG_DATA  *Dhcp6ConfigData    OPTIONAL
  )
{
  EFI_TPL         OldTpl;
  EFI_DHCP6_IA    *Ia;
  DHCP6_INSTANCE  *Instance;
  DHCP6_SERVICE   *Service;
  UINT32          IaSize;
  UINT32          IdSize;
 
  if ((This == NULL) || ((Dhcp6ModeData == NULL) && (Dhcp6ConfigData == NULL))) {
    return EFI_INVALID_PARAMETER;
  }
 
  Instance = DHCP6_INSTANCE_FROM_THIS (This);
  Service  = Instance->Service;
 
  if ((Instance->Config == NULL) && (Dhcp6ConfigData != NULL)) {
    return EFI_ACCESS_DENIED;
  }
 
  ASSERT (Service->ClientId != NULL);
 
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  //
  // User needs a copy of instance config data.
  //
  if (Dhcp6ConfigData != NULL) {
    ZeroMem (Dhcp6ConfigData, sizeof (EFI_DHCP6_CONFIG_DATA));
    //
    // Duplicate config data, including all reference buffers.
    //
    if (EFI_ERROR (Dhcp6CopyConfigData (Dhcp6ConfigData, Instance->Config))) {
      goto ON_ERROR;
    }
  }
 
  //
  // User need a copy of instance mode data.
  //
  if (Dhcp6ModeData != NULL) {
    ZeroMem (Dhcp6ModeData, sizeof (EFI_DHCP6_MODE_DATA));
    //
    // Duplicate a copy of EFI_DHCP6_DUID for client Id.
    //
    IdSize = Service->ClientId->Length + sizeof (Service->ClientId->Length);
 
    Dhcp6ModeData->ClientId = AllocateZeroPool (IdSize);
    if (Dhcp6ModeData->ClientId == NULL) {
      goto ON_ERROR;
    }
 
    CopyMem (
      Dhcp6ModeData->ClientId,
      Service->ClientId,
      IdSize
      );
 
    Ia = Instance->IaCb.Ia;
    if (Ia != NULL) {
      //
      // Duplicate a copy of EFI_DHCP6_IA for configured Ia.
      //
      IaSize = sizeof (EFI_DHCP6_IA) + (Ia->IaAddressCount -1) * sizeof (EFI_DHCP6_IA_ADDRESS);
 
      Dhcp6ModeData->Ia = AllocateZeroPool (IaSize);
      if (Dhcp6ModeData->Ia == NULL) {
        goto ON_ERROR;
      }
 
      CopyMem (
        Dhcp6ModeData->Ia,
        Ia,
        IaSize
        );
 
      //
      // Duplicate a copy of reply packet if has.
      //
      if (Ia->ReplyPacket != NULL) {
        Dhcp6ModeData->Ia->ReplyPacket = AllocateZeroPool (Ia->ReplyPacket->Size);
        if (Dhcp6ModeData->Ia->ReplyPacket == NULL) {
          goto ON_ERROR;
        }
 
        CopyMem (
          Dhcp6ModeData->Ia->ReplyPacket,
          Ia->ReplyPacket,
          Ia->ReplyPacket->Size
          );
      }
    }
  }
 
  gBS->RestoreTPL (OldTpl);
 
  return EFI_SUCCESS;
 
ON_ERROR:
 
  if (Dhcp6ConfigData != NULL) {
    Dhcp6CleanupConfigData (Dhcp6ConfigData);
  }
 
  if (Dhcp6ModeData != NULL) {
    Dhcp6CleanupModeData (Dhcp6ModeData);
  }
 
  gBS->RestoreTPL (OldTpl);
 
  return EFI_OUT_OF_RESOURCES;
}
 
EFI_STATUS
EFIAPI
EfiDhcp6Configure (
  IN EFI_DHCP6_PROTOCOL     *This,
  IN EFI_DHCP6_CONFIG_DATA  *Dhcp6CfgData    OPTIONAL
  )
{
  EFI_TPL         OldTpl;
  EFI_STATUS      Status;
  LIST_ENTRY      *Entry;
  DHCP6_INSTANCE  *Other;
  DHCP6_INSTANCE  *Instance;
  DHCP6_SERVICE   *Service;
  UINTN           Index;
 
  if (This == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  Instance = DHCP6_INSTANCE_FROM_THIS (This);
  Service  = Instance->Service;
 
  //
  // Check the parameter of configure data.
  //
  if (Dhcp6CfgData != NULL) {
    if ((Dhcp6CfgData->OptionCount > 0) && (Dhcp6CfgData->OptionList == NULL)) {
      return EFI_INVALID_PARAMETER;
    }
 
    if (Dhcp6CfgData->OptionList != NULL) {
      for (Index = 0; Index < Dhcp6CfgData->OptionCount; Index++) {
        if ((Dhcp6CfgData->OptionList[Index]->OpCode == Dhcp6OptClientId) ||
            (Dhcp6CfgData->OptionList[Index]->OpCode == Dhcp6OptRapidCommit) ||
            (Dhcp6CfgData->OptionList[Index]->OpCode == Dhcp6OptReconfigureAccept) ||
            (Dhcp6CfgData->OptionList[Index]->OpCode == Dhcp6OptIana) ||
            (Dhcp6CfgData->OptionList[Index]->OpCode == Dhcp6OptIata)
            )
        {
          return EFI_INVALID_PARAMETER;
        }
      }
    }
 
    if ((Dhcp6CfgData->IaDescriptor.Type != EFI_DHCP6_IA_TYPE_NA) &&
        (Dhcp6CfgData->IaDescriptor.Type != EFI_DHCP6_IA_TYPE_TA)
        )
    {
      return EFI_INVALID_PARAMETER;
    }
 
    if ((Dhcp6CfgData->IaInfoEvent == NULL) && (Dhcp6CfgData->SolicitRetransmission == NULL)) {
      return EFI_INVALID_PARAMETER;
    }
 
    if ((Dhcp6CfgData->SolicitRetransmission != NULL) &&
        (Dhcp6CfgData->SolicitRetransmission->Mrc == 0) &&
        (Dhcp6CfgData->SolicitRetransmission->Mrd == 0)
        )
    {
      return EFI_INVALID_PARAMETER;
    }
 
    //
    // Make sure the (IaId, IaType) is unique over all the instances.
    //
    NET_LIST_FOR_EACH (Entry, &Service->Child) {
      Other = NET_LIST_USER_STRUCT (Entry, DHCP6_INSTANCE, Link);
      if ((Other->IaCb.Ia != NULL) &&
          (Other->IaCb.Ia->Descriptor.Type == Dhcp6CfgData->IaDescriptor.Type) &&
          (Other->IaCb.Ia->Descriptor.IaId == Dhcp6CfgData->IaDescriptor.IaId)
          )
      {
        return EFI_INVALID_PARAMETER;
      }
    }
  }
 
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  if (Dhcp6CfgData != NULL) {
    //
    // It's not allowed to configure one instance twice without configure null.
    //
    if (Instance->Config != NULL) {
      gBS->RestoreTPL (OldTpl);
      return EFI_ACCESS_DENIED;
    }
 
    //
    // Duplicate config data including all reference buffers.
    //
    Instance->Config = AllocateZeroPool (sizeof (EFI_DHCP6_CONFIG_DATA));
    if (Instance->Config == NULL) {
      gBS->RestoreTPL (OldTpl);
      return EFI_OUT_OF_RESOURCES;
    }
 
    Status = Dhcp6CopyConfigData (Instance->Config, Dhcp6CfgData);
    if (EFI_ERROR (Status)) {
      FreePool (Instance->Config);
      gBS->RestoreTPL (OldTpl);
      return EFI_OUT_OF_RESOURCES;
    }
 
    //
    // Initialize the Ia descriptor from the config data, and leave the other
    // fields of the Ia as default value 0.
    //
    Instance->IaCb.Ia = AllocateZeroPool (sizeof (EFI_DHCP6_IA));
    if (Instance->IaCb.Ia == NULL) {
      Dhcp6CleanupConfigData (Instance->Config);
      FreePool (Instance->Config);
      gBS->RestoreTPL (OldTpl);
      return EFI_OUT_OF_RESOURCES;
    }
 
    CopyMem (
      &Instance->IaCb.Ia->Descriptor,
      &Dhcp6CfgData->IaDescriptor,
      sizeof (EFI_DHCP6_IA_DESCRIPTOR)
      );
  } else {
    if (Instance->Config == NULL) {
      ASSERT (Instance->IaCb.Ia == NULL);
      gBS->RestoreTPL (OldTpl);
      return EFI_SUCCESS;
    }
 
    //
    // It's not allowed to configure a started instance as null.
    //
    if (Instance->IaCb.Ia->State != Dhcp6Init) {
      gBS->RestoreTPL (OldTpl);
      return EFI_ACCESS_DENIED;
    }
 
    Dhcp6CleanupConfigData (Instance->Config);
    FreePool (Instance->Config);
    Instance->Config = NULL;
 
    FreePool (Instance->IaCb.Ia);
    Instance->IaCb.Ia = NULL;
  }
 
  gBS->RestoreTPL (OldTpl);
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
EfiDhcp6InfoRequest (
  IN EFI_DHCP6_PROTOCOL        *This,
  IN BOOLEAN                   SendClientId,
  IN EFI_DHCP6_PACKET_OPTION   *OptionRequest,
  IN UINT32                    OptionCount,
  IN EFI_DHCP6_PACKET_OPTION   *OptionList[]    OPTIONAL,
  IN EFI_DHCP6_RETRANSMISSION  *Retransmission,
  IN EFI_EVENT                 TimeoutEvent     OPTIONAL,
  IN EFI_DHCP6_INFO_CALLBACK   ReplyCallback,
  IN VOID                      *CallbackContext OPTIONAL
  )
{
  EFI_STATUS      Status;
  DHCP6_INSTANCE  *Instance;
  DHCP6_SERVICE   *Service;
  UINTN           Index;
  EFI_EVENT       Timer;
  EFI_STATUS      TimerStatus;
  UINTN           GetMappingTimeOut;
 
  if ((This == NULL) || (OptionRequest == NULL) || (Retransmission == NULL) || (ReplyCallback == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  if ((Retransmission != NULL) && (Retransmission->Mrc == 0) && (Retransmission->Mrd == 0)) {
    return EFI_INVALID_PARAMETER;
  }
 
  if ((OptionCount > 0) && (OptionList == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  if (OptionList != NULL) {
    for (Index = 0; Index < OptionCount; Index++) {
      if ((OptionList[Index]->OpCode == Dhcp6OptClientId) || (OptionList[Index]->OpCode == Dhcp6OptRequestOption)) {
        return EFI_INVALID_PARAMETER;
      }
    }
  }
 
  Instance = DHCP6_INSTANCE_FROM_THIS (This);
  Service  = Instance->Service;
 
  Status = Dhcp6StartInfoRequest (
             Instance,
             SendClientId,
             OptionRequest,
             OptionCount,
             OptionList,
             Retransmission,
             TimeoutEvent,
             ReplyCallback,
             CallbackContext
             );
  if (Status == EFI_NO_MAPPING) {
    //
    // The link local address is not ready, wait for some time and restart
    // the DHCP6 information request process.
    //
    Status = Dhcp6GetMappingTimeOut (Service->Ip6Cfg, &GetMappingTimeOut);
    if (EFI_ERROR (Status)) {
      return Status;
    }
 
    Status = gBS->CreateEvent (EVT_TIMER, TPL_CALLBACK, NULL, NULL, &Timer);
    if (EFI_ERROR (Status)) {
      return Status;
    }
 
    //
    // Start the timer, wait for link local address DAD to finish.
    //
    Status = gBS->SetTimer (Timer, TimerRelative, GetMappingTimeOut);
    if (EFI_ERROR (Status)) {
      gBS->CloseEvent (Timer);
      return Status;
    }
 
    do {
      TimerStatus = gBS->CheckEvent (Timer);
      if (!EFI_ERROR (TimerStatus)) {
        Status = Dhcp6StartInfoRequest (
                   Instance,
                   SendClientId,
                   OptionRequest,
                   OptionCount,
                   OptionList,
                   Retransmission,
                   TimeoutEvent,
                   ReplyCallback,
                   CallbackContext
                   );
      }
    } while (TimerStatus == EFI_NOT_READY);
 
    gBS->CloseEvent (Timer);
  }
 
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  //
  // Poll udp out of the net tpl if synchronous call.
  //
  if (TimeoutEvent == NULL) {
    while (Instance->UdpSts == EFI_ALREADY_STARTED) {
      Service->UdpIo->Protocol.Udp6->Poll (Service->UdpIo->Protocol.Udp6);
    }
 
    return Instance->UdpSts;
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
EfiDhcp6RenewRebind (
  IN EFI_DHCP6_PROTOCOL  *This,
  IN BOOLEAN             RebindRequest
  )
{
  EFI_STATUS      Status;
  EFI_TPL         OldTpl;
  DHCP6_INSTANCE  *Instance;
  DHCP6_SERVICE   *Service;
 
  if (This == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  Instance = DHCP6_INSTANCE_FROM_THIS (This);
  Service  = Instance->Service;
 
  //
  // The instance hasn't been configured.
  //
  if (Instance->Config == NULL) {
    return EFI_ACCESS_DENIED;
  }
 
  ASSERT (Instance->IaCb.Ia != NULL);
 
  //
  // The instance has already entered renewing or rebinding state.
  //
  if (((Instance->IaCb.Ia->State == Dhcp6Rebinding) && RebindRequest) ||
      ((Instance->IaCb.Ia->State == Dhcp6Renewing) && !RebindRequest)
      )
  {
    return EFI_ALREADY_STARTED;
  }
 
  if (Instance->IaCb.Ia->State != Dhcp6Bound) {
    return EFI_ACCESS_DENIED;
  }
 
  OldTpl           = gBS->RaiseTPL (TPL_CALLBACK);
  Instance->UdpSts = EFI_ALREADY_STARTED;
 
  //
  // Send renew/rebind message to start exchange process.
  //
  Status = Dhcp6SendRenewRebindMsg (Instance, RebindRequest);
 
  if (EFI_ERROR (Status)) {
    goto ON_ERROR;
  }
 
  //
  // Register receive callback for the stateful exchange process.
  //
  Status = UdpIoRecvDatagram (
             Service->UdpIo,
             Dhcp6ReceivePacket,
             Service,
             0
             );
 
  if (EFI_ERROR (Status) && (Status != EFI_ALREADY_STARTED)) {
    goto ON_ERROR;
  }
 
  gBS->RestoreTPL (OldTpl);
 
  //
  // Poll udp out of the net tpl if synchronous call.
  //
  if (Instance->Config->IaInfoEvent == NULL) {
    while (Instance->UdpSts == EFI_ALREADY_STARTED) {
      Service->UdpIo->Protocol.Udp6->Poll (Service->UdpIo->Protocol.Udp6);
    }
 
    return Instance->UdpSts;
  }
 
  return EFI_SUCCESS;
 
ON_ERROR:
 
  gBS->RestoreTPL (OldTpl);
  return Status;
}
 
EFI_STATUS
EFIAPI
EfiDhcp6Decline (
  IN EFI_DHCP6_PROTOCOL  *This,
  IN UINT32              AddressCount,
  IN EFI_IPv6_ADDRESS    *Addresses
  )
{
  EFI_STATUS      Status;
  EFI_TPL         OldTpl;
  EFI_DHCP6_IA    *DecIa;
  DHCP6_INSTANCE  *Instance;
  DHCP6_SERVICE   *Service;
 
  if ((This == NULL) || (AddressCount == 0) || (Addresses == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  Instance = DHCP6_INSTANCE_FROM_THIS (This);
  Service  = Instance->Service;
 
  //
  // The instance hasn't been configured.
  //
  if (Instance->Config == NULL) {
    return EFI_ACCESS_DENIED;
  }
 
  ASSERT (Instance->IaCb.Ia != NULL);
 
  if (Instance->IaCb.Ia->State != Dhcp6Bound) {
    return EFI_ACCESS_DENIED;
  }
 
  //
  // Check whether all the declined addresses belongs to the configured Ia.
  //
  Status = Dhcp6CheckAddress (Instance->IaCb.Ia, AddressCount, Addresses);
 
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  OldTpl           = gBS->RaiseTPL (TPL_CALLBACK);
  Instance->UdpSts = EFI_ALREADY_STARTED;
 
  //
  // Deprive of all the declined addresses from the configured Ia, and create a
  // DeclineIa used to create decline message.
  //
  DecIa = Dhcp6DepriveAddress (Instance->IaCb.Ia, AddressCount, Addresses);
 
  if (DecIa == NULL) {
    Status = EFI_OUT_OF_RESOURCES;
    goto ON_ERROR;
  }
 
  //
  // Send the decline message to start exchange process.
  //
  Status = Dhcp6SendDeclineMsg (Instance, DecIa);
 
  if (EFI_ERROR (Status)) {
    goto ON_ERROR;
  }
 
  //
  // Register receive callback for the stateful exchange process.
  //
  Status = UdpIoRecvDatagram (
             Service->UdpIo,
             Dhcp6ReceivePacket,
             Service,
             0
             );
 
  if (EFI_ERROR (Status) && (Status != EFI_ALREADY_STARTED)) {
    goto ON_ERROR;
  }
 
  FreePool (DecIa);
  gBS->RestoreTPL (OldTpl);
 
  //
  // Poll udp out of the net tpl if synchronous call.
  //
  if (Instance->Config->IaInfoEvent == NULL) {
    while (Instance->UdpSts == EFI_ALREADY_STARTED) {
      Service->UdpIo->Protocol.Udp6->Poll (Service->UdpIo->Protocol.Udp6);
    }
 
    return Instance->UdpSts;
  }
 
  return EFI_SUCCESS;
 
ON_ERROR:
 
  if (DecIa != NULL) {
    FreePool (DecIa);
  }
 
  gBS->RestoreTPL (OldTpl);
 
  return Status;
}
 
EFI_STATUS
EFIAPI
EfiDhcp6Release (
  IN EFI_DHCP6_PROTOCOL  *This,
  IN UINT32              AddressCount,
  IN EFI_IPv6_ADDRESS    *Addresses
  )
{
  EFI_STATUS      Status;
  EFI_TPL         OldTpl;
  EFI_DHCP6_IA    *RelIa;
  DHCP6_INSTANCE  *Instance;
  DHCP6_SERVICE   *Service;
 
  if ((This == NULL) || ((AddressCount != 0) && (Addresses == NULL))) {
    return EFI_INVALID_PARAMETER;
  }
 
  Instance = DHCP6_INSTANCE_FROM_THIS (This);
  Service  = Instance->Service;
 
  //
  // The instance hasn't been configured.
  //
  if (Instance->Config == NULL) {
    return EFI_ACCESS_DENIED;
  }
 
  ASSERT (Instance->IaCb.Ia != NULL);
 
  if (Instance->IaCb.Ia->State != Dhcp6Bound) {
    return EFI_ACCESS_DENIED;
  }
 
  //
  // Check whether all the released addresses belongs to the configured Ia.
  //
  Status = Dhcp6CheckAddress (Instance->IaCb.Ia, AddressCount, Addresses);
 
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  OldTpl           = gBS->RaiseTPL (TPL_CALLBACK);
  Instance->UdpSts = EFI_ALREADY_STARTED;
 
  //
  // Deprive of all the released addresses from the configured Ia, and create a
  // ReleaseIa used to create release message.
  //
  RelIa = Dhcp6DepriveAddress (Instance->IaCb.Ia, AddressCount, Addresses);
 
  if (RelIa == NULL) {
    Status = EFI_OUT_OF_RESOURCES;
    goto ON_ERROR;
  }
 
  //
  // Send the release message to start exchange process.
  //
  Status = Dhcp6SendReleaseMsg (Instance, RelIa);
 
  if (EFI_ERROR (Status)) {
    goto ON_ERROR;
  }
 
  //
  // Register receive callback for the stateful exchange process.
  //
  Status = UdpIoRecvDatagram (
             Service->UdpIo,
             Dhcp6ReceivePacket,
             Service,
             0
             );
 
  if (EFI_ERROR (Status) && (Status != EFI_ALREADY_STARTED)) {
    goto ON_ERROR;
  }
 
  FreePool (RelIa);
  gBS->RestoreTPL (OldTpl);
 
  //
  // Poll udp out of the net tpl if synchronous call.
  //
  if (Instance->Config->IaInfoEvent == NULL) {
    while (Instance->UdpSts == EFI_ALREADY_STARTED) {
      Service->UdpIo->Protocol.Udp6->Poll (Service->UdpIo->Protocol.Udp6);
    }
 
    return Instance->UdpSts;
  }
 
  return EFI_SUCCESS;
 
ON_ERROR:
 
  if (RelIa != NULL) {
    FreePool (RelIa);
  }
 
  gBS->RestoreTPL (OldTpl);
 
  return Status;
}
 
EFI_STATUS
EFIAPI
EfiDhcp6Parse (
  IN EFI_DHCP6_PROTOCOL        *This,
  IN EFI_DHCP6_PACKET          *Packet,
  IN OUT UINT32                *OptionCount,
  OUT EFI_DHCP6_PACKET_OPTION  *PacketOptionList[]  OPTIONAL
  )
{
  UINT32  OptCnt;
  UINT32  OptLen;
  UINT16  DataLen;
  UINT8   *Start;
  UINT8   *End;
 
  if ((This == NULL) || (Packet == NULL) || (OptionCount == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  if ((*OptionCount != 0) && (PacketOptionList == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  if ((Packet->Length > Packet->Size) || (Packet->Length < sizeof (EFI_DHCP6_HEADER))) {
    return EFI_INVALID_PARAMETER;
  }
 
  //
  //  The format of Dhcp6 option:
  //
  //     0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
  //    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  //    |          option-code          |   option-len (option data)    |
  //    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  //    |                          option-data                          |
  //    |                      (option-len octets)                      |
  //    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  //
 
  OptCnt = 0;
  OptLen = Packet->Length - sizeof (EFI_DHCP6_HEADER);
  Start  = Packet->Dhcp6.Option;
  End    = Start + OptLen;
 
  //
  // Calculate the number of option in the packet.
  //
  while (Start < End) {
    DataLen = ((EFI_DHCP6_PACKET_OPTION *)Start)->OpLen;
    Start  += (NTOHS (DataLen) + 4);
    OptCnt++;
  }
 
  //
  // It will return buffer too small if pass-in option count is smaller than the
  // actual count of options in the packet.
  //
  if (OptCnt > *OptionCount) {
    *OptionCount = OptCnt;
    return EFI_BUFFER_TOO_SMALL;
  }
 
  ZeroMem (
    PacketOptionList,
    (*OptionCount * sizeof (EFI_DHCP6_PACKET_OPTION *))
    );
 
  OptCnt = 0;
  Start  = Packet->Dhcp6.Option;
 
  while (Start < End) {
    PacketOptionList[OptCnt] = (EFI_DHCP6_PACKET_OPTION *)Start;
    DataLen                  = ((EFI_DHCP6_PACKET_OPTION *)Start)->OpLen;
    Start                   += (NTOHS (DataLen) + 4);
    OptCnt++;
  }
 
  return EFI_SUCCESS;
}