tequilaOS/platform_system_core
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Merge "Combine tcp_connect and socket_spec_connect."

Browse source
This commit is contained in:
Cody Schuffelen 2019-01-18 02:28:50 +00:00 committed by Gerrit Code Review
commit 539c4d427b
6 changed files with 79 additions and 83 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

26
adb/client/adb_client.cpp
View file

@ -144,53 +144,51 @@ static int _adb_connect(const std::string& service, std::string* error) {
}
std::string reason;
int fd = socket_spec_connect(__adb_server_socket_spec, &reason);
if (fd < 0) {
unique_fd fd;
if (!socket_spec_connect(&fd, __adb_server_socket_spec, nullptr, nullptr, &reason)) {
*error = android::base::StringPrintf("cannot connect to daemon at %s: %s",
__adb_server_socket_spec, reason.c_str());
return -2;
}
if (memcmp(&service[0], "host", 4) != 0 && switch_socket_transport(fd, error)) {
if (memcmp(&service[0], "host", 4) != 0 && switch_socket_transport(fd.get(), error)) {
return -1;
}
if (!SendProtocolString(fd, service)) {
if (!SendProtocolString(fd.get(), service)) {
*error = perror_str("write failure during connection");
adb_close(fd);
return -1;
}
if (!adb_status(fd, error)) {
adb_close(fd);
if (!adb_status(fd.get(), error)) {
return -1;
}
D("_adb_connect: return fd %d", fd);
return fd;
D("_adb_connect: return fd %d", fd.get());
return fd.release();
}
bool adb_kill_server() {
D("adb_kill_server");
std::string reason;
int fd = socket_spec_connect(__adb_server_socket_spec, &reason);
if (fd < 0) {
unique_fd fd;
if (!socket_spec_connect(&fd, __adb_server_socket_spec, nullptr, nullptr, &reason)) {
fprintf(stderr, "cannot connect to daemon at %s: %s\n", __adb_server_socket_spec,
reason.c_str());
return true;
}
if (!SendProtocolString(fd, "host:kill")) {
if (!SendProtocolString(fd.get(), "host:kill")) {
fprintf(stderr, "error: write failure during connection: %s\n", strerror(errno));
return false;
}
// The server might send OKAY, so consume that.
char buf[4];
ReadFdExactly(fd, buf, 4);
ReadFdExactly(fd.get(), buf, 4);
// Now that no more data is expected, wait for socket orderly shutdown or error, indicating
// server death.
ReadOrderlyShutdown(fd);
ReadOrderlyShutdown(fd.get());
return true;
}

9
adb/services.cpp
View file

@ -72,24 +72,23 @@ unique_fd create_service_thread(const char* service_name, std::function<void(uni
}
int service_to_fd(std::string_view name, atransport* transport) {
int ret = -1;
unique_fd ret;
if (is_socket_spec(name)) {
std::string error;
ret = socket_spec_connect(name, &error);
if (ret < 0) {
if (!socket_spec_connect(&ret, name, nullptr, nullptr, &error)) {
LOG(ERROR) << "failed to connect to socket '" << name << "': " << error;
}
} else {
#if !ADB_HOST
ret = daemon_service_to_fd(name, transport).release();
ret = daemon_service_to_fd(name, transport);
#endif
}
if (ret >= 0) {
close_on_exec(ret);
}
return ret;
return ret.release();
}
#if ADB_HOST

49
adb/socket_spec.cpp
View file

@ -67,7 +67,7 @@ static auto& kLocalSocketTypes = *new std::unordered_map<std::string, LocalSocke
});
bool parse_tcp_socket_spec(std::string_view spec, std::string* hostname, int* port,
std::string* error) {
std::string* serial, std::string* error) {
if (!spec.starts_with("tcp:")) {
*error = "specification is not tcp: ";
*error += spec;
@ -92,7 +92,7 @@ bool parse_tcp_socket_spec(std::string_view spec, std::string* hostname, int* po
// FIXME: ParseNetAddress rejects port 0. This currently doesn't hurt, because listening
// on an address that isn't 'localhost' is unsupported.
if (!android::base::ParseNetAddress(addr, &hostname_value, &port_value, nullptr, error)) {
if (!android::base::ParseNetAddress(addr, &hostname_value, &port_value, serial, error)) {
return false;
}
@ -139,63 +139,68 @@ bool is_local_socket_spec(std::string_view spec) {
std::string error;
std::string hostname;
if (!parse_tcp_socket_spec(spec, &hostname, nullptr, &error)) {
if (!parse_tcp_socket_spec(spec, &hostname, nullptr, nullptr, &error)) {
return false;
}
return tcp_host_is_local(hostname);
}
int socket_spec_connect(std::string_view spec, std::string* error) {
if (spec.starts_with("tcp:")) {
bool socket_spec_connect(unique_fd* fd, std::string_view address, int* port, std::string* serial,
std::string* error) {
if (address.starts_with("tcp:")) {
std::string hostname;
int port;
if (!parse_tcp_socket_spec(spec, &hostname, &port, error)) {
return -1;
int port_value = port ? *port : 0;
if (!parse_tcp_socket_spec(address, &hostname, &port_value, serial, error)) {
return false;
}
int result;
if (tcp_host_is_local(hostname)) {
result = network_loopback_client(port, SOCK_STREAM, error);
fd->reset(network_loopback_client(port_value, SOCK_STREAM, error));
} else {
#if ADB_HOST
result = network_connect(hostname, port, SOCK_STREAM, 0, error);
fd->reset(network_connect(hostname, port_value, SOCK_STREAM, 0, error));
#else
// Disallow arbitrary connections in adbd.
*error = "adbd does not support arbitrary tcp connections";
return -1;
return false;
#endif
}
if (result >= 0) {
disable_tcp_nagle(result);
if (fd->get() > 0) {
disable_tcp_nagle(fd->get());
if (port) {
*port = port_value;
}
return true;
}
return result;
return false;
}
for (const auto& it : kLocalSocketTypes) {
std::string prefix = it.first + ":";
if (spec.starts_with(prefix)) {
if (address.starts_with(prefix)) {
if (!it.second.available) {
*error = StringPrintf("socket type %s is unavailable on this platform",
it.first.c_str());
return -1;
return false;
}
return network_local_client(&spec[prefix.length()], it.second.socket_namespace,
SOCK_STREAM, error);
fd->reset(network_local_client(&address[prefix.length()], it.second.socket_namespace,
SOCK_STREAM, error));
return true;
}
}
*error = "unknown socket specification: ";
*error += spec;
return -1;
*error += address;
return false;
}
int socket_spec_listen(std::string_view spec, std::string* error, int* resolved_tcp_port) {
if (spec.starts_with("tcp:")) {
std::string hostname;
int port;
if (!parse_tcp_socket_spec(spec, &hostname, &port, error)) {
if (!parse_tcp_socket_spec(spec, &hostname, &port, nullptr, error)) {
return -1;
}

8
adb/socket_spec.h
View file

@ -17,14 +17,18 @@
#pragma once
#include <string>
#include <tuple>
#include "adb_unique_fd.h"
// Returns true if the argument starts with a plausible socket prefix.
bool is_socket_spec(std::string_view spec);
bool is_local_socket_spec(std::string_view spec);
int socket_spec_connect(std::string_view spec, std::string* error);
bool socket_spec_connect(unique_fd* fd, std::string_view address, int* port, std::string* serial,
std::string* error);
int socket_spec_listen(std::string_view spec, std::string* error, int* resolved_tcp_port = nullptr);
// Exposed for testing.
bool parse_tcp_socket_spec(std::string_view spec, std::string* hostname, int* port,
std::string* error);
std::string* serial, std::string* error);

35
adb/socket_spec_test.cpp
View file

@ -21,34 +21,37 @@
#include <gtest/gtest.h>
TEST(socket_spec, parse_tcp_socket_spec) {
std::string hostname, error;
std::string hostname, error, serial;
int port;
EXPECT_TRUE(parse_tcp_socket_spec("tcp:5037", &hostname, &port, &error));
EXPECT_TRUE(parse_tcp_socket_spec("tcp:5037", &hostname, &port, &serial, &error));
EXPECT_EQ("", hostname);
EXPECT_EQ(5037, port);
EXPECT_EQ("", serial);
// Bad ports:
EXPECT_FALSE(parse_tcp_socket_spec("tcp:", &hostname, &port, &error));
EXPECT_FALSE(parse_tcp_socket_spec("tcp:-1", &hostname, &port, &error));
EXPECT_FALSE(parse_tcp_socket_spec("tcp:65536", &hostname, &port, &error));
EXPECT_FALSE(parse_tcp_socket_spec("tcp:", &hostname, &port, &serial, &error));
EXPECT_FALSE(parse_tcp_socket_spec("tcp:-1", &hostname, &port, &serial, &error));
EXPECT_FALSE(parse_tcp_socket_spec("tcp:65536", &hostname, &port, &serial, &error));
EXPECT_TRUE(parse_tcp_socket_spec("tcp:localhost:1234", &hostname, &port, &error));
EXPECT_TRUE(parse_tcp_socket_spec("tcp:localhost:1234", &hostname, &port, &serial, &error));
EXPECT_EQ("localhost", hostname);
EXPECT_EQ(1234, port);
EXPECT_EQ("localhost:1234", serial);
EXPECT_FALSE(parse_tcp_socket_spec("tcp:localhost", &hostname, &port, &error));
EXPECT_FALSE(parse_tcp_socket_spec("tcp:localhost:", &hostname, &port, &error));
EXPECT_FALSE(parse_tcp_socket_spec("tcp:localhost:-1", &hostname, &port, &error));
EXPECT_FALSE(parse_tcp_socket_spec("tcp:localhost:65536", &hostname, &port, &error));
EXPECT_FALSE(parse_tcp_socket_spec("tcp:localhost", &hostname, &port, &serial, &error));
EXPECT_FALSE(parse_tcp_socket_spec("tcp:localhost:", &hostname, &port, &serial, &error));
EXPECT_FALSE(parse_tcp_socket_spec("tcp:localhost:-1", &hostname, &port, &serial, &error));
EXPECT_FALSE(parse_tcp_socket_spec("tcp:localhost:65536", &hostname, &port, &serial, &error));
// IPv6:
EXPECT_TRUE(parse_tcp_socket_spec("tcp:[::1]:1234", &hostname, &port, &error));
EXPECT_TRUE(parse_tcp_socket_spec("tcp:[::1]:1234", &hostname, &port, &serial, &error));
EXPECT_EQ("::1", hostname);
EXPECT_EQ(1234, port);
EXPECT_EQ("[::1]:1234", serial);
EXPECT_FALSE(parse_tcp_socket_spec("tcp:[::1]", &hostname, &port, &error));
EXPECT_FALSE(parse_tcp_socket_spec("tcp:[::1]:", &hostname, &port, &error));
EXPECT_FALSE(parse_tcp_socket_spec("tcp:[::1]:-1", &hostname, &port, &error));
EXPECT_FALSE(parse_tcp_socket_spec("tcp:::1", &hostname, &port, &error));
EXPECT_FALSE(parse_tcp_socket_spec("tcp:::1:1234", &hostname, &port, &error));
EXPECT_FALSE(parse_tcp_socket_spec("tcp:[::1]", &hostname, &port, &serial, &error));
EXPECT_FALSE(parse_tcp_socket_spec("tcp:[::1]:", &hostname, &port, &serial, &error));
EXPECT_FALSE(parse_tcp_socket_spec("tcp:[::1]:-1", &hostname, &port, &serial, &error));
EXPECT_FALSE(parse_tcp_socket_spec("tcp:::1", &hostname, &port, &serial, &error));
EXPECT_FALSE(parse_tcp_socket_spec("tcp:::1:1234", &hostname, &port, &serial, &error));
}

35
adb/transport_local.cpp
View file

@ -45,6 +45,7 @@
#include "adb_io.h"
#include "adb_unique_fd.h"
#include "adb_utils.h"
#include "socket_spec.h"
#include "sysdeps/chrono.h"
#if ADB_HOST
@ -70,32 +71,17 @@ bool local_connect(int port) {
std::tuple<unique_fd, int, std::string> tcp_connect(const std::string& address,
std::string* response) {
std::string serial;
std::string host;
unique_fd fd;
int port = DEFAULT_ADB_LOCAL_TRANSPORT_PORT;
if (!android::base::ParseNetAddress(address, &host, &port, &serial, response)) {
D("failed to parse address: '%s'", address.c_str());
return std::make_tuple(unique_fd(), port, serial);
}
std::string error;
unique_fd fd(network_connect(host.c_str(), port, SOCK_STREAM, 10, &error));
if (fd == -1) {
*response = android::base::StringPrintf("unable to connect to %s: %s",
serial.c_str(), error.c_str());
std::string serial;
if (socket_spec_connect(&fd, "tcp:" + address, &port, &serial, response)) {
close_on_exec(fd);
if (!set_tcp_keepalive(fd, 1)) {
D("warning: failed to configure TCP keepalives (%s)", strerror(errno));
}
return std::make_tuple(std::move(fd), port, serial);
}
D("client: connected %s remote on fd %d", serial.c_str(), fd.get());
close_on_exec(fd);
disable_tcp_nagle(fd);
// Send a TCP keepalive ping to the device every second so we can detect disconnects.
if (!set_tcp_keepalive(fd, 1)) {
D("warning: failed to configure TCP keepalives (%s)", strerror(errno));
}
return std::make_tuple(std::move(fd), port, serial);
return std::make_tuple(unique_fd(), 0, "");
}
void connect_device(const std::string& address, std::string* response) {
@ -251,8 +237,9 @@ static void server_socket_thread(int port) {
adb_thread_setname("server socket");
D("transport: server_socket_thread() starting");
while (serverfd == -1) {
std::string spec = android::base::StringPrintf("tcp:%d", port);
std::string error;
serverfd.reset(network_inaddr_any_server(port, SOCK_STREAM, &error));
serverfd.reset(socket_spec_listen(spec, &error));
if (serverfd < 0) {
D("server: cannot bind socket yet: %s", error.c_str());
std::this_thread::sleep_for(1s);