Ip4If.c

Go to the documentation of this file.

 
#include "Ip4Impl.h"
 
//
// Mac address with all zero, used to determine whether the ARP
// resolve succeeded. Failed ARP requests zero the MAC address buffer.
//
EFI_MAC_ADDRESS  mZeroMacAddress;
 
VOID
EFIAPI
Ip4OnFrameSentDpc (
  IN VOID  *Context
  );
 
VOID
EFIAPI
Ip4OnFrameSent (
  IN EFI_EVENT  Event,
  IN VOID       *Context
  );
 
VOID
EFIAPI
Ip4OnArpResolvedDpc (
  IN VOID  *Context
  );
 
VOID
EFIAPI
Ip4OnArpResolved (
  IN EFI_EVENT  Event,
  IN VOID       *Context
  );
 
VOID
EFIAPI
Ip4OnFrameReceivedDpc (
  IN VOID  *Context
  );
 
VOID
EFIAPI
Ip4OnFrameReceived (
  IN EFI_EVENT  Event,
  IN VOID       *Context
  );
 
VOID
Ip4CancelFrameArp (
  IN IP4_ARP_QUE          *ArpQue,
  IN EFI_STATUS           IoStatus,
  IN IP4_FRAME_TO_CANCEL  FrameToCancel  OPTIONAL,
  IN VOID                 *Context
  );
 
IP4_LINK_TX_TOKEN *
Ip4WrapLinkTxToken (
  IN IP4_INTERFACE       *Interface,
  IN IP4_PROTOCOL        *IpInstance     OPTIONAL,
  IN NET_BUF             *Packet,
  IN IP4_FRAME_CALLBACK  CallBack,
  IN VOID                *Context,
  IN IP4_SERVICE         *IpSb
  )
{
  EFI_MANAGED_NETWORK_COMPLETION_TOKEN  *MnpToken;
  EFI_MANAGED_NETWORK_TRANSMIT_DATA     *MnpTxData;
  IP4_LINK_TX_TOKEN                     *Token;
  EFI_STATUS                            Status;
  UINT32                                Count;
 
  Token = AllocatePool (
            sizeof (IP4_LINK_TX_TOKEN) + \
            (Packet->BlockOpNum - 1) * sizeof (EFI_MANAGED_NETWORK_FRAGMENT_DATA)
            );
 
  if (Token == NULL) {
    return NULL;
  }
 
  Token->Signature = IP4_FRAME_TX_SIGNATURE;
  InitializeListHead (&Token->Link);
 
  Token->Interface  = Interface;
  Token->IpInstance = IpInstance;
  Token->IpSb       = IpSb;
  Token->CallBack   = CallBack;
  Token->Packet     = Packet;
  Token->Context    = Context;
  CopyMem (&Token->DstMac, &mZeroMacAddress, sizeof (Token->DstMac));
  CopyMem (&Token->SrcMac, &Interface->Mac, sizeof (Token->SrcMac));
 
  MnpToken         = &(Token->MnpToken);
  MnpToken->Status = EFI_NOT_READY;
 
  Status = gBS->CreateEvent (
                  EVT_NOTIFY_SIGNAL,
                  TPL_NOTIFY,
                  Ip4OnFrameSent,
                  Token,
                  &MnpToken->Event
                  );
 
  if (EFI_ERROR (Status)) {
    FreePool (Token);
    return NULL;
  }
 
  MnpTxData               = &Token->MnpTxData;
  MnpToken->Packet.TxData = MnpTxData;
 
  MnpTxData->DestinationAddress = &Token->DstMac;
  MnpTxData->SourceAddress      = &Token->SrcMac;
  MnpTxData->ProtocolType       = IP4_ETHER_PROTO;
  MnpTxData->DataLength         = Packet->TotalSize;
  MnpTxData->HeaderLength       = 0;
 
  Count = Packet->BlockOpNum;
 
  NetbufBuildExt (Packet, (NET_FRAGMENT *)MnpTxData->FragmentTable, &Count);
  MnpTxData->FragmentCount = (UINT16)Count;
 
  return Token;
}
 
VOID
Ip4FreeLinkTxToken (
  IN IP4_LINK_TX_TOKEN  *Token
  )
{
  NET_CHECK_SIGNATURE (Token, IP4_FRAME_TX_SIGNATURE);
 
  gBS->CloseEvent (Token->MnpToken.Event);
  FreePool (Token);
}
 
