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