Ip6Common.c

Go to the documentation of this file.

 
#include "Ip6Impl.h"
 
EFI_STATUS
Ip6BuildEfiAddressList (
  IN IP6_SERVICE            *IpSb,
  OUT UINT32                *AddressCount,
  OUT EFI_IP6_ADDRESS_INFO  **AddressList OPTIONAL
  )
{
  UINT32                Count;
  LIST_ENTRY            *Entry;
  EFI_IP6_ADDRESS_INFO  *EfiAddrInfo;
  IP6_ADDRESS_INFO      *AddrInfo;
 
  if (AddressCount == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  if (IpSb->LinkLocalOk) {
    Count = 1 + IpSb->DefaultInterface->AddressCount;
  } else {
    Count = 0;
  }
 
  *AddressCount = Count;
 
  if ((AddressList == NULL) || (Count == 0)) {
    return EFI_SUCCESS;
  }
 
  if (*AddressList == NULL) {
    *AddressList = AllocatePool (sizeof (EFI_IP6_ADDRESS_INFO) * Count);
    if (*AddressList == NULL) {
      return EFI_OUT_OF_RESOURCES;
    }
  }
 
  EfiAddrInfo = *AddressList;
 
  IP6_COPY_ADDRESS (&EfiAddrInfo->Address, &IpSb->LinkLocalAddr);
  EfiAddrInfo->PrefixLength = IP6_LINK_LOCAL_PREFIX_LENGTH;
 
  EfiAddrInfo++;
  Count = 1;
 
  NET_LIST_FOR_EACH (Entry, &IpSb->DefaultInterface->AddressList) {
    AddrInfo = NET_LIST_USER_STRUCT_S (Entry, IP6_ADDRESS_INFO, Link, IP6_ADDR_INFO_SIGNATURE);
 
    IP6_COPY_ADDRESS (&EfiAddrInfo->Address, &AddrInfo->Address);
    EfiAddrInfo->PrefixLength = AddrInfo->PrefixLength;
 
    EfiAddrInfo++;
    Count++;
  }
 
  ASSERT (Count == *AddressCount);
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
Ip6SetToAllNodeMulticast (
  IN  BOOLEAN           Router,
  IN  UINT8             Scope,
  OUT EFI_IPv6_ADDRESS  *Ip6Addr
  )
{
  if (Ip6Addr == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  if (!Router && (Scope == IP6_SITE_LOCAL_SCOPE)) {
    return EFI_INVALID_PARAMETER;
  }
 
  ZeroMem (Ip6Addr, sizeof (EFI_IPv6_ADDRESS));
  Ip6Addr->Addr[0] = 0xFF;
  Ip6Addr->Addr[1] = Scope;
 
  if (!Router) {
    Ip6Addr->Addr[15] = 0x1;
  } else {
    Ip6Addr->Addr[15] = 0x2;
  }
 
  return EFI_SUCCESS;
}
 
UINT8 *
Ip6CreateInterfaceID (
  IN OUT IP6_SERVICE  *IpSb
  )
{
  UINT8            InterfaceId[8];
  UINT8            Byte;
  EFI_MAC_ADDRESS  *MacAddr;
  UINT32           AddrLen;
 
  NET_CHECK_SIGNATURE (IpSb, IP6_SERVICE_SIGNATURE);
 
  AddrLen = IpSb->SnpMode.HwAddressSize;
 
  //
  // Currently only IEEE 802 48-bit MACs are supported to create link local address.
  //
  if ((AddrLen != IP6_MAC_LEN) || (IpSb->InterfaceIdLen != IP6_IF_ID_LEN)) {
    return NULL;
  }
 
  MacAddr = &IpSb->SnpMode.CurrentAddress;
 
  //
  // Convert MAC address to 64 bits interface ID according to Appendix A of RFC4291:
  // 1. Insert 0xFFFE to the middle
  // 2. Invert the universal/local bit - bit 6 in network order
  //
  CopyMem (InterfaceId, MacAddr, 3);
  InterfaceId[3] = 0xFF;
  InterfaceId[4] = 0xFE;
  CopyMem (&InterfaceId[5], &MacAddr->Addr[3], 3);
 
  Byte = (UINT8)(InterfaceId[0] & IP6_U_BIT);
  if (Byte == IP6_U_BIT) {
    InterfaceId[0] &= ~IP6_U_BIT;
  } else {
    InterfaceId[0] |= IP6_U_BIT;
  }
 
  //
  // Return the interface ID.
  //
  return AllocateCopyPool (IpSb->InterfaceIdLen, InterfaceId);
}
 
EFI_IPv6_ADDRESS *
Ip6CreateLinkLocalAddr (
  IN OUT IP6_SERVICE  *IpSb
  )
{
  EFI_IPv6_ADDRESS             *Ip6Addr;
  EFI_IP6_CONFIG_PROTOCOL      *Ip6Config;
  UINTN                        DataSize;
  EFI_IP6_CONFIG_INTERFACE_ID  InterfaceId;
  EFI_STATUS                   Status;
 
  NET_CHECK_SIGNATURE (IpSb, IP6_SERVICE_SIGNATURE);
 
  if (IpSb->InterfaceId != NULL) {
    FreePool (IpSb->InterfaceId);
  }
 
  //
  // Get the interface id if it is manually configured.
  //
  Ip6Config = &IpSb->Ip6ConfigInstance.Ip6Config;
  DataSize  = sizeof (EFI_IP6_CONFIG_INTERFACE_ID);
  ZeroMem (&InterfaceId, DataSize);
 
  Status = Ip6Config->GetData (
                        Ip6Config,
                        Ip6ConfigDataTypeAltInterfaceId,
                        &DataSize,
                        &InterfaceId
                        );
  if (Status == EFI_NOT_FOUND) {
    //
    // Since the interface id is not configured, generate the interface id from
    // MAC address.
    //
    IpSb->InterfaceId = Ip6CreateInterfaceID (IpSb);
    if (IpSb->InterfaceId == NULL) {
      return NULL;
    }
 
    CopyMem (&InterfaceId, IpSb->InterfaceId, IpSb->InterfaceIdLen);
    //
    // Record the interface id.
    //
    Status = Ip6Config->SetData (
                          Ip6Config,
                          Ip6ConfigDataTypeAltInterfaceId,
                          DataSize,
                          &InterfaceId
                          );
    if (EFI_ERROR (Status)) {
      FreePool (IpSb->InterfaceId);
      IpSb->InterfaceId = NULL;
      return NULL;
    }
  } else if (!EFI_ERROR (Status)) {
    IpSb->InterfaceId = AllocateCopyPool (DataSize, &InterfaceId);
    if (IpSb->InterfaceId == NULL) {
      return NULL;
    }
  } else {
    return NULL;
  }
 
  //
  // Append FE80::/64 to the left of IPv6 address then return.
  //
  Ip6Addr = AllocateZeroPool (sizeof (EFI_IPv6_ADDRESS));
  if (Ip6Addr == NULL) {
    FreePool (IpSb->InterfaceId);
    IpSb->InterfaceId = NULL;
    return NULL;
  }
 
  CopyMem (&Ip6Addr->Addr[8], IpSb->InterfaceId, IpSb->InterfaceIdLen);
  Ip6Addr->Addr[1] = 0x80;
  Ip6Addr->Addr[0] = 0xFE;
 
  return Ip6Addr;
}
 
VOID
Ip6CreateSNMulticastAddr (
  IN EFI_IPv6_ADDRESS   *Ip6Addr,
  OUT EFI_IPv6_ADDRESS  *MulticastAddr
  )
{
  ASSERT (Ip6Addr != NULL && MulticastAddr != NULL);
 
  ZeroMem (MulticastAddr, sizeof (EFI_IPv6_ADDRESS));
 
  MulticastAddr->Addr[0]  = 0xFF;
  MulticastAddr->Addr[1]  = 0x02;
  MulticastAddr->Addr[11] = 0x1;
  MulticastAddr->Addr[12] = 0xFF;
 
  CopyMem (&MulticastAddr->Addr[13], &Ip6Addr->Addr[13], 3);
}
 
VOID
Ip6AddAddr (
  IN OUT IP6_INTERFACE  *IpIf,
  IN IP6_ADDRESS_INFO   *AddrInfo
  )
{
  InsertHeadList (&IpIf->AddressList, &AddrInfo->Link);
  IpIf->AddressCount++;
}
 
EFI_STATUS
EFIAPI
Ip6DestroyChildEntryByAddr (
  IN LIST_ENTRY  *Entry,
  IN VOID        *Context
  )
{
  IP6_PROTOCOL                  *Instance;
  EFI_SERVICE_BINDING_PROTOCOL  *ServiceBinding;
  EFI_IPv6_ADDRESS              *Address;
 
  Instance       = NET_LIST_USER_STRUCT_S (Entry, IP6_PROTOCOL, Link, IP6_PROTOCOL_SIGNATURE);
  ServiceBinding = ((IP6_DESTROY_CHILD_BY_ADDR_CALLBACK_CONTEXT *)Context)->ServiceBinding;
  Address        = ((IP6_DESTROY_CHILD_BY_ADDR_CALLBACK_CONTEXT *)Context)->Address;
 
  if ((Instance->State == IP6_STATE_CONFIGED) && EFI_IP6_EQUAL (&Instance->ConfigData.StationAddress, Address)) {
    return ServiceBinding->DestroyChild (ServiceBinding, Instance->Handle);
  }
 
  return EFI_SUCCESS;
}
 
VOID
Ip6DestroyInstanceByAddress (
  IN OUT IP6_SERVICE   *IpSb,
  IN EFI_IPv6_ADDRESS  *Address
  )
{
  LIST_ENTRY                                  *List;
  IP6_DESTROY_CHILD_BY_ADDR_CALLBACK_CONTEXT  Context;
 
  NET_CHECK_SIGNATURE (IpSb, IP6_SERVICE_SIGNATURE);
 
  List                   = &IpSb->Children;
  Context.ServiceBinding = &IpSb->ServiceBinding;
  Context.Address        = Address;
  NetDestroyLinkList (
    List,
    Ip6DestroyChildEntryByAddr,
    &Context,
    NULL
    );
}
 
EFI_STATUS
Ip6RemoveAddr (
  IN IP6_SERVICE       *IpSb          OPTIONAL,
  IN OUT LIST_ENTRY    *AddressList,
  IN OUT UINT32        *AddressCount,
  IN EFI_IPv6_ADDRESS  *Prefix        OPTIONAL,
  IN UINT8             PrefixLength
  )
{
  EFI_STATUS        Status;
  LIST_ENTRY        *Entry;
  LIST_ENTRY        *Next;
  IP6_ADDRESS_INFO  *AddrInfo;
  EFI_IPv6_ADDRESS  SnMCastAddr;
 
  if (IsListEmpty (AddressList) || (*AddressCount < 1) || (PrefixLength > IP6_PREFIX_MAX)) {
    return EFI_INVALID_PARAMETER;
  }
 
  Status = EFI_NOT_FOUND;
 
  NET_LIST_FOR_EACH_SAFE (Entry, Next, AddressList) {
    AddrInfo = NET_LIST_USER_STRUCT_S (Entry, IP6_ADDRESS_INFO, Link, IP6_ADDR_INFO_SIGNATURE);
 
    if ((Prefix == NULL) ||
        ((PrefixLength == 128) && EFI_IP6_EQUAL (Prefix, &AddrInfo->Address)) ||
        ((PrefixLength == AddrInfo->PrefixLength) && NetIp6IsNetEqual (Prefix, &AddrInfo->Address, PrefixLength))
        )
    {
      if (IpSb != NULL) {
        NET_CHECK_SIGNATURE (IpSb, IP6_SERVICE_SIGNATURE);
        Ip6CreateSNMulticastAddr (&AddrInfo->Address, &SnMCastAddr);
        Ip6LeaveGroup (IpSb, &SnMCastAddr);
 
        //
        // Destroy any instance who is using the dying address as the source address.
        //
        Ip6DestroyInstanceByAddress (IpSb, &AddrInfo->Address);
      }
 
      RemoveEntryList (Entry);
      FreePool (AddrInfo);
      (*AddressCount)--;
 
      Status = EFI_SUCCESS;
    }
  }
 
  return Status;
}
 
BOOLEAN
Ip6IsSNMulticastAddr (
  IN EFI_IPv6_ADDRESS  *Ip6
  )
{
  EFI_IPv6_ADDRESS  Sn;
  BOOLEAN           Flag;
 
  Ip6CreateSNMulticastAddr (Ip6, &Sn);
  Flag = FALSE;
 
  if (CompareMem (Sn.Addr, Ip6->Addr, 13) == 0) {
    Flag = TRUE;
  }
 
  return Flag;
}
 
BOOLEAN
Ip6IsOneOfSetAddress (
  IN  IP6_SERVICE       *IpSb,
  IN  EFI_IPv6_ADDRESS  *Address,
  OUT IP6_INTERFACE     **Interface   OPTIONAL,
  OUT IP6_ADDRESS_INFO  **AddressInfo OPTIONAL
  )
{
  LIST_ENTRY        *Entry;
  LIST_ENTRY        *Entry2;
  IP6_INTERFACE     *IpIf;
  IP6_ADDRESS_INFO  *TmpAddressInfo;
 
  //
  // Check link-local address first
  //
  if (IpSb->LinkLocalOk && EFI_IP6_EQUAL (&IpSb->LinkLocalAddr, Address)) {
    if (Interface != NULL) {
      *Interface = IpSb->DefaultInterface;
    }
 
    if (AddressInfo != NULL) {
      *AddressInfo = NULL;
    }
 
    return TRUE;
  }
 
  NET_LIST_FOR_EACH (Entry, &IpSb->Interfaces) {
    IpIf = NET_LIST_USER_STRUCT_S (Entry, IP6_INTERFACE, Link, IP6_INTERFACE_SIGNATURE);
 
    NET_LIST_FOR_EACH (Entry2, &IpIf->AddressList) {
      TmpAddressInfo = NET_LIST_USER_STRUCT_S (Entry2, IP6_ADDRESS_INFO, Link, IP6_ADDR_INFO_SIGNATURE);
 
      if (EFI_IP6_EQUAL (&TmpAddressInfo->Address, Address)) {
        if (Interface != NULL) {
          *Interface = IpIf;
        }
 
        if (AddressInfo != NULL) {
          *AddressInfo = TmpAddressInfo;
        }
 
        return TRUE;
      }
    }
  }
 
  return FALSE;
}
 
BOOLEAN
Ip6IsValidLinkAddress (
  IN  IP6_SERVICE      *IpSb,
  IN  EFI_MAC_ADDRESS  *LinkAddress
  )
{
  UINT32  Index;
 
  //
  // TODO: might be updated later to be more acceptable.
  //
  for (Index = IpSb->SnpMode.HwAddressSize; Index < sizeof (EFI_MAC_ADDRESS); Index++) {
    if (LinkAddress->Addr[Index] != 0) {
      return FALSE;
    }
  }
 
  return TRUE;
}
 
VOID
Ip6CopyAddressByPrefix (
  OUT EFI_IPv6_ADDRESS  *Dest,
  IN  EFI_IPv6_ADDRESS  *Src,
  IN  UINT8             PrefixLength
  )
{
  UINT8  Byte;
  UINT8  Bit;
  UINT8  Mask;
 
  ASSERT (Dest != NULL && Src != NULL);
  ASSERT (PrefixLength <= IP6_PREFIX_MAX);
 
  Byte = (UINT8)(PrefixLength / 8);
  Bit  = (UINT8)(PrefixLength % 8);
 
  ZeroMem (Dest, sizeof (EFI_IPv6_ADDRESS));
 
  CopyMem (Dest, Src, Byte);
 
  if (Bit > 0) {
    Mask = (UINT8)(0xFF << (8 - Bit));
    ASSERT (Byte < 16);
    Dest->Addr[Byte] = (UINT8)(Src->Addr[Byte] & Mask);
  }
}
 
EFI_STATUS
Ip6GetMulticastMac (
  IN  EFI_MANAGED_NETWORK_PROTOCOL  *Mnp,
  IN  EFI_IPv6_ADDRESS              *Multicast,
  OUT EFI_MAC_ADDRESS               *Mac
  )
{
  EFI_IP_ADDRESS  EfiIp;
 
  IP6_COPY_ADDRESS (&EfiIp.v6, Multicast);
 
  return Mnp->McastIpToMac (Mnp, TRUE, &EfiIp, Mac);
}
 
EFI_IP6_HEADER *
Ip6NtohHead (
  IN OUT EFI_IP6_HEADER  *Head
  )
{
  Head->FlowLabelL    = NTOHS (Head->FlowLabelL);
  Head->PayloadLength = NTOHS (Head->PayloadLength);
 
  return Head;
}