Udp4Impl.c

Go to the documentation of this file.

 
#include "Udp4Impl.h"
 
UINT16  mUdp4RandomPort;
 
VOID
EFIAPI
Udp4CheckTimeout (
  IN EFI_EVENT  Event,
  IN VOID       *Context
  );
 
BOOLEAN
Udp4FindInstanceByPort (
  IN LIST_ENTRY        *InstanceList,
  IN EFI_IPv4_ADDRESS  *Address,
  IN UINT16            Port
  );
 
VOID
EFIAPI
Udp4DgramSent (
  IN EFI_STATUS         Status,
  IN VOID               *Context,
  IN IP_IO_IP_PROTOCOL  Sender,
  IN VOID               *NotifyData
  );
 
VOID
EFIAPI
Udp4DgramRcvd (
  IN EFI_STATUS            Status,
  IN UINT8                 IcmpError,
  IN EFI_NET_SESSION_DATA  *NetSession,
  IN NET_BUF               *Packet,
  IN VOID                  *Context
  );
 
EFI_STATUS
EFIAPI
Udp4CancelTokens (
  IN NET_MAP       *Map,
  IN NET_MAP_ITEM  *Item,
  IN VOID          *Arg OPTIONAL
  );
 
BOOLEAN
Udp4MatchDgram (
  IN UDP4_INSTANCE_DATA     *Instance,
  IN EFI_UDP4_SESSION_DATA  *Udp4Session
  );
 
VOID
EFIAPI
Udp4RecycleRxDataWrap (
  IN EFI_EVENT  Event,
  IN VOID       *Context
  );
 
UDP4_RXDATA_WRAP *
Udp4WrapRxData (
  IN UDP4_INSTANCE_DATA     *Instance,
  IN NET_BUF                *Packet,
  IN EFI_UDP4_RECEIVE_DATA  *RxData
  );
 
UINTN
Udp4EnqueueDgram (
  IN UDP4_SERVICE_DATA      *Udp4Service,
  IN NET_BUF                *Packet,
  IN EFI_UDP4_RECEIVE_DATA  *RxData
  );
 
VOID
Udp4DeliverDgram (
  IN UDP4_SERVICE_DATA  *Udp4Service
  );
 
VOID
Udp4Demultiplex (
  IN UDP4_SERVICE_DATA     *Udp4Service,
  IN EFI_NET_SESSION_DATA  *NetSession,
  IN NET_BUF               *Packet
  );
 
VOID
Udp4IcmpHandler (
  IN UDP4_SERVICE_DATA     *Udp4Service,
  IN UINT8                 IcmpError,
  IN EFI_NET_SESSION_DATA  *NetSession,
  IN NET_BUF               *Packet
  );
 
VOID
Udp4SendPortUnreach (
  IN IP_IO                 *IpIo,
  IN EFI_NET_SESSION_DATA  *NetSession,
  IN VOID                  *Udp4Header
  );
 