IP4_ARP_QUE *
Ip4CreateArpQue (
  IN IP4_INTERFACE  *Interface,
  IN IP4_ADDR       DestIp
  )
{
  IP4_ARP_QUE  *ArpQue;
  EFI_STATUS   Status;
 
  ArpQue = AllocatePool (sizeof (IP4_ARP_QUE));
 
  if (ArpQue == NULL) {
    return NULL;
  }
 
  ArpQue->Signature = IP4_FRAME_ARP_SIGNATURE;
  InitializeListHead (&ArpQue->Link);
 
  InitializeListHead (&ArpQue->Frames);
  ArpQue->Interface = Interface;
 
  Status = gBS->CreateEvent (
                  EVT_NOTIFY_SIGNAL,
                  TPL_NOTIFY,
                  Ip4OnArpResolved,
                  ArpQue,
                  &ArpQue->OnResolved
                  );
 
  if (EFI_ERROR (Status)) {
    FreePool (ArpQue);
    return NULL;
  }
 
  ArpQue->Ip = DestIp;
  CopyMem (&ArpQue->Mac, &mZeroMacAddress, sizeof (ArpQue->Mac));
 
  return ArpQue;
}
 
VOID
Ip4FreeArpQue (
  IN IP4_ARP_QUE  *ArpQue,
  IN EFI_STATUS   IoStatus
  )
{
  NET_CHECK_SIGNATURE (ArpQue, IP4_FRAME_ARP_SIGNATURE);
 
  //
  // Remove all the frame waiting the ARP response
  //
  Ip4CancelFrameArp (ArpQue, IoStatus, NULL, NULL);
 
  gBS->CloseEvent (ArpQue->OnResolved);
  FreePool (ArpQue);
}
 
IP4_LINK_RX_TOKEN *
Ip4CreateLinkRxToken (
  IN IP4_INTERFACE       *Interface,
  IN IP4_PROTOCOL        *IpInstance,
  IN IP4_FRAME_CALLBACK  CallBack,
  IN VOID                *Context
  )
{
  EFI_MANAGED_NETWORK_COMPLETION_TOKEN  *MnpToken;
  IP4_LINK_RX_TOKEN                     *Token;
  EFI_STATUS                            Status;
 
  Token = AllocatePool (sizeof (IP4_LINK_RX_TOKEN));
  if (Token == NULL) {
    return NULL;
  }
 
  Token->Signature  = IP4_FRAME_RX_SIGNATURE;
  Token->Interface  = Interface;
  Token->IpInstance = IpInstance;
  Token->CallBack   = CallBack;
  Token->Context    = Context;
 
  MnpToken         = &Token->MnpToken;
  MnpToken->Status = EFI_NOT_READY;
 
  Status = gBS->CreateEvent (
                  EVT_NOTIFY_SIGNAL,
                  TPL_NOTIFY,
                  Ip4OnFrameReceived,
                  Token,
                  &MnpToken->Event
                  );
 
  if (EFI_ERROR (Status)) {
    FreePool (Token);
    return NULL;
  }
 
  MnpToken->Packet.RxData = NULL;
  return Token;
}
 
VOID
Ip4FreeFrameRxToken (
  IN IP4_LINK_RX_TOKEN  *Token
  )
{
  NET_CHECK_SIGNATURE (Token, IP4_FRAME_RX_SIGNATURE);
 
  gBS->CloseEvent (Token->MnpToken.Event);
  FreePool (Token);
}
 
VOID
Ip4CancelFrameArp (
  IN IP4_ARP_QUE          *ArpQue,
  IN EFI_STATUS           IoStatus,
  IN IP4_FRAME_TO_CANCEL  FrameToCancel  OPTIONAL,
  IN VOID                 *Context
  )
{
  LIST_ENTRY         *Entry;
  LIST_ENTRY         *Next;
  IP4_LINK_TX_TOKEN  *Token;
 
  NET_LIST_FOR_EACH_SAFE (Entry, Next, &ArpQue->Frames) {
    Token = NET_LIST_USER_STRUCT (Entry, IP4_LINK_TX_TOKEN, Link);
 
    if ((FrameToCancel == NULL) || FrameToCancel (Token, Context)) {
      RemoveEntryList (Entry);
 
      Token->CallBack (Token->IpInstance, Token->Packet, IoStatus, 0, Token->Context);
      Ip4FreeLinkTxToken (Token);
    }
  }
}
 
