921 lines
28 KiB
C++
921 lines
28 KiB
C++
/*
|
|
* Copyright (C) 2007 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.
|
|
*/
|
|
|
|
#define TRACE_TAG SOCKETS
|
|
|
|
#include "sysdeps.h"
|
|
|
|
#include <ctype.h>
|
|
#include <errno.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
|
|
#include <algorithm>
|
|
#include <chrono>
|
|
#include <mutex>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#include <android-base/strings.h>
|
|
|
|
#if !ADB_HOST
|
|
#include <android-base/properties.h>
|
|
#include <log/log_properties.h>
|
|
#endif
|
|
|
|
#include "adb.h"
|
|
#include "adb_io.h"
|
|
#include "adb_utils.h"
|
|
#include "transport.h"
|
|
#include "types.h"
|
|
|
|
using namespace std::chrono_literals;
|
|
|
|
static std::recursive_mutex& local_socket_list_lock = *new std::recursive_mutex();
|
|
static unsigned local_socket_next_id = 1;
|
|
|
|
static auto& local_socket_list = *new std::vector<asocket*>();
|
|
|
|
/* the the list of currently closing local sockets.
|
|
** these have no peer anymore, but still packets to
|
|
** write to their fd.
|
|
*/
|
|
static auto& local_socket_closing_list = *new std::vector<asocket*>();
|
|
|
|
// Parse the global list of sockets to find one with id |local_id|.
|
|
// If |peer_id| is not 0, also check that it is connected to a peer
|
|
// with id |peer_id|. Returns an asocket handle on success, NULL on failure.
|
|
asocket* find_local_socket(unsigned local_id, unsigned peer_id) {
|
|
asocket* result = nullptr;
|
|
|
|
std::lock_guard<std::recursive_mutex> lock(local_socket_list_lock);
|
|
for (asocket* s : local_socket_list) {
|
|
if (s->id != local_id) {
|
|
continue;
|
|
}
|
|
if (peer_id == 0 || (s->peer && s->peer->id == peer_id)) {
|
|
result = s;
|
|
}
|
|
break;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
void install_local_socket(asocket* s) {
|
|
std::lock_guard<std::recursive_mutex> lock(local_socket_list_lock);
|
|
|
|
s->id = local_socket_next_id++;
|
|
|
|
// Socket ids should never be 0.
|
|
if (local_socket_next_id == 0) {
|
|
LOG(FATAL) << "local socket id overflow";
|
|
}
|
|
|
|
local_socket_list.push_back(s);
|
|
}
|
|
|
|
void remove_socket(asocket* s) {
|
|
std::lock_guard<std::recursive_mutex> lock(local_socket_list_lock);
|
|
for (auto list : { &local_socket_list, &local_socket_closing_list }) {
|
|
list->erase(std::remove_if(list->begin(), list->end(), [s](asocket* x) { return x == s; }),
|
|
list->end());
|
|
}
|
|
}
|
|
|
|
void close_all_sockets(atransport* t) {
|
|
/* this is a little gross, but since s->close() *will* modify
|
|
** the list out from under you, your options are limited.
|
|
*/
|
|
std::lock_guard<std::recursive_mutex> lock(local_socket_list_lock);
|
|
restart:
|
|
for (asocket* s : local_socket_list) {
|
|
if (s->transport == t || (s->peer && s->peer->transport == t)) {
|
|
s->close(s);
|
|
goto restart;
|
|
}
|
|
}
|
|
}
|
|
|
|
enum class SocketFlushResult {
|
|
Destroyed,
|
|
TryAgain,
|
|
Completed,
|
|
};
|
|
|
|
static SocketFlushResult local_socket_flush_incoming(asocket* s) {
|
|
if (!s->packet_queue.empty()) {
|
|
std::vector<adb_iovec> iov = s->packet_queue.iovecs();
|
|
ssize_t rc = adb_writev(s->fd, iov.data(), iov.size());
|
|
if (rc > 0 && static_cast<size_t>(rc) == s->packet_queue.size()) {
|
|
s->packet_queue.clear();
|
|
} else if (rc > 0) {
|
|
s->packet_queue.drop_front(rc);
|
|
fdevent_add(s->fde, FDE_WRITE);
|
|
return SocketFlushResult::TryAgain;
|
|
} else if (rc == -1 && errno == EAGAIN) {
|
|
fdevent_add(s->fde, FDE_WRITE);
|
|
return SocketFlushResult::TryAgain;
|
|
} else {
|
|
// We failed to write, but it's possible that we can still read from the socket.
|
|
// Give that a try before giving up.
|
|
s->has_write_error = true;
|
|
}
|
|
}
|
|
|
|
// If we sent the last packet of a closing socket, we can now destroy it.
|
|
if (s->closing) {
|
|
s->close(s);
|
|
return SocketFlushResult::Destroyed;
|
|
}
|
|
|
|
fdevent_del(s->fde, FDE_WRITE);
|
|
return SocketFlushResult::Completed;
|
|
}
|
|
|
|
// Returns false if the socket has been closed and destroyed as a side-effect of this function.
|
|
static bool local_socket_flush_outgoing(asocket* s) {
|
|
const size_t max_payload = s->get_max_payload();
|
|
apacket::payload_type data;
|
|
data.resize(max_payload);
|
|
char* x = &data[0];
|
|
size_t avail = max_payload;
|
|
int r = 0;
|
|
int is_eof = 0;
|
|
|
|
while (avail > 0) {
|
|
r = adb_read(s->fd, x, avail);
|
|
D("LS(%d): post adb_read(fd=%d,...) r=%d (errno=%d) avail=%zu", s->id, s->fd, r,
|
|
r < 0 ? errno : 0, avail);
|
|
if (r == -1) {
|
|
if (errno == EAGAIN) {
|
|
break;
|
|
}
|
|
} else if (r > 0) {
|
|
avail -= r;
|
|
x += r;
|
|
continue;
|
|
}
|
|
|
|
/* r = 0 or unhandled error */
|
|
is_eof = 1;
|
|
break;
|
|
}
|
|
D("LS(%d): fd=%d post avail loop. r=%d is_eof=%d forced_eof=%d", s->id, s->fd, r, is_eof,
|
|
s->fde->force_eof);
|
|
|
|
if (avail != max_payload && s->peer) {
|
|
data.resize(max_payload - avail);
|
|
|
|
// s->peer->enqueue() may call s->close() and free s,
|
|
// so save variables for debug printing below.
|
|
unsigned saved_id = s->id;
|
|
int saved_fd = s->fd;
|
|
r = s->peer->enqueue(s->peer, std::move(data));
|
|
D("LS(%u): fd=%d post peer->enqueue(). r=%d", saved_id, saved_fd, r);
|
|
|
|
if (r < 0) {
|
|
// Error return means they closed us as a side-effect and we must
|
|
// return immediately.
|
|
//
|
|
// Note that if we still have buffered packets, the socket will be
|
|
// placed on the closing socket list. This handler function will be
|
|
// called again to process FDE_WRITE events.
|
|
return false;
|
|
}
|
|
|
|
if (r > 0) {
|
|
/* if the remote cannot accept further events,
|
|
** we disable notification of READs. They'll
|
|
** be enabled again when we get a call to ready()
|
|
*/
|
|
fdevent_del(s->fde, FDE_READ);
|
|
}
|
|
}
|
|
|
|
// Don't allow a forced eof if data is still there.
|
|
if ((s->fde->force_eof && !r) || is_eof) {
|
|
D(" closing because is_eof=%d r=%d s->fde.force_eof=%d", is_eof, r, s->fde->force_eof);
|
|
s->close(s);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static int local_socket_enqueue(asocket* s, apacket::payload_type data) {
|
|
D("LS(%d): enqueue %zu", s->id, data.size());
|
|
|
|
s->packet_queue.append(std::move(data));
|
|
switch (local_socket_flush_incoming(s)) {
|
|
case SocketFlushResult::Destroyed:
|
|
return -1;
|
|
|
|
case SocketFlushResult::TryAgain:
|
|
return 1;
|
|
|
|
case SocketFlushResult::Completed:
|
|
return 0;
|
|
}
|
|
|
|
return !s->packet_queue.empty();
|
|
}
|
|
|
|
static void local_socket_ready(asocket* s) {
|
|
/* far side is ready for data, pay attention to
|
|
readable events */
|
|
fdevent_add(s->fde, FDE_READ);
|
|
}
|
|
|
|
struct ClosingSocket {
|
|
std::chrono::steady_clock::time_point begin;
|
|
};
|
|
|
|
// The standard (RFC 1122 - 4.2.2.13) says that if we call close on a
|
|
// socket while we have pending data, a TCP RST should be sent to the
|
|
// other end to notify it that we didn't read all of its data. However,
|
|
// this can result in data that we've successfully written out to be dropped
|
|
// on the other end. To avoid this, instead of immediately closing a
|
|
// socket, call shutdown on it instead, and then read from the file
|
|
// descriptor until we hit EOF or an error before closing.
|
|
static void deferred_close(unique_fd fd) {
|
|
// Shutdown the socket in the outgoing direction only, so that
|
|
// we don't have the same problem on the opposite end.
|
|
adb_shutdown(fd.get(), SHUT_WR);
|
|
auto callback = [](fdevent* fde, unsigned event, void* arg) {
|
|
auto socket_info = static_cast<ClosingSocket*>(arg);
|
|
if (event & FDE_READ) {
|
|
ssize_t rc;
|
|
char buf[BUFSIZ];
|
|
while ((rc = adb_read(fde->fd.get(), buf, sizeof(buf))) > 0) {
|
|
continue;
|
|
}
|
|
|
|
if (rc == -1 && errno == EAGAIN) {
|
|
// There's potentially more data to read.
|
|
auto duration = std::chrono::steady_clock::now() - socket_info->begin;
|
|
if (duration > 1s) {
|
|
LOG(WARNING) << "timeout expired while flushing socket, closing";
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
} else if (event & FDE_TIMEOUT) {
|
|
LOG(WARNING) << "timeout expired while flushing socket, closing";
|
|
}
|
|
|
|
// Either there was an error, we hit the end of the socket, or our timeout expired.
|
|
fdevent_destroy(fde);
|
|
delete socket_info;
|
|
};
|
|
|
|
ClosingSocket* socket_info = new ClosingSocket{
|
|
.begin = std::chrono::steady_clock::now(),
|
|
};
|
|
|
|
fdevent* fde = fdevent_create(fd.release(), callback, socket_info);
|
|
fdevent_add(fde, FDE_READ);
|
|
fdevent_set_timeout(fde, 1s);
|
|
}
|
|
|
|
// be sure to hold the socket list lock when calling this
|
|
static void local_socket_destroy(asocket* s) {
|
|
int exit_on_close = s->exit_on_close;
|
|
|
|
D("LS(%d): destroying fde.fd=%d", s->id, s->fd);
|
|
|
|
deferred_close(fdevent_release(s->fde));
|
|
|
|
remove_socket(s);
|
|
delete s;
|
|
|
|
if (exit_on_close) {
|
|
D("local_socket_destroy: exiting");
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
static void local_socket_close(asocket* s) {
|
|
D("entered local_socket_close. LS(%d) fd=%d", s->id, s->fd);
|
|
std::lock_guard<std::recursive_mutex> lock(local_socket_list_lock);
|
|
if (s->peer) {
|
|
D("LS(%d): closing peer. peer->id=%d peer->fd=%d", s->id, s->peer->id, s->peer->fd);
|
|
/* Note: it's important to call shutdown before disconnecting from
|
|
* the peer, this ensures that remote sockets can still get the id
|
|
* of the local socket they're connected to, to send a CLOSE()
|
|
* protocol event. */
|
|
if (s->peer->shutdown) {
|
|
s->peer->shutdown(s->peer);
|
|
}
|
|
s->peer->peer = nullptr;
|
|
s->peer->close(s->peer);
|
|
s->peer = nullptr;
|
|
}
|
|
|
|
/* If we are already closing, or if there are no
|
|
** pending packets, destroy immediately
|
|
*/
|
|
if (s->closing || s->has_write_error || s->packet_queue.empty()) {
|
|
int id = s->id;
|
|
local_socket_destroy(s);
|
|
D("LS(%d): closed", id);
|
|
return;
|
|
}
|
|
|
|
/* otherwise, put on the closing list
|
|
*/
|
|
D("LS(%d): closing", s->id);
|
|
s->closing = 1;
|
|
fdevent_del(s->fde, FDE_READ);
|
|
remove_socket(s);
|
|
D("LS(%d): put on socket_closing_list fd=%d", s->id, s->fd);
|
|
local_socket_closing_list.push_back(s);
|
|
CHECK_EQ(FDE_WRITE, s->fde->state & FDE_WRITE);
|
|
}
|
|
|
|
static void local_socket_event_func(int fd, unsigned ev, void* _s) {
|
|
asocket* s = reinterpret_cast<asocket*>(_s);
|
|
D("LS(%d): event_func(fd=%d(==%d), ev=%04x)", s->id, s->fd, fd, ev);
|
|
|
|
/* put the FDE_WRITE processing before the FDE_READ
|
|
** in order to simplify the code.
|
|
*/
|
|
if (ev & FDE_WRITE) {
|
|
switch (local_socket_flush_incoming(s)) {
|
|
case SocketFlushResult::Destroyed:
|
|
return;
|
|
|
|
case SocketFlushResult::TryAgain:
|
|
break;
|
|
|
|
case SocketFlushResult::Completed:
|
|
s->peer->ready(s->peer);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (ev & FDE_READ) {
|
|
if (!local_socket_flush_outgoing(s)) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (ev & FDE_ERROR) {
|
|
/* this should be caught be the next read or write
|
|
** catching it here means we may skip the last few
|
|
** bytes of readable data.
|
|
*/
|
|
D("LS(%d): FDE_ERROR (fd=%d)", s->id, s->fd);
|
|
return;
|
|
}
|
|
}
|
|
|
|
asocket* create_local_socket(unique_fd ufd) {
|
|
int fd = ufd.release();
|
|
asocket* s = new asocket();
|
|
s->fd = fd;
|
|
s->enqueue = local_socket_enqueue;
|
|
s->ready = local_socket_ready;
|
|
s->shutdown = nullptr;
|
|
s->close = local_socket_close;
|
|
install_local_socket(s);
|
|
|
|
s->fde = fdevent_create(fd, local_socket_event_func, s);
|
|
D("LS(%d): created (fd=%d)", s->id, s->fd);
|
|
return s;
|
|
}
|
|
|
|
asocket* create_local_service_socket(std::string_view name, atransport* transport) {
|
|
#if !ADB_HOST
|
|
if (asocket* s = daemon_service_to_socket(name); s) {
|
|
return s;
|
|
}
|
|
#endif
|
|
unique_fd fd = service_to_fd(name, transport);
|
|
if (fd < 0) {
|
|
return nullptr;
|
|
}
|
|
|
|
int fd_value = fd.get();
|
|
asocket* s = create_local_socket(std::move(fd));
|
|
LOG(VERBOSE) << "LS(" << s->id << "): bound to '" << name << "' via " << fd_value;
|
|
|
|
#if !ADB_HOST
|
|
if ((name.starts_with("root:") && getuid() != 0 && __android_log_is_debuggable()) ||
|
|
(name.starts_with("unroot:") && getuid() == 0) || name.starts_with("usb:") ||
|
|
name.starts_with("tcpip:")) {
|
|
D("LS(%d): enabling exit_on_close", s->id);
|
|
s->exit_on_close = 1;
|
|
}
|
|
#endif
|
|
|
|
return s;
|
|
}
|
|
|
|
static int remote_socket_enqueue(asocket* s, apacket::payload_type data) {
|
|
D("entered remote_socket_enqueue RS(%d) WRITE fd=%d peer.fd=%d", s->id, s->fd, s->peer->fd);
|
|
apacket* p = get_apacket();
|
|
|
|
p->msg.command = A_WRTE;
|
|
p->msg.arg0 = s->peer->id;
|
|
p->msg.arg1 = s->id;
|
|
|
|
if (data.size() > MAX_PAYLOAD) {
|
|
put_apacket(p);
|
|
return -1;
|
|
}
|
|
|
|
p->payload = std::move(data);
|
|
p->msg.data_length = p->payload.size();
|
|
|
|
send_packet(p, s->transport);
|
|
return 1;
|
|
}
|
|
|
|
static void remote_socket_ready(asocket* s) {
|
|
D("entered remote_socket_ready RS(%d) OKAY fd=%d peer.fd=%d", s->id, s->fd, s->peer->fd);
|
|
apacket* p = get_apacket();
|
|
p->msg.command = A_OKAY;
|
|
p->msg.arg0 = s->peer->id;
|
|
p->msg.arg1 = s->id;
|
|
send_packet(p, s->transport);
|
|
}
|
|
|
|
static void remote_socket_shutdown(asocket* s) {
|
|
D("entered remote_socket_shutdown RS(%d) CLOSE fd=%d peer->fd=%d", s->id, s->fd,
|
|
s->peer ? s->peer->fd : -1);
|
|
apacket* p = get_apacket();
|
|
p->msg.command = A_CLSE;
|
|
if (s->peer) {
|
|
p->msg.arg0 = s->peer->id;
|
|
}
|
|
p->msg.arg1 = s->id;
|
|
send_packet(p, s->transport);
|
|
}
|
|
|
|
static void remote_socket_close(asocket* s) {
|
|
if (s->peer) {
|
|
s->peer->peer = nullptr;
|
|
D("RS(%d) peer->close()ing peer->id=%d peer->fd=%d", s->id, s->peer->id, s->peer->fd);
|
|
s->peer->close(s->peer);
|
|
}
|
|
D("entered remote_socket_close RS(%d) CLOSE fd=%d peer->fd=%d", s->id, s->fd,
|
|
s->peer ? s->peer->fd : -1);
|
|
D("RS(%d): closed", s->id);
|
|
delete s;
|
|
}
|
|
|
|
// Create a remote socket to exchange packets with a remote service through transport
|
|
// |t|. Where |id| is the socket id of the corresponding service on the other
|
|
// side of the transport (it is allocated by the remote side and _cannot_ be 0).
|
|
// Returns a new non-NULL asocket handle.
|
|
asocket* create_remote_socket(unsigned id, atransport* t) {
|
|
if (id == 0) {
|
|
LOG(FATAL) << "invalid remote socket id (0)";
|
|
}
|
|
asocket* s = new asocket();
|
|
s->id = id;
|
|
s->enqueue = remote_socket_enqueue;
|
|
s->ready = remote_socket_ready;
|
|
s->shutdown = remote_socket_shutdown;
|
|
s->close = remote_socket_close;
|
|
s->transport = t;
|
|
|
|
D("RS(%d): created", s->id);
|
|
return s;
|
|
}
|
|
|
|
void connect_to_remote(asocket* s, std::string_view destination) {
|
|
D("Connect_to_remote call RS(%d) fd=%d", s->id, s->fd);
|
|
apacket* p = get_apacket();
|
|
|
|
LOG(VERBOSE) << "LS(" << s->id << ": connect(" << destination << ")";
|
|
p->msg.command = A_OPEN;
|
|
p->msg.arg0 = s->id;
|
|
|
|
// adbd used to expect a null-terminated string.
|
|
// Keep doing so to maintain backward compatibility.
|
|
p->payload.resize(destination.size() + 1);
|
|
memcpy(p->payload.data(), destination.data(), destination.size());
|
|
p->payload[destination.size()] = '\0';
|
|
p->msg.data_length = p->payload.size();
|
|
|
|
CHECK_LE(p->msg.data_length, s->get_max_payload());
|
|
|
|
send_packet(p, s->transport);
|
|
}
|
|
|
|
#if ADB_HOST
|
|
/* this is used by magic sockets to rig local sockets to
|
|
send the go-ahead message when they connect */
|
|
static void local_socket_ready_notify(asocket* s) {
|
|
s->ready = local_socket_ready;
|
|
s->shutdown = nullptr;
|
|
s->close = local_socket_close;
|
|
SendOkay(s->fd);
|
|
s->ready(s);
|
|
}
|
|
|
|
/* this is used by magic sockets to rig local sockets to
|
|
send the failure message if they are closed before
|
|
connected (to avoid closing them without a status message) */
|
|
static void local_socket_close_notify(asocket* s) {
|
|
s->ready = local_socket_ready;
|
|
s->shutdown = nullptr;
|
|
s->close = local_socket_close;
|
|
SendFail(s->fd, "closed");
|
|
s->close(s);
|
|
}
|
|
|
|
static unsigned unhex(const char* s, int len) {
|
|
unsigned n = 0, c;
|
|
|
|
while (len-- > 0) {
|
|
switch ((c = *s++)) {
|
|
case '0':
|
|
case '1':
|
|
case '2':
|
|
case '3':
|
|
case '4':
|
|
case '5':
|
|
case '6':
|
|
case '7':
|
|
case '8':
|
|
case '9':
|
|
c -= '0';
|
|
break;
|
|
case 'a':
|
|
case 'b':
|
|
case 'c':
|
|
case 'd':
|
|
case 'e':
|
|
case 'f':
|
|
c = c - 'a' + 10;
|
|
break;
|
|
case 'A':
|
|
case 'B':
|
|
case 'C':
|
|
case 'D':
|
|
case 'E':
|
|
case 'F':
|
|
c = c - 'A' + 10;
|
|
break;
|
|
default:
|
|
return 0xffffffff;
|
|
}
|
|
|
|
n = (n << 4) | c;
|
|
}
|
|
|
|
return n;
|
|
}
|
|
|
|
namespace internal {
|
|
|
|
// Parses a host service string of the following format:
|
|
// * [tcp:|udp:]<serial>[:<port>]:<command>
|
|
// * <prefix>:<serial>:<command>
|
|
// Where <port> must be a base-10 number and <prefix> may be any of {usb,product,model,device}.
|
|
bool parse_host_service(std::string_view* out_serial, std::string_view* out_command,
|
|
std::string_view full_service) {
|
|
if (full_service.empty()) {
|
|
return false;
|
|
}
|
|
|
|
std::string_view serial;
|
|
std::string_view command = full_service;
|
|
// Remove |count| bytes from the beginning of command and add them to |serial|.
|
|
auto consume = [&full_service, &serial, &command](size_t count) {
|
|
CHECK_LE(count, command.size());
|
|
if (!serial.empty()) {
|
|
CHECK_EQ(serial.data() + serial.size(), command.data());
|
|
}
|
|
|
|
serial = full_service.substr(0, serial.size() + count);
|
|
command.remove_prefix(count);
|
|
};
|
|
|
|
// Remove the trailing : from serial, and assign the values to the output parameters.
|
|
auto finish = [out_serial, out_command, &serial, &command] {
|
|
if (serial.empty() || command.empty()) {
|
|
return false;
|
|
}
|
|
|
|
CHECK_EQ(':', serial.back());
|
|
serial.remove_suffix(1);
|
|
|
|
*out_serial = serial;
|
|
*out_command = command;
|
|
return true;
|
|
};
|
|
|
|
static constexpr std::string_view prefixes[] = {
|
|
"usb:", "product:", "model:", "device:", "localfilesystem:"};
|
|
for (std::string_view prefix : prefixes) {
|
|
if (command.starts_with(prefix)) {
|
|
consume(prefix.size());
|
|
|
|
size_t offset = command.find_first_of(':');
|
|
if (offset == std::string::npos) {
|
|
return false;
|
|
}
|
|
consume(offset + 1);
|
|
return finish();
|
|
}
|
|
}
|
|
|
|
// For fastboot compatibility, ignore protocol prefixes.
|
|
if (command.starts_with("tcp:") || command.starts_with("udp:")) {
|
|
consume(4);
|
|
if (command.empty()) {
|
|
return false;
|
|
}
|
|
}
|
|
if (command.starts_with("vsock:")) {
|
|
// vsock serials are vsock:cid:port, which have an extra colon compared to tcp.
|
|
size_t next_colon = command.find(':');
|
|
if (next_colon == std::string::npos) {
|
|
return false;
|
|
}
|
|
consume(next_colon + 1);
|
|
}
|
|
|
|
bool found_address = false;
|
|
if (command[0] == '[') {
|
|
// Read an IPv6 address. `adb connect` creates the serial number from the canonical
|
|
// network address so it will always have the [] delimiters.
|
|
size_t ipv6_end = command.find_first_of(']');
|
|
if (ipv6_end != std::string::npos) {
|
|
consume(ipv6_end + 1);
|
|
if (command.empty()) {
|
|
// Nothing after the IPv6 address.
|
|
return false;
|
|
} else if (command[0] != ':') {
|
|
// Garbage after the IPv6 address.
|
|
return false;
|
|
}
|
|
consume(1);
|
|
found_address = true;
|
|
}
|
|
}
|
|
|
|
if (!found_address) {
|
|
// Scan ahead to the next colon.
|
|
size_t offset = command.find_first_of(':');
|
|
if (offset == std::string::npos) {
|
|
return false;
|
|
}
|
|
consume(offset + 1);
|
|
}
|
|
|
|
// We're either at the beginning of a port, or the command itself.
|
|
// Look for a port in between colons.
|
|
size_t next_colon = command.find_first_of(':');
|
|
if (next_colon == std::string::npos) {
|
|
// No colon, we must be at the command.
|
|
return finish();
|
|
}
|
|
|
|
bool port_valid = true;
|
|
if (command.size() <= next_colon) {
|
|
return false;
|
|
}
|
|
|
|
std::string_view port = command.substr(0, next_colon);
|
|
for (auto digit : port) {
|
|
if (!isdigit(digit)) {
|
|
// Port isn't a number.
|
|
port_valid = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (port_valid) {
|
|
consume(next_colon + 1);
|
|
}
|
|
return finish();
|
|
}
|
|
|
|
} // namespace internal
|
|
|
|
static int smart_socket_enqueue(asocket* s, apacket::payload_type data) {
|
|
std::string_view service;
|
|
std::string_view serial;
|
|
TransportId transport_id = 0;
|
|
TransportType type = kTransportAny;
|
|
|
|
D("SS(%d): enqueue %zu", s->id, data.size());
|
|
|
|
if (s->smart_socket_data.empty()) {
|
|
// TODO: Make this an IOVector?
|
|
s->smart_socket_data.assign(data.begin(), data.end());
|
|
} else {
|
|
std::copy(data.begin(), data.end(), std::back_inserter(s->smart_socket_data));
|
|
}
|
|
|
|
/* don't bother if we can't decode the length */
|
|
if (s->smart_socket_data.size() < 4) {
|
|
return 0;
|
|
}
|
|
|
|
uint32_t len = unhex(s->smart_socket_data.data(), 4);
|
|
if (len == 0 || len > MAX_PAYLOAD) {
|
|
D("SS(%d): bad size (%u)", s->id, len);
|
|
goto fail;
|
|
}
|
|
|
|
D("SS(%d): len is %u", s->id, len);
|
|
/* can't do anything until we have the full header */
|
|
if ((len + 4) > s->smart_socket_data.size()) {
|
|
D("SS(%d): waiting for %zu more bytes", s->id, len + 4 - s->smart_socket_data.size());
|
|
return 0;
|
|
}
|
|
|
|
s->smart_socket_data[len + 4] = 0;
|
|
|
|
D("SS(%d): '%s'", s->id, (char*)(s->smart_socket_data.data() + 4));
|
|
|
|
service = std::string_view(s->smart_socket_data).substr(4);
|
|
|
|
// TODO: These should be handled in handle_host_request.
|
|
if (android::base::ConsumePrefix(&service, "host-serial:")) {
|
|
// serial number should follow "host:" and could be a host:port string.
|
|
if (!internal::parse_host_service(&serial, &service, service)) {
|
|
LOG(ERROR) << "SS(" << s->id << "): failed to parse host service: " << service;
|
|
goto fail;
|
|
}
|
|
} else if (android::base::ConsumePrefix(&service, "host-transport-id:")) {
|
|
if (!ParseUint(&transport_id, service, &service)) {
|
|
LOG(ERROR) << "SS(" << s->id << "): failed to parse host transport id: " << service;
|
|
return -1;
|
|
}
|
|
if (!android::base::ConsumePrefix(&service, ":")) {
|
|
LOG(ERROR) << "SS(" << s->id << "): host-transport-id without command";
|
|
return -1;
|
|
}
|
|
} else if (android::base::ConsumePrefix(&service, "host-usb:")) {
|
|
type = kTransportUsb;
|
|
} else if (android::base::ConsumePrefix(&service, "host-local:")) {
|
|
type = kTransportLocal;
|
|
} else if (android::base::ConsumePrefix(&service, "host:")) {
|
|
type = kTransportAny;
|
|
} else {
|
|
service = std::string_view{};
|
|
}
|
|
|
|
if (!service.empty()) {
|
|
asocket* s2;
|
|
|
|
// Some requests are handled immediately -- in that case the handle_host_request() routine
|
|
// has sent the OKAY or FAIL message and all we have to do is clean up.
|
|
auto host_request_result = handle_host_request(
|
|
service, type, serial.empty() ? nullptr : std::string(serial).c_str(), transport_id,
|
|
s->peer->fd, s);
|
|
|
|
switch (host_request_result) {
|
|
case HostRequestResult::Handled:
|
|
LOG(VERBOSE) << "SS(" << s->id << "): handled host service '" << service << "'";
|
|
goto fail;
|
|
|
|
case HostRequestResult::SwitchedTransport:
|
|
D("SS(%d): okay transport", s->id);
|
|
s->smart_socket_data.clear();
|
|
return 0;
|
|
|
|
case HostRequestResult::Unhandled:
|
|
break;
|
|
}
|
|
|
|
/* try to find a local service with this name.
|
|
** if no such service exists, we'll fail out
|
|
** and tear down here.
|
|
*/
|
|
// TODO: Convert to string_view.
|
|
s2 = host_service_to_socket(service, serial, transport_id);
|
|
if (s2 == nullptr) {
|
|
LOG(VERBOSE) << "SS(" << s->id << "): couldn't create host service '" << service << "'";
|
|
SendFail(s->peer->fd, "unknown host service");
|
|
goto fail;
|
|
}
|
|
|
|
/* we've connected to a local host service,
|
|
** so we make our peer back into a regular
|
|
** local socket and bind it to the new local
|
|
** service socket, acknowledge the successful
|
|
** connection, and close this smart socket now
|
|
** that its work is done.
|
|
*/
|
|
SendOkay(s->peer->fd);
|
|
|
|
s->peer->ready = local_socket_ready;
|
|
s->peer->shutdown = nullptr;
|
|
s->peer->close = local_socket_close;
|
|
s->peer->peer = s2;
|
|
s2->peer = s->peer;
|
|
s->peer = nullptr;
|
|
D("SS(%d): okay", s->id);
|
|
s->close(s);
|
|
|
|
/* initial state is "ready" */
|
|
s2->ready(s2);
|
|
return 0;
|
|
}
|
|
|
|
if (!s->transport) {
|
|
SendFail(s->peer->fd, "device offline (no transport)");
|
|
goto fail;
|
|
} else if (!ConnectionStateIsOnline(s->transport->GetConnectionState())) {
|
|
/* if there's no remote we fail the connection
|
|
** right here and terminate it
|
|
*/
|
|
SendFail(s->peer->fd, "device offline (transport offline)");
|
|
goto fail;
|
|
}
|
|
|
|
/* instrument our peer to pass the success or fail
|
|
** message back once it connects or closes, then
|
|
** detach from it, request the connection, and
|
|
** tear down
|
|
*/
|
|
s->peer->ready = local_socket_ready_notify;
|
|
s->peer->shutdown = nullptr;
|
|
s->peer->close = local_socket_close_notify;
|
|
s->peer->peer = nullptr;
|
|
/* give them our transport and upref it */
|
|
s->peer->transport = s->transport;
|
|
|
|
connect_to_remote(s->peer, std::string_view(s->smart_socket_data).substr(4));
|
|
s->peer = nullptr;
|
|
s->close(s);
|
|
return 1;
|
|
|
|
fail:
|
|
/* we're going to close our peer as a side-effect, so
|
|
** return -1 to signal that state to the local socket
|
|
** who is enqueueing against us
|
|
*/
|
|
s->close(s);
|
|
return -1;
|
|
}
|
|
|
|
static void smart_socket_ready(asocket* s) {
|
|
D("SS(%d): ready", s->id);
|
|
}
|
|
|
|
static void smart_socket_close(asocket* s) {
|
|
D("SS(%d): closed", s->id);
|
|
if (s->peer) {
|
|
s->peer->peer = nullptr;
|
|
s->peer->close(s->peer);
|
|
s->peer = nullptr;
|
|
}
|
|
delete s;
|
|
}
|
|
|
|
static asocket* create_smart_socket(void) {
|
|
D("Creating smart socket");
|
|
asocket* s = new asocket();
|
|
s->enqueue = smart_socket_enqueue;
|
|
s->ready = smart_socket_ready;
|
|
s->shutdown = nullptr;
|
|
s->close = smart_socket_close;
|
|
|
|
D("SS(%d)", s->id);
|
|
return s;
|
|
}
|
|
|
|
void connect_to_smartsocket(asocket* s) {
|
|
D("Connecting to smart socket");
|
|
asocket* ss = create_smart_socket();
|
|
s->peer = ss;
|
|
ss->peer = s;
|
|
s->ready(s);
|
|
}
|
|
#endif
|
|
|
|
size_t asocket::get_max_payload() const {
|
|
size_t max_payload = MAX_PAYLOAD;
|
|
if (transport) {
|
|
max_payload = std::min(max_payload, transport->get_max_payload());
|
|
}
|
|
if (peer && peer->transport) {
|
|
max_payload = std::min(max_payload, peer->transport->get_max_payload());
|
|
}
|
|
return max_payload;
|
|
}
|