Dhcp4Io.c

Go to the documentation of this file.

 
#include "Dhcp4Impl.h"
 
UINT32  mDhcp4DefaultTimeout[4] = { 4, 8, 16, 32 };
 
EFI_STATUS
DhcpInitRequest (
  IN DHCP_SERVICE  *DhcpSb
  )
{
  EFI_STATUS  Status;
 
  ASSERT ((DhcpSb->DhcpState == Dhcp4Init) || (DhcpSb->DhcpState == Dhcp4InitReboot));
 
  //
  // Clear initial time to make sure that elapsed-time is set to 0 for first Discover or REQUEST message.
  //
  DhcpSb->ActiveChild->ElaspedTime = 0;
 
  if (DhcpSb->DhcpState == Dhcp4Init) {
    DhcpSetState (DhcpSb, Dhcp4Selecting, FALSE);
    Status = DhcpSendMessage (DhcpSb, NULL, NULL, DHCP_MSG_DISCOVER, NULL);
 
    if (EFI_ERROR (Status)) {
      DhcpSb->DhcpState = Dhcp4Init;
      return Status;
    }
  } else {
    DhcpSetState (DhcpSb, Dhcp4Rebooting, FALSE);
    Status = DhcpSendMessage (DhcpSb, NULL, NULL, DHCP_MSG_REQUEST, NULL);
 
    if (EFI_ERROR (Status)) {
      DhcpSb->DhcpState = Dhcp4InitReboot;
      return Status;
    }
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
DhcpCallUser (
  IN  DHCP_SERVICE      *DhcpSb,
  IN  EFI_DHCP4_EVENT   Event,
  IN  EFI_DHCP4_PACKET  *Packet       OPTIONAL,
  OUT EFI_DHCP4_PACKET  **NewPacket   OPTIONAL
  )
{
  EFI_DHCP4_CONFIG_DATA  *Config;
  EFI_STATUS             Status;
 
  if (NewPacket != NULL) {
    *NewPacket = NULL;
  }
 
  //
  // If user doesn't provide the call back function, return the value
  // that directs the client to continue the normal process.
  // In Dhcp4Selecting EFI_SUCCESS tells the client to stop collecting
  // the offers and select a offer, EFI_NOT_READY tells the client to
  // collect more offers.
  //
  Config = &DhcpSb->ActiveConfig;
 
  if (Config->Dhcp4Callback == NULL) {
    if (Event == Dhcp4RcvdOffer) {
      return EFI_NOT_READY;
    }
 
    return EFI_SUCCESS;
  }
 
  Status = Config->Dhcp4Callback (
                     &DhcpSb->ActiveChild->Dhcp4Protocol,
                     Config->CallbackContext,
                     (EFI_DHCP4_STATE)DhcpSb->DhcpState,
                     Event,
                     Packet,
                     NewPacket
                     );
 
  //
  // User's callback should only return EFI_SUCCESS, EFI_NOT_READY,
  // and EFI_ABORTED. If it returns values other than those, assume
  // it to be EFI_ABORTED.
  //
  if ((Status == EFI_SUCCESS) || (Status == EFI_NOT_READY)) {
    return Status;
  }
 
  return EFI_ABORTED;
}
 
VOID
DhcpNotifyUser (
  IN DHCP_SERVICE  *DhcpSb,
  IN INTN          Which
  )
{
  DHCP_PROTOCOL  *Child;
 
  if ((Child = DhcpSb->ActiveChild) == NULL) {
    return;
  }
 
  if ((Child->CompletionEvent != NULL) &&
      ((Which == DHCP_NOTIFY_COMPLETION) || (Which == DHCP_NOTIFY_ALL))
      )
  {
    gBS->SignalEvent (Child->CompletionEvent);
    Child->CompletionEvent = NULL;
  }
 
  if ((Child->RenewRebindEvent != NULL) &&
      ((Which == DHCP_NOTIFY_RENEWREBIND) || (Which == DHCP_NOTIFY_ALL))
      )
  {
    gBS->SignalEvent (Child->RenewRebindEvent);
    Child->RenewRebindEvent = NULL;
  }
}
 
EFI_STATUS
DhcpSetState (
  IN OUT DHCP_SERVICE  *DhcpSb,
  IN     INTN          State,
  IN     BOOLEAN       CallUser
  )
{
  EFI_STATUS  Status;
 
  if (CallUser) {
    Status = EFI_SUCCESS;
 
    if (State == Dhcp4Renewing) {
      Status = DhcpCallUser (DhcpSb, Dhcp4EnterRenewing, NULL, NULL);
    } else if (State == Dhcp4Rebinding) {
      Status = DhcpCallUser (DhcpSb, Dhcp4EnterRebinding, NULL, NULL);
    } else if (State == Dhcp4Bound) {
      Status = DhcpCallUser (DhcpSb, Dhcp4BoundCompleted, NULL, NULL);
    }
 
    if (EFI_ERROR (Status)) {
      return Status;
    }
  }
 
  //
  // Update the retransmission timer during the state transition.
  // This will clear the retry count. This is also why the rule
  // first transit the state, then send packets.
  //
  if (State == Dhcp4Selecting) {
    DhcpSb->MaxRetries = DhcpSb->ActiveConfig.DiscoverTryCount;
  } else {
    DhcpSb->MaxRetries = DhcpSb->ActiveConfig.RequestTryCount;
  }
 
  if (DhcpSb->MaxRetries == 0) {
    DhcpSb->MaxRetries = 4;
  }
 
  DhcpSb->CurRetry     = 0;
  DhcpSb->PacketToLive = 0;
  DhcpSb->LastTimeout  = 0;
  DhcpSb->DhcpState    = State;
  return EFI_SUCCESS;
}
 
VOID
DhcpSetTransmitTimer (
  IN OUT DHCP_SERVICE  *DhcpSb
  )
{
  UINT32  *Times;
 
  ASSERT (DhcpSb->MaxRetries > DhcpSb->CurRetry);
 
  if (DhcpSb->DhcpState == Dhcp4Selecting) {
    Times = DhcpSb->ActiveConfig.DiscoverTimeout;
  } else {
    Times = DhcpSb->ActiveConfig.RequestTimeout;
  }
 
  if (Times == NULL) {
    Times = mDhcp4DefaultTimeout;
  }
 
  DhcpSb->PacketToLive = Times[DhcpSb->CurRetry];
  DhcpSb->LastTimeout  = DhcpSb->PacketToLive;
 
  return;
}
 
VOID
DhcpComputeLease (
  IN OUT DHCP_SERVICE    *DhcpSb,
  IN     DHCP_PARAMETER  *Para
  )
{
  ASSERT (Para != NULL);
 
  DhcpSb->Lease = Para->Lease;
  DhcpSb->T2    = Para->T2;
  DhcpSb->T1    = Para->T1;
 
  if (DhcpSb->Lease == 0) {
    DhcpSb->Lease = DHCP_DEFAULT_LEASE;
  }
 
  if ((DhcpSb->T2 == 0) || (DhcpSb->T2 >= Para->Lease)) {
    DhcpSb->T2 = Para->Lease - (Para->Lease >> 3);
  }
 
  if ((DhcpSb->T1 == 0) || (DhcpSb->T1 >= Para->T2)) {
    DhcpSb->T1 = DhcpSb->Lease >> 1;
  }
}
 
EFI_STATUS
EFIAPI
DhcpConfigLeaseIoPort (
  IN UDP_IO  *UdpIo,
  IN VOID    *Context
  )
{
  EFI_UDP4_CONFIG_DATA  UdpConfigData;
  EFI_IPv4_ADDRESS      Subnet;
  EFI_IPv4_ADDRESS      Gateway;
  DHCP_SERVICE          *DhcpSb;
  EFI_STATUS            Status;
  IP4_ADDR              Ip;
 
  DhcpSb = (DHCP_SERVICE *)Context;
 
  UdpConfigData.AcceptBroadcast    = FALSE;
  UdpConfigData.AcceptPromiscuous  = FALSE;
  UdpConfigData.AcceptAnyPort      = FALSE;
  UdpConfigData.AllowDuplicatePort = TRUE;
  UdpConfigData.TypeOfService      = 0;
  UdpConfigData.TimeToLive         = 64;
  UdpConfigData.DoNotFragment      = FALSE;
  UdpConfigData.ReceiveTimeout     = 1;
  UdpConfigData.TransmitTimeout    = 0;
 
  UdpConfigData.UseDefaultAddress = FALSE;
  UdpConfigData.StationPort       = DHCP_CLIENT_PORT;
  UdpConfigData.RemotePort        = DHCP_SERVER_PORT;
 
  Ip = HTONL (DhcpSb->ClientAddr);
  CopyMem (&UdpConfigData.StationAddress, &Ip, sizeof (EFI_IPv4_ADDRESS));
 
  Ip = HTONL (DhcpSb->Netmask);
  CopyMem (&UdpConfigData.SubnetMask, &Ip, sizeof (EFI_IPv4_ADDRESS));
 
  ZeroMem (&UdpConfigData.RemoteAddress, sizeof (EFI_IPv4_ADDRESS));
 
  Status = UdpIo->Protocol.Udp4->Configure (UdpIo->Protocol.Udp4, &UdpConfigData);
 
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  //
  // Add a default route if received from the server.
  //
  if ((DhcpSb->Para != NULL) && (DhcpSb->Para->Router != 0)) {
    ZeroMem (&Subnet, sizeof (EFI_IPv4_ADDRESS));
 
    Ip = HTONL (DhcpSb->Para->Router);
    CopyMem (&Gateway, &Ip, sizeof (EFI_IPv4_ADDRESS));
 
    UdpIo->Protocol.Udp4->Routes (UdpIo->Protocol.Udp4, FALSE, &Subnet, &Subnet, &Gateway);
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
DhcpLeaseAcquired (
  IN OUT DHCP_SERVICE  *DhcpSb
  )
{
  DhcpSb->ClientAddr = EFI_NTOHL (DhcpSb->Selected->Dhcp4.Header.YourAddr);
 
  if (DhcpSb->Para != NULL) {
    DhcpSb->Netmask    = DhcpSb->Para->NetMask;
    DhcpSb->ServerAddr = DhcpSb->Para->ServerId;
  }
 
  if (DhcpSb->Netmask == 0) {
    return EFI_ABORTED;
  }
 
  if (DhcpSb->LeaseIoPort != NULL) {
    UdpIoFreeIo (DhcpSb->LeaseIoPort);
  }
 
  //
  // Create a UDP/IP child to provide ARP service for the Leased IP,
  // and transmit unicast packet with it as source address. Don't
  // start receive on this port, the queued packet will be timeout.
  //
  DhcpSb->LeaseIoPort = UdpIoCreateIo (
                          DhcpSb->Controller,
                          DhcpSb->Image,
                          DhcpConfigLeaseIoPort,
                          UDP_IO_UDP4_VERSION,
                          DhcpSb
                          );
 
  if (DhcpSb->LeaseIoPort == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  if (!DHCP_IS_BOOTP (DhcpSb->Para)) {
    DhcpComputeLease (DhcpSb, DhcpSb->Para);
  }
 
  return DhcpSetState (DhcpSb, Dhcp4Bound, TRUE);
}
 
VOID
DhcpCleanLease (
  IN DHCP_SERVICE  *DhcpSb
  )
{
  DhcpSb->DhcpState  = Dhcp4Init;
  DhcpSb->Xid        = DhcpSb->Xid + 1;
  DhcpSb->ClientAddr = 0;
  DhcpSb->Netmask    = 0;
  DhcpSb->ServerAddr = 0;
 
  if (DhcpSb->LastOffer != NULL) {
    FreePool (DhcpSb->LastOffer);
    DhcpSb->LastOffer = NULL;
  }
 
  if (DhcpSb->Selected != NULL) {
    FreePool (DhcpSb->Selected);
    DhcpSb->Selected = NULL;
  }
 
  if (DhcpSb->Para != NULL) {
    FreePool (DhcpSb->Para);
    DhcpSb->Para = NULL;
  }
 
  DhcpSb->Lease        = 0;
  DhcpSb->T1           = 0;
  DhcpSb->T2           = 0;
  DhcpSb->ExtraRefresh = FALSE;
 
  if (DhcpSb->LeaseIoPort != NULL) {
    UdpIoFreeIo (DhcpSb->LeaseIoPort);
    DhcpSb->LeaseIoPort = NULL;
  }
 
  if (DhcpSb->LastPacket != NULL) {
    FreePool (DhcpSb->LastPacket);
    DhcpSb->LastPacket = NULL;
  }
 
  DhcpSb->PacketToLive = 0;
  DhcpSb->LastTimeout  = 0;
  DhcpSb->CurRetry     = 0;
  DhcpSb->MaxRetries   = 0;
  DhcpSb->LeaseLife    = 0;
 
  //
  // Clean active config data.
  //
  DhcpCleanConfigure (&DhcpSb->ActiveConfig);
}
 
EFI_STATUS
DhcpChooseOffer (
  IN DHCP_SERVICE  *DhcpSb
  )
{
  EFI_DHCP4_PACKET  *Selected;
  EFI_DHCP4_PACKET  *NewPacket;
  EFI_DHCP4_PACKET  *TempPacket;
  EFI_STATUS        Status;
 
  ASSERT (DhcpSb->LastOffer != NULL);
 
  //
  // User will cache previous offers if he wants to select
  // from multiple offers. If user provides an invalid packet,
  // use the last offer, otherwise use the provided packet.
  //
  NewPacket = NULL;
  Status    = DhcpCallUser (DhcpSb, Dhcp4SelectOffer, DhcpSb->LastOffer, &NewPacket);
 
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  Selected = DhcpSb->LastOffer;
 
  if ((NewPacket != NULL) && !EFI_ERROR (DhcpValidateOptions (NewPacket, NULL))) {
    TempPacket = (EFI_DHCP4_PACKET *)AllocatePool (NewPacket->Size);
    if (TempPacket != NULL) {
      CopyMem (TempPacket, NewPacket, NewPacket->Size);
      FreePool (Selected);
      Selected = TempPacket;
    }
  }
 
  DhcpSb->Selected  = Selected;
  DhcpSb->LastOffer = NULL;
  DhcpSb->Para      = NULL;
  DhcpValidateOptions (Selected, &DhcpSb->Para);
 
  //
  // A bootp offer has been selected, save the lease status,
  // enter bound state then notify the user.
  //
  if (DHCP_IS_BOOTP (DhcpSb->Para)) {
    Status = DhcpLeaseAcquired (DhcpSb);
 
    if (EFI_ERROR (Status)) {
      return Status;
    }
 
    DhcpSb->IoStatus = EFI_SUCCESS;
    DhcpNotifyUser (DhcpSb, DHCP_NOTIFY_ALL);
    return EFI_SUCCESS;
  }
 
  //
  // Send a DHCP requests
  //
  Status = DhcpSetState (DhcpSb, Dhcp4Requesting, TRUE);
 
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  return DhcpSendMessage (DhcpSb, Selected, DhcpSb->Para, DHCP_MSG_REQUEST, NULL);
}
 
VOID
DhcpEndSession (
  IN DHCP_SERVICE  *DhcpSb,
  IN EFI_STATUS    Status
  )
{
  if (DHCP_CONNECTED (DhcpSb->DhcpState)) {
    DhcpCallUser (DhcpSb, Dhcp4AddressLost, NULL, NULL);
  } else {
    DhcpCallUser (DhcpSb, Dhcp4Fail, NULL, NULL);
  }
 
  DhcpCleanLease (DhcpSb);
 
  DhcpSb->IoStatus = Status;
  DhcpNotifyUser (DhcpSb, DHCP_NOTIFY_ALL);
}
 
EFI_STATUS
DhcpHandleSelect (
  IN DHCP_SERVICE      *DhcpSb,
  IN EFI_DHCP4_PACKET  *Packet,
  IN DHCP_PARAMETER    *Para
  )
{
  EFI_STATUS  Status;
 
  Status = EFI_SUCCESS;
 
  //
  // First validate the message:
  // 1. the offer is a unicast
  // 2. if it is a DHCP message, it must contains a server ID.
  // Don't return a error for these two case otherwise the session is ended.
  //
  if (!DHCP_IS_BOOTP (Para) &&
      ((Para->DhcpType != DHCP_MSG_OFFER) || (Para->ServerId == 0))
      )
  {
    goto ON_EXIT;
  }
 
  //
  // Call the user's callback. The action according to the return is as:
  // 1. EFI_SUCCESS: stop waiting for more offers, select the offer now
  // 2. EFI_NOT_READY: wait for more offers
  // 3. EFI_ABORTED: abort the address acquiring.
  //
  Status = DhcpCallUser (DhcpSb, Dhcp4RcvdOffer, Packet, NULL);
 
  if (Status == EFI_SUCCESS) {
    if (DhcpSb->LastOffer != NULL) {
      FreePool (DhcpSb->LastOffer);
    }
 
    DhcpSb->LastOffer = Packet;
 
    return DhcpChooseOffer (DhcpSb);
  } else if (Status == EFI_NOT_READY) {
    if (DhcpSb->LastOffer != NULL) {
      FreePool (DhcpSb->LastOffer);
    }
 
    DhcpSb->LastOffer = Packet;
  } else if (Status == EFI_ABORTED) {
    //
    // DhcpInput will end the session upon error return. Remember
    // only to call DhcpEndSession at the top level call.
    //
    goto ON_EXIT;
  }
 
  return EFI_SUCCESS;
 
ON_EXIT:
  FreePool (Packet);
  return Status;
}
 
EFI_STATUS
DhcpHandleRequest (
  IN DHCP_SERVICE      *DhcpSb,
  IN EFI_DHCP4_PACKET  *Packet,
  IN DHCP_PARAMETER    *Para
  )
{
  EFI_DHCP4_HEADER  *Head;
  EFI_DHCP4_HEADER  *Selected;
  EFI_STATUS        Status;
  UINT8             *Message;
 
  ASSERT (!DHCP_IS_BOOTP (DhcpSb->Para));
 
  Head     = &Packet->Dhcp4.Header;
  Selected = &DhcpSb->Selected->Dhcp4.Header;
 
  //
  // Ignore the BOOTP message and DHCP messages other than DHCP ACK/NACK.
  //
  if (DHCP_IS_BOOTP (Para) ||
      (Para->ServerId != DhcpSb->Para->ServerId) ||
      ((Para->DhcpType != DHCP_MSG_ACK) && (Para->DhcpType != DHCP_MSG_NAK))
      )
  {
    Status = EFI_SUCCESS;
    goto ON_EXIT;
  }
 
  //
  // Received a NAK, end the session no matter what the user returns
  //
  Status = EFI_DEVICE_ERROR;
 
  if (Para->DhcpType == DHCP_MSG_NAK) {
    DhcpCallUser (DhcpSb, Dhcp4RcvdNak, Packet, NULL);
    goto ON_EXIT;
  }
 
  //
  // Check whether the ACK matches the selected offer
  //
  Message = NULL;
 
  if (!EFI_IP4_EQUAL (&Head->YourAddr, &Selected->YourAddr)) {
    Message = (UINT8 *)"Lease confirmed isn't the same as that in the offer";
    goto REJECT;
  }
 
  Status = DhcpCallUser (DhcpSb, Dhcp4RcvdAck, Packet, NULL);
 
  if (EFI_ERROR (Status)) {
    Message = (UINT8 *)"Lease is denied upon received ACK";
    goto REJECT;
  }
 
  //
  // Record the lease, transit to BOUND state, then notify the user
  //
  Status = DhcpLeaseAcquired (DhcpSb);
 
  if (EFI_ERROR (Status)) {
    Message = (UINT8 *)"Lease is denied upon entering bound";
    goto REJECT;
  }
 
  DhcpSb->IoStatus = EFI_SUCCESS;
  DhcpNotifyUser (DhcpSb, DHCP_NOTIFY_COMPLETION);
 
  FreePool (Packet);
  return EFI_SUCCESS;
 
REJECT:
  DhcpSendMessage (DhcpSb, DhcpSb->Selected, DhcpSb->Para, DHCP_MSG_DECLINE, Message);
 
ON_EXIT:
  FreePool (Packet);
  return Status;
}
 
EFI_STATUS
DhcpHandleRenewRebind (
  IN DHCP_SERVICE      *DhcpSb,
  IN EFI_DHCP4_PACKET  *Packet,
  IN DHCP_PARAMETER    *Para
  )
{
  EFI_DHCP4_HEADER  *Head;
  EFI_DHCP4_HEADER  *Selected;
  EFI_STATUS        Status;
 
  ASSERT (!DHCP_IS_BOOTP (DhcpSb->Para));
 
  Head     = &Packet->Dhcp4.Header;
  Selected = &DhcpSb->Selected->Dhcp4.Header;
 
  //
  // Ignore the BOOTP message and DHCP messages other than DHCP ACK/NACK
  //
  if (DHCP_IS_BOOTP (Para) ||
      (Para->ServerId != DhcpSb->Para->ServerId) ||
      ((Para->DhcpType != DHCP_MSG_ACK) && (Para->DhcpType != DHCP_MSG_NAK))
      )
  {
    Status = EFI_SUCCESS;
    goto ON_EXIT;
  }
 
  //
  // Received a NAK, ignore the user's return then terminate the process
  //
  Status = EFI_DEVICE_ERROR;
 
  if (Para->DhcpType == DHCP_MSG_NAK) {
    DhcpCallUser (DhcpSb, Dhcp4RcvdNak, Packet, NULL);
    goto ON_EXIT;
  }
 
  //
  // The lease is different from the selected. Don't send a DECLINE
  // since it isn't existed in the client's FSM.
  //
  if (!EFI_IP4_EQUAL (&Head->YourAddr, &Selected->YourAddr)) {
    goto ON_EXIT;
  }
 
  Status = DhcpCallUser (DhcpSb, Dhcp4RcvdAck, Packet, NULL);
 
  if (EFI_ERROR (Status)) {
    goto ON_EXIT;
  }
 
  //
  // Record the lease, start timer for T1 and T2,
  //
  DhcpComputeLease (DhcpSb, Para);
  DhcpSb->LeaseLife = 0;
  DhcpSetState (DhcpSb, Dhcp4Bound, TRUE);
 
  if (DhcpSb->ExtraRefresh != 0) {
    DhcpSb->ExtraRefresh = FALSE;
 
    DhcpSb->IoStatus = EFI_SUCCESS;
    DhcpNotifyUser (DhcpSb, DHCP_NOTIFY_RENEWREBIND);
  }
 
ON_EXIT:
  FreePool (Packet);
  return Status;
}
 
EFI_STATUS
DhcpHandleReboot (
  IN DHCP_SERVICE      *DhcpSb,
  IN EFI_DHCP4_PACKET  *Packet,
  IN DHCP_PARAMETER    *Para
  )
{
  EFI_DHCP4_HEADER  *Head;
  EFI_STATUS        Status;
 
  Head = &Packet->Dhcp4.Header;
 
  //
  // Ignore the BOOTP message and DHCP messages other than DHCP ACK/NACK
  //
  if (DHCP_IS_BOOTP (Para) ||
      ((Para->DhcpType != DHCP_MSG_ACK) && (Para->DhcpType != DHCP_MSG_NAK))
      )
  {
    Status = EFI_SUCCESS;
    goto ON_EXIT;
  }
 
  //
  // If a NAK is received, transit to INIT and try again.
  //
  if (Para->DhcpType == DHCP_MSG_NAK) {
    DhcpCallUser (DhcpSb, Dhcp4RcvdNak, Packet, NULL);
 
    DhcpSb->ClientAddr = 0;
    DhcpSb->DhcpState  = Dhcp4Init;
 
    Status = DhcpInitRequest (DhcpSb);
    goto ON_EXIT;
  }
 
  //
  // Check whether the ACK matches the selected offer
  //
  if (EFI_NTOHL (Head->YourAddr) != DhcpSb->ClientAddr) {
    Status = EFI_DEVICE_ERROR;
    goto ON_EXIT;
  }
 
  Status = DhcpCallUser (DhcpSb, Dhcp4RcvdAck, Packet, NULL);
  if (EFI_ERROR (Status)) {
    goto ON_EXIT;
  }
 
  //
  // OK, get the parameter from server, record the lease
  //
  DhcpSb->Para = AllocateCopyPool (sizeof (DHCP_PARAMETER), Para);
  if (DhcpSb->Para == NULL) {
    Status = EFI_OUT_OF_RESOURCES;
    goto ON_EXIT;
  }
 
  DhcpSb->Selected = Packet;
  Status           = DhcpLeaseAcquired (DhcpSb);
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  DhcpSb->IoStatus = EFI_SUCCESS;
  DhcpNotifyUser (DhcpSb, DHCP_NOTIFY_COMPLETION);
  return EFI_SUCCESS;
 
ON_EXIT:
  FreePool (Packet);
  return Status;
}
 
VOID
EFIAPI
DhcpInput (
  NET_BUF        *UdpPacket,
  UDP_END_POINT  *EndPoint,
  EFI_STATUS     IoStatus,
  VOID           *Context
  )
{
  DHCP_SERVICE      *DhcpSb;
  EFI_DHCP4_HEADER  *Head;
  EFI_DHCP4_PACKET  *Packet;
  DHCP_PARAMETER    *Para;
  EFI_STATUS        Status;
  UINT32            Len;
 
  Packet = NULL;
  DhcpSb = (DHCP_SERVICE *)Context;
 
  //
  // Don't restart receive if error occurs or DHCP is destroyed.
  //
  if (EFI_ERROR (IoStatus)) {
    return;
  } else if (DhcpSb->ServiceState == DHCP_DESTROY) {
    NetbufFree (UdpPacket);
    return;
  }
 
  ASSERT (UdpPacket != NULL);
 
  if (DhcpSb->DhcpState == Dhcp4Stopped) {
    goto RESTART;
  }
 
  //
  // Validate the packet received
  //
  if (UdpPacket->TotalSize < sizeof (EFI_DHCP4_HEADER)) {
    goto RESTART;
  }
 
  //
  // Copy the DHCP message to a continuous memory block
  //
  Len    = sizeof (EFI_DHCP4_PACKET) + UdpPacket->TotalSize - sizeof (EFI_DHCP4_HEADER);
  Packet = (EFI_DHCP4_PACKET *)AllocatePool (Len);
 
  if (Packet == NULL) {
    goto RESTART;
  }
 
  Packet->Size   = Len;
  Head           = &Packet->Dhcp4.Header;
  Packet->Length = NetbufCopy (UdpPacket, 0, UdpPacket->TotalSize, (UINT8 *)Head);
 
  if (Packet->Length != UdpPacket->TotalSize) {
    goto RESTART;
  }
 
  //
  // Is this packet the answer to our packet?
  //
  if ((Head->OpCode != BOOTP_REPLY) ||
      (NTOHL (Head->Xid) != DhcpSb->Xid) ||
      (CompareMem (DhcpSb->ClientAddressSendOut, Head->ClientHwAddr, Head->HwAddrLen) != 0))
  {
    goto RESTART;
  }
 
  //
  // Validate the options and retrieve the interested options
  //
  Para = NULL;
  if ((Packet->Length > sizeof (EFI_DHCP4_HEADER) + sizeof (UINT32)) &&
      (Packet->Dhcp4.Magik == DHCP_OPTION_MAGIC) &&
      EFI_ERROR (DhcpValidateOptions (Packet, &Para)))
  {
    goto RESTART;
  }
 
  //
  // Call the handler for each state. The handler should return
  // EFI_SUCCESS if the process can go on no matter whether the
  // packet is ignored or not. If the return is EFI_ERROR, the
  // session will be terminated. Packet's ownership is handled
  // over to the handlers. If operation succeeds, the handler
  // must notify the user. It isn't necessary to do if EFI_ERROR
  // is returned because the DhcpEndSession will notify the user.
  //
  Status = EFI_SUCCESS;
 
  switch (DhcpSb->DhcpState) {
    case Dhcp4Selecting:
      Status = DhcpHandleSelect (DhcpSb, Packet, Para);
      break;
 
    case Dhcp4Requesting:
      Status = DhcpHandleRequest (DhcpSb, Packet, Para);
      break;
 
    case Dhcp4InitReboot:
    case Dhcp4Init:
    case Dhcp4Bound:
      //
      // Ignore the packet in INITREBOOT, INIT and BOUND states
      //
      FreePool (Packet);
      Status = EFI_SUCCESS;
      break;
 
    case Dhcp4Renewing:
    case Dhcp4Rebinding:
      Status = DhcpHandleRenewRebind (DhcpSb, Packet, Para);
      break;
 
    case Dhcp4Rebooting:
      Status = DhcpHandleReboot (DhcpSb, Packet, Para);
      break;
  }
 
  if (Para != NULL) {
    FreePool (Para);
  }
 
  Packet = NULL;
 
  if (EFI_ERROR (Status)) {
    NetbufFree (UdpPacket);
    UdpIoRecvDatagram (DhcpSb->UdpIo, DhcpInput, DhcpSb, 0);
    DhcpEndSession (DhcpSb, Status);
    return;
  }
 
RESTART:
  NetbufFree (UdpPacket);
 
  if (Packet != NULL) {
    FreePool (Packet);
  }
 
  Status = UdpIoRecvDatagram (DhcpSb->UdpIo, DhcpInput, DhcpSb, 0);
 
  if (EFI_ERROR (Status)) {
    DhcpEndSession (DhcpSb, EFI_DEVICE_ERROR);
  }
}
 
VOID
EFIAPI
DhcpOnPacketSent (
  NET_BUF        *Packet,
  UDP_END_POINT  *EndPoint,
  EFI_STATUS     IoStatus,
  VOID           *Context
  )
{
  NetbufFree (Packet);
}
 
EFI_STATUS
DhcpSendMessage (
  IN DHCP_SERVICE      *DhcpSb,
  IN EFI_DHCP4_PACKET  *Seed,
  IN DHCP_PARAMETER    *Para,
  IN UINT8             Type,
  IN UINT8             *Msg
  )
{
  EFI_DHCP4_CONFIG_DATA  *Config;
  EFI_DHCP4_PACKET       *Packet;
  EFI_DHCP4_PACKET       *NewPacket;
  EFI_DHCP4_HEADER       *Head;
  EFI_DHCP4_HEADER       *SeedHead;
  UDP_IO                 *UdpIo;
  UDP_END_POINT          EndPoint;
  NET_BUF                *Wrap;
  NET_FRAGMENT           Frag;
  EFI_STATUS             Status;
  IP4_ADDR               IpAddr;
  UINT8                  *Buf;
  UINT16                 MaxMsg;
  UINT32                 Len;
  UINT32                 Index;
 
  //
  // Allocate a big enough memory block to hold the DHCP packet
  //
  Len = sizeof (EFI_DHCP4_PACKET) + 128 + DhcpSb->UserOptionLen;
 
  if (Msg != NULL) {
    Len += (UINT32)AsciiStrLen ((CHAR8 *)Msg);
  }
 
  Packet = AllocatePool (Len);
 
  if (Packet == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  Packet->Size   = Len;
  Packet->Length = sizeof (EFI_DHCP4_HEADER) + sizeof (UINT32);
 
  //
  // Fill in the DHCP header fields
  //
  Config   = &DhcpSb->ActiveConfig;
  SeedHead = NULL;
 
  if (Seed != NULL) {
    SeedHead = &Seed->Dhcp4.Header;
  }
 
  Head = &Packet->Dhcp4.Header;
  ZeroMem (Head, sizeof (EFI_DHCP4_HEADER));
 
  Head->OpCode    = BOOTP_REQUEST;
  Head->HwType    = DhcpSb->HwType;
  Head->HwAddrLen = DhcpSb->HwLen;
  Head->Xid       = HTONL (DhcpSb->Xid);
  Head->Reserved  = HTONS (0x8000);     // Server, broadcast the message please.
 
  EFI_IP4 (Head->ClientAddr) = HTONL (DhcpSb->ClientAddr);
  CopyMem (Head->ClientHwAddr, DhcpSb->Mac.Addr, DhcpSb->HwLen);
 
  if ((Type == DHCP_MSG_DECLINE) || (Type == DHCP_MSG_RELEASE)) {
    Head->Seconds = 0;
  } else if ((Type == DHCP_MSG_REQUEST) && (DhcpSb->DhcpState == Dhcp4Requesting)) {
    //
    // Use the same value as the original DHCPDISCOVER message.
    //
    Head->Seconds = DhcpSb->LastPacket->Dhcp4.Header.Seconds;
  } else {
    SetElapsedTime (&Head->Seconds, DhcpSb->ActiveChild);
  }
 
  //
  // Append the DHCP message type
  //
  Packet->Dhcp4.Magik = DHCP_OPTION_MAGIC;
  Buf                 = Packet->Dhcp4.Option;
  Buf                 = DhcpAppendOption (Buf, DHCP4_TAG_MSG_TYPE, 1, &Type);
 
  //
  // Append the serverid option if necessary:
  //   1. DHCP decline message
  //   2. DHCP release message
  //   3. DHCP request to confirm one lease.
  //
  if ((Type == DHCP_MSG_DECLINE) || (Type == DHCP_MSG_RELEASE) ||
      ((Type == DHCP_MSG_REQUEST) && (DhcpSb->DhcpState == Dhcp4Requesting))
      )
  {
    ASSERT ((Para != NULL) && (Para->ServerId != 0));
 
    IpAddr = HTONL (Para->ServerId);
    Buf    = DhcpAppendOption (Buf, DHCP4_TAG_SERVER_ID, 4, (UINT8 *)&IpAddr);
  }
 
  //
  // Append the requested IP option if necessary:
  //   1. DHCP request to use the previously allocated address
  //   2. DHCP request to confirm one lease
  //   3. DHCP decline to decline one lease
  //
  IpAddr = 0;
 
  if (Type == DHCP_MSG_REQUEST) {
    if (DhcpSb->DhcpState == Dhcp4Rebooting) {
      IpAddr = EFI_IP4 (Config->ClientAddress);
    } else if (DhcpSb->DhcpState == Dhcp4Requesting) {
      ASSERT (SeedHead != NULL);
      IpAddr = EFI_IP4 (SeedHead->YourAddr);
    }
  } else if (Type == DHCP_MSG_DECLINE) {
    ASSERT (SeedHead != NULL);
    IpAddr = EFI_IP4 (SeedHead->YourAddr);
  }
 
  if (IpAddr != 0) {
    Buf = DhcpAppendOption (Buf, DHCP4_TAG_REQUEST_IP, 4, (UINT8 *)&IpAddr);
  }
 
  //
  // Append the Max Message Length option if it isn't a DECLINE
  // or RELEASE to direct the server use large messages instead of
  // override the BOOTFILE and SERVER fields in the message head.
  //
  if ((Type != DHCP_MSG_DECLINE) && (Type != DHCP_MSG_RELEASE)) {
    MaxMsg = HTONS (0xFF00);
    Buf    = DhcpAppendOption (Buf, DHCP4_TAG_MAXMSG, 2, (UINT8 *)&MaxMsg);
  }
 
  //
  // Append the user's message if it isn't NULL
  //
  if (Msg != NULL) {
    Len = MIN ((UINT32)AsciiStrLen ((CHAR8 *)Msg), 255);
    Buf = DhcpAppendOption (Buf, DHCP4_TAG_MESSAGE, (UINT16)Len, Msg);
  }
 
  //
  // Append the user configured options
  //
  if (DhcpSb->UserOptionLen != 0) {
    for (Index = 0; Index < Config->OptionCount; Index++) {
      //
      // We can't use any option other than the client ID from user
      // if it is a DHCP decline or DHCP release .
      //
      if (((Type == DHCP_MSG_DECLINE) || (Type == DHCP_MSG_RELEASE)) &&
          (Config->OptionList[Index]->OpCode != DHCP4_TAG_CLIENT_ID))
      {
        continue;
      }
 
      Buf = DhcpAppendOption (
              Buf,
              Config->OptionList[Index]->OpCode,
              Config->OptionList[Index]->Length,
              Config->OptionList[Index]->Data
              );
    }
  }
 
  *(Buf++)        = DHCP4_TAG_EOP;
  Packet->Length += (UINT32)(Buf - Packet->Dhcp4.Option);
 
  //
  // OK, the message is built, call the user to override it.
  //
  Status    = EFI_SUCCESS;
  NewPacket = NULL;
 
  if (Type == DHCP_MSG_DISCOVER) {
    Status = DhcpCallUser (DhcpSb, Dhcp4SendDiscover, Packet, &NewPacket);
  } else if (Type == DHCP_MSG_REQUEST) {
    Status = DhcpCallUser (DhcpSb, Dhcp4SendRequest, Packet, &NewPacket);
  } else if (Type == DHCP_MSG_DECLINE) {
    Status = DhcpCallUser (DhcpSb, Dhcp4SendDecline, Packet, &NewPacket);
  }
 
  if (EFI_ERROR (Status)) {
    FreePool (Packet);
    return Status;
  }
 
  if (NewPacket != NULL) {
    FreePool (Packet);
    Packet = NewPacket;
  }
 
  //
  // Save the Client Address will be sent out
  //
  CopyMem (
    &DhcpSb->ClientAddressSendOut[0],
    &Packet->Dhcp4.Header.ClientHwAddr[0],
    Packet->Dhcp4.Header.HwAddrLen
    );
 
  //
  // Wrap it into a netbuf then send it.
  //
  Frag.Bulk = (UINT8 *)&Packet->Dhcp4.Header;
  Frag.Len  = Packet->Length;
  Wrap      = NetbufFromExt (&Frag, 1, 0, 0, DhcpDummyExtFree, NULL);
 
  if (Wrap == NULL) {
    FreePool (Packet);
    return EFI_OUT_OF_RESOURCES;
  }
 
  //
  // Save it as the last sent packet for retransmission
  //
  if (DhcpSb->LastPacket != NULL) {
    FreePool (DhcpSb->LastPacket);
  }
 
  DhcpSb->LastPacket = Packet;
  DhcpSetTransmitTimer (DhcpSb);
 
  //
  // Broadcast the message, unless we know the server address.
  // Use the lease UdpIo port to send the unicast packet.
  //
  EndPoint.RemoteAddr.Addr[0] = 0xffffffff;
  EndPoint.LocalAddr.Addr[0]  = 0;
  EndPoint.RemotePort         = DHCP_SERVER_PORT;
  EndPoint.LocalPort          = DHCP_CLIENT_PORT;
  UdpIo                       = DhcpSb->UdpIo;
 
  if ((DhcpSb->DhcpState == Dhcp4Renewing) || (Type == DHCP_MSG_RELEASE)) {
    EndPoint.RemoteAddr.Addr[0] = DhcpSb->ServerAddr;
    EndPoint.LocalAddr.Addr[0]  = DhcpSb->ClientAddr;
    UdpIo                       = DhcpSb->LeaseIoPort;
  }
 
  ASSERT (UdpIo != NULL);
 
  Status = UdpIoSendDatagram (
             UdpIo,
             Wrap,
             &EndPoint,
             NULL,
             DhcpOnPacketSent,
             DhcpSb
             );
 
  if (EFI_ERROR (Status)) {
    NetbufFree (Wrap);
    return EFI_ACCESS_DENIED;
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
DhcpRetransmit (
  IN DHCP_SERVICE  *DhcpSb
  )
{
  UDP_IO         *UdpIo;
  UDP_END_POINT  EndPoint;
  NET_BUF        *Wrap;
  NET_FRAGMENT   Frag;
  EFI_STATUS     Status;
 
  ASSERT (DhcpSb->LastPacket != NULL);
 
  //
  // For REQUEST message in Dhcp4Requesting state, do not change the secs fields.
  //
  if (DhcpSb->DhcpState != Dhcp4Requesting) {
    SetElapsedTime (&DhcpSb->LastPacket->Dhcp4.Header.Seconds, DhcpSb->ActiveChild);
  }
 
  //
  // Wrap it into a netbuf then send it.
  //
  Frag.Bulk = (UINT8 *)&DhcpSb->LastPacket->Dhcp4.Header;
  Frag.Len  = DhcpSb->LastPacket->Length;
  Wrap      = NetbufFromExt (&Frag, 1, 0, 0, DhcpDummyExtFree, NULL);
 
  if (Wrap == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  //
  // Broadcast the message, unless we know the server address.
  //
  EndPoint.RemotePort         = DHCP_SERVER_PORT;
  EndPoint.LocalPort          = DHCP_CLIENT_PORT;
  EndPoint.RemoteAddr.Addr[0] = 0xffffffff;
  EndPoint.LocalAddr.Addr[0]  = 0;
  UdpIo                       = DhcpSb->UdpIo;
 
  if (DhcpSb->DhcpState == Dhcp4Renewing) {
    EndPoint.RemoteAddr.Addr[0] = DhcpSb->ServerAddr;
    EndPoint.LocalAddr.Addr[0]  = DhcpSb->ClientAddr;
    UdpIo                       = DhcpSb->LeaseIoPort;
  }
 
  ASSERT (UdpIo != NULL);
 
  Status = UdpIoSendDatagram (
             UdpIo,
             Wrap,
             &EndPoint,
             NULL,
             DhcpOnPacketSent,
             DhcpSb
             );
 
  if (EFI_ERROR (Status)) {
    NetbufFree (Wrap);
    return EFI_ACCESS_DENIED;
  }
 
  return EFI_SUCCESS;
}
 
VOID
EFIAPI
DhcpOnTimerTick (
  IN EFI_EVENT  Event,
  IN VOID       *Context
  )
{
  LIST_ENTRY     *Entry;
  LIST_ENTRY     *Next;
  DHCP_SERVICE   *DhcpSb;
  DHCP_PROTOCOL  *Instance;
  EFI_STATUS     Status;
 
  DhcpSb   = (DHCP_SERVICE *)Context;
  Instance = DhcpSb->ActiveChild;
 
  //
  // 0xffff is the maximum supported value for elapsed time according to RFC.
  //
  if ((Instance != NULL) && (Instance->ElaspedTime < 0xffff)) {
    Instance->ElaspedTime++;
  }
 
  //
  // Check the retransmit timer
  //
  if ((DhcpSb->PacketToLive > 0) && (--DhcpSb->PacketToLive == 0)) {
    //
    // Select offer at each timeout if any offer received.
    //
    if ((DhcpSb->DhcpState == Dhcp4Selecting) && (DhcpSb->LastOffer != NULL)) {
      Status = DhcpChooseOffer (DhcpSb);
 
      if (EFI_ERROR (Status)) {
        if (DhcpSb->LastOffer != NULL) {
          FreePool (DhcpSb->LastOffer);
          DhcpSb->LastOffer = NULL;
        }
      } else {
        goto ON_EXIT;
      }
    }
 
    if (++DhcpSb->CurRetry < DhcpSb->MaxRetries) {
      //
      // Still has another try
      //
      DhcpRetransmit (DhcpSb);
      DhcpSetTransmitTimer (DhcpSb);
    } else if (DHCP_CONNECTED (DhcpSb->DhcpState)) {
      //
      // Retransmission failed, if the DHCP request is initiated by
      // user, adjust the current state according to the lease life.
      // Otherwise do nothing to wait the lease to timeout
      //
      if (DhcpSb->ExtraRefresh != 0) {
        Status = EFI_SUCCESS;
 
        if (DhcpSb->LeaseLife < DhcpSb->T1) {
          Status = DhcpSetState (DhcpSb, Dhcp4Bound, FALSE);
        } else if (DhcpSb->LeaseLife < DhcpSb->T2) {
          Status = DhcpSetState (DhcpSb, Dhcp4Renewing, FALSE);
        } else if (DhcpSb->LeaseLife < DhcpSb->Lease) {
          Status = DhcpSetState (DhcpSb, Dhcp4Rebinding, FALSE);
        } else {
          goto END_SESSION;
        }
 
        DhcpSb->IoStatus = EFI_TIMEOUT;
        DhcpNotifyUser (DhcpSb, DHCP_NOTIFY_RENEWREBIND);
      }
    } else {
      goto END_SESSION;
    }
  }
 
  //
  // If an address has been acquired, check whether need to
  // refresh or whether it has expired.
  //
  if (DHCP_CONNECTED (DhcpSb->DhcpState)) {
    DhcpSb->LeaseLife++;
 
    //
    // Don't timeout the lease, only count the life if user is
    // requesting extra renew/rebind. Adjust the state after that.
    //
    if (DhcpSb->ExtraRefresh != 0) {
      return;
    }
 
    if (DhcpSb->LeaseLife == DhcpSb->Lease) {
      //
      // Lease expires, end the session
      //
      goto END_SESSION;
    } else if (DhcpSb->LeaseLife == DhcpSb->T2) {
      //
      // T2 expires, transit to rebinding then send a REQUEST to any server
      //
      if (EFI_ERROR (DhcpSetState (DhcpSb, Dhcp4Rebinding, TRUE))) {
        goto END_SESSION;
      }
 
      if (Instance != NULL) {
        Instance->ElaspedTime = 0;
      }
 
      Status = DhcpSendMessage (
                 DhcpSb,
                 DhcpSb->Selected,
                 DhcpSb->Para,
                 DHCP_MSG_REQUEST,
                 NULL
                 );
 
      if (EFI_ERROR (Status)) {
        goto END_SESSION;
      }
    } else if (DhcpSb->LeaseLife == DhcpSb->T1) {
      //
      // T1 expires, transit to renewing, then send a REQUEST to the server
      //
      if (EFI_ERROR (DhcpSetState (DhcpSb, Dhcp4Renewing, TRUE))) {
        goto END_SESSION;
      }
 
      if (Instance != NULL) {
        Instance->ElaspedTime = 0;
      }
 
      Status = DhcpSendMessage (
                 DhcpSb,
                 DhcpSb->Selected,
                 DhcpSb->Para,
                 DHCP_MSG_REQUEST,
                 NULL
                 );
 
      if (EFI_ERROR (Status)) {
        goto END_SESSION;
      }
    }
  }
 
ON_EXIT:
  //
  // Iterate through all the DhcpSb Children.
  //
  NET_LIST_FOR_EACH_SAFE (Entry, Next, &DhcpSb->Children) {
    Instance = NET_LIST_USER_STRUCT (Entry, DHCP_PROTOCOL, Link);
    Instance->Timeout--;
    if ((Instance->Timeout == 0) && (Instance->Token != NULL)) {
      PxeDhcpDone (Instance);
    }
  }
 
  return;
 
END_SESSION:
  DhcpEndSession (DhcpSb, EFI_TIMEOUT);
 
  return;
}