diff --git a/adb/Android.mk b/adb/Android.mk index bf9fc654e..0a9c454b4 100644 --- a/adb/Android.mk +++ b/adb/Android.mk @@ -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 \ diff --git a/adb/adb_listeners.cpp b/adb/adb_listeners.cpp index 0299be3d3..18b14923c 100644 --- a/adb/adb_listeners.cpp +++ b/adb/adb_listeners.cpp @@ -23,12 +23,10 @@ #include #include +#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 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()); diff --git a/adb/services.cpp b/adb/services.cpp index 3b212e9c8..2207a3eaf 100644 --- a/adb/services.cpp +++ b/adb/services.cpp @@ -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) { - 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 + if (is_socket_spec(name)) { + std::string error; + 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); diff --git a/adb/socket_spec.cpp b/adb/socket_spec.cpp new file mode 100644 index 000000000..f8bbbb325 --- /dev/null +++ b/adb/socket_spec.cpp @@ -0,0 +1,220 @@ +/* + * 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 +#include +#include + +#include +#include +#include + +#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({ +#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 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; +} diff --git a/adb/socket_spec.h b/adb/socket_spec.h new file mode 100644 index 000000000..69efb07c2 --- /dev/null +++ b/adb/socket_spec.h @@ -0,0 +1,26 @@ +/* + * 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 + +// 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); diff --git a/adb/sysdeps.h b/adb/sysdeps.h index 322f99256..8d99722b5 100644 --- a/adb/sysdeps.h +++ b/adb/sysdeps.h @@ -277,6 +277,15 @@ static __inline__ void adb_sleep_ms( int mseconds ) int network_loopback_client(int port, int type, std::string* error); int network_loopback_server(int port, int type, std::string* error); int network_inaddr_any_server(int port, int type, std::string* error); + +inline int network_local_client(const char* name, int namespace_id, int type, std::string* error) { + abort(); +} + +inline int network_local_server(const char* name, int namespace_id, int type, std::string* error) { + abort(); +} + int network_connect(const std::string& host, int port, int type, int timeout, std::string* error); @@ -638,10 +647,12 @@ inline int network_inaddr_any_server(int port, int type, std::string* error) { return _fd_set_error_str(socket_inaddr_any_server(port, type), error); } -inline int network_local_server(const char *name, int namespace_id, int type, - std::string* error) { - return _fd_set_error_str(socket_local_server(name, namespace_id, type), - error); +inline int network_local_client(const char* name, int namespace_id, int type, std::string* error) { + return _fd_set_error_str(socket_local_client(name, namespace_id, type), error); +} + +inline int network_local_server(const char* name, int namespace_id, int type, std::string* error) { + return _fd_set_error_str(socket_local_server(name, namespace_id, type), error); } inline int network_connect(const std::string& host, int port, int type,