void manager_free(Manager *m) {
Network *network;
NetDev *netdev;
Link *link;
if (!m)
return;
udev_monitor_unref(m->udev_monitor);
udev_unref(m->udev);
sd_bus_unref(m->bus);
sd_event_source_unref(m->udev_event_source);
sd_event_source_unref(m->sigterm_event_source);
sd_event_source_unref(m->sigint_event_source);
sd_event_unref(m->event);
while ((network = m->networks))
network_free(network);
while ((link = hashmap_first(m->links)))
link_free(link);
hashmap_free(m->links);
while ((netdev = hashmap_first(m->netdevs)))
netdev_free(netdev);
hashmap_free(m->netdevs);
sd_rtnl_unref(m->rtnl);
free(m);
}
void manager_free(Manager *m) {
Network *network;
Bridge *bridge;
Link *link;
udev_monitor_unref(m->udev_monitor);
udev_unref(m->udev);
sd_bus_unref(m->bus);
sd_event_source_unref(m->udev_event_source);
sd_event_unref(m->event);
while ((network = m->networks))
network_free(network);
while ((link = hashmap_first(m->links)))
link_free(link);
hashmap_free(m->links);
while ((bridge = hashmap_first(m->bridges)))
bridge_free(bridge);
hashmap_free(m->bridges);
sd_rtnl_unref(m->rtnl);
free(m);
}
struct network *
bitonic_alloc_and_init(unsigned int k)
{
struct network *n, *n0, *n1, *n2;
unsigned int i;
if (k == 2) {
// a bitonic[2] network is the same as a
// merger[2]
return merger_alloc_and_init(2);
}
n = network_alloc_and_init(k);
n0 = n1 = n2 = 0;
if (!n)
goto free_n;
n0 = merger_alloc_and_init(k);
if (!n0)
goto free_n;
n1 = bitonic_alloc_and_init(k / 2);
if (!n1)
goto free_n;
n2 = bitonic_alloc_and_init(k / 2);
if (!n2)
goto free_n;
for (i = 0; i < k / 2; i++) {
n->inputs[i] = n1->inputs[i];
n->outputs[i] = n0->outputs[i];
n->hilo[i] = n0->hilo[i];
n1->outputs[i]->links[n1->hilo[i]].b = n0->inputs[i];
n1->outputs[i]->l = 0;
}
for (i = 0; i < k / 2; i++) {
n->inputs[i + (k / 2)] = n2->inputs[i];
n->outputs[i + (k / 2)] = n0->outputs[i + (k / 2)];
n->hilo[i + (k / 2)] = n0->hilo[i + (k / 2)];
n2->outputs[i]->links[n2->hilo[i]].b = n0->inputs[i + (k / 2)];
n2->outputs[i]->l = 0;
}
n->bhead = n0->bhead;
n->btail = n0->btail;
n1->btail->next = n->bhead;
n->bhead = n1->bhead;
n2->btail->next = n->bhead;
n->bhead = n2->bhead;
network_clear(n0); network_free(n0);
network_clear(n1); network_free(n1);
network_clear(n2); network_free(n2);
return n;
free_n:
network_free(n);
network_free(n0);
network_free(n1);
network_free(n2);
return 0;
}
/**Function********************************************************************
Synopsis [Levelmap command.]
Description []
SideEffects []
SeeAlso [optional]
CommandName [optional]
CommandSynopsis [optional]
CommandArguments [optional]
CommandDescription [optional]
******************************************************************************/
int
levm_Com(
network_t **network,
array_t *llib,
int argc,
char **argv)
{
int k = 4, c;
network_t *new_network;
short nl = 0, vpr = 0;
char *ret;
char name[200];
util_getopt_reset();
while ((c = util_getopt(argc, argv, "vnk:")) != EOF) {
switch (c) {
case 'k': {
if((k = atoi(util_optarg)) < 2) {
Usage();
return 1;
}
} break;
case 'n': {
nl = 1;
} break;
case 'v': {
vpr = 1;
} break;
default:
Usage();
return 1;
}
}
if((llib == NIL(array_t)) && (nl == 1)) {
fprintf(siserr,"No logic library loaded.\n");
return 1;
}
new_network = levmRun(*network, k);
if(new_network != NIL(network_t)) {
network_free(*network);
*network = new_network;
}
if(nl == 1) {
Bind(*network, llib, k);
ret = netl_ClblCreate(*network);
BindFree(*network);
if(ret != NIL(char)) {
fprintf(siserr,"%s\n",ret);
FREE(ret);
}
}
void
mtscan_model_buffer_clear(mtscan_model_t *model)
{
GSList *current = model->buffer;
while(current)
{
network_t *net = (network_t*)(current->data);
network_free(net);
g_free(net);
current = current->next;
}
g_slist_free(model->buffer);
model->buffer = NULL;
}
void
mtscan_model_buffer_add(mtscan_model_t *model,
network_t *net)
{
if(conf_get_preferences_blacklist_enabled() &&
conf_get_preferences_blacklist(net->address))
{
network_free(net);
g_free(net);
return;
}
network_to_utf8(net, conf_get_preferences_fallback_encoding());
model->buffer = g_slist_prepend(model->buffer, (gpointer)net);
}
int
main (int argc, const char* argv[])
{
err_t err;
printf ("Loading images and labels...\n");
data_t data;
err = read_all_data (&data, images_file, labels_file);
EXIT_MAIN_ON_ERR(err);
printf ("Setting up network...\n");
network_t network;
uint32_t layers = sizeof(nodes) / sizeof(nodes[0]);
printf ("Node structure: ");
for (uint32_t i = 0; i < layers - 1; ++i) {
printf ("%i x ", nodes[i]);
}
printf ("%i.\n", nodes[layers - 1]);
network.nodes.size = layers;
network.nodes.data = nodes;
network.epochs = EPOCHS;
network.mini_batch_size = MINI_BATCH_SIZE;
network.eta = ETA;
err = network_allocate (&network);
EXIT_MAIN_ON_ERR(err);
printf ("Initialising network...\n");
network_random_init (&network, RANDOM_VARIANCE);
// Split off a chunk of data for testing
data_t test_data;
partition_data(&data, &test_data, VALIDATION_DATA_CHUNK_SIZE);
printf ("Stochastic gradient descent...\n");
network_sgd (&network, &data, &test_data);
network_free (&network);
images_free (&data.images);
labels_free (&data.labels);
return EXIT_SUCCESS;
}
void active_server_free(ACTIVE_SERVER *self) {
assert(self);
network_free(NET);
if (ERR && self->exception_internal) {
exception_delCallback(ERR);
exception_free(ERR);
}
if (self->root) {
free(self->root);
self->root = NULL;
}
free(self);
self = NULL;
}
gint
mtscan_model_buffer_and_inactive_update(mtscan_model_t *model)
{
GSList *current;
gint state = MODEL_UPDATE_NONE;
gint status;
if(model->buffer)
{
model->buffer = g_slist_reverse(model->buffer);
current = model->buffer;
while(current)
{
network_t* net = (network_t*)(current->data);
status = model_update_network(model, net);
if(status == MODEL_NETWORK_NEW_ALARM)
state |= MODEL_UPDATE_NEW_ALARM;
else if(status == MODEL_NETWORK_NEW_HIGHLIGHT)
state |= MODEL_UPDATE_NEW_HIGHLIGHT;
else if(status == MODEL_NETWORK_NEW)
state |= MODEL_UPDATE_NEW;
else if(status == MODEL_NETWORK_UPDATE)
state |= MODEL_UPDATE;
network_free(net);
g_free(net);
current = current->next;
}
g_slist_free(model->buffer);
model->buffer = NULL;
}
model->clear_active_changed = FALSE;
g_hash_table_foreach_remove(model->active, model_clear_active_foreach, model);
if(model->clear_active_changed && state == MODEL_UPDATE_NONE)
state = MODEL_UPDATE_ONLY_INACTIVE;
return state;
}
struct network *
merger_alloc_and_init(unsigned int k)
{
struct network *n, *n0, *n1;
struct balancer *b;
unsigned int i;
n = network_alloc_and_init(k);
n0 = n1 = 0;
if (!n)
return 0;
if (k == 2) {
// merger[2] is defined as single balancer
//b = (struct balancer *) memalign(CACHELINE_SIZE, sizeof(*b));
b = (struct balancer *) malloc(sizeof(*b));
if (!b)
goto free_n;
balancer_init_leaf(b, 0, 0);
n->bhead = n->btail = b;
n->inputs[0] = n->inputs[1] = b;
n->outputs[0] = n->outputs[1] = b;
n->hilo[0] = 0;
n->hilo[1] = 1;
return n;
}
// merger[2k] is defined recursively:
//
// Let the input x_0, x_1, ..., x_{2k-1} be the input to merger[2k].
// Divide this input into two k-length sequences X and X', such that
// X = x_0, x_1, ..., x_{k-1}
// X' = x_k, x_{k+1}, ..., x_{2k-1}
//
// Now, we take X_0, X_2, ..., X_{k-2} and merge with X'_1, X'_3, ...,
// X'_{k-1} with a merger[k]. We also take X_1, X_3, ..., X_{k-1} and merge
// with X'_0, X'_2, ..., X'_{k-2} with another merger[k]. We then join
// the outputs.
n0 = merger_alloc_and_init(k / 2);
if (!n0)
goto free_n;
n1 = merger_alloc_and_init(k / 2);
if (!n1)
goto free_n;
for (i = 0; i < k / 2; i += 2)
n->inputs[i] = n0->inputs[i / 2];
for (i = 1; i < k / 2; i += 2)
n->inputs[(k / 2) + i] = n0->inputs[(k / 4) + (i / 2)];
for (i = 1; i < k / 2; i += 2)
n->inputs[i] = n1->inputs[i / 2];
for (i = 0; i < k / 2; i += 2)
n->inputs[(k / 2) + i] = n1->inputs[(k / 4) + (i / 2)];
for (i = 0; i < k / 2; i++) {
//b = (struct balancer *) memalign(CACHELINE_SIZE, sizeof(*b));
b = (struct balancer *) malloc(sizeof(*b));
if (!b)
goto free_n;
balancer_init_leaf(b, 0, 0);
b->next = n->bhead;
if (!n->btail)
n->bhead = n->btail = b;
else
n->bhead = b;
n0->outputs[i]->links[n0->hilo[i]].b = b;
n0->outputs[i]->l = 0;
n1->outputs[i]->links[n1->hilo[i]].b = b;
n1->outputs[i]->l = 0;
n->outputs[2 * i] = n->outputs[2 * i + 1] = b;
n->hilo[2 * i] = 0;
n->hilo[2 * i + 1] = 1;
}
n0->btail->next = n->bhead;
n->bhead = n0->bhead;
n1->btail->next = n->bhead;
n->bhead = n1->bhead;
network_clear(n0); network_free(n0);
network_clear(n1); network_free(n1);
return n;
free_n:
network_free(n);
network_free(n0);
network_free(n1);
return 0;
}
static gboolean
log_save_foreach(GtkTreeModel *store,
GtkTreePath *path,
GtkTreeIter *iter,
gpointer data)
{
yajl_gen gen = (yajl_gen)data;
network_t net;
signals_node_t *sample;
const gchar *buffer;
gtk_tree_model_get(GTK_TREE_MODEL(ui.model->store), iter,
COL_ADDRESS, &net.address,
COL_FREQUENCY, &net.frequency,
COL_CHANNEL, &net.channel,
COL_MODE, &net.mode,
COL_SSID, &net.ssid,
COL_RADIONAME, &net.radioname,
COL_MAXRSSI, &net.rssi,
COL_PRIVACY, &net.flags.privacy,
COL_ROUTEROS, &net.flags.routeros,
COL_NSTREME, &net.flags.nstreme,
COL_TDMA, &net.flags.tdma,
COL_WDS, &net.flags.wds,
COL_BRIDGE, &net.flags.bridge,
COL_ROUTEROS_VER, &net.routeros_ver,
COL_FIRSTSEEN, &net.firstseen,
COL_LASTSEEN, &net.lastseen,
COL_LATITUDE, &net.latitude,
COL_LONGITUDE, &net.longitude,
COL_SIGNALS, &net.signals,
-1);
yajl_gen_string(gen, (guchar*)net.address, strlen(net.address));
yajl_gen_map_open(gen);
buffer = model_format_frequency(net.frequency);
yajl_gen_string(gen, (guchar*)keys[KEY_FREQUENCY], strlen(keys[KEY_FREQUENCY]));
yajl_gen_number(gen, buffer, strlen(buffer));
yajl_gen_string(gen, (guchar*)keys[KEY_CHANNEL], strlen(keys[KEY_CHANNEL]));
yajl_gen_string(gen, (guchar*)net.channel, strlen(net.channel));
yajl_gen_string(gen, (guchar*)keys[KEY_MODE], strlen(keys[KEY_MODE]));
yajl_gen_string(gen, (guchar*)net.mode, strlen(net.mode));
yajl_gen_string(gen, (guchar*)keys[KEY_SSID], strlen(keys[KEY_SSID]));
yajl_gen_string(gen, (guchar*)net.ssid, strlen(net.ssid));
yajl_gen_string(gen, (guchar*)keys[KEY_RADIONAME], strlen(keys[KEY_RADIONAME]));
yajl_gen_string(gen, (guchar*)net.radioname, strlen(net.radioname));
yajl_gen_string(gen, (guchar*)keys[KEY_RSSI], strlen(keys[KEY_RSSI]));
yajl_gen_integer(gen, net.rssi);
yajl_gen_string(gen, (guchar*)keys[KEY_PRIVACY], strlen(keys[KEY_PRIVACY]));
yajl_gen_integer(gen, net.flags.privacy);
yajl_gen_string(gen, (guchar*)keys[KEY_ROUTEROS], strlen(keys[KEY_ROUTEROS]));
if(net.routeros_ver && strlen(net.routeros_ver))
yajl_gen_string(gen, (guchar*)net.routeros_ver, strlen(net.routeros_ver));
else
yajl_gen_integer(gen, net.flags.routeros);
yajl_gen_string(gen, (guchar*)keys[KEY_NSTREME], strlen(keys[KEY_NSTREME]));
yajl_gen_integer(gen, net.flags.nstreme);
yajl_gen_string(gen, (guchar*)keys[KEY_TDMA], strlen(keys[KEY_TDMA]));
yajl_gen_integer(gen, net.flags.tdma);
yajl_gen_string(gen, (guchar*)keys[KEY_WDS], strlen(keys[KEY_WDS]));
yajl_gen_integer(gen, net.flags.wds);
yajl_gen_string(gen, (guchar*)keys[KEY_BRIDGE], strlen(keys[KEY_BRIDGE]));
yajl_gen_integer(gen, net.flags.bridge);
yajl_gen_string(gen, (guchar*)keys[KEY_FIRSTSEEN], strlen(keys[KEY_FIRSTSEEN]));
yajl_gen_integer(gen, net.firstseen);
yajl_gen_string(gen, (guchar*)keys[KEY_LASTSEEN], strlen(keys[KEY_LASTSEEN]));
yajl_gen_integer(gen, net.lastseen);
if(!isnan(net.latitude) && !isnan(net.longitude))
{
buffer = model_format_gps(net.latitude);
yajl_gen_string(gen, (guchar*)keys[KEY_LATITUDE], strlen(keys[KEY_LATITUDE]));
yajl_gen_number(gen, buffer, strlen(buffer));
buffer = model_format_gps(net.longitude);
yajl_gen_string(gen, (guchar*)keys[KEY_LONGITUDE], strlen(keys[KEY_LONGITUDE]));
yajl_gen_number(gen, buffer, strlen(buffer));
}
if(net.signals->head)
{
yajl_gen_string(gen, (guchar*)keys[KEY_SIGNALS], strlen(keys[KEY_SIGNALS]));
yajl_gen_array_open(gen);
sample = net.signals->head;
while(sample)
{
yajl_gen_map_open(gen);
yajl_gen_string(gen, (guchar*)keys_signals[KEY_SIGNALS_TIMESTAMP], strlen(keys_signals[KEY_SIGNALS_TIMESTAMP]));
yajl_gen_integer(gen, sample->timestamp);
yajl_gen_string(gen, (guchar*)keys_signals[KEY_SIGNALS_RSSI], strlen(keys_signals[KEY_SIGNALS_RSSI]));
yajl_gen_integer(gen, sample->rssi);
if(!isnan(sample->latitude) && !isnan(sample->longitude))
{
buffer = model_format_gps(sample->latitude);
yajl_gen_string(gen, (guchar*)keys_signals[KEY_SIGNALS_LATITUDE], strlen(keys_signals[KEY_SIGNALS_LATITUDE]));
yajl_gen_number(gen, buffer, strlen(buffer));
buffer = model_format_gps(sample->longitude);
yajl_gen_string(gen, (guchar*)keys_signals[KEY_SIGNALS_LONGITUDE], strlen(keys_signals[KEY_SIGNALS_LONGITUDE]));
yajl_gen_number(gen, buffer, strlen(buffer));
}
yajl_gen_map_close(gen);
sample = sample->next;
}
yajl_gen_array_close(gen);
}
yajl_gen_map_close(gen);
/* Signals are stored in GtkListStore just as pointer,
so set it to NULL before freeing the struct */
net.signals = NULL;
network_free(&net);
return FALSE;
}
void
log_open(GSList *filenames,
gboolean merge)
{
gchar *filename;
gzFile gzfp;
gint n, err;
guchar buffer[READ_BUFFER_LEN];
const gchar *err_string;
yajl_handle json;
yajl_status status;
read_ctx_t context;
if(ui.changed && !ui_dialog_ask_unsaved())
return;
context.merge = merge;
context.changed = FALSE;
if(!merge)
ui_clear();
ui_view_lock(ui.treeview);
while(filenames != NULL)
{
filename = (gchar*)filenames->data;
gzfp = gzopen(filename, "r");
if(!gzfp)
{
ui_dialog(ui.window,
GTK_MESSAGE_ERROR,
"Error",
"Failed to open a file:\n%s", filename);
}
else
{
context.key = KEY_UNKNOWN;
context.level = LEVEL_ROOT;
context.level_signals = FALSE;
context.signal = NULL;
network_init(&context.network);
json = yajl_alloc(&json_callbacks, NULL, &context);
do
{
n = gzread(gzfp, buffer, READ_BUFFER_LEN-1);
status = yajl_parse(json, buffer, n);
if(n < READ_BUFFER_LEN-1)
{
if(gzeof(gzfp))
break;
err_string = gzerror(gzfp, &err);
if(err)
{
ui_dialog(ui.window,
GTK_MESSAGE_ERROR,
"Error",
"Failed to read a file:\n%s\n\n%s",
filename, err_string);
break;
}
}
} while (status == yajl_status_ok);
gzclose(gzfp);
if(status == yajl_status_ok)
status = yajl_complete_parse(json);
yajl_free(json);
if(status != yajl_status_ok)
{
network_free(&context.network);
g_free(context.signal);
ui_dialog(ui.window,
GTK_MESSAGE_ERROR,
"Error",
"The selected file is corrupted or is not a valid MTscan log:\n%s",
filename);
}
else if(!merge)
{
/* Take the allocated filename for the UI */
ui_set_title(filename);
filenames->data = NULL;
}
}
filenames = filenames->next;
}
ui_view_unlock(ui.treeview);
if(context.changed)
{
ui_status_update_networks();
if(merge)
{
/* Set filename to NULL after merge */
ui_set_title(NULL);
ui_changed();
}
}
}
