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;
}
