void task4(void) { task_sleep(); flag_create(&wait_flag); lprintf("start task4\n"); for (;;) { task_tsleep(50); flag_set(&wait_flag); lprintf("set_flag task4\n"); } }
static void warts_trace_params(const scamper_trace_t *trace, warts_addrtable_t *table, uint8_t *flags, uint16_t *flags_len, uint16_t *params_len) { int max_id = 0; const warts_var_t *var; size_t i; /* unset all the flags possible */ memset(flags, 0, trace_vars_mfb); *params_len = 0; for(i=0; i<sizeof(trace_vars)/sizeof(warts_var_t); i++) { var = &trace_vars[i]; if(var->id == WARTS_TRACE_ADDR_SRC_GID || var->id == WARTS_TRACE_ADDR_DST_GID) { continue; } if(var->id == WARTS_TRACE_USERID) { if(trace->userid == 0) continue; } if(var->id == WARTS_TRACE_OFFSET) { if(trace->offset == 0) continue; } flag_set(flags, var->id, &max_id); if(var->id == WARTS_TRACE_ADDR_SRC) { *params_len += warts_addr_size(table, trace->src); continue; } else if(var->id == WARTS_TRACE_ADDR_DST) { *params_len += warts_addr_size(table, trace->dst); continue; } assert(var->size >= 0); *params_len += var->size; } *flags_len = fold_flags(flags, max_id); return; }
static int warts_dealias_radargun_state(const scamper_file_t *sf, const void *data, warts_dealias_data_t *state, warts_addrtable_t *table, uint32_t *len) { const scamper_dealias_radargun_t *rg = data; const warts_var_t *var; int max_id = 0; size_t size; uint32_t i; if(rg->probedefc == 0) return -1; size = rg->probedefc * sizeof(warts_dealias_probedef_t); if((state->probedefs = malloc_zero(size)) == NULL) return -1; memset(state->flags, 0, dealias_radargun_vars_mfb); state->params_len = 0; for(i=0; i<sizeof(dealias_radargun_vars)/sizeof(warts_var_t); i++) { var = &dealias_radargun_vars[i]; if(var->id == WARTS_DEALIAS_RADARGUN_FLAGS) { if(rg->flags == 0) continue; } flag_set(state->flags, var->id, &max_id); assert(var->size >= 0); state->params_len += var->size; } state->flags_len = fold_flags(state->flags, max_id); for(i=0; i<rg->probedefc; i++) { if(warts_dealias_probedef_params(sf, &rg->probedefs[i], &state->probedefs[i], table, len) != 0) { return -1; } } /* increase length required for the radargun record */ *len += state->flags_len + state->params_len; if(state->params_len != 0) *len += 2; return 0; }
u8 *cmd_restart_game(u8 *c) { u16 snd_state; u16 user_result; u16 input_state; sound_stop(); input_state = input_edit_status(); input_edit_on(); if (flag_test(F16_RESTARTMODE) != 0) user_result = 1; else user_result = message_box("Press ENTER to restart\nthe game.\n\nPress ESC to continue\nthis game."); if ( user_result != 0) { cmd_cancel_line(0); snd_state = flag_test(F09_SOUND); //clear_memory(); // shouldn't be necessary game_init(); volumes_close(); flag_set(F06_RESTART); if ( snd_state != 0) flag_set(F09_SOUND); state.ticks = 0; if (trace_logic != 0) logic_load_2(trace_logic); menu_enable_all(); } if ( (user_result != 0) || (input_state != 0) ) input_edit_off(); if (user_result != 0) return 0; else return c; }
ssize_t serial_read(int fd, void *buf, size_t count) { u8 data[32000]; int sz; ut64 s; if (config.seek > serial_bufsz) config.seek = serial_bufsz; if (fd == serial_fd) { if (socket_ready(fd, 0, 10)>0) { sz = read(fd, data, 32000); if (sz == -1) { eprintf("Connection closed\n"); // XXX close foo } if (sz>0) { if (serial_buf) serial_buf = (u8 *)realloc(serial_buf, serial_bufsz+sz); else serial_buf = (u8 *)malloc(serial_bufsz+sz); if (lock) memcpy(serial_buf, data, sz); else memcpy(serial_buf+(int)serial_bufsz, data, sz); sprintf((char *)data, "_read_%d", serial_bufread++); flag_set((char *)data, serial_bufsz, 0); flag_set("_read_last", serial_bufsz, 0); serial_bufsz += sz; } } if (config.seek < serial_bufsz) { s = count; if (count+config.seek > serial_bufsz) s = serial_bufsz-config.seek; memcpy(buf, serial_buf+config.seek, s); return s; } } return 0; }
void mesh_geometry::normals_update(bool force) { if((force || flag_get(GEOMETRY_NORMALS_DIRTY)) && vertexnum_get() && facenum_get()) { lock(); normals_calc(position_get(),vertexnum_get(), faces_get(),facenum_get(), normal_get()); unlock(); flag_set(GEOMETRY_NORMALS_DIRTY); } }
static int warts_neighbourdisc_reply_state(scamper_neighbourdisc_reply_t *reply, warts_neighbourdisc_reply_t *state, warts_addrtable_t *table, uint32_t *len) { int i = 0; memset(state->flags, 0, neighbourdisc_reply_vars_mfb); state->params_len = 0; flag_set(state->flags, WARTS_NEIGHBOURDISC_REPLY_RX, &i); state->params_len += 8; flag_set(state->flags, WARTS_NEIGHBOURDISC_REPLY_MAC, &i); state->params_len += warts_addr_size(table, reply->mac); state->flags_len = fold_flags(state->flags, i); *len += state->flags_len + state->params_len; if(state->params_len != 0) *len += 2; return 0; }
static void warts_tbit_params(const scamper_tbit_t *tbit, warts_addrtable_t *table, uint8_t *flags, uint16_t *flags_len, uint16_t *params_len) { const warts_var_t *var; int i, max_id = 0; /* Unset all flags */ memset(flags, 0, tbit_vars_mfb); *params_len = 0; for(i=0; i<sizeof(tbit_vars)/sizeof(warts_var_t); i++) { var = &tbit_vars[i]; /* Skip the variables for which we have no data */ if(var->id == WARTS_TBIT_PKTC16) continue; else if(var->id == WARTS_TBIT_LIST && tbit->list == NULL) continue; else if(var->id == WARTS_TBIT_CYCLE && tbit->cycle == NULL) continue; else if(var->id == WARTS_TBIT_USERID && tbit->userid == 0) continue; else if(var->id == WARTS_TBIT_SRC && tbit->src == NULL) continue; else if(var->id == WARTS_TBIT_DST && tbit->dst == NULL) continue; /* Set the flag for the rest of the variables */ flag_set(flags, var->id, &max_id); /* Variables that don't have a fixed size */ if(var->id == WARTS_TBIT_SRC) { *params_len += warts_addr_size(table, tbit->src); continue; } else if(var->id == WARTS_TBIT_DST) { *params_len += warts_addr_size(table, tbit->dst); continue; } /* The rest of the variables have a fixed size */ *params_len += var->size; } *flags_len = fold_flags(flags, max_id); return; }
static void warts_tbit_pkt_params(const scamper_tbit_pkt_t *pkt, warts_tbit_pkt_t *state, uint32_t *len) { const warts_var_t *var; int max_id = 0; uint16_t i; memset(state->flags, 0, tbit_pkt_vars_mfb); state->params_len = 0; for(i=0; i<sizeof(tbit_pkt_vars) / sizeof(warts_var_t); i++) { var = &tbit_pkt_vars[i]; if(var->id == WARTS_TBIT_PKT_DATA) { if(pkt->len == 0) continue; state->params_len += pkt->len; flag_set(state->flags, var->id, &max_id); continue; } assert(var->size >= 0); state->params_len += var->size; flag_set(state->flags, var->id, &max_id); } state->flags_len = fold_flags(state->flags, max_id); *len += state->flags_len + state->params_len; if(state->params_len != 0) *len += 2; return; }
static void warts_trace_pmtud_n_params(const scamper_trace_pmtud_t *pmtud, const scamper_trace_pmtud_n_t *n, warts_trace_pmtud_n_t *state) { const scamper_trace_hop_t *hop; const warts_var_t *var; uint16_t u16; int i, max_id = 0; memset(state->flags, 0, pmtud_n_vars_mfb); state->params_len = 0; for(i=0; i<sizeof(pmtud_n_vars)/sizeof(warts_var_t); i++) { var = &pmtud_n_vars[i]; if(var->id == WARTS_TRACE_PMTUD_N_TYPE) { if(n->type == 0) continue; } else if(var->id == WARTS_TRACE_PMTUD_N_NHMTU) { if(n->nhmtu == 0) continue; } else if(var->id == WARTS_TRACE_PMTUD_N_HOP) { if(n->hop == NULL) continue; u16 = 0; for(hop = pmtud->hops; hop != NULL; hop = hop->hop_next) { if(hop == n->hop) break; u16++; } assert(hop != NULL); state->hop = u16; } flag_set(state->flags, var->id, &max_id); assert(var->size >= 0); state->params_len += var->size; } state->flags_len = fold_flags(state->flags, max_id); return; }
static int warts_dealias_mercator_state(const scamper_file_t *sf, const void *data, warts_dealias_data_t *state, warts_addrtable_t *table,uint32_t *len) { const scamper_dealias_mercator_t *m = data; int max_id = 0; size_t size = sizeof(warts_dealias_probedef_t); if((state->probedefs = malloc_zero(size)) == NULL) return -1; assert(sizeof(state->flags) >= dealias_mercator_vars_mfb); memset(state->flags, 0, dealias_mercator_vars_mfb); state->params_len = 0; flag_set(state->flags, WARTS_DEALIAS_MERCATOR_ATTEMPTS, &max_id); state->params_len += 1; flag_set(state->flags, WARTS_DEALIAS_MERCATOR_WAIT_TIMEOUT, &max_id); state->params_len += 1; state->flags_len = fold_flags(state->flags, max_id); if(warts_dealias_probedef_params(sf, &m->probedef, &state->probedefs[0], table, len) != 0) { return -1; } /* increase length required for the mercator record */ *len += state->flags_len + state->params_len; if(state->params_len != 0) *len += 2; return 0; }
void go() override { Botan::DL_Group group(get_arg("name")); if(flag_set("pem")) { output() << group.PEM_encode(Botan::DL_Group::ANSI_X9_42_DH_PARAMETERS); } else { output() << "P = " << std::hex << group.get_p() << "\n" << "G = " << group.get_g() << "\n"; } }
/* * Sets friend_faction to be percent% friendly toward faction * >0 means friend, =0 means neutral, <0 means ennemy */ void set_faction_friendliness(u32b faction, u32b friend_faction, s32b percent) { flags_type *faction_table; /* Get the factions table, make if unexisting */ if (!flag_exists(&factions, faction)) { faction_table = flag_new(2); flag_set_flags(&factions, faction, faction_table); } else faction_table = flag_get_flags(&factions, faction); flag_set(faction_table, friend_faction, percent); }
void prepare_inventory(flags_type *inventory) { s32b i; flag_init(inventory, 2); for (i = INVEN_INVEN; i < INVEN_TOTAL; i++) { flags_type *inven = flag_new(2); /* Default size */ flag_set(inven, INVEN_LIMIT_KEY, 23); /* Empty list */ flag_set_full(inventory, i, FLAG_FLAG_FLAGS, 0, 0, inven); } }
static int warts_tracelb_probeset_state(const scamper_file_t *sf, const scamper_tracelb_probeset_t *set, warts_tracelb_probeset_t *state, warts_addrtable_t *table, uint32_t *len) { const warts_var_t *var; int i, max_id = 0; size_t size; state->probec = set->probec; memset(state->flags, 0, tracelb_probeset_vars_mfb); state->params_len = 0; for(i=0; i<sizeof(tracelb_probeset_vars)/sizeof(warts_var_t); i++) { var = &tracelb_probeset_vars[i]; flag_set(state->flags, var->id, &max_id); state->params_len += var->size; } state->flags_len = fold_flags(state->flags, max_id); *len += state->flags_len + state->params_len; if(state->params_len != 0) *len += 2; if(set->probec > 0) { size = sizeof(warts_tracelb_probe_t) * set->probec; if((state->probes = malloc_zero(size)) == NULL) { return -1; } for(i=0; i<set->probec; i++) { if(warts_tracelb_probe_state(sf, set->probes[i], &state->probes[i], table, len) != 0) return -1; } } return 0; }
void go() override { Botan::EC_Group group(get_arg("name")); if(flag_set("pem")) { output() << group.PEM_encode(); } else { output() << "P = " << std::hex << group.get_curve().get_p() << "\n" << "A = " << std::hex << group.get_curve().get_a() << "\n" << "B = " << std::hex << group.get_curve().get_b() << "\n" << "G = " << group.get_base_point().get_affine_x() << "," << group.get_base_point().get_affine_y() << "\n"; } }
static void warts_tbit_pmtud_params(const scamper_tbit_t *tbit, warts_addrtable_t *table, warts_tbit_pmtud_t *state) { scamper_tbit_pmtud_t *pmtud = tbit->data; const warts_var_t *var; int i, max_id = 0; /* unset all the flags possible */ memset(state->flags, 0, tbit_pmtud_vars_mfb); state->params_len = 0; for(i=0; i<sizeof(tbit_pmtud_vars)/sizeof(warts_var_t); i++) { var = &tbit_pmtud_vars[i]; if(var->id == WARTS_TBIT_PMTUD_MTU && pmtud->mtu == 0) continue; if(var->id == WARTS_TBIT_PMTUD_PTBRETX && pmtud->ptb_retx == 0) continue; if(var->id == WARTS_TBIT_PMTUD_OPTIONS && pmtud->options == 0) continue; if(var->id == WARTS_TBIT_PMTUD_PTBSRC && pmtud->ptbsrc == NULL) continue; flag_set(state->flags, var->id, &max_id); if(var->id == WARTS_TBIT_PMTUD_PTBSRC) { state->params_len += warts_addr_size(table, pmtud->ptbsrc); continue; } assert(var->size >= 0); state->params_len += var->size; } state->flags_len = fold_flags(state->flags, max_id); state->len = state->flags_len + state->params_len; if(state->params_len != 0) state->len += 2; return; }
static int radare_tsearch_callback(struct _tokenizer *t, int i, ut64 where) { char flag_name[128]; ut64 off = config.seek; if (align != 0 && where%align != 0) return 1; if (search_count && nhit >= search_count) return 1; nhit++; radare_flag_name (flag_name, i, nhit); radare_seek(where, SEEK_SET); radare_read(0); if (search_flag) flag_set(flag_name, where, 0); if (search_cmdhit && search_cmdhit[0]!='\0') { char *cmdhit = strdup(search_cmdhit); radare_seek(where, SEEK_SET); setenv("KEYWORD", search_last_keyword, 1); // XXX this is not last-keyword!! must array this! radare_cmd(cmdhit, 0); free(cmdhit); radare_controlc(); } if (search_verbose) { u8 *ptr = config.block; //+(where-config.seek)-3; cons_printf("%03d 0x%08llx %s ", nhit, where, flag_name); for(i=0;i<20;i++) { if (is_printable(ptr[i])) cons_printf("%c", ptr[i]); } cons_printf("\n"); } //D { fprintf(stderr, "\r%d\n", nhit); fflush(stderr); } fflush(stdout); config.seek = off; return 0; }
static void warts_trace_pmtud_params(const scamper_trace_t *trace, warts_trace_pmtud_t *state) { const scamper_trace_pmtud_t *pmtud = trace->pmtud; const warts_var_t *var; int i, max_id = 0; /* unset all the flags possible */ memset(state->flags, 0, pmtud_vars_mfb); state->params_len = 0; for(i=0; i<sizeof(pmtud_vars)/sizeof(warts_var_t); i++) { var = &pmtud_vars[i]; if(var->id == WARTS_TRACE_PMTUD_IFMTU) { if(pmtud->ifmtu == 0) continue; } else if(var->id == WARTS_TRACE_PMTUD_PMTU) { if(pmtud->pmtu == 0) continue; } else if(var->id == WARTS_TRACE_PMTUD_OUTMTU) { if(pmtud->outmtu == 0) continue; } else if(var->id == WARTS_TRACE_PMTUD_NOTEC) { if(pmtud->notec == 0) continue; } flag_set(state->flags, var->id, &max_id); assert(var->size >= 0); state->params_len += var->size; } state->flags_len = fold_flags(state->flags, max_id); return; }
void go() override { const std::string algo = get_arg("algo"); const std::string params = get_arg("params"); std::unique_ptr<Botan::Private_Key> key(Botan::create_private_key(algo, rng(), params)); if(!key) { throw CLI_Error_Unsupported("keygen", algo); } const std::string pass = get_arg("passphrase"); const bool der_out = flag_set("der-out"); const std::chrono::milliseconds pbe_millis(get_arg_sz("pbe-millis")); const std::string pbe = get_arg("pbe"); if(der_out) { if(pass.empty()) { write_output(Botan::PKCS8::BER_encode(*key)); } else { write_output(Botan::PKCS8::BER_encode(*key, rng(), pass, pbe_millis, pbe)); } } else { if(pass.empty()) { output() << Botan::PKCS8::PEM_encode(*key); } else { output() << Botan::PKCS8::PEM_encode(*key, rng(), pass, pbe_millis, pbe); } } }
iface_t *get_config(FILE *fp, unsigned int *line, enum itype type) { char *var,*val; struct kopts **opt; iface_t *ifp; int ret; if((ifp = (iface_t *) malloc(sizeof(iface_t))) == NULL) { *line = 0; return(NULL); } memset((void *) ifp,0,sizeof(iface_t)); ifp->direction = BOTH; ifp->checksum=-1; ifp->strict=-1; ifp->type=type; /* Set defaults */ switch (type) { case FILEIO: flag_set(ifp,F_NOCR); break; default: break; } for(opt = &ifp->options;next_config(fp,line,&var,&val) == 0;) { if (!var) return(ifp); if ((ret = add_common_opt(var,val,ifp)) == 0) continue; if ((ret < 0) || (((*opt) = add_option(var,val)) == NULL && (ret=-1))) { if (ret == -1) *line=0; break; } opt=&(*opt)->next; } free_options(ifp->options); free(ifp); return(NULL); }
static void warts_tbit_app_http_params(const scamper_tbit_t *tbit, warts_tbit_app_http_t *state) { scamper_tbit_app_http_t *http = tbit->app_data; const warts_var_t *var; int i, max_id = 0; /* unset all the flags possible */ memset(state->flags, 0, tbit_app_http_vars_mfb); state->params_len = 0; for(i=0; i<sizeof(tbit_app_http_vars)/sizeof(warts_var_t); i++) { var = &tbit_app_http_vars[i]; if(var->id == WARTS_TBIT_APP_HTTP_HOST && http->host == NULL) continue; if(var->id == WARTS_TBIT_APP_HTTP_FILE && http->file == NULL) continue; flag_set(state->flags, var->id, &max_id); if(var->size < 0) { if(var->id == WARTS_TBIT_APP_HTTP_HOST) state->params_len += warts_str_size(http->host); else if(var->id == WARTS_TBIT_APP_HTTP_FILE) state->params_len += warts_str_size(http->file); continue; } assert(var->size >= 0); state->params_len += var->size; } state->flags_len = fold_flags(state->flags, max_id); state->len = state->flags_len + state->params_len; if(state->params_len != 0) state->len += 2; return; }
static void init_gold_list() { s32b k; s32b i=0; /* Create a list of TV_GOLD drops */ gold_list = flag_new(0); /* Look for TV_GOLD */ for (k = 1; k < max_k_idx; k++) { object_kind *k_ptr = &k_info[k]; /* Found a match */ if (has_flag(k_ptr, FLAG_GOLD_VALUE)) { flag_set(gold_list, i, k); i++; } } }
/* * Make a treasure object * * The location must be a legal, clean, floor grid. */ bool make_gold(object_type *j_ptr) { s32b i; s32b k_idx; s32b base; /* First time set up the list of TV_GOLD svals */ if (!gold_list) init_gold_list(); /* Hack -- Pick a Treasure variety */ i = ((randint(object_level + 2) + 2) / 2) - 1; /* Apply "extra" magic */ if (rand_int(GREAT_OBJ) == 0) { i += randint(object_level + 1); } /* Hack -- Creeping Coins only generate "themselves" */ if (coin_type) i = coin_type; /* Do not create "illegal" Treasure Types */ if (i > flag_max_key(gold_list)) i = flag_max_key(gold_list); /* lookup the i'th SV from gold_list and use that */ k_idx = flag_get(gold_list, i); /* Prepare a gold object */ object_prep(j_ptr, k_idx); /* Base coin cost from flag */ base = flag_get(&k_info[k_idx].flags,FLAG_GOLD_VALUE); /* Determine how much the treasure is "worth" (maybe use getter.random instead?) */ flag_set(&j_ptr->flags, FLAG_GOLD_VALUE, (base + randint(base))); /* Success */ return (TRUE); }
void parse(u8 *string) { u16 wordNumber; u8 *wordString; // the string data of the word memset(word_string, 0, sizeof(word_string)); memset(word_num, 0, sizeof(word_num)); parse_read(string); word_total = 0; strPtr = parse_string; while ((*strPtr != 0) && (word_total < WORD_BUF_SIZE)) { wordString = strPtr; wordNumber = word_find(); if (wordNumber == 0xFFFF) // bad { word_string[word_total] = strPtr; state.var[V09_BADWORD] = word_total + 1; // bad word word_total++; assert(word_total > 0); // we need flag 2 set break; } if (wordNumber != WORD_IGNORE) // good { word_num[word_total] = wordNumber; word_string[word_total] = wordString; word_total++; } // if WORD_IGNORE then skip it } if (word_total > 0) flag_set(F02_PLAYERCMD); }
static int warts_dealias_bump_state(const scamper_file_t *sf, const void *data, warts_dealias_data_t *state, warts_addrtable_t *table, uint32_t *len) { const scamper_dealias_bump_t *bump = data; const warts_var_t *var; int i, max_id = 0; size_t size = sizeof(warts_dealias_probedef_t) * 2; if((state->probedefs = malloc_zero(size)) == NULL) return -1; memset(state->flags, 0, dealias_bump_vars_mfb); state->params_len = 0; for(i=0; i<sizeof(dealias_bump_vars)/sizeof(warts_var_t); i++) { var = &dealias_bump_vars[i]; flag_set(state->flags, var->id, &max_id); state->params_len += var->size; } state->flags_len = fold_flags(state->flags, max_id); if(warts_dealias_probedef_params(sf, &bump->probedefs[0], &state->probedefs[0], table, len) != 0 || warts_dealias_probedef_params(sf, &bump->probedefs[1], &state->probedefs[1], table, len) != 0) { return -1; } /* increase length required for the ally record */ *len += state->flags_len + state->params_len; if(state->params_len != 0) *len += 2; return 0; }
int search_range(char *range) { int len, i,j; char str[128]; int num = -1, num2 = -1; tokenizer *t; ut64 tmp = config.seek; ut64 search_from; ut64 search_to; ut64 limit; int range_n = 0; int f0 = 0; ut64 s; if (range == NULL) return 0; free(search_last_keyword); search_last_keyword = strdup(range); // init stuff search_cmdhit = config_get("cmd.hit"); search_count = (int)(size_t)config_get_i("cfg.count"); search_flag = (int)(size_t)config_get("search.flag"); search_from = config_get_i("search.from"); search_to = config_get_i("search.to"); search_verbose = (int)(size_t)config_get("search.verbose"); if (config_get("search.inar")) { if (! ranges_get_n(range_n++, &search_from, &search_to)) { eprintf("No ranges defined\n"); return 0; } printf("Searching using ranges...\n"); } // twice hit_idx = 1; // reset hit index radare_cmd("f -hit0_*", 0); radare_cmd("f -hit0_*", 0); radare_cmd("fs search", 0); do { nhit = 0; t = binparse_new(0); align = config_get_i("search.align"); t->callback = &radare_tsearch_callback; len = strlen(range); // foreach token in range for(j=i=0;i<len;i++,j++) { str[j] = range[i]; str[j+1] = '\0'; switch(range[i+1]) { case '-': num = atoi(str); i++; j=-1; f0=1; break; case '\0': case ',': if (str[0]=='\0') break; num2 = atoi(str); if (f0) { f0=0; if (num == -1) { printf("syntax error\n"); break; } for(j = num;j<=num2;j++) binparse_add_search(t, j); } else binparse_add_search(t, num2); j=-1; str[0]='\0'; i++; break; } } #if __UNIX__ go_alarm(search_alarm); #endif /* search loop */ radare_controlc(); config.seek = search_from; limit = config.limit; if (search_to!=0) limit = search_to; //D eprintf("Searching from 0x%08llx to 0x%08llx\n", search_from, (search_to==0)?-1:search_to); for(i=1, radare_read(0); !config.interrupted; i = radare_read(1)) { s = config.seek; if (i==0) { //eprintf("read err at 0x%08llx\n", config.seek); break; } if (limit && config.seek >= limit) break; if (config.debug && config.seek == 0xFFFFFFFF) break; for(i=0;!config.interrupted && i<config.block_size;i++) { if (update_tlist(t, config.block[i], config.seek+i)) { config.seek = s; radare_read(0); } } config.seek = s; } } while(config_get("search.inar") && ranges_get_n(range_n++, &search_from, &search_to)); binparser_free(t); #if __UNIX__ go_alarm(SIG_IGN); #endif if (config.interrupted) { printf("\nStopped at 0x"OFF_FMTx" (flag search_stop)\n", config.seek); flag_set("search_stop",config.seek, 0); } radare_controlc_end(); radare_seek(tmp, SEEK_SET); if (!search_verbose) printf("\n"); return 1; }
static void warts_ping_params(const scamper_ping_t *ping, warts_addrtable_t *table, uint8_t *flags, uint16_t *flags_len, uint16_t *params_len) { const warts_var_t *var; int i, j, max_id = 0; /* unset all the flags possible */ memset(flags, 0, ping_vars_mfb); *params_len = 0; for(i=0; i<sizeof(ping_vars)/sizeof(warts_var_t); i++) { var = &ping_vars[i]; if(var->id == WARTS_PING_ADDR_SRC_GID || var->id == WARTS_PING_ADDR_DST_GID || (var->id == WARTS_PING_ADDR_SRC && ping->src == NULL) || (var->id == WARTS_PING_ADDR_DST && ping->dst == NULL) || (var->id == WARTS_PING_LIST_ID && ping->list == NULL) || (var->id == WARTS_PING_CYCLE_ID && ping->cycle == NULL) || (var->id == WARTS_PING_USERID && ping->userid == 0) || (var->id == WARTS_PING_DATA_LEN && ping->probe_datalen == 0) || (var->id == WARTS_PING_PROBE_METHOD && ping->probe_method == 0) || (var->id == WARTS_PING_PROBE_TOS && ping->probe_tos == 0) || (var->id == WARTS_PING_PROBE_SPORT && ping->probe_sport == 0) || (var->id == WARTS_PING_PROBE_DPORT && ping->probe_dport == 0) || (var->id == WARTS_PING_FLAGS && ping->flags == 0) || (var->id == WARTS_PING_REPLY_PMTU && ping->reply_pmtu == 0) || (var->id == WARTS_PING_PROBE_TIMEOUT && ping->probe_timeout == ping->probe_wait)) { continue; } if(var->id == WARTS_PING_PROBE_ICMPSUM) { if(ping->probe_icmpsum == 0 || (ping->flags & SCAMPER_PING_FLAG_ICMPSUM) == 0) continue; } if(var->id == WARTS_PING_DATA_BYTES) { if(ping->probe_datalen != 0) { flag_set(flags, WARTS_PING_DATA_BYTES, &max_id); *params_len += ping->probe_datalen; } continue; } if(var->id == WARTS_PING_PROBE_TSPS) { if(ping->probe_tsps != NULL) { flag_set(flags, WARTS_PING_PROBE_TSPS, &max_id); *params_len += 1; for(j=0; j<ping->probe_tsps->ipc; j++) *params_len += warts_addr_size(table,ping->probe_tsps->ips[j]); } continue; } flag_set(flags, var->id, &max_id); if(var->id == WARTS_PING_ADDR_SRC) { *params_len += warts_addr_size(table, ping->src); continue; } else if(var->id == WARTS_PING_ADDR_DST) { *params_len += warts_addr_size(table, ping->dst); continue; } assert(var->size >= 0); *params_len += var->size; } *flags_len = fold_flags(flags, max_id); return; }
static void warts_ping_reply_params(const scamper_ping_t *ping, const scamper_ping_reply_t *reply, warts_addrtable_t *table, uint8_t *flags, uint16_t *flags_len, uint16_t *params_len) { const warts_var_t *var; int i, j, max_id = 0; /* unset all the flags possible */ memset(flags, 0, ping_reply_vars_mfb); *params_len = 0; for(i=0; i<sizeof(ping_reply_vars)/sizeof(warts_var_t); i++) { var = &ping_reply_vars[i]; if(var->id == WARTS_PING_REPLY_ADDR_GID || (var->id == WARTS_PING_REPLY_ADDR && reply->addr == NULL) || (var->id == WARTS_PING_REPLY_FLAGS && reply->flags == 0) || (var->id == WARTS_PING_REPLY_REPLY_PROTO && SCAMPER_PING_METHOD_IS_ICMP(ping)) || (var->id == WARTS_PING_REPLY_REPLY_TTL && (reply->flags & SCAMPER_PING_REPLY_FLAG_REPLY_TTL) == 0) || (var->id == WARTS_PING_REPLY_REPLY_IPID && SCAMPER_ADDR_TYPE_IS_IPV4(ping->dst) && (reply->flags & SCAMPER_PING_REPLY_FLAG_REPLY_IPID) == 0) || (var->id == WARTS_PING_REPLY_REPLY_IPID32 && SCAMPER_ADDR_TYPE_IS_IPV6(ping->dst) && (reply->flags & SCAMPER_PING_REPLY_FLAG_REPLY_IPID) == 0) || (var->id == WARTS_PING_REPLY_PROBE_IPID && SCAMPER_ADDR_TYPE_IS_IPV4(ping->dst) && (reply->flags & SCAMPER_PING_REPLY_FLAG_PROBE_IPID) == 0) || (var->id == WARTS_PING_REPLY_ICMP_TC && SCAMPER_PING_REPLY_IS_ICMP(reply) == 0) || (var->id == WARTS_PING_REPLY_TCP_FLAGS && SCAMPER_PING_REPLY_IS_TCP(reply) == 0) || (var->id == WARTS_PING_REPLY_V4RR && reply->v4rr == NULL) || (var->id == WARTS_PING_REPLY_V4TS && reply->v4ts == NULL) || (var->id == WARTS_PING_REPLY_TX && reply->tx.tv_sec == 0) || (var->id == WARTS_PING_REPLY_TSREPLY && reply->tsreply == NULL)) { continue; } flag_set(flags, var->id, &max_id); if(var->id == WARTS_PING_REPLY_ADDR) { *params_len += warts_addr_size(table, reply->addr); } else if(var->id == WARTS_PING_REPLY_V4RR) { *params_len += 1; for(j=0; j<reply->v4rr->rrc; j++) *params_len += warts_addr_size(table, reply->v4rr->rr[j]); } else if(var->id == WARTS_PING_REPLY_V4TS) { assert(reply->v4ts != NULL); *params_len += 2; /* one byte tsc, one byte count of v4ts->ips */ *params_len += (reply->v4ts->tsc * 4); if(reply->v4ts->ips != NULL) for(j=0; j<reply->v4ts->tsc; j++) *params_len += warts_addr_size(table, reply->v4ts->ips[j]); } else { assert(var->size >= 0); *params_len += var->size; } } *flags_len = fold_flags(flags, max_id); return; }
static int warts_dealias_prefixscan_state(const scamper_file_t *sf, const void *data, warts_dealias_data_t *state, warts_addrtable_t *table, uint32_t *len) { const scamper_dealias_prefixscan_t *p = data; const warts_var_t *var; int max_id = 0; uint16_t i, j; size_t size; if(p->probedefc > 0) { size = p->probedefc * sizeof(warts_dealias_probedef_t); if((state->probedefs = malloc_zero(size)) == NULL) return -1; } memset(state->flags, 0, dealias_prefixscan_vars_mfb); state->params_len = 0; for(i=0; i<sizeof(dealias_prefixscan_vars)/sizeof(warts_var_t); i++) { var = &dealias_prefixscan_vars[i]; if(var->id == WARTS_DEALIAS_PREFIXSCAN_A) { if(p->a != NULL) { flag_set(state->flags, var->id, &max_id); state->params_len += warts_addr_size(table, p->a); } continue; } else if(var->id == WARTS_DEALIAS_PREFIXSCAN_B) { if(p->b != NULL) { flag_set(state->flags, var->id, &max_id); state->params_len += warts_addr_size(table, p->b); } continue; } else if(var->id == WARTS_DEALIAS_PREFIXSCAN_AB) { if(p->ab != NULL) { flag_set(state->flags, var->id, &max_id); state->params_len += warts_addr_size(table, p->ab); } continue; } else if(var->id == WARTS_DEALIAS_PREFIXSCAN_XS) { if(p->xc > 0) { flag_set(state->flags, var->id, &max_id); state->params_len += 2; for(j=0; j<p->xc; j++) state->params_len += warts_addr_size(table, p->xs[j]); } continue; } else if(var->id == WARTS_DEALIAS_PREFIXSCAN_PROBEDEFC) { if(p->probedefc == 0) continue; } else if(var->id == WARTS_DEALIAS_PREFIXSCAN_FLAGS) { if(p->flags == 0) continue; } else if(var->id == WARTS_DEALIAS_PREFIXSCAN_REPLYC) { if(p->replyc == 5) continue; } flag_set(state->flags, var->id, &max_id); assert(var->size >= 0); state->params_len += var->size; } state->flags_len = fold_flags(state->flags, max_id); for(i=0; i<p->probedefc; i++) { if(warts_dealias_probedef_params(sf, &p->probedefs[i], &state->probedefs[i], table, len) != 0) { return -1; } } *len += state->flags_len + state->params_len; if(state->params_len != 0) *len += 2; return 0; }