Merge "DO NOT MERGE - Merge qt-dev-plus-aosp-without-vendor (5699924) into... (12684d74) · Commits · e / os / android_system_core

adb/adb.cpp

+6 −2

Original line number	Diff line number	Diff line
		@@ -337,9 +337,12 @@ void handle_packet(apacket p, atransport t)
		case ADB_AUTH_SIGNATURE: {
		// TODO: Switch to string_view.
		std::string signature(p->payload.begin(), p->payload.end());
		if (adbd_auth_verify(t->token, sizeof(t->token), signature)) {
		std::string auth_key;
		if (adbd_auth_verify(t->token, sizeof(t->token), signature, &auth_key)) {
		adbd_auth_verified(t);
		t->failed_auth_attempts = 0;
		t->auth_key = auth_key;
		adbd_notify_framework_connected_key(t);
		} else {
		if (t->failed_auth_attempts++ > 256) std::this_thread::sleep_for(1s);
		send_auth_request(t);
		@@ -348,7 +351,8 @@ void handle_packet(apacket p, atransport t)
		}

		case ADB_AUTH_RSAPUBLICKEY:
		adbd_auth_confirm_key(p->payload.data(), p->msg.data_length, t);
		t->auth_key = std::string(p->payload.data());
		adbd_auth_confirm_key(t);
		break;
		#endif
		default:

adb/adb.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -33,6 +33,7 @@

		constexpr size_t MAX_PAYLOAD_V1 = 4 * 1024;
		constexpr size_t MAX_PAYLOAD = 1024 * 1024;
		constexpr size_t MAX_FRAMEWORK_PAYLOAD = 64 * 1024;

		constexpr size_t LINUX_MAX_SOCKET_SIZE = 4194304;

adb/adb_auth.h

+4 −2

Original line number	Diff line number	Diff line
		@@ -50,8 +50,10 @@ void adbd_auth_init(void);
		void adbd_auth_verified(atransport *t);

		void adbd_cloexec_auth_socket();
		bool adbd_auth_verify(const char* token, size_t token_size, const std::string& sig);
		void adbd_auth_confirm_key(const char* data, size_t len, atransport* t);
		bool adbd_auth_verify(const char* token, size_t token_size, const std::string& sig,
		std::string* auth_key);
		void adbd_auth_confirm_key(atransport* t);
		void adbd_notify_framework_connected_key(atransport* t);

		void send_auth_request(atransport *t);

adb/daemon/auth.cpp

+102 −47

Original line number	Diff line number	Diff line
		@@ -18,6 +18,7 @@

		#include "adb.h"
		#include "adb_auth.h"
		#include "adb_io.h"
		#include "fdevent.h"
		#include "sysdeps.h"
		#include "transport.h"
		@@ -25,7 +26,9 @@
		#include <resolv.h>
		#include <stdio.h>
		#include <string.h>
		#include <iomanip>

		#include <algorithm>
		#include <memory>

		#include <android-base/file.h>
		@@ -37,22 +40,24 @@

		static fdevent* listener_fde = nullptr;
		static fdevent* framework_fde = nullptr;
		static int framework_fd = -1;
		static auto& framework_mutex = *new std::mutex();
		static int framework_fd GUARDED_BY(framework_mutex) = -1;
		static auto& connected_keys GUARDED_BY(framework_mutex) = *new std::vector<std::string>;

		static void usb_disconnected(void* unused, atransport* t);
		static struct adisconnect usb_disconnect = { usb_disconnected, nullptr};
		static atransport* usb_transport;
		static void adb_disconnected(void* unused, atransport* t);
		static struct adisconnect adb_disconnect = {adb_disconnected, nullptr};
		static atransport* adb_transport;
		static bool needs_retry = false;

		bool auth_required = true;

		bool adbd_auth_verify(const char* token, size_t token_size, const std::string& sig) {
		bool adbd_auth_verify(const char* token, size_t token_size, const std::string& sig,
		std::string* auth_key) {
		static constexpr const char* key_paths[] = { "/adb_keys", "/data/misc/adb/adb_keys", nullptr };

		for (const auto& path : key_paths) {
		if (access(path, R_OK) == 0) {
		LOG(INFO) << "Loading keys from " << path;

		std::string content;
		if (!android::base::ReadFileToString(path, &content)) {
		PLOG(ERROR) << "Couldn't read " << path;
		@@ -60,6 +65,8 @@ bool adbd_auth_verify(const char* token, size_t token_size, const std::string& s
		}

		for (const auto& line : android::base::Split(content, "\n")) {
		if (line.empty()) continue;
		*auth_key = line;
		// TODO: do we really have to support both ' ' and '\t'?
		char* sep = strpbrk(const_cast<char*>(line.c_str()), " \t");
		if (sep) *sep = '\0';
		@@ -87,9 +94,31 @@ bool adbd_auth_verify(const char* token, size_t token_size, const std::string& s
		}
		}
		}
		auth_key->clear();
		return false;
		}

		static bool adbd_send_key_message_locked(std::string_view msg_type, std::string_view key)
		REQUIRES(framework_mutex) {
		if (framework_fd < 0) {
		LOG(ERROR) << "Client not connected to send msg_type " << msg_type;
		return false;
		}
		std::string msg = std::string(msg_type) + std::string(key);
		int msg_len = msg.length();
		if (msg_len >= static_cast<int>(MAX_FRAMEWORK_PAYLOAD)) {
		LOG(ERROR) << "Key too long (" << msg_len << ")";
		return false;
		}

		LOG(DEBUG) << "Sending '" << msg << "'";
		if (!WriteFdExactly(framework_fd, msg.c_str(), msg_len)) {
		PLOG(ERROR) << "Failed to write " << msg_type;
		return false;
		}
		return true;
		}

		static bool adbd_auth_generate_token(void* token, size_t token_size) {
		FILE* fp = fopen("/dev/urandom", "re");
		if (!fp) return false;
		@@ -98,19 +127,30 @@ static bool adbd_auth_generate_token(void* token, size_t token_size) {
		return okay;
		}

		static void usb_disconnected(void* unused, atransport* t) {
		LOG(INFO) << "USB disconnect";
		usb_transport = nullptr;
		static void adb_disconnected(void* unused, atransport* t) {
		LOG(INFO) << "ADB disconnect";
		adb_transport = nullptr;
		needs_retry = false;
		{
		std::lock_guard<std::mutex> lock(framework_mutex);
		if (framework_fd >= 0) {
		adbd_send_key_message_locked("DC", t->auth_key);
		}
		connected_keys.erase(std::remove(connected_keys.begin(), connected_keys.end(), t->auth_key),
		connected_keys.end());
		}
		}

		static void framework_disconnected() {
		LOG(INFO) << "Framework disconnect";
		if (framework_fde) {
		fdevent_destroy(framework_fde);
		{
		std::lock_guard<std::mutex> lock(framework_mutex);
		framework_fd = -1;
		}
		}
		}

		static void adbd_auth_event(int fd, unsigned events, void*) {
		if (events & FDE_READ) {
		@@ -119,41 +159,28 @@ static void adbd_auth_event(int fd, unsigned events, void*) {
		if (ret <= 0) {
		framework_disconnected();
		} else if (ret == 2 && response[0] == 'O' && response[1] == 'K') {
		if (usb_transport) {
		adbd_auth_verified(usb_transport);
		if (adb_transport) {
		adbd_auth_verified(adb_transport);
		}
		}
		}
		}

		void adbd_auth_confirm_key(const char* key, size_t len, atransport* t) {
		if (!usb_transport) {
		usb_transport = t;
		t->AddDisconnect(&usb_disconnect);
		void adbd_auth_confirm_key(atransport* t) {
		if (!adb_transport) {
		adb_transport = t;
		t->AddDisconnect(&adb_disconnect);
		}

		{
		std::lock_guard<std::mutex> lock(framework_mutex);
		if (framework_fd < 0) {
		LOG(ERROR) << "Client not connected";
		needs_retry = true;
		return;
		}

		if (key[len - 1] != '\0') {
		LOG(ERROR) << "Key must be a null-terminated string";
		return;
		}

		char msg[MAX_PAYLOAD_V1];
		int msg_len = snprintf(msg, sizeof(msg), "PK%s", key);
		if (msg_len >= static_cast<int>(sizeof(msg))) {
		LOG(ERROR) << "Key too long (" << msg_len << ")";
		return;
		}
		LOG(DEBUG) << "Sending '" << msg << "'";

		if (unix_write(framework_fd, msg, msg_len) == -1) {
		PLOG(ERROR) << "Failed to write PK";
		return;
		adbd_send_key_message_locked("PK", t->auth_key);
		}
		}

		@@ -164,6 +191,8 @@ static void adbd_auth_listener(int fd, unsigned events, void* data) {
		return;
		}

		{
		std::lock_guard<std::mutex> lock(framework_mutex);
		if (framework_fd >= 0) {
		LOG(WARNING) << "adb received framework auth socket connection again";
		framework_disconnected();
		@@ -175,7 +204,33 @@ static void adbd_auth_listener(int fd, unsigned events, void* data) {

		if (needs_retry) {
		needs_retry = false;
		send_auth_request(usb_transport);
		send_auth_request(adb_transport);
		}

		// if a client connected before the framework was available notify the framework of the
		// connected key now.
		if (!connected_keys.empty()) {
		for (const auto& key : connected_keys) {
		adbd_send_key_message_locked("CK", key);
		}
		}
		}
		}

		void adbd_notify_framework_connected_key(atransport* t) {
		if (!adb_transport) {
		adb_transport = t;
		t->AddDisconnect(&adb_disconnect);
		}
		{
		std::lock_guard<std::mutex> lock(framework_mutex);
		if (std::find(connected_keys.begin(), connected_keys.end(), t->auth_key) ==
		connected_keys.end()) {
		connected_keys.push_back(t->auth_key);
		}
		if (framework_fd >= 0) {
		adbd_send_key_message_locked("CK", t->auth_key);
		}
		}
		}

adb/daemon/usb.cpp

+7 −20

Original line number	Diff line number	Diff line
		@@ -509,16 +509,14 @@ struct UsbFfsConnection : public Connection {
		}

		if (id.direction == TransferDirection::READ) {
		if (!HandleRead(id, event.res)) {
		return;
		}
		HandleRead(id, event.res);
		} else {
		HandleWrite(id);
		}
		}
		}

		bool HandleRead(TransferId id, int64_t size) {
		void HandleRead(TransferId id, int64_t size) {
		uint64_t read_idx = id.id % kUsbReadQueueDepth;
		IoBlock* block = &read_requests_[read_idx];
		block->pending = false;
		@@ -528,7 +526,7 @@ struct UsbFfsConnection : public Connection {
		if (block->id().id != needed_read_id_) {
		LOG(VERBOSE) << "read " << block->id().id << " completed while waiting for "
		<< needed_read_id_;
		return true;
		return;
		}

		for (uint64_t id = needed_read_id_;; ++id) {
		@@ -537,22 +535,15 @@ struct UsbFfsConnection : public Connection {
		if (current_block->pending) {
		break;
		}
		if (!ProcessRead(current_block)) {
		return false;
		}
		ProcessRead(current_block);
		++needed_read_id_;
		}

		return true;
		}

		bool ProcessRead(IoBlock* block) {
		void ProcessRead(IoBlock* block) {
		if (!block->payload->empty()) {
		if (!incoming_header_.has_value()) {
		if (block->payload->size() != sizeof(amessage)) {
		HandleError("received packet of unexpected length while reading header");
		return false;
		}
		CHECK_EQ(sizeof(amessage), block->payload->size());
		amessage msg;
		memcpy(&msg, block->payload->data(), sizeof(amessage));
		LOG(DEBUG) << "USB read:" << dump_header(&msg);
		@@ -560,10 +551,7 @@ struct UsbFfsConnection : public Connection {
		} else {
		size_t bytes_left = incoming_header_->data_length - incoming_payload_.size();
		Block payload = std::move(*block->payload);
		if (block->payload->size() > bytes_left) {
		HandleError("received too many bytes while waiting for payload");
		return false;
		}
		CHECK_LE(payload.size(), bytes_left);
		incoming_payload_.append(std::make_unique<Block>(std::move(payload)));
		}

		@@ -582,7 +570,6 @@ struct UsbFfsConnection : public Connection {

		PrepareReadBlock(block, block->id().id + kUsbReadQueueDepth);
		SubmitRead(block);
		return true;
		}

		bool SubmitRead(IoBlock* block) {