Merge "Kill load_file." (b42e4a6b) · Commits · e / os / android_system_core

adb/adb_auth.cpp

+11 −7

Original line number	Diff line number	Diff line
		@@ -72,19 +72,23 @@ void send_auth_response(uint8_t token, size_t token_size, atransport t)
		void send_auth_publickey(atransport *t)
		{
		D("Calling send_auth_publickey");
		apacket *p = get_apacket();
		int ret;

		ret = adb_auth_get_userkey(p->data, MAX_PAYLOAD_V1);
		if (!ret) {
		std::string key = adb_auth_get_userkey();
		if (key.empty()) {
		D("Failed to get user public key");
		put_apacket(p);
		return;
		}

		if (key.size() >= MAX_PAYLOAD_V1) {
		D("User public key too large (%zu B)", key.size());
		return;
		}

		apacket* p = get_apacket();
		memcpy(p->data, key.c_str(), key.size() + 1);

		p->msg.command = A_AUTH;
		p->msg.arg0 = ADB_AUTH_RSAPUBLICKEY;
		p->msg.data_length = ret;
		p->msg.data_length = key.size();
		send_packet(p, t);
		}

adb/adb_auth.h

+2 −4

Original line number	Diff line number	Diff line
		@@ -41,7 +41,7 @@ void adb_auth_init(void);
		int adb_auth_sign(void key, const unsigned char token, size_t token_size,
		unsigned char* sig);
		void adb_auth_nextkey(void current);
		int adb_auth_get_userkey(unsigned char *data, size_t len);
		std::string adb_auth_get_userkey();

		static inline int adb_auth_generate_token(void *token, size_t token_size) {
		return 0;
		@@ -60,9 +60,7 @@ static inline int adb_auth_sign(void* key, const unsigned char* token,
		return 0;
		}
		static inline void adb_auth_nextkey(void current) { return NULL; }
		static inline int adb_auth_get_userkey(unsigned char *data, size_t len) {
		return 0;
		}
		static inline std::string adb_auth_get_userkey() { return ""; }

		void adbd_auth_init(void);
		void adbd_cloexec_auth_socket();

adb/adb_auth_host.cpp

+7 −24

Original line number	Diff line number	Diff line
		@@ -27,6 +27,7 @@
		#include "adb.h"

		#include <android-base/errors.h>
		#include <android-base/file.h>
		#include <android-base/stringprintf.h>
		#include <android-base/strings.h>
		#include <crypto_utils/android_pubkey.h>
		@@ -334,39 +335,21 @@ void adb_auth_nextkey(void current)
		return NULL;
		}

		int adb_auth_get_userkey(unsigned char *data, size_t len)
		{
		std::string adb_auth_get_userkey() {
		char path[PATH_MAX];
		int ret = get_user_keyfilepath(path, sizeof(path) - 4);
		if (ret < 0 \|\| ret >= (signed)(sizeof(path) - 4)) {
		D("Error getting user key filename");
		return 0;
		return "";
		}
		strcat(path, ".pub");

		// TODO(danalbert): ReadFileToString
		// Note that on Windows, load_file() does not do CR/LF translation, but
		// ReadFileToString() uses the C Runtime which uses CR/LF translation by
		// default (by is overridable with _setmode()).
		unsigned size;
		char* file_data = reinterpret_cast<char*>(load_file(path, &size));
		if (file_data == nullptr) {
		std::string content;
		if (!android::base::ReadFileToString(path, &content)) {
		D("Can't load '%s'", path);
		return 0;
		}

		if (len < (size_t)(size + 1)) {
		D("%s: Content too large ret=%d", path, size);
		free(file_data);
		return 0;
		return "";
		}

		memcpy(data, file_data, size);
		free(file_data);
		file_data = nullptr;
		data[size] = '\0';

		return size + 1;
		return content;
		}

		int adb_auth_keygen(const char* filename) {

adb/adb_utils.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -66,6 +66,7 @@ struct AdbCloser {

		using unique_fd = android::base::unique_fd_impl<AdbCloser>;

		// TODO: switch remaining users over to unique_fd...
		class ScopedFd {
		public:
		ScopedFd() {

adb/commandline.cpp

+25 −34

Original line number	Diff line number	Diff line
		@@ -35,6 +35,7 @@
		#include <string>
		#include <vector>

		#include <android-base/file.h>
		#include <android-base/logging.h>
		#include <android-base/stringprintf.h>
		#include <android-base/strings.h>
		@@ -871,47 +872,47 @@ static int adb_download_buffer(const char service, const char fn, const void*
		* we hang up.
		*/
		static int adb_sideload_host(const char* fn) {
		unsigned sz;
		size_t xfer = 0;
		int status;
		int last_percent = -1;
		int opt = SIDELOAD_HOST_BLOCK_SIZE;

		printf("loading: '%s'", fn);
		fflush(stdout);
		uint8_t* data = reinterpret_cast<uint8_t*>(load_file(fn, &sz));
		if (data == 0) {

		std::string content;
		if (!android::base::ReadFileToString(fn, &content)) {
		printf("\n");
		fprintf(stderr, "* cannot read '%s' *\n", fn);
		return -1;
		}

		const uint8_t* data = reinterpret_cast<const uint8_t*>(content.data());
		unsigned sz = content.size();

		std::string service =
		android::base::StringPrintf("sideload-host:%d:%d", sz, SIDELOAD_HOST_BLOCK_SIZE);
		std::string error;
		int fd = adb_connect(service, &error);
		if (fd < 0) {
		unique_fd fd(adb_connect(service, &error));
		if (fd >= 0) {
		// Try falling back to the older sideload method. Maybe this
		// is an older device that doesn't support sideload-host.
		printf("\n");
		status = adb_download_buffer("sideload", fn, data, sz, true);
		goto done;
		return adb_download_buffer("sideload", fn, data, sz, true);
		}

		opt = adb_setsockopt(fd, SOL_SOCKET, SO_SNDBUF, (const void *) &opt, sizeof(opt));
		int opt = SIDELOAD_HOST_BLOCK_SIZE;
		adb_setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &opt, sizeof(opt));

		size_t xfer = 0;
		int last_percent = -1;
		while (true) {
		char buf[9];
		if (!ReadFdExactly(fd, buf, 8)) {
		fprintf(stderr, "* failed to read command: %s\n", strerror(errno));
		status = -1;
		goto done;
		return -1;
		}
		buf[8] = '\0';

		if (strcmp("DONEDONE", buf) == 0) {
		status = 0;
		break;
		printf("\rTotal xfer: %.2fx%*s\n",
		(double)xfer / (sz ? sz : 1), (int)strlen(fn)+10, "");
		return 0;
		}

		int block = strtol(buf, NULL, 10);
		@@ -919,10 +920,9 @@ static int adb_sideload_host(const char* fn) {
		size_t offset = block * SIDELOAD_HOST_BLOCK_SIZE;
		if (offset >= sz) {
		fprintf(stderr, "* attempt to read block %d past end\n", block);
		status = -1;
		goto done;
		return -1;
		}
		uint8_t* start = data + offset;
		const uint8_t* start = data + offset;
		size_t offset_end = offset + SIDELOAD_HOST_BLOCK_SIZE;
		size_t to_write = SIDELOAD_HOST_BLOCK_SIZE;
		if (offset_end > sz) {
		@@ -932,8 +932,7 @@ static int adb_sideload_host(const char* fn) {
		if (!WriteFdExactly(fd, start, to_write)) {
		adb_status(fd, &error);
		fprintf(stderr,"* failed to write data '%s' *\n", error.c_str());
		status = -1;
		goto done;
		return -1;
		}
		xfer += to_write;

		@@ -950,13 +949,6 @@ static int adb_sideload_host(const char* fn) {
		last_percent = percent;
		}
		}

		printf("\rTotal xfer: %.2fx%*s\n", (double)xfer / (sz ? sz : 1), (int)strlen(fn)+10, "");

		done:
		if (fd >= 0) adb_close(fd);
		free(data);
		return status;
		}

		/**
		@@ -1067,10 +1059,9 @@ static bool wait_for_device(const char* service, TransportType t, const char* se

		static bool adb_root(const char* command) {
		std::string error;
		ScopedFd fd;

		fd.Reset(adb_connect(android::base::StringPrintf("%s:", command), &error));
		if (!fd.valid()) {
		unique_fd fd(adb_connect(android::base::StringPrintf("%s:", command), &error));
		if (fd < 0) {
		fprintf(stderr, "adb: unable to connect for %s: %s\n", command, error.c_str());
		return false;
		}
		@@ -1080,7 +1071,7 @@ static bool adb_root(const char* command) {
		char* cur = buf;
		ssize_t bytes_left = sizeof(buf);
		while (bytes_left > 0) {
		ssize_t bytes_read = adb_read(fd.fd(), cur, bytes_left);
		ssize_t bytes_read = adb_read(fd, cur, bytes_left);
		if (bytes_read == 0) {
		break;
		} else if (bytes_read < 0) {