blob: 47567c0414e611475d5b299eab842cbdd3a9875f [file] [log] [blame]
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001/*
2 * Copyright (C) 2008 The Android Open Source Project
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * * Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * * Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in
Anatol Pomazau5ae3f932012-02-28 07:21:08 -080012 * the documentation and/or other materials provided with the
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080013 * distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
18 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
19 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
21 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
Anatol Pomazau5ae3f932012-02-28 07:21:08 -080022 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080023 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
24 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
25 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28
Anatol Pomazauc8ba5362011-12-15 17:50:18 -080029#include "fastboot.h"
Dmitry Grinberge6f3e9b2014-03-11 18:28:15 -070030#include "fs.h"
Anatol Pomazauc8ba5362011-12-15 17:50:18 -080031
Colin Cross81c632e2013-01-23 19:13:43 -080032#include <errno.h>
Elliott Hughes3ab8b852015-08-25 19:34:13 -070033#include <stdarg.h>
Mark Salyzyn5957c1f2014-04-30 14:05:28 -070034#include <stdio.h>
35#include <stdlib.h>
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080036#include <string.h>
Anatol Pomazauc8ba5362011-12-15 17:50:18 -080037#include <sys/stat.h>
Anatol Pomazauc8ba5362011-12-15 17:50:18 -080038#include <sys/types.h>
39#include <unistd.h>
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080040
Anatol Pomazauc8ba5362011-12-15 17:50:18 -080041#define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0]))
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080042
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080043#define OP_DOWNLOAD 1
44#define OP_COMMAND 2
45#define OP_QUERY 3
46#define OP_NOTICE 4
Dmitry Grinberge6f3e9b2014-03-11 18:28:15 -070047#define OP_DOWNLOAD_SPARSE 5
48#define OP_WAIT_FOR_DISCONNECT 6
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080049
50typedef struct Action Action;
51
Anatol Pomazauc8ba5362011-12-15 17:50:18 -080052#define CMD_SIZE 64
53
Elliott Hughesfc797672015-04-07 20:12:50 -070054struct Action {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080055 unsigned op;
Elliott Hughesfc797672015-04-07 20:12:50 -070056 Action* next;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080057
Anatol Pomazauc8ba5362011-12-15 17:50:18 -080058 char cmd[CMD_SIZE];
Elliott Hughesfc797672015-04-07 20:12:50 -070059 const char* prod;
60 void* data;
61
62 // The protocol only supports 32-bit sizes, so you'll have to break
63 // anything larger into chunks.
64 uint32_t size;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080065
66 const char *msg;
Elliott Hughesb3748de2015-06-23 20:27:58 -070067 int (*func)(Action* a, int status, const char* resp);
Daniel Sandlercb6e22b2010-02-25 14:05:33 -050068
69 double start;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080070};
71
72static Action *action_list = 0;
73static Action *action_last = 0;
74
Anatol Pomazauc8ba5362011-12-15 17:50:18 -080075
Anatol Pomazauc8ba5362011-12-15 17:50:18 -080076
Anatol Pomazauc8ba5362011-12-15 17:50:18 -080077
David Pursell0b156632015-10-30 11:22:01 -070078bool fb_getvar(Transport* transport, const std::string& key, std::string* value) {
Elliott Hughes2fd45a92015-10-30 11:49:47 -070079 std::string cmd = "getvar:";
80 cmd += key;
Colin Cross80f2d032012-05-24 18:24:53 -070081
Elliott Hughes2fd45a92015-10-30 11:49:47 -070082 char buf[FB_RESPONSE_SZ + 1];
83 memset(buf, 0, sizeof(buf));
David Pursell0b156632015-10-30 11:22:01 -070084 if (fb_command_response(transport, cmd.c_str(), buf)) {
Elliott Hughes2fd45a92015-10-30 11:49:47 -070085 return false;
86 }
87 *value = buf;
88 return true;
Colin Cross80f2d032012-05-24 18:24:53 -070089}
90
Elliott Hughesb3748de2015-06-23 20:27:58 -070091static int cb_default(Action* a, int status, const char* resp) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080092 if (status) {
93 fprintf(stderr,"FAILED (%s)\n", resp);
94 } else {
Daniel Sandlercb6e22b2010-02-25 14:05:33 -050095 double split = now();
96 fprintf(stderr,"OKAY [%7.3fs]\n", (split - a->start));
97 a->start = split;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080098 }
99 return status;
100}
101
102static Action *queue_action(unsigned op, const char *fmt, ...)
103{
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800104 va_list ap;
Bruce Beare50b39952010-07-15 08:52:01 -0700105 size_t cmdsize;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800106
Elliott Hughesb3748de2015-06-23 20:27:58 -0700107 Action* a = reinterpret_cast<Action*>(calloc(1, sizeof(Action)));
108 if (a == nullptr) die("out of memory");
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800109
110 va_start(ap, fmt);
Bruce Beare50b39952010-07-15 08:52:01 -0700111 cmdsize = vsnprintf(a->cmd, sizeof(a->cmd), fmt, ap);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800112 va_end(ap);
113
Bruce Beare50b39952010-07-15 08:52:01 -0700114 if (cmdsize >= sizeof(a->cmd)) {
115 free(a);
116 die("Command length (%d) exceeds maximum size (%d)", cmdsize, sizeof(a->cmd));
117 }
118
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800119 if (action_last) {
120 action_last->next = a;
121 } else {
122 action_list = a;
123 }
124 action_last = a;
125 a->op = op;
126 a->func = cb_default;
Daniel Sandlercb6e22b2010-02-25 14:05:33 -0500127
128 a->start = -1;
129
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800130 return a;
131}
132
Daniel Rosenbergb7bd4ae2015-09-14 21:05:41 -0700133void fb_set_active(const char *slot)
134{
135 Action *a;
136 a = queue_action(OP_COMMAND, "set_active:%s", slot);
137 a->msg = mkmsg("Setting current slot to '%s'", slot);
138}
139
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800140void fb_queue_erase(const char *ptn)
141{
142 Action *a;
143 a = queue_action(OP_COMMAND, "erase:%s", ptn);
144 a->msg = mkmsg("erasing '%s'", ptn);
145}
146
Alexander Levitskiy8d7ddb32014-05-07 23:31:59 +0000147void fb_queue_flash(const char *ptn, void *data, unsigned sz)
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800148{
149 Action *a;
150
151 a = queue_action(OP_DOWNLOAD, "");
152 a->data = data;
153 a->size = sz;
154 a->msg = mkmsg("sending '%s' (%d KB)", ptn, sz / 1024);
155
156 a = queue_action(OP_COMMAND, "flash:%s", ptn);
157 a->msg = mkmsg("writing '%s'", ptn);
158}
159
Josh Gao9da9ac52016-01-19 14:50:18 -0800160void fb_queue_flash_sparse(const char* ptn, struct sparse_file* s, unsigned sz, size_t current,
161 size_t total) {
Colin Crossf8387882012-05-24 17:18:41 -0700162 Action *a;
163
164 a = queue_action(OP_DOWNLOAD_SPARSE, "");
165 a->data = s;
166 a->size = 0;
Josh Gao9da9ac52016-01-19 14:50:18 -0800167 a->msg = mkmsg("sending sparse '%s' %zu/%zu (%d KB)", ptn, current, total, sz / 1024);
Colin Crossf8387882012-05-24 17:18:41 -0700168
169 a = queue_action(OP_COMMAND, "flash:%s", ptn);
Josh Gao9da9ac52016-01-19 14:50:18 -0800170 a->msg = mkmsg("writing '%s' %zu/%zu", ptn, current, total);
Colin Crossf8387882012-05-24 17:18:41 -0700171}
172
Elliott Hughesb3748de2015-06-23 20:27:58 -0700173static int match(const char* str, const char** value, unsigned count) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800174 unsigned n;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800175
176 for (n = 0; n < count; n++) {
177 const char *val = value[n];
178 int len = strlen(val);
179 int match;
180
181 if ((len > 1) && (val[len-1] == '*')) {
182 len--;
183 match = !strncmp(val, str, len);
184 } else {
185 match = !strcmp(val, str);
186 }
187
188 if (match) return 1;
189 }
190
191 return 0;
192}
193
194
195
Elliott Hughesb3748de2015-06-23 20:27:58 -0700196static int cb_check(Action* a, int status, const char* resp, int invert)
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800197{
Elliott Hughesb3748de2015-06-23 20:27:58 -0700198 const char** value = reinterpret_cast<const char**>(a->data);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800199 unsigned count = a->size;
200 unsigned n;
201 int yes;
202
203 if (status) {
204 fprintf(stderr,"FAILED (%s)\n", resp);
205 return status;
206 }
207
Wink Savilleb98762f2011-04-04 17:54:59 -0700208 if (a->prod) {
209 if (strcmp(a->prod, cur_product) != 0) {
210 double split = now();
211 fprintf(stderr,"IGNORE, product is %s required only for %s [%7.3fs]\n",
212 cur_product, a->prod, (split - a->start));
213 a->start = split;
214 return 0;
215 }
216 }
217
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800218 yes = match(resp, value, count);
219 if (invert) yes = !yes;
220
221 if (yes) {
Daniel Sandlercb6e22b2010-02-25 14:05:33 -0500222 double split = now();
223 fprintf(stderr,"OKAY [%7.3fs]\n", (split - a->start));
224 a->start = split;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800225 return 0;
226 }
227
228 fprintf(stderr,"FAILED\n\n");
229 fprintf(stderr,"Device %s is '%s'.\n", a->cmd + 7, resp);
230 fprintf(stderr,"Update %s '%s'",
231 invert ? "rejects" : "requires", value[0]);
232 for (n = 1; n < count; n++) {
233 fprintf(stderr," or '%s'", value[n]);
234 }
235 fprintf(stderr,".\n\n");
236 return -1;
237}
238
Elliott Hughesb3748de2015-06-23 20:27:58 -0700239static int cb_require(Action*a, int status, const char* resp) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800240 return cb_check(a, status, resp, 0);
241}
242
Elliott Hughesb3748de2015-06-23 20:27:58 -0700243static int cb_reject(Action* a, int status, const char* resp) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800244 return cb_check(a, status, resp, 1);
245}
246
Wink Savilleb98762f2011-04-04 17:54:59 -0700247void fb_queue_require(const char *prod, const char *var,
Elliott Hughesfc797672015-04-07 20:12:50 -0700248 bool invert, size_t nvalues, const char **value)
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800249{
250 Action *a;
251 a = queue_action(OP_QUERY, "getvar:%s", var);
Wink Savilleb98762f2011-04-04 17:54:59 -0700252 a->prod = prod;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800253 a->data = value;
254 a->size = nvalues;
255 a->msg = mkmsg("checking %s", var);
256 a->func = invert ? cb_reject : cb_require;
Elliott Hughesb3748de2015-06-23 20:27:58 -0700257 if (a->data == nullptr) die("out of memory");
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800258}
259
Elliott Hughesb3748de2015-06-23 20:27:58 -0700260static int cb_display(Action* a, int status, const char* resp) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800261 if (status) {
262 fprintf(stderr, "%s FAILED (%s)\n", a->cmd, resp);
263 return status;
264 }
265 fprintf(stderr, "%s: %s\n", (char*) a->data, resp);
266 return 0;
267}
268
269void fb_queue_display(const char *var, const char *prettyname)
270{
271 Action *a;
272 a = queue_action(OP_QUERY, "getvar:%s", var);
273 a->data = strdup(prettyname);
Elliott Hughesb3748de2015-06-23 20:27:58 -0700274 if (a->data == nullptr) die("out of memory");
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800275 a->func = cb_display;
276}
277
Elliott Hughesb3748de2015-06-23 20:27:58 -0700278static int cb_save(Action* a, int status, const char* resp) {
Wink Savilleb98762f2011-04-04 17:54:59 -0700279 if (status) {
280 fprintf(stderr, "%s FAILED (%s)\n", a->cmd, resp);
281 return status;
282 }
Elliott Hughesb3748de2015-06-23 20:27:58 -0700283 strncpy(reinterpret_cast<char*>(a->data), resp, a->size);
Wink Savilleb98762f2011-04-04 17:54:59 -0700284 return 0;
285}
286
287void fb_queue_query_save(const char *var, char *dest, unsigned dest_size)
288{
289 Action *a;
290 a = queue_action(OP_QUERY, "getvar:%s", var);
291 a->data = (void *)dest;
292 a->size = dest_size;
293 a->func = cb_save;
294}
295
Elliott Hughesb3748de2015-06-23 20:27:58 -0700296static int cb_do_nothing(Action*, int , const char*) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800297 fprintf(stderr,"\n");
298 return 0;
299}
300
301void fb_queue_reboot(void)
302{
303 Action *a = queue_action(OP_COMMAND, "reboot");
304 a->func = cb_do_nothing;
305 a->msg = "rebooting";
306}
307
308void fb_queue_command(const char *cmd, const char *msg)
309{
310 Action *a = queue_action(OP_COMMAND, cmd);
311 a->msg = msg;
312}
313
314void fb_queue_download(const char *name, void *data, unsigned size)
315{
316 Action *a = queue_action(OP_DOWNLOAD, "");
317 a->data = data;
318 a->size = size;
319 a->msg = mkmsg("downloading '%s'", name);
320}
321
322void fb_queue_notice(const char *notice)
323{
324 Action *a = queue_action(OP_NOTICE, "");
325 a->data = (void*) notice;
326}
327
Mark Wachsler157b0012013-10-02 09:35:38 -0400328void fb_queue_wait_for_disconnect(void)
329{
330 queue_action(OP_WAIT_FOR_DISCONNECT, "");
331}
332
David Pursell0b156632015-10-30 11:22:01 -0700333int fb_execute_queue(Transport* transport)
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800334{
335 Action *a;
336 char resp[FB_RESPONSE_SZ+1];
Brian Carlstromeb31c0b2010-04-23 12:38:51 -0700337 int status = 0;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800338
339 a = action_list;
Scott Anderson13081c62012-04-06 12:39:30 -0700340 if (!a)
341 return status;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800342 resp[FB_RESPONSE_SZ] = 0;
343
Daniel Sandlercb6e22b2010-02-25 14:05:33 -0500344 double start = -1;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800345 for (a = action_list; a; a = a->next) {
Daniel Sandlercb6e22b2010-02-25 14:05:33 -0500346 a->start = now();
347 if (start < 0) start = a->start;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800348 if (a->msg) {
Brian Swetland63e52052010-06-28 11:14:26 -0700349 // fprintf(stderr,"%30s... ",a->msg);
350 fprintf(stderr,"%s...\n",a->msg);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800351 }
352 if (a->op == OP_DOWNLOAD) {
David Pursell0b156632015-10-30 11:22:01 -0700353 status = fb_download_data(transport, a->data, a->size);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800354 status = a->func(a, status, status ? fb_get_error() : "");
355 if (status) break;
356 } else if (a->op == OP_COMMAND) {
David Pursell0b156632015-10-30 11:22:01 -0700357 status = fb_command(transport, a->cmd);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800358 status = a->func(a, status, status ? fb_get_error() : "");
359 if (status) break;
360 } else if (a->op == OP_QUERY) {
David Pursell0b156632015-10-30 11:22:01 -0700361 status = fb_command_response(transport, a->cmd, resp);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800362 status = a->func(a, status, status ? fb_get_error() : resp);
363 if (status) break;
364 } else if (a->op == OP_NOTICE) {
365 fprintf(stderr,"%s\n",(char*)a->data);
Colin Crossf8387882012-05-24 17:18:41 -0700366 } else if (a->op == OP_DOWNLOAD_SPARSE) {
David Pursell0b156632015-10-30 11:22:01 -0700367 status = fb_download_data_sparse(transport, reinterpret_cast<sparse_file*>(a->data));
Colin Crossf8387882012-05-24 17:18:41 -0700368 status = a->func(a, status, status ? fb_get_error() : "");
369 if (status) break;
Mark Wachsler157b0012013-10-02 09:35:38 -0400370 } else if (a->op == OP_WAIT_FOR_DISCONNECT) {
David Pursell0b156632015-10-30 11:22:01 -0700371 transport->WaitForDisconnect();
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800372 } else {
373 die("bogus action");
374 }
375 }
Daniel Sandlercb6e22b2010-02-25 14:05:33 -0500376
377 fprintf(stderr,"finished. total time: %.3fs\n", (now() - start));
Brian Carlstromeb31c0b2010-04-23 12:38:51 -0700378 return status;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800379}