Merge "adb: convert more stuff to unique_fd." (7dcb91cb) · Commits · e / os / android_system_core

adb/adb.h

+1 −1

Original line number	Diff line number	Diff line
		@@ -139,7 +139,7 @@ atransport* find_emulator_transport_by_adb_port(int adb_port);
		atransport* find_emulator_transport_by_console_port(int console_port);
		#endif

		int service_to_fd(std::string_view name, atransport* transport);
		unique_fd service_to_fd(std::string_view name, atransport* transport);
		#if !ADB_HOST
		unique_fd daemon_service_to_fd(std::string_view name, atransport* transport);
		#endif

adb/adb_listeners.cpp

+5 −10

Original line number	Diff line number	Diff line
		@@ -75,41 +75,36 @@ static ListenerList& listener_list GUARDED_BY(listener_list_mutex) = *new Listen

		static void ss_listener_event_func(int _fd, unsigned ev, void *_l) {
		if (ev & FDE_READ) {
		int fd = adb_socket_accept(_fd, nullptr, nullptr);
		unique_fd fd(adb_socket_accept(_fd, nullptr, nullptr));
		if (fd < 0) return;

		int rcv_buf_size = CHUNK_SIZE;
		adb_setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &rcv_buf_size, sizeof(rcv_buf_size));
		adb_setsockopt(fd.get(), SOL_SOCKET, SO_RCVBUF, &rcv_buf_size, sizeof(rcv_buf_size));

		asocket* s = create_local_socket(fd);
		asocket* s = create_local_socket(std::move(fd));
		if (s) {
		connect_to_smartsocket(s);
		return;
		}

		adb_close(fd);
		}
		}

		static void listener_event_func(int _fd, unsigned ev, void* _l)
		{
		alistener* listener = reinterpret_cast<alistener*>(_l);
		asocket *s;

		if (ev & FDE_READ) {
		int fd = adb_socket_accept(_fd, nullptr, nullptr);
		unique_fd fd(adb_socket_accept(_fd, nullptr, nullptr));
		if (fd < 0) {
		return;
		}

		s = create_local_socket(fd);
		asocket* s = create_local_socket(std::move(fd));
		if (s) {
		s->transport = listener->transport;
		connect_to_remote(s, listener->connect_to);
		return;
		}

		adb_close(fd);
		}
		}

adb/adb_utils.h

+0 −2

Original line number	Diff line number	Diff line
		@@ -53,8 +53,6 @@ std::string perror_str(const char* msg);

		bool set_file_block_mode(int fd, bool block);

		int adb_close(int fd);

		// Given forward/reverse targets, returns true if they look sane. If an error is found, fills
		// \|error\| and returns false.
		// Currently this only checks "tcp:" targets. Additional checking could be added for other targets

adb/adb_utils_test.cpp

+10 −11

Original line number	Diff line number	Diff line
		@@ -147,7 +147,7 @@ TEST(adb_utils, mkdirs) {

		#if !defined(_WIN32)
		TEST(adb_utils, set_file_block_mode) {
		int fd = adb_open("/dev/null", O_RDWR \| O_APPEND);
		unique_fd fd(adb_open("/dev/null", O_RDWR \| O_APPEND));
		ASSERT_GE(fd, 0);
		int flags = fcntl(fd, F_GETFL, 0);
		ASSERT_EQ(O_RDWR \| O_APPEND, (flags & (O_RDWR \| O_APPEND)));
		@@ -157,7 +157,6 @@ TEST(adb_utils, set_file_block_mode) {
		ASSERT_TRUE(set_file_block_mode(fd, true));
		new_flags = fcntl(fd, F_GETFL, 0);
		ASSERT_EQ(flags, new_flags);
		ASSERT_EQ(0, adb_close(fd));
		}
		#endif

adb/client/adb_client.cpp

+10 −18

Original line number	Diff line number	Diff line
		@@ -100,13 +100,11 @@ static int switch_socket_transport(int fd, std::string* error) {

		if (!SendProtocolString(fd, service)) {
		*error = perror_str("write failure during connection");
		adb_close(fd);
		return -1;
		}
		D("Switch transport in progress");

		if (!adb_status(fd, error)) {
		adb_close(fd);
		D("Switch transport failed: %s", error->c_str());
		return -1;
		}
		@@ -194,7 +192,7 @@ bool adb_kill_server() {

		int adb_connect(const std::string& service, std::string* error) {
		// first query the adb server's version
		int fd = _adb_connect("host:version", error);
		unique_fd fd(_adb_connect("host:version", error));

		D("adb_connect: service %s", service.c_str());
		if (fd == -2 && !is_local_socket_spec(__adb_server_socket_spec)) {
		@@ -224,12 +222,10 @@ int adb_connect(const std::string& service, std::string* error) {
		if (fd >= 0) {
		std::string version_string;
		if (!ReadProtocolString(fd, &version_string, error)) {
		adb_close(fd);
		return -1;
		}

		ReadOrderlyShutdown(fd);
		adb_close(fd);

		if (sscanf(&version_string[0], "%04x", &version) != 1) {
		*error = android::base::StringPrintf("cannot parse version string: %s",
		@@ -258,52 +254,48 @@ int adb_connect(const std::string& service, std::string* error) {
		return 0;
		}

		fd = _adb_connect(service, error);
		fd.reset(_adb_connect(service, error));
		if (fd == -1) {
		D("_adb_connect error: %s", error->c_str());
		} else if(fd == -2) {
		fprintf(stderr, "* daemon still not running\n");
		}
		D("adb_connect: return fd %d", fd);
		D("adb_connect: return fd %d", fd.get());

		return fd;
		return fd.release();
		}


		bool adb_command(const std::string& service) {
		std::string error;
		int fd = adb_connect(service, &error);
		unique_fd fd(adb_connect(service, &error));
		if (fd < 0) {
		fprintf(stderr, "error: %s\n", error.c_str());
		return false;
		}

		if (!adb_status(fd, &error)) {
		if (!adb_status(fd.get(), &error)) {
		fprintf(stderr, "error: %s\n", error.c_str());
		adb_close(fd);
		return false;
		}

		ReadOrderlyShutdown(fd);
		adb_close(fd);
		ReadOrderlyShutdown(fd.get());
		return true;
		}

		bool adb_query(const std::string& service, std::string* result, std::string* error) {
		D("adb_query: %s", service.c_str());
		int fd = adb_connect(service, error);
		unique_fd fd(adb_connect(service, error));
		if (fd < 0) {
		return false;
		}

		result->clear();
		if (!ReadProtocolString(fd, result, error)) {
		adb_close(fd);
		if (!ReadProtocolString(fd.get(), result, error)) {
		return false;
		}

		ReadOrderlyShutdown(fd);
		adb_close(fd);
		ReadOrderlyShutdown(fd.get());
		return true;
		}