EFI_STATUS
Udp4CreateService (
  IN OUT UDP4_SERVICE_DATA  *Udp4Service,
  IN     EFI_HANDLE         ImageHandle,
  IN     EFI_HANDLE         ControllerHandle
  )
{
  EFI_STATUS           Status;
  IP_IO_OPEN_DATA      OpenData;
  EFI_IP4_CONFIG_DATA  *Ip4ConfigData;
 
  ZeroMem (Udp4Service, sizeof (UDP4_SERVICE_DATA));
 
  Udp4Service->Signature        = UDP4_SERVICE_DATA_SIGNATURE;
  Udp4Service->ServiceBinding   = mUdp4ServiceBinding;
  Udp4Service->ImageHandle      = ImageHandle;
  Udp4Service->ControllerHandle = ControllerHandle;
  Udp4Service->ChildrenNumber   = 0;
 
  InitializeListHead (&Udp4Service->ChildrenList);
 
  //
  // Create the IpIo for this service context.
  //
  Udp4Service->IpIo = IpIoCreate (ImageHandle, ControllerHandle, IP_VERSION_4);
  if (Udp4Service->IpIo == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  //
  // Set the OpenData used to open the IpIo.
  //
  Ip4ConfigData = &OpenData.IpConfigData.Ip4CfgData;
  CopyMem (Ip4ConfigData, &mIp4IoDefaultIpConfigData, sizeof (EFI_IP4_CONFIG_DATA));
  Ip4ConfigData->AcceptBroadcast = TRUE;
  OpenData.RcvdContext           = (VOID *)Udp4Service;
  OpenData.SndContext            = NULL;
  OpenData.PktRcvdNotify         = Udp4DgramRcvd;
  OpenData.PktSentNotify         = Udp4DgramSent;
 
  //
  // Configure and start the IpIo.
  //
  Status = IpIoOpen (Udp4Service->IpIo, &OpenData);
  if (EFI_ERROR (Status)) {
    goto ON_ERROR;
  }
 
  //
  // Create the event for Udp timeout checking.
  //
  Status = gBS->CreateEvent (
                  EVT_TIMER | EVT_NOTIFY_SIGNAL,
                  TPL_CALLBACK,
                  Udp4CheckTimeout,
                  Udp4Service,
                  &Udp4Service->TimeoutEvent
                  );
  if (EFI_ERROR (Status)) {
    goto ON_ERROR;
  }
 
  //
  // Start the timeout timer event.
  //
  Status = gBS->SetTimer (
                  Udp4Service->TimeoutEvent,
                  TimerPeriodic,
                  UDP4_TIMEOUT_INTERVAL
                  );
  if (EFI_ERROR (Status)) {
    goto ON_ERROR;
  }
 
  return EFI_SUCCESS;
 
ON_ERROR:
 
  if (Udp4Service->TimeoutEvent != NULL) {
    gBS->CloseEvent (Udp4Service->TimeoutEvent);
  }
 
  IpIoDestroy (Udp4Service->IpIo);
 
  return Status;
}
 
VOID
Udp4CleanService (
  IN UDP4_SERVICE_DATA  *Udp4Service
  )
{
  //
  // Cancel the TimeoutEvent timer.
  //
  gBS->SetTimer (Udp4Service->TimeoutEvent, TimerCancel, 0);
 
  //
  // Close the TimeoutEvent timer.
  //
  gBS->CloseEvent (Udp4Service->TimeoutEvent);
 
  //
  // Destroy the IpIo.
  //
  IpIoDestroy (Udp4Service->IpIo);
}
 
VOID
EFIAPI
Udp4CheckTimeout (
  IN EFI_EVENT  Event,
  IN VOID       *Context
  )
{
  UDP4_SERVICE_DATA   *Udp4Service;
  LIST_ENTRY          *Entry;
  UDP4_INSTANCE_DATA  *Instance;
  LIST_ENTRY          *WrapEntry;
  LIST_ENTRY          *NextEntry;
  UDP4_RXDATA_WRAP    *Wrap;
 
  Udp4Service = (UDP4_SERVICE_DATA *)Context;
  NET_CHECK_SIGNATURE (Udp4Service, UDP4_SERVICE_DATA_SIGNATURE);
 
  NET_LIST_FOR_EACH (Entry, &Udp4Service->ChildrenList) {
    //
    // Iterate all the instances belonging to this service context.
    //
    Instance = NET_LIST_USER_STRUCT (Entry, UDP4_INSTANCE_DATA, Link);
    NET_CHECK_SIGNATURE (Instance, UDP4_INSTANCE_DATA_SIGNATURE);
 
    if (!Instance->Configured || (Instance->ConfigData.ReceiveTimeout == 0)) {
      //
      // Skip this instance if it's not configured or no receive timeout.
      //
      continue;
    }
 
    NET_LIST_FOR_EACH_SAFE (WrapEntry, NextEntry, &Instance->RcvdDgramQue) {
      //
      // Iterate all the rxdatas belonging to this udp instance.
      //
      Wrap = NET_LIST_USER_STRUCT (WrapEntry, UDP4_RXDATA_WRAP, Link);
 
      //
      // TimeoutTick unit is microsecond, MNP_TIMEOUT_CHECK_INTERVAL unit is 100ns.
      //
      if (Wrap->TimeoutTick < (UDP4_TIMEOUT_INTERVAL / 10)) {
        //
        // Remove this RxData if it timeouts.
        //
        Udp4RecycleRxDataWrap (NULL, (VOID *)Wrap);
      } else {
        Wrap->TimeoutTick -= (UDP4_TIMEOUT_INTERVAL / 10);
      }
    }
  }
}
 
VOID
Udp4InitInstance (
  IN     UDP4_SERVICE_DATA   *Udp4Service,
  IN OUT UDP4_INSTANCE_DATA  *Instance
  )
{
  //
  // Set the signature.
  //
  Instance->Signature = UDP4_INSTANCE_DATA_SIGNATURE;
 
  //
  // Init the lists.
  //
  InitializeListHead (&Instance->Link);
  InitializeListHead (&Instance->RcvdDgramQue);
  InitializeListHead (&Instance->DeliveredDgramQue);
 
  //
  // Init the NET_MAPs.
  //
  NetMapInit (&Instance->TxTokens);
  NetMapInit (&Instance->RxTokens);
  NetMapInit (&Instance->McastIps);
 
  //
  // Save the pointer to the UDP4_SERVICE_DATA, and initialize other members.
  //
  Instance->Udp4Service = Udp4Service;
  CopyMem (&Instance->Udp4Proto, &mUdp4Protocol, sizeof (Instance->Udp4Proto));
  Instance->IcmpError   = EFI_SUCCESS;
  Instance->Configured  = FALSE;
  Instance->IsNoMapping = FALSE;
  Instance->InDestroy   = FALSE;
}
 
VOID
Udp4CleanInstance (
  IN UDP4_INSTANCE_DATA  *Instance
  )
{
  NetMapClean (&Instance->McastIps);
  NetMapClean (&Instance->RxTokens);
  NetMapClean (&Instance->TxTokens);
}
 
BOOLEAN
Udp4FindInstanceByPort (
  IN LIST_ENTRY        *InstanceList,
  IN EFI_IPv4_ADDRESS  *Address,
  IN UINT16            Port
  )
{
  LIST_ENTRY            *Entry;
  UDP4_INSTANCE_DATA    *Instance;
  EFI_UDP4_CONFIG_DATA  *ConfigData;
 
  NET_LIST_FOR_EACH (Entry, InstanceList) {
    //
    // Iterate all the udp instances.
    //
    Instance   = NET_LIST_USER_STRUCT (Entry, UDP4_INSTANCE_DATA, Link);
    ConfigData = &Instance->ConfigData;
 
    if (!Instance->Configured || ConfigData->AcceptAnyPort) {
      //
      // If the instance is not configured or the configdata of the instance indicates
      // this instance accepts any port, skip it.
      //
      continue;
    }
 
    if (EFI_IP4_EQUAL (&ConfigData->StationAddress, Address) &&
        (ConfigData->StationPort == Port))
    {
      //
      // if both the address and the port are the same, return TRUE.
      //
      return TRUE;
    }
  }
 
  //
  // return FALSE when matching fails.
  //
  return FALSE;
}
 
EFI_STATUS
Udp4Bind (
  IN     LIST_ENTRY            *InstanceList,
  IN OUT EFI_UDP4_CONFIG_DATA  *ConfigData
  )
{
  EFI_IPv4_ADDRESS  *StationAddress;
  UINT16            StartPort;
 
  if (ConfigData->AcceptAnyPort) {
    return EFI_SUCCESS;
  }
 
  StationAddress = &ConfigData->StationAddress;
 
  if (ConfigData->StationPort != 0) {
    if (!ConfigData->AllowDuplicatePort &&
        Udp4FindInstanceByPort (InstanceList, StationAddress, ConfigData->StationPort))
    {
      //
      // Do not allow duplicate port and the port is already used by other instance.
      //
      return EFI_ACCESS_DENIED;
    }
  } else {
    //
    // select a random port for this instance;
    //
 
    if (ConfigData->AllowDuplicatePort) {
      //
      // Just pick up the random port if the instance allows duplicate port.
      //
      ConfigData->StationPort = mUdp4RandomPort;
    } else {
      StartPort = mUdp4RandomPort;
 
      while (Udp4FindInstanceByPort (InstanceList, StationAddress, mUdp4RandomPort)) {
        mUdp4RandomPort++;
        if (mUdp4RandomPort == 0) {
          mUdp4RandomPort = UDP4_PORT_KNOWN;
        }
 
        if (mUdp4RandomPort == StartPort) {
          //
          // No available port.
          //
          return EFI_OUT_OF_RESOURCES;
        }
      }
 
      ConfigData->StationPort = mUdp4RandomPort;
    }
 
    mUdp4RandomPort++;
    if (mUdp4RandomPort == 0) {
      mUdp4RandomPort = UDP4_PORT_KNOWN;
    }
  }
 
  return EFI_SUCCESS;
}
 
BOOLEAN
Udp4IsReconfigurable (
  IN EFI_UDP4_CONFIG_DATA  *OldConfigData,
  IN EFI_UDP4_CONFIG_DATA  *NewConfigData
  )
{
  if ((NewConfigData->AcceptAnyPort      != OldConfigData->AcceptAnyPort)     ||
      (NewConfigData->AcceptBroadcast    != OldConfigData->AcceptBroadcast)   ||
      (NewConfigData->AcceptPromiscuous  != OldConfigData->AcceptPromiscuous) ||
      (NewConfigData->AllowDuplicatePort != OldConfigData->AllowDuplicatePort)
      )
  {
    //
    // The receiving filter parameters cannot be changed.
    //
    return FALSE;
  }
 
  if ((!NewConfigData->AcceptAnyPort) &&
      (NewConfigData->StationPort != OldConfigData->StationPort)
      )
  {
    //
    // The port is not changeable.
    //
    return FALSE;
  }
 
  if (!NewConfigData->AcceptPromiscuous) {
    if (NewConfigData->UseDefaultAddress != OldConfigData->UseDefaultAddress) {
      //
      // The NewConfigData differs to the old one on the UseDefaultAddress.
      //
      return FALSE;
    }
 
    if (!NewConfigData->UseDefaultAddress &&
        (!EFI_IP4_EQUAL (&NewConfigData->StationAddress, &OldConfigData->StationAddress) ||
         !EFI_IP4_EQUAL (&NewConfigData->SubnetMask, &OldConfigData->SubnetMask))
        )
    {
      //
      // If the instance doesn't use the default address, and the new address or
      // new subnet mask is different from the old values.
      //
      return FALSE;
    }
  }
 
  if (!EFI_IP4_EQUAL (&NewConfigData->RemoteAddress, &OldConfigData->RemoteAddress)) {
    //
    // The remoteaddress is not the same.
    //
    return FALSE;
  }
 
  if (!EFI_IP4_EQUAL (&NewConfigData->RemoteAddress, &mZeroIp4Addr) &&
      (NewConfigData->RemotePort != OldConfigData->RemotePort)
      )
  {
    //
    // The RemotePort differs if it's designated in the configdata.
    //
    return FALSE;
  }
 
  //
  // All checks pass, return TRUE.
  //
  return TRUE;
}
 
VOID
Udp4BuildIp4ConfigData (
  IN     EFI_UDP4_CONFIG_DATA  *Udp4ConfigData,
  IN OUT EFI_IP4_CONFIG_DATA   *Ip4ConfigData
  )
{
  CopyMem (Ip4ConfigData, &mIp4IoDefaultIpConfigData, sizeof (*Ip4ConfigData));
 
  Ip4ConfigData->DefaultProtocol   = EFI_IP_PROTO_UDP;
  Ip4ConfigData->AcceptBroadcast   = Udp4ConfigData->AcceptBroadcast;
  Ip4ConfigData->AcceptPromiscuous = Udp4ConfigData->AcceptPromiscuous;
  Ip4ConfigData->UseDefaultAddress = Udp4ConfigData->UseDefaultAddress;
  CopyMem (&Ip4ConfigData->StationAddress, &Udp4ConfigData->StationAddress, sizeof (EFI_IPv4_ADDRESS));
  CopyMem (&Ip4ConfigData->SubnetMask, &Udp4ConfigData->SubnetMask, sizeof (EFI_IPv4_ADDRESS));
 
  //
  // use the -1 magic number to disable the receiving process of the ip instance.
  //
  Ip4ConfigData->ReceiveTimeout = (UINT32)(-1);
}
 
EFI_STATUS
Udp4ValidateTxToken (
  IN UDP4_INSTANCE_DATA         *Instance,
  IN EFI_UDP4_COMPLETION_TOKEN  *TxToken
  )
{
  EFI_UDP4_TRANSMIT_DATA  *TxData;
  UINT32                  Index;
  UINT32                  TotalLen;
  EFI_UDP4_CONFIG_DATA    *ConfigData;
  EFI_UDP4_SESSION_DATA   *UdpSessionData;
  IP4_ADDR                SourceAddress;
  IP4_ADDR                GatewayAddress;
 
  if (TxToken->Event == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  TxData = TxToken->Packet.TxData;
 
  if ((TxData == NULL) || (TxData->FragmentCount == 0)) {
    return EFI_INVALID_PARAMETER;
  }
 
  TotalLen = 0;
  for (Index = 0; Index < TxData->FragmentCount; Index++) {
    if ((TxData->FragmentTable[Index].FragmentBuffer == NULL) ||
        (TxData->FragmentTable[Index].FragmentLength == 0))
    {
      //
      // if the FragmentBuffer is NULL or the FragmentLeng is zero.
      //
      return EFI_INVALID_PARAMETER;
    }
 
    TotalLen += TxData->FragmentTable[Index].FragmentLength;
  }
 
  if (TotalLen != TxData->DataLength) {
    //
    // The TotalLen calculated by adding all the FragmentLeng doesn't equal to the
    // DataLength.
    //
    return EFI_INVALID_PARAMETER;
  }
 
  if (TxData->GatewayAddress != NULL) {
    CopyMem (&GatewayAddress, TxData->GatewayAddress, sizeof (IP4_ADDR));
 
    if (!Instance->ConfigData.UseDefaultAddress &&
        (EFI_NTOHL (Instance->ConfigData.SubnetMask) != 0) &&
        !NetIp4IsUnicast (NTOHL (GatewayAddress), EFI_NTOHL (Instance->ConfigData.SubnetMask)))
    {
      //
      // The specified GatewayAddress is not a unicast IPv4 address while it's not 0.
      //
      return EFI_INVALID_PARAMETER;
    }
  }
 
  ConfigData     = &Instance->ConfigData;
  UdpSessionData = TxData->UdpSessionData;
 
  if (UdpSessionData != NULL) {
    CopyMem (&SourceAddress, &UdpSessionData->SourceAddress, sizeof (IP4_ADDR));
 
    if ((SourceAddress != 0) &&
        !Instance->ConfigData.UseDefaultAddress &&
        (EFI_NTOHL (Instance->ConfigData.SubnetMask) != 0) &&
        !NetIp4IsUnicast (HTONL (SourceAddress), EFI_NTOHL (Instance->ConfigData.SubnetMask)))
    {
      //
      // Check whether SourceAddress is a valid IPv4 address in case it's not zero.
      // The configured station address is used if SourceAddress is zero.
      //
      return EFI_INVALID_PARAMETER;
    }
 
    if ((UdpSessionData->DestinationPort == 0) && (ConfigData->RemotePort == 0)) {
      //
      // Ambiguous, no available DestinationPort for this token.
      //
      return EFI_INVALID_PARAMETER;
    }
 
    if (EFI_IP4_EQUAL (&UdpSessionData->DestinationAddress, &mZeroIp4Addr)) {
      //
      // The DestinationAddress specified in the UdpSessionData is 0.
      //
      return EFI_INVALID_PARAMETER;
    }
  } else if (EFI_IP4_EQUAL (&ConfigData->RemoteAddress, &mZeroIp4Addr)) {
    //
    // the configured RemoteAddress is all zero, and the user doesn't override the
    // destination address.
    //
    return EFI_INVALID_PARAMETER;
  }
 
  if (TxData->DataLength > UDP4_MAX_DATA_SIZE) {
    return EFI_BAD_BUFFER_SIZE;
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
Udp4TokenExist (
  IN NET_MAP       *Map,
  IN NET_MAP_ITEM  *Item,
  IN VOID          *Context
  )
{
  EFI_UDP4_COMPLETION_TOKEN  *Token;
  EFI_UDP4_COMPLETION_TOKEN  *TokenInItem;
 
  Token       = (EFI_UDP4_COMPLETION_TOKEN *)Context;
  TokenInItem = (EFI_UDP4_COMPLETION_TOKEN *)Item->Key;
 
  if ((Token == TokenInItem) || (Token->Event == TokenInItem->Event)) {
    //
    // The Token duplicates with the TokenInItem in case either the two pointers are the
    // same or the Events of these two tokens are the same.
    //
    return EFI_ACCESS_DENIED;
  }
 
  return EFI_SUCCESS;
}
 
UINT16
Udp4Checksum (
  IN NET_BUF  *Packet,
  IN UINT16   HeadSum
  )
{
  UINT16  Checksum;
 
  Checksum = NetbufChecksum (Packet);
  Checksum = NetAddChecksum (Checksum, HeadSum);
 
  Checksum = NetAddChecksum (Checksum, HTONS ((UINT16)Packet->TotalSize));
 
  return (UINT16) ~Checksum;
}
 
EFI_STATUS
Udp4RemoveToken (
  IN OUT NET_MAP                    *TokenMap,
  IN     EFI_UDP4_COMPLETION_TOKEN  *Token
  )
{
  NET_MAP_ITEM  *Item;
 
  //
  // Find the Token first.
  //
  Item = NetMapFindKey (TokenMap, (VOID *)Token);
 
  if (Item != NULL) {
    //
    // Remove the token if it's found in the map.
    //
    NetMapRemoveItem (TokenMap, Item, NULL);
 
    return EFI_SUCCESS;
  }
 
  return EFI_NOT_FOUND;
}
 
VOID
EFIAPI
Udp4DgramSent (
  IN EFI_STATUS         Status,
  IN VOID               *Context,
  IN IP_IO_IP_PROTOCOL  Sender,
  IN VOID               *NotifyData
  )
{
  UDP4_INSTANCE_DATA         *Instance;
  EFI_UDP4_COMPLETION_TOKEN  *Token;
 
  Instance = (UDP4_INSTANCE_DATA *)Context;
  Token    = (EFI_UDP4_COMPLETION_TOKEN *)NotifyData;
 
  if (Udp4RemoveToken (&Instance->TxTokens, Token) == EFI_SUCCESS) {
    //
    // The token may be cancelled. Only signal it if the remove operation succeeds.
    //
    Token->Status = Status;
    gBS->SignalEvent (Token->Event);
    DispatchDpc ();
  }
}
 
VOID
EFIAPI
Udp4DgramRcvd (
  IN EFI_STATUS            Status,
  IN UINT8                 IcmpError,
  IN EFI_NET_SESSION_DATA  *NetSession,
  IN NET_BUF               *Packet,
  IN VOID                  *Context
  )
{
  NET_CHECK_SIGNATURE (Packet, NET_BUF_SIGNATURE);
 
  //
  // IpIo only passes received packets with Status EFI_SUCCESS or EFI_ICMP_ERROR.
  //
  if (Status == EFI_SUCCESS) {
    //
    // Demultiplex the received datagram.
    //
    Udp4Demultiplex ((UDP4_SERVICE_DATA *)Context, NetSession, Packet);
  } else {
    //
    // Handle the ICMP_ERROR packet.
    //
    Udp4IcmpHandler ((UDP4_SERVICE_DATA *)Context, IcmpError, NetSession, Packet);
  }
 
  //
  // Dispatch the DPC queued by the NotifyFunction of the rx token's events
  // which are signaled with received data.
  //
  DispatchDpc ();
}
 
EFI_STATUS
EFIAPI
Udp4LeaveGroup (
  IN OUT NET_MAP       *Map,
  IN     NET_MAP_ITEM  *Item,
  IN     VOID          *Arg OPTIONAL
  )
{
  EFI_IPv4_ADDRESS  *McastIp;
 
  McastIp = Arg;
 
  if ((McastIp != NULL) && (!EFI_IP4_EQUAL (McastIp, &(Item->Key)))) {
    //
    // McastIp is not NULL and the multicast address contained in the Item
    // is not the same as McastIp.
    //
    return EFI_SUCCESS;
  }
 
  //
  // Remove this Item.
  //
  NetMapRemoveItem (Map, Item, NULL);
 
  if (McastIp != NULL) {
    //
    // Return EFI_ABORTED in case McastIp is not NULL to terminate the iteration.
    //
    return EFI_ABORTED;
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
Udp4CancelTokens (
  IN NET_MAP       *Map,
  IN NET_MAP_ITEM  *Item,
  IN VOID          *Arg OPTIONAL
  )
{
  EFI_UDP4_COMPLETION_TOKEN  *TokenToCancel;
  NET_BUF                    *Packet;
  IP_IO                      *IpIo;
 
  if ((Arg != NULL) && (Item->Key != Arg)) {
    return EFI_SUCCESS;
  }
 
  if (Item->Value != NULL) {
    //
    // If the token is a transmit token, the corresponding Packet is recorded in
    // Item->Value, invoke IpIo to cancel this packet first. The IpIoCancelTxToken
    // will invoke Udp4DgramSent, the token will be signaled and this Item will
    // be removed from the Map there.
    //
    Packet = (NET_BUF *)(Item->Value);
    IpIo   = (IP_IO *)(*((UINTN *)&Packet->ProtoData[0]));
 
    IpIoCancelTxToken (IpIo, Packet);
  } else {
    //
    // The token is a receive token. Abort it and remove it from the Map.
    //
    TokenToCancel = (EFI_UDP4_COMPLETION_TOKEN *)Item->Key;
    NetMapRemoveItem (Map, Item, NULL);
 
    TokenToCancel->Status = EFI_ABORTED;
    gBS->SignalEvent (TokenToCancel->Event);
  }
 
  if (Arg != NULL) {
    return EFI_ABORTED;
  }
 
  return EFI_SUCCESS;
}
 
VOID
Udp4FlushRcvdDgram (
  IN UDP4_INSTANCE_DATA  *Instance
  )
{
  UDP4_RXDATA_WRAP  *Wrap;
 
  while (!IsListEmpty (&Instance->RcvdDgramQue)) {
    //
    // Iterate all the Wraps in the RcvdDgramQue.
    //
    Wrap = NET_LIST_HEAD (&Instance->RcvdDgramQue, UDP4_RXDATA_WRAP, Link);
 
    //
    // The Wrap will be removed from the RcvdDgramQue by this function call.
    //
    Udp4RecycleRxDataWrap (NULL, (VOID *)Wrap);
  }
}
 
EFI_STATUS
Udp4InstanceCancelToken (
  IN UDP4_INSTANCE_DATA         *Instance,
  IN EFI_UDP4_COMPLETION_TOKEN  *Token OPTIONAL
  )
{
  EFI_STATUS  Status;
 
  //
  // Cancel this token from the TxTokens map.
  //
  Status = NetMapIterate (&Instance->TxTokens, Udp4CancelTokens, Token);
 
  if ((Token != NULL) && (Status == EFI_ABORTED)) {
    //
    // If Token isn't NULL and Status is EFI_ABORTED, the token is cancelled from
    // the TxTokens, just return success.
    //
    return EFI_SUCCESS;
  }
 
  //
  // Try to cancel this token from the RxTokens map in condition either the Token
  // is NULL or the specified Token is not in TxTokens.
  //
  Status = NetMapIterate (&Instance->RxTokens, Udp4CancelTokens, Token);
 
  if ((Token != NULL) && (Status == EFI_SUCCESS)) {
    //
    // If Token isn't NULL and Status is EFI_SUCCESS, the token is neither in the
    // TxTokens nor the RxTokens, or say, it's not found.
    //
    return EFI_NOT_FOUND;
  }
 
  ASSERT (
    (Token != NULL) || (  (0 == NetMapGetCount (&Instance->TxTokens))
                       && (0 == NetMapGetCount (&Instance->RxTokens)))
    );
 
  return EFI_SUCCESS;
}
 
BOOLEAN
Udp4MatchDgram (
  IN UDP4_INSTANCE_DATA     *Instance,
  IN EFI_UDP4_SESSION_DATA  *Udp4Session
  )
{
  EFI_UDP4_CONFIG_DATA  *ConfigData;
  IP4_ADDR              Destination;
 
  ConfigData = &Instance->ConfigData;
 
  if (ConfigData->AcceptPromiscuous) {
    //
    // Always matches if this instance is in the promiscuous state.
    //
    return TRUE;
  }
 
  if ((!ConfigData->AcceptAnyPort && (Udp4Session->DestinationPort != ConfigData->StationPort)) ||
      ((ConfigData->RemotePort != 0) && (Udp4Session->SourcePort != ConfigData->RemotePort))
      )
  {
    //
    // The local port or the remote port doesn't match.
    //
    return FALSE;
  }
 
  if (!EFI_IP4_EQUAL (&ConfigData->RemoteAddress, &mZeroIp4Addr) &&
      !EFI_IP4_EQUAL (&ConfigData->RemoteAddress, &Udp4Session->SourceAddress)
      )
  {
    //
    // This datagram doesn't come from the instance's specified sender.
    //
    return FALSE;
  }
 
  if (EFI_IP4_EQUAL (&ConfigData->StationAddress, &mZeroIp4Addr) ||
      EFI_IP4_EQUAL (&Udp4Session->DestinationAddress, &ConfigData->StationAddress)
      )
  {
    //
    // The instance is configured to receive datagrams destined to any station IP or
    // the destination address of this datagram matches the configured station IP.
    //
    return TRUE;
  }
 
  CopyMem (&Destination, &Udp4Session->DestinationAddress, sizeof (IP4_ADDR));
 
  if (IP4_IS_LOCAL_BROADCAST (Destination) && ConfigData->AcceptBroadcast) {
    //
    // The instance is configured to receive broadcast and this is a broadcast packet.
    //
    return TRUE;
  }
 
  if (IP4_IS_MULTICAST (NTOHL (Destination)) &&
      (NetMapFindKey (&Instance->McastIps, (VOID *)(UINTN)Destination) != NULL)
      )
  {
    //
    // It's a multicast packet and the multicast address is accepted by this instance.
    //
    return TRUE;
  }
 
  return FALSE;
}
 
VOID
EFIAPI
Udp4RecycleRxDataWrap (
  IN EFI_EVENT  Event,
  IN VOID       *Context
  )
{
  UDP4_RXDATA_WRAP  *Wrap;
 
  Wrap = (UDP4_RXDATA_WRAP *)Context;
 
  //
  // Remove the Wrap from the list it belongs to.
  //
  RemoveEntryList (&Wrap->Link);
 
  //
  // Free the Packet associated with this Wrap.
  //
  NetbufFree (Wrap->Packet);
 
  //
  // Close the event.
  //
  gBS->CloseEvent (Wrap->RxData.RecycleSignal);
 
  FreePool (Wrap);
}
 
UDP4_RXDATA_WRAP *
Udp4WrapRxData (
  IN UDP4_INSTANCE_DATA     *Instance,
  IN NET_BUF                *Packet,
  IN EFI_UDP4_RECEIVE_DATA  *RxData
  )
{
  EFI_STATUS        Status;
  UDP4_RXDATA_WRAP  *Wrap;
 
  //
  // Allocate buffer for the Wrap.
  //
  Wrap = AllocatePool (
           sizeof (UDP4_RXDATA_WRAP) +
           (Packet->BlockOpNum - 1) * sizeof (EFI_UDP4_FRAGMENT_DATA)
           );
  if (Wrap == NULL) {
    return NULL;
  }
 
  InitializeListHead (&Wrap->Link);
 
  CopyMem (&Wrap->RxData, RxData, sizeof (Wrap->RxData));
 
  //
  // Create the Recycle event.
  //
  Status = gBS->CreateEvent (
                  EVT_NOTIFY_SIGNAL,
                  TPL_NOTIFY,
                  Udp4RecycleRxDataWrap,
                  Wrap,
                  &Wrap->RxData.RecycleSignal
                  );
  if (EFI_ERROR (Status)) {
    FreePool (Wrap);
    return NULL;
  }
 
  Wrap->Packet      = Packet;
  Wrap->TimeoutTick = Instance->ConfigData.ReceiveTimeout;
 
  return Wrap;
}
 
UINTN
Udp4EnqueueDgram (
  IN UDP4_SERVICE_DATA      *Udp4Service,
  IN NET_BUF                *Packet,
  IN EFI_UDP4_RECEIVE_DATA  *RxData
  )
{
  LIST_ENTRY          *Entry;
  UDP4_INSTANCE_DATA  *Instance;
  UDP4_RXDATA_WRAP    *Wrap;
  UINTN               Enqueued;
 
  Enqueued = 0;
 
  NET_LIST_FOR_EACH (Entry, &Udp4Service->ChildrenList) {
    //
    // Iterate the instances.
    //
    Instance = NET_LIST_USER_STRUCT (Entry, UDP4_INSTANCE_DATA, Link);
 
    if (!Instance->Configured) {
      continue;
    }
 
    if (Udp4MatchDgram (Instance, &RxData->UdpSession)) {
      //
      // Wrap the RxData and put this Wrap into the instances RcvdDgramQue.
      //
      Wrap = Udp4WrapRxData (Instance, Packet, RxData);
      if (Wrap == NULL) {
        continue;
      }
 
      NET_GET_REF (Packet);
 
      InsertTailList (&Instance->RcvdDgramQue, &Wrap->Link);
 
      Enqueued++;
    }
  }
 
  return Enqueued;
}
 
VOID
Udp4InstanceDeliverDgram (
  IN UDP4_INSTANCE_DATA  *Instance
  )
{
  UDP4_RXDATA_WRAP           *Wrap;
  EFI_UDP4_COMPLETION_TOKEN  *Token;
  NET_BUF                    *Dup;
  EFI_UDP4_RECEIVE_DATA      *RxData;
  EFI_TPL                    OldTpl;
 
  if (!IsListEmpty (&Instance->RcvdDgramQue) &&
      !NetMapIsEmpty (&Instance->RxTokens))
  {
    Wrap = NET_LIST_HEAD (&Instance->RcvdDgramQue, UDP4_RXDATA_WRAP, Link);
 
    if (NET_BUF_SHARED (Wrap->Packet)) {
      //
      // Duplicate the Packet if it is shared between instances.
      //
      Dup = NetbufDuplicate (Wrap->Packet, NULL, 0);
      if (Dup == NULL) {
        return;
      }
 
      NetbufFree (Wrap->Packet);
 
      Wrap->Packet = Dup;
    }
 
    NetListRemoveHead (&Instance->RcvdDgramQue);
 
    Token = (EFI_UDP4_COMPLETION_TOKEN *)NetMapRemoveHead (&Instance->RxTokens, NULL);
 
    //
    // Build the FragmentTable and set the FragmentCount in RxData.
    //
    RxData                = &Wrap->RxData;
    RxData->FragmentCount = Wrap->Packet->BlockOpNum;
 
    NetbufBuildExt (
      Wrap->Packet,
      (NET_FRAGMENT *)RxData->FragmentTable,
      &RxData->FragmentCount
      );
 
    Token->Status        = EFI_SUCCESS;
    Token->Packet.RxData = &Wrap->RxData;
 
    OldTpl = gBS->RaiseTPL (TPL_NOTIFY);
    InsertTailList (&Instance->DeliveredDgramQue, &Wrap->Link);
    gBS->RestoreTPL (OldTpl);
 
    gBS->SignalEvent (Token->Event);
  }
}
 
VOID
Udp4DeliverDgram (
  IN UDP4_SERVICE_DATA  *Udp4Service
  )
{
  LIST_ENTRY          *Entry;
  UDP4_INSTANCE_DATA  *Instance;
 
  NET_LIST_FOR_EACH (Entry, &Udp4Service->ChildrenList) {
    //
    // Iterate the instances.
    //
    Instance = NET_LIST_USER_STRUCT (Entry, UDP4_INSTANCE_DATA, Link);
 
    if (!Instance->Configured) {
      continue;
    }
 
    //
    // Deliver the datagrams of this instance.
    //
    Udp4InstanceDeliverDgram (Instance);
  }
}
 
VOID
Udp4Demultiplex (
  IN UDP4_SERVICE_DATA     *Udp4Service,
  IN EFI_NET_SESSION_DATA  *NetSession,
  IN NET_BUF               *Packet
  )
{
  EFI_UDP_HEADER         *Udp4Header;
  UINT16                 HeadSum;
  EFI_UDP4_RECEIVE_DATA  RxData;
  EFI_UDP4_SESSION_DATA  *Udp4Session;
  UINTN                  Enqueued;
 
  if (Packet->TotalSize < sizeof (EFI_UDP_HEADER)) {
    NetbufFree (Packet);
    return;
  }
 
  //
  // Get the datagram header from the packet buffer.
  //
  Udp4Header = (EFI_UDP_HEADER *)NetbufGetByte (Packet, 0, NULL);
  ASSERT (Udp4Header != NULL);
 
  if (Udp4Header->Checksum != 0) {
    //
    // check the checksum.
    //
    HeadSum = NetPseudoHeadChecksum (
                NetSession->Source.Addr[0],
                NetSession->Dest.Addr[0],
                EFI_IP_PROTO_UDP,
                0
                );
 
    if (Udp4Checksum (Packet, HeadSum) != 0) {
      //
      // Wrong checksum.
      //
      NetbufFree (Packet);
      return;
    }
  }
 
  Udp4Session                  = &RxData.UdpSession;
  Udp4Session->SourcePort      = NTOHS (Udp4Header->SrcPort);
  Udp4Session->DestinationPort = NTOHS (Udp4Header->DstPort);
 
  CopyMem (&Udp4Session->SourceAddress, &NetSession->Source, sizeof (EFI_IPv4_ADDRESS));
  CopyMem (&Udp4Session->DestinationAddress, &NetSession->Dest, sizeof (EFI_IPv4_ADDRESS));
 
  //
  // Trim the UDP header.
  //
  NetbufTrim (Packet, UDP4_HEADER_SIZE, TRUE);
 
  RxData.DataLength = (UINT32)Packet->TotalSize;
 
  //
  // Try to enqueue this datagram into the instances.
  //
  Enqueued = Udp4EnqueueDgram (Udp4Service, Packet, &RxData);
 
  if (Enqueued == 0) {
    //
    // Send the port unreachable ICMP packet before we free this NET_BUF
    //
    Udp4SendPortUnreach (Udp4Service->IpIo, NetSession, Udp4Header);
  }
 
  //
  // Try to free the packet before deliver it.
  //
  NetbufFree (Packet);
 
  if (Enqueued > 0) {
    //
    // Deliver the datagram.
    //
    Udp4DeliverDgram (Udp4Service);
  }
}
 
VOID
Udp4SendPortUnreach (
  IN IP_IO                 *IpIo,
  IN EFI_NET_SESSION_DATA  *NetSession,
  IN VOID                  *Udp4Header
  )
{
  NET_BUF              *Packet;
  UINT32               Len;
  IP4_ICMP_ERROR_HEAD  *IcmpErrHdr;
  EFI_IP4_HEADER       *IpHdr;
  UINT8                *Ptr;
  IP_IO_OVERRIDE       Override;
  IP_IO_IP_INFO        *IpSender;
 
  IpSender = IpIoFindSender (&IpIo, NetSession->IpVersion, &NetSession->Dest);
  if (IpSender == NULL) {
    //
    // No appropriate sender, since we cannot send out the ICMP message through
    // the default zero station address IP instance, abort.
    //
    return;
  }
 
  IpHdr = NetSession->IpHdr.Ip4Hdr;
 
  //
  // Calculate the required length of the icmp error message.
  //
  Len = sizeof (IP4_ICMP_ERROR_HEAD) + (EFI_IP4_HEADER_LEN (IpHdr) -
                                        sizeof (IP4_HEAD)) + ICMP_ERROR_PACKET_LENGTH;
 
  //
  // Allocate buffer for the icmp error message.
  //
  Packet = NetbufAlloc (Len);
  if (Packet == NULL) {
    return;
  }
 
  //
  // Allocate space for the IP4_ICMP_ERROR_HEAD.
  //
  IcmpErrHdr = (IP4_ICMP_ERROR_HEAD *)NetbufAllocSpace (Packet, Len, FALSE);
  ASSERT (IcmpErrHdr != NULL);
 
  //
  // Set the required fields for the icmp port unreachable message.
  //
  IcmpErrHdr->Head.Type     = ICMP_TYPE_UNREACH;
  IcmpErrHdr->Head.Code     = ICMP_CODE_UNREACH_PORT;
  IcmpErrHdr->Head.Checksum = 0;
  IcmpErrHdr->Fourth        = 0;
 
  //
  // Copy the IP header of the datagram tragged the error.
  //
  CopyMem (&IcmpErrHdr->IpHead, IpHdr, EFI_IP4_HEADER_LEN (IpHdr));
 
  //
  // Copy the UDP header.
  //
  Ptr = (UINT8 *)&IcmpErrHdr->IpHead + EFI_IP4_HEADER_LEN (IpHdr);
  CopyMem (Ptr, Udp4Header, ICMP_ERROR_PACKET_LENGTH);
 
  //
  // Calculate the checksum.
  //
  IcmpErrHdr->Head.Checksum = (UINT16) ~(NetbufChecksum (Packet));
 
  //
  // Fill the override data.
  //
  Override.Ip4OverrideData.DoNotFragment = FALSE;
  Override.Ip4OverrideData.TypeOfService = 0;
  Override.Ip4OverrideData.TimeToLive    = 255;
  Override.Ip4OverrideData.Protocol      = EFI_IP_PROTO_ICMP;
 
  CopyMem (&Override.Ip4OverrideData.SourceAddress, &NetSession->Dest, sizeof (EFI_IPv4_ADDRESS));
  ZeroMem (&Override.Ip4OverrideData.GatewayAddress, sizeof (EFI_IPv4_ADDRESS));
 
  //
  // Send out this icmp packet.
  //
  IpIoSend (IpIo, Packet, IpSender, NULL, NULL, &NetSession->Source, &Override);
 
  NetbufFree (Packet);
}
 
VOID
Udp4IcmpHandler (
  IN UDP4_SERVICE_DATA     *Udp4Service,
  IN UINT8                 IcmpError,
  IN EFI_NET_SESSION_DATA  *NetSession,
  IN NET_BUF               *Packet
  )
{
  EFI_UDP_HEADER         *Udp4Header;
  EFI_UDP4_SESSION_DATA  Udp4Session;
  LIST_ENTRY             *Entry;
  UDP4_INSTANCE_DATA     *Instance;
 
  if (Packet->TotalSize < sizeof (EFI_UDP_HEADER)) {
    NetbufFree (Packet);
    return;
  }
 
  Udp4Header = (EFI_UDP_HEADER *)NetbufGetByte (Packet, 0, NULL);
  ASSERT (Udp4Header != NULL);
 
  CopyMem (&Udp4Session.SourceAddress, &NetSession->Source, sizeof (EFI_IPv4_ADDRESS));
  CopyMem (&Udp4Session.DestinationAddress, &NetSession->Dest, sizeof (EFI_IPv4_ADDRESS));
 
  Udp4Session.SourcePort      = NTOHS (Udp4Header->DstPort);
  Udp4Session.DestinationPort = NTOHS (Udp4Header->SrcPort);
 
  NET_LIST_FOR_EACH (Entry, &Udp4Service->ChildrenList) {
    //
    // Iterate all the instances.
    //
    Instance = NET_LIST_USER_STRUCT (Entry, UDP4_INSTANCE_DATA, Link);
 
    if (!Instance->Configured) {
      continue;
    }
 
    if (Udp4MatchDgram (Instance, &Udp4Session)) {
      //
      // Translate the Icmp Error code according to the udp spec.
      //
      Instance->IcmpError = IpIoGetIcmpErrStatus (IcmpError, IP_VERSION_4, NULL, NULL);
 
      if (IcmpError > ICMP_ERR_UNREACH_PORT) {
        Instance->IcmpError = EFI_ICMP_ERROR;
      }
 
      //
      // Notify the instance with the received Icmp Error.
      //
      Udp4ReportIcmpError (Instance);
 
      break;
    }
  }
 
  NetbufFree (Packet);
}
 
VOID
Udp4ReportIcmpError (
  IN UDP4_INSTANCE_DATA  *Instance
  )
{
  EFI_UDP4_COMPLETION_TOKEN  *Token;
 
  if (NetMapIsEmpty (&Instance->RxTokens)) {
    //
    // There are no receive tokens to deliver the ICMP error.
    //
    return;
  }
 
  if (EFI_ERROR (Instance->IcmpError)) {
    //
    // Try to get a RxToken from the RxTokens map.
    //
    Token = (EFI_UDP4_COMPLETION_TOKEN *)NetMapRemoveHead (&Instance->RxTokens, NULL);
 
    if (Token != NULL) {
      //
      // Report the error through the Token.
      //
      Token->Status = Instance->IcmpError;
      gBS->SignalEvent (Token->Event);
 
      //
      // Clear the IcmpError.
      //
      Instance->IcmpError = EFI_SUCCESS;
    }
  }
}
 
VOID
EFIAPI
Udp4NetVectorExtFree (
  VOID  *Context
  )
{
}