void initDimmunix() {
histSize = 0;
init_Cycle(&cycle);
init_Cycle(&stack);
joinPointFound = NULL;
blocked = false;
nSyncs = 0;
nSyncThreads = 0;
nYields = 0;
pthread_mutex_init(&avoidanceLock, NULL);
if((positions=(struct Queue*)malloc_zero(sizeof(struct Queue)*MAXPOSITIONS))==NULL){
LOGD("ERROR ALLOCATING DIMMUNIX positions");
}
if((history=(struct Template*)malloc_zero(sizeof(struct Template)*MAXTEMPLATES))==NULL){
LOGD("ERROR ALLOCATING DIMMUNIX history");
}
int i;
for (i = 0; i < MAXPOSITIONS; i++) {
initQueue(&positions[i]);
}
loadHistory();
// pthread_create(&monitorThread, NULL, printStats, NULL);
enabled = true;
LOGD("initialized Dimmunix");
}
static int warts_trace_pmtud_state(const scamper_trace_t *trace,
warts_trace_pmtud_t *state,
warts_addrtable_t *table)
{
warts_trace_pmtud_n_t *note;
scamper_trace_hop_t *hop;
uint8_t i;
size_t size;
int j;
/* figure out what the structure of the pmtud header looks like */
warts_trace_pmtud_params(trace, state);
/* flags + params + number of hop records for pmtud structure */
state->len = state->flags_len + state->params_len + 2;
if(state->params_len != 0)
state->len += 2;
/* count the number of hop records */
state->hopc = scamper_trace_pmtud_hop_count(trace);
if(state->hopc > 0)
{
/* allocate an array of address indexes for the pmtud hop addresses */
size = state->hopc * sizeof(warts_trace_hop_t);
if((state->hops = (warts_trace_hop_t *)malloc_zero(size)) == NULL)
return -1;
/* record hop state for each pmtud hop */
for(hop = trace->pmtud->hops, j=0; hop != NULL; hop = hop->hop_next)
warts_trace_hop_state(trace,hop,&state->hops[j++],table,&state->len);
}
/* record state for each pmtud note */
if(trace->pmtud->notec > 0)
{
size = trace->pmtud->notec * sizeof(warts_trace_pmtud_n_t);
if((state->notes = (warts_trace_pmtud_n_t *)malloc_zero(size)) == NULL)
return -1;
for(i=0; i<trace->pmtud->notec; i++)
{
note = &state->notes[i];
warts_trace_pmtud_n_params(trace->pmtud,trace->pmtud->notes[i],note);
/* increase length required for the trace record */
state->len += note->flags_len + note->params_len;
if(note->params_len != 0)
state->len += 2;
}
}
return 0;
}
scamper_task_sig_t *scamper_task_sig_alloc(uint8_t type)
{
scamper_task_sig_t *sig;
if((sig = malloc_zero(sizeof(scamper_task_sig_t))) != NULL)
sig->sig_type = type;
return sig;
}
/** Implements the init_input function of the plugin API */
int corsaro_dos_init_input(corsaro_in_t *corsaro)
{
struct corsaro_dos_in_state_t *state;
corsaro_plugin_t *plugin = PLUGIN(corsaro);
assert(plugin != NULL);
if((state = malloc_zero(sizeof(struct corsaro_dos_in_state_t)))
== NULL)
{
corsaro_log_in(__func__, corsaro,
"could not malloc corsaro_dos_state_t");
goto err;
}
corsaro_plugin_register_state(corsaro->plugin_manager, plugin, state);
/* we initially expect an corsaro interval record */
state->expected_type = CORSARO_IN_RECORD_TYPE_IO_INTERVAL_START;
/* don't set the vector_cnt until we actually see a header record */
return 0;
err:
corsaro_dos_close_input(corsaro);
return -1;
}
/** Implements the init_output function of the plugin API */
int corsaro_anon_init_output(corsaro_t *corsaro)
{
struct corsaro_anon_state_t *state;
corsaro_plugin_t *plugin = PLUGIN(corsaro);
assert(plugin != NULL);
if((state = malloc_zero(sizeof(struct corsaro_anon_state_t))) == NULL)
{
corsaro_log(__func__, corsaro,
"could not malloc corsaro_anon_state_t");
goto err;
}
corsaro_plugin_register_state(corsaro->plugin_manager, plugin, state);
/* set the defaults */
state->encryption_type = CORSARO_ANON_ENC_CRYPTOPAN;
state->encrypt_source = ANON_SOURCE;
state->encrypt_destination = ANON_DEST;
/* parse the arguments */
if(parse_args(corsaro) != 0)
{
return -1;
}
assert(state->encryption_key != NULL);
corsaro_anon_init(state->encryption_type, state->encryption_key);
return 0;
err:
corsaro_anon_close_output(corsaro);
return -1;
}
int scamper_dealias_probes_alloc(scamper_dealias_t *dealias, uint32_t cnt)
{
size_t size = cnt * sizeof(scamper_dealias_probe_t *);
if((dealias->probes = malloc_zero(size)) == NULL)
return -1;
return 0;
}
int scamper_dealias_bump_alloc(scamper_dealias_t *dealias)
{
if((dealias->data = malloc_zero(sizeof(scamper_dealias_bump_t))) != NULL)
return 0;
return -1;
}
/*
* scamper_task_alloc
*
* allocate and initialise a task object.
*/
scamper_task_t *scamper_task_alloc(void *data, scamper_task_funcs_t *funcs)
{
scamper_task_t *task;
assert(data != NULL);
assert(funcs != NULL);
if((task = malloc_zero(sizeof(scamper_task_t))) == NULL)
{
printerror(errno, strerror, __func__, "could not malloc task");
goto err;
}
if((task->queue = scamper_queue_alloc(task)) == NULL)
goto err;
if((task->siglist = slist_alloc()) == NULL)
goto err;
task->funcs = funcs;
task->data = data;
return task;
err:
scamper_task_free(task);
return NULL;
}
static scamper_file_t *file_open(int fd, char *fn, char mode, int type)
{
scamper_file_t *sf;
int (*open_func)(scamper_file_t *);
if(mode == 'r') open_func = file_open_read;
else if(mode == 'w') open_func = file_open_write;
else if(mode == 'a') open_func = file_open_append;
else return NULL;
if((sf = (scamper_file_t *)malloc_zero(sizeof(scamper_file_t))) == NULL)
{
return NULL;
}
sf->type = type;
sf->fd = fd;
if(fn != NULL && (sf->filename = strdup(fn)) == NULL)
{
return NULL;
}
if(open_func(sf) == -1)
{
scamper_file_close(sf);
return NULL;
}
return sf;
}
/** Implements the init_output function of the plugin API */
int corsaro_dos_init_output(corsaro_t *corsaro)
{
struct corsaro_dos_state_t *state;
/* retrieve a pointer to the plugin struct with our name and id */
corsaro_plugin_t *plugin = PLUGIN(corsaro);
assert(plugin != NULL);
/*
* allocate memory for the state structure which will hold a pointer to the
* output file and other statistics
*/
if((state = malloc_zero(sizeof(struct corsaro_dos_state_t))) == NULL)
{
corsaro_log(__func__, corsaro,
"could not malloc corsaro_dos_state_t");
goto err;
}
/*
* register the state structure with the plugin manager
* this associates it with our plugin id so it can be retrieved later
*/
corsaro_plugin_register_state(corsaro->plugin_manager, plugin, state);
/* init the hash table for attack vectors */
state->attack_hash = kh_init(av);
return 0;
err:
corsaro_dos_close_output(corsaro);
return -1;
}
bgpstream_elem_t *bgpstream_elem_create() {
// allocate memory for new element
bgpstream_elem_t *ri = NULL;
if((ri =
(bgpstream_elem_t *) malloc_zero(sizeof(bgpstream_elem_t))) == NULL) {
goto err;
}
// all fields are initialized to zero
// need to create as path
if((ri->aspath = bgpstream_as_path_create()) == NULL) {
goto err;
}
// and a community set
if((ri->communities = bgpstream_community_set_create()) == NULL) {
goto err;
}
return ri;
err:
bgpstream_elem_destroy(ri);
return NULL;
}
int scamper_dealias_replies_alloc(scamper_dealias_probe_t *probe, uint16_t cnt)
{
size_t size = cnt * sizeof(scamper_dealias_reply_t *);
if((probe->replies = malloc_zero(size)) == NULL)
return -1;
return 0;
}
int scamper_dealias_prefixscan_xs_alloc(scamper_dealias_prefixscan_t *p,
uint16_t xc)
{
if((p->xs = malloc_zero(sizeof(scamper_addr_t *) * xc)) != NULL)
return 0;
return -1;
}
int scamper_dealias_prefixscan_alloc(scamper_dealias_t *dealias)
{
dealias->data = malloc_zero(sizeof(scamper_dealias_prefixscan_t));
if(dealias->data != NULL)
return 0;
return -1;
}
int scamper_dealias_radargun_probedefs_alloc(scamper_dealias_radargun_t *rg,
uint32_t probedefc)
{
size_t len = probedefc * sizeof(scamper_dealias_probedef_t);
if((rg->probedefs = malloc_zero(len)) == NULL)
return -1;
return 0;
}
int scamper_dealias_prefixscan_probedefs_alloc(scamper_dealias_prefixscan_t *p,
uint32_t probedefc)
{
size_t len = probedefc * sizeof(scamper_dealias_probedef_t);
if((p->probedefs = malloc_zero(len)) != NULL)
return 0;
return -1;
}
static scamper_fd_t *fd_alloc_dm(int type, int fd, const char *file,
const int line)
#endif
{
scamper_fd_t *fdn = NULL;
size_t size;
int i;
#ifndef DMALLOC
if((fdn = malloc_zero(sizeof(scamper_fd_t))) == NULL)
#else
if((fdn = malloc_zero_dm(sizeof(scamper_fd_t), file, line)) == NULL)
#endif
{
goto err;
}
fdn->type = type;
fdn->fd = fd;
fdn->refcnt = 1;
/* set up to poll read ability */
if((fdn->read.node = dlist_node_alloc(&fdn->read)) == NULL)
{
goto err;
}
fdn->read.fdn = fdn;
fdn->read.flags = SCAMPER_FD_POLL_FLAG_INACTIVE;
/* set up to poll write ability */
if((fdn->write.node = dlist_node_alloc(&fdn->write)) == NULL)
{
goto err;
}
fdn->write.fdn = fdn;
fdn->write.flags = SCAMPER_FD_POLL_FLAG_INACTIVE;
/* store the fd in an array indexed by the fd number */
if(fd+1 > fd_array_s)
{
size = sizeof(scamper_fd_t *) * (fd+1);
if(realloc_wrap((void **)&fd_array, size) != 0)
goto err;
for(i=fd_array_s; i<fd+1; i++)
fd_array[i] = NULL;
fd_array_s = fd+1;
}
fd_array[fd] = fdn;
return fdn;
err:
if(fdn != NULL) fd_free(fdn);
return NULL;
}
/** Implements the init_output function of the plugin API */
int bgpcorsaro_pfxmonitor_init_output(bgpcorsaro_t *bgpcorsaro)
{
struct bgpcorsaro_pfxmonitor_state_t *state;
bgpcorsaro_plugin_t *plugin = PLUGIN(bgpcorsaro);
assert(plugin != NULL);
if ((state = malloc_zero(sizeof(struct bgpcorsaro_pfxmonitor_state_t))) ==
NULL) {
bgpcorsaro_log(__func__, bgpcorsaro,
"could not malloc bgpcorsaro_pfxmonitor_state_t");
goto err;
}
bgpcorsaro_plugin_register_state(bgpcorsaro->plugin_manager, plugin, state);
/* initialize state with default values */
state = STATE(bgpcorsaro);
strncpy(state->metric_prefix, PFXMONITOR_DEFAULT_METRIC_PFX,
PFXMONITOR_METRIC_PFX_LEN);
strncpy(state->ip_space_name, PFXMONITOR_DEFAULT_IPSPACE_NAME,
PFXMONITOR_METRIC_PFX_LEN);
if ((state->poi = bgpstream_ip_counter_create()) == NULL) {
goto err;
}
state->peer_asns_th = PFXMONITOR_DEFAULT_PEER_ASNS_THRESHOLD;
state->more_specific = 0;
/* parse the arguments */
if (parse_args(bgpcorsaro) != 0) {
goto err;
}
graphite_safe(state->metric_prefix);
graphite_safe(state->ip_space_name);
/* create all the sets and maps we need */
if ((state->overlapping_pfx_cache = bgpstream_pfx_storage_set_create()) ==
NULL ||
(state->non_overlapping_pfx_cache = bgpstream_pfx_storage_set_create()) ==
NULL ||
(state->pfx_info = kh_init(pfx_info_map)) == NULL ||
(state->unique_origins = bgpstream_id_set_create()) == NULL ||
(state->peer_asns = bgpstream_id_set_create()) == NULL) {
goto err;
}
/* defer opening the output file until we start the first interval */
return 0;
err:
bgpcorsaro_pfxmonitor_close_output(bgpcorsaro);
return -1;
}
scamper_route_t *scamper_route_alloc(scamper_addr_t *dst, void *param,
void (*cb)(scamper_route_t *rt))
{
scamper_route_t *route;
if((route = malloc_zero(sizeof(scamper_route_t))) == NULL)
return NULL;
route->dst = scamper_addr_use(dst);
route->param = param;
route->cb = cb;
return route;
}
/* allocate memory for a new bgpstream filter */
bgpstream_filter_mgr_t *bgpstream_filter_mgr_create()
{
bgpstream_debug("\tBSF_MGR: create start");
bgpstream_filter_mgr_t *bs_filter_mgr =
(bgpstream_filter_mgr_t *)malloc_zero(sizeof(bgpstream_filter_mgr_t));
if (bs_filter_mgr == NULL) {
return NULL; // can't allocate memory
}
bgpstream_debug("\tBSF_MGR: create end");
return bs_filter_mgr;
}
int scamper_task_sig_add(scamper_task_t *task, scamper_task_sig_t *sig)
{
s2t_t *s2t;
if((s2t = malloc_zero(sizeof(s2t_t))) == NULL)
return -1;
s2t->sig = sig;
s2t->task = task;
if(slist_tail_push(task->siglist, s2t) == NULL)
return -1;
return 0;
}
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;
}
bgpstream_csvfile_datasource_t *
bgpstream_csvfile_datasource_create(bgpstream_filter_mgr_t *filter_mgr,
char *csvfile_file)
{
bgpstream_debug("\t\tBSDS_CSVFILE: create csvfile_ds start");
bgpstream_csvfile_datasource_t *csvfile_ds = (bgpstream_csvfile_datasource_t*) malloc_zero(sizeof(bgpstream_csvfile_datasource_t));
if(csvfile_ds == NULL) {
bgpstream_log_err("\t\tBSDS_CSVFILE: create csvfile_ds can't allocate memory");
goto err;
}
if(csvfile_file == NULL)
{
bgpstream_log_err("\t\tBSDS_CSVFILE: create csvfile_ds no file provided");
goto err;
}
if((csvfile_ds->csvfile_file = strdup(csvfile_file)) == NULL)
{
bgpstream_log_err("\t\tBSDS_CSVFILE: can't allocate memory for filename");
goto err;
}
/* cvs file parser options */
unsigned char options = CSV_STRICT | CSV_REPALL_NL | CSV_STRICT_FINI |
CSV_APPEND_NULL | CSV_EMPTY_IS_NULL;
if(csv_init(&(csvfile_ds->parser), options) !=0)
{
bgpstream_log_err("\t\tBSDS_CSVFILE: can't initialize csv parser");
goto err;
}
csvfile_ds->current_field = CSVFILE_PATH;
csvfile_ds->filter_mgr = filter_mgr;
csvfile_ds->input_mgr = NULL;
csvfile_ds->num_results = 0;
csvfile_ds->max_ts_infile = 0;
csvfile_ds->last_processed_ts = 0;
csvfile_ds->max_accepted_ts = 0;
bgpstream_debug("\t\tBSDS_CSVFILE: create csvfile_ds end");
return csvfile_ds;
err:
bgpstream_csvfile_datasource_destroy(csvfile_ds);
return NULL;
}
static int warts_dealias_probe_state(const scamper_file_t *sf,
const scamper_dealias_probe_t *probe,
warts_dealias_probe_t *state,
warts_addrtable_t *table, uint32_t *len)
{
int i = 0;
size_t size;
memset(state->flags, 0, dealias_probe_vars_mfb);
state->params_len = 0;
flag_set(state->flags, WARTS_DEALIAS_PROBE_DEF, &i);
state->params_len += 4;
flag_set(state->flags, WARTS_DEALIAS_PROBE_TX, &i);
state->params_len += 8;
flag_set(state->flags, WARTS_DEALIAS_PROBE_REPLYC, &i);
state->params_len += 2;
flag_set(state->flags, WARTS_DEALIAS_PROBE_IPID, &i);
state->params_len += 2;
flag_set(state->flags, WARTS_DEALIAS_PROBE_SEQ, &i);
state->params_len += 4;
state->flags_len = fold_flags(state->flags, i);
state->replies = NULL;
if(probe->replyc > 0)
{
size = sizeof(warts_dealias_reply_t) * probe->replyc;
if((state->replies = malloc_zero(size)) == NULL)
return -1;
for(i=0; i<probe->replyc; i++)
{
if(warts_dealias_reply_state(probe->replies[i], &state->replies[i],
sf, table, len) != 0)
{
free(state->replies);
state->replies = NULL;
return -1;
}
}
}
/* increase length required for the probe record */
*len += state->flags_len + state->params_len;
if(state->params_len != 0) *len += 2;
return 0;
}
static rtsock_pair_t *rtsock_pair_alloc(scamper_route_t *route, int seq)
{
rtsock_pair_t *pair;
if((pair = malloc_zero(sizeof(rtsock_pair_t))) == NULL)
return NULL;
pair->route = route;
pair->seq = seq;
if((pair->node = dlist_head_push(pairs, pair)) == NULL)
{
free(pair);
return NULL;
}
route->internal = pair;
return pair;
}
struct Position* getPosition(char* _stack) {
int hash = hashOfStack(_stack);
struct Queue* q = &positions[hash];
struct Position* pos = findInQueuePos(q, _stack);
if(pos == NULL){
pos = (struct Position*)malloc_zero(sizeof(struct Position));
init_Position(pos, _stack);
addToQueue(q, pos);
}
//LOGD("pos = %s", pos->id);
return pos;
}
scamper_task_anc_t *scamper_task_anc_add(scamper_task_t *task, void *data,
void (*freedata)(void *))
{
scamper_task_anc_t *anc = NULL;
if(task->ancillary == NULL && (task->ancillary = dlist_alloc()) == NULL)
return NULL;
if((anc = malloc_zero(sizeof(scamper_task_anc_t))) == NULL)
return NULL;
anc->data = data;
anc->freedata = freedata;
if((anc->node = dlist_tail_push(task->ancillary, anc)) == NULL)
{
free(anc);
return NULL;
}
return anc;
}
static addr2mac_t *addr2mac_alloc(const int ifindex, scamper_addr_t *ip,
scamper_addr_t *mac, time_t expire)
{
addr2mac_t *addr2mac;
if((addr2mac = malloc_zero(sizeof(addr2mac_t))) == NULL)
{
printerror(errno, strerror, __func__, "could not malloc addr2mac");
return NULL;
}
addr2mac->ifindex = ifindex;
addr2mac->ip = ip != NULL ? scamper_addr_use(ip) : NULL;
addr2mac->mac = mac != NULL ? scamper_addr_use(mac) : NULL;
addr2mac->expire = expire;
return addr2mac;
}
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;
}
static int warts_dealias_ally_state(const scamper_file_t *sf, const void *data,
warts_dealias_data_t *state,
warts_addrtable_t *table, uint32_t *len)
{
const scamper_dealias_ally_t *ally = data;
int 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_ally_vars_mfb);
state->params_len = 0;
flag_set(state->flags, WARTS_DEALIAS_ALLY_WAIT_PROBE, &max_id);
state->params_len += 2;
flag_set(state->flags, WARTS_DEALIAS_ALLY_WAIT_TIMEOUT, &max_id);
state->params_len += 1;
flag_set(state->flags, WARTS_DEALIAS_ALLY_ATTEMPTS, &max_id);
state->params_len += 1;
flag_set(state->flags, WARTS_DEALIAS_ALLY_FUDGE, &max_id);
state->params_len += 2;
if(ally->flags != 0)
{
flag_set(state->flags, WARTS_DEALIAS_ALLY_FLAGS, &max_id);
state->params_len += 1;
}
state->flags_len = fold_flags(state->flags, max_id);
if(warts_dealias_probedef_params(sf, &ally->probedefs[0],
&state->probedefs[0], table, len) != 0 ||
warts_dealias_probedef_params(sf, &ally->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;
}
