Add new "shell command" feature to Binder objects. (9461b6f9) · Commits · e / os / android_frameworks_base

core/java/android/os/Binder.java

+100 −28

Original line number	Diff line number	Diff line
		@@ -19,6 +19,7 @@ package android.os;
		import android.util.Log;
		import android.util.Slog;
		import com.android.internal.util.FastPrintWriter;
		import libcore.io.IoUtils;

		import java.io.FileDescriptor;
		import java.io.FileOutputStream;
		@@ -342,19 +343,40 @@ public class Binder implements IBinder {
		try {
		dump(fd.getFileDescriptor(), args);
		} finally {
		try {
		fd.close();
		} catch (IOException e) {
		// swallowed, not propagated back to the caller
		IoUtils.closeQuietly(fd);
		}
		}
		// Write the StrictMode header.
		if (reply != null) {
		reply.writeNoException();
		} else {
		StrictMode.clearGatheredViolations();
		}
		return true;
		} else if (code == SHELL_COMMAND_TRANSACTION) {
		ParcelFileDescriptor in = data.readFileDescriptor();
		ParcelFileDescriptor out = data.readFileDescriptor();
		ParcelFileDescriptor err = data.readFileDescriptor();
		String[] args = data.readStringArray();
		ResultReceiver resultReceiver = ResultReceiver.CREATOR.createFromParcel(data);
		try {
		if (out != null) {
		shellCommand(in != null ? in.getFileDescriptor() : null,
		out.getFileDescriptor(),
		err != null ? err.getFileDescriptor() : out.getFileDescriptor(),
		args, resultReceiver);
		}
		} finally {
		IoUtils.closeQuietly(in);
		IoUtils.closeQuietly(out);
		IoUtils.closeQuietly(err);
		// Write the StrictMode header.
		if (reply != null) {
		reply.writeNoException();
		} else {
		StrictMode.clearGatheredViolations();
		}
		}
		return true;
		}
		return false;
		@@ -368,6 +390,13 @@ public class Binder implements IBinder {
		FileOutputStream fout = new FileOutputStream(fd);
		PrintWriter pw = new FastPrintWriter(fout);
		try {
		doDump(fd, pw, args);
		} finally {
		pw.flush();
		}
		}

		void doDump(FileDescriptor fd, PrintWriter pw, String[] args) {
		final String disabled;
		synchronized (Binder.class) {
		disabled = sDumpDisabled;
		@@ -390,9 +419,6 @@ public class Binder implements IBinder {
		} else {
		pw.println(sDumpDisabled);
		}
		} finally {
		pw.flush();
		}
		}

		/**
		@@ -425,6 +451,34 @@ public class Binder implements IBinder {
		protected void dump(FileDescriptor fd, PrintWriter fout, String[] args) {
		}

		/**
		* @param in The raw file descriptor that an input data stream can be read from.
		* @param out The raw file descriptor that normal command messages should be written to.
		* @param err The raw file descriptor that command error messages should be written to.
		* @param args Command-line arguments.
		* @param resultReceiver Called when the command has finished executing, with the result code.
		* @throws RemoteException
		* @hide
		*/
		public void shellCommand(FileDescriptor in, FileDescriptor out, FileDescriptor err,
		String[] args, ResultReceiver resultReceiver) throws RemoteException {
		onShellCommand(in, out, err, args, resultReceiver);
		}

		/**
		* Handle a call to {@link #shellCommand}. The default implementation simply prints
		* an error message. Override and replace with your own.
		* @hide
		*/
		public void onShellCommand(FileDescriptor in, FileDescriptor out, FileDescriptor err,
		String[] args, ResultReceiver resultReceiver) throws RemoteException {
		FileOutputStream fout = new FileOutputStream(err != null ? err : out);
		PrintWriter pw = new FastPrintWriter(fout);
		pw.println("No shell command implementation.");
		pw.flush();
		resultReceiver.send(0, null);
		}

		/**
		* Default implementation rewinds the parcels and calls onTransact. On
		* the remote side, transact calls into the binder to do the IPC.
		@@ -590,6 +644,24 @@ final class BinderProxy implements IBinder {
		}
		}

		public void shellCommand(FileDescriptor in, FileDescriptor out, FileDescriptor err,
		String[] args, ResultReceiver resultReceiver) throws RemoteException {
		Parcel data = Parcel.obtain();
		Parcel reply = Parcel.obtain();
		data.writeFileDescriptor(in);
		data.writeFileDescriptor(out);
		data.writeFileDescriptor(err);
		data.writeStringArray(args);
		resultReceiver.writeToParcel(data, 0);
		try {
		transact(SHELL_COMMAND_TRANSACTION, data, reply, 0);
		reply.readException();
		} finally {
		data.recycle();
		reply.recycle();
		}
		}

		BinderProxy() {
		mSelf = new WeakReference(this);
		}

core/java/android/os/IBinder.java

+22 −2

Original line number	Diff line number	Diff line
		@@ -102,6 +102,12 @@ public interface IBinder {
		*/
		int DUMP_TRANSACTION = ('_'<<24)\|('D'<<16)\|('M'<<8)\|'P';

		/**
		* IBinder protocol transaction code: execute a shell command.
		* @hide
		*/
		int SHELL_COMMAND_TRANSACTION = ('_'<<24)\|('C'<<16)\|('M'<<8)\|'D';

		/**
		* IBinder protocol transaction code: interrogate the recipient side
		* of the transaction for its canonical interface descriptor.
		@@ -206,6 +212,20 @@ public interface IBinder {
		*/
		public void dumpAsync(FileDescriptor fd, String[] args) throws RemoteException;

		/**
		* Execute a shell command on this object. This may be performed asynchrously from the caller;
		* the implementation must always call resultReceiver when finished.
		*
		* @param in The raw file descriptor that an input data stream can be read from.
		* @param out The raw file descriptor that normal command messages should be written to.
		* @param err The raw file descriptor that command error messages should be written to.
		* @param args Command-line arguments.
		* @param resultReceiver Called when the command has finished executing, with the result code.
		* @hide
		*/
		public void shellCommand(FileDescriptor in, FileDescriptor out, FileDescriptor err,
		String[] args, ResultReceiver resultReceiver) throws RemoteException;

		/**
		* Perform a generic operation with the object.
		*

core/java/android/os/ShellCommand.java

0 → 100644

+192 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2015 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.os;

		import android.util.Slog;
		import com.android.internal.util.FastPrintWriter;

		import java.io.FileDescriptor;
		import java.io.FileOutputStream;
		import java.io.PrintWriter;

		/**
		* @hide
		*/
		public abstract class ShellCommand {
		static final String TAG = "ShellCommand";
		static final boolean DEBUG = false;

		private Binder mTarget;
		private FileDescriptor mIn;
		private FileDescriptor mOut;
		private FileDescriptor mErr;
		private String[] mArgs;
		private ResultReceiver mResultReceiver;

		private String mCmd;
		private int mArgPos;
		private String mCurArgData;

		private FastPrintWriter mOutPrintWriter;
		private FastPrintWriter mErrPrintWriter;

		public void exec(Binder target, FileDescriptor in, FileDescriptor out, FileDescriptor err,
		String[] args, ResultReceiver resultReceiver) {
		mTarget = target;
		mIn = in;
		mOut = out;
		mErr = err;
		mArgs = args;
		mResultReceiver = resultReceiver;
		mCmd = args != null && args.length > 0 ? args[0] : null;
		mArgPos = 1;
		mCurArgData = null;
		mOutPrintWriter = null;
		mErrPrintWriter = null;

		if (DEBUG) Slog.d(TAG, "Starting command " + mCmd + " on " + mTarget);
		int res = -1;
		try {
		res = onCommand(mCmd);
		if (DEBUG) Slog.d(TAG, "Executed command " + mCmd + " on " + mTarget);
		} catch (SecurityException e) {
		PrintWriter eout = getErrPrintWriter();
		eout.println("Security exception: " + e.getMessage());
		eout.println();
		e.printStackTrace(eout);
		} catch (Throwable e) {
		// Unlike usual calls, in this case if an exception gets thrown
		// back to us we want to print it back in to the dump data, since
		// that is where the caller expects all interesting information to
		// go.
		PrintWriter eout = getErrPrintWriter();
		eout.println();
		eout.println("Exception occurred while dumping:");
		e.printStackTrace(eout);
		} finally {
		if (DEBUG) Slog.d(TAG, "Flushing output streams on " + mTarget);
		if (mOutPrintWriter != null) {
		mOutPrintWriter.flush();
		}
		if (mErrPrintWriter != null) {
		mErrPrintWriter.flush();
		}
		if (DEBUG) Slog.d(TAG, "Sending command result on " + mTarget);
		mResultReceiver.send(res, null);
		}
		if (DEBUG) Slog.d(TAG, "Finished command " + mCmd + " on " + mTarget);
		}

		public PrintWriter getOutPrintWriter() {
		if (mOutPrintWriter == null) {
		FileOutputStream fout = new FileOutputStream(mOut);
		mOutPrintWriter = new FastPrintWriter(fout);
		}
		return mOutPrintWriter;
		}

		public PrintWriter getErrPrintWriter() {
		if (mErr == null) {
		return getOutPrintWriter();
		}
		if (mErrPrintWriter == null) {
		FileOutputStream fout = new FileOutputStream(mErr);
		mErrPrintWriter = new FastPrintWriter(fout);
		}
		return mErrPrintWriter;
		}

		/**
		* Return the next option on the command line -- that is an argument that
		* starts with '-'. If the next argument is not an option, null is returned.
		*/
		public String getNextOption() {
		if (mCurArgData != null) {
		String prev = mArgs[mArgPos - 1];
		throw new IllegalArgumentException("No argument expected after \"" + prev + "\"");
		}
		if (mArgPos >= mArgs.length) {
		return null;
		}
		String arg = mArgs[mArgPos];
		if (!arg.startsWith("-")) {
		return null;
		}
		mArgPos++;
		if (arg.equals("--")) {
		return null;
		}
		if (arg.length() > 1 && arg.charAt(1) != '-') {
		if (arg.length() > 2) {
		mCurArgData = arg.substring(2);
		return arg.substring(0, 2);
		} else {
		mCurArgData = null;
		return arg;
		}
		}
		mCurArgData = null;
		return arg;
		}

		/**
		* Return the next argument on the command line, whatever it is; if there are
		* no arguments left, return null.
		*/
		public String getNextArg() {
		if (mCurArgData != null) {
		String arg = mCurArgData;
		mCurArgData = null;
		return arg;
		} else if (mArgPos < mArgs.length) {
		return mArgs[mArgPos++];
		} else {
		return null;
		}
		}

		/**
		* Return the next argument on the command line, whatever it is; if there are
		* no arguments left, throws an IllegalArgumentException to report this to the user.
		*/
		public String getNextArgRequired() {
		String arg = getNextArg();
		if (arg == null) {
		String prev = mArgs[mArgPos - 1];
		throw new IllegalArgumentException("Argument expected after \"" + prev + "\"");
		}
		return arg;
		}

		public int handleDefaultCommands(String cmd) {
		if ("dump".equals(cmd)) {
		String[] newArgs = new String[mArgs.length-1];
		System.arraycopy(mArgs, 1, newArgs, 0, mArgs.length-1);
		mTarget.doDump(mOut, getOutPrintWriter(), newArgs);
		return 0;
		} else if (cmd == null \|\| "help".equals(cmd) \|\| "-h".equals(cmd)) {
		onHelp();
		} else {
		getOutPrintWriter().println("Unknown command: " + cmd);
		}
		return -1;
		}

		public abstract int onCommand(String cmd);

		public abstract void onHelp();
		}

services/core/java/com/android/server/DeviceIdleController.java

+222 −175

File changed.

Preview size limit exceeded, changes collapsed.