static int set_servers (struct global *g)
{
int ret = 0;
// count servers
size_t num_entries = count_entries(g);
// allocate sort array
struct dns_sort_entry *sort_entries = BAllocArray(num_entries, sizeof(sort_entries[0]));
if (!sort_entries) {
goto fail0;
}
// fill sort array
num_entries = 0;
for (LinkedList1Node *n = LinkedList1_GetFirst(&g->instances); n; n = LinkedList1Node_Next(n)) {
struct instance *o = UPPER_OBJECT(n, struct instance, instances_node);
for (LinkedList1Node *en = LinkedList1_GetFirst(&o->entries); en; en = LinkedList1Node_Next(en)) {
struct dns_entry *e = UPPER_OBJECT(en, struct dns_entry, list_node);
sort_entries[num_entries].line = e->line;
sort_entries[num_entries].priority= e->priority;
num_entries++;
}
}
// sort by priority
// use a custom insertion sort instead of qsort() because we want a stable sort
struct dns_sort_entry temp;
BInsertionSort(sort_entries, num_entries, sizeof(sort_entries[0]), dns_sort_comparator, &temp);
ExpString estr;
if (!ExpString_Init(&estr)) {
goto fail1;
}
for (size_t i = 0; i < num_entries; i++) {
if (!ExpString_Append(&estr, sort_entries[i].line)) {
goto fail2;
}
}
// set servers
if (!NCDIfConfig_set_resolv_conf(ExpString_Get(&estr), ExpString_Length(&estr))) {
goto fail2;
}
ret = 1;
fail2:
ExpString_Free(&estr);
fail1:
BFree(sort_entries);
fail0:
return ret;
}
static size_t count_entries (struct global *g)
{
size_t c = 0;
for (LinkedList1Node *n = LinkedList1_GetFirst(&g->instances); n; n = LinkedList1Node_Next(n)) {
struct instance *o = UPPER_OBJECT(n, struct instance, instances_node);
for (LinkedList1Node *en = LinkedList1_GetFirst(&o->entries); en; en = LinkedList1Node_Next(en)) {
c++;
}
}
return c;
}
static void remove_entries (struct instance *o)
{
LinkedList1Node *n;
while (n = LinkedList1_GetFirst(&o->entries)) {
struct dns_entry *e = UPPER_OBJECT(n, struct dns_entry, list_node);
remove_dns_entry(o, e);
}
}
void NCDValue_Free (NCDValue *o)
{
switch (o->type) {
case NCDVALUE_STRING: {
free(o->string);
} break;
case NCDVALUE_LIST: {
LinkedList1Node *n;
while (n = LinkedList1_GetFirst(&o->list)) {
struct NCDValue__list_element *e = UPPER_OBJECT(n, struct NCDValue__list_element, list_node);
NCDValue_Free(&e->v);
LinkedList1_Remove(&o->list, &e->list_node);
free(e);
}
} break;
case NCDVALUE_MAP: {
LinkedList1Node *n;
while (n = LinkedList1_GetFirst(&o->map_list)) {
struct NCDValue__map_element *e = UPPER_OBJECT(n, struct NCDValue__map_element, list_node);
LinkedList1_Remove(&o->map_list, &e->list_node);
NCDValue_Free(&e->key);
NCDValue_Free(&e->val);
free(e);
}
} break;
case NCDVALUE_VAR: {
free(o->var_name);
} break;
case NCDVALUE_INVOC: {
NCDValue_Free(o->invoc_arg);
NCDValue_Free(o->invoc_func);
free(o->invoc_arg);
free(o->invoc_func);
} break;
default:
ASSERT(0);
}
}
static DPReceivePeer * find_peer (DPReceiveDevice *o, peerid_t id)
{
for (LinkedList1Node *node = LinkedList1_GetFirst(&o->peers_list); node; node = LinkedList1Node_Next(node)) {
DPReceivePeer *p = UPPER_OBJECT(node, DPReceivePeer, list_node);
if (p->peer_id == id) {
return p;
}
}
return NULL;
}
static void free_oldest_frame (FragmentProtoAssembler *o)
{
ASSERT(!LinkedList1_IsEmpty(&o->frames_used))
// obtain oldest frame (first on the list)
LinkedList1Node *list_node = LinkedList1_GetFirst(&o->frames_used);
ASSERT(list_node)
struct FragmentProtoAssembler_frame *frame = UPPER_OBJECT(list_node, struct FragmentProtoAssembler_frame, list_node);
// free frame
free_frame(o, frame);
}
static void schedule (PacketPassFifoQueue *o)
{
ASSERT(!o->freeing)
ASSERT(!o->sending_flow)
ASSERT(!LinkedList1_IsEmpty(&o->waiting_flows_list))
ASSERT(!BPending_IsSet(&o->schedule_job))
// get first waiting flow
PacketPassFifoQueueFlow *flow = UPPER_OBJECT(LinkedList1_GetFirst(&o->waiting_flows_list), PacketPassFifoQueueFlow, waiting_flows_list_node);
ASSERT(flow->queue == o)
ASSERT(flow->is_waiting)
// remove it from queue
LinkedList1_Remove(&o->waiting_flows_list, &flow->waiting_flows_list_node);
flow->is_waiting = 0;
// send
PacketPassInterface_Sender_Send(o->output, flow->waiting_data, flow->waiting_len);
o->sending_flow = flow;
}
#include <misc/offset.h>
#include <misc/debug.h>
#include <misc/balloc.h>
#include <ncd/modules/event_template.h>
#define TemplateLog(o, ...) NCDModuleInst_Backend_Log((o)->i, (o)->blog_channel, __VA_ARGS__)
static void enable_event (event_template *o)
{
ASSERT(!LinkedList1_IsEmpty(&o->events_list))
ASSERT(!o->enabled)
// get event
struct event_template_event *e = UPPER_OBJECT(LinkedList1_GetFirst(&o->events_list), struct event_template_event, events_list_node);
// remove from events list
LinkedList1_Remove(&o->events_list, &e->events_list_node);
// grab enabled map
o->enabled_map = e->map;
// append to free list
LinkedList1_Append(&o->free_list, &e->events_list_node);
// set enabled
o->enabled = 1;
// signal up
NCDModuleInst_Backend_Up(o->i);
