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-09-23 06:52:57 +08:00
|
|
|
#define TRACE_TAG ADB
|
2015-03-20 06:21:08 +08:00
|
|
|
|
|
|
|
#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>
|
2009-03-04 11:32:55 +08:00
|
|
|
|
2016-01-28 00:52:53 +08:00
|
|
|
#include <android-base/errors.h>
|
2016-09-01 06:07:18 +08:00
|
|
|
#include <android-base/file.h>
|
2015-12-05 14:00:26 +08:00
|
|
|
#include <android-base/logging.h>
|
|
|
|
#include <android-base/macros.h>
|
2016-01-22 00:40:59 +08:00
|
|
|
#include <android-base/parsenetaddress.h>
|
2015-12-05 14:00:26 +08:00
|
|
|
#include <android-base/stringprintf.h>
|
|
|
|
#include <android-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
|
|
|
|
|
|
|
#if !ADB_HOST
|
2013-03-01 06:12:58 +08:00
|
|
|
#include <sys/capability.h>
|
2012-08-15 12:00:22 +08:00
|
|
|
#include <sys/mount.h>
|
2016-09-24 06:40:03 +08:00
|
|
|
#include <android-base/properties.h>
|
2009-03-04 11:32:55 +08:00
|
|
|
#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);
|
2016-05-14 09:16:43 +08:00
|
|
|
char buf[1024];
|
|
|
|
vsnprintf(buf, sizeof(buf), fmt, ap);
|
|
|
|
|
|
|
|
#if ADB_HOST
|
|
|
|
fprintf(stderr, "error: %s\n", buf);
|
|
|
|
#else
|
|
|
|
LOG(ERROR) << "error: " << buf;
|
|
|
|
#endif
|
|
|
|
|
2009-03-04 11:32:55 +08:00
|
|
|
va_end(ap);
|
2016-05-14 09:16:43 +08:00
|
|
|
abort();
|
2009-03-04 11:32:55 +08:00
|
|
|
}
|
|
|
|
|
2015-05-22 04:58:50 +08:00
|
|
|
void fatal_errno(const char* fmt, ...) {
|
2016-05-14 09:16:43 +08:00
|
|
|
int err = errno;
|
2009-03-04 11:32:55 +08:00
|
|
|
va_list ap;
|
|
|
|
va_start(ap, fmt);
|
2016-05-14 09:16:43 +08:00
|
|
|
char buf[1024];
|
|
|
|
vsnprintf(buf, sizeof(buf), fmt, ap);
|
|
|
|
|
|
|
|
#if ADB_HOST
|
|
|
|
fprintf(stderr, "error: %s: %s\n", buf, strerror(err));
|
|
|
|
#else
|
|
|
|
LOG(ERROR) << "error: " << buf << ": " << strerror(err);
|
|
|
|
#endif
|
|
|
|
|
2009-03-04 11:32:55 +08:00
|
|
|
va_end(ap);
|
2016-05-14 09:16:43 +08:00
|
|
|
abort();
|
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
|
|
|
|
2016-09-24 06:40:03 +08:00
|
|
|
for (const auto& prop : cnxn_props) {
|
|
|
|
std::string value = std::string(prop) + "=" + android::base::GetProperty(prop, "");
|
|
|
|
connection_properties.push_back(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(
|
2015-09-23 01:43:08 +08:00
|
|
|
"features=%s", FeatureSetToString(supported_features()).c_str()));
|
2015-05-19 04:06:53 +08:00
|
|
|
|
|
|
|
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, ":");
|
|
|
|
|
2015-09-26 04:04:21 +08:00
|
|
|
// Reset the features list or else if the server sends no features we may
|
|
|
|
// keep the existing feature set (http://b/24405971).
|
|
|
|
t->SetFeatures("");
|
|
|
|
|
2015-04-25 14:02:00 +08:00
|
|
|
if (pieces.size() > 2) {
|
|
|
|
const std::string& props = pieces[2];
|
2015-10-08 06:59:35 +08:00
|
|
|
for (const auto& prop : android::base::Split(props, ";")) {
|
2015-04-25 14:02:00 +08:00
|
|
|
// 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") {
|
2015-09-23 01:43:08 +08:00
|
|
|
t->SetFeatures(value);
|
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)
|
|
|
|
{
|
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:
|
2016-06-16 05:46:56 +08:00
|
|
|
if (p->msg.arg0){
|
2009-03-04 11:32:55 +08:00
|
|
|
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;
|
2016-06-30 08:42:01 +08:00
|
|
|
send_auth_response(p->data, p->msg.data_length, 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
|
|
|
} else if (p->msg.arg0 == ADB_AUTH_SIGNATURE) {
|
2016-06-30 08:42:01 +08:00
|
|
|
if (adb_auth_verify(t->token, sizeof(t->token), p->data, p->msg.data_length)) {
|
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
|
|
|
adb_auth_verified(t);
|
|
|
|
t->failed_auth_attempts = 0;
|
|
|
|
} else {
|
2016-08-23 04:12:32 +08:00
|
|
|
if (t->failed_auth_attempts++ > 256) adb_sleep_ms(1000);
|
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
|
|
|
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;
|
2016-06-16 05:46:56 +08:00
|
|
|
asocket* s = create_local_service_socket(name, t);
|
|
|
|
if (s == nullptr) {
|
2009-03-04 11:32:55 +08:00
|
|
|
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) {
|
2016-06-16 05:46:56 +08:00
|
|
|
asocket* s = find_local_socket(p->msg.arg1, 0);
|
|
|
|
if (s) {
|
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
|
|
|
}
|
2015-09-30 03:25:33 +08:00
|
|
|
} else {
|
|
|
|
// When receiving A_OKAY from device for A_OPEN request, the host server may
|
|
|
|
// have closed the local socket because of client disconnection. Then we need
|
|
|
|
// to send A_CLSE back to device to close the service on device.
|
|
|
|
send_close(p->msg.arg1, p->msg.arg0, t);
|
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) {
|
2016-06-16 05:46:56 +08:00
|
|
|
asocket* s = find_local_socket(p->msg.arg1, p->msg.arg0);
|
|
|
|
if (s) {
|
2013-12-13 21:09:44 +08:00
|
|
|
/* 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) {
|
2016-06-16 05:46:56 +08:00
|
|
|
asocket* s = find_local_socket(p->msg.arg1, p->msg.arg0);
|
|
|
|
if (s) {
|
2009-03-04 11:32:55 +08:00
|
|
|
unsigned rid = p->msg.arg0;
|
|
|
|
p->len = p->msg.data_length;
|
|
|
|
|
2016-06-16 05:46:56 +08:00
|
|
|
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
|
|
|
|
|
2015-09-17 07:40:06 +08:00
|
|
|
// Try to make a handle non-inheritable and if there is an error, don't output
|
|
|
|
// any error info, but leave GetLastError() for the caller to read. This is
|
|
|
|
// convenient if the caller is expecting that this may fail and they'd like to
|
|
|
|
// ignore such a failure.
|
|
|
|
static bool _try_make_handle_noninheritable(HANDLE h) {
|
2015-08-27 09:46:09 +08:00
|
|
|
if (h != INVALID_HANDLE_VALUE && h != NULL) {
|
2015-09-17 07:40:06 +08:00
|
|
|
return SetHandleInformation(h, HANDLE_FLAG_INHERIT, 0) ? true : false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Try to make a handle non-inheritable with the expectation that this should
|
|
|
|
// succeed, so if this fails, output error info.
|
|
|
|
static bool _make_handle_noninheritable(HANDLE h) {
|
|
|
|
if (!_try_make_handle_noninheritable(h)) {
|
|
|
|
// 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",
|
2016-01-28 00:52:53 +08:00
|
|
|
h, android::base::SystemErrorCodeToString(GetLastError()).c_str());
|
2015-09-17 07:40:06 +08:00
|
|
|
return false;
|
2015-08-27 09:46:09 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
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",
|
2016-01-28 00:52:53 +08:00
|
|
|
android::base::SystemErrorCodeToString(GetLastError()).c_str());
|
2015-08-27 09:46:09 +08:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2015-11-22 09:23:51 +08:00
|
|
|
// Read from a pipe (that we take ownership of) and write the result to stdout/stderr. Return on
|
|
|
|
// error or when the pipe is closed. Internally makes inheritable handles, so this should not be
|
|
|
|
// called if subprocesses may be started concurrently.
|
2015-08-27 09:46:09 +08:00
|
|
|
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);
|
2015-11-22 09:23:51 +08:00
|
|
|
const char* output_name = nStdHandle == STD_OUTPUT_HANDLE ? "stdout" : "stderr";
|
|
|
|
const int original_fd = fileno(nStdHandle == STD_OUTPUT_HANDLE ? stdout : stderr);
|
|
|
|
std::unique_ptr<FILE, decltype(&fclose)> stream(nullptr, fclose);
|
|
|
|
|
|
|
|
if (original_fd == -1) {
|
|
|
|
fprintf(stderr, "Failed to get file descriptor for %s: %s\n", output_name, strerror(errno));
|
|
|
|
return EXIT_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If fileno() is -2, stdout/stderr is not associated with an output stream, so we should read,
|
|
|
|
// but don't write. Otherwise, make a FILE* identical to stdout/stderr except that it is in
|
|
|
|
// binary mode with no CR/LR translation since we're reading raw.
|
|
|
|
if (original_fd >= 0) {
|
|
|
|
// This internally makes a duplicate file handle that is inheritable, so callers should not
|
|
|
|
// call this function if subprocesses may be started concurrently.
|
|
|
|
const int fd = dup(original_fd);
|
|
|
|
if (fd == -1) {
|
|
|
|
fprintf(stderr, "Failed to duplicate file descriptor for %s: %s\n", output_name,
|
|
|
|
strerror(errno));
|
|
|
|
return EXIT_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Note that although we call fdopen() below with a binary flag, it may not adhere to that
|
|
|
|
// flag, so we have to set the mode manually.
|
|
|
|
if (_setmode(fd, _O_BINARY) == -1) {
|
|
|
|
fprintf(stderr, "Failed to set binary mode for duplicate of %s: %s\n", output_name,
|
|
|
|
strerror(errno));
|
|
|
|
unix_close(fd);
|
|
|
|
return EXIT_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
stream.reset(fdopen(fd, "wb"));
|
|
|
|
if (stream.get() == nullptr) {
|
|
|
|
fprintf(stderr, "Failed to open duplicate stream for %s: %s\n", output_name,
|
|
|
|
strerror(errno));
|
|
|
|
unix_close(fd);
|
|
|
|
return EXIT_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Unbuffer the stream because it will be buffered by default and we want subprocess output
|
|
|
|
// to be shown immediately.
|
|
|
|
if (setvbuf(stream.get(), NULL, _IONBF, 0) == -1) {
|
|
|
|
fprintf(stderr, "Failed to unbuffer %s: %s\n", output_name, strerror(errno));
|
|
|
|
return EXIT_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
// fd will be closed when stream is closed.
|
|
|
|
}
|
2015-08-27 09:46:09 +08:00
|
|
|
|
|
|
|
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,
|
2016-01-28 00:52:53 +08:00
|
|
|
android::base::SystemErrorCodeToString(err).c_str());
|
2015-08-27 09:46:09 +08:00
|
|
|
return EXIT_FAILURE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-11-22 09:23:51 +08:00
|
|
|
// Don't try to write if our stdout/stderr was not setup by the parent process.
|
|
|
|
if (stream) {
|
|
|
|
// fwrite() actually calls adb_fwrite() which can write UTF-8 to the console.
|
|
|
|
const size_t bytes_written = fwrite(buf, 1, bytes_read, stream.get());
|
2015-08-27 09:46:09 +08:00
|
|
|
if (bytes_written != bytes_read) {
|
2015-11-22 09:23:51 +08:00
|
|
|
fprintf(stderr, "Only wrote %zu of %lu bytes to %s\n", bytes_written, bytes_read,
|
|
|
|
output_name);
|
2015-08-27 09:46:09 +08:00
|
|
|
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
|
|
|
|
|
2016-08-26 07:00:22 +08:00
|
|
|
int launch_server(const std::string& socket_spec) {
|
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",
|
2016-01-28 00:52:53 +08:00
|
|
|
android::base::SystemErrorCodeToString(GetLastError()).c_str());
|
2015-05-21 14:17:26 +08:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2015-11-22 09:23:51 +08:00
|
|
|
// Create pipes with non-inheritable read handle, inheritable write handle. We need to connect
|
|
|
|
// the subprocess to pipes instead of just letting the subprocess inherit our existing
|
|
|
|
// stdout/stderr handles because a DETACHED_PROCESS cannot write to a console that it is not
|
|
|
|
// attached to.
|
2015-08-27 09:46:09 +08:00
|
|
|
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
|
2015-09-17 07:40:06 +08:00
|
|
|
*
|
|
|
|
* Older versions of Windows return console pseudo-handles that cannot be
|
|
|
|
* made non-inheritable, so ignore those failures.
|
2012-11-29 09:18:50 +08:00
|
|
|
*/
|
2015-09-17 07:40:06 +08:00
|
|
|
_try_make_handle_noninheritable(GetStdHandle(STD_INPUT_HANDLE));
|
|
|
|
_try_make_handle_noninheritable(GetStdHandle(STD_OUTPUT_HANDLE));
|
|
|
|
_try_make_handle_noninheritable(GetStdHandle(STD_ERROR_HANDLE));
|
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",
|
2016-01-28 00:52:53 +08:00
|
|
|
android::base::SystemErrorCodeToString(GetLastError()).c_str());
|
2015-08-27 09:46:09 +08:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
WCHAR args[64];
|
2016-08-26 07:00:22 +08:00
|
|
|
snwprintf(args, arraysize(args), L"adb -L %s fork-server server --reply-fd %d",
|
|
|
|
socket_spec.c_str(), ack_write_as_int);
|
2015-08-27 09:46:09 +08:00
|
|
|
|
|
|
|
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",
|
2016-01-28 00:52:53 +08:00
|
|
|
android::base::SystemErrorCodeToString(GetLastError()).c_str());
|
2015-08-27 09:46:09 +08:00
|
|
|
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();
|
|
|
|
|
2015-11-22 09:23:51 +08:00
|
|
|
// Start threads to read from subprocess stdout/stderr and write to ours to make subprocess
|
|
|
|
// errors easier to diagnose. Note that the threads internally create inheritable handles, but
|
|
|
|
// that is ok because we've already spawned the subprocess.
|
2015-08-27 09:46:09 +08:00
|
|
|
|
|
|
|
// 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",
|
2016-01-28 00:52:53 +08:00
|
|
|
android::base::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",
|
2016-01-28 00:52:53 +08:00
|
|
|
wait_result, android::base::SystemErrorCodeToString(GetLastError()).c_str());
|
2015-08-27 09:46:09 +08:00
|
|
|
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
|
|
|
// 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]
|
2016-09-01 06:07:18 +08:00
|
|
|
int fd[2];
|
2009-03-04 11:32:55 +08:00
|
|
|
if (pipe(fd)) {
|
|
|
|
fprintf(stderr, "pipe failed in launch_server, errno: %d\n", errno);
|
|
|
|
return -1;
|
|
|
|
}
|
2016-09-01 06:07:18 +08:00
|
|
|
|
|
|
|
std::string path = android::base::GetExecutablePath();
|
|
|
|
|
2009-03-04 11:32:55 +08:00
|
|
|
pid_t pid = fork();
|
2016-09-01 06:07:18 +08:00
|
|
|
if (pid < 0) return -1;
|
2009-03-04 11:32:55 +08:00
|
|
|
|
|
|
|
if (pid == 0) {
|
|
|
|
// child side of the fork
|
|
|
|
|
|
|
|
adb_close(fd[0]);
|
|
|
|
|
2015-08-08 01:10:29 +08:00
|
|
|
char reply_fd[30];
|
|
|
|
snprintf(reply_fd, sizeof(reply_fd), "%d", fd[1]);
|
2009-03-04 11:32:55 +08:00
|
|
|
// child process
|
2016-08-26 07:00:22 +08:00
|
|
|
int result = execl(path.c_str(), "adb", "-L", socket_spec.c_str(), "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;
|
|
|
|
}
|
|
|
|
}
|
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
|
2016-01-16 06:35:54 +08:00
|
|
|
return SendProtocolString(reply_fd, listeners);
|
2013-03-22 04:07:42 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
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-10-08 05:55:10 +08:00
|
|
|
atransport* transport = acquire_one_transport(type, serial, nullptr, &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;
|
2016-04-08 02:25:48 +08:00
|
|
|
int resolved_tcp_port = 0;
|
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 {
|
2016-04-08 02:25:48 +08:00
|
|
|
r = install_listener(pieces[0], pieces[1].c_str(), transport, no_rebind,
|
|
|
|
&resolved_tcp_port, &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
|
2016-04-08 02:25:48 +08:00
|
|
|
// 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);
|
2016-04-08 02:25:48 +08:00
|
|
|
|
|
|
|
// If a TCP port was resolved, send the actual port number back.
|
|
|
|
if (resolved_tcp_port != 0) {
|
|
|
|
SendProtocolString(reply_fd, android::base::StringPrintf("%d", resolved_tcp_port));
|
|
|
|
}
|
|
|
|
|
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
|
|
|
|
adb: fix adb client running out of sockets on Windows
Background
==========
On Windows, if you run "adb shell exit" in a loop in two windows,
eventually the adb client will be unable to connect to the adb server. I
think connect() is returning WSAEADDRINUSE: "Only one usage of each
socket address (protocol/network address/port) is normally permitted.
(10048)". The Windows System Event Log may also show Event 4227, Tcpip.
Netstat output is filled with:
# for the adb server
TCP 127.0.0.1:5037 127.0.0.1:65523 TIME_WAIT
# for the adb client
TCP 127.0.0.1:65523 127.0.0.1:5037 TIME_WAIT
The error probably means that the client is running out of free
address:port pairs.
The first netstat line is unavoidable, but the second line exists
because the adb client is not waiting for orderly/graceful shutdown of
the socket, and that is apparently required on Windows to get rid of the
second line. For more info, see
https://github.com/CompareAndSwap/SocketCloseTest .
This is exacerbated by the fact that "adb shell exit" makes 4 socket
connections to the adb server: 1) host:version, 2) host:features, 3)
host:version (again), 4) shell:exit. Also exacerbating is the fact that
the adb protocol is length-prefixed so the client typically does not
have to 'read() until zero' which effectively waits for orderly/graceful
shutdown.
The Fix
=======
Introduce a function, ReadOrderlyShutdown(), that should be called in
the adb client to wait for the server to close its socket, before
closing the client socket.
I reviewed all code where the adb client makes a connection to the adb
server and added ReadOrderlyShutdown() when it made sense. I wasn't able
to add it to the following:
* interactive_shell: this doesn't matter because this is interactive and
thus can't be run fast enough to use up ports.
* adb sideload: I couldn't get enough test coverage and I don't think
this is being called frequently enough to be a problem.
* send_shell_command, backup, adb_connect_command, adb shell, adb
exec-out, install_multiple_app, adb_send_emulator_command: These
already wait for server socket shutdown since they already call
recv() until zero.
* restore, adb exec-in: protocol design can't have the server close
first.
* adb start-server: no fd is actually returned
* create_local_service_socket, local_connect_arbitrary_ports,
connect_device: probably called rarely enough not to be a problem.
Also in this change
===================
* Clarify comments in when adb_shutdown() is called before exit().
* add some missing adb_close() in adb sideload.
* Fixup error handling and comments in adb_send_emulator_command().
* Make SyncConnection::SendQuit return a success boolean.
* Add unittest for adb emu kill command. This gets code coverage over
this very careful piece of code.
Change-Id: Iad0b1336f5b74186af2cd35f7ea827d0fa77a17c
Signed-off-by: Spencer Low <CompareAndSwap@gmail.com>
2015-10-15 08:32:44 +08:00
|
|
|
// On Windows, if the process exits with open sockets that
|
|
|
|
// shutdown(SD_SEND) has not been called on, TCP RST segments will be
|
|
|
|
// sent to the peers which will cause their next recv() to error-out
|
|
|
|
// with WSAECONNRESET. In the case of this code, that means the client
|
|
|
|
// may not read the OKAY sent above.
|
2015-08-12 08:05:02 +08:00
|
|
|
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-10-08 05:55:10 +08:00
|
|
|
std::string error;
|
|
|
|
atransport* t = acquire_one_transport(type, serial, nullptr, &error);
|
2015-06-24 04:00:32 +08:00
|
|
|
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-10-08 05:55:10 +08:00
|
|
|
SendFail(reply_fd, error);
|
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")) {
|
2015-10-08 05:55:10 +08:00
|
|
|
std::string error;
|
|
|
|
atransport* t = acquire_one_transport(type, serial, nullptr, &error);
|
2015-09-05 07:40:30 +08:00
|
|
|
if (t != nullptr) {
|
2015-09-23 01:43:08 +08:00
|
|
|
SendOkay(reply_fd, FeatureSetToString(t->features()));
|
2015-09-05 07:40:30 +08:00
|
|
|
} else {
|
2015-10-08 05:55:10 +08:00
|
|
|
SendFail(reply_fd, error);
|
2015-09-05 07:40:30 +08:00
|
|
|
}
|
|
|
|
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;
|
2016-01-22 00:40:59 +08:00
|
|
|
if (!android::base::ParseNetAddress(address, &host, &port, &serial, &error)) {
|
2015-07-19 03:21:30 +08:00
|
|
|
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
|
|
|
}
|
|
|
|
|
2015-10-08 05:55:10 +08:00
|
|
|
// Returns our value for ADB_SERVER_VERSION.
|
2009-03-04 11:32:55 +08:00
|
|
|
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")) {
|
2015-10-08 05:55:10 +08:00
|
|
|
std::string error;
|
|
|
|
atransport* t = acquire_one_transport(type, serial, nullptr, &error);
|
|
|
|
if (t) {
|
|
|
|
return SendOkay(reply_fd, t->serial ? t->serial : "unknown");
|
|
|
|
} else {
|
|
|
|
return SendFail(reply_fd, error);
|
|
|
|
}
|
2009-03-04 11:32:55 +08:00
|
|
|
}
|
2015-06-24 04:00:32 +08:00
|
|
|
if (!strcmp(service, "get-devpath")) {
|
2015-10-08 05:55:10 +08:00
|
|
|
std::string error;
|
|
|
|
atransport* t = acquire_one_transport(type, serial, nullptr, &error);
|
|
|
|
if (t) {
|
|
|
|
return SendOkay(reply_fd, t->devpath ? t->devpath : "unknown");
|
|
|
|
} else {
|
|
|
|
return SendFail(reply_fd, error);
|
|
|
|
}
|
2012-04-21 02:21:14 +08:00
|
|
|
}
|
2015-06-24 04:00:32 +08:00
|
|
|
if (!strcmp(service, "get-state")) {
|
2015-10-08 05:55:10 +08:00
|
|
|
std::string error;
|
|
|
|
atransport* t = acquire_one_transport(type, serial, nullptr, &error);
|
|
|
|
if (t) {
|
|
|
|
return SendOkay(reply_fd, t->connection_state_name());
|
|
|
|
} else {
|
|
|
|
return SendFail(reply_fd, error);
|
|
|
|
}
|
2015-06-24 04:00:32 +08:00
|
|
|
}
|
|
|
|
|
2015-10-08 05:55:10 +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;
|
|
|
|
}
|
2016-04-06 04:50:44 +08:00
|
|
|
|
|
|
|
if (!strcmp(service, "reconnect")) {
|
|
|
|
if (s->transport != nullptr) {
|
|
|
|
kick_transport(s->transport);
|
|
|
|
}
|
|
|
|
return SendOkay(reply_fd, "done");
|
|
|
|
}
|
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;
|
|
|
|
}
|