Merge "adb: factor out socket specification." (bd7d2e2e) · Commits · e / os / android_system_core

adb/Android.mk

+1 −0

Original line number	Diff line number	Diff line
		@@ -52,6 +52,7 @@ LIBADB_SRC_FILES := \
		adb_utils.cpp \
		fdevent.cpp \
		sockets.cpp \
		socket_spec.cpp \
		transport.cpp \
		transport_local.cpp \
		transport_usb.cpp \

adb/adb_listeners.cpp

+11 −46

Original line number	Diff line number	Diff line
		@@ -23,12 +23,10 @@
		#include <android-base/strings.h>
		#include <cutils/sockets.h>

		#include "socket_spec.h"
		#include "sysdeps.h"
		#include "transport.h"

		// Not static because it is used in commandline.c.
		int gListenAll = 0;

		// A listener is an entity which binds to a local port and, upon receiving a connection on that
		// port, creates an asocket to connect the new local connection to a specific remote service.
		//
		@@ -120,48 +118,6 @@ static void listener_disconnect(void* arg, atransport*) {
		}
		}

		int local_name_to_fd(alistener* listener, int* resolved_tcp_port, std::string* error) {
		if (android::base::StartsWith(listener->local_name, "tcp:")) {
		int requested_port = atoi(&listener->local_name[4]);
		int sock = -1;
		if (gListenAll > 0) {
		sock = network_inaddr_any_server(requested_port, SOCK_STREAM, error);
		} else {
		sock = network_loopback_server(requested_port, SOCK_STREAM, error);
		}

		// If the caller requested port 0, update the listener name with the resolved port.
		if (sock >= 0 && requested_port == 0) {
		int local_port = adb_socket_get_local_port(sock);
		if (local_port > 0) {
		listener->local_name = android::base::StringPrintf("tcp:%d", local_port);
		if (resolved_tcp_port != nullptr) {
		*resolved_tcp_port = local_port;
		}
		}
		}

		return sock;
		}
		#if !defined(_WIN32) // No Unix-domain sockets on Windows.
		// It's nonsensical to support the "reserved" space on the adb host side.
		if (android::base::StartsWith(listener->local_name, "local:")) {
		return network_local_server(&listener->local_name[6], ANDROID_SOCKET_NAMESPACE_ABSTRACT,
		SOCK_STREAM, error);
		} else if (android::base::StartsWith(listener->local_name, "localabstract:")) {
		return network_local_server(&listener->local_name[14], ANDROID_SOCKET_NAMESPACE_ABSTRACT,
		SOCK_STREAM, error);
		} else if (android::base::StartsWith(listener->local_name, "localfilesystem:")) {
		return network_local_server(&listener->local_name[16], ANDROID_SOCKET_NAMESPACE_FILESYSTEM,
		SOCK_STREAM, error);
		}

		#endif
		*error = android::base::StringPrintf("unknown local portname '%s'",
		listener->local_name.c_str());
		return -1;
		}

		// Write the list of current listeners (network redirections) into a string.
		std::string format_listeners() {
		std::string result;
		@@ -230,11 +186,20 @@ InstallStatus install_listener(const std::string& local_name, const char* connec

		std::unique_ptr<alistener> listener(new alistener(local_name, connect_to));

		listener->fd = local_name_to_fd(listener.get(), resolved_tcp_port, error);
		int resolved = 0;
		listener->fd = socket_spec_listen(listener->local_name, error, &resolved);
		if (listener->fd < 0) {
		return INSTALL_STATUS_CANNOT_BIND;
		}

		// If the caller requested port 0, update the listener name with the resolved port.
		if (resolved != 0) {
		listener->local_name = android::base::StringPrintf("tcp:%d", resolved);
		if (resolved_tcp_port) {
		*resolved_tcp_port = resolved;
		}
		}

		close_on_exec(listener->fd);
		if (listener->connect_to == "smartsocket") {
		fdevent_install(&listener->fde, listener->fd, ss_listener_event_func, listener.get());

adb/services.cpp

+6 −29

Original line number	Diff line number	Diff line
		@@ -49,6 +49,7 @@
		#include "remount_service.h"
		#include "services.h"
		#include "shell_service.h"
		#include "socket_spec.h"
		#include "sysdeps.h"
		#include "transport.h"

		@@ -278,36 +279,12 @@ static int create_service_thread(void (func)(int, void ), void *cookie)
		int service_to_fd(const char* name, const atransport* transport) {
		int ret = -1;

		if(!strncmp(name, "tcp:", 4)) {
		int port = atoi(name + 4);
		name = strchr(name + 4, ':');
		if(name == 0) {
		if (is_socket_spec(name)) {
		std::string error;
		ret = network_loopback_client(port, SOCK_STREAM, &error);
		if (ret >= 0)
		disable_tcp_nagle(ret);
		} else {
		#if ADB_HOST
		std::string error;
		ret = network_connect(name + 1, port, SOCK_STREAM, 0, &error);
		#else
		return -1;
		#endif
		ret = socket_spec_connect(name, &error);
		if (ret < 0) {
		LOG(ERROR) << "failed to connect to socket '" << name << "': " << error;
		}
		#if !defined(_WIN32) /* winsock doesn't implement unix domain sockets */
		} else if(!strncmp(name, "local:", 6)) {
		ret = socket_local_client(name + 6,
		ANDROID_SOCKET_NAMESPACE_RESERVED, SOCK_STREAM);
		} else if(!strncmp(name, "localreserved:", 14)) {
		ret = socket_local_client(name + 14,
		ANDROID_SOCKET_NAMESPACE_RESERVED, SOCK_STREAM);
		} else if(!strncmp(name, "localabstract:", 14)) {
		ret = socket_local_client(name + 14,
		ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_STREAM);
		} else if(!strncmp(name, "localfilesystem:", 16)) {
		ret = socket_local_client(name + 16,
		ANDROID_SOCKET_NAMESPACE_FILESYSTEM, SOCK_STREAM);
		#endif
		#if !ADB_HOST
		} else if(!strncmp("dev:", name, 4)) {
		ret = unix_open(name + 4, O_RDWR \| O_CLOEXEC);

adb/socket_spec.cpp

0 → 100644

+220 −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.
		*/

		#include "socket_spec.h"

		#include <string>
		#include <unordered_map>
		#include <vector>

		#include <android-base/stringprintf.h>
		#include <android-base/strings.h>
		#include <cutils/sockets.h>

		#include "adb.h"
		#include "sysdeps.h"

		using android::base::StartsWith;
		using android::base::StringPrintf;

		#if defined(__linux__)
		#define ADB_LINUX 1
		#else
		#define ADB_LINUX 0
		#endif

		#if defined(_WIN32)
		#define ADB_WINDOWS 1
		#else
		#define ADB_WINDOWS 0
		#endif

		// Not static because it is used in commandline.c.
		int gListenAll = 0;

		struct LocalSocketType {
		int socket_namespace;
		bool available;
		};

		static auto& kLocalSocketTypes = *new std::unordered_map<std::string, LocalSocketType>({
		#if ADB_HOST
		{ "local", { ANDROID_SOCKET_NAMESPACE_FILESYSTEM, !ADB_WINDOWS } },
		#else
		{ "local", { ANDROID_SOCKET_NAMESPACE_RESERVED, !ADB_WINDOWS } },
		#endif

		{ "localreserved", { ANDROID_SOCKET_NAMESPACE_RESERVED, !ADB_HOST } },
		{ "localabstract", { ANDROID_SOCKET_NAMESPACE_ABSTRACT, ADB_LINUX } },
		{ "localfilesystem", { ANDROID_SOCKET_NAMESPACE_FILESYSTEM, !ADB_WINDOWS } },
		});

		static bool parse_tcp_spec(const std::string& spec, std::string* hostname, int* port,
		std::string* error) {
		std::vector<std::string> fragments = android::base::Split(spec, ":");
		if (fragments.size() == 1 \|\| fragments.size() > 3) {
		*error = StringPrintf("invalid tcp specification: '%s'", spec.c_str());
		return false;
		}

		if (fragments[0] != "tcp") {
		*error = StringPrintf("specification is not tcp: '%s'", spec.c_str());
		return false;
		}

		// strtol accepts leading whitespace.
		const std::string& port_str = fragments.back();
		if (port_str.empty() \|\| port_str[0] < '0' \|\| port_str[0] > '9') {
		*error = StringPrintf("invalid port '%s'", port_str.c_str());
		return false;
		}

		char* parsed_end;
		long parsed_port = strtol(port_str.c_str(), &parsed_end, 10);
		if (*parsed_end != '\0') {
		*error = StringPrintf("trailing chars in port: '%s'", port_str.c_str());
		return false;
		}
		if (parsed_port > 65535) {
		*error = StringPrintf("invalid port %ld", parsed_port);
		return false;
		}

		// tcp:123 is valid, tcp::123 isn't.
		if (fragments.size() == 2) {
		// Empty hostname.
		if (hostname) {
		*hostname = "";
		}
		} else {
		if (fragments[1].empty()) {
		*error = StringPrintf("empty host in '%s'", spec.c_str());
		return false;
		}
		if (hostname) {
		*hostname = fragments[1];
		}
		}

		if (port) {
		*port = parsed_port;
		}

		return true;
		}

		static bool tcp_host_is_local(const std::string& hostname) {
		// FIXME
		return hostname.empty() \|\| hostname == "localhost";
		}

		bool is_socket_spec(const std::string& spec) {
		for (const auto& it : kLocalSocketTypes) {
		std::string prefix = it.first + ":";
		if (StartsWith(spec, prefix.c_str())) {
		return true;
		}
		}
		return StartsWith(spec, "tcp:");
		}

		int socket_spec_connect(const std::string& spec, std::string* error) {
		if (StartsWith(spec, "tcp:")) {
		std::string hostname;
		int port;
		if (!parse_tcp_spec(spec, &hostname, &port, error)) {
		return -1;
		}

		int result;
		if (tcp_host_is_local(hostname)) {
		result = network_loopback_client(port, SOCK_STREAM, error);
		} else {
		#if ADB_HOST
		result = network_connect(hostname, port, SOCK_STREAM, 0, error);
		#else
		// Disallow arbitrary connections in adbd.
		*error = "adbd does not support arbitrary tcp connections";
		return -1;
		#endif
		}

		if (result >= 0) {
		disable_tcp_nagle(result);
		}
		return result;
		}

		for (const auto& it : kLocalSocketTypes) {
		std::string prefix = it.first + ":";
		if (StartsWith(spec, prefix.c_str())) {
		if (!it.second.available) {
		*error = StringPrintf("socket type %s is unavailable on this platform",
		it.first.c_str());
		return -1;
		}

		return network_local_client(&spec[prefix.length()], it.second.socket_namespace,
		SOCK_STREAM, error);
		}
		}

		*error = StringPrintf("unknown socket specification '%s'", spec.c_str());
		return -1;
		}

		int socket_spec_listen(const std::string& spec, std::string* error, int* resolved_tcp_port) {
		if (StartsWith(spec, "tcp:")) {
		std::string hostname;
		int port;
		if (!parse_tcp_spec(spec, &hostname, &port, error)) {
		return -1;
		}

		int result;
		if (hostname.empty() && gListenAll) {
		result = network_inaddr_any_server(port, SOCK_STREAM, error);
		} else if (tcp_host_is_local(hostname)) {
		result = network_loopback_server(port, SOCK_STREAM, error);
		} else {
		// TODO: Implement me.
		*error = "listening on specified hostname currently unsupported";
		return -1;
		}

		if (result >= 0 && port == 0 && resolved_tcp_port) {
		*resolved_tcp_port = adb_socket_get_local_port(result);
		}
		return result;
		}

		for (const auto& it : kLocalSocketTypes) {
		std::string prefix = it.first + ":";
		if (StartsWith(spec, prefix.c_str())) {
		if (!it.second.available) {
		*error = StringPrintf("attempted to listen on unavailable socket type: '%s'",
		spec.c_str());
		return -1;
		}

		return network_local_server(&spec[prefix.length()], it.second.socket_namespace,
		SOCK_STREAM, error);
		}
		}

		*error = StringPrintf("unknown socket specification '%s'", spec.c_str());
		return -1;
		}

adb/socket_spec.h

0 → 100644

+26 −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.
		*/

		#pragma once

		#include <string>

		// Returns true if the argument starts with a plausible socket prefix.
		bool is_socket_spec(const std::string& spec);

		int socket_spec_connect(const std::string& spec, std::string* error);
		int socket_spec_listen(const std::string& spec, std::string* error,
		int* resolved_tcp_port = nullptr);