Move NetworkMonitor to NetworkStack (5daa3703) · Commits · e / os / android_packages_modules_NetworkStack

Android.bp

+1 −1

Original line number	Diff line number	Diff line
		@@ -21,10 +21,10 @@ java_library {
		installable: true,
		srcs: [
		"src/*/.java",
		":services-networkstack-shared-srcs",
		],
		static_libs: [
		"dhcp-packet-lib",
		"frameworks-net-shared-utils",
		]
		}

AndroidManifest.xml

+3 −0

Original line number	Diff line number	Diff line
		@@ -22,8 +22,11 @@
		<uses-permission android:name="android.permission.INTERNET" />
		<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
		<uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
		<uses-permission android:name="android.permission.CONNECTIVITY_INTERNAL" />
		<uses-permission android:name="android.permission.NETWORK_SETTINGS" />
		<!-- Launch captive portal app as specific user -->
		<uses-permission android:name="android.permission.INTERACT_ACROSS_USERS_FULL" />
		<uses-permission android:name="android.permission.NETWORK_STACK" />
		<application
		android:label="NetworkStack"
		android:defaultToDeviceProtectedStorage="true"

src/android/net/util/SharedLog.java

+4 −0

Original line number	Diff line number	Diff line
		@@ -69,6 +69,10 @@ public class SharedLog {
		mComponent = component;
		}

		public String getTag() {
		return mTag;
		}

		/**
		* Create a SharedLog based on this log with an additional component prefix on each logged line.
		*/

src/android/net/util/Stopwatch.java

0 → 100644

+83 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2016 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		package android.net.util;

		import android.os.SystemClock;


		/**
		* @hide
		*/
		public class Stopwatch {
		private long mStartTimeMs;
		private long mStopTimeMs;

		public boolean isStarted() {
		return (mStartTimeMs > 0);
		}

		public boolean isStopped() {
		return (mStopTimeMs > 0);
		}

		public boolean isRunning() {
		return (isStarted() && !isStopped());
		}

		/**
		* Start the Stopwatch.
		*/
		public Stopwatch start() {
		if (!isStarted()) {
		mStartTimeMs = SystemClock.elapsedRealtime();
		}
		return this;
		}

		/**
		* Stop the Stopwatch.
		* @return the total time recorded, in milliseconds, or 0 if not started.
		*/
		public long stop() {
		if (isRunning()) {
		mStopTimeMs = SystemClock.elapsedRealtime();
		}
		// Return either the delta after having stopped, or 0.
		return (mStopTimeMs - mStartTimeMs);
		}

		/**
		* Return the total time recorded to date, in milliseconds.
		* If the Stopwatch is not running, returns the same value as stop(),
		* i.e. either the total time recorded before stopping or 0.
		*/
		public long lap() {
		if (isRunning()) {
		return (SystemClock.elapsedRealtime() - mStartTimeMs);
		} else {
		return stop();
		}
		}

		/**
		* Reset the Stopwatch. It will be stopped when this method returns.
		*/
		public void reset() {
		mStartTimeMs = 0;
		mStopTimeMs = 0;
		}
		}

src/com/android/server/NetworkStackService.java

+133 −5