VOID
Ip4CancelFrames (
  IN IP4_INTERFACE        *Interface,
  IN EFI_STATUS           IoStatus,
  IN IP4_FRAME_TO_CANCEL  FrameToCancel    OPTIONAL,
  IN VOID                 *Context
  )
{
  LIST_ENTRY         *Entry;
  LIST_ENTRY         *Next;
  IP4_ARP_QUE        *ArpQue;
  IP4_LINK_TX_TOKEN  *Token;
 
  //
  // Cancel all the pending frames on ARP requests
  //
  NET_LIST_FOR_EACH_SAFE (Entry, Next, &Interface->ArpQues) {
    ArpQue = NET_LIST_USER_STRUCT (Entry, IP4_ARP_QUE, Link);
 
    Ip4CancelFrameArp (ArpQue, IoStatus, FrameToCancel, Context);
 
    if (IsListEmpty (&ArpQue->Frames)) {
      Interface->Arp->Cancel (Interface->Arp, &ArpQue->Ip, ArpQue->OnResolved);
    }
  }
 
  //
  // Cancel all the frames that have been delivered to MNP
  // but not yet recycled.
  //
  NET_LIST_FOR_EACH_SAFE (Entry, Next, &Interface->SentFrames) {
    Token = NET_LIST_USER_STRUCT (Entry, IP4_LINK_TX_TOKEN, Link);
 
    if ((FrameToCancel == NULL) || FrameToCancel (Token, Context)) {
      Interface->Mnp->Cancel (Interface->Mnp, &Token->MnpToken);
    }
  }
}
 
IP4_INTERFACE *
Ip4CreateInterface (
  IN  EFI_MANAGED_NETWORK_PROTOCOL  *Mnp,
  IN  EFI_HANDLE                    Controller,
  IN  EFI_HANDLE                    ImageHandle
  )
{
  IP4_INTERFACE            *Interface;
  EFI_SIMPLE_NETWORK_MODE  SnpMode;
 
  if (Mnp == NULL) {
    return NULL;
  }
 
  Interface = AllocatePool (sizeof (IP4_INTERFACE));
 
  if (Interface == NULL) {
    return NULL;
  }
 
  Interface->Signature = IP4_INTERFACE_SIGNATURE;
  InitializeListHead (&Interface->Link);
  Interface->RefCnt = 1;
 
  Interface->Ip         = IP4_ALLZERO_ADDRESS;
  Interface->SubnetMask = IP4_ALLZERO_ADDRESS;
  Interface->Configured = FALSE;
 
  Interface->Controller = Controller;
  Interface->Image      = ImageHandle;
  Interface->Mnp        = Mnp;
  Interface->Arp        = NULL;
  Interface->ArpHandle  = NULL;
 
  InitializeListHead (&Interface->ArpQues);
  InitializeListHead (&Interface->SentFrames);
 
  Interface->RecvRequest = NULL;
 
  //
  // Get the interface's Mac address and broadcast mac address from SNP
  //
  if (EFI_ERROR (Mnp->GetModeData (Mnp, NULL, &SnpMode))) {
    FreePool (Interface);
    return NULL;
  }
 
  CopyMem (&Interface->Mac, &SnpMode.CurrentAddress, sizeof (Interface->Mac));
  CopyMem (&Interface->BroadcastMac, &SnpMode.BroadcastAddress, sizeof (Interface->BroadcastMac));
  Interface->HwaddrLen = SnpMode.HwAddressSize;
 
  InitializeListHead (&Interface->IpInstances);
  Interface->PromiscRecv = FALSE;
 
  return Interface;
}
 
