The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 1 | /* |
| 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 Pomazau | 5ae3f93 | 2012-02-28 07:21:08 -0800 | [diff] [blame] | 12 | * the documentation and/or other materials provided with the |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 13 | * 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 Pomazau | 5ae3f93 | 2012-02-28 07:21:08 -0800 | [diff] [blame] | 22 | * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 23 | * 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 Pomazau | c8ba536 | 2011-12-15 17:50:18 -0800 | [diff] [blame] | 29 | #include "fastboot.h" |
Dmitry Grinberg | e6f3e9b | 2014-03-11 18:28:15 -0700 | [diff] [blame] | 30 | #include "fs.h" |
Anatol Pomazau | c8ba536 | 2011-12-15 17:50:18 -0800 | [diff] [blame] | 31 | |
Colin Cross | 81c632e | 2013-01-23 19:13:43 -0800 | [diff] [blame] | 32 | #include <errno.h> |
Elliott Hughes | 3ab8b85 | 2015-08-25 19:34:13 -0700 | [diff] [blame] | 33 | #include <stdarg.h> |
Mark Salyzyn | 5957c1f | 2014-04-30 14:05:28 -0700 | [diff] [blame] | 34 | #include <stdio.h> |
| 35 | #include <stdlib.h> |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 36 | #include <string.h> |
Anatol Pomazau | c8ba536 | 2011-12-15 17:50:18 -0800 | [diff] [blame] | 37 | #include <sys/stat.h> |
Anatol Pomazau | c8ba536 | 2011-12-15 17:50:18 -0800 | [diff] [blame] | 38 | #include <sys/types.h> |
| 39 | #include <unistd.h> |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 40 | |
Anatol Pomazau | c8ba536 | 2011-12-15 17:50:18 -0800 | [diff] [blame] | 41 | #define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0])) |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 42 | |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 43 | #define OP_DOWNLOAD 1 |
| 44 | #define OP_COMMAND 2 |
| 45 | #define OP_QUERY 3 |
| 46 | #define OP_NOTICE 4 |
Dmitry Grinberg | e6f3e9b | 2014-03-11 18:28:15 -0700 | [diff] [blame] | 47 | #define OP_DOWNLOAD_SPARSE 5 |
| 48 | #define OP_WAIT_FOR_DISCONNECT 6 |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 49 | |
| 50 | typedef struct Action Action; |
| 51 | |
Anatol Pomazau | c8ba536 | 2011-12-15 17:50:18 -0800 | [diff] [blame] | 52 | #define CMD_SIZE 64 |
| 53 | |
Elliott Hughes | fc79767 | 2015-04-07 20:12:50 -0700 | [diff] [blame] | 54 | struct Action { |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 55 | unsigned op; |
Elliott Hughes | fc79767 | 2015-04-07 20:12:50 -0700 | [diff] [blame] | 56 | Action* next; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 57 | |
Anatol Pomazau | c8ba536 | 2011-12-15 17:50:18 -0800 | [diff] [blame] | 58 | char cmd[CMD_SIZE]; |
Elliott Hughes | fc79767 | 2015-04-07 20:12:50 -0700 | [diff] [blame] | 59 | 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 Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 65 | |
| 66 | const char *msg; |
Elliott Hughes | b3748de | 2015-06-23 20:27:58 -0700 | [diff] [blame] | 67 | int (*func)(Action* a, int status, const char* resp); |
Daniel Sandler | cb6e22b | 2010-02-25 14:05:33 -0500 | [diff] [blame] | 68 | |
| 69 | double start; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 70 | }; |
| 71 | |
| 72 | static Action *action_list = 0; |
| 73 | static Action *action_last = 0; |
| 74 | |
Anatol Pomazau | c8ba536 | 2011-12-15 17:50:18 -0800 | [diff] [blame] | 75 | |
Anatol Pomazau | c8ba536 | 2011-12-15 17:50:18 -0800 | [diff] [blame] | 76 | |
Anatol Pomazau | c8ba536 | 2011-12-15 17:50:18 -0800 | [diff] [blame] | 77 | |
David Pursell | 0b15663 | 2015-10-30 11:22:01 -0700 | [diff] [blame] | 78 | bool fb_getvar(Transport* transport, const std::string& key, std::string* value) { |
Elliott Hughes | 2fd45a9 | 2015-10-30 11:49:47 -0700 | [diff] [blame] | 79 | std::string cmd = "getvar:"; |
| 80 | cmd += key; |
Colin Cross | 80f2d03 | 2012-05-24 18:24:53 -0700 | [diff] [blame] | 81 | |
Elliott Hughes | 2fd45a9 | 2015-10-30 11:49:47 -0700 | [diff] [blame] | 82 | char buf[FB_RESPONSE_SZ + 1]; |
| 83 | memset(buf, 0, sizeof(buf)); |
David Pursell | 0b15663 | 2015-10-30 11:22:01 -0700 | [diff] [blame] | 84 | if (fb_command_response(transport, cmd.c_str(), buf)) { |
Elliott Hughes | 2fd45a9 | 2015-10-30 11:49:47 -0700 | [diff] [blame] | 85 | return false; |
| 86 | } |
| 87 | *value = buf; |
| 88 | return true; |
Colin Cross | 80f2d03 | 2012-05-24 18:24:53 -0700 | [diff] [blame] | 89 | } |
| 90 | |
Elliott Hughes | b3748de | 2015-06-23 20:27:58 -0700 | [diff] [blame] | 91 | static int cb_default(Action* a, int status, const char* resp) { |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 92 | if (status) { |
| 93 | fprintf(stderr,"FAILED (%s)\n", resp); |
| 94 | } else { |
Daniel Sandler | cb6e22b | 2010-02-25 14:05:33 -0500 | [diff] [blame] | 95 | double split = now(); |
| 96 | fprintf(stderr,"OKAY [%7.3fs]\n", (split - a->start)); |
| 97 | a->start = split; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 98 | } |
| 99 | return status; |
| 100 | } |
| 101 | |
| 102 | static Action *queue_action(unsigned op, const char *fmt, ...) |
| 103 | { |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 104 | va_list ap; |
Bruce Beare | 50b3995 | 2010-07-15 08:52:01 -0700 | [diff] [blame] | 105 | size_t cmdsize; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 106 | |
Elliott Hughes | b3748de | 2015-06-23 20:27:58 -0700 | [diff] [blame] | 107 | Action* a = reinterpret_cast<Action*>(calloc(1, sizeof(Action))); |
| 108 | if (a == nullptr) die("out of memory"); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 109 | |
| 110 | va_start(ap, fmt); |
Bruce Beare | 50b3995 | 2010-07-15 08:52:01 -0700 | [diff] [blame] | 111 | cmdsize = vsnprintf(a->cmd, sizeof(a->cmd), fmt, ap); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 112 | va_end(ap); |
| 113 | |
Bruce Beare | 50b3995 | 2010-07-15 08:52:01 -0700 | [diff] [blame] | 114 | 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 Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 119 | 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 Sandler | cb6e22b | 2010-02-25 14:05:33 -0500 | [diff] [blame] | 127 | |
| 128 | a->start = -1; |
| 129 | |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 130 | return a; |
| 131 | } |
| 132 | |
Daniel Rosenberg | b7bd4ae | 2015-09-14 21:05:41 -0700 | [diff] [blame] | 133 | void 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 Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 140 | void 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 Levitskiy | 8d7ddb3 | 2014-05-07 23:31:59 +0000 | [diff] [blame] | 147 | void fb_queue_flash(const char *ptn, void *data, unsigned sz) |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 148 | { |
| 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 Gao | 9da9ac5 | 2016-01-19 14:50:18 -0800 | [diff] [blame] | 160 | void fb_queue_flash_sparse(const char* ptn, struct sparse_file* s, unsigned sz, size_t current, |
| 161 | size_t total) { |
Colin Cross | f838788 | 2012-05-24 17:18:41 -0700 | [diff] [blame] | 162 | Action *a; |
| 163 | |
| 164 | a = queue_action(OP_DOWNLOAD_SPARSE, ""); |
| 165 | a->data = s; |
| 166 | a->size = 0; |
Josh Gao | 9da9ac5 | 2016-01-19 14:50:18 -0800 | [diff] [blame] | 167 | a->msg = mkmsg("sending sparse '%s' %zu/%zu (%d KB)", ptn, current, total, sz / 1024); |
Colin Cross | f838788 | 2012-05-24 17:18:41 -0700 | [diff] [blame] | 168 | |
| 169 | a = queue_action(OP_COMMAND, "flash:%s", ptn); |
Josh Gao | 9da9ac5 | 2016-01-19 14:50:18 -0800 | [diff] [blame] | 170 | a->msg = mkmsg("writing '%s' %zu/%zu", ptn, current, total); |
Colin Cross | f838788 | 2012-05-24 17:18:41 -0700 | [diff] [blame] | 171 | } |
| 172 | |
Elliott Hughes | b3748de | 2015-06-23 20:27:58 -0700 | [diff] [blame] | 173 | static int match(const char* str, const char** value, unsigned count) { |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 174 | unsigned n; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 175 | |
| 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 Hughes | b3748de | 2015-06-23 20:27:58 -0700 | [diff] [blame] | 196 | static int cb_check(Action* a, int status, const char* resp, int invert) |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 197 | { |
Elliott Hughes | b3748de | 2015-06-23 20:27:58 -0700 | [diff] [blame] | 198 | const char** value = reinterpret_cast<const char**>(a->data); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 199 | 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 Saville | b98762f | 2011-04-04 17:54:59 -0700 | [diff] [blame] | 208 | 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 Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 218 | yes = match(resp, value, count); |
| 219 | if (invert) yes = !yes; |
| 220 | |
| 221 | if (yes) { |
Daniel Sandler | cb6e22b | 2010-02-25 14:05:33 -0500 | [diff] [blame] | 222 | double split = now(); |
| 223 | fprintf(stderr,"OKAY [%7.3fs]\n", (split - a->start)); |
| 224 | a->start = split; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 225 | 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 Hughes | b3748de | 2015-06-23 20:27:58 -0700 | [diff] [blame] | 239 | static int cb_require(Action*a, int status, const char* resp) { |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 240 | return cb_check(a, status, resp, 0); |
| 241 | } |
| 242 | |
Elliott Hughes | b3748de | 2015-06-23 20:27:58 -0700 | [diff] [blame] | 243 | static int cb_reject(Action* a, int status, const char* resp) { |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 244 | return cb_check(a, status, resp, 1); |
| 245 | } |
| 246 | |
Wink Saville | b98762f | 2011-04-04 17:54:59 -0700 | [diff] [blame] | 247 | void fb_queue_require(const char *prod, const char *var, |
Elliott Hughes | fc79767 | 2015-04-07 20:12:50 -0700 | [diff] [blame] | 248 | bool invert, size_t nvalues, const char **value) |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 249 | { |
| 250 | Action *a; |
| 251 | a = queue_action(OP_QUERY, "getvar:%s", var); |
Wink Saville | b98762f | 2011-04-04 17:54:59 -0700 | [diff] [blame] | 252 | a->prod = prod; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 253 | a->data = value; |
| 254 | a->size = nvalues; |
| 255 | a->msg = mkmsg("checking %s", var); |
| 256 | a->func = invert ? cb_reject : cb_require; |
Elliott Hughes | b3748de | 2015-06-23 20:27:58 -0700 | [diff] [blame] | 257 | if (a->data == nullptr) die("out of memory"); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 258 | } |
| 259 | |
Elliott Hughes | b3748de | 2015-06-23 20:27:58 -0700 | [diff] [blame] | 260 | static int cb_display(Action* a, int status, const char* resp) { |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 261 | 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 | |
| 269 | void 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 Hughes | b3748de | 2015-06-23 20:27:58 -0700 | [diff] [blame] | 274 | if (a->data == nullptr) die("out of memory"); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 275 | a->func = cb_display; |
| 276 | } |
| 277 | |
Elliott Hughes | b3748de | 2015-06-23 20:27:58 -0700 | [diff] [blame] | 278 | static int cb_save(Action* a, int status, const char* resp) { |
Wink Saville | b98762f | 2011-04-04 17:54:59 -0700 | [diff] [blame] | 279 | if (status) { |
| 280 | fprintf(stderr, "%s FAILED (%s)\n", a->cmd, resp); |
| 281 | return status; |
| 282 | } |
Elliott Hughes | b3748de | 2015-06-23 20:27:58 -0700 | [diff] [blame] | 283 | strncpy(reinterpret_cast<char*>(a->data), resp, a->size); |
Wink Saville | b98762f | 2011-04-04 17:54:59 -0700 | [diff] [blame] | 284 | return 0; |
| 285 | } |
| 286 | |
| 287 | void 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 Hughes | b3748de | 2015-06-23 20:27:58 -0700 | [diff] [blame] | 296 | static int cb_do_nothing(Action*, int , const char*) { |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 297 | fprintf(stderr,"\n"); |
| 298 | return 0; |
| 299 | } |
| 300 | |
| 301 | void 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 | |
| 308 | void fb_queue_command(const char *cmd, const char *msg) |
| 309 | { |
| 310 | Action *a = queue_action(OP_COMMAND, cmd); |
| 311 | a->msg = msg; |
| 312 | } |
| 313 | |
| 314 | void 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 | |
| 322 | void fb_queue_notice(const char *notice) |
| 323 | { |
| 324 | Action *a = queue_action(OP_NOTICE, ""); |
| 325 | a->data = (void*) notice; |
| 326 | } |
| 327 | |
Mark Wachsler | 157b001 | 2013-10-02 09:35:38 -0400 | [diff] [blame] | 328 | void fb_queue_wait_for_disconnect(void) |
| 329 | { |
| 330 | queue_action(OP_WAIT_FOR_DISCONNECT, ""); |
| 331 | } |
| 332 | |
David Pursell | 0b15663 | 2015-10-30 11:22:01 -0700 | [diff] [blame] | 333 | int fb_execute_queue(Transport* transport) |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 334 | { |
| 335 | Action *a; |
| 336 | char resp[FB_RESPONSE_SZ+1]; |
Brian Carlstrom | eb31c0b | 2010-04-23 12:38:51 -0700 | [diff] [blame] | 337 | int status = 0; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 338 | |
| 339 | a = action_list; |
Scott Anderson | 13081c6 | 2012-04-06 12:39:30 -0700 | [diff] [blame] | 340 | if (!a) |
| 341 | return status; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 342 | resp[FB_RESPONSE_SZ] = 0; |
| 343 | |
Daniel Sandler | cb6e22b | 2010-02-25 14:05:33 -0500 | [diff] [blame] | 344 | double start = -1; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 345 | for (a = action_list; a; a = a->next) { |
Daniel Sandler | cb6e22b | 2010-02-25 14:05:33 -0500 | [diff] [blame] | 346 | a->start = now(); |
| 347 | if (start < 0) start = a->start; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 348 | if (a->msg) { |
Brian Swetland | 63e5205 | 2010-06-28 11:14:26 -0700 | [diff] [blame] | 349 | // fprintf(stderr,"%30s... ",a->msg); |
| 350 | fprintf(stderr,"%s...\n",a->msg); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 351 | } |
| 352 | if (a->op == OP_DOWNLOAD) { |
David Pursell | 0b15663 | 2015-10-30 11:22:01 -0700 | [diff] [blame] | 353 | status = fb_download_data(transport, a->data, a->size); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 354 | status = a->func(a, status, status ? fb_get_error() : ""); |
| 355 | if (status) break; |
| 356 | } else if (a->op == OP_COMMAND) { |
David Pursell | 0b15663 | 2015-10-30 11:22:01 -0700 | [diff] [blame] | 357 | status = fb_command(transport, a->cmd); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 358 | status = a->func(a, status, status ? fb_get_error() : ""); |
| 359 | if (status) break; |
| 360 | } else if (a->op == OP_QUERY) { |
David Pursell | 0b15663 | 2015-10-30 11:22:01 -0700 | [diff] [blame] | 361 | status = fb_command_response(transport, a->cmd, resp); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 362 | 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 Cross | f838788 | 2012-05-24 17:18:41 -0700 | [diff] [blame] | 366 | } else if (a->op == OP_DOWNLOAD_SPARSE) { |
David Pursell | 0b15663 | 2015-10-30 11:22:01 -0700 | [diff] [blame] | 367 | status = fb_download_data_sparse(transport, reinterpret_cast<sparse_file*>(a->data)); |
Colin Cross | f838788 | 2012-05-24 17:18:41 -0700 | [diff] [blame] | 368 | status = a->func(a, status, status ? fb_get_error() : ""); |
| 369 | if (status) break; |
Mark Wachsler | 157b001 | 2013-10-02 09:35:38 -0400 | [diff] [blame] | 370 | } else if (a->op == OP_WAIT_FOR_DISCONNECT) { |
David Pursell | 0b15663 | 2015-10-30 11:22:01 -0700 | [diff] [blame] | 371 | transport->WaitForDisconnect(); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 372 | } else { |
| 373 | die("bogus action"); |
| 374 | } |
| 375 | } |
Daniel Sandler | cb6e22b | 2010-02-25 14:05:33 -0500 | [diff] [blame] | 376 | |
| 377 | fprintf(stderr,"finished. total time: %.3fs\n", (now() - start)); |
Brian Carlstrom | eb31c0b | 2010-04-23 12:38:51 -0700 | [diff] [blame] | 378 | return status; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 379 | } |