2009-03-04 11:32:55 +08:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
2015-03-20 06:21:08 +08:00
|
|
|
#define TRACE_TAG TRACE_ADB
|
|
|
|
|
|
|
|
#include "sysdeps.h"
|
|
|
|
#include "adb.h"
|
2009-03-04 11:32:55 +08:00
|
|
|
|
|
|
|
#include <ctype.h>
|
|
|
|
#include <errno.h>
|
2015-03-09 12:12:08 +08:00
|
|
|
#include <stdarg.h>
|
2012-05-26 04:55:46 +08:00
|
|
|
#include <stddef.h>
|
2015-03-09 12:12:08 +08:00
|
|
|
#include <stdint.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
2009-03-04 11:32:55 +08:00
|
|
|
#include <string.h>
|
2009-05-26 06:17:55 +08:00
|
|
|
#include <sys/time.h>
|
2015-03-09 12:12:08 +08:00
|
|
|
#include <time.h>
|
|
|
|
|
|
|
|
#include <string>
|
2015-03-20 04:25:27 +08:00
|
|
|
#include <vector>
|
|
|
|
#include <unordered_map>
|
2009-03-04 11:32:55 +08:00
|
|
|
|
2015-05-22 04:58:50 +08:00
|
|
|
#include <base/logging.h>
|
2015-05-11 16:08:48 +08:00
|
|
|
#include <base/macros.h>
|
2015-04-20 23:09:20 +08:00
|
|
|
#include <base/stringprintf.h>
|
2015-04-25 14:02:00 +08:00
|
|
|
#include <base/strings.h>
|
2015-04-20 23:09:20 +08:00
|
|
|
|
adb: Add public key authentification
Secure adb using a public key authentication, to allow USB debugging
only from authorized hosts.
When a device is connected to an unauthorized host, the adb daemon sends
the user public key to the device. A popup is shown to ask the user to
allow debugging once or permanantly from the host. The public key is
installed on the device in the later case. Other keys may be installed
at build time.
On the host, the user public/private key pair is automatically generated,
if it does not exist, when the adb daemon starts and is stored in
$HOME/.android/adb_key(.pub) or in $ANDROID_SDK_HOME on windows. If needed,
the ADB_KEYS_PATH env variable may be set to a :-separated (; under
Windows) list of private keys, e.g. company-wide or vendor keys.
On the device, vendors public keys are installed at build time in
/adb_keys. User-installed keys are stored in /data/misc/adb/adb_keys.
ADB Protocol change:
If the device needs to authenticate the host, it replies to CNXN
packets with an AUTH packet. The AUTH packet payload is a random token.
The host signs the token with one of its private keys and sends an AUTH(0)
packet. If the signature verification succeeds, the device replies with
a CNXN packet. Otherwise, it sends a new AUTH packet with a new token so
that the host can retry with another private key. Once the host has tried
all its keys, it can send an AUTH(1) packet with a public key as
payload. adbd then sends the public key to the framework (if it has been
started) for confirmation.
Change-Id: I4e84d7621da956f66ff657245901bdaefead8395
2012-04-13 03:23:49 +08:00
|
|
|
#include "adb_auth.h"
|
2015-02-25 13:26:58 +08:00
|
|
|
#include "adb_io.h"
|
2015-02-19 10:03:26 +08:00
|
|
|
#include "adb_listeners.h"
|
2015-07-19 03:21:30 +08:00
|
|
|
#include "adb_utils.h"
|
2015-02-25 07:51:19 +08:00
|
|
|
#include "transport.h"
|
2009-03-04 11:32:55 +08:00
|
|
|
|
2012-05-26 05:10:02 +08:00
|
|
|
#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
|
|
|
|
|
2009-03-04 11:32:55 +08:00
|
|
|
#if !ADB_HOST
|
2013-05-24 00:54:13 +08:00
|
|
|
#include <cutils/properties.h>
|
2013-03-01 06:12:58 +08:00
|
|
|
#include <sys/capability.h>
|
2012-08-15 12:00:22 +08:00
|
|
|
#include <sys/mount.h>
|
2009-03-04 11:32:55 +08:00
|
|
|
#endif
|
|
|
|
|
2012-05-26 05:10:02 +08:00
|
|
|
#if !ADB_HOST
|
2015-05-22 04:58:50 +08:00
|
|
|
const char* adb_device_banner = "device";
|
|
|
|
static android::base::LogdLogger gLogdLogger;
|
2015-05-19 04:06:53 +08:00
|
|
|
#else
|
|
|
|
const char* adb_device_banner = "host";
|
2012-05-26 05:10:02 +08:00
|
|
|
#endif
|
2009-03-04 11:32:55 +08:00
|
|
|
|
2015-05-22 04:58:50 +08:00
|
|
|
void AdbLogger(android::base::LogId id, android::base::LogSeverity severity,
|
|
|
|
const char* tag, const char* file, unsigned int line,
|
|
|
|
const char* message) {
|
|
|
|
android::base::StderrLogger(id, severity, tag, file, line, message);
|
|
|
|
#if !ADB_HOST
|
|
|
|
gLogdLogger(id, severity, tag, file, line, message);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2015-08-12 23:32:10 +08:00
|
|
|
std::string adb_version() {
|
|
|
|
// Don't change the format of this --- it's parsed by ddmlib.
|
|
|
|
return android::base::StringPrintf("Android Debug Bridge version %d.%d.%d\n"
|
|
|
|
"Revision %s\n",
|
|
|
|
ADB_VERSION_MAJOR, ADB_VERSION_MINOR, ADB_SERVER_VERSION,
|
|
|
|
ADB_REVISION);
|
|
|
|
}
|
|
|
|
|
2015-05-22 04:58:50 +08:00
|
|
|
void fatal(const char *fmt, ...) {
|
2009-03-04 11:32:55 +08:00
|
|
|
va_list ap;
|
|
|
|
va_start(ap, fmt);
|
|
|
|
fprintf(stderr, "error: ");
|
|
|
|
vfprintf(stderr, fmt, ap);
|
|
|
|
fprintf(stderr, "\n");
|
|
|
|
va_end(ap);
|
|
|
|
exit(-1);
|
|
|
|
}
|
|
|
|
|
2015-05-22 04:58:50 +08:00
|
|
|
void fatal_errno(const char* fmt, ...) {
|
2009-03-04 11:32:55 +08:00
|
|
|
va_list ap;
|
|
|
|
va_start(ap, fmt);
|
|
|
|
fprintf(stderr, "error: %s: ", strerror(errno));
|
|
|
|
vfprintf(stderr, fmt, ap);
|
|
|
|
fprintf(stderr, "\n");
|
|
|
|
va_end(ap);
|
|
|
|
exit(-1);
|
|
|
|
}
|
|
|
|
|
2015-03-09 12:12:08 +08:00
|
|
|
#if !ADB_HOST
|
2015-05-22 04:58:50 +08:00
|
|
|
static std::string get_log_file_name() {
|
2015-03-09 12:12:08 +08:00
|
|
|
struct tm now;
|
|
|
|
time_t t;
|
|
|
|
tzset();
|
|
|
|
time(&t);
|
|
|
|
localtime_r(&t, &now);
|
|
|
|
|
2015-03-20 13:53:30 +08:00
|
|
|
char timestamp[PATH_MAX];
|
|
|
|
strftime(timestamp, sizeof(timestamp), "%Y-%m-%d-%H-%M-%S", &now);
|
|
|
|
|
2015-05-22 04:58:50 +08:00
|
|
|
return android::base::StringPrintf("/data/adb/adb-%s-%d", timestamp,
|
|
|
|
getpid());
|
|
|
|
}
|
|
|
|
|
|
|
|
void start_device_log(void) {
|
|
|
|
int fd = unix_open(get_log_file_name().c_str(),
|
|
|
|
O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC, 0640);
|
2015-03-09 12:12:08 +08:00
|
|
|
if (fd == -1) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-05-22 04:58:50 +08:00
|
|
|
// Redirect stdout and stderr to the log file.
|
2015-03-09 12:12:08 +08:00
|
|
|
dup2(fd, STDOUT_FILENO);
|
|
|
|
dup2(fd, STDERR_FILENO);
|
|
|
|
fprintf(stderr, "--- adb starting (pid %d) ---\n", getpid());
|
2015-05-23 11:09:06 +08:00
|
|
|
unix_close(fd);
|
2015-03-09 12:12:08 +08:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
int adb_trace_mask;
|
|
|
|
|
|
|
|
std::string get_trace_setting_from_env() {
|
|
|
|
const char* setting = getenv("ADB_TRACE");
|
|
|
|
if (setting == nullptr) {
|
|
|
|
setting = "";
|
|
|
|
}
|
|
|
|
|
|
|
|
return std::string(setting);
|
|
|
|
}
|
|
|
|
|
|
|
|
#if !ADB_HOST
|
|
|
|
std::string get_trace_setting_from_prop() {
|
|
|
|
char buf[PROPERTY_VALUE_MAX];
|
|
|
|
property_get("persist.adb.trace_mask", buf, "");
|
|
|
|
return std::string(buf);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
std::string get_trace_setting() {
|
|
|
|
#if ADB_HOST
|
|
|
|
return get_trace_setting_from_env();
|
|
|
|
#else
|
|
|
|
return get_trace_setting_from_prop();
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2015-03-20 04:25:27 +08:00
|
|
|
// Split the space separated list of tags from the trace setting and build the
|
|
|
|
// trace mask from it. note that '1' and 'all' are special cases to enable all
|
|
|
|
// tracing.
|
2015-03-09 12:12:08 +08:00
|
|
|
//
|
|
|
|
// adb's trace setting comes from the ADB_TRACE environment variable, whereas
|
|
|
|
// adbd's comes from the system property persist.adb.trace_mask.
|
2015-05-22 04:58:50 +08:00
|
|
|
static void setup_trace_mask() {
|
2015-03-09 12:12:08 +08:00
|
|
|
const std::string trace_setting = get_trace_setting();
|
2009-03-04 11:32:55 +08:00
|
|
|
|
2015-03-20 04:25:27 +08:00
|
|
|
std::unordered_map<std::string, int> trace_flags = {
|
|
|
|
{"1", 0},
|
|
|
|
{"all", 0},
|
|
|
|
{"adb", TRACE_ADB},
|
|
|
|
{"sockets", TRACE_SOCKETS},
|
|
|
|
{"packets", TRACE_PACKETS},
|
|
|
|
{"rwx", TRACE_RWX},
|
|
|
|
{"usb", TRACE_USB},
|
|
|
|
{"sync", TRACE_SYNC},
|
|
|
|
{"sysdeps", TRACE_SYSDEPS},
|
|
|
|
{"transport", TRACE_TRANSPORT},
|
|
|
|
{"jdwp", TRACE_JDWP},
|
|
|
|
{"services", TRACE_SERVICES},
|
|
|
|
{"auth", TRACE_AUTH}};
|
|
|
|
|
|
|
|
std::vector<std::string> elements = android::base::Split(trace_setting, " ");
|
|
|
|
for (const auto& elem : elements) {
|
|
|
|
const auto& flag = trace_flags.find(elem);
|
|
|
|
if (flag == trace_flags.end()) {
|
2015-09-03 08:44:28 +08:00
|
|
|
D("Unknown trace flag: %s", flag->first.c_str());
|
2015-03-20 04:25:27 +08:00
|
|
|
continue;
|
2009-03-04 11:32:55 +08:00
|
|
|
}
|
2015-03-20 04:25:27 +08:00
|
|
|
|
|
|
|
if (flag->second == 0) {
|
|
|
|
// 0 is used for the special values "1" and "all" that enable all
|
|
|
|
// tracing.
|
|
|
|
adb_trace_mask = ~0;
|
|
|
|
return;
|
|
|
|
} else {
|
|
|
|
adb_trace_mask |= 1 << flag->second;
|
2009-03-04 11:32:55 +08:00
|
|
|
}
|
|
|
|
}
|
2015-05-22 04:58:50 +08:00
|
|
|
}
|
2015-03-09 12:12:08 +08:00
|
|
|
|
2015-05-22 04:58:50 +08:00
|
|
|
void adb_trace_init(char** argv) {
|
2015-08-12 06:48:15 +08:00
|
|
|
#if !ADB_HOST
|
2015-06-06 07:00:07 +08:00
|
|
|
// Don't open log file if no tracing, since this will block
|
|
|
|
// the crypto unmount of /data
|
2015-08-12 06:48:15 +08:00
|
|
|
if (!get_trace_setting().empty()) {
|
|
|
|
if (isatty(STDOUT_FILENO) == 0) {
|
|
|
|
start_device_log();
|
|
|
|
}
|
2015-05-22 04:58:50 +08:00
|
|
|
}
|
2015-03-09 12:12:08 +08:00
|
|
|
#endif
|
2015-05-22 04:58:50 +08:00
|
|
|
|
|
|
|
setup_trace_mask();
|
|
|
|
android::base::InitLogging(argv, AdbLogger);
|
2015-08-12 23:32:10 +08:00
|
|
|
|
|
|
|
D("%s", adb_version().c_str());
|
2009-03-04 11:32:55 +08:00
|
|
|
}
|
|
|
|
|
2015-02-26 09:51:28 +08:00
|
|
|
apacket* get_apacket(void)
|
2009-03-04 11:32:55 +08:00
|
|
|
{
|
2015-02-26 09:51:28 +08:00
|
|
|
apacket* p = reinterpret_cast<apacket*>(malloc(sizeof(apacket)));
|
|
|
|
if (p == nullptr) {
|
|
|
|
fatal("failed to allocate an apacket");
|
|
|
|
}
|
|
|
|
|
2009-03-04 11:32:55 +08:00
|
|
|
memset(p, 0, sizeof(apacket) - MAX_PAYLOAD);
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
|
|
|
|
void put_apacket(apacket *p)
|
|
|
|
{
|
|
|
|
free(p);
|
|
|
|
}
|
|
|
|
|
adb: Add public key authentification
Secure adb using a public key authentication, to allow USB debugging
only from authorized hosts.
When a device is connected to an unauthorized host, the adb daemon sends
the user public key to the device. A popup is shown to ask the user to
allow debugging once or permanantly from the host. The public key is
installed on the device in the later case. Other keys may be installed
at build time.
On the host, the user public/private key pair is automatically generated,
if it does not exist, when the adb daemon starts and is stored in
$HOME/.android/adb_key(.pub) or in $ANDROID_SDK_HOME on windows. If needed,
the ADB_KEYS_PATH env variable may be set to a :-separated (; under
Windows) list of private keys, e.g. company-wide or vendor keys.
On the device, vendors public keys are installed at build time in
/adb_keys. User-installed keys are stored in /data/misc/adb/adb_keys.
ADB Protocol change:
If the device needs to authenticate the host, it replies to CNXN
packets with an AUTH packet. The AUTH packet payload is a random token.
The host signs the token with one of its private keys and sends an AUTH(0)
packet. If the signature verification succeeds, the device replies with
a CNXN packet. Otherwise, it sends a new AUTH packet with a new token so
that the host can retry with another private key. Once the host has tried
all its keys, it can send an AUTH(1) packet with a public key as
payload. adbd then sends the public key to the framework (if it has been
started) for confirmation.
Change-Id: I4e84d7621da956f66ff657245901bdaefead8395
2012-04-13 03:23:49 +08:00
|
|
|
void handle_online(atransport *t)
|
2009-03-04 11:32:55 +08:00
|
|
|
{
|
2015-09-03 08:44:28 +08:00
|
|
|
D("adb: online");
|
adb: Add public key authentification
Secure adb using a public key authentication, to allow USB debugging
only from authorized hosts.
When a device is connected to an unauthorized host, the adb daemon sends
the user public key to the device. A popup is shown to ask the user to
allow debugging once or permanantly from the host. The public key is
installed on the device in the later case. Other keys may be installed
at build time.
On the host, the user public/private key pair is automatically generated,
if it does not exist, when the adb daemon starts and is stored in
$HOME/.android/adb_key(.pub) or in $ANDROID_SDK_HOME on windows. If needed,
the ADB_KEYS_PATH env variable may be set to a :-separated (; under
Windows) list of private keys, e.g. company-wide or vendor keys.
On the device, vendors public keys are installed at build time in
/adb_keys. User-installed keys are stored in /data/misc/adb/adb_keys.
ADB Protocol change:
If the device needs to authenticate the host, it replies to CNXN
packets with an AUTH packet. The AUTH packet payload is a random token.
The host signs the token with one of its private keys and sends an AUTH(0)
packet. If the signature verification succeeds, the device replies with
a CNXN packet. Otherwise, it sends a new AUTH packet with a new token so
that the host can retry with another private key. Once the host has tried
all its keys, it can send an AUTH(1) packet with a public key as
payload. adbd then sends the public key to the framework (if it has been
started) for confirmation.
Change-Id: I4e84d7621da956f66ff657245901bdaefead8395
2012-04-13 03:23:49 +08:00
|
|
|
t->online = 1;
|
2009-03-04 11:32:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void handle_offline(atransport *t)
|
|
|
|
{
|
2015-09-03 08:44:28 +08:00
|
|
|
D("adb: offline");
|
2009-03-04 11:32:55 +08:00
|
|
|
//Close the associated usb
|
adb: Add public key authentification
Secure adb using a public key authentication, to allow USB debugging
only from authorized hosts.
When a device is connected to an unauthorized host, the adb daemon sends
the user public key to the device. A popup is shown to ask the user to
allow debugging once or permanantly from the host. The public key is
installed on the device in the later case. Other keys may be installed
at build time.
On the host, the user public/private key pair is automatically generated,
if it does not exist, when the adb daemon starts and is stored in
$HOME/.android/adb_key(.pub) or in $ANDROID_SDK_HOME on windows. If needed,
the ADB_KEYS_PATH env variable may be set to a :-separated (; under
Windows) list of private keys, e.g. company-wide or vendor keys.
On the device, vendors public keys are installed at build time in
/adb_keys. User-installed keys are stored in /data/misc/adb/adb_keys.
ADB Protocol change:
If the device needs to authenticate the host, it replies to CNXN
packets with an AUTH packet. The AUTH packet payload is a random token.
The host signs the token with one of its private keys and sends an AUTH(0)
packet. If the signature verification succeeds, the device replies with
a CNXN packet. Otherwise, it sends a new AUTH packet with a new token so
that the host can retry with another private key. Once the host has tried
all its keys, it can send an AUTH(1) packet with a public key as
payload. adbd then sends the public key to the framework (if it has been
started) for confirmation.
Change-Id: I4e84d7621da956f66ff657245901bdaefead8395
2012-04-13 03:23:49 +08:00
|
|
|
t->online = 0;
|
2015-08-27 02:18:42 +08:00
|
|
|
|
2015-08-29 06:09:44 +08:00
|
|
|
// This is necessary to avoid a race condition that occurred when a transport closes
|
2015-08-27 02:18:42 +08:00
|
|
|
// while a client socket is still active.
|
|
|
|
close_all_sockets(t);
|
|
|
|
|
2015-08-29 06:09:44 +08:00
|
|
|
t->RunDisconnects();
|
2009-03-04 11:32:55 +08:00
|
|
|
}
|
|
|
|
|
adb: Add public key authentification
Secure adb using a public key authentication, to allow USB debugging
only from authorized hosts.
When a device is connected to an unauthorized host, the adb daemon sends
the user public key to the device. A popup is shown to ask the user to
allow debugging once or permanantly from the host. The public key is
installed on the device in the later case. Other keys may be installed
at build time.
On the host, the user public/private key pair is automatically generated,
if it does not exist, when the adb daemon starts and is stored in
$HOME/.android/adb_key(.pub) or in $ANDROID_SDK_HOME on windows. If needed,
the ADB_KEYS_PATH env variable may be set to a :-separated (; under
Windows) list of private keys, e.g. company-wide or vendor keys.
On the device, vendors public keys are installed at build time in
/adb_keys. User-installed keys are stored in /data/misc/adb/adb_keys.
ADB Protocol change:
If the device needs to authenticate the host, it replies to CNXN
packets with an AUTH packet. The AUTH packet payload is a random token.
The host signs the token with one of its private keys and sends an AUTH(0)
packet. If the signature verification succeeds, the device replies with
a CNXN packet. Otherwise, it sends a new AUTH packet with a new token so
that the host can retry with another private key. Once the host has tried
all its keys, it can send an AUTH(1) packet with a public key as
payload. adbd then sends the public key to the framework (if it has been
started) for confirmation.
Change-Id: I4e84d7621da956f66ff657245901bdaefead8395
2012-04-13 03:23:49 +08:00
|
|
|
#if DEBUG_PACKETS
|
2009-03-04 11:32:55 +08:00
|
|
|
#define DUMPMAX 32
|
|
|
|
void print_packet(const char *label, apacket *p)
|
|
|
|
{
|
|
|
|
char *tag;
|
|
|
|
char *x;
|
|
|
|
unsigned count;
|
|
|
|
|
|
|
|
switch(p->msg.command){
|
|
|
|
case A_SYNC: tag = "SYNC"; break;
|
|
|
|
case A_CNXN: tag = "CNXN" ; break;
|
|
|
|
case A_OPEN: tag = "OPEN"; break;
|
|
|
|
case A_OKAY: tag = "OKAY"; break;
|
|
|
|
case A_CLSE: tag = "CLSE"; break;
|
|
|
|
case A_WRTE: tag = "WRTE"; break;
|
adb: Add public key authentification
Secure adb using a public key authentication, to allow USB debugging
only from authorized hosts.
When a device is connected to an unauthorized host, the adb daemon sends
the user public key to the device. A popup is shown to ask the user to
allow debugging once or permanantly from the host. The public key is
installed on the device in the later case. Other keys may be installed
at build time.
On the host, the user public/private key pair is automatically generated,
if it does not exist, when the adb daemon starts and is stored in
$HOME/.android/adb_key(.pub) or in $ANDROID_SDK_HOME on windows. If needed,
the ADB_KEYS_PATH env variable may be set to a :-separated (; under
Windows) list of private keys, e.g. company-wide or vendor keys.
On the device, vendors public keys are installed at build time in
/adb_keys. User-installed keys are stored in /data/misc/adb/adb_keys.
ADB Protocol change:
If the device needs to authenticate the host, it replies to CNXN
packets with an AUTH packet. The AUTH packet payload is a random token.
The host signs the token with one of its private keys and sends an AUTH(0)
packet. If the signature verification succeeds, the device replies with
a CNXN packet. Otherwise, it sends a new AUTH packet with a new token so
that the host can retry with another private key. Once the host has tried
all its keys, it can send an AUTH(1) packet with a public key as
payload. adbd then sends the public key to the framework (if it has been
started) for confirmation.
Change-Id: I4e84d7621da956f66ff657245901bdaefead8395
2012-04-13 03:23:49 +08:00
|
|
|
case A_AUTH: tag = "AUTH"; break;
|
2009-03-04 11:32:55 +08:00
|
|
|
default: tag = "????"; break;
|
|
|
|
}
|
|
|
|
|
|
|
|
fprintf(stderr, "%s: %s %08x %08x %04x \"",
|
|
|
|
label, tag, p->msg.arg0, p->msg.arg1, p->msg.data_length);
|
|
|
|
count = p->msg.data_length;
|
|
|
|
x = (char*) p->data;
|
|
|
|
if(count > DUMPMAX) {
|
|
|
|
count = DUMPMAX;
|
|
|
|
tag = "\n";
|
|
|
|
} else {
|
|
|
|
tag = "\"\n";
|
|
|
|
}
|
|
|
|
while(count-- > 0){
|
|
|
|
if((*x >= ' ') && (*x < 127)) {
|
|
|
|
fputc(*x, stderr);
|
|
|
|
} else {
|
|
|
|
fputc('.', stderr);
|
|
|
|
}
|
|
|
|
x++;
|
|
|
|
}
|
adb: Add public key authentification
Secure adb using a public key authentication, to allow USB debugging
only from authorized hosts.
When a device is connected to an unauthorized host, the adb daemon sends
the user public key to the device. A popup is shown to ask the user to
allow debugging once or permanantly from the host. The public key is
installed on the device in the later case. Other keys may be installed
at build time.
On the host, the user public/private key pair is automatically generated,
if it does not exist, when the adb daemon starts and is stored in
$HOME/.android/adb_key(.pub) or in $ANDROID_SDK_HOME on windows. If needed,
the ADB_KEYS_PATH env variable may be set to a :-separated (; under
Windows) list of private keys, e.g. company-wide or vendor keys.
On the device, vendors public keys are installed at build time in
/adb_keys. User-installed keys are stored in /data/misc/adb/adb_keys.
ADB Protocol change:
If the device needs to authenticate the host, it replies to CNXN
packets with an AUTH packet. The AUTH packet payload is a random token.
The host signs the token with one of its private keys and sends an AUTH(0)
packet. If the signature verification succeeds, the device replies with
a CNXN packet. Otherwise, it sends a new AUTH packet with a new token so
that the host can retry with another private key. Once the host has tried
all its keys, it can send an AUTH(1) packet with a public key as
payload. adbd then sends the public key to the framework (if it has been
started) for confirmation.
Change-Id: I4e84d7621da956f66ff657245901bdaefead8395
2012-04-13 03:23:49 +08:00
|
|
|
fputs(tag, stderr);
|
2009-03-04 11:32:55 +08:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static void send_ready(unsigned local, unsigned remote, atransport *t)
|
|
|
|
{
|
2015-09-03 08:44:28 +08:00
|
|
|
D("Calling send_ready");
|
2009-03-04 11:32:55 +08:00
|
|
|
apacket *p = get_apacket();
|
|
|
|
p->msg.command = A_OKAY;
|
|
|
|
p->msg.arg0 = local;
|
|
|
|
p->msg.arg1 = remote;
|
|
|
|
send_packet(p, t);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void send_close(unsigned local, unsigned remote, atransport *t)
|
|
|
|
{
|
2015-09-03 08:44:28 +08:00
|
|
|
D("Calling send_close");
|
2009-03-04 11:32:55 +08:00
|
|
|
apacket *p = get_apacket();
|
|
|
|
p->msg.command = A_CLSE;
|
|
|
|
p->msg.arg0 = local;
|
|
|
|
p->msg.arg1 = remote;
|
|
|
|
send_packet(p, t);
|
|
|
|
}
|
|
|
|
|
2015-05-19 04:06:53 +08:00
|
|
|
std::string get_connection_string() {
|
|
|
|
std::vector<std::string> connection_properties;
|
|
|
|
|
|
|
|
#if !ADB_HOST
|
|
|
|
static const char* cnxn_props[] = {
|
2012-05-26 05:10:02 +08:00
|
|
|
"ro.product.name",
|
|
|
|
"ro.product.model",
|
|
|
|
"ro.product.device",
|
|
|
|
};
|
2015-05-19 04:06:53 +08:00
|
|
|
|
|
|
|
for (const auto& prop_name : cnxn_props) {
|
2012-05-26 05:10:02 +08:00
|
|
|
char value[PROPERTY_VALUE_MAX];
|
2015-05-19 04:06:53 +08:00
|
|
|
property_get(prop_name, value, "");
|
|
|
|
connection_properties.push_back(
|
|
|
|
android::base::StringPrintf("%s=%s", prop_name, value));
|
2012-05-26 05:10:02 +08:00
|
|
|
}
|
|
|
|
#endif
|
2015-05-19 04:06:53 +08:00
|
|
|
|
|
|
|
connection_properties.push_back(android::base::StringPrintf(
|
|
|
|
"features=%s", android::base::Join(supported_features(), ',').c_str()));
|
|
|
|
|
|
|
|
return android::base::StringPrintf(
|
|
|
|
"%s::%s", adb_device_banner,
|
|
|
|
android::base::Join(connection_properties, ';').c_str());
|
2012-05-26 05:10:02 +08:00
|
|
|
}
|
|
|
|
|
2015-05-19 04:06:53 +08:00
|
|
|
void send_connect(atransport* t) {
|
2015-09-03 08:44:28 +08:00
|
|
|
D("Calling send_connect");
|
2015-05-19 04:06:53 +08:00
|
|
|
apacket* cp = get_apacket();
|
2009-03-04 11:32:55 +08:00
|
|
|
cp->msg.command = A_CNXN;
|
2015-07-14 02:12:28 +08:00
|
|
|
cp->msg.arg0 = t->get_protocol_version();
|
|
|
|
cp->msg.arg1 = t->get_max_payload();
|
2015-05-19 04:06:53 +08:00
|
|
|
|
|
|
|
std::string connection_str = get_connection_string();
|
|
|
|
// Connect and auth packets are limited to MAX_PAYLOAD_V1 because we don't
|
|
|
|
// yet know how much data the other size is willing to accept.
|
|
|
|
if (connection_str.length() > MAX_PAYLOAD_V1) {
|
|
|
|
LOG(FATAL) << "Connection banner is too long (length = "
|
|
|
|
<< connection_str.length() << ")";
|
|
|
|
}
|
|
|
|
|
|
|
|
memcpy(cp->data, connection_str.c_str(), connection_str.length());
|
|
|
|
cp->msg.data_length = connection_str.length();
|
|
|
|
|
2009-03-04 11:32:55 +08:00
|
|
|
send_packet(cp, t);
|
adb: Add public key authentification
Secure adb using a public key authentication, to allow USB debugging
only from authorized hosts.
When a device is connected to an unauthorized host, the adb daemon sends
the user public key to the device. A popup is shown to ask the user to
allow debugging once or permanantly from the host. The public key is
installed on the device in the later case. Other keys may be installed
at build time.
On the host, the user public/private key pair is automatically generated,
if it does not exist, when the adb daemon starts and is stored in
$HOME/.android/adb_key(.pub) or in $ANDROID_SDK_HOME on windows. If needed,
the ADB_KEYS_PATH env variable may be set to a :-separated (; under
Windows) list of private keys, e.g. company-wide or vendor keys.
On the device, vendors public keys are installed at build time in
/adb_keys. User-installed keys are stored in /data/misc/adb/adb_keys.
ADB Protocol change:
If the device needs to authenticate the host, it replies to CNXN
packets with an AUTH packet. The AUTH packet payload is a random token.
The host signs the token with one of its private keys and sends an AUTH(0)
packet. If the signature verification succeeds, the device replies with
a CNXN packet. Otherwise, it sends a new AUTH packet with a new token so
that the host can retry with another private key. Once the host has tried
all its keys, it can send an AUTH(1) packet with a public key as
payload. adbd then sends the public key to the framework (if it has been
started) for confirmation.
Change-Id: I4e84d7621da956f66ff657245901bdaefead8395
2012-04-13 03:23:49 +08:00
|
|
|
}
|
|
|
|
|
2015-04-25 14:02:00 +08:00
|
|
|
// qual_overwrite is used to overwrite a qualifier string. dst is a
|
|
|
|
// pointer to a char pointer. It is assumed that if *dst is non-NULL, it
|
|
|
|
// was malloc'ed and needs to freed. *dst will be set to a dup of src.
|
|
|
|
// TODO: switch to std::string for these atransport fields instead.
|
|
|
|
static void qual_overwrite(char** dst, const std::string& src) {
|
2012-05-26 05:10:02 +08:00
|
|
|
free(*dst);
|
2015-04-25 14:02:00 +08:00
|
|
|
*dst = strdup(src.c_str());
|
2012-05-26 05:10:02 +08:00
|
|
|
}
|
|
|
|
|
2015-05-19 04:06:53 +08:00
|
|
|
void parse_banner(const std::string& banner, atransport* t) {
|
2015-09-03 08:44:28 +08:00
|
|
|
D("parse_banner: %s", banner.c_str());
|
2015-04-25 14:02:00 +08:00
|
|
|
|
|
|
|
// The format is something like:
|
|
|
|
// "device::ro.product.name=x;ro.product.model=y;ro.product.device=z;".
|
|
|
|
std::vector<std::string> pieces = android::base::Split(banner, ":");
|
|
|
|
|
|
|
|
if (pieces.size() > 2) {
|
|
|
|
const std::string& props = pieces[2];
|
|
|
|
for (auto& prop : android::base::Split(props, ";")) {
|
|
|
|
// The list of properties was traditionally ;-terminated rather than ;-separated.
|
|
|
|
if (prop.empty()) continue;
|
|
|
|
|
|
|
|
std::vector<std::string> key_value = android::base::Split(prop, "=");
|
|
|
|
if (key_value.size() != 2) continue;
|
|
|
|
|
|
|
|
const std::string& key = key_value[0];
|
|
|
|
const std::string& value = key_value[1];
|
|
|
|
if (key == "ro.product.name") {
|
|
|
|
qual_overwrite(&t->product, value);
|
|
|
|
} else if (key == "ro.product.model") {
|
|
|
|
qual_overwrite(&t->model, value);
|
|
|
|
} else if (key == "ro.product.device") {
|
|
|
|
qual_overwrite(&t->device, value);
|
2015-05-19 04:06:53 +08:00
|
|
|
} else if (key == "features") {
|
|
|
|
for (const auto& feature : android::base::Split(value, ",")) {
|
|
|
|
t->add_feature(feature);
|
|
|
|
}
|
2012-05-26 05:10:02 +08:00
|
|
|
}
|
|
|
|
}
|
2009-03-04 11:32:55 +08:00
|
|
|
}
|
|
|
|
|
2015-04-25 14:02:00 +08:00
|
|
|
const std::string& type = pieces[0];
|
|
|
|
if (type == "bootloader") {
|
2015-09-03 08:44:28 +08:00
|
|
|
D("setting connection_state to kCsBootloader");
|
2015-05-19 07:43:57 +08:00
|
|
|
t->connection_state = kCsBootloader;
|
2009-03-04 11:32:55 +08:00
|
|
|
update_transports();
|
2015-04-25 14:02:00 +08:00
|
|
|
} else if (type == "device") {
|
2015-09-03 08:44:28 +08:00
|
|
|
D("setting connection_state to kCsDevice");
|
2015-05-19 07:43:57 +08:00
|
|
|
t->connection_state = kCsDevice;
|
2009-03-04 11:32:55 +08:00
|
|
|
update_transports();
|
2015-04-25 14:02:00 +08:00
|
|
|
} else if (type == "recovery") {
|
2015-09-03 08:44:28 +08:00
|
|
|
D("setting connection_state to kCsRecovery");
|
2015-05-19 07:43:57 +08:00
|
|
|
t->connection_state = kCsRecovery;
|
2009-03-04 11:32:55 +08:00
|
|
|
update_transports();
|
2015-04-25 14:02:00 +08:00
|
|
|
} else if (type == "sideload") {
|
2015-09-03 08:44:28 +08:00
|
|
|
D("setting connection_state to kCsSideload");
|
2015-05-19 07:43:57 +08:00
|
|
|
t->connection_state = kCsSideload;
|
2012-01-10 06:54:53 +08:00
|
|
|
update_transports();
|
2015-04-30 13:37:25 +08:00
|
|
|
} else {
|
2015-09-03 08:44:28 +08:00
|
|
|
D("setting connection_state to kCsHost");
|
2015-05-19 07:43:57 +08:00
|
|
|
t->connection_state = kCsHost;
|
2012-01-10 06:54:53 +08:00
|
|
|
}
|
2009-03-04 11:32:55 +08:00
|
|
|
}
|
|
|
|
|
2015-05-19 04:06:53 +08:00
|
|
|
static void handle_new_connection(atransport* t, apacket* p) {
|
|
|
|
if (t->connection_state != kCsOffline) {
|
|
|
|
t->connection_state = kCsOffline;
|
|
|
|
handle_offline(t);
|
|
|
|
}
|
|
|
|
|
|
|
|
t->update_version(p->msg.arg0, p->msg.arg1);
|
|
|
|
std::string banner(reinterpret_cast<const char*>(p->data),
|
|
|
|
p->msg.data_length);
|
|
|
|
parse_banner(banner, t);
|
|
|
|
|
|
|
|
#if ADB_HOST
|
|
|
|
handle_online(t);
|
|
|
|
#else
|
|
|
|
if (!auth_required) {
|
|
|
|
handle_online(t);
|
|
|
|
send_connect(t);
|
|
|
|
} else {
|
|
|
|
send_auth_request(t);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2009-03-04 11:32:55 +08:00
|
|
|
void handle_packet(apacket *p, atransport *t)
|
|
|
|
{
|
|
|
|
asocket *s;
|
|
|
|
|
2015-09-03 08:44:28 +08:00
|
|
|
D("handle_packet() %c%c%c%c", ((char*) (&(p->msg.command)))[0],
|
2010-06-16 21:11:28 +08:00
|
|
|
((char*) (&(p->msg.command)))[1],
|
|
|
|
((char*) (&(p->msg.command)))[2],
|
|
|
|
((char*) (&(p->msg.command)))[3]);
|
2009-03-04 11:32:55 +08:00
|
|
|
print_packet("recv", p);
|
|
|
|
|
|
|
|
switch(p->msg.command){
|
|
|
|
case A_SYNC:
|
|
|
|
if(p->msg.arg0){
|
|
|
|
send_packet(p, t);
|
2015-08-12 04:40:42 +08:00
|
|
|
#if ADB_HOST
|
|
|
|
send_connect(t);
|
|
|
|
#endif
|
2009-03-04 11:32:55 +08:00
|
|
|
} else {
|
2015-05-19 07:43:57 +08:00
|
|
|
t->connection_state = kCsOffline;
|
2009-03-04 11:32:55 +08:00
|
|
|
handle_offline(t);
|
|
|
|
send_packet(p, t);
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
|
2015-05-19 04:06:53 +08:00
|
|
|
case A_CNXN: // CONNECT(version, maxdata, "system-id-string")
|
|
|
|
handle_new_connection(t, p);
|
adb: Add public key authentification
Secure adb using a public key authentication, to allow USB debugging
only from authorized hosts.
When a device is connected to an unauthorized host, the adb daemon sends
the user public key to the device. A popup is shown to ask the user to
allow debugging once or permanantly from the host. The public key is
installed on the device in the later case. Other keys may be installed
at build time.
On the host, the user public/private key pair is automatically generated,
if it does not exist, when the adb daemon starts and is stored in
$HOME/.android/adb_key(.pub) or in $ANDROID_SDK_HOME on windows. If needed,
the ADB_KEYS_PATH env variable may be set to a :-separated (; under
Windows) list of private keys, e.g. company-wide or vendor keys.
On the device, vendors public keys are installed at build time in
/adb_keys. User-installed keys are stored in /data/misc/adb/adb_keys.
ADB Protocol change:
If the device needs to authenticate the host, it replies to CNXN
packets with an AUTH packet. The AUTH packet payload is a random token.
The host signs the token with one of its private keys and sends an AUTH(0)
packet. If the signature verification succeeds, the device replies with
a CNXN packet. Otherwise, it sends a new AUTH packet with a new token so
that the host can retry with another private key. Once the host has tried
all its keys, it can send an AUTH(1) packet with a public key as
payload. adbd then sends the public key to the framework (if it has been
started) for confirmation.
Change-Id: I4e84d7621da956f66ff657245901bdaefead8395
2012-04-13 03:23:49 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
case A_AUTH:
|
|
|
|
if (p->msg.arg0 == ADB_AUTH_TOKEN) {
|
2015-05-19 07:43:57 +08:00
|
|
|
t->connection_state = kCsUnauthorized;
|
adb: Add public key authentification
Secure adb using a public key authentication, to allow USB debugging
only from authorized hosts.
When a device is connected to an unauthorized host, the adb daemon sends
the user public key to the device. A popup is shown to ask the user to
allow debugging once or permanantly from the host. The public key is
installed on the device in the later case. Other keys may be installed
at build time.
On the host, the user public/private key pair is automatically generated,
if it does not exist, when the adb daemon starts and is stored in
$HOME/.android/adb_key(.pub) or in $ANDROID_SDK_HOME on windows. If needed,
the ADB_KEYS_PATH env variable may be set to a :-separated (; under
Windows) list of private keys, e.g. company-wide or vendor keys.
On the device, vendors public keys are installed at build time in
/adb_keys. User-installed keys are stored in /data/misc/adb/adb_keys.
ADB Protocol change:
If the device needs to authenticate the host, it replies to CNXN
packets with an AUTH packet. The AUTH packet payload is a random token.
The host signs the token with one of its private keys and sends an AUTH(0)
packet. If the signature verification succeeds, the device replies with
a CNXN packet. Otherwise, it sends a new AUTH packet with a new token so
that the host can retry with another private key. Once the host has tried
all its keys, it can send an AUTH(1) packet with a public key as
payload. adbd then sends the public key to the framework (if it has been
started) for confirmation.
Change-Id: I4e84d7621da956f66ff657245901bdaefead8395
2012-04-13 03:23:49 +08:00
|
|
|
t->key = adb_auth_nextkey(t->key);
|
|
|
|
if (t->key) {
|
|
|
|
send_auth_response(p->data, p->msg.data_length, t);
|
|
|
|
} else {
|
|
|
|
/* No more private keys to try, send the public key */
|
|
|
|
send_auth_publickey(t);
|
|
|
|
}
|
|
|
|
} else if (p->msg.arg0 == ADB_AUTH_SIGNATURE) {
|
|
|
|
if (adb_auth_verify(t->token, p->data, p->msg.data_length)) {
|
|
|
|
adb_auth_verified(t);
|
|
|
|
t->failed_auth_attempts = 0;
|
|
|
|
} else {
|
|
|
|
if (t->failed_auth_attempts++ > 10)
|
|
|
|
adb_sleep_ms(1000);
|
|
|
|
send_auth_request(t);
|
|
|
|
}
|
|
|
|
} else if (p->msg.arg0 == ADB_AUTH_RSAPUBLICKEY) {
|
|
|
|
adb_auth_confirm_key(p->data, p->msg.data_length, t);
|
|
|
|
}
|
2009-03-04 11:32:55 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
case A_OPEN: /* OPEN(local-id, 0, "destination") */
|
2013-12-13 21:09:44 +08:00
|
|
|
if (t->online && p->msg.arg0 != 0 && p->msg.arg1 == 0) {
|
2009-03-04 11:32:55 +08:00
|
|
|
char *name = (char*) p->data;
|
|
|
|
name[p->msg.data_length > 0 ? p->msg.data_length - 1 : 0] = 0;
|
|
|
|
s = create_local_service_socket(name);
|
|
|
|
if(s == 0) {
|
|
|
|
send_close(0, p->msg.arg0, t);
|
|
|
|
} else {
|
|
|
|
s->peer = create_remote_socket(p->msg.arg0, t);
|
|
|
|
s->peer->peer = s;
|
|
|
|
send_ready(s->id, s->peer->id, t);
|
|
|
|
s->ready(s);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case A_OKAY: /* READY(local-id, remote-id, "") */
|
2013-12-13 21:09:44 +08:00
|
|
|
if (t->online && p->msg.arg0 != 0 && p->msg.arg1 != 0) {
|
|
|
|
if((s = find_local_socket(p->msg.arg1, 0))) {
|
2009-03-04 11:32:55 +08:00
|
|
|
if(s->peer == 0) {
|
2013-12-13 21:09:44 +08:00
|
|
|
/* On first READY message, create the connection. */
|
2009-03-04 11:32:55 +08:00
|
|
|
s->peer = create_remote_socket(p->msg.arg0, t);
|
|
|
|
s->peer->peer = s;
|
2013-12-13 21:09:44 +08:00
|
|
|
s->ready(s);
|
|
|
|
} else if (s->peer->id == p->msg.arg0) {
|
|
|
|
/* Other READY messages must use the same local-id */
|
|
|
|
s->ready(s);
|
|
|
|
} else {
|
2015-09-03 08:44:28 +08:00
|
|
|
D("Invalid A_OKAY(%d,%d), expected A_OKAY(%d,%d) on transport %s",
|
2013-12-13 21:09:44 +08:00
|
|
|
p->msg.arg0, p->msg.arg1, s->peer->id, p->msg.arg1, t->serial);
|
2009-03-04 11:32:55 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2013-12-13 21:09:44 +08:00
|
|
|
case A_CLSE: /* CLOSE(local-id, remote-id, "") or CLOSE(0, remote-id, "") */
|
|
|
|
if (t->online && p->msg.arg1 != 0) {
|
|
|
|
if((s = find_local_socket(p->msg.arg1, p->msg.arg0))) {
|
|
|
|
/* According to protocol.txt, p->msg.arg0 might be 0 to indicate
|
|
|
|
* a failed OPEN only. However, due to a bug in previous ADB
|
|
|
|
* versions, CLOSE(0, remote-id, "") was also used for normal
|
|
|
|
* CLOSE() operations.
|
|
|
|
*
|
|
|
|
* This is bad because it means a compromised adbd could
|
|
|
|
* send packets to close connections between the host and
|
|
|
|
* other devices. To avoid this, only allow this if the local
|
|
|
|
* socket has a peer on the same transport.
|
|
|
|
*/
|
|
|
|
if (p->msg.arg0 == 0 && s->peer && s->peer->transport != t) {
|
2015-09-03 08:44:28 +08:00
|
|
|
D("Invalid A_CLSE(0, %u) from transport %s, expected transport %s",
|
2013-12-13 21:09:44 +08:00
|
|
|
p->msg.arg1, t->serial, s->peer->transport->serial);
|
|
|
|
} else {
|
|
|
|
s->close(s);
|
|
|
|
}
|
2009-03-04 11:32:55 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2013-12-13 21:09:44 +08:00
|
|
|
case A_WRTE: /* WRITE(local-id, remote-id, <data>) */
|
|
|
|
if (t->online && p->msg.arg0 != 0 && p->msg.arg1 != 0) {
|
|
|
|
if((s = find_local_socket(p->msg.arg1, p->msg.arg0))) {
|
2009-03-04 11:32:55 +08:00
|
|
|
unsigned rid = p->msg.arg0;
|
|
|
|
p->len = p->msg.data_length;
|
|
|
|
|
|
|
|
if(s->enqueue(s, p) == 0) {
|
2015-09-03 08:44:28 +08:00
|
|
|
D("Enqueue the socket");
|
2009-03-04 11:32:55 +08:00
|
|
|
send_ready(s->id, rid, t);
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
printf("handle_packet: what is %08x?!\n", p->msg.command);
|
|
|
|
}
|
|
|
|
|
|
|
|
put_apacket(p);
|
|
|
|
}
|
|
|
|
|
|
|
|
#if ADB_HOST
|
2012-12-07 10:18:12 +08:00
|
|
|
|
2015-08-27 09:46:09 +08:00
|
|
|
#ifdef _WIN32
|
|
|
|
|
|
|
|
static bool _make_handle_noninheritable(HANDLE h) {
|
|
|
|
if (h != INVALID_HANDLE_VALUE && h != NULL) {
|
|
|
|
if (!SetHandleInformation(h, HANDLE_FLAG_INHERIT, 0)) {
|
|
|
|
// Show the handle value to give us a clue in case we have problems
|
|
|
|
// with pseudo-handle values.
|
|
|
|
fprintf(stderr, "Cannot make handle 0x%p non-inheritable: %s\n",
|
|
|
|
h, SystemErrorCodeToString(GetLastError()).c_str());
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Create anonymous pipe, preventing inheritance of the read pipe and setting
|
|
|
|
// security of the write pipe to sa.
|
|
|
|
static bool _create_anonymous_pipe(unique_handle* pipe_read_out,
|
|
|
|
unique_handle* pipe_write_out,
|
|
|
|
SECURITY_ATTRIBUTES* sa) {
|
|
|
|
HANDLE pipe_read_raw = NULL;
|
|
|
|
HANDLE pipe_write_raw = NULL;
|
|
|
|
if (!CreatePipe(&pipe_read_raw, &pipe_write_raw, sa, 0)) {
|
|
|
|
fprintf(stderr, "Cannot create pipe: %s\n",
|
|
|
|
SystemErrorCodeToString(GetLastError()).c_str());
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
unique_handle pipe_read(pipe_read_raw);
|
|
|
|
pipe_read_raw = NULL;
|
|
|
|
unique_handle pipe_write(pipe_write_raw);
|
|
|
|
pipe_write_raw = NULL;
|
|
|
|
|
|
|
|
if (!_make_handle_noninheritable(pipe_read.get())) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
*pipe_read_out = std::move(pipe_read);
|
|
|
|
*pipe_write_out = std::move(pipe_write);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Read from a pipe (that we take ownership of) and write what is returned to
|
|
|
|
// GetStdHandle(nStdHandle). Return on error or when the pipe is closed.
|
|
|
|
static unsigned _redirect_pipe_thread(HANDLE h, DWORD nStdHandle) {
|
|
|
|
// Take ownership of the HANDLE and close when we're done.
|
|
|
|
unique_handle read_pipe(h);
|
|
|
|
const HANDLE write_handle = GetStdHandle(nStdHandle);
|
|
|
|
const char* output_name = nStdHandle == STD_OUTPUT_HANDLE ?
|
|
|
|
"stdout" : "stderr";
|
|
|
|
|
|
|
|
while (true) {
|
|
|
|
char buf[64 * 1024];
|
|
|
|
DWORD bytes_read = 0;
|
|
|
|
if (!ReadFile(read_pipe.get(), buf, sizeof(buf), &bytes_read, NULL)) {
|
|
|
|
const DWORD err = GetLastError();
|
|
|
|
// ERROR_BROKEN_PIPE is expected when the subprocess closes
|
|
|
|
// the other end of the pipe.
|
|
|
|
if (err == ERROR_BROKEN_PIPE) {
|
|
|
|
return EXIT_SUCCESS;
|
|
|
|
} else {
|
|
|
|
fprintf(stderr, "Failed to read from %s: %s\n", output_name,
|
|
|
|
SystemErrorCodeToString(err).c_str());
|
|
|
|
return EXIT_FAILURE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Don't try to write if our stdout/stderr was not setup by the
|
|
|
|
// parent process.
|
|
|
|
if (write_handle != NULL && write_handle != INVALID_HANDLE_VALUE) {
|
|
|
|
DWORD bytes_written = 0;
|
|
|
|
if (!WriteFile(write_handle, buf, bytes_read, &bytes_written,
|
|
|
|
NULL)) {
|
|
|
|
fprintf(stderr, "Failed to write to %s: %s\n", output_name,
|
|
|
|
SystemErrorCodeToString(GetLastError()).c_str());
|
|
|
|
return EXIT_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (bytes_written != bytes_read) {
|
|
|
|
fprintf(stderr, "Only wrote %lu of %lu bytes to %s\n",
|
|
|
|
bytes_written, bytes_read, output_name);
|
|
|
|
return EXIT_FAILURE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned __stdcall _redirect_stdout_thread(HANDLE h) {
|
2015-08-29 07:37:29 +08:00
|
|
|
adb_thread_setname("stdout redirect");
|
2015-08-27 09:46:09 +08:00
|
|
|
return _redirect_pipe_thread(h, STD_OUTPUT_HANDLE);
|
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned __stdcall _redirect_stderr_thread(HANDLE h) {
|
2015-08-29 07:37:29 +08:00
|
|
|
adb_thread_setname("stderr redirect");
|
2015-08-27 09:46:09 +08:00
|
|
|
return _redirect_pipe_thread(h, STD_ERROR_HANDLE);
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2010-04-19 19:21:12 +08:00
|
|
|
int launch_server(int server_port)
|
2009-03-04 11:32:55 +08:00
|
|
|
{
|
2014-11-12 01:24:11 +08:00
|
|
|
#if defined(_WIN32)
|
2009-03-04 11:32:55 +08:00
|
|
|
/* we need to start the server in the background */
|
|
|
|
/* we create a PIPE that will be used to wait for the server's "OK" */
|
|
|
|
/* message since the pipe handles must be inheritable, we use a */
|
|
|
|
/* security attribute */
|
|
|
|
SECURITY_ATTRIBUTES sa;
|
|
|
|
sa.nLength = sizeof(sa);
|
|
|
|
sa.lpSecurityDescriptor = NULL;
|
|
|
|
sa.bInheritHandle = TRUE;
|
|
|
|
|
2015-08-27 09:46:09 +08:00
|
|
|
// Redirect stdin to Windows /dev/null. If we instead pass an original
|
|
|
|
// stdin/stdout/stderr handle and it is a console handle, when the adb
|
|
|
|
// server starts up, the C Runtime will see a console handle for a process
|
|
|
|
// that isn't connected to a console and it will configure
|
|
|
|
// stdin/stdout/stderr to be closed. At that point, freopen() could be used
|
|
|
|
// to reopen stderr/out, but it would take more massaging to fixup the file
|
|
|
|
// descriptor number that freopen() uses. It's simplest to avoid all of this
|
|
|
|
// complexity by just redirecting stdin to `nul' and then the C Runtime acts
|
|
|
|
// as expected.
|
|
|
|
unique_handle nul_read(CreateFileW(L"nul", GENERIC_READ,
|
|
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE, &sa, OPEN_EXISTING,
|
|
|
|
FILE_ATTRIBUTE_NORMAL, NULL));
|
|
|
|
if (nul_read.get() == INVALID_HANDLE_VALUE) {
|
|
|
|
fprintf(stderr, "Cannot open 'nul': %s\n",
|
2015-08-03 09:50:17 +08:00
|
|
|
SystemErrorCodeToString(GetLastError()).c_str());
|
2015-05-21 14:17:26 +08:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2015-08-27 09:46:09 +08:00
|
|
|
// create pipes with non-inheritable read handle, inheritable write handle
|
|
|
|
unique_handle ack_read, ack_write;
|
|
|
|
if (!_create_anonymous_pipe(&ack_read, &ack_write, &sa)) {
|
2015-05-21 14:17:26 +08:00
|
|
|
return -1;
|
|
|
|
}
|
2015-08-27 09:46:09 +08:00
|
|
|
unique_handle stdout_read, stdout_write;
|
|
|
|
if (!_create_anonymous_pipe(&stdout_read, &stdout_write, &sa)) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
unique_handle stderr_read, stderr_write;
|
|
|
|
if (!_create_anonymous_pipe(&stderr_read, &stderr_write, &sa)) {
|
2009-03-04 11:32:55 +08:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2012-11-29 09:18:50 +08:00
|
|
|
/* Some programs want to launch an adb command and collect its output by
|
|
|
|
* calling CreateProcess with inheritable stdout/stderr handles, then
|
|
|
|
* using read() to get its output. When this happens, the stdout/stderr
|
|
|
|
* handles passed to the adb client process will also be inheritable.
|
|
|
|
* When starting the adb server here, care must be taken to reset them
|
|
|
|
* to non-inheritable.
|
|
|
|
* Otherwise, something bad happens: even if the adb command completes,
|
|
|
|
* the calling process is stuck while read()-ing from the stdout/stderr
|
|
|
|
* descriptors, because they're connected to corresponding handles in the
|
|
|
|
* adb server process (even if the latter never uses/writes to them).
|
2015-08-27 09:46:09 +08:00
|
|
|
* Note that even if we don't pass these handles in the STARTUPINFO struct,
|
|
|
|
* if they're marked inheritable, they're still inherited, requiring us to
|
|
|
|
* deal with this.
|
|
|
|
*
|
|
|
|
* If we're still having problems with inheriting random handles in the
|
|
|
|
* future, consider using PROC_THREAD_ATTRIBUTE_HANDLE_LIST to explicitly
|
|
|
|
* specify which handles should be inherited: http://blogs.msdn.com/b/oldnewthing/archive/2011/12/16/10248328.aspx
|
2012-11-29 09:18:50 +08:00
|
|
|
*/
|
2015-08-27 09:46:09 +08:00
|
|
|
if (!_make_handle_noninheritable(GetStdHandle(STD_INPUT_HANDLE))) {
|
|
|
|
return -1;
|
2012-11-29 09:18:50 +08:00
|
|
|
}
|
2015-08-27 09:46:09 +08:00
|
|
|
if (!_make_handle_noninheritable(GetStdHandle(STD_OUTPUT_HANDLE))) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (!_make_handle_noninheritable(GetStdHandle(STD_ERROR_HANDLE))) {
|
|
|
|
return -1;
|
2012-11-29 09:18:50 +08:00
|
|
|
}
|
|
|
|
|
2015-08-27 09:46:09 +08:00
|
|
|
STARTUPINFOW startup;
|
2009-03-04 11:32:55 +08:00
|
|
|
ZeroMemory( &startup, sizeof(startup) );
|
|
|
|
startup.cb = sizeof(startup);
|
2015-08-27 09:46:09 +08:00
|
|
|
startup.hStdInput = nul_read.get();
|
|
|
|
startup.hStdOutput = stdout_write.get();
|
|
|
|
startup.hStdError = stderr_write.get();
|
2009-03-04 11:32:55 +08:00
|
|
|
startup.dwFlags = STARTF_USESTDHANDLES;
|
|
|
|
|
2015-08-09 06:07:07 +08:00
|
|
|
// Verify that the pipe_write handle value can be passed on the command line
|
|
|
|
// as %d and that the rest of adb code can pass it around in an int.
|
2015-08-27 09:46:09 +08:00
|
|
|
const int ack_write_as_int = cast_handle_to_int(ack_write.get());
|
|
|
|
if (cast_int_to_handle(ack_write_as_int) != ack_write.get()) {
|
2015-08-09 06:07:07 +08:00
|
|
|
// If this fires, either handle values are larger than 32-bits or else
|
|
|
|
// there is a bug in our casting.
|
|
|
|
// https://msdn.microsoft.com/en-us/library/windows/desktop/aa384203%28v=vs.85%29.aspx
|
2015-08-27 09:46:09 +08:00
|
|
|
fprintf(stderr, "Cannot fit pipe handle value into 32-bits: 0x%p\n",
|
|
|
|
ack_write.get());
|
2015-08-09 06:07:07 +08:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2015-08-27 09:46:09 +08:00
|
|
|
// get path of current program
|
|
|
|
WCHAR program_path[MAX_PATH];
|
|
|
|
const DWORD module_result = GetModuleFileNameW(NULL, program_path,
|
|
|
|
arraysize(program_path));
|
|
|
|
if ((module_result >= arraysize(program_path)) || (module_result == 0)) {
|
|
|
|
// String truncation or some other error.
|
|
|
|
fprintf(stderr, "Cannot get executable path: %s\n",
|
|
|
|
SystemErrorCodeToString(GetLastError()).c_str());
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
WCHAR args[64];
|
2015-05-11 16:08:48 +08:00
|
|
|
snwprintf(args, arraysize(args),
|
2015-08-09 06:07:07 +08:00
|
|
|
L"adb -P %d fork-server server --reply-fd %d", server_port,
|
2015-08-27 09:46:09 +08:00
|
|
|
ack_write_as_int);
|
|
|
|
|
|
|
|
PROCESS_INFORMATION pinfo;
|
|
|
|
ZeroMemory(&pinfo, sizeof(pinfo));
|
|
|
|
|
|
|
|
if (!CreateProcessW(
|
2009-03-04 11:32:55 +08:00
|
|
|
program_path, /* program path */
|
2013-11-13 16:23:37 +08:00
|
|
|
args,
|
2009-03-04 11:32:55 +08:00
|
|
|
/* the fork-server argument will set the
|
|
|
|
debug = 2 in the child */
|
|
|
|
NULL, /* process handle is not inheritable */
|
|
|
|
NULL, /* thread handle is not inheritable */
|
|
|
|
TRUE, /* yes, inherit some handles */
|
|
|
|
DETACHED_PROCESS, /* the new process doesn't have a console */
|
|
|
|
NULL, /* use parent's environment block */
|
|
|
|
NULL, /* use parent's starting directory */
|
|
|
|
&startup, /* startup info, i.e. std handles */
|
2015-08-27 09:46:09 +08:00
|
|
|
&pinfo )) {
|
|
|
|
fprintf(stderr, "Cannot create process: %s\n",
|
|
|
|
SystemErrorCodeToString(GetLastError()).c_str());
|
|
|
|
return -1;
|
|
|
|
}
|
2009-03-04 11:32:55 +08:00
|
|
|
|
2015-08-27 09:46:09 +08:00
|
|
|
unique_handle process_handle(pinfo.hProcess);
|
|
|
|
pinfo.hProcess = NULL;
|
|
|
|
|
|
|
|
// Close handles that we no longer need to complete the rest.
|
|
|
|
CloseHandle(pinfo.hThread);
|
|
|
|
pinfo.hThread = NULL;
|
|
|
|
|
|
|
|
nul_read.reset();
|
|
|
|
ack_write.reset();
|
|
|
|
stdout_write.reset();
|
|
|
|
stderr_write.reset();
|
|
|
|
|
|
|
|
// Start threads to read from subprocess stdout/stderr and write to ours
|
|
|
|
// to make subprocess errors easier to diagnose.
|
|
|
|
|
|
|
|
// In the past, reading from a pipe before the child process's C Runtime
|
|
|
|
// started up and called GetFileType() caused a hang: http://blogs.msdn.com/b/oldnewthing/archive/2011/12/02/10243553.aspx#10244216
|
|
|
|
// This is reportedly fixed in Windows Vista: https://support.microsoft.com/en-us/kb/2009703
|
|
|
|
// I was unable to reproduce the problem on Windows XP. It sounds like a
|
|
|
|
// Windows Update may have fixed this: https://www.duckware.com/tech/peeknamedpipe.html
|
|
|
|
unique_handle stdout_thread(reinterpret_cast<HANDLE>(
|
|
|
|
_beginthreadex(NULL, 0, _redirect_stdout_thread, stdout_read.get(),
|
|
|
|
0, NULL)));
|
|
|
|
if (stdout_thread.get() == nullptr) {
|
|
|
|
fprintf(stderr, "Cannot create thread: %s\n", strerror(errno));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
stdout_read.release(); // Transfer ownership to new thread
|
2009-03-04 11:32:55 +08:00
|
|
|
|
2015-08-27 09:46:09 +08:00
|
|
|
unique_handle stderr_thread(reinterpret_cast<HANDLE>(
|
|
|
|
_beginthreadex(NULL, 0, _redirect_stderr_thread, stderr_read.get(),
|
|
|
|
0, NULL)));
|
|
|
|
if (stderr_thread.get() == nullptr) {
|
|
|
|
fprintf(stderr, "Cannot create thread: %s\n", strerror(errno));
|
2009-03-04 11:32:55 +08:00
|
|
|
return -1;
|
|
|
|
}
|
2015-08-27 09:46:09 +08:00
|
|
|
stderr_read.release(); // Transfer ownership to new thread
|
2009-03-04 11:32:55 +08:00
|
|
|
|
2015-08-27 09:46:09 +08:00
|
|
|
bool got_ack = false;
|
2009-03-04 11:32:55 +08:00
|
|
|
|
2015-08-27 09:46:09 +08:00
|
|
|
// Wait for the "OK\n" message, for the pipe to be closed, or other error.
|
2009-03-04 11:32:55 +08:00
|
|
|
{
|
2015-08-27 09:46:09 +08:00
|
|
|
char temp[3];
|
|
|
|
DWORD count = 0;
|
|
|
|
|
|
|
|
if (ReadFile(ack_read.get(), temp, sizeof(temp), &count, NULL)) {
|
|
|
|
const CHAR expected[] = "OK\n";
|
|
|
|
const DWORD expected_length = arraysize(expected) - 1;
|
|
|
|
if (count == expected_length &&
|
|
|
|
memcmp(temp, expected, expected_length) == 0) {
|
|
|
|
got_ack = true;
|
|
|
|
} else {
|
|
|
|
fprintf(stderr, "ADB server didn't ACK\n");
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
const DWORD err = GetLastError();
|
|
|
|
// If the ACK was not written and the process exited, GetLastError()
|
|
|
|
// is probably ERROR_BROKEN_PIPE, in which case that info is not
|
|
|
|
// useful to the user.
|
|
|
|
fprintf(stderr, "could not read ok from ADB Server%s\n",
|
|
|
|
err == ERROR_BROKEN_PIPE ? "" :
|
|
|
|
android::base::StringPrintf(": %s",
|
|
|
|
SystemErrorCodeToString(err).c_str()).c_str());
|
2009-03-04 11:32:55 +08:00
|
|
|
}
|
2015-08-27 09:46:09 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Always try to wait a bit for threads reading stdout/stderr to finish.
|
|
|
|
// If the process started ok, it should close the pipes causing the threads
|
|
|
|
// to finish. If the process had an error, it should exit, also causing
|
|
|
|
// the pipes to be closed. In that case we want to read all of the output
|
|
|
|
// and write it out so that the user can diagnose failures.
|
|
|
|
const DWORD thread_timeout_ms = 15 * 1000;
|
|
|
|
const HANDLE threads[] = { stdout_thread.get(), stderr_thread.get() };
|
|
|
|
const DWORD wait_result = WaitForMultipleObjects(arraysize(threads),
|
|
|
|
threads, TRUE, thread_timeout_ms);
|
|
|
|
if (wait_result == WAIT_TIMEOUT) {
|
|
|
|
// Threads did not finish after waiting a little while. Perhaps the
|
|
|
|
// server didn't close pipes, or it is hung.
|
|
|
|
fprintf(stderr, "Timed-out waiting for threads to finish reading from "
|
|
|
|
"ADB Server\n");
|
|
|
|
// Process handles are signaled when the process exits, so if we wait
|
|
|
|
// on the handle for 0 seconds and it returns 'timeout', that means that
|
|
|
|
// the process is still running.
|
|
|
|
if (WaitForSingleObject(process_handle.get(), 0) == WAIT_TIMEOUT) {
|
|
|
|
// We could TerminateProcess(), but that seems somewhat presumptive.
|
|
|
|
fprintf(stderr, "ADB Server is running: process id %lu\n",
|
|
|
|
pinfo.dwProcessId);
|
2009-03-04 11:32:55 +08:00
|
|
|
}
|
2015-08-27 09:46:09 +08:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (wait_result != WAIT_OBJECT_0) {
|
|
|
|
fprintf(stderr, "Unexpected result waiting for threads: %lu: %s\n",
|
|
|
|
wait_result, SystemErrorCodeToString(GetLastError()).c_str());
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
// For now ignore the thread exit codes and assume they worked properly.
|
|
|
|
|
|
|
|
if (!got_ack) {
|
|
|
|
return -1;
|
2009-03-04 11:32:55 +08:00
|
|
|
}
|
2014-11-12 01:24:11 +08:00
|
|
|
#else /* !defined(_WIN32) */
|
2009-03-04 11:32:55 +08:00
|
|
|
char path[PATH_MAX];
|
|
|
|
int fd[2];
|
|
|
|
|
|
|
|
// set up a pipe so the child can tell us when it is ready.
|
2015-08-08 01:10:29 +08:00
|
|
|
// fd[0] will be parent's end, and the child will write on fd[1]
|
2009-03-04 11:32:55 +08:00
|
|
|
if (pipe(fd)) {
|
|
|
|
fprintf(stderr, "pipe failed in launch_server, errno: %d\n", errno);
|
|
|
|
return -1;
|
|
|
|
}
|
2009-10-21 23:55:00 +08:00
|
|
|
get_my_path(path, PATH_MAX);
|
2009-03-04 11:32:55 +08:00
|
|
|
pid_t pid = fork();
|
|
|
|
if(pid < 0) return -1;
|
|
|
|
|
|
|
|
if (pid == 0) {
|
|
|
|
// child side of the fork
|
|
|
|
|
|
|
|
adb_close(fd[0]);
|
|
|
|
|
2012-11-15 02:16:17 +08:00
|
|
|
char str_port[30];
|
2015-08-08 01:10:29 +08:00
|
|
|
snprintf(str_port, sizeof(str_port), "%d", server_port);
|
|
|
|
char reply_fd[30];
|
|
|
|
snprintf(reply_fd, sizeof(reply_fd), "%d", fd[1]);
|
2009-03-04 11:32:55 +08:00
|
|
|
// child process
|
2015-08-08 01:10:29 +08:00
|
|
|
int result = execl(path, "adb", "-P", str_port, "fork-server", "server", "--reply-fd", reply_fd, NULL);
|
2009-03-04 11:32:55 +08:00
|
|
|
// this should not return
|
|
|
|
fprintf(stderr, "OOPS! execl returned %d, errno: %d\n", result, errno);
|
|
|
|
} else {
|
|
|
|
// parent side of the fork
|
|
|
|
|
|
|
|
char temp[3];
|
|
|
|
|
|
|
|
temp[0] = 'A'; temp[1] = 'B'; temp[2] = 'C';
|
|
|
|
// wait for the "OK\n" message
|
|
|
|
adb_close(fd[1]);
|
|
|
|
int ret = adb_read(fd[0], temp, 3);
|
2011-03-17 06:57:42 +08:00
|
|
|
int saved_errno = errno;
|
2009-03-04 11:32:55 +08:00
|
|
|
adb_close(fd[0]);
|
|
|
|
if (ret < 0) {
|
2011-03-17 06:57:42 +08:00
|
|
|
fprintf(stderr, "could not read ok from ADB Server, errno = %d\n", saved_errno);
|
2009-03-04 11:32:55 +08:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (ret != 3 || temp[0] != 'O' || temp[1] != 'K' || temp[2] != '\n') {
|
|
|
|
fprintf(stderr, "ADB server didn't ACK\n" );
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
setsid();
|
|
|
|
}
|
2014-11-12 01:24:11 +08:00
|
|
|
#endif /* !defined(_WIN32) */
|
2009-03-04 11:32:55 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2014-11-12 01:24:11 +08:00
|
|
|
#endif /* ADB_HOST */
|
2009-03-04 11:32:55 +08:00
|
|
|
|
2013-03-22 04:07:42 +08:00
|
|
|
// Try to handle a network forwarding request.
|
|
|
|
// This returns 1 on success, 0 on failure, and -1 to indicate this is not
|
|
|
|
// a forwarding-related request.
|
2015-05-08 12:38:41 +08:00
|
|
|
int handle_forward_request(const char* service, TransportType type, const char* serial, int reply_fd)
|
2013-03-22 04:07:42 +08:00
|
|
|
{
|
|
|
|
if (!strcmp(service, "list-forward")) {
|
|
|
|
// Create the list of forward redirections.
|
2015-05-01 08:32:03 +08:00
|
|
|
std::string listeners = format_listeners();
|
2013-03-22 04:07:42 +08:00
|
|
|
#if ADB_HOST
|
2015-05-01 08:32:03 +08:00
|
|
|
SendOkay(reply_fd);
|
2013-03-22 04:07:42 +08:00
|
|
|
#endif
|
2015-05-01 08:32:03 +08:00
|
|
|
SendProtocolString(reply_fd, listeners);
|
2013-03-22 04:07:42 +08:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!strcmp(service, "killforward-all")) {
|
|
|
|
remove_all_listeners();
|
|
|
|
#if ADB_HOST
|
|
|
|
/* On the host: 1st OKAY is connect, 2nd OKAY is status */
|
2015-05-01 08:32:03 +08:00
|
|
|
SendOkay(reply_fd);
|
2013-03-22 04:07:42 +08:00
|
|
|
#endif
|
2015-05-01 08:32:03 +08:00
|
|
|
SendOkay(reply_fd);
|
2013-03-22 04:07:42 +08:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2015-05-30 08:55:19 +08:00
|
|
|
if (!strncmp(service, "forward:", 8) || !strncmp(service, "killforward:", 12)) {
|
|
|
|
// killforward:local
|
|
|
|
// forward:(norebind:)?local;remote
|
|
|
|
bool kill_forward = false;
|
|
|
|
bool no_rebind = false;
|
|
|
|
if (android::base::StartsWith(service, "killforward:")) {
|
|
|
|
kill_forward = true;
|
|
|
|
service += 12;
|
2015-07-30 08:21:21 +08:00
|
|
|
} else {
|
|
|
|
service += 8; // skip past "forward:"
|
2015-05-30 08:55:19 +08:00
|
|
|
if (android::base::StartsWith(service, "norebind:")) {
|
|
|
|
no_rebind = true;
|
|
|
|
service += 9;
|
|
|
|
}
|
2013-03-22 04:07:42 +08:00
|
|
|
}
|
|
|
|
|
2015-05-30 08:55:19 +08:00
|
|
|
std::vector<std::string> pieces = android::base::Split(service, ";");
|
2013-03-22 04:07:42 +08:00
|
|
|
|
2015-05-30 08:55:19 +08:00
|
|
|
if (kill_forward) {
|
|
|
|
// Check killforward: parameter format: '<local>'
|
|
|
|
if (pieces.size() != 1 || pieces[0].empty()) {
|
|
|
|
SendFail(reply_fd, android::base::StringPrintf("bad killforward: %s", service));
|
2013-03-22 04:07:42 +08:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
} else {
|
2015-05-30 08:55:19 +08:00
|
|
|
// Check forward: parameter format: '<local>;<remote>'
|
|
|
|
if (pieces.size() != 2 || pieces[0].empty() || pieces[1].empty() || pieces[1][0] == '*') {
|
|
|
|
SendFail(reply_fd, android::base::StringPrintf("bad forward: %s", service));
|
2013-03-22 04:07:42 +08:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-04-17 13:54:44 +08:00
|
|
|
std::string error_msg;
|
2015-05-30 08:55:19 +08:00
|
|
|
atransport* transport = acquire_one_transport(kCsAny, type, serial, &error_msg);
|
2013-03-22 04:07:42 +08:00
|
|
|
if (!transport) {
|
2015-05-01 08:32:03 +08:00
|
|
|
SendFail(reply_fd, error_msg);
|
2013-03-22 04:07:42 +08:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2015-07-31 14:07:55 +08:00
|
|
|
std::string error;
|
2015-05-06 04:10:43 +08:00
|
|
|
InstallStatus r;
|
2015-05-30 08:55:19 +08:00
|
|
|
if (kill_forward) {
|
|
|
|
r = remove_listener(pieces[0].c_str(), transport);
|
2013-03-22 04:07:42 +08:00
|
|
|
} else {
|
2015-07-31 14:07:55 +08:00
|
|
|
r = install_listener(pieces[0], pieces[1].c_str(), transport,
|
|
|
|
no_rebind, &error);
|
2013-03-22 04:07:42 +08:00
|
|
|
}
|
2015-04-20 23:09:20 +08:00
|
|
|
if (r == INSTALL_STATUS_OK) {
|
2013-03-22 04:07:42 +08:00
|
|
|
#if ADB_HOST
|
|
|
|
/* On the host: 1st OKAY is connect, 2nd OKAY is status */
|
2015-05-01 08:32:03 +08:00
|
|
|
SendOkay(reply_fd);
|
2013-03-22 04:07:42 +08:00
|
|
|
#endif
|
2015-05-01 08:32:03 +08:00
|
|
|
SendOkay(reply_fd);
|
2013-03-22 04:07:42 +08:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2015-04-20 23:09:20 +08:00
|
|
|
std::string message;
|
|
|
|
switch (r) {
|
2015-05-30 08:55:19 +08:00
|
|
|
case INSTALL_STATUS_OK: message = "success (!)"; break;
|
2015-04-20 23:09:20 +08:00
|
|
|
case INSTALL_STATUS_INTERNAL_ERROR: message = "internal error"; break;
|
|
|
|
case INSTALL_STATUS_CANNOT_BIND:
|
2015-08-12 07:45:32 +08:00
|
|
|
message = android::base::StringPrintf("cannot bind listener: %s",
|
2015-07-31 14:07:55 +08:00
|
|
|
error.c_str());
|
2015-04-20 23:09:20 +08:00
|
|
|
break;
|
|
|
|
case INSTALL_STATUS_CANNOT_REBIND:
|
2015-07-30 08:21:21 +08:00
|
|
|
message = android::base::StringPrintf("cannot rebind existing socket");
|
2015-04-20 23:09:20 +08:00
|
|
|
break;
|
2015-05-30 08:55:19 +08:00
|
|
|
case INSTALL_STATUS_LISTENER_NOT_FOUND:
|
|
|
|
message = android::base::StringPrintf("listener '%s' not found", service);
|
|
|
|
break;
|
2013-03-22 04:07:42 +08:00
|
|
|
}
|
2015-05-01 08:32:03 +08:00
|
|
|
SendFail(reply_fd, message);
|
2013-03-22 04:07:42 +08:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-06-24 04:00:32 +08:00
|
|
|
#if ADB_HOST
|
|
|
|
static int SendOkay(int fd, const std::string& s) {
|
|
|
|
SendOkay(fd);
|
|
|
|
SendProtocolString(fd, s);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2015-05-09 07:13:53 +08:00
|
|
|
int handle_host_request(const char* service, TransportType type,
|
|
|
|
const char* serial, int reply_fd, asocket* s) {
|
|
|
|
if (strcmp(service, "kill") == 0) {
|
|
|
|
fprintf(stderr, "adb server killed by remote request\n");
|
2009-03-04 11:32:55 +08:00
|
|
|
fflush(stdout);
|
2015-05-01 08:32:03 +08:00
|
|
|
SendOkay(reply_fd);
|
2015-08-12 08:05:02 +08:00
|
|
|
|
|
|
|
// At least on Windows, if we exit() without shutdown(SD_SEND) or
|
|
|
|
// closesocket(), the client's next recv() will error-out with
|
|
|
|
// WSAECONNRESET and they'll never read the OKAY.
|
|
|
|
adb_shutdown(reply_fd);
|
|
|
|
|
2009-03-04 11:32:55 +08:00
|
|
|
exit(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
#if ADB_HOST
|
|
|
|
// "transport:" is used for switching transport with a specified serial number
|
|
|
|
// "transport-usb:" is used for switching transport to the only USB transport
|
|
|
|
// "transport-local:" is used for switching transport to the only local transport
|
|
|
|
// "transport-any:" is used for switching transport to the only transport
|
|
|
|
if (!strncmp(service, "transport", strlen("transport"))) {
|
2015-05-06 04:10:43 +08:00
|
|
|
TransportType type = kTransportAny;
|
2009-03-04 11:32:55 +08:00
|
|
|
|
|
|
|
if (!strncmp(service, "transport-usb", strlen("transport-usb"))) {
|
|
|
|
type = kTransportUsb;
|
|
|
|
} else if (!strncmp(service, "transport-local", strlen("transport-local"))) {
|
|
|
|
type = kTransportLocal;
|
|
|
|
} else if (!strncmp(service, "transport-any", strlen("transport-any"))) {
|
|
|
|
type = kTransportAny;
|
|
|
|
} else if (!strncmp(service, "transport:", strlen("transport:"))) {
|
|
|
|
service += strlen("transport:");
|
2011-07-28 01:56:14 +08:00
|
|
|
serial = service;
|
2009-03-04 11:32:55 +08:00
|
|
|
}
|
|
|
|
|
2015-06-24 04:00:32 +08:00
|
|
|
std::string error_msg;
|
|
|
|
atransport* t = acquire_one_transport(kCsAny, type, serial, &error_msg);
|
|
|
|
if (t != nullptr) {
|
|
|
|
s->transport = t;
|
2015-05-01 08:32:03 +08:00
|
|
|
SendOkay(reply_fd);
|
2009-03-04 11:32:55 +08:00
|
|
|
} else {
|
2015-05-01 08:32:03 +08:00
|
|
|
SendFail(reply_fd, error_msg);
|
2009-03-04 11:32:55 +08:00
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
// return a list of all connected devices
|
2012-04-21 02:21:14 +08:00
|
|
|
if (!strncmp(service, "devices", 7)) {
|
2015-05-01 08:32:03 +08:00
|
|
|
bool long_listing = (strcmp(service+7, "-l") == 0);
|
|
|
|
if (long_listing || service[7] == 0) {
|
2015-09-03 08:44:28 +08:00
|
|
|
D("Getting device list...");
|
2015-05-01 08:32:03 +08:00
|
|
|
std::string device_list = list_transports(long_listing);
|
2015-09-03 08:44:28 +08:00
|
|
|
D("Sending device list...");
|
2015-06-24 04:00:32 +08:00
|
|
|
return SendOkay(reply_fd, device_list);
|
2012-04-21 02:21:14 +08:00
|
|
|
}
|
2015-05-01 08:32:03 +08:00
|
|
|
return 1;
|
2009-03-04 11:32:55 +08:00
|
|
|
}
|
|
|
|
|
2015-05-21 09:58:41 +08:00
|
|
|
if (!strcmp(service, "features")) {
|
|
|
|
SendOkay(reply_fd);
|
|
|
|
SendProtocolString(
|
|
|
|
reply_fd, android::base::Join(supported_features(), '\n'));
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-10-12 11:04:18 +08:00
|
|
|
// remove TCP transport
|
|
|
|
if (!strncmp(service, "disconnect:", 11)) {
|
2015-07-19 03:21:30 +08:00
|
|
|
const std::string address(service + 11);
|
|
|
|
if (address.empty()) {
|
2015-08-28 03:03:11 +08:00
|
|
|
kick_all_tcp_devices();
|
2015-07-19 03:21:30 +08:00
|
|
|
return SendOkay(reply_fd, "disconnected everything");
|
2009-10-12 11:04:18 +08:00
|
|
|
}
|
|
|
|
|
2015-07-19 03:21:30 +08:00
|
|
|
std::string serial;
|
|
|
|
std::string host;
|
|
|
|
int port = DEFAULT_ADB_LOCAL_TRANSPORT_PORT;
|
|
|
|
std::string error;
|
|
|
|
if (!parse_host_and_port(address, &serial, &host, &port, &error)) {
|
|
|
|
return SendFail(reply_fd, android::base::StringPrintf("couldn't parse '%s': %s",
|
|
|
|
address.c_str(), error.c_str()));
|
|
|
|
}
|
|
|
|
atransport* t = find_transport(serial.c_str());
|
|
|
|
if (t == nullptr) {
|
|
|
|
return SendFail(reply_fd, android::base::StringPrintf("no such device '%s'",
|
|
|
|
serial.c_str()));
|
|
|
|
}
|
2015-08-28 03:03:11 +08:00
|
|
|
kick_transport(t);
|
2015-07-19 03:21:30 +08:00
|
|
|
return SendOkay(reply_fd, android::base::StringPrintf("disconnected %s", address.c_str()));
|
2009-08-25 06:58:40 +08:00
|
|
|
}
|
|
|
|
|
2009-03-04 11:32:55 +08:00
|
|
|
// returns our value for ADB_SERVER_VERSION
|
|
|
|
if (!strcmp(service, "version")) {
|
2015-06-24 04:00:32 +08:00
|
|
|
return SendOkay(reply_fd, android::base::StringPrintf("%04x", ADB_SERVER_VERSION));
|
2009-03-04 11:32:55 +08:00
|
|
|
}
|
|
|
|
|
2015-06-24 04:00:32 +08:00
|
|
|
// These always report "unknown" rather than the actual error, for scripts.
|
|
|
|
if (!strcmp(service, "get-serialno")) {
|
|
|
|
std::string ignored;
|
|
|
|
atransport* t = acquire_one_transport(kCsAny, type, serial, &ignored);
|
|
|
|
return SendOkay(reply_fd, (t && t->serial) ? t->serial : "unknown");
|
2009-03-04 11:32:55 +08:00
|
|
|
}
|
2015-06-24 04:00:32 +08:00
|
|
|
if (!strcmp(service, "get-devpath")) {
|
|
|
|
std::string ignored;
|
|
|
|
atransport* t = acquire_one_transport(kCsAny, type, serial, &ignored);
|
|
|
|
return SendOkay(reply_fd, (t && t->devpath) ? t->devpath : "unknown");
|
2012-04-21 02:21:14 +08:00
|
|
|
}
|
2015-06-24 04:00:32 +08:00
|
|
|
if (!strcmp(service, "get-state")) {
|
|
|
|
std::string ignored;
|
|
|
|
atransport* t = acquire_one_transport(kCsAny, type, serial, &ignored);
|
|
|
|
return SendOkay(reply_fd, t ? t->connection_state_name() : "unknown");
|
|
|
|
}
|
|
|
|
|
2009-03-04 11:32:55 +08:00
|
|
|
// indicates a new emulator instance has started
|
2015-06-24 04:00:32 +08:00
|
|
|
if (!strncmp(service, "emulator:", 9)) {
|
2009-03-04 11:32:55 +08:00
|
|
|
int port = atoi(service+9);
|
|
|
|
local_connect(port);
|
|
|
|
/* we don't even need to send a reply */
|
|
|
|
return 0;
|
|
|
|
}
|
2014-07-15 08:23:06 +08:00
|
|
|
#endif // ADB_HOST
|
|
|
|
|
2015-05-06 04:10:43 +08:00
|
|
|
int ret = handle_forward_request(service, type, serial, reply_fd);
|
2014-07-15 08:23:06 +08:00
|
|
|
if (ret >= 0)
|
|
|
|
return ret - 1;
|
2009-03-04 11:32:55 +08:00
|
|
|
return -1;
|
|
|
|
}
|