EFI_STATUS
Ip4SetAddress (
  IN OUT IP4_INTERFACE  *Interface,
  IN     IP4_ADDR       IpAddr,
  IN     IP4_ADDR       SubnetMask
  )
{
  EFI_ARP_CONFIG_DATA  ArpConfig;
  EFI_STATUS           Status;
 
  NET_CHECK_SIGNATURE (Interface, IP4_INTERFACE_SIGNATURE);
 
  //
  // Set the ip/netmask, then compute the subnet broadcast
  // and network broadcast for easy access. When computing
  // network broadcast, the subnet mask is most like longer
  // than the default netmask (not subneted) as defined in
  // RFC793. If that isn't the case, we are aggregating the
  // networks, use the subnet's mask instead.
  //
  Interface->Ip            = IpAddr;
  Interface->SubnetMask    = SubnetMask;
  Interface->SubnetBrdcast = (IpAddr | ~SubnetMask);
  Interface->NetBrdcast    = (IpAddr | ~SubnetMask);
 
  //
  // Do clean up for Arp child
  //
  if (Interface->ArpHandle != NULL) {
    if (Interface->Arp != NULL) {
      gBS->CloseProtocol (
             Interface->ArpHandle,
             &gEfiArpProtocolGuid,
             Interface->Image,
             Interface->Controller
             );
 
      Interface->Arp = NULL;
    }
 
    NetLibDestroyServiceChild (
      Interface->Controller,
      Interface->Image,
      &gEfiArpServiceBindingProtocolGuid,
      Interface->ArpHandle
      );
 
    Interface->ArpHandle = NULL;
  }
 
  //
  // If the address is NOT all zero, create then configure an ARP child.
  // Pay attention: DHCP configures its station address as 0.0.0.0/0
  //
  if (IpAddr != IP4_ALLZERO_ADDRESS) {
    Status = NetLibCreateServiceChild (
               Interface->Controller,
               Interface->Image,
               &gEfiArpServiceBindingProtocolGuid,
               &Interface->ArpHandle
               );
 
    if (EFI_ERROR (Status)) {
      return Status;
    }
 
    Status = gBS->OpenProtocol (
                    Interface->ArpHandle,
                    &gEfiArpProtocolGuid,
                    (VOID **)&Interface->Arp,
                    Interface->Image,
                    Interface->Controller,
                    EFI_OPEN_PROTOCOL_BY_DRIVER
                    );
 
    if (EFI_ERROR (Status)) {
      goto ON_ERROR;
    }
 
    IpAddr                    = HTONL (IpAddr);
    ArpConfig.SwAddressType   = IP4_ETHER_PROTO;
    ArpConfig.SwAddressLength = 4;
    ArpConfig.StationAddress  = &IpAddr;
    ArpConfig.EntryTimeOut    = 0;
    ArpConfig.RetryCount      = 0;
    ArpConfig.RetryTimeOut    = 0;
 
    Status = Interface->Arp->Configure (Interface->Arp, &ArpConfig);
 
    if (EFI_ERROR (Status)) {
      gBS->CloseProtocol (
             Interface->ArpHandle,
             &gEfiArpProtocolGuid,
             Interface->Image,
             Interface->Controller
             );
 
      goto ON_ERROR;
    }
  }
 
  Interface->Configured = TRUE;
  return EFI_SUCCESS;
 
ON_ERROR:
  NetLibDestroyServiceChild (
    Interface->Controller,
    Interface->Image,
    &gEfiArpServiceBindingProtocolGuid,
    Interface->ArpHandle
    );
 
  return Status;
}
 
BOOLEAN
Ip4CancelInstanceFrame (
  IN IP4_LINK_TX_TOKEN  *Frame,
  IN VOID               *Context
  )
{
  if (Frame->IpInstance == (IP4_PROTOCOL *)Context) {
    return TRUE;
  }
 
  return FALSE;
}
 
VOID
Ip4CancelReceive (
  IN IP4_INTERFACE  *Interface
  )
{
  EFI_TPL            OldTpl;
  IP4_LINK_RX_TOKEN  *Token;
 
  if ((Token = Interface->RecvRequest) != NULL) {
    OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
    Interface->RecvRequest = NULL;
    Interface->Mnp->Cancel (Interface->Mnp, &Token->MnpToken);
 
    gBS->RestoreTPL (OldTpl);
  }
}
 
