Merge changes I93514d22,I57dbc113,I707ffbd1 (6aafa03c) · Commits · e / os / android_system_core

adb/adb_client.cpp

+9 −0

Original line number	Diff line number	Diff line
		@@ -50,6 +50,15 @@ void adb_set_transport(TransportType type, const char* serial)
		__adb_serial = serial;
		}

		void adb_get_transport(TransportType* type, const char** serial) {
		if (type) {
		*type = __adb_transport;
		}
		if (serial) {
		*serial = __adb_serial;
		}
		}

		void adb_set_tcp_specifics(int server_port)
		{
		__adb_server_port = server_port;

adb/adb_client.h

+3 −0

Original line number	Diff line number	Diff line
		@@ -39,6 +39,9 @@ bool adb_query(const std::string& service, std::string* _Nonnull result,
		// Set the preferred transport to connect to.
		void adb_set_transport(TransportType type, const char* _Nullable serial);

		// Get the preferred transport to connect to.
		void adb_get_transport(TransportType* _Nullable type, const char* _Nullable* _Nullable serial);

		// Set TCP specifics of the transport to use.
		void adb_set_tcp_specifics(int server_port);

adb/adb_utils.h

+43 −0

Original line number	Diff line number	Diff line
		@@ -19,6 +19,8 @@

		#include <string>

		#include <android-base/macros.h>

		void close_stdin();

		bool getcwd(std::string* cwd);
		@@ -39,4 +41,45 @@ std::string perror_str(const char* msg);

		bool set_file_block_mode(int fd, bool block);

		extern int adb_close(int fd);

		// Helper to automatically close an FD when it goes out of scope.
		class ScopedFd {
		public:
		ScopedFd() {
		}

		~ScopedFd() {
		Reset();
		}

		void Reset(int fd = -1) {
		if (fd != fd_) {
		if (valid()) {
		adb_close(fd_);
		}
		fd_ = fd;
		}
		}

		int Release() {
		int temp = fd_;
		fd_ = -1;
		return temp;
		}

		bool valid() const {
		return fd_ >= 0;
		}

		int fd() const {
		return fd_;
		}

		private:
		int fd_ = -1;

		DISALLOW_COPY_AND_ASSIGN(ScopedFd);
		};

		#endif

adb/commandline.cpp

+51 −4

Original line number	Diff line number	Diff line
		@@ -1072,6 +1072,51 @@ static bool wait_for_device(const char* service, TransportType t, const char* se
		return adb_command(cmd);
		}

		static bool adb_root(const char* command) {
		std::string error;
		ScopedFd fd;

		fd.Reset(adb_connect(android::base::StringPrintf("%s:", command), &error));
		if (!fd.valid()) {
		fprintf(stderr, "adb: unable to connect for %s: %s\n", command, error.c_str());
		return false;
		}

		// Figure out whether we actually did anything.
		char buf[256];
		char* cur = buf;
		ssize_t bytes_left = sizeof(buf);
		while (bytes_left > 0) {
		ssize_t bytes_read = adb_read(fd.fd(), cur, bytes_left);
		if (bytes_read == 0) {
		break;
		} else if (bytes_read < 0) {
		fprintf(stderr, "adb: error while reading for %s: %s\n", command, strerror(errno));
		return false;
		}
		cur += bytes_read;
		bytes_left -= bytes_read;
		}

		if (bytes_left == 0) {
		fprintf(stderr, "adb: unexpected output length for %s\n", command);
		return false;
		}

		fflush(stdout);
		WriteFdExactly(STDOUT_FILENO, buf, sizeof(buf) - bytes_left);
		if (cur != buf && strstr(buf, "restarting") == nullptr) {
		return true;
		}

		// Give adbd 500ms to kill itself, then wait-for-device for it to come back up.
		adb_sleep_ms(500);
		TransportType type;
		const char* serial;
		adb_get_transport(&type, &serial);
		return wait_for_device("wait-for-device", type, serial);
		}

		// Connects to the device "shell" service with \|command\| and prints the
		// resulting output.
		static int send_shell_command(TransportType transport_type, const char* serial,
		@@ -1220,6 +1265,9 @@ static int restore(int argc, const char** argv) {
		printf("Now unlock your device and confirm the restore operation.\n");
		copy_to_file(tarFd, fd);

		// Wait until the other side finishes, or it'll get sent SIGHUP.
		copy_to_file(fd, STDOUT_FILENO);

		adb_close(fd);
		adb_close(tarFd);
		return 0;
		@@ -1632,8 +1680,6 @@ int adb_commandline(int argc, const char **argv) {
		!strcmp(argv[0], "reboot") \|\|
		!strcmp(argv[0], "reboot-bootloader") \|\|
		!strcmp(argv[0], "usb") \|\|
		!strcmp(argv[0], "root") \|\|
		!strcmp(argv[0], "unroot") \|\|
		!strcmp(argv[0], "disable-verity") \|\|
		!strcmp(argv[0], "enable-verity")) {
		std::string command;
		@@ -1645,8 +1691,9 @@ int adb_commandline(int argc, const char **argv) {
		command = android::base::StringPrintf("%s:", argv[0]);
		}
		return adb_connect_command(command);
		}
		else if (!strcmp(argv[0], "bugreport")) {
		} else if (!strcmp(argv[0], "root") \|\| !strcmp(argv[0], "unroot")) {
		return adb_root(argv[0]) ? 0 : 1;
		} else if (!strcmp(argv[0], "bugreport")) {
		if (argc != 1) return usage();
		// No need for shell protocol with bugreport, always disable for
		// simplicity.

adb/shell_service.cpp

+0 −31

Original line number	Diff line number	Diff line
		@@ -135,37 +135,6 @@ std::string ReadAll(int fd) {
		return received;
		}

		// Helper to automatically close an FD when it goes out of scope.
		class ScopedFd {
		public:
		ScopedFd() {}
		~ScopedFd() { Reset(); }

		void Reset(int fd=-1) {
		if (fd != fd_) {
		if (valid()) {
		adb_close(fd_);
		}
		fd_ = fd;
		}
		}

		int Release() {
		int temp = fd_;
		fd_ = -1;
		return temp;
		}

		bool valid() const { return fd_ >= 0; }

		int fd() const { return fd_; }

		private:
		int fd_ = -1;

		DISALLOW_COPY_AND_ASSIGN(ScopedFd);
		};

		// Creates a socketpair and saves the endpoints to \|fd1\| and \|fd2\|.
		bool CreateSocketpair(ScopedFd* fd1, ScopedFd* fd2) {
		int sockets[2];