Move offload config hidl usage from native to java (0d5a36be) · Commits · e / os / android_frameworks_base

packages/Tethering/Android.bp

+15 −14

Original line number	Original line	Diff line number	Diff line
	@@ -28,6 +28,7 @@ java_defaults {
	"netd_aidl_interface-unstable-java",		"netd_aidl_interface-unstable-java",
	"netlink-client",		"netlink-client",
	"networkstack-aidl-interfaces-unstable-java",		"networkstack-aidl-interfaces-unstable-java",
			"android.hardware.tetheroffload.config-V1.0-java",
	"android.hardware.tetheroffload.control-V1.0-java",		"android.hardware.tetheroffload.control-V1.0-java",
	"net-utils-framework-common",		"net-utils-framework-common",
	],		],
	@@ -48,25 +49,26 @@ android_library {
	// Due to b/143733063, APK can't access a jni lib that is in APEX (but not in the APK).		// Due to b/143733063, APK can't access a jni lib that is in APEX (but not in the APK).
	cc_library {		cc_library {
	name: "libtetherutilsjni",		name: "libtetherutilsjni",
			sdk_version: "current",
	srcs: [		srcs: [
	"jni/android_net_util_TetheringUtils.cpp",		"jni/android_net_util_TetheringUtils.cpp",
	],		],
	shared_libs: [		shared_libs: [
	"libcgrouprc",
	"libnativehelper_compat_libc++",
	"libvndksupport",
	],
	static_libs: [
	"android.hardware.tetheroffload.config@1.0",
	"liblog",		"liblog",
	"libbase",		"libnativehelper_compat_libc++",
	"libcutils",
	"libhidlbase",
	"libjsoncpp",
	"libprocessgroup",
	"libutils",
	],		],

			// We cannot use plain "libc++" here to link libc++ dynamically because it results in:
			// java.lang.UnsatisfiedLinkError: dlopen failed: library "libc++_shared.so" not found
			// even if "libc++" is added into jni_libs below. Adding "libc++_shared" into jni_libs doesn't
			// build because soong complains of:
			// module Tethering missing dependencies: libc++_shared
			//
			// So, link libc++ statically. This means that we also need to ensure that all the C++ libraries
			// we depend on do not dynamically link libc++. This is currently the case, because liblog is
			// C-only and libnativehelper_compat_libc also uses stl: "c++_static".
			stl: "c++_static",

	cflags: [		cflags: [
	"-Wall",		"-Wall",
	"-Werror",		"-Werror",
	@@ -85,9 +87,8 @@ java_defaults {
	// Build system doesn't track transitive dependeicies for jni_libs, list all the dependencies		// Build system doesn't track transitive dependeicies for jni_libs, list all the dependencies
	// explicitly.		// explicitly.
	jni_libs: [		jni_libs: [
	"libcgrouprc",		"liblog",
	"libnativehelper_compat_libc++",		"libnativehelper_compat_libc++",
	"libvndksupport",
	"libtetherutilsjni",		"libtetherutilsjni",
	],		],
	resource_dirs: [		resource_dirs: [

packages/Tethering/jni/android_net_util_TetheringUtils.cpp

+2 −108

Original line number	Original line	Diff line number	Diff line
	@@ -16,123 +16,18 @@

	#include <errno.h>		#include <errno.h>
	#include <error.h>		#include <error.h>
	#include <hidl/HidlSupport.h>
	#include <jni.h>		#include <jni.h>
	#include <nativehelper/JNIHelp.h>		#include <nativehelper/JNIHelp.h>
	#include <nativehelper/ScopedUtfChars.h>		#include <nativehelper/ScopedUtfChars.h>
	#include <linux/netfilter/nfnetlink.h>
	#include <linux/netlink.h>
	#include <net/if.h>		#include <net/if.h>
	#include <netinet/icmp6.h>		#include <netinet/icmp6.h>
	#include <sys/socket.h>		#include <sys/socket.h>
	#include <android-base/unique_fd.h>
	#include <android/hardware/tetheroffload/config/1.0/IOffloadConfig.h>

	#define LOG_TAG "TetheringUtils"		#define LOG_TAG "TetheringUtils"
	#include <utils/Log.h>		#include <android/log.h>

	namespace android {		namespace android {

	using hardware::hidl_handle;
	using hardware::hidl_string;
	using hardware::tetheroffload::config::V1_0::IOffloadConfig;

	namespace {

	inline const sockaddr * asSockaddr(const sockaddr_nl *nladdr) {
	return reinterpret_cast<const sockaddr *>(nladdr);
	}

	int conntrackSocket(unsigned groups) {
	base::unique_fd s(socket(AF_NETLINK, SOCK_DGRAM, NETLINK_NETFILTER));
	if (s.get() < 0) return -errno;

	const struct sockaddr_nl bind_addr = {
	.nl_family = AF_NETLINK,
	.nl_pad = 0,
	.nl_pid = 0,
	.nl_groups = groups,
	};
	if (bind(s.get(), asSockaddr(&bind_addr), sizeof(bind_addr)) != 0) {
	return -errno;
	}

	const struct sockaddr_nl kernel_addr = {
	.nl_family = AF_NETLINK,
	.nl_pad = 0,
	.nl_pid = 0,
	.nl_groups = groups,
	};
	if (connect(s.get(), asSockaddr(&kernel_addr), sizeof(kernel_addr)) != 0) {
	return -errno;
	}

	return s.release();
	}

	// Return a hidl_handle that owns the file descriptor owned by fd, and will
	// auto-close it (otherwise there would be double-close problems).
	//
	// Rely upon the compiler to eliminate the constexprs used for clarity.
	hidl_handle handleFromFileDescriptor(base::unique_fd fd) {
	hidl_handle h;

	static constexpr int kNumFds = 1;
	static constexpr int kNumInts = 0;
	native_handle_t *nh = native_handle_create(kNumFds, kNumInts);
	nh->data[0] = fd.release();

	static constexpr bool kTakeOwnership = true;
	h.setTo(nh, kTakeOwnership);

	return h;
	}

	} // namespace

	static jboolean android_net_util_configOffload(
	JNIEnv* /* env */) {
	sp<IOffloadConfig> configInterface = IOffloadConfig::getService();
	if (configInterface.get() == nullptr) {
	ALOGD("Could not find IOffloadConfig service.");
	return false;
	}

	// Per the IConfigOffload definition:
	//
	// fd1 A file descriptor bound to the following netlink groups
	// (NF_NETLINK_CONNTRACK_NEW \| NF_NETLINK_CONNTRACK_DESTROY).
	//
	// fd2 A file descriptor bound to the following netlink groups
	// (NF_NETLINK_CONNTRACK_UPDATE \| NF_NETLINK_CONNTRACK_DESTROY).
	base::unique_fd
	fd1(conntrackSocket(NF_NETLINK_CONNTRACK_NEW \| NF_NETLINK_CONNTRACK_DESTROY)),
	fd2(conntrackSocket(NF_NETLINK_CONNTRACK_UPDATE \| NF_NETLINK_CONNTRACK_DESTROY));
	if (fd1.get() < 0 \|\| fd2.get() < 0) {
	ALOGE("Unable to create conntrack handles: %d/%s", errno, strerror(errno));
	return false;
	}

	hidl_handle h1(handleFromFileDescriptor(std::move(fd1))),
	h2(handleFromFileDescriptor(std::move(fd2)));

	bool rval(false);
	hidl_string msg;
	const auto status = configInterface->setHandles(h1, h2,
	[&rval, &msg](bool success, const hidl_string& errMsg) {
	rval = success;
	msg = errMsg;
	});
	if (!status.isOk() \|\| !rval) {
	ALOGE("IOffloadConfig::setHandles() error: '%s' / '%s'",
	status.description().c_str(), msg.c_str());
	// If status is somehow not ok, make sure rval captures this too.
	rval = false;
	}

	return rval;
	}

	static void android_net_util_setupRaSocket(JNIEnv *env, jobject clazz, jobject javaFd,		static void android_net_util_setupRaSocket(JNIEnv *env, jobject clazz, jobject javaFd,
	jint ifIndex)		jint ifIndex)
	{		{
	@@ -229,7 +124,6 @@ static void android_net_util_setupRaSocket(JNIEnv *env, jobject clazz, jobject j
	*/		*/
	static const JNINativeMethod gMethods[] = {		static const JNINativeMethod gMethods[] = {
	/* name, signature, funcPtr */		/* name, signature, funcPtr */
	{ "configOffload", "()Z", (void*) android_net_util_configOffload },
	{ "setupRaSocket", "(Ljava/io/FileDescriptor;I)V", (void*) android_net_util_setupRaSocket },		{ "setupRaSocket", "(Ljava/io/FileDescriptor;I)V", (void*) android_net_util_setupRaSocket },
	};		};

	@@ -242,7 +136,7 @@ int register_android_net_util_TetheringUtils(JNIEnv* env) {
	extern "C" jint JNI_OnLoad(JavaVM* vm, void*) {		extern "C" jint JNI_OnLoad(JavaVM* vm, void*) {
	JNIEnv *env;		JNIEnv *env;
	if (vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK) {		if (vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK) {
	ALOGE("ERROR: GetEnv failed");		__android_log_print(ANDROID_LOG_ERROR, LOG_TAG, "ERROR: GetEnv failed");
	return JNI_ERR;		return JNI_ERR;
	}		}

packages/Tethering/src/android/net/util/TetheringUtils.java

+0 −8

Original line number	Original line	Diff line number	Diff line
	@@ -24,14 +24,6 @@ import java.net.SocketException;
	* {@hide}		* {@hide}
	*/		*/
	public class TetheringUtils {		public class TetheringUtils {

	/**
	* Offload management process need to know conntrack rules to support NAT, but it may not have
	* permission to create netlink netfilter sockets. Create two netlink netfilter sockets and
	* share them with offload management process.
	*/
	public static native boolean configOffload();

	/**		/**
	* Configures a socket for receiving ICMPv6 router solicitations and sending advertisements.		* Configures a socket for receiving ICMPv6 router solicitations and sending advertisements.
	* @param fd the socket's {@link FileDescriptor}.		* @param fd the socket's {@link FileDescriptor}.

packages/Tethering/src/com/android/server/connectivity/tethering/OffloadHardwareInterface.java

+110 −3

Original line number	Original line	Diff line number	Diff line
	@@ -18,19 +18,28 @@ package com.android.server.connectivity.tethering;

	import static android.net.util.TetheringUtils.uint16;		import static android.net.util.TetheringUtils.uint16;

			import android.hardware.tetheroffload.config.V1_0.IOffloadConfig;
	import android.hardware.tetheroffload.control.V1_0.IOffloadControl;		import android.hardware.tetheroffload.control.V1_0.IOffloadControl;
	import android.hardware.tetheroffload.control.V1_0.ITetheringOffloadCallback;		import android.hardware.tetheroffload.control.V1_0.ITetheringOffloadCallback;
	import android.hardware.tetheroffload.control.V1_0.NatTimeoutUpdate;		import android.hardware.tetheroffload.control.V1_0.NatTimeoutUpdate;
	import android.hardware.tetheroffload.control.V1_0.NetworkProtocol;		import android.hardware.tetheroffload.control.V1_0.NetworkProtocol;
	import android.hardware.tetheroffload.control.V1_0.OffloadCallbackEvent;		import android.hardware.tetheroffload.control.V1_0.OffloadCallbackEvent;
			import android.net.netlink.NetlinkSocket;
	import android.net.util.SharedLog;		import android.net.util.SharedLog;
	import android.net.util.TetheringUtils;		import android.net.util.SocketUtils;
	import android.os.Handler;		import android.os.Handler;
			import android.os.NativeHandle;
	import android.os.RemoteException;		import android.os.RemoteException;
			import android.system.ErrnoException;
			import android.system.Os;
	import android.system.OsConstants;		import android.system.OsConstants;

	import com.android.internal.annotations.VisibleForTesting;		import com.android.internal.annotations.VisibleForTesting;

			import java.io.FileDescriptor;
			import java.io.IOException;
			import java.net.SocketAddress;
			import java.net.SocketException;
	import java.util.ArrayList;		import java.util.ArrayList;


	@@ -49,6 +58,10 @@ public class OffloadHardwareInterface {
	private static final String NO_INTERFACE_NAME = "";		private static final String NO_INTERFACE_NAME = "";
	private static final String NO_IPV4_ADDRESS = "";		private static final String NO_IPV4_ADDRESS = "";
	private static final String NO_IPV4_GATEWAY = "";		private static final String NO_IPV4_GATEWAY = "";
			// Reference kernel/uapi/linux/netfilter/nfnetlink_compat.h
			private static final int NF_NETLINK_CONNTRACK_NEW = 1;
			private static final int NF_NETLINK_CONNTRACK_UPDATE = 2;
			private static final int NF_NETLINK_CONNTRACK_DESTROY = 4;

	private final Handler mHandler;		private final Handler mHandler;
	private final SharedLog mLog;		private final SharedLog mLog;
	@@ -121,9 +134,103 @@ public class OffloadHardwareInterface {
	return DEFAULT_TETHER_OFFLOAD_DISABLED;		return DEFAULT_TETHER_OFFLOAD_DISABLED;
	}		}

	/** Configure offload management process. */		/**
			* Offload management process need to know conntrack rules to support NAT, but it may not have
			* permission to create netlink netfilter sockets. Create two netlink netfilter sockets and
			* share them with offload management process.
			*/
	public boolean initOffloadConfig() {		public boolean initOffloadConfig() {
	return TetheringUtils.configOffload();		IOffloadConfig offloadConfig;
			try {
			offloadConfig = IOffloadConfig.getService();
			} catch (RemoteException e) {
			mLog.e("getIOffloadConfig error " + e);
			return false;
			}
			if (offloadConfig == null) {
			mLog.e("Could not find IOffloadConfig service");
			return false;
			}
			// Per the IConfigOffload definition:
			//
			// h1 provides a file descriptor bound to the following netlink groups
			// (NF_NETLINK_CONNTRACK_NEW \| NF_NETLINK_CONNTRACK_DESTROY).
			//
			// h2 provides a file descriptor bound to the following netlink groups
			// (NF_NETLINK_CONNTRACK_UPDATE \| NF_NETLINK_CONNTRACK_DESTROY).
			final NativeHandle h1 = createConntrackSocket(
			NF_NETLINK_CONNTRACK_NEW \| NF_NETLINK_CONNTRACK_DESTROY);
			if (h1 == null) return false;

			final NativeHandle h2 = createConntrackSocket(
			NF_NETLINK_CONNTRACK_UPDATE \| NF_NETLINK_CONNTRACK_DESTROY);
			if (h2 == null) {
			closeFdInNativeHandle(h1);
			return false;
			}

			final CbResults results = new CbResults();
			try {
			offloadConfig.setHandles(h1, h2,
			(boolean success, String errMsg) -> {
			results.mSuccess = success;
			results.mErrMsg = errMsg;
			});
			} catch (RemoteException e) {
			record("initOffloadConfig, setHandles fail", e);
			return false;
			}
			// Explicitly close FDs.
			closeFdInNativeHandle(h1);
			closeFdInNativeHandle(h2);

			record("initOffloadConfig, setHandles results:", results);
			return results.mSuccess;
			}

			private void closeFdInNativeHandle(final NativeHandle h) {
			try {
			h.close();
			} catch (IOException \| IllegalStateException e) {
			// IllegalStateException means fd is already closed, do nothing here.
			// Also nothing we can do if IOException.
			}
			}

			private NativeHandle createConntrackSocket(final int groups) {
			FileDescriptor fd;
			try {
			fd = NetlinkSocket.forProto(OsConstants.NETLINK_NETFILTER);
			} catch (ErrnoException e) {
			mLog.e("Unable to create conntrack socket " + e);
			return null;
			}

			final SocketAddress sockAddr = SocketUtils.makeNetlinkSocketAddress(0, groups);
			try {
			Os.bind(fd, sockAddr);
			} catch (ErrnoException \| SocketException e) {
			mLog.e("Unable to bind conntrack socket for groups " + groups + " error: " + e);
			try {
			SocketUtils.closeSocket(fd);
			} catch (IOException ie) {
			// Nothing we can do here
			}
			return null;
			}
			try {
			Os.connect(fd, sockAddr);
			} catch (ErrnoException \| SocketException e) {
			mLog.e("connect to kernel fail for groups " + groups + " error: " + e);
			try {
			SocketUtils.closeSocket(fd);
			} catch (IOException ie) {
			// Nothing we can do here
			}
			return null;
			}

			return new NativeHandle(fd, true);
	}		}

	/** Initialize the tethering offload HAL. */		/** Initialize the tethering offload HAL. */