/* Read two ssize_t's, separated by a comma, from str, and store them in * *line and *column (if they're not both NULL). Return FALSE on error, * or TRUE otherwise. */ bool parse_line_column(const char *str, ssize_t *line, ssize_t *column) { bool retval = TRUE; const char *comma; assert(str != NULL); comma = strchr(str, ','); if (comma != NULL && column != NULL) { if (!parse_num(comma + 1, column)) retval = FALSE; } if (line != NULL) { if (comma != NULL) { char *str_line = mallocstrncpy(NULL, str, comma - str + 1); str_line[comma - str] = '\0'; if (str_line[0] != '\0' && !parse_num(str_line, line)) retval = FALSE; free(str_line); } else if (!parse_num(str, line)) retval = FALSE; } return retval; }
int parse_hunk_header(char *line, int len, int *ob, int *on, int *nb, int *nn) { char *cp; cp = line + 4; if (parse_num(&cp, ob)) { bad_line: return error("malformed diff output: %s", line); } if (*cp == ',') { cp++; if (parse_num(&cp, on)) goto bad_line; } else *on = 1; if (*cp++ != ' ' || *cp++ != '+') goto bad_line; if (parse_num(&cp, nb)) goto bad_line; if (*cp == ',') { cp++; if (parse_num(&cp, nn)) goto bad_line; } else *nn = 1; return -!!memcmp(cp, " @@", 3); }
uforth_stat uforth_interpret(char *str) { uforth_stat stat; char *word; CELL wd_idx; char immediate = 0; char primitive = 0; uforth_iram->inbufptr = str; while(*(word = uforth_next_word()) != 0) { wd_idx = find_word(word,uforth_iram->currwordlen,0,&immediate,&primitive); switch (uforth_iram->compiling) { case 0: /* interpret mode */ if (wd_idx == 0) { /* number or trash */ DCELL num = parse_num(word,uforth_uram->base); if (num == 0 && word[0] != '0') { uforth_abort_request(ABORT_NAW); uforth_abort(); return E_NOT_A_WORD; } if (abs32(num) > (int32_t)MAX_CELL_NUM){ dpush32(num); } else { dpush(num); } } else { stat = exec(wd_idx,primitive,uforth_uram->ridx-1); if (stat != OK) { uforth_abort(); uforth_abort_clr(); return stat; } } break; case 1: /* in the middle of a colon def */ if (wd_idx == 0) { /* number or trash */ DCELL num = parse_num(word,uforth_uram->base); if (num == 0 && word[0] != '0') { uforth_abort_request(ABORT_NAW); uforth_abort(); dict_end_def(); return E_NOT_A_WORD; } /* OPTIMIZATION: Only DLIT big numbers */ if (num < 0 || abs32(num) > (int32_t)MAX_CELL_NUM){ dict_append(DLIT); dict_append(((uint32_t)num)>>16); dict_append(((uint16_t)num)&0xffff); } else { dict_append(LIT); dict_append(num); } } else if (word[0] == ';') { /* exit from a colon def */
/* int parse_real(char *str, double *v) * check whether str[] starts with a number, or number/number. If yes, * store the value in *v and return the length of the matching part. * Return value is the same as for the previous routine. */ static int parse_real(char *str, double *v) {int i,ret; double d; i=0; if(*str==' '){ str++; i++; } ret=parse_num(str,v); if(ret<=0) return ret; // 0 or -1 i+=ret; str+=ret; if(*str=='/'){ str++; i++; d=*v; ret=parse_num(str,v); if(ret<=0) return -1; // syntax error i+=ret; *v = d/(*v); } return i; }
static void act_width (void) { char buffer[80]; char prompt[80]; fileoffset_t w; fileoffset_t new_top; int error; sprintf (prompt, "Enter screen width in bytes (now %"OFF"d): ", width); if (!get_str (prompt, buffer, FALSE)) return; w = parse_num (buffer, &error); if (error) { display_beep(); strcpy (message, "Unable to parse width value"); return; } if (w > 0) { width = w; fix_offset(); new_top = cur_pos - (scrlines-1) * width; new_top = begline(new_top); if (top_pos < new_top) top_pos = new_top; } }
static void act_goto (void) { char buffer[80]; fileoffset_t position, new_top; int error; if (!get_str("Enter position to go to: ", buffer, FALSE)) return; /* user break */ position = parse_num (buffer, &error); if (error) { display_beep(); strcpy (message, "Unable to parse position value"); return; } if (position < 0 || position > file_size) { display_beep(); strcpy (message, "Position is outside bounds of file"); return; } cur_pos = position; edit_type = !!edit_type; new_top = cur_pos - (scrlines-1) * width; if (new_top < 0) new_top = 0; new_top = begline(new_top); if (top_pos > cur_pos) top_pos = begline(cur_pos); if (top_pos < new_top) top_pos = new_top; }
static int parse_cryptofunction(ocra_suite * ocra, const char *in) { int ret, l; char *token, *string, *tofree; if (NULL == (tofree = string = strdup(in))) return RFC6287_ERR_POSIX; if ((NULL == (token = strsep(&string, "-"))) || (0 != strcmp(token, "HOTP")) || (NULL == (token = strsep(&string, "-"))) || (none == (ocra->hotp_alg = parse_alg(token))) || (NULL == (token = strsep(&string, "-"))) || (2 < (l = strlen(token))) || (-1 == (ocra->hotp_trunc = parse_num(token))) || ((0 != ocra->hotp_trunc) && ((4 > ocra->hotp_trunc) || (11 < ocra->hotp_trunc))) || ((10 > ocra->hotp_trunc) && (2 == l))) ret = RFC6287_INVALID_SUITE; else ret = 0; free(tofree); return ret; }
int get_second_value(longint_t vars[], char *rhsarg, longint_t *second_value) { char *p; int varnum2; if (strchr(NUMCHRS, *rhsarg) != NULL || strchr(SGNCHRS, *rhsarg) != NULL) { /* first character is a digit or a sign, so RHS * should be a number */ p = rhsarg+1; while (*p) { if (strchr(NUMCHRS, *p) == NULL) { /* nope, found an illegal character */ return ERROR; } p++; } *second_value = parse_num(rhsarg); return !ERROR; } else { /* argument is not a number, so might be a variable */ varnum2 = to_varnum(*rhsarg); if (varnum2==ERROR || strlen(rhsarg)!=1) { /* nope, not a variable either */ return ERROR; } /* is a variable, so can use its value to assign to * second_value */ *second_value = vars[varnum2]; return !ERROR; } return ERROR; }
static struct expr * parse_timecmp() { enum prop prop; enum op op; if (token("atime")) prop = PROP_ATIME; else if (token("ctime")) prop = PROP_CTIME; else if (token("mtime")) prop = PROP_MTIME; else if (token("date")) prop = PROP_DATE; else return parse_cmp(); op = parse_op(); if (!op) parse_error("invalid comparison at '%.15s'", pos); int64_t n; if (parse_num(&n) || parse_dur(&n)) { struct expr *e = mkexpr(op); e->a.prop = prop; e->b.num = n; return e; } return 0; }
static void act_offset (void) { char buffer[80]; char prompt[80]; fileoffset_t o; fileoffset_t new_top; int error; sprintf (prompt, "Enter start-of-file offset in bytes (now %"OFF"d): ", realoffset); if (!get_str (prompt, buffer, FALSE)) return; o = parse_num (buffer, &error); if (error) { display_beep(); strcpy (message, "Unable to parse offset value"); return; } if (o >= 0) { realoffset = o; fix_offset(); new_top = cur_pos - (scrlines-1) * width; new_top = begline(new_top); if (top_pos < new_top) top_pos = new_top; } }
/* parses a line of the file * tries to set the corresponding row in the matrix * returns false on error */ bool parse_row(char* s, int row, LinearProgram* lp) { assert(lp_is_valid(lp)); assert(row >= 0); assert(row < get_rows(lp)); char* end_ptr; int cols = get_cols(lp); int i; for (i = 0; i < cols; i++) { num_t num = parse_num(s, &end_ptr); if (!is_num_valid(num, s, end_ptr)) { return false; } set_coef(lp, row, i, num); s = end_ptr; } s = parse_type(s, row, lp); if (NULL == s) { return false; } num_t num = parse_num(s, &end_ptr); if (!is_num_valid(num, s, end_ptr)) { return false; } s = end_ptr; s = skip_spaces(s); if ('\0' != *s) { return false; } set_rhs(lp, row, num); assert(lp_is_valid(lp)); return true; }
static void sendhup(char *str) { int pid; if (parse_num(str, "PPPD_PID=", &pid) && pid != getpid()) { if (debug) dbglog("sending SIGHUP to process %d", pid); kill(pid, SIGHUP); } }
Sophon_Result sophon_time_parse (Sophon_VM *vm, Sophon_String *str, Sophon_Time *time) { Sophon_Char *ptr; Sophon_Date date; Sophon_Result r; SOPHON_ASSERT(str && time); sophon_memset(&date, 0, sizeof(date)); ptr = sophon_string_chars(vm, str); while (*ptr && sophon_isspace(*ptr)) ptr++; if ((r = parse_num(vm, ptr, &date.year)) < 0) return r; date.year -= 1900; ptr += r; if (*ptr++ != '-') return SOPHON_ERR_PARSE; if ((r = parse_num(vm, ptr, &date.mon)) < 0) return r; date.mon--; ptr += r; if (*ptr++ != '-') return SOPHON_ERR_PARSE; if ((r = parse_num(vm, ptr, &date.mday)) < 0) return r; ptr += r; if ((*ptr == 'T') || (*ptr == ' ')) { ptr++; if ((r = parse_num(vm, ptr, &date.hour)) < 0) return r; ptr += r; if (*ptr++ != ':') return SOPHON_ERR_PARSE; if ((r = parse_num(vm, ptr, &date.min)) < 0) return r; ptr += r; if (*ptr++ != ':') return SOPHON_ERR_PARSE; if ((r = parse_num(vm, ptr, &date.sec)) < 0) return r; ptr += r; if (*ptr++ == '.') { if ((r = parse_num(vm, ptr, &date.msec)) < 0) return r; ptr += r; } } else { date.mday = 1; } return sophon_date_to_time(vm, &date, time); }
/* parses a line of the file * tries to set the corresponding row in the matrix * returns false on error */ bool parse_row(char* s, int row, LinearProgram* lp) { assert(lp_is_valid(lp)); assert(row >= 0); assert(row < lp->rows); int i; char* end_ptr; for (i = 0; i < lp->cols; i++) { num_t num = parse_num(s, &end_ptr); if (!is_num_valid(num, s, end_ptr)) { return false; } lp->matrix[row][i] = num; s = end_ptr; } s = parse_type(s, row, lp); if (NULL == s) { return false; } num_t num = parse_num(s, &end_ptr); if (!is_num_valid(num, s, end_ptr)) { return false; } s = end_ptr; s = skip_spaces(s); if ('\0' != *s) { return false; } lp->vector[row] = num; assert(lp_is_valid(lp)); return true; }
/*---------------------------------------------------------------------- * Write this byte into current packet */ static void write_byte (const char *str) { guint32 num; num = parse_num(str, FALSE); packet_buf[curr_offset] = (guint8) num; curr_offset ++; if (curr_offset >= max_offset) /* packet full */ start_new_packet(); }
/*---------------------------------------------------------------------- * Write this byte into current packet */ static void write_byte (const char *str) { unsigned long num; num = parse_num(str, FALSE); packet_buf[curr_offset] = (unsigned char) num; curr_offset ++; if (curr_offset >= max_offset) /* packet full */ start_new_packet(); }
static void parse_packet(indexer_dv_context *This, unsigned char *p) { indexer_dv_bitstream b; int type = p[0]; b = bitstream_new(p + 1); switch (type) { case 0x62: /* Record date */ parse_num(&b, 8); This->rec_curr_day = parse_bcd(&b, 6); parse_num(&b, 2); This->rec_curr_month = parse_bcd(&b, 5); parse_num(&b, 3); This->rec_curr_year = parse_bcd(&b, 8); if (This->rec_curr_year < 25) { This->rec_curr_year += 2000; } else { This->rec_curr_year += 1900; } This->got_record_date = 1; break; case 0x63: /* Record time */ This->rec_curr_frame = parse_bcd(&b, 6); parse_num(&b, 2); This->rec_curr_second = parse_bcd(&b, 7); parse_num(&b, 1); This->rec_curr_minute = parse_bcd(&b, 7); parse_num(&b, 1); This->rec_curr_hour = parse_bcd(&b, 6); This->got_record_time = 1; break; } }
bool parse_baud(char *s, unsigned long *val, char **es, char *delim) { if (!parse_num(s, val, es, delim)) { return false; } if ((*val == 9600) || (*val == 19200) || (*val == 38400) || (*val == 57600) || (*val == 115200)) return true; else return false; }
//parser cellpoint read_parse(char *ibuf, char **pscan) { current_state = STATE_INIT; stack_init(&parser_stack); stack_init(&state_stack); while (*pscan == NULL || **pscan == '\0'){ *pscan = reload_ibuffer(ibuf); } while (1){ if (current_state == STATE_INIT && !stack_is_empty(&parser_stack)){ //parses a object return stack_pop(&parser_stack); } if (current_state == STATE_INIT){ do_state_init(ibuf, pscan); }else if (current_state == STATE_SHARP){ do_state_sharp(ibuf, pscan); }else if (current_state == STATE_DOT){ do_state_dot(pscan); }else if (current_state == STATE_ADD){ do_state_add(pscan); }else if (current_state == STATE_SUB){ do_state_sub(pscan); }else if (current_state == STATE_NUM){ //parses number object parse_num(pscan); }else if (current_state == STATE_CHAR){ //parses character object parse_char(pscan); }else if (current_state == STATE_STR){ //parses string object parse_string(ibuf, pscan); }else if (current_state == STATE_SYM){ //parses symbol object parse_sym(pscan); }else if (current_state == STATE_LIST){ //parses list object parse_list(ibuf, pscan); }else if (current_state == STATE_VEC){ //parses vector object parse_vector(ibuf, pscan); }else { perror("Error: Bad state. -- READ\n"); error_handler(); return NIL; } } }
// factor = number | string_literal | "(" expression ")" | // variable | "this" | "null" | "true" | "false" | // "{" object_literal "}" | // "[" array_literal "]" | // function_definition | // function_call static enum v7_err parse_factor(struct v7 *v7) { int old_sp = v7_sp(v7); if (*v7->cursor == '(') { TRY(match(v7, '(')); TRY(parse_expression(v7)); TRY(match(v7, ')')); } else if (*v7->cursor == '\'' || *v7->cursor == '"') { TRY(parse_string_literal(v7)); } else if (*v7->cursor == '{') { TRY(parse_object_literal(v7)); } else if (is_alpha(*v7->cursor) || *v7->cursor == '_') { TRY(parse_identifier(v7)); if (test_token(v7, "this", 4)) { inc_stack(v7, 1); v7_top(v7)[-1] = &v7->scopes[v7->current_scope]; } else if (test_token(v7, "null", 4)) { TRY(v7_make_and_push(v7, V7_NULL)); } else if (test_token(v7, "true", 4)) { TRY(v7_make_and_push(v7, V7_BOOL)); v7_top(v7)[-1]->v.num = 1; } else if (test_token(v7, "false", 5)) { TRY(v7_make_and_push(v7, V7_BOOL)); v7_top(v7)[-1]->v.num = 0; } else if (test_token(v7, "function", 8)) { TRY(parse_function_definition(v7, NULL, 0)); } else if (test_token(v7, "delete", 6)) { TRY(parse_delete(v7)); } else { TRY(parse_variable(v7)); } } else { TRY(parse_num(v7)); } if (*v7->cursor == '(') { TRY(parse_function_call(v7)); } // Don't leave anything on stack if no execution flag is set if (v7->no_exec) { inc_stack(v7, old_sp - v7->sp); } return V7_OK; }
object_t *parse_sexp(FILE *fp){ char buf; buf=skip_space_getchar(fp); ungetc(buf,fp); if(isalpha(buf) || buf=='+' || buf=='*' || buf=='-'){ return parse_sym(fp); } else if(isdigit(buf)){ return parse_num(fp); } else if(buf=='('){ return parse_list(fp); } return (object_t*)NULL; }
char *eval (const char *expr) { char result[256], *expr_value; int value; int session = StartSPASMErrorSession(); bool fResult = parse_num (expr, &value); EndSPASMErrorSession(session); if (fResult) { sprintf (result, "$%0X", value); expr_value = strdup (result); } else { expr_value = expand_expr (expr); } return expr_value; }
static struct expr * parse_cmp() { enum prop prop; enum op op; if (token("depth")) prop = PROP_DEPTH; else if (token("kept")) prop = PROP_KEPT; else if (token("index")) prop = PROP_INDEX; else if (token("replies")) { prop = PROP_REPLIES; need_thr = 1; } else if (token("size")) prop = PROP_SIZE; else if (token("total")) prop = PROP_TOTAL; else return parse_flag(); if (!(op = parse_op())) parse_error("invalid comparison at '%.15s'", pos); int64_t n; if (parse_num(&n)) { struct expr *e = mkexpr(op); e->a.prop = prop; e->b.num = n; return e; } else if (token("cur")) { struct expr *e = mkexpr(op); e->a.prop = prop; e->b.var = VAR_CUR; e->extra = 1; return e; } return 0; }
static void do_channel(int argc, char *argv[]) { int cur = CYGACC_CALL_IF_SET_CONSOLE_COMM(CYGNUM_CALL_IF_SET_COMM_ID_QUERY_CURRENT); if (argc == 2) { #ifdef CYGPKG_REDBOOT_ANY_CONSOLE if (strcmp( argv[1], "-1") == 0) { console_selected = false; console_echo = true; } else #endif { unsigned long chan; if ( !parse_num( argv[1], &chan, NULL, NULL) ) { diag_printf("** Error: invalid channel '%s'\n", argv[1]); } else { if (chan < CYGNUM_HAL_VIRTUAL_VECTOR_NUM_CHANNELS) { CYGACC_CALL_IF_SET_CONSOLE_COMM(chan); CYGACC_CALL_IF_SET_DEBUG_COMM(chan); if (chan != cur) console_echo = true; } else { diag_printf("**Error: bad channel number '%s'\n", argv[1]); } } } } /* else display */ else { diag_printf("Current console channel id: "); #ifdef CYGPKG_REDBOOT_ANY_CONSOLE if (!console_selected) diag_printf("-1\n"); else #endif diag_printf("%d\n", cur); } }
static int spmtwam_process_argument(const char *arg, int len) { unsigned int event; if (start == 1) { reset_driver_stat(); } if (strncmp(arg, "clock:", 6) == 0) { if (strncmp(&(arg[6]), "speed", 5) == 0) { twam_clock_mode = true; } else if (strncmp(&(arg[6]), "normal", 6) == 0){ twam_clock_mode = false; } else { return -1; } } else if (strncmp(arg, "signal:", 7) == 0) { if (parse_num(&(arg[7]), &event, len-7) < 0) { return -1; } if (assign_slot(event) < 0) { return -1; } } else if (strncmp(arg, "scpsys:", 7) == 0) { //TODO: event = 0; if (arg[7] == '0') {//infrasys } else if (arg[7] == '1') {//perisys } else { return -1; } } else { return -1; } met_spmtwam.mode = 1; return 0; }
/* * Inserts a define into a label list alphabetically (will parse if possible) */ void write_defines_callback(define_t *define, list_t *label_list) { int value; label_t *label; list_t *node, *prev; if (define->num_args > 0 || define->contents == NULL) return; if (parse_num(define->contents, &value) == false) return; node = label_list->next, prev = label_list; while (node != NULL && strcasecmp (define->name, ((label_t *) node->data)->name) > 0) { prev = node; node = node->next; } label = (label_t *) malloc(sizeof(label_t)); label->name = define->name; label->value = value; list_insert(prev, label); }
char* reduce_string (char* input) { char *output = input; int quote_count = 0; for (int i = 0; input[i] != '\0'; i++, output++) { if (input[i] == '\\') { int value; char pbuf[8] = "'\\ '"; pbuf[2] = input[++i]; parse_num (pbuf, &value); *output = value; } else if (input[i] == '"') { quote_count++; *output = input[i]; } else { *output = input[i]; } } *output = '\0'; // Count the quotes if (quote_count >= 2) { if (input[0] == '"' && input[strlen(input) - 1] == '"') { input[strlen(input) - 1] = '\0'; memmove(input, input + 1, strlen(input)); } } return input; }
static int NFQUEUE_parse(int c, char **argv, int invert, unsigned int *flags, const void *entry, struct xt_entry_target **target) { struct xt_NFQ_info *tinfo = (struct xt_NFQ_info *)(*target)->data; switch (c) { case 'F': if (*flags) xtables_error(PARAMETER_PROBLEM, "NFQUEUE target: " "Only use --queue-num ONCE!"); parse_num(optarg, tinfo); break; case 'B': xtables_error(PARAMETER_PROBLEM, "NFQUEUE target: " "--queue-balance not supported (kernel too old?)"); default: return 0; } return 1; }
char *eval (const char *expr) { char result[256], *expr_value; int value; int session = StartSPASMErrorSession(); bool fResult = parse_num (expr, &value); EndSPASMErrorSession(session); if (fResult) { const char *sign = ""; if (value < 0) { sign = "-"; value = -value; } snprintf (result, sizeof (result), "%s$%0X", sign, value); expr_value = strdup (result); } else { expr_value = expand_expr (expr); } return expr_value; }
int main(int argc, char **argv) { int wants_wipe = 0; int wants_reboot = 0; int wants_reboot_bootloader = 0; int erase_first = 1; void *data; unsigned sz; int status; int c; int longindex; const struct option longopts[] = { {"base", required_argument, 0, 'b'}, {"kernel_offset", required_argument, 0, 'k'}, {"page_size", required_argument, 0, 'n'}, {"ramdisk_offset", required_argument, 0, 'r'}, {"tags_offset", required_argument, 0, 't'}, {"help", no_argument, 0, 'h'}, {"unbuffered", no_argument, 0, 0}, {"version", no_argument, 0, 0}, {0, 0, 0, 0} }; serial = getenv("ANDROID_SERIAL"); while (1) { c = getopt_long(argc, argv, "wub:k:n:r:t:s:S:lp:c:i:m:h", longopts, &longindex); if (c < 0) { break; } /* Alphabetical cases */ switch (c) { case 'b': base_addr = strtoul(optarg, 0, 16); break; case 'c': cmdline = optarg; break; case 'h': usage(); return 1; case 'i': { char *endptr = NULL; unsigned long val; val = strtoul(optarg, &endptr, 0); if (!endptr || *endptr != '\0' || (val & ~0xffff)) die("invalid vendor id '%s'", optarg); vendor_id = (unsigned short)val; break; } case 'k': kernel_offset = strtoul(optarg, 0, 16); break; case 'l': long_listing = 1; break; case 'n': page_size = (unsigned)strtoul(optarg, NULL, 0); if (!page_size) die("invalid page size"); break; case 'p': product = optarg; break; case 'r': ramdisk_offset = strtoul(optarg, 0, 16); break; case 't': tags_offset = strtoul(optarg, 0, 16); break; case 's': serial = optarg; break; case 'S': sparse_limit = parse_num(optarg); if (sparse_limit < 0) { die("invalid sparse limit"); } break; case 'u': erase_first = 0; break; case 'w': wants_wipe = 1; break; case '?': return 1; case 0: if (strcmp("unbuffered", longopts[longindex].name) == 0) { setvbuf(stdout, NULL, _IONBF, 0); setvbuf(stderr, NULL, _IONBF, 0); } else if (strcmp("version", longopts[longindex].name) == 0) { fprintf(stdout, "fastboot version %s\n", FASTBOOT_REVISION); return 0; } break; default: abort(); } } argc -= optind; argv += optind; if (argc == 0 && !wants_wipe) { usage(); return 1; } if (argc > 0 && !strcmp(*argv, "devices")) { skip(1); list_devices(); return 0; } if (argc > 0 && !strcmp(*argv, "help")) { usage(); return 0; } usb_handle* usb = open_device(); while (argc > 0) { if(!strcmp(*argv, "getvar")) { require(2); fb_queue_display(argv[1], argv[1]); skip(2); } else if(!strcmp(*argv, "erase")) { require(2); if (fb_format_supported(usb, argv[1], NULL)) { fprintf(stderr, "******** Did you mean to fastboot format this partition?\n"); } fb_queue_erase(argv[1]); skip(2); } else if(!strncmp(*argv, "format", strlen("format"))) { char *overrides; char *type_override = NULL; char *size_override = NULL; require(2); /* * Parsing for: "format[:[type][:[size]]]" * Some valid things: * - select ontly the size, and leave default fs type: * format::0x4000000 userdata * - default fs type and size: * format userdata * format:: userdata */ overrides = strchr(*argv, ':'); if (overrides) { overrides++; size_override = strchr(overrides, ':'); if (size_override) { size_override[0] = '\0'; size_override++; } type_override = overrides; } if (type_override && !type_override[0]) type_override = NULL; if (size_override && !size_override[0]) size_override = NULL; if (erase_first && needs_erase(usb, argv[1])) { fb_queue_erase(argv[1]); } fb_perform_format(usb, argv[1], 0, type_override, size_override); skip(2); } else if(!strcmp(*argv, "signature")) { require(2); data = load_file(argv[1], &sz); if (data == 0) die("could not load '%s': %s", argv[1], strerror(errno)); if (sz != 256) die("signature must be 256 bytes"); fb_queue_download("signature", data, sz); fb_queue_command("signature", "installing signature"); skip(2); } else if(!strcmp(*argv, "reboot")) { wants_reboot = 1; skip(1); if (argc > 0) { if (!strcmp(*argv, "bootloader")) { wants_reboot = 0; wants_reboot_bootloader = 1; skip(1); } } require(0); } else if(!strcmp(*argv, "reboot-bootloader")) { wants_reboot_bootloader = 1; skip(1); } else if (!strcmp(*argv, "continue")) { fb_queue_command("continue", "resuming boot"); skip(1); } else if(!strcmp(*argv, "boot")) { char *kname = 0; char *rname = 0; skip(1); if (argc > 0) { kname = argv[0]; skip(1); } if (argc > 0) { rname = argv[0]; skip(1); } data = load_bootable_image(kname, rname, &sz, cmdline); if (data == 0) return 1; fb_queue_download("boot.img", data, sz); fb_queue_command("boot", "booting"); } else if(!strcmp(*argv, "flash")) { char *pname = argv[1]; char *fname = 0; require(2); if (argc > 2) { fname = argv[2]; skip(3); } else { fname = find_item(pname, product); skip(2); } if (fname == 0) die("cannot determine image filename for '%s'", pname); if (erase_first && needs_erase(usb, pname)) { fb_queue_erase(pname); } do_flash(usb, pname, fname); } else if(!strcmp(*argv, "flash:raw")) { char *pname = argv[1]; char *kname = argv[2]; char *rname = 0; require(3); if(argc > 3) { rname = argv[3]; skip(4); } else { skip(3); } data = load_bootable_image(kname, rname, &sz, cmdline); if (data == 0) die("cannot load bootable image"); fb_queue_flash(pname, data, sz); } else if(!strcmp(*argv, "flashall")) { skip(1); do_flashall(usb, erase_first); wants_reboot = 1; } else if(!strcmp(*argv, "update")) { if (argc > 1) { do_update(usb, argv[1], erase_first); skip(2); } else { do_update(usb, "update.zip", erase_first); skip(1); } wants_reboot = 1; } else if(!strcmp(*argv, "oem")) { argc = do_oem_command(argc, argv); } else if(!strcmp(*argv, "flashing") && argc == 2) { if(!strcmp(*(argv+1), "unlock") || !strcmp(*(argv+1), "lock") || !strcmp(*(argv+1), "unlock_critical") || !strcmp(*(argv+1), "lock_critical") || !strcmp(*(argv+1), "get_unlock_ability")) { argc = do_oem_command(argc, argv); } else { usage(); return 1; } } else { usage(); return 1; } } if (wants_wipe) { fb_queue_erase("userdata"); fb_perform_format(usb, "userdata", 1, NULL, NULL); fb_queue_erase("cache"); fb_perform_format(usb, "cache", 1, NULL, NULL); } if (wants_reboot) { fb_queue_reboot(); fb_queue_wait_for_disconnect(); } else if (wants_reboot_bootloader) { fb_queue_command("reboot-bootloader", "rebooting into bootloader"); fb_queue_wait_for_disconnect(); } if (fb_queue_is_empty()) return 0; status = fb_execute_queue(usb); return (status) ? 1 : 0; }