Original line number	Diff line number	Diff line
		@@ -25,18 +25,31 @@ import static com.android.server.util.PermissionUtil.checkNetworkStackCallingPer
		import android.annotation.NonNull;
		import android.annotation.Nullable;
		import android.app.Service;
		import android.content.Context;
		import android.content.Intent;
		import android.net.ConnectivityManager;
		import android.net.INetworkMonitor;
		import android.net.INetworkMonitorCallbacks;
		import android.net.INetworkStackConnector;
		import android.net.Network;
		import android.net.NetworkRequest;
		import android.net.PrivateDnsConfigParcel;
		import android.net.dhcp.DhcpServer;
		import android.net.dhcp.DhcpServingParams;
		import android.net.dhcp.DhcpServingParamsParcel;
		import android.net.dhcp.IDhcpServerCallbacks;
		import android.net.shared.PrivateDnsConfig;
		import android.net.util.SharedLog;
		import android.os.IBinder;
		import android.os.RemoteException;

		import com.android.internal.annotations.GuardedBy;
		import com.android.internal.util.IndentingPrintWriter;
		import com.android.server.connectivity.NetworkMonitor;

		import java.io.FileDescriptor;
		import java.io.PrintWriter;
		import java.util.ArrayDeque;

		/**
		* Android service used to start the network stack when bound to via an intent.
		@@ -52,17 +65,41 @@ public class NetworkStackService extends Service {
		* <p>On platforms where the network stack runs in the system server process, this method may
		* be called directly instead of obtaining the connector by binding to the service.
		*/
		public static IBinder makeConnector() {
		return new NetworkStackConnector();
		public static IBinder makeConnector(Context context) {
		return new NetworkStackConnector(context);
		}

		@NonNull
		@Override
		public IBinder onBind(Intent intent) {
		return makeConnector();
		return makeConnector(this);
		}

		private static class NetworkStackConnector extends INetworkStackConnector.Stub {
		private static final int NUM_VALIDATION_LOG_LINES = 20;
		private final Context mContext;
		private final ConnectivityManager mCm;

		private static final int MAX_VALIDATION_LOGS = 10;
		@GuardedBy("mValidationLogs")
		private final ArrayDeque<SharedLog> mValidationLogs = new ArrayDeque<>(MAX_VALIDATION_LOGS);

		private SharedLog addValidationLogs(Network network, String name) {
		final SharedLog log = new SharedLog(NUM_VALIDATION_LOG_LINES, network + " - " + name);
		synchronized (mValidationLogs) {
		while (mValidationLogs.size() >= MAX_VALIDATION_LOGS) {
		mValidationLogs.removeLast();
		}
		mValidationLogs.addFirst(log);
		}
		return log;
		}

		NetworkStackConnector(Context context) {
		mContext = context;
		mCm = context.getSystemService(ConnectivityManager.class);
		}

		@NonNull
		private final SharedLog mLog = new SharedLog(TAG);

		@@ -88,12 +125,103 @@ public class NetworkStackService extends Service {
		cb.onDhcpServerCreated(STATUS_SUCCESS, server);
		}

		@Override
		public void makeNetworkMonitor(int netId, String name, INetworkMonitorCallbacks cb)
		throws RemoteException {
		final Network network = new Network(netId, false /* privateDnsBypass */);
		final NetworkRequest defaultRequest = mCm.getDefaultRequest();
		final SharedLog log = addValidationLogs(network, name);
		final NetworkMonitor nm = new NetworkMonitor(
		mContext, cb, network, defaultRequest, log);
		cb.onNetworkMonitorCreated(new NetworkMonitorImpl(nm));
		}

		@Override
		protected void dump(@NonNull FileDescriptor fd, @NonNull PrintWriter fout,
		@Nullable String[] args) {
		checkNetworkStackCallingPermission();
		fout.println("NetworkStack logs:");
		mLog.dump(fd, fout, args);
		final IndentingPrintWriter pw = new IndentingPrintWriter(fout, " ");
		pw.println("NetworkStack logs:");
		mLog.dump(fd, pw, args);

		pw.println();
		pw.println("Validation logs (most recent first):");
		synchronized (mValidationLogs) {
		for (SharedLog p : mValidationLogs) {
		pw.println(p.getTag());
		pw.increaseIndent();
		p.dump(fd, pw, args);
		pw.decreaseIndent();
		}
		}
		}
		}

		private static class NetworkMonitorImpl extends INetworkMonitor.Stub {
		private final NetworkMonitor mNm;

		NetworkMonitorImpl(NetworkMonitor nm) {
		mNm = nm;
		}

		@Override
		public void start() {
		checkNetworkStackCallingPermission();
		mNm.start();
		}

		@Override
		public void launchCaptivePortalApp() {
		checkNetworkStackCallingPermission();
		mNm.launchCaptivePortalApp();
		}

		@Override
		public void forceReevaluation(int uid) {
		checkNetworkStackCallingPermission();
		mNm.forceReevaluation(uid);
		}

		@Override
		public void notifyPrivateDnsChanged(PrivateDnsConfigParcel config) {
		checkNetworkStackCallingPermission();
		mNm.notifyPrivateDnsSettingsChanged(PrivateDnsConfig.fromParcel(config));
		}

		@Override
		public void notifyDnsResponse(int returnCode) {
		checkNetworkStackCallingPermission();
		mNm.notifyDnsResponse(returnCode);
		}

		@Override
		public void notifySystemReady() {
		checkNetworkStackCallingPermission();
		mNm.notifySystemReady();
		}

		@Override
		public void notifyNetworkConnected() {
		checkNetworkStackCallingPermission();
		mNm.notifyNetworkConnected();
		}

		@Override
		public void notifyNetworkDisconnected() {
		checkNetworkStackCallingPermission();
		mNm.notifyNetworkDisconnected();
		}

		@Override
		public void notifyLinkPropertiesChanged() {
		checkNetworkStackCallingPermission();
		mNm.notifyLinkPropertiesChanged();
		}

		@Override
		public void notifyNetworkCapabilitiesChanged() {
		checkNetworkStackCallingPermission();
		mNm.notifyNetworkCapabilitiesChanged();
		}
		}
		}