EFI_STATUS
Ip4FreeInterface (
  IN  IP4_INTERFACE  *Interface,
  IN  IP4_PROTOCOL   *IpInstance           OPTIONAL
  )
{
  NET_CHECK_SIGNATURE (Interface, IP4_INTERFACE_SIGNATURE);
  ASSERT (Interface->RefCnt > 0);
 
  //
  // Remove all the pending transmit token related to this IP instance.
  //
  Ip4CancelFrames (Interface, EFI_ABORTED, Ip4CancelInstanceFrame, IpInstance);
 
  if (--Interface->RefCnt > 0) {
    return EFI_SUCCESS;
  }
 
  //
  // Destroy the interface if this is the last IP instance that
  // has the address. Remove all the system transmitted packets
  // from this interface, cancel the receive request if there is
  // one, and destroy the ARP requests.
  //
  Ip4CancelFrames (Interface, EFI_ABORTED, Ip4CancelInstanceFrame, NULL);
  Ip4CancelReceive (Interface);
 
  ASSERT (IsListEmpty (&Interface->IpInstances));
  ASSERT (IsListEmpty (&Interface->ArpQues));
  ASSERT (IsListEmpty (&Interface->SentFrames));
 
  if (Interface->Arp != NULL) {
    gBS->CloseProtocol (
           Interface->ArpHandle,
           &gEfiArpProtocolGuid,
           Interface->Image,
           Interface->Controller
           );
 
    NetLibDestroyServiceChild (
      Interface->Controller,
      Interface->Image,
      &gEfiArpServiceBindingProtocolGuid,
      Interface->ArpHandle
      );
  }
 
  RemoveEntryList (&Interface->Link);
  FreePool (Interface);
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
Ip4SendFrameToDefaultRoute (
  IN  IP4_ARP_QUE  *ArpQue
  )
{
  LIST_ENTRY             *Entry;
  LIST_ENTRY             *Next;
  IP4_ROUTE_CACHE_ENTRY  *RtCacheEntry;
  IP4_LINK_TX_TOKEN      *Token;
  IP4_ADDR               Gateway;
  EFI_STATUS             Status;
  IP4_ROUTE_ENTRY        *DefaultRoute;
 
  //
  // ARP resolve failed when using /32 subnet mask.
  //
  NET_LIST_FOR_EACH_SAFE (Entry, Next, &ArpQue->Frames) {
    RemoveEntryList (Entry);
    Token = NET_LIST_USER_STRUCT (Entry, IP4_LINK_TX_TOKEN, Link);
    ASSERT (Token->Interface->SubnetMask == IP4_ALLONE_ADDRESS);
    //
    // Find the default gateway IP address. The default route was saved to the RtCacheEntry->Tag in Ip4Route().
    //
    RtCacheEntry = NULL;
    if (Token->IpInstance != NULL) {
      RtCacheEntry = Ip4FindRouteCache (Token->IpInstance->RouteTable, NTOHL (ArpQue->Ip), Token->Interface->Ip);
    }
 
    if (RtCacheEntry == NULL) {
      RtCacheEntry = Ip4FindRouteCache (Token->IpSb->DefaultRouteTable, NTOHL (ArpQue->Ip), Token->Interface->Ip);
    }
 
    if (RtCacheEntry == NULL) {
      Status = EFI_NO_MAPPING;
      goto ON_ERROR;
    }
 
    DefaultRoute = (IP4_ROUTE_ENTRY *)RtCacheEntry->Tag;
    if (DefaultRoute == NULL) {
      Status = EFI_NO_MAPPING;
      goto ON_ERROR;
    }
 
    //
    // Try to send the frame to the default route.
    //
    Gateway = DefaultRoute->NextHop;
    if (ArpQue->Ip == Gateway) {
      //
      // ARP resolve for the default route is failed, return error to caller.
      //
      Status = EFI_NO_MAPPING;
      goto ON_ERROR;
    }
 
    RtCacheEntry->NextHop = Gateway;
    Status                = Ip4SendFrame (Token->Interface, Token->IpInstance, Token->Packet, Gateway, Token->CallBack, Token->Context, Token->IpSb);
    if (EFI_ERROR (Status)) {
      Status = EFI_NO_MAPPING;
      goto ON_ERROR;
    }
 
    Ip4FreeRouteCacheEntry (RtCacheEntry);
  }
 
  return EFI_SUCCESS;
 
ON_ERROR:
  if (RtCacheEntry != NULL) {
    Ip4FreeRouteCacheEntry (RtCacheEntry);
  }
 
  Token->CallBack (Token->IpInstance, Token->Packet, Status, 0, Token->Context);
  Ip4FreeLinkTxToken (Token);
  return Status;
}
 
VOID
EFIAPI
Ip4OnArpResolvedDpc (
  IN VOID  *Context
  )
{
  LIST_ENTRY         *Entry;
  LIST_ENTRY         *Next;
  IP4_ARP_QUE        *ArpQue;
  IP4_INTERFACE      *Interface;
  IP4_LINK_TX_TOKEN  *Token;
  EFI_STATUS         Status;
  EFI_STATUS         IoStatus;
 
  ArpQue = (IP4_ARP_QUE *)Context;
  NET_CHECK_SIGNATURE (ArpQue, IP4_FRAME_ARP_SIGNATURE);
 
  RemoveEntryList (&ArpQue->Link);
 
  //
  // ARP resolve failed for some reason.
  //
  if (NET_MAC_EQUAL (&ArpQue->Mac, &mZeroMacAddress, ArpQue->Interface->HwaddrLen)) {
    if (ArpQue->Interface->SubnetMask != IP4_ALLONE_ADDRESS) {
      //
      // Release all the frame and ARP queue itself. Ip4FreeArpQue will call the frame's
      // owner back.
      //
      IoStatus = EFI_NO_MAPPING;
    } else {
      //
      // ARP resolve failed when using 32bit subnet mask, try to send the packets to the
      // default route.
      //
      IoStatus = Ip4SendFrameToDefaultRoute (ArpQue);
    }
 
    goto ON_EXIT;
  }
 
  //
  // ARP resolve succeeded, Transmit all the frame. Release the ARP
  // queue. It isn't necessary for us to cache the ARP binding because
  // we always check the ARP cache first before transmit.
  //
  IoStatus  = EFI_SUCCESS;
  Interface = ArpQue->Interface;
 
  NET_LIST_FOR_EACH_SAFE (Entry, Next, &ArpQue->Frames) {
    RemoveEntryList (Entry);
 
    Token = NET_LIST_USER_STRUCT (Entry, IP4_LINK_TX_TOKEN, Link);
    CopyMem (&Token->DstMac, &ArpQue->Mac, sizeof (Token->DstMac));
 
    //
    // Insert the tx token before transmitting it via MNP as the FrameSentDpc
    // may be called before Mnp->Transmit returns which will remove this tx
    // token from the SentFrames list. Remove it from the list if the returned
    // Status of Mnp->Transmit is not EFI_SUCCESS as in this case the
    // FrameSentDpc won't be queued.
    //
    InsertTailList (&Interface->SentFrames, &Token->Link);
 
    Status = Interface->Mnp->Transmit (Interface->Mnp, &Token->MnpToken);
    if (EFI_ERROR (Status)) {
      RemoveEntryList (&Token->Link);
      Token->CallBack (Token->IpInstance, Token->Packet, Status, 0, Token->Context);
 
      Ip4FreeLinkTxToken (Token);
      continue;
    }
  }
 
ON_EXIT:
  Ip4FreeArpQue (ArpQue, IoStatus);
}
 
VOID
EFIAPI
Ip4OnArpResolved (
  IN EFI_EVENT  Event,
  IN VOID       *Context
  )
{
  //
  // Request Ip4OnArpResolvedDpc as a DPC at TPL_CALLBACK
  //
  QueueDpc (TPL_CALLBACK, Ip4OnArpResolvedDpc, Context);
}
 
VOID
EFIAPI
Ip4OnFrameSentDpc (
  IN VOID  *Context
  )
{
  IP4_LINK_TX_TOKEN  *Token;
 
  Token = (IP4_LINK_TX_TOKEN *)Context;
  NET_CHECK_SIGNATURE (Token, IP4_FRAME_TX_SIGNATURE);
 
  RemoveEntryList (&Token->Link);
 
  Token->CallBack (
           Token->IpInstance,
           Token->Packet,
           Token->MnpToken.Status,
           0,
           Token->Context
           );
 
  Ip4FreeLinkTxToken (Token);
}
 
VOID
EFIAPI
Ip4OnFrameSent (
  IN EFI_EVENT  Event,
  IN VOID       *Context
  )
{
  //
  // Request Ip4OnFrameSentDpc as a DPC at TPL_CALLBACK
  //
  QueueDpc (TPL_CALLBACK, Ip4OnFrameSentDpc, Context);
}
 
EFI_STATUS
Ip4SendFrame (
  IN  IP4_INTERFACE       *Interface,
  IN  IP4_PROTOCOL        *IpInstance       OPTIONAL,
  IN  NET_BUF             *Packet,
  IN  IP4_ADDR            NextHop,
  IN  IP4_FRAME_CALLBACK  CallBack,
  IN  VOID                *Context,
  IN IP4_SERVICE          *IpSb
  )
{
  IP4_LINK_TX_TOKEN  *Token;
  LIST_ENTRY         *Entry;
  IP4_ARP_QUE        *ArpQue;
  EFI_ARP_PROTOCOL   *Arp;
  EFI_STATUS         Status;
 
  ASSERT (Interface->Configured);
 
  Token = Ip4WrapLinkTxToken (Interface, IpInstance, Packet, CallBack, Context, IpSb);
 
  if (Token == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  //
  // Get the destination MAC address for multicast and broadcasts.
  // Don't depend on ARP to solve the address since there maybe no
  // ARP at all. Ip4Output has set NextHop to 255.255.255.255 for
  // all the broadcasts.
  //
  if (NextHop == IP4_ALLONE_ADDRESS) {
    CopyMem (&Token->DstMac, &Interface->BroadcastMac, sizeof (Token->DstMac));
    goto SEND_NOW;
  } else if (IP4_IS_MULTICAST (NextHop)) {
    Status = Ip4GetMulticastMac (Interface->Mnp, NextHop, &Token->DstMac);
 
    if (EFI_ERROR (Status)) {
      goto ON_ERROR;
    }
 
    goto SEND_NOW;
  }
 
  //
  // Can only send out multicast/broadcast if the IP address is zero
  //
  if ((Arp = Interface->Arp) == NULL) {
    Status = EFI_NO_MAPPING;
    goto ON_ERROR;
  }
 
  //
  // First check whether this binding is in the ARP cache.
  //
  NextHop = HTONL (NextHop);
  Status  = Arp->Request (Arp, &NextHop, NULL, &Token->DstMac);
 
  if (Status == EFI_SUCCESS) {
    goto SEND_NOW;
  } else if (Status != EFI_NOT_READY) {
    goto ON_ERROR;
  }
 
  //
  // Have to do asynchronous ARP resolution. First check
  // whether there is already a pending request.
  //
  ArpQue = NULL;
 
  NET_LIST_FOR_EACH (Entry, &Interface->ArpQues) {
    ArpQue = NET_LIST_USER_STRUCT (Entry, IP4_ARP_QUE, Link);
 
    if (ArpQue->Ip == NextHop) {
      break;
    }
  }
 
  //
  // Found a pending ARP request, enqueue the frame then return
  //
  if (Entry != &Interface->ArpQues) {
    InsertTailList (&ArpQue->Frames, &Token->Link);
    return EFI_SUCCESS;
  }
 
  //
  // First frame to NextHop, issue an asynchronous ARP requests
  //
  ArpQue = Ip4CreateArpQue (Interface, NextHop);
 
  if (ArpQue == NULL) {
    Status = EFI_OUT_OF_RESOURCES;
    goto ON_ERROR;
  }
 
  Status = Arp->Request (Arp, &ArpQue->Ip, ArpQue->OnResolved, ArpQue->Mac.Addr);
 
  if (EFI_ERROR (Status) && (Status != EFI_NOT_READY)) {
    Ip4FreeArpQue (ArpQue, EFI_NO_MAPPING);
    goto ON_ERROR;
  }
 
  InsertHeadList (&ArpQue->Frames, &Token->Link);
  InsertHeadList (&Interface->ArpQues, &ArpQue->Link);
  return EFI_SUCCESS;
 
SEND_NOW:
  //
  // Insert the tx token into the SentFrames list before calling Mnp->Transmit.
  // Remove it if the returned status is not EFI_SUCCESS.
  //
  InsertTailList (&Interface->SentFrames, &Token->Link);
  Status = Interface->Mnp->Transmit (Interface->Mnp, &Token->MnpToken);
  if (EFI_ERROR (Status)) {
    RemoveEntryList (&Token->Link);
    goto ON_ERROR;
  }
 
  return EFI_SUCCESS;
 
ON_ERROR:
  Ip4FreeLinkTxToken (Token);
  return Status;
}
 
VOID
EFIAPI
Ip4RecycleFrame (
  IN VOID  *Context
  )
{
  IP4_LINK_RX_TOKEN  *Frame;
 
  Frame = (IP4_LINK_RX_TOKEN *)Context;
  NET_CHECK_SIGNATURE (Frame, IP4_FRAME_RX_SIGNATURE);
 
  gBS->SignalEvent (Frame->MnpToken.Packet.RxData->RecycleEvent);
  Ip4FreeFrameRxToken (Frame);
}
 
VOID
EFIAPI
Ip4OnFrameReceivedDpc (
  IN VOID  *Context
  )
{
  EFI_MANAGED_NETWORK_COMPLETION_TOKEN  *MnpToken;
  EFI_MANAGED_NETWORK_RECEIVE_DATA      *MnpRxData;
  IP4_LINK_RX_TOKEN                     *Token;
  NET_FRAGMENT                          Netfrag;
  NET_BUF                               *Packet;
  UINT32                                Flag;
 
  Token = (IP4_LINK_RX_TOKEN *)Context;
  NET_CHECK_SIGNATURE (Token, IP4_FRAME_RX_SIGNATURE);
 
  //
  // First clear the interface's receive request in case the
  // caller wants to call Ip4ReceiveFrame in the callback.
  //
  Token->Interface->RecvRequest = NULL;
 
  MnpToken  = &Token->MnpToken;
  MnpRxData = MnpToken->Packet.RxData;
 
  if (EFI_ERROR (MnpToken->Status) || (MnpRxData == NULL)) {
    Token->CallBack (Token->IpInstance, NULL, MnpToken->Status, 0, Token->Context);
    Ip4FreeFrameRxToken (Token);
 
    return;
  }
 
  //
  // Wrap the frame in a net buffer then deliver it to IP input.
  // IP will reassemble the packet, and deliver it to upper layer
  //
  Netfrag.Len  = MnpRxData->DataLength;
  Netfrag.Bulk = MnpRxData->PacketData;
 
  Packet = NetbufFromExt (&Netfrag, 1, 0, IP4_MAX_HEADLEN, Ip4RecycleFrame, Token);
 
  if (Packet == NULL) {
    gBS->SignalEvent (MnpRxData->RecycleEvent);
 
    Token->CallBack (Token->IpInstance, NULL, EFI_OUT_OF_RESOURCES, 0, Token->Context);
    Ip4FreeFrameRxToken (Token);
 
    return;
  }
 
  Flag  = (MnpRxData->BroadcastFlag ? IP4_LINK_BROADCAST : 0);
  Flag |= (MnpRxData->MulticastFlag ? IP4_LINK_MULTICAST : 0);
  Flag |= (MnpRxData->PromiscuousFlag ? IP4_LINK_PROMISC : 0);
 
  Token->CallBack (Token->IpInstance, Packet, EFI_SUCCESS, Flag, Token->Context);
}
 
VOID
EFIAPI
Ip4OnFrameReceived (
  IN EFI_EVENT  Event,
  IN VOID       *Context
  )
{
  //
  // Request Ip4OnFrameReceivedDpc as a DPC at TPL_CALLBACK
  //
  QueueDpc (TPL_CALLBACK, Ip4OnFrameReceivedDpc, Context);
}
 
EFI_STATUS
Ip4ReceiveFrame (
  IN  IP4_INTERFACE       *Interface,
  IN  IP4_PROTOCOL        *IpInstance       OPTIONAL,
  IN  IP4_FRAME_CALLBACK  CallBack,
  IN  VOID                *Context
  )
{
  IP4_LINK_RX_TOKEN  *Token;
  EFI_STATUS         Status;
 
  NET_CHECK_SIGNATURE (Interface, IP4_INTERFACE_SIGNATURE);
 
  if (Interface->RecvRequest != NULL) {
    return EFI_ALREADY_STARTED;
  }
 
  Token = Ip4CreateLinkRxToken (Interface, IpInstance, CallBack, Context);
 
  if (Token == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  Interface->RecvRequest = Token;
  Status                 = Interface->Mnp->Receive (Interface->Mnp, &Token->MnpToken);
  if (EFI_ERROR (Status)) {
    Interface->RecvRequest = NULL;
    Ip4FreeFrameRxToken (Token);
    return Status;
  }
 
  return EFI_SUCCESS;
}