/*
* Insert an additional listener in to the sorted list of listeners
*/
void
add_listener(struct Listener_head *listeners, struct Listener *listener) {
assert(listeners != NULL);
assert(listener != NULL);
assert(listener->address != NULL);
listener_ref_get(listener);
if (SLIST_FIRST(listeners) == NULL ||
address_compare(listener->address, SLIST_FIRST(listeners)->address) < 0) {
SLIST_INSERT_HEAD(listeners, listener, entries);
return;
}
struct Listener *iter;
SLIST_FOREACH(iter, listeners, entries) {
if (SLIST_NEXT(iter, entries) == NULL ||
address_compare(listener->address, SLIST_NEXT(iter, entries)->address) < 0) {
SLIST_INSERT_AFTER(iter, listener, entries);
return;
}
}
}
/*
* Unregister all hooks and cookies for that module. Note: doesn't disconnect
* any hooks!
*/
void
ng_unregister_module(const struct lmodule *mod)
{
struct msgreg *m, *m1;
struct datareg *d, *d1;
m = SLIST_FIRST(&msgreg_list);
while (m != NULL) {
m1 = SLIST_NEXT(m, link);
if (m->mod == mod) {
SLIST_REMOVE(&msgreg_list, m, msgreg, link);
free(m);
}
m = m1;
}
d = SLIST_FIRST(&datareg_list);
while (d != NULL) {
d1 = SLIST_NEXT(d, link);
if (d->mod == mod) {
SLIST_REMOVE(&datareg_list, d, datareg, link);
free(d);
}
d = d1;
}
}
static struct pgt *pop_least_used_from_cache_list(void)
{
struct pgt *pgt;
struct pgt *p_prev = NULL;
size_t least_used;
pgt = SLIST_FIRST(&pgt_cache_list);
if (!pgt)
return NULL;
if (!pgt->num_used_entries)
goto out;
least_used = pgt->num_used_entries;
while (true) {
if (!SLIST_NEXT(pgt, link))
break;
if (SLIST_NEXT(pgt, link)->num_used_entries <= least_used) {
p_prev = pgt;
least_used = SLIST_NEXT(pgt, link)->num_used_entries;
}
pgt = SLIST_NEXT(pgt, link);
}
out:
if (p_prev) {
pgt = SLIST_NEXT(p_prev, link);
SLIST_REMOVE_AFTER(p_prev, link);
} else {
pgt = SLIST_FIRST(&pgt_cache_list);
SLIST_REMOVE_HEAD(&pgt_cache_list, link);
}
return pgt;
}
void
listeners_reload(struct Listener_head *existing_listeners,
struct Listener_head *new_listeners,
const struct Table_head *tables, struct ev_loop *loop) {
struct Listener *iter_existing = SLIST_FIRST(existing_listeners);
struct Listener *iter_new = SLIST_FIRST(new_listeners);
while (iter_existing != NULL || iter_new != NULL) {
int compare_result;
char address[ADDRESS_BUFFER_SIZE];
if (iter_existing == NULL)
compare_result = 1;
else if (iter_new == NULL)
compare_result = -1;
else
compare_result = address_compare(iter_existing->address, iter_new->address);
if (compare_result > 0) {
struct Listener *new_listener = iter_new;
iter_new = SLIST_NEXT(iter_new, entries);
notice("Listener %s added.",
display_address(new_listener->address,
address, sizeof(address)));
SLIST_REMOVE(new_listeners, new_listener, Listener, entries);
add_listener(existing_listeners, new_listener);
init_listener(new_listener, tables, loop);
/* -1 for removing from new_listeners */
listener_ref_put(new_listener);
} else if (compare_result == 0) {
notice ("Listener %s updated.",
display_address(iter_existing->address,
address, sizeof(address)));
listener_update(iter_existing, iter_new, tables);
iter_existing = SLIST_NEXT(iter_existing, entries);
iter_new = SLIST_NEXT(iter_new, entries);
} else {
struct Listener *removed_listener = iter_existing;
iter_existing = SLIST_NEXT(iter_existing, entries);
notice("Listener %s removed.",
display_address(removed_listener->address,
address, sizeof(address)));
SLIST_REMOVE(existing_listeners, removed_listener, Listener, entries);
close_listener(loop, removed_listener);
/* -1 for removing from existing_listeners */
listener_ref_put(removed_listener);
}
}
}
void
uicb_screen_prev(Uicb cmd)
{
struct screen *s = SLIST_FIRST(&W->h.screen);
(void)cmd;
while(SLIST_NEXT(s, next) && SLIST_NEXT(s, next) != s)
s = SLIST_NEXT(s, next);
screen_select(s);
}
void
uicb_screen_move_client_prev(Uicb cmd)
{
struct screen *s = SLIST_FIRST(&W->h.screen);
(void)cmd;
while(SLIST_NEXT(s, next) && SLIST_NEXT(s, next) != s)
s = SLIST_NEXT(s, next);
if(W->client)
tag_client(s->seltag, W->client);
}
int
main(int argc, char **argv)
{
struct head root;
SLIST_INIT(&root);
addnodes(&root, 2);
addnodes(&SLIST_FIRST(&root)->children, 4);
addnodes(&SLIST_NEXT(SLIST_FIRST(&root), links)->children, 2);
// dumptree output:
//
// 1
// 3
// 2
// 1
// 0
// 0
// 1
// 0
dumptree(&root, 0);
/* free_tree(&root); */
}
/*
* Called by UART driver to send out next character.
*
* Interrupts disabled when nmgr_uart_tx_char/nmgr_uart_rx_char are called.
*/
static int
nmgr_uart_tx_char(void *arg)
{
struct nmgr_uart_state *nus = (struct nmgr_uart_state *)arg;
struct os_mbuf *m;
uint8_t ch;
if (!nus->nus_tx) {
/*
* Out of data. Return -1 makes UART stop asking for more.
*/
return -1;
}
while (nus->nus_tx->om_len == nus->nus_tx_off) {
/*
* If no active mbuf, move to next one.
*/
m = SLIST_NEXT(nus->nus_tx, om_next);
os_mbuf_free(nus->nus_tx);
nus->nus_tx = m;
nus->nus_tx_off = 0;
if (!nus->nus_tx) {
return -1;
}
}
os_mbuf_copydata(nus->nus_tx, nus->nus_tx_off++, 1, &ch);
return ch;
}
void
hashtable_delete(const char *key, uint32_t klen, struct hash_table *ht)
{
struct item_slh *bucket;
struct item *it, *prev;
ASSERT(hashtable_get(key, klen, ht) != NULL);
bucket = _get_bucket(key, klen, ht);
for (prev = NULL, it = SLIST_FIRST(bucket); it != NULL;
prev = it, it = SLIST_NEXT(it, i_sle)) {
/* iterate through bucket to find item to be removed */
if ((klen == it->klen) && cc_memcmp(key, item_key(it), klen) == 0) {
/* found item */
break;
}
}
if (prev == NULL) {
SLIST_REMOVE_HEAD(bucket, i_sle);
} else {
SLIST_REMOVE_AFTER(prev, i_sle);
}
--(ht->nhash_item);
}
static struct pgt *pop_from_cache_list(vaddr_t vabase, void *ctx)
{
struct pgt *pgt;
struct pgt *p;
pgt = SLIST_FIRST(&pgt_cache_list);
if (!pgt)
return NULL;
if (match_pgt(pgt, vabase, ctx)) {
SLIST_REMOVE_HEAD(&pgt_cache_list, link);
return pgt;
}
while (true) {
p = SLIST_NEXT(pgt, link);
if (!p)
break;
if (match_pgt(p, vabase, ctx)) {
SLIST_REMOVE_AFTER(pgt, link);
break;
}
pgt = p;
}
return p;
}
static void
readdumptimes(FILE *df)
{
int i;
struct dumptime *dtwalk;
for (;;) {
dtwalk = (struct dumptime *)calloc(1, sizeof (struct dumptime));
if (getrecord(df, &(dtwalk->dt_value)) < 0) {
free(dtwalk);
break;
}
nddates++;
SLIST_INSERT_HEAD(&dthead, dtwalk, dt_list);
}
/*
* arrayify the list, leaving enough room for the additional
* record that we may have to add to the ddate structure
*/
ddatev = (struct dumpdates **)
calloc((unsigned) (nddates + 1), sizeof (struct dumpdates *));
dtwalk = SLIST_FIRST(&dthead);
for (i = nddates - 1; i >= 0; i--, dtwalk = SLIST_NEXT(dtwalk, dt_list))
ddatev[i] = &dtwalk->dt_value;
}
ENTRY *
hsearch(ENTRY item, ACTION action)
{
struct internal_head *head;
struct internal_entry *ie;
uint32_t hashval;
size_t len;
len = strlen(item.key);
hashval = (*__default_hash)(item.key, len);
head = &htable[hashval & (htablesize - 1)];
ie = SLIST_FIRST(head);
while (ie != NULL) {
if (strcmp(ie->ent.key, item.key) == 0)
break;
ie = SLIST_NEXT(ie, link);
}
if (ie != NULL)
return &ie->ent;
else if (action == FIND)
return NULL;
ie = malloc(sizeof *ie);
if (ie == NULL)
return NULL;
ie->ent.key = item.key;
ie->ent.data = item.data;
SLIST_INSERT_HEAD(head, ie, link);
return &ie->ent;
}
/**
* \fn order_remove
*
* \brief order the remove list according to dependency level
*/
Plisthead *
order_remove(Plisthead *deptreehead)
{
int i, maxlevel = 0;
Pkglist *pdp, *next;
Plisthead *ordtreehead;
/* package removal cannot trust recorded dependencies, reorder */
remove_dep_deepness(deptreehead);
SLIST_FOREACH(pdp, deptreehead, next)
if (pdp->level > maxlevel)
maxlevel = pdp->level;
ordtreehead = init_head();
for (i = maxlevel; i >= 0; i--) {
pdp = SLIST_FIRST(deptreehead);
while (pdp != NULL) {
next = SLIST_NEXT(pdp, next);
if (pdp->level == i) {
SLIST_REMOVE(deptreehead, pdp, Pkglist, next);
SLIST_INSERT_HEAD(ordtreehead, pdp, next);
}
pdp = next;
}
}
return ordtreehead;
}
int
nffs_dir_read(struct nffs_dir *dir, struct nffs_dirent **out_dirent)
{
struct nffs_inode_entry *child;
int rc;
if (dir->nd_dirent.nde_inode_entry == NULL) {
child = SLIST_FIRST(&dir->nd_parent_inode_entry->nie_child_list);
} else {
child = SLIST_NEXT(dir->nd_dirent.nde_inode_entry, nie_sibling_next);
rc = nffs_inode_dec_refcnt(dir->nd_dirent.nde_inode_entry);
if (rc != 0) {
/* XXX: Need to clean up anything? */
return rc;
}
}
dir->nd_dirent.nde_inode_entry = child;
if (child == NULL) {
*out_dirent = NULL;
return FS_ENOENT;
}
child->nie_refcnt++;
*out_dirent = &dir->nd_dirent;
return 0;
}
void alarmsProcess(void)
{
//
// Note that this code works in the way that neither locking the list
// nor disabling interrupts is required
//
uint32_t now = (uint32_t) getJiffies();
// PRINTF("processAlarms: jiffies=%lu\n", now);
Alarm_t **a = &SLIST_FIRST(&alarmListHead);
while (*a) {
Alarm_t *ap = *a;
// the alarm must have valid callback
ASSERT(ap->callback != NULL);
// PRINTF("processAlarms: ap=%p, ap->jiffies=%lu\n", ap, ap->jiffies);
if (timeAfter32(ap->jiffies, now)) {
break;
}
// save next alarm for later reference
Alarm_t **next = &SLIST_NEXT(ap, chain);
// remove the alarm from the list
*a = *next;
// call the callback
ap->callback(ap->data);
// move to the next
a = next;
}
}
void alarmSchedule(Alarm_t *alarm, uint32_t milliseconds)
{
// we want to avoid inserting local variables in the global alarm list
// (but this warning, not an error, because the user function may never return)
WARN_ON(isStackAddress(alarm));
// PRINTF("alarmSchedule %p, ms=%lu\n", alarm, milliseconds);
alarm->jiffies = (uint32_t)getJiffies() + milliseconds;
// locking is required, because both kernel and user threads can be using this function
Handle_t h;
ATOMIC_START(h);
// unschedule the alarm, if it was already scheduled
SLIST_REMOVE_SAFE(&alarmListHead, alarm, Alarm_s, chain);
// insert it in appropriate position
Alarm_t **prev = &SLIST_FIRST(&alarmListHead);
Alarm_t *a = *prev;
while (a && timeAfter32(alarm->jiffies, a->jiffies)) {
prev = &SLIST_NEXT(a, chain);
a = *prev;
}
SLIST_INSERT(prev, alarm, chain);
#if USE_THREADS
// always reschedule alarm processing in case some alarm was added
// that might need to be processed before end of current kernel sleep time
processFlags.bits.alarmsProcess = true;
// and make sure the kernel thread is awake and ready to deal with it
threadWakeup(KERNEL_THREAD_INDEX, THREAD_READY);
#endif
ATOMIC_END(h);
}
/*
* Receive a character from UART.
*/
static int
nmgr_uart_rx_char(void *arg, uint8_t data)
{
struct nmgr_uart_state *nus = (struct nmgr_uart_state *)arg;
struct os_mbuf *m;
int rc;
if (!nus->nus_rx) {
m = os_msys_get_pkthdr(SHELL_NLIP_MAX_FRAME, 0);
if (!m) {
return 0;
}
nus->nus_rx = OS_MBUF_PKTHDR(m);
if (OS_MBUF_TRAILINGSPACE(m) < SHELL_NLIP_MAX_FRAME) {
/*
* mbuf is too small.
*/
os_mbuf_free_chain(m);
nus->nus_rx = NULL;
return 0;
}
}
m = OS_MBUF_PKTHDR_TO_MBUF(nus->nus_rx);
if (data == '\n') {
/*
* Full line of input. Process it outside interrupt context.
*/
assert(!nus->nus_rx_q);
nus->nus_rx_q = nus->nus_rx;
nus->nus_rx = NULL;
os_eventq_put(g_mgmt_evq, &nus->nus_cb_ev);
return 0;
} else {
rc = os_mbuf_append(m, &data, 1);
if (rc == 0) {
return 0;
}
}
/* failed */
nus->nus_rx->omp_len = 0;
m->om_len = 0;
os_mbuf_free_chain(SLIST_NEXT(m, om_next));
SLIST_NEXT(m, om_next) = NULL;
return 0;
}
static struct scan_entry *
find_old_scan(const char *location)
{
struct scan_entry *e;
char *dep, *dep2, *path, *fullpath;
int is_current;
time_t mtime;
e = SLIST_FIRST(&hash_table[hash_entry(location)]);
while (e) {
if (strcmp(e->location, location) == 0)
break;
e = SLIST_NEXT(e, hash_link);
}
if (e == NULL)
return NULL;
if (e->scan_depends == NULL)
return e;
is_current = 1;
dep2 = dep = xstrdup(e->scan_depends);
while ((path = strtok(dep, " ")) != NULL) {
dep = NULL;
if (*path == '\0')
continue;
if (*path == '/') {
mtime = stat_path(path);
if (mtime == -1 || mtime >= scan_mtime) {
is_current = 0;
break;
}
continue;
}
if (strncmp("../../", path, 6) == 0) {
const char *s1 = strrchr(location, '/');
const char *s2 = strchr(location, '/');
if (s1 == s2)
fullpath = xasprintf("%s/%s", pkgsrc_tree,
path + 6);
else
fullpath = xasprintf("%s/%s/%s", pkgsrc_tree,
location, path);
} else {
fullpath = xasprintf("%s/%s/%s", pkgsrc_tree,
location, path);
}
mtime = stat_path(fullpath);
if (mtime == -1 || mtime >= scan_mtime) {
is_current = 0;
break;
}
}
free(dep2);
return is_current ? e : NULL;
}
static void flush_ctx_range_from_list(struct pgt_cache *pgt_cache, void *ctx,
vaddr_t begin, vaddr_t last)
{
struct pgt *p;
struct pgt *next_p;
/*
* Do the special case where the first element in the list is
* removed first.
*/
p = SLIST_FIRST(pgt_cache);
while (pgt_entry_matches(p, ctx, begin, last)) {
flush_pgt_entry(p);
SLIST_REMOVE_HEAD(pgt_cache, link);
push_to_free_list(p);
p = SLIST_FIRST(pgt_cache);
}
/*
* p either points to the first element in the list or it's NULL,
* if NULL the list is empty and we're done.
*/
if (!p)
return;
/*
* Do the common case where the next element in the list is
* removed.
*/
while (true) {
next_p = SLIST_NEXT(p, link);
if (!next_p)
break;
if (pgt_entry_matches(next_p, ctx, begin, last)) {
flush_pgt_entry(next_p);
SLIST_REMOVE_AFTER(p, link);
push_to_free_list(next_p);
continue;
}
p = SLIST_NEXT(p, link);
}
}
/**
* Allocate a pdu (chain) for reception.
*
* @param len
*
* @return struct os_mbuf*
*/
struct os_mbuf *
ble_ll_rxpdu_alloc(uint16_t len)
{
uint16_t mb_bytes;
struct os_mbuf *m;
struct os_mbuf *n;
struct os_mbuf *p;
struct os_mbuf_pkthdr *pkthdr;
p = os_msys_get_pkthdr(len, sizeof(struct ble_mbuf_hdr));
if (!p) {
goto rxpdu_alloc_exit;
}
/* Set packet length */
pkthdr = OS_MBUF_PKTHDR(p);
pkthdr->omp_len = len;
/*
* NOTE: first mbuf in chain will have data pre-pended to it so we adjust
* m_data by a word.
*/
p->om_data += 4;
mb_bytes = (p->om_omp->omp_databuf_len - p->om_pkthdr_len - 4);
if (mb_bytes < len) {
n = p;
len -= mb_bytes;
while (len) {
m = os_msys_get(len, 0);
if (!m) {
os_mbuf_free_chain(p);
p = NULL;
goto rxpdu_alloc_exit;
}
/* Chain new mbuf to existing chain */
SLIST_NEXT(n, om_next) = m;
n = m;
mb_bytes = m->om_omp->omp_databuf_len;
if (mb_bytes >= len) {
len = 0;
} else {
len -= mb_bytes;
}
}
}
rxpdu_alloc_exit:
if (!p) {
STATS_INC(ble_ll_stats, no_bufs);
}
return p;
}
void
uicb_screen_next(Uicb cmd)
{
struct screen *s = SLIST_NEXT(W->screen, next);
(void)cmd;
if(!s)
s = SLIST_FIRST(&W->h.screen);
screen_select(s);
}
uint16_t
chr_end_handle(struct bletiny_svc *svc, struct bletiny_chr *chr)
{
struct bletiny_chr *next_chr;
next_chr = SLIST_NEXT(chr, next);
if (next_chr != NULL) {
return next_chr->chr.def_handle - 1;
} else {
return svc->svc.end_handle;
}
}
void
uicb_screen_move_client_next(Uicb cmd)
{
struct screen *s = SLIST_NEXT(W->screen, next);
(void)cmd;
if(!s)
s = SLIST_FIRST(&W->h.screen);
if(W->client)
tag_client(s->seltag, W->client);
}
void
symlist_free(symlist_t *symlist)
{
symbol_node_t *node1, *node2;
node1 = SLIST_FIRST(symlist);
while (node1 != NULL) {
node2 = SLIST_NEXT(node1, links);
free(node1);
node1 = node2;
}
SLIST_INIT(symlist);
}
symbol_node_t *
symlist_search(symlist_t *symlist, char *symname)
{
symbol_node_t *curnode;
curnode = SLIST_FIRST(symlist);
while(curnode != NULL) {
if (strcmp(symname, curnode->symbol->name) == 0)
break;
curnode = SLIST_NEXT(curnode, links);
}
return (curnode);
}
static int
rc_sect_free(struct rcsection *rsp) {
struct rckey *p,*n;
for(p = SLIST_FIRST(&rsp->rs_keys);p;) {
n = p;
p = SLIST_NEXT(p,rk_next);
rc_key_free(n);
}
free(rsp->rs_name);
free(rsp);
return 0;
}
int
rc_close(struct rcfile *rcp) {
struct rcsection *p,*n;
fclose(rcp->rf_f);
for(p = SLIST_FIRST(&rcp->rf_sect);p;) {
n = p;
p = SLIST_NEXT(p,rs_next);
rc_sect_free(n);
}
free(rcp->rf_name);
SLIST_REMOVE(&pf_head, rcp, rcfile, rf_next);
free(rcp);
return 0;
}
static int
rc_freesect(struct rcfile *rcp, struct rcsection *rsp)
{
struct rckey *p,*n;
SLIST_REMOVE(&rcp->rf_sect, rsp, rcsection, rs_next);
for(p = SLIST_FIRST(&rsp->rs_keys);p;) {
n = p;
p = SLIST_NEXT(p,rk_next);
rc_key_free(n);
}
free(rsp->rs_name);
free(rsp);
return 0;
}
void
print_mbuf(const struct os_mbuf *om)
{
int colon;
colon = 0;
while (om != NULL) {
if (colon) {
console_printf(":");
} else {
colon = 1;
}
print_bytes(om->om_data, om->om_len);
om = SLIST_NEXT(om, om_next);
}
}
static int
process_device_object(CborEncoder *device, const char *uuid, const char *rt,
int rt_len)
{
int dev, matches = 0;
#ifdef OC_SERVER
oc_resource_t *resource;
#endif
oc_rep_start_object(*device, links);
oc_rep_set_text_string(links, di, uuid);
oc_rep_set_array(links, links);
if (filter_resource(oc_core_get_resource_by_index(OCF_P), rt, rt_len,
oc_rep_array(links)))
matches++;
for (dev = 0; dev < oc_core_get_num_devices(); dev++) {
if (filter_resource(
oc_core_get_resource_by_index(NUM_OC_CORE_RESOURCES - 1 - dev), rt,
rt_len, oc_rep_array(links)))
matches++;
}
#ifdef OC_SERVER
for (resource = oc_ri_get_app_resources(); resource;
resource = SLIST_NEXT(resource, next)) {
if (!(resource->properties & OC_DISCOVERABLE)) {
continue;
}
if (filter_resource(resource, rt, rt_len, oc_rep_array(links))) {
matches++;
}
}
#endif
#ifdef OC_SECURITY
if (filter_resource(oc_core_get_resource_by_index(OCF_SEC_DOXM), rt, rt_len,
oc_rep_array(links)))
matches++;
#endif
oc_rep_close_array(links, links);
oc_rep_end_object(*device, links);
return matches;
}