Supports IPv6 multicast routing. * *
Note that usage of this class is not thread-safe. All public methods must be called from the
* same thread that the handler from {@code dependencies.getHandler} is associated.
*/
public class MulticastRoutingCoordinatorService {
private static final String TAG = MulticastRoutingCoordinatorService.class.getSimpleName();
private static final int ICMP6_FILTER = 1;
private static final int MRT6_INIT = 200;
private static final int MRT6_ADD_MIF = 202;
private static final int MRT6_DEL_MIF = 203;
private static final int MRT6_ADD_MFC = 204;
private static final int MRT6_DEL_MFC = 205;
private static final int ONE = 1;
private final Dependencies mDependencies;
private final Handler mHandler;
private final MulticastNocacheUpcallListener mMulticastNoCacheUpcallListener;
@NonNull private final FileDescriptor mMulticastRoutingFd; // For multicast routing config
@NonNull private final MulticastSocket mMulticastSocket; // For join group and leave group
@VisibleForTesting public static final int MFC_INACTIVE_CHECK_INTERVAL_MS = 60_000;
@VisibleForTesting public static final int MFC_INACTIVE_TIMEOUT_MS = 300_000;
@VisibleForTesting public static final int MFC_MAX_NUMBER_OF_ENTRIES = 1_000;
// The kernel supports max 32 virtual interfaces per multicast routing table.
private static final int MAX_NUM_OF_MULTICAST_VIRTUAL_INTERFACES = 32;
/** Tracks if checking for inactive MFC has been scheduled */
private boolean mMfcPollingScheduled = false;
/** Mapping from multicast virtual interface index to interface name */
private SparseArray Remove the network interface from multicast configs and remove it from the list of
* multicast routing interfaces in the kernel
*
* @param ifName name of the interface that should be removed
*/
@VisibleForTesting
public void removeInterfaceFromMulticastRouting(final String ifName) {
checkOnHandlerThread();
final Integer virtualIndex = getVirtualInterfaceIndex(ifName);
if (virtualIndex == null) return;
updateMfcs();
mInterfaces.removeAt(getIndexForValue(mInterfaces, ifName));
mVirtualInterfaces.remove(virtualIndex);
try {
mDependencies.setsockoptMrt6DelMif(mMulticastRoutingFd, virtualIndex);
Log.d(TAG, "Removed mifi " + virtualIndex + " from MIF");
} catch (ErrnoException e) {
Log.e(TAG, "failed to remove multicast virtual interface" + virtualIndex, e);
}
}
/**
* Returns the next available virtual index for multicast routing, or -1 if the number of
* virtual interfaces has reached max value.
*/
private int getNextAvailableVirtualIndex() {
if (mVirtualInterfaces.size() >= MAX_NUM_OF_MULTICAST_VIRTUAL_INTERFACES) {
Log.e(TAG, "Can't allocate new multicast virtual interface");
return -1;
}
for (int i = 0; i < mVirtualInterfaces.size(); i++) {
if (!mVirtualInterfaces.contains(i)) {
return i;
}
}
return mVirtualInterfaces.size();
}
@VisibleForTesting
public Integer getVirtualInterfaceIndex(String ifName) {
int mapIndex = getIndexForValue(mVirtualInterfaces, ifName);
if (mapIndex < 0) return null;
return mVirtualInterfaces.keyAt(mapIndex);
}
private Integer getVirtualInterfaceIndex(int physicalIndex) {
String ifName = mInterfaces.get(physicalIndex);
if (ifName == null) {
// This is only used to match MFCs from kernel to MFCs we know about.
// Unknown MFCs should be ignored.
return null;
}
return getVirtualInterfaceIndex(ifName);
}
private String getInterfaceName(int virtualIndex) {
return mVirtualInterfaces.get(virtualIndex);
}
/**
* Returns {@code true} if the interfaces is added and tracked, or {@code false} when failed
* to add the interface.
*/
private boolean maybeAddAndTrackInterface(String ifName) {
checkOnHandlerThread();
if (getIndexForValue(mVirtualInterfaces, ifName) >= 0) return true;
int nextVirtualIndex = getNextAvailableVirtualIndex();
if (nextVirtualIndex < 0) {
return false;
}
int ifIndex = mDependencies.getInterfaceIndex(ifName);
if (ifIndex == 0) {
Log.e(TAG, "Can't get interface index for " + ifName);
return false;
}
final StructMif6ctl mif6ctl =
new StructMif6ctl(
nextVirtualIndex,
(short) 0 /* mif6c_flags */,
(short) 1 /* vifc_threshold */,
ifIndex,
0 /* vifc_rate_limit */);
try {
mDependencies.setsockoptMrt6AddMif(mMulticastRoutingFd, mif6ctl);
Log.d(TAG, "Added mifi " + nextVirtualIndex + " to MIF");
} catch (ErrnoException e) {
Log.e(TAG, "failed to add multicast virtual interface", e);
return false;
}
mVirtualInterfaces.put(nextVirtualIndex, ifName);
mInterfaces.put(ifIndex, ifName);
return true;
}
@VisibleForTesting
public MulticastRoutingConfig getMulticastRoutingConfig(String iifName, String oifName) {
PerInterfaceMulticastRoutingConfig configs = mMulticastRoutingConfigs.get(iifName);
final MulticastRoutingConfig defaultConfig = MulticastRoutingConfig.CONFIG_FORWARD_NONE;
if (configs == null) {
return defaultConfig;
} else {
return configs.oifConfigs.getOrDefault(oifName, defaultConfig);
}
}
private void setMulticastRoutingConfig(
final String iifName, final String oifName, final MulticastRoutingConfig config) {
checkOnHandlerThread();
PerInterfaceMulticastRoutingConfig iifConfig = mMulticastRoutingConfigs.get(iifName);
if (config.getForwardingMode() == FORWARD_NONE) {
if (iifConfig != null) {
iifConfig.oifConfigs.remove(oifName);
}
if (iifConfig.oifConfigs.isEmpty()) {
mMulticastRoutingConfigs.remove(iifName);
}
return;
}
if (iifConfig == null) {
iifConfig = new PerInterfaceMulticastRoutingConfig();
mMulticastRoutingConfigs.put(iifName, iifConfig);
}
iifConfig.oifConfigs.put(oifName, config);
}
/** Returns whether an interface has multicast routing config */
private boolean hasActiveMulticastConfig(final String ifName) {
// FORWARD_NONE configs are not saved in the config tables, so
// any existing config is an active multicast routing config
if (mMulticastRoutingConfigs.containsKey(ifName)) return true;
for (var pic : mMulticastRoutingConfigs.values()) {
if (pic.oifConfigs.containsKey(ifName)) return true;
}
return false;
}
/**
* A multicast forwarding cache (MFC) entry holds a multicast forwarding route where packet from
* incoming interface(iif) with source address(S) to group address (G) are forwarded to outgoing
* interfaces(oifs).
*
* iif, S and G identifies an MFC entry. For example an MFC1 is added: [iif1, S1, G1, oifs1]
* Adding another MFC2 of [iif1, S1, G1, oifs2] to the kernel overwrites MFC1.
*/
private static final class MfcKey {
public final int mIifVirtualIdx;
public final Inet6Address mSrcAddr;
public final Inet6Address mDstAddr;
public MfcKey(int iif, Inet6Address src, Inet6Address dst) {
mIifVirtualIdx = iif;
mSrcAddr = src;
mDstAddr = dst;
}
public boolean equals(Object other) {
if (other == this) {
return true;
} else if (!(other instanceof MfcKey)) {
return false;
} else {
MfcKey otherKey = (MfcKey) other;
return mIifVirtualIdx == otherKey.mIifVirtualIdx
&& mSrcAddr.equals(otherKey.mSrcAddr)
&& mDstAddr.equals(otherKey.mDstAddr);
}
}
public int hashCode() {
return Objects.hash(mIifVirtualIdx, mSrcAddr, mDstAddr);
}
public String toString() {
return "{iifVirtualIndex: "
+ Integer.toString(mIifVirtualIdx)
+ ", sourceAddress: "
+ mSrcAddr.toString()
+ ", destinationAddress: "
+ mDstAddr.toString()
+ "}";
}
}
private static final class MfcValue {
private Set Note that if a packet has no matching MFC entry in the kernel, kernel creates an
* unresolved route and notifies multicast socket with a NOCACHE upcall message. The unresolved
* route is kept for no less than 10s. If packets with the same source and destination arrives
* before the 10s timeout, they will not be notified. Thus we need to add a 'blocking' MFC which
* is an MFC with an empty oif list. When the multicast configs changes, the 'blocking' MFC
* will be updated to a 'forwarding' MFC so that corresponding multicast traffic can be
* forwarded instantly.
*
* @return {@code true} if the MFC is updated and no operation is needed from caller.
* {@code false} if the MFC should not be added, caller of the function should remove
* the MFC if needed.
*/
private boolean addOrUpdateMfc(int vif, Inet6Address src, Inet6Address dst) {
checkOnHandlerThread();
final MfcKey key = new MfcKey(vif, src, dst);
final MfcValue value = mMfcs.get(key);
final MfcValue updatedValue = computeMfcValue(vif, dst);
if (updatedValue == null) {
return false;
}
if (value != null && value.hasSameOifsAs(updatedValue)) {
// no updates to make
return true;
}
final StructMf6cctl mf6cctl =
new StructMf6cctl(src, dst, vif, updatedValue.getOifIndices());
try {
mDependencies.setsockoptMrt6AddMfc(mMulticastRoutingFd, mf6cctl);
} catch (ErrnoException e) {
Log.e(TAG, "failed to add MFC: " + e);
return false;
}
mMfcs.put(key, updatedValue);
String operation = (value == null ? "Added" : "Updated");
Log.d(TAG, operation + " MFC key: " + key + " value: " + updatedValue);
return true;
}
private void checkMfcsExpiration() {
checkOnHandlerThread();
// Check if there are inactive MFCs that can be removed
refreshMfcInactiveDuration();
maybeExpireMfcs();
if (mMfcs.size() > 0) {
mHandler.postDelayed(() -> checkMfcsExpiration(), MFC_INACTIVE_CHECK_INTERVAL_MS);
mMfcPollingScheduled = true;
} else {
mMfcPollingScheduled = false;
}
}
private void checkMfcEntriesLimit() {
checkOnHandlerThread();
// If the max number of MFC entries is reached, remove the first MFC entry. This can be
// any entry, as if this entry is needed again there will be a NOCACHE upcall to add it
// back.
if (mMfcs.size() == MFC_MAX_NUMBER_OF_ENTRIES) {
Log.w(TAG, "Reached max number of MFC entries " + MFC_MAX_NUMBER_OF_ENTRIES);
var iter = mMfcs.entrySet().iterator();
MfcKey firstMfcKey = iter.next().getKey();
removeMfcFromKernel(firstMfcKey);
iter.remove();
}
}
/**
* Reads multicast routes information from the kernel, and update the last used timestamp for
* each multicast route save in this class.
*/
private void refreshMfcInactiveDuration() {
checkOnHandlerThread();
final List If the kernel doesn't support multicast routing, then the {@code setsockoptInt} with
* {@code MRT6_INIT} method would fail.
*
* @return the multicast routing socket, or null if it fails to be created/configured.
*/
public FileDescriptor createMulticastRoutingSocket() {
FileDescriptor sock = null;
byte[] filter = new byte[32]; // filter all ICMPv6 messages
try {
sock = Os.socket(AF_INET6, SOCK_RAW | SOCK_CLOEXEC | SOCK_NONBLOCK, IPPROTO_ICMPV6);
Os.setsockoptInt(sock, IPPROTO_IPV6, MRT6_INIT, ONE);
NetworkUtils.setsockoptBytes(sock, IPPROTO_ICMPV6, ICMP6_FILTER, filter);
} catch (ErrnoException e) {
Log.e(TAG, "failed to create multicast socket: " + e);
if (sock != null) {
SocketUtils.closeSocketQuietly(sock);
}
throw new UnsupportedOperationException("Multicast routing is not supported ", e);
}
Log.i(TAG, "socket created for multicast routing: " + sock);
return sock;
}
public MulticastSocket createMulticastSocket() {
try {
return new MulticastSocket();
} catch (IOException e) {
Log.wtf(TAG, "Failed to create multicast socket " + e);
throw new IllegalStateException(e);
}
}
public void setsockoptMrt6AddMif(FileDescriptor fd, StructMif6ctl mif6ctl)
throws ErrnoException {
final byte[] bytes = mif6ctl.writeToBytes();
NetworkUtils.setsockoptBytes(fd, IPPROTO_IPV6, MRT6_ADD_MIF, bytes);
}
public void setsockoptMrt6DelMif(FileDescriptor fd, int virtualIfIndex)
throws ErrnoException {
Os.setsockoptInt(fd, IPPROTO_IPV6, MRT6_DEL_MIF, virtualIfIndex);
}
public void setsockoptMrt6AddMfc(FileDescriptor fd, StructMf6cctl mf6cctl)
throws ErrnoException {
final byte[] bytes = mf6cctl.writeToBytes();
NetworkUtils.setsockoptBytes(fd, IPPROTO_IPV6, MRT6_ADD_MFC, bytes);
}
public void setsockoptMrt6DelMfc(FileDescriptor fd, StructMf6cctl mf6cctl)
throws ErrnoException {
final byte[] bytes = mf6cctl.writeToBytes();
NetworkUtils.setsockoptBytes(fd, IPPROTO_IPV6, MRT6_DEL_MFC, bytes);
}
/**
* Returns the interface index for an interface name, or 0 if the interface index could
* not be found.
*/
public int getInterfaceIndex(String ifName) {
return Os.if_nametoindex(ifName);
}
public NetworkInterface getNetworkInterface(int physicalIndex) {
try {
return NetworkInterface.getByIndex(physicalIndex);
} catch (SocketException e) {
return null;
}
}
public Clock getClock() {
return mClock;
}
}
}