ArpMain.c

Go to the documentation of this file.

 
#include "ArpImpl.h"
 
EFI_STATUS
EFIAPI
ArpConfigure (
  IN EFI_ARP_PROTOCOL     *This,
  IN EFI_ARP_CONFIG_DATA  *ConfigData OPTIONAL
  )
{
  EFI_STATUS         Status;
  ARP_INSTANCE_DATA  *Instance;
  EFI_TPL            OldTpl;
 
  if (This == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  if ((ConfigData != NULL) &&
      ((ConfigData->SwAddressLength == 0) ||
       (ConfigData->StationAddress == NULL) ||
       (ConfigData->SwAddressType <= 1500)))
  {
    return EFI_INVALID_PARAMETER;
  }
 
  Instance = ARP_INSTANCE_DATA_FROM_THIS (This);
 
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  //
  // Configure this instance, the ConfigData has already passed the basic checks.
  //
  Status = ArpConfigureInstance (Instance, ConfigData);
 
  gBS->RestoreTPL (OldTpl);
 
  return Status;
}
 
EFI_STATUS
EFIAPI
ArpAdd (
  IN EFI_ARP_PROTOCOL  *This,
  IN BOOLEAN           DenyFlag,
  IN VOID              *TargetSwAddress OPTIONAL,
  IN VOID              *TargetHwAddress OPTIONAL,
  IN UINT32            TimeoutValue,
  IN BOOLEAN           Overwrite
  )
{
  EFI_STATUS               Status;
  ARP_INSTANCE_DATA        *Instance;
  ARP_SERVICE_DATA         *ArpService;
  ARP_CACHE_ENTRY          *CacheEntry;
  EFI_SIMPLE_NETWORK_MODE  *SnpMode;
  NET_ARP_ADDRESS          MatchAddress[2];
  EFI_TPL                  OldTpl;
 
  if (This == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  if (((!DenyFlag) && ((TargetHwAddress == NULL) || (TargetSwAddress == NULL))) ||
      (DenyFlag && (TargetHwAddress != NULL) && (TargetSwAddress != NULL)) ||
      ((TargetHwAddress == NULL) && (TargetSwAddress == NULL)))
  {
    return EFI_INVALID_PARAMETER;
  }
 
  Instance = ARP_INSTANCE_DATA_FROM_THIS (This);
 
  if (!Instance->Configured) {
    return EFI_NOT_STARTED;
  }
 
  Status     = EFI_SUCCESS;
  ArpService = Instance->ArpService;
  SnpMode    = &Instance->ArpService->SnpMode;
 
  //
  // Fill the hardware address part in the MatchAddress.
  //
  MatchAddress[Hardware].Type       = SnpMode->IfType;
  MatchAddress[Hardware].Length     = (UINT8)SnpMode->HwAddressSize;
  MatchAddress[Hardware].AddressPtr = TargetHwAddress;
 
  //
  // Fill the software address part in the MatchAddress.
  //
  MatchAddress[Protocol].Type       = Instance->ConfigData.SwAddressType;
  MatchAddress[Protocol].Length     = Instance->ConfigData.SwAddressLength;
  MatchAddress[Protocol].AddressPtr = TargetSwAddress;
 
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  //
  // See whether the entry to add exists. Check the DeniedCacheTable first.
  //
  CacheEntry = ArpFindDeniedCacheEntry (
                 ArpService,
                 &MatchAddress[Protocol],
                 &MatchAddress[Hardware]
                 );
 
  if (CacheEntry == NULL) {
    //
    // Check the ResolvedCacheTable
    //
    CacheEntry = ArpFindNextCacheEntryInTable (
                   &ArpService->ResolvedCacheTable,
                   NULL,
                   ByBoth,
                   &MatchAddress[Protocol],
                   &MatchAddress[Hardware]
                   );
  }
 
  if ((CacheEntry != NULL) && !Overwrite) {
    //
    // The entry to add exists, if not Overwrite, deny this add request.
    //
    Status = EFI_ACCESS_DENIED;
    goto UNLOCK_EXIT;
  }
 
  if ((CacheEntry == NULL) && (TargetSwAddress != NULL)) {
    //
    // Check whether there are pending requests matching the entry to be added.
    //
    CacheEntry = ArpFindNextCacheEntryInTable (
                   &ArpService->PendingRequestTable,
                   NULL,
                   ByProtoAddress,
                   &MatchAddress[Protocol],
                   NULL
                   );
  }
 
  if (CacheEntry != NULL) {
    //
    // Remove it from the Table.
    //
    RemoveEntryList (&CacheEntry->List);
  } else {
    //
    // It's a new entry, allocate memory for the entry.
    //
    CacheEntry = ArpAllocCacheEntry (Instance);
 
    if (CacheEntry == NULL) {
      DEBUG ((DEBUG_ERROR, "ArpAdd: Failed to allocate pool for CacheEntry.\n"));
      Status = EFI_OUT_OF_RESOURCES;
      goto UNLOCK_EXIT;
    }
  }
 
  //
  // Overwrite these parameters.
  //
  CacheEntry->DefaultDecayTime = TimeoutValue;
  CacheEntry->DecayTime        = TimeoutValue;
 
  //
  // Fill in the addresses.
  //
  ArpFillAddressInCacheEntry (
    CacheEntry,
    &MatchAddress[Hardware],
    &MatchAddress[Protocol]
    );
 
  //
  // Inform the user if there is any.
  //
  ArpAddressResolved (CacheEntry, NULL, NULL);
 
  //
  // Add this CacheEntry to the corresponding CacheTable.
  //
  if (DenyFlag) {
    InsertHeadList (&ArpService->DeniedCacheTable, &CacheEntry->List);
  } else {
    InsertHeadList (&ArpService->ResolvedCacheTable, &CacheEntry->List);
  }
 
UNLOCK_EXIT:
 
  gBS->RestoreTPL (OldTpl);
 
  return Status;
}
 
EFI_STATUS
EFIAPI
ArpFind (
  IN EFI_ARP_PROTOCOL    *This,
  IN BOOLEAN             BySwAddress,
  IN VOID                *AddressBuffer OPTIONAL,
  OUT UINT32             *EntryLength   OPTIONAL,
  OUT UINT32             *EntryCount    OPTIONAL,
  OUT EFI_ARP_FIND_DATA  **Entries      OPTIONAL,
  IN BOOLEAN             Refresh
  )
{
  EFI_STATUS         Status;
  ARP_INSTANCE_DATA  *Instance;
  EFI_TPL            OldTpl;
 
  if ((This == NULL) ||
      (!Refresh && (EntryCount == NULL) && (EntryLength == NULL)) ||
      ((Entries != NULL) && ((EntryLength == NULL) || (EntryCount == NULL))))
  {
    return EFI_INVALID_PARAMETER;
  }
 
  Instance = ARP_INSTANCE_DATA_FROM_THIS (This);
 
  if (!Instance->Configured) {
    return EFI_NOT_STARTED;
  }
 
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  //
  // All the check passed, find the cache entries now.
  //
  Status = ArpFindCacheEntry (
             Instance,
             BySwAddress,
             AddressBuffer,
             EntryLength,
             EntryCount,
             Entries,
             Refresh
             );
 
  gBS->RestoreTPL (OldTpl);
 
  return Status;
}
 
EFI_STATUS
EFIAPI
ArpDelete (
  IN EFI_ARP_PROTOCOL  *This,
  IN BOOLEAN           BySwAddress,
  IN VOID              *AddressBuffer OPTIONAL
  )
{
  ARP_INSTANCE_DATA  *Instance;
  UINTN              Count;
  EFI_TPL            OldTpl;
 
  if (This == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  Instance = ARP_INSTANCE_DATA_FROM_THIS (This);
 
  if (!Instance->Configured) {
    return EFI_NOT_STARTED;
  }
 
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  //
  // Delete the specified cache entries.
  //
  Count = ArpDeleteCacheEntry (Instance, BySwAddress, AddressBuffer, TRUE);
 
  gBS->RestoreTPL (OldTpl);
 
  return (Count == 0) ? EFI_NOT_FOUND : EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
ArpFlush (
  IN EFI_ARP_PROTOCOL  *This
  )
{
  ARP_INSTANCE_DATA  *Instance;
  UINTN              Count;
  EFI_TPL            OldTpl;
 
  if (This == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  Instance = ARP_INSTANCE_DATA_FROM_THIS (This);
 
  if (!Instance->Configured) {
    return EFI_NOT_STARTED;
  }
 
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  //
  // Delete the dynamic entries from the cache table.
  //
  Count = ArpDeleteCacheEntry (Instance, FALSE, NULL, FALSE);
 
  gBS->RestoreTPL (OldTpl);
 
  return (Count == 0) ? EFI_NOT_FOUND : EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
ArpRequest (
  IN EFI_ARP_PROTOCOL  *This,
  IN VOID              *TargetSwAddress OPTIONAL,
  IN EFI_EVENT         ResolvedEvent    OPTIONAL,
  OUT VOID             *TargetHwAddress
  )
{
  EFI_STATUS               Status;
  ARP_INSTANCE_DATA        *Instance;
  ARP_SERVICE_DATA         *ArpService;
  EFI_SIMPLE_NETWORK_MODE  *SnpMode;
  ARP_CACHE_ENTRY          *CacheEntry;
  NET_ARP_ADDRESS          HardwareAddress;
  NET_ARP_ADDRESS          ProtocolAddress;
  USER_REQUEST_CONTEXT     *RequestContext;
  EFI_TPL                  OldTpl;
 
  if ((This == NULL) || (TargetHwAddress == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  Instance = ARP_INSTANCE_DATA_FROM_THIS (This);
 
  if (!Instance->Configured) {
    return EFI_NOT_STARTED;
  }
 
  Status     = EFI_SUCCESS;
  ArpService = Instance->ArpService;
  SnpMode    = &ArpService->SnpMode;
 
  if ((TargetSwAddress == NULL) ||
      ((Instance->ConfigData.SwAddressType == IPV4_ETHER_PROTO_TYPE) &&
       IP4_IS_LOCAL_BROADCAST (*((UINT32 *)TargetSwAddress))))
  {
    //
    // Return the hardware broadcast address.
    //
    CopyMem (TargetHwAddress, &SnpMode->BroadcastAddress, SnpMode->HwAddressSize);
 
    goto SIGNAL_USER;
  }
 
  if ((Instance->ConfigData.SwAddressType == IPV4_ETHER_PROTO_TYPE) &&
      IP4_IS_MULTICAST (NTOHL (*((UINT32 *)TargetSwAddress))))
  {
    //
    // If the software address is an IPv4 multicast address, invoke Mnp to
    // resolve the address.
    //
    Status = ArpService->Mnp->McastIpToMac (
                                ArpService->Mnp,
                                FALSE,
                                TargetSwAddress,
                                TargetHwAddress
                                );
    goto SIGNAL_USER;
  }
 
  HardwareAddress.Type       = SnpMode->IfType;
  HardwareAddress.Length     = (UINT8)SnpMode->HwAddressSize;
  HardwareAddress.AddressPtr = NULL;
 
  ProtocolAddress.Type       = Instance->ConfigData.SwAddressType;
  ProtocolAddress.Length     = Instance->ConfigData.SwAddressLength;
  ProtocolAddress.AddressPtr = TargetSwAddress;
 
  //
  // Initialize the TargetHwAddress to a zero address.
  //
  ZeroMem (TargetHwAddress, SnpMode->HwAddressSize);
 
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  //
  // Check whether the software address is in the denied table.
  //
  CacheEntry = ArpFindDeniedCacheEntry (ArpService, &ProtocolAddress, NULL);
  if (CacheEntry != NULL) {
    Status = EFI_ACCESS_DENIED;
    goto UNLOCK_EXIT;
  }
 
  //
  // Check whether the software address is already resolved.
  //
  CacheEntry = ArpFindNextCacheEntryInTable (
                 &ArpService->ResolvedCacheTable,
                 NULL,
                 ByProtoAddress,
                 &ProtocolAddress,
                 NULL
                 );
  if (CacheEntry != NULL) {
    //
    // Resolved, copy the address into the user buffer.
    //
    CopyMem (
      TargetHwAddress,
      CacheEntry->Addresses[Hardware].AddressPtr,
      CacheEntry->Addresses[Hardware].Length
      );
 
    goto UNLOCK_EXIT;
  }
 
  if (ResolvedEvent == NULL) {
    Status = EFI_NOT_READY;
    goto UNLOCK_EXIT;
  }
 
  //
  // Create a request context for this arp request.
  //
  RequestContext = AllocatePool (sizeof (USER_REQUEST_CONTEXT));
  if (RequestContext == NULL) {
    DEBUG ((DEBUG_ERROR, "ArpRequest: Allocate memory for RequestContext failed.\n"));
 
    Status = EFI_OUT_OF_RESOURCES;
    goto UNLOCK_EXIT;
  }
 
  RequestContext->Instance         = Instance;
  RequestContext->UserRequestEvent = ResolvedEvent;
  RequestContext->UserHwAddrBuffer = TargetHwAddress;
  InitializeListHead (&RequestContext->List);
 
  //
  // Check whether there is a same request.
  //
  CacheEntry = ArpFindNextCacheEntryInTable (
                 &ArpService->PendingRequestTable,
                 NULL,
                 ByProtoAddress,
                 &ProtocolAddress,
                 NULL
                 );
  if (CacheEntry != NULL) {
    CacheEntry->NextRetryTime = Instance->ConfigData.RetryTimeOut;
    CacheEntry->RetryCount    = Instance->ConfigData.RetryCount;
  } else {
    //
    // Allocate a cache entry for this request.
    //
    CacheEntry = ArpAllocCacheEntry (Instance);
    if (CacheEntry == NULL) {
      DEBUG ((DEBUG_ERROR, "ArpRequest: Allocate memory for CacheEntry failed.\n"));
      FreePool (RequestContext);
 
      Status = EFI_OUT_OF_RESOURCES;
      goto UNLOCK_EXIT;
    }
 
    //
    // Fill the software address.
    //
    ArpFillAddressInCacheEntry (CacheEntry, &HardwareAddress, &ProtocolAddress);
 
    //
    // Add this entry into the PendingRequestTable.
    //
    InsertTailList (&ArpService->PendingRequestTable, &CacheEntry->List);
  }
 
  //
  // Link this request context into the cache entry.
  //
  InsertHeadList (&CacheEntry->UserRequestList, &RequestContext->List);
 
  //
  // Send out the ARP Request frame.
  //
  ArpSendFrame (Instance, CacheEntry, ARP_OPCODE_REQUEST);
  Status = EFI_NOT_READY;
 
UNLOCK_EXIT:
 
  gBS->RestoreTPL (OldTpl);
 
SIGNAL_USER:
 
  if ((ResolvedEvent != NULL) && (Status == EFI_SUCCESS)) {
    gBS->SignalEvent (ResolvedEvent);
 
    //
    // Dispatch the DPC queued by the NotifyFunction of ResolvedEvent.
    //
    DispatchDpc ();
  }
 
  return Status;
}
 
EFI_STATUS
EFIAPI
ArpCancel (
  IN EFI_ARP_PROTOCOL  *This,
  IN VOID              *TargetSwAddress OPTIONAL,
  IN EFI_EVENT         ResolvedEvent    OPTIONAL
  )
{
  ARP_INSTANCE_DATA  *Instance;
  UINTN              Count;
  EFI_TPL            OldTpl;
 
  if ((This == NULL) ||
      ((TargetSwAddress != NULL) && (ResolvedEvent == NULL)) ||
      ((TargetSwAddress == NULL) && (ResolvedEvent != NULL)))
  {
    return EFI_INVALID_PARAMETER;
  }
 
  Instance = ARP_INSTANCE_DATA_FROM_THIS (This);
 
  if (!Instance->Configured) {
    return EFI_NOT_STARTED;
  }
 
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  //
  // Cancel the specified request.
  //
  Count = ArpCancelRequest (Instance, TargetSwAddress, ResolvedEvent);
 
  //
  // Dispatch the DPCs queued by the NotifyFunction of the events signaled
  // by ArpCancelRequest.
  //
  DispatchDpc ();
 
  gBS->RestoreTPL (OldTpl);
 
  return (Count == 0) ? EFI_NOT_FOUND : EFI_SUCCESS;
}