Merge "Add "require partition-exists=" support." am: 539f3ddff5 am: fea8b41aa1 (610ba635) · Commits · e / os / android_system_core

fastboot/engine.cpp

+152 −217

Original line number	Original line	Diff line number	Diff line
	@@ -27,7 +27,6 @@
	*/		*/

	#include "fastboot.h"		#include "fastboot.h"
	#include "fs.h"

	#include <errno.h>		#include <errno.h>
	#include <stdarg.h>		#include <stdarg.h>
	@@ -38,150 +37,117 @@
	#include <sys/types.h>		#include <sys/types.h>
	#include <unistd.h>		#include <unistd.h>

	#define OP_DOWNLOAD 1		#include <memory>
	#define OP_COMMAND 2		#include <vector>
	#define OP_QUERY 3
	#define OP_NOTICE 4
	#define OP_DOWNLOAD_SPARSE 5
	#define OP_WAIT_FOR_DISCONNECT 6
	#define OP_DOWNLOAD_FD 7
	#define OP_UPLOAD 8

	typedef struct Action Action;		#include <android-base/stringprintf.h>

	#define CMD_SIZE 64		enum Op {
			OP_DOWNLOAD,
			OP_COMMAND,
			OP_QUERY,
			OP_NOTICE,
			OP_DOWNLOAD_SPARSE,
			OP_WAIT_FOR_DISCONNECT,
			OP_DOWNLOAD_FD,
			OP_UPLOAD,
			};

	struct Action {		struct Action {
	unsigned op;		Action(Op op, const std::string& cmd) : op(op), cmd(cmd) {}
	Action* next;

	char cmd[CMD_SIZE];
	const char* prod;
	void* data;
	int fd;

	// The protocol only supports 32-bit sizes, so you'll have to break		Op op;
	// anything larger into chunks.		std::string cmd;
	uint32_t size;		std::string msg;

	const char *msg;		std::string product;
	int (func)(Action a, int status, const char* resp);

	double start;		void* data = nullptr;
	};		// The protocol only supports 32-bit sizes, so you'll have to break
			// anything larger into multiple chunks.
			uint32_t size = 0;

	static Action *action_list = 0;		int fd = -1;
	static Action *action_last = 0;

			int (func)(Action& a, int status, const char resp) = nullptr;

			double start = -1;
			};

			static std::vector<std::unique_ptr<Action>> action_list;

	bool fb_getvar(Transport* transport, const std::string& key, std::string* value) {		bool fb_getvar(Transport* transport, const std::string& key, std::string* value) {
	std::string cmd = "getvar:";		std::string cmd = "getvar:" + key;
	cmd += key;

	char buf[FB_RESPONSE_SZ + 1];		char buf[FB_RESPONSE_SZ + 1];
	memset(buf, 0, sizeof(buf));		memset(buf, 0, sizeof(buf));
	if (fb_command_response(transport, cmd.c_str(), buf)) {		if (fb_command_response(transport, cmd, buf)) {
	return false;		return false;
	}		}
	*value = buf;		*value = buf;
	return true;		return true;
	}		}

	static int cb_default(Action* a, int status, const char* resp) {		static int cb_default(Action& a, int status, const char* resp) {
	if (status) {		if (status) {
	fprintf(stderr,"FAILED (%s)\n", resp);		fprintf(stderr,"FAILED (%s)\n", resp);
	} else {		} else {
	double split = now();		double split = now();
	fprintf(stderr,"OKAY [%7.3fs]\n", (split - a->start));		fprintf(stderr, "OKAY [%7.3fs]\n", (split - a.start));
	a->start = split;		a.start = split;
	}		}
	return status;		return status;
	}		}

	static Action queue_action(unsigned op, const char fmt, ...)		static Action& queue_action(Op op, const std::string& cmd) {
	{		std::unique_ptr<Action> a{new Action(op, cmd)};
	va_list ap;
	size_t cmdsize;

	Action* a = reinterpret_cast<Action*>(calloc(1, sizeof(Action)));
	if (a == nullptr) die("out of memory");

	va_start(ap, fmt);
	cmdsize = vsnprintf(a->cmd, sizeof(a->cmd), fmt, ap);
	va_end(ap);

	if (cmdsize >= sizeof(a->cmd)) {
	free(a);
	die("Command length (%zu) exceeds maximum size (%zu)", cmdsize, sizeof(a->cmd));
	}

	if (action_last) {
	action_last->next = a;
	} else {
	action_list = a;
	}
	action_last = a;
	a->op = op;
	a->func = cb_default;		a->func = cb_default;

	a->start = -1;		action_list.push_back(std::move(a));
			return *action_list.back();
	return a;
	}		}

	void fb_set_active(const char *slot)		void fb_set_active(const std::string& slot) {
	{		Action& a = queue_action(OP_COMMAND, "set_active:" + slot);
	Action *a;		a.msg = "Setting current slot to '" + slot + "'...";
	a = queue_action(OP_COMMAND, "set_active:%s", slot);
	a->msg = mkmsg("Setting current slot to '%s'", slot);
	}		}

	void fb_queue_erase(const char *ptn)		void fb_queue_erase(const std::string& partition) {
	{		Action& a = queue_action(OP_COMMAND, "erase:" + partition);
	Action *a;		a.msg = "Erasing '" + partition + "'...";
	a = queue_action(OP_COMMAND, "erase:%s", ptn);
	a->msg = mkmsg("erasing '%s'", ptn);
	}		}

	void fb_queue_flash_fd(const char *ptn, int fd, uint32_t sz)		void fb_queue_flash_fd(const std::string& partition, int fd, uint32_t sz) {
	{		Action& a = queue_action(OP_DOWNLOAD_FD, "");
	Action *a;		a.fd = fd;
			a.size = sz;
	a = queue_action(OP_DOWNLOAD_FD, "");		a.msg = android::base::StringPrintf("Sending '%s' (%d KB)...", partition.c_str(), sz / 1024);
	a->fd = fd;
	a->size = sz;
	a->msg = mkmsg("sending '%s' (%d KB)", ptn, sz / 1024);

	a = queue_action(OP_COMMAND, "flash:%s", ptn);		Action& b = queue_action(OP_COMMAND, "flash:" + partition);
	a->msg = mkmsg("writing '%s'", ptn);		b.msg = "Writing '" + partition + "'...";
	}		}

	void fb_queue_flash(const char ptn, void data, uint32_t sz)		void fb_queue_flash(const std::string& partition, void* data, uint32_t sz) {
	{		Action& a = queue_action(OP_DOWNLOAD, "");
	Action *a;		a.data = data;
			a.size = sz;
			a.msg = android::base::StringPrintf("Sending '%s' (%d KB)...", partition.c_str(), sz / 1024);

	a = queue_action(OP_DOWNLOAD, "");		Action& b = queue_action(OP_COMMAND, "flash:" + partition);
	a->data = data;		b.msg = "Writing '" + partition + "'...";
	a->size = sz;
	a->msg = mkmsg("sending '%s' (%d KB)", ptn, sz / 1024);

	a = queue_action(OP_COMMAND, "flash:%s", ptn);
	a->msg = mkmsg("writing '%s'", ptn);
	}		}

	void fb_queue_flash_sparse(const char* ptn, struct sparse_file* s, uint32_t sz, size_t current,		void fb_queue_flash_sparse(const std::string& partition, struct sparse_file* s, uint32_t sz,
	size_t total) {		size_t current, size_t total) {
	Action *a;		Action& a = queue_action(OP_DOWNLOAD_SPARSE, "");
			a.data = s;
	a = queue_action(OP_DOWNLOAD_SPARSE, "");		a.size = 0;
	a->data = s;		a.msg = android::base::StringPrintf("Sending sparse '%s' %zu/%zu (%d KB)...", partition.c_str(),
	a->size = 0;		current, total, sz / 1024);
	a->msg = mkmsg("sending sparse '%s' %zu/%zu (%d KB)", ptn, current, total, sz / 1024);

	a = queue_action(OP_COMMAND, "flash:%s", ptn);		Action& b = queue_action(OP_COMMAND, "flash:" + partition);
	a->msg = mkmsg("writing '%s' %zu/%zu", ptn, current, total);		b.msg =
			android::base::StringPrintf("Writing '%s' %zu/%zu...", partition.c_str(), current, total);
	}		}

	static int match(const char* str, const char** value, unsigned count) {		static int match(const char* str, const char** value, unsigned count) {
	@@ -205,44 +171,39 @@ static int match(const char* str, const char** value, unsigned count) {
	return 0;		return 0;
	}		}

			static int cb_check(Action& a, int status, const char* resp, int invert) {
			const char value = reinterpret_cast<const char>(a.data);
	static int cb_check(Action* a, int status, const char* resp, int invert)		unsigned count = a.size;
	{
	const char value = reinterpret_cast<const char>(a->data);
	unsigned count = a->size;
	unsigned n;		unsigned n;
	int yes;

	if (status) {		if (status) {
	fprintf(stderr,"FAILED (%s)\n", resp);		fprintf(stderr,"FAILED (%s)\n", resp);
	return status;		return status;
	}		}

	if (a->prod) {		if (!a.product.empty()) {
	if (strcmp(a->prod, cur_product) != 0) {		if (a.product != cur_product) {
	double split = now();		double split = now();
	fprintf(stderr,"IGNORE, product is %s required only for %s [%7.3fs]\n",		fprintf(stderr, "IGNORE, product is %s required only for %s [%7.3fs]\n", cur_product,
	cur_product, a->prod, (split - a->start));		a.product.c_str(), (split - a.start));
	a->start = split;		a.start = split;
	return 0;		return 0;
	}		}
	}		}

	yes = match(resp, value, count);		int yes = match(resp, value, count);
	if (invert) yes = !yes;		if (invert) yes = !yes;

	if (yes) {		if (yes) {
	double split = now();		double split = now();
	fprintf(stderr,"OKAY [%7.3fs]\n", (split - a->start));		fprintf(stderr, "OKAY [%7.3fs]\n", (split - a.start));
	a->start = split;		a.start = split;
	return 0;		return 0;
	}		}

	fprintf(stderr, "FAILED\n\n");		fprintf(stderr, "FAILED\n\n");
	fprintf(stderr,"Device %s is '%s'.\n", a->cmd + 7, resp);		fprintf(stderr, "Device %s is '%s'.\n", a.cmd.c_str() + 7, resp);
	fprintf(stderr,"Update %s '%s'",		fprintf(stderr, "Update %s '%s'", invert ? "rejects" : "requires", value[0]);
	invert ? "rejects" : "requires", value[0]);
	for (n = 1; n < count; n++) {		for (n = 1; n < count; n++) {
	fprintf(stderr, " or '%s'", value[n]);		fprintf(stderr, " or '%s'", value[n]);
	}		}
	@@ -250,167 +211,141 @@ static int cb_check(Action* a, int status, const char* resp, int invert)
	return -1;		return -1;
	}		}

	static int cb_require(Actiona, int status, const char resp) {		static int cb_require(Action& a, int status, const char* resp) {
	return cb_check(a, status, resp, 0);		return cb_check(a, status, resp, 0);
	}		}

	static int cb_reject(Action* a, int status, const char* resp) {		static int cb_reject(Action& a, int status, const char* resp) {
	return cb_check(a, status, resp, 1);		return cb_check(a, status, resp, 1);
	}		}

	static char* xstrdup(const char* s) {		void fb_queue_require(const std::string& product, const std::string& var, bool invert,
	char* result = strdup(s);		size_t nvalues, const char** values) {
	if (!result) die("out of memory");		Action& a = queue_action(OP_QUERY, "getvar:" + var);
	return result;		a.product = product;
			a.data = values;
			a.size = nvalues;
			a.msg = "Checking " + var;
			a.func = invert ? cb_reject : cb_require;
			if (a.data == nullptr) die("out of memory");
	}		}

	void fb_queue_require(const char prod, const char var,		static int cb_display(Action& a, int status, const char* resp) {
	bool invert, size_t nvalues, const char **value)
	{
	Action *a;
	a = queue_action(OP_QUERY, "getvar:%s", var);
	a->prod = prod;
	a->data = value;
	a->size = nvalues;
	a->msg = mkmsg("checking %s", var);
	a->func = invert ? cb_reject : cb_require;
	if (a->data == nullptr) die("out of memory");
	}

	static int cb_display(Action* a, int status, const char* resp) {
	if (status) {		if (status) {
	fprintf(stderr, "%s FAILED (%s)\n", a->cmd, resp);		fprintf(stderr, "%s FAILED (%s)\n", a.cmd.c_str(), resp);
	return status;		return status;
	}		}
	fprintf(stderr, "%s: %s\n", static_cast<const char*>(a->data), resp);		fprintf(stderr, "%s: %s\n", static_cast<const char*>(a.data), resp);
	free(static_cast<char*>(a->data));		free(static_cast<char*>(a.data));
	return 0;		return 0;
	}		}

	void fb_queue_display(const char* var, const char* prettyname) {		void fb_queue_display(const std::string& label, const std::string& var) {
	Action* a = queue_action(OP_QUERY, "getvar:%s", var);		Action& a = queue_action(OP_QUERY, "getvar:" + var);
	a->data = xstrdup(prettyname);		a.data = xstrdup(label.c_str());
	a->func = cb_display;		a.func = cb_display;
	}		}

	static int cb_save(Action* a, int status, const char* resp) {		static int cb_save(Action& a, int status, const char* resp) {
	if (status) {		if (status) {
	fprintf(stderr, "%s FAILED (%s)\n", a->cmd, resp);		fprintf(stderr, "%s FAILED (%s)\n", a.cmd.c_str(), resp);
	return status;		return status;
	}		}
	strncpy(reinterpret_cast<char*>(a->data), resp, a->size);		strncpy(reinterpret_cast<char*>(a.data), resp, a.size);
	return 0;		return 0;
	}		}

	void fb_queue_query_save(const char* var, char* dest, uint32_t dest_size) {		void fb_queue_query_save(const std::string& var, char* dest, uint32_t dest_size) {
	Action* a = queue_action(OP_QUERY, "getvar:%s", var);		Action& a = queue_action(OP_QUERY, "getvar:" + var);
	a->data = dest;		a.data = dest;
	a->size = dest_size;		a.size = dest_size;
	a->func = cb_save;		a.func = cb_save;
	}		}

	static int cb_do_nothing(Action, int , const char) {		static int cb_do_nothing(Action&, int, const char*) {
	fprintf(stderr, "\n");		fprintf(stderr, "\n");
	return 0;		return 0;
	}		}

	void fb_queue_reboot(void)		void fb_queue_reboot() {
	{		Action& a = queue_action(OP_COMMAND, "reboot");
	Action *a = queue_action(OP_COMMAND, "reboot");		a.func = cb_do_nothing;
	a->func = cb_do_nothing;		a.msg = "Rebooting...";
	a->msg = "rebooting";
	}		}

	void fb_queue_command(const char cmd, const char msg)		void fb_queue_command(const std::string& cmd, const std::string& msg) {
	{		Action& a = queue_action(OP_COMMAND, cmd);
	Action *a = queue_action(OP_COMMAND, cmd);		a.msg = msg;
	a->msg = msg;
	}		}

	void fb_queue_download(const char name, void data, uint32_t size)		void fb_queue_download(const std::string& name, void* data, uint32_t size) {
	{		Action& a = queue_action(OP_DOWNLOAD, "");
	Action *a = queue_action(OP_DOWNLOAD, "");		a.data = data;
	a->data = data;		a.size = size;
	a->size = size;		a.msg = "Downloading '" + name + "'";
	a->msg = mkmsg("downloading '%s'", name);
	}		}

	void fb_queue_download_fd(const char *name, int fd, uint32_t sz)		void fb_queue_download_fd(const std::string& name, int fd, uint32_t sz) {
	{		Action& a = queue_action(OP_DOWNLOAD_FD, "");
	Action *a;		a.fd = fd;
	a = queue_action(OP_DOWNLOAD_FD, "");		a.size = sz;
	a->fd = fd;		a.msg = android::base::StringPrintf("Sending '%s' (%d KB)", name.c_str(), sz / 1024);
	a->size = sz;
	a->msg = mkmsg("sending '%s' (%d KB)", name, sz / 1024);
	}		}

	void fb_queue_upload(const char* outfile) {		void fb_queue_upload(const std::string& outfile) {
	Action* a = queue_action(OP_UPLOAD, "");		Action& a = queue_action(OP_UPLOAD, "");
	a->data = xstrdup(outfile);		a.data = xstrdup(outfile.c_str());
	a->msg = mkmsg("uploading '%s'", outfile);		a.msg = "Uploading '" + outfile + "'";
	}		}

	void fb_queue_notice(const char* notice) {		void fb_queue_notice(const std::string& notice) {
	Action *a = queue_action(OP_NOTICE, "");		Action& a = queue_action(OP_NOTICE, "");
	a->data = (void*) notice;		a.msg = notice;
	}		}

	void fb_queue_wait_for_disconnect(void)		void fb_queue_wait_for_disconnect() {
	{
	queue_action(OP_WAIT_FOR_DISCONNECT, "");		queue_action(OP_WAIT_FOR_DISCONNECT, "");
	}		}

	int64_t fb_execute_queue(Transport* transport)		int64_t fb_execute_queue(Transport* transport) {
	{
	Action *a;
	char resp[FB_RESPONSE_SZ+1];
	int64_t status = 0;		int64_t status = 0;
			for (auto& a : action_list) {
	a = action_list;
	if (!a)
	return status;
	resp[FB_RESPONSE_SZ] = 0;

	double start = -1;
	for (a = action_list; a; a = a->next) {
	a->start = now();		a->start = now();
	if (start < 0) start = a->start;		if (!a->msg.empty()) {
	if (a->msg) {		fprintf(stderr, "%s\n", a->msg.c_str());
	// fprintf(stderr,"%30s... ",a->msg);
	fprintf(stderr,"%s...\n",a->msg);
	}		}
	if (a->op == OP_DOWNLOAD) {		if (a->op == OP_DOWNLOAD) {
	status = fb_download_data(transport, a->data, a->size);		status = fb_download_data(transport, a->data, a->size);
	status = a->func(a, status, status ? fb_get_error().c_str() : "");		status = a->func(*a, status, status ? fb_get_error().c_str() : "");
	if (status) break;		if (status) break;
	} else if (a->op == OP_DOWNLOAD_FD) {		} else if (a->op == OP_DOWNLOAD_FD) {
	status = fb_download_data_fd(transport, a->fd, a->size);		status = fb_download_data_fd(transport, a->fd, a->size);
	status = a->func(a, status, status ? fb_get_error().c_str() : "");		status = a->func(*a, status, status ? fb_get_error().c_str() : "");
	if (status) break;		if (status) break;
	} else if (a->op == OP_COMMAND) {		} else if (a->op == OP_COMMAND) {
	status = fb_command(transport, a->cmd);		status = fb_command(transport, a->cmd);
	status = a->func(a, status, status ? fb_get_error().c_str() : "");		status = a->func(*a, status, status ? fb_get_error().c_str() : "");
	if (status) break;		if (status) break;
	} else if (a->op == OP_QUERY) {		} else if (a->op == OP_QUERY) {
			char resp[FB_RESPONSE_SZ + 1] = {};
	status = fb_command_response(transport, a->cmd, resp);		status = fb_command_response(transport, a->cmd, resp);
	status = a->func(a, status, status ? fb_get_error().c_str() : resp);		status = a->func(*a, status, status ? fb_get_error().c_str() : resp);
	if (status) break;		if (status) break;
	} else if (a->op == OP_NOTICE) {		} else if (a->op == OP_NOTICE) {
	fprintf(stderr,"%s\n",(char*)a->data);		// We already showed the notice because it's in `Action::msg`.
	} else if (a->op == OP_DOWNLOAD_SPARSE) {		} else if (a->op == OP_DOWNLOAD_SPARSE) {
	status = fb_download_data_sparse(transport, reinterpret_cast<sparse_file*>(a->data));		status = fb_download_data_sparse(transport, reinterpret_cast<sparse_file*>(a->data));
	status = a->func(a, status, status ? fb_get_error().c_str() : "");		status = a->func(*a, status, status ? fb_get_error().c_str() : "");
	if (status) break;		if (status) break;
	} else if (a->op == OP_WAIT_FOR_DISCONNECT) {		} else if (a->op == OP_WAIT_FOR_DISCONNECT) {
	transport->WaitForDisconnect();		transport->WaitForDisconnect();
	} else if (a->op == OP_UPLOAD) {		} else if (a->op == OP_UPLOAD) {
	status = fb_upload_data(transport, reinterpret_cast<char*>(a->data));		status = fb_upload_data(transport, reinterpret_cast<char*>(a->data));
	status = a->func(a, status, status ? fb_get_error().c_str() : "");		status = a->func(*a, status, status ? fb_get_error().c_str() : "");
	} else {		} else {
	die("bogus action");		die("unknown action: %d", a->op);
	}		}
	}		}
			action_list.clear();
	fprintf(stderr,"finished. total time: %.3fs\n", (now() - start));
	return status;		return status;
	}		}

fastboot/fastboot.cpp

+91 −73

File changed.

Preview size limit exceeded, changes collapsed.

fastboot/fastboot.h

+19 −19

Original line number	Original line	Diff line number	Diff line
	@@ -39,8 +39,8 @@
	struct sparse_file;		struct sparse_file;

	/* protocol.c - fastboot protocol */		/* protocol.c - fastboot protocol */
	int fb_command(Transport* transport, const char* cmd);		int fb_command(Transport* transport, const std::string& cmd);
	int fb_command_response(Transport* transport, const char* cmd, char* response);		int fb_command_response(Transport* transport, const std::string& cmd, char* response);
	int64_t fb_download_data(Transport* transport, const void* data, uint32_t size);		int64_t fb_download_data(Transport* transport, const void* data, uint32_t size);
	int64_t fb_download_data_fd(Transport* transport, int fd, uint32_t size);		int64_t fb_download_data_fd(Transport* transport, int fd, uint32_t size);
	int fb_download_data_sparse(Transport* transport, struct sparse_file* s);		int fb_download_data_sparse(Transport* transport, struct sparse_file* s);
	@@ -52,29 +52,29 @@ const std::string fb_get_error();

	/* engine.c - high level command queue engine */		/* engine.c - high level command queue engine */
	bool fb_getvar(Transport* transport, const std::string& key, std::string* value);		bool fb_getvar(Transport* transport, const std::string& key, std::string* value);
	void fb_queue_flash(const char ptn, void data, uint32_t sz);		void fb_queue_flash(const std::string& partition, void* data, uint32_t sz);
	void fb_queue_flash_fd(const char *ptn, int fd, uint32_t sz);		void fb_queue_flash_fd(const std::string& partition, int fd, uint32_t sz);
	void fb_queue_flash_sparse(const char* ptn, struct sparse_file* s, uint32_t sz, size_t current,		void fb_queue_flash_sparse(const std::string& partition, struct sparse_file* s, uint32_t sz,
	size_t total);		size_t current, size_t total);
	void fb_queue_erase(const char *ptn);		void fb_queue_erase(const std::string& partition);
	void fb_queue_format(const char *ptn, int skip_if_not_supported, int32_t max_chunk_sz);		void fb_queue_format(const std::string& partition, int skip_if_not_supported, int32_t max_chunk_sz);
	void fb_queue_require(const char prod, const char var, bool invert,		void fb_queue_require(const std::string& prod, const std::string& var, bool invert, size_t nvalues,
	size_t nvalues, const char **value);		const char** values);
	void fb_queue_display(const char var, const char prettyname);		void fb_queue_display(const std::string& label, const std::string& var);
	void fb_queue_query_save(const char var, char dest, uint32_t dest_size);		void fb_queue_query_save(const std::string& var, char* dest, uint32_t dest_size);
	void fb_queue_reboot(void);		void fb_queue_reboot(void);
	void fb_queue_command(const char cmd, const char msg);		void fb_queue_command(const std::string& cmd, const std::string& msg);
	void fb_queue_download(const char name, void data, uint32_t size);		void fb_queue_download(const std::string& name, void* data, uint32_t size);
	void fb_queue_download_fd(const char *name, int fd, uint32_t sz);		void fb_queue_download_fd(const std::string& name, int fd, uint32_t sz);
	void fb_queue_upload(const char* outfile);		void fb_queue_upload(const std::string& outfile);
	void fb_queue_notice(const char *notice);		void fb_queue_notice(const std::string& notice);
	void fb_queue_wait_for_disconnect(void);		void fb_queue_wait_for_disconnect(void);
	int64_t fb_execute_queue(Transport* transport);		int64_t fb_execute_queue(Transport* transport);
	void fb_set_active(const char *slot);		void fb_set_active(const std::string& slot);

	/* util stuff */		/* util stuff */
	double now();		double now();
	char mkmsg(const char fmt, ...);		char* xstrdup(const char*);

	// These printf-like functions are implemented in terms of vsnprintf, so they		// These printf-like functions are implemented in terms of vsnprintf, so they
	// use the same attribute for compile-time format string checking. On Windows,		// use the same attribute for compile-time format string checking. On Windows,

fastboot/protocol.cpp

+12 −12

Original line number	Original line	Diff line number	Diff line
	@@ -113,10 +113,10 @@ static int64_t check_response(Transport* transport, uint32_t size, char* respons
	return -1;		return -1;
	}		}

	static int64_t _command_start(Transport* transport, const char* cmd, uint32_t size, char* response) {		static int64_t _command_start(Transport* transport, const std::string& cmd, uint32_t size,
	size_t cmdsize = strlen(cmd);		char* response) {
	if (cmdsize > 64) {		if (cmd.size() > 64) {
	g_error = android::base::StringPrintf("command too large (%zu)", cmdsize);		g_error = android::base::StringPrintf("command too large (%zu)", cmd.size());
	return -1;		return -1;
	}		}

	@@ -124,7 +124,7 @@ static int64_t _command_start(Transport* transport, const char* cmd, uint32_t si
	response[0] = 0;		response[0] = 0;
	}		}

	if (transport->Write(cmd, cmdsize) != static_cast<int>(cmdsize)) {		if (transport->Write(cmd.c_str(), cmd.size()) != static_cast<int>(cmd.size())) {
	g_error = android::base::StringPrintf("command write failed (%s)", strerror(errno));		g_error = android::base::StringPrintf("command write failed (%s)", strerror(errno));
	transport->Close();		transport->Close();
	return -1;		return -1;
	@@ -167,8 +167,8 @@ static int64_t _command_end(Transport* transport) {
	return check_response(transport, 0, 0) < 0 ? -1 : 0;		return check_response(transport, 0, 0) < 0 ? -1 : 0;
	}		}

	static int64_t _command_send(Transport* transport, const char* cmd, const void* data, uint32_t size,		static int64_t _command_send(Transport* transport, const std::string& cmd, const void* data,
	char* response) {		uint32_t size, char* response) {
	if (size == 0) {		if (size == 0) {
	return -1;		return -1;
	}		}
	@@ -190,7 +190,7 @@ static int64_t _command_send(Transport* transport, const char* cmd, const void*
	return size;		return size;
	}		}

	static int64_t _command_send_fd(Transport* transport, const char* cmd, int fd, uint32_t size,		static int64_t _command_send_fd(Transport* transport, const std::string& cmd, int fd, uint32_t size,
	char* response) {		char* response) {
	static constexpr uint32_t MAX_MAP_SIZE = 512 * 1024 * 1024;		static constexpr uint32_t MAX_MAP_SIZE = 512 * 1024 * 1024;
	off64_t offset = 0;		off64_t offset = 0;
	@@ -223,15 +223,15 @@ static int64_t _command_send_fd(Transport* transport, const char* cmd, int fd, u
	return size;		return size;
	}		}

	static int _command_send_no_data(Transport* transport, const char* cmd, char* response) {		static int _command_send_no_data(Transport* transport, const std::string& cmd, char* response) {
	return _command_start(transport, cmd, 0, response);		return _command_start(transport, cmd, 0, response);
	}		}

	int fb_command(Transport* transport, const char* cmd) {		int fb_command(Transport* transport, const std::string& cmd) {
	return _command_send_no_data(transport, cmd, 0);		return _command_send_no_data(transport, cmd, 0);
	}		}

	int fb_command_response(Transport* transport, const char* cmd, char* response) {		int fb_command_response(Transport* transport, const std::string& cmd, char* response) {
	return _command_send_no_data(transport, cmd, response);		return _command_send_no_data(transport, cmd, response);
	}		}

	@@ -339,7 +339,7 @@ int fb_download_data_sparse(Transport* transport, struct sparse_file* s) {
	}		}

	std::string cmd(android::base::StringPrintf("download:%08x", size));		std::string cmd(android::base::StringPrintf("download:%08x", size));
	int r = _command_start(transport, cmd.c_str(), size, 0);		int r = _command_start(transport, cmd, size, 0);
	if (r < 0) {		if (r < 0) {
	return -1;		return -1;
	}		}

fastboot/util.cpp

+9 −20

Original line number	Original line	Diff line number	Diff line
	@@ -35,35 +35,24 @@

	#include "fastboot.h"		#include "fastboot.h"

	double now()		double now() {
	{
	struct timeval tv;		struct timeval tv;
	gettimeofday(&tv, NULL);		gettimeofday(&tv, NULL);
	return (double)tv.tv_sec + (double)tv.tv_usec / 1000000;		return (double)tv.tv_sec + (double)tv.tv_usec / 1000000;
	}		}

	char mkmsg(const char fmt, ...)		void die(const char* fmt, ...) {
	{
	char buf[256];
	char *s;
	va_list ap;

	va_start(ap, fmt);
	vsprintf(buf, fmt, ap);
	va_end(ap);

	s = strdup(buf);
	if (s == 0) die("out of memory");
	return s;
	}

	void die(const char *fmt, ...)
	{
	va_list ap;		va_list ap;
	va_start(ap, fmt);		va_start(ap, fmt);
	fprintf(stderr,"error: ");		fprintf(stderr,"error: ");
	vfprintf(stderr, fmt, ap);		vfprintf(stderr, fmt, ap);
	fprintf(stderr,"\n");		fprintf(stderr,"\n");
	va_end(ap);		va_end(ap);
	exit(1);		exit(EXIT_FAILURE);
			}

			char* xstrdup(const char* s) {
			char* result = strdup(s);
			if (!result) die("out of memory");
			return result;
	}		}