/* reload configurations for the PPPoE daemon */
int
pppoed_reload(pppoed *_this, struct pppoe_confs *pppoe_conf)
{
int i, count, do_start, found;
struct pppoe_conf *conf;
struct ifaddrs *ifa0;
slist rmlist, newlist;
struct {
char ifname[IF_NAMESIZE];
char name[PPPOED_PHY_LABEL_SIZE];
struct pppoe_conf *conf;
} listeners[PPPOE_NLISTENER];
pppoed_listener *l;
pppoe_session *session;
hash_link *hl;
do_start = 0;
ifa0 = NULL;
slist_init(&rmlist);
slist_init(&newlist);
if (getifaddrs(&ifa0) != 0) {
pppoed_log(_this, LOG_ERR,
"getifaddrs() failed on %s(): %m", __func__);
goto fail;
}
count = 0;
TAILQ_FOREACH(conf, pppoe_conf, entry) {
strlcpy(listeners[count].ifname, conf->if_name,
sizeof(listeners[count].ifname));
strlcpy(listeners[count].name, conf->name,
sizeof(listeners[count].name));
listeners[count].conf = conf;
count++;
}
struct util_buf_pool *util_buf_pool_create_ex(size_t size, size_t alignment,
size_t max_cnt, size_t chunk_cnt,
util_buf_region_alloc_hndlr alloc_hndlr,
util_buf_region_free_hndlr free_hndlr)
{
size_t entry_sz;
struct util_buf_pool *buf_pool;
buf_pool = calloc(1, sizeof(*buf_pool));
if (!buf_pool)
return NULL;
buf_pool->alloc_hndlr = alloc_hndlr;
buf_pool->free_hndlr = free_hndlr;
buf_pool->data_sz = size;
buf_pool->alignment = alignment;
buf_pool->max_cnt = max_cnt;
buf_pool->chunk_cnt = chunk_cnt;
entry_sz = util_buf_use_ftr(buf_pool) ?
(size + sizeof(struct util_buf_footer)) : size;
buf_pool->entry_sz = fi_get_aligned_sz(entry_sz, alignment);
slist_init(&buf_pool->buf_list);
slist_init(&buf_pool->region_list);
if (util_buf_grow(buf_pool)) {
free(buf_pool);
return NULL;
}
return buf_pool;
}
//Private Method
int init_state(pm_t* pm, pm_state_t* state, pm_int_t depth) {
if(pm == NULL || state == NULL) {
return -1;
}
memset(state, 0, sizeof(pm_state_t));
state->depth = depth;
state->id = pm->newstate;
state->fail = NULL;
state->output = (slist_t*)malloc(sizeof(slist_t));
state->_transitions = (slist_t*)malloc(sizeof(slist_t));
if(state->output == NULL || state->_transitions == NULL) {
perror("Failed to allocate memory\n");
exit(-1);
}
slist_init(state->output);
slist_init(state->_transitions);
pm->newstate++;
return 0;
}
int main()
{
int i, x;
list *first = slist_init();
list *second = slist_init();
list *m;
slist_push_back(first, 0);
slist_push_back(first, 2);
slist_push_back(first, 4);
slist_push_back(first, 6);
slist_push_back(first, 8);
slist_show(first, mydump);
slist_push_back(second, 1);
slist_push_back(second, 3);
slist_push_back(second, 5);
slist_push_back(second, 7);
slist_push_back(second, 9);
slist_show(second, mydump);
m = merge(first, second);
slist_show(m, mydump);
return 0;
}
int util_buf_pool_create_ex(struct util_buf_pool **buf_pool,
size_t size, size_t alignment,
size_t max_cnt, size_t chunk_cnt,
util_buf_region_alloc_hndlr alloc_hndlr,
util_buf_region_free_hndlr free_hndlr,
void *pool_ctx)
{
size_t entry_sz;
(*buf_pool) = calloc(1, sizeof(**buf_pool));
if (!*buf_pool)
return -FI_ENOMEM;
(*buf_pool)->alloc_hndlr = alloc_hndlr;
(*buf_pool)->free_hndlr = free_hndlr;
(*buf_pool)->data_sz = size;
(*buf_pool)->alignment = alignment;
(*buf_pool)->max_cnt = max_cnt;
(*buf_pool)->chunk_cnt = chunk_cnt;
(*buf_pool)->ctx = pool_ctx;
entry_sz = util_buf_use_ftr(*buf_pool) ?
(size + sizeof(struct util_buf_footer)) : size;
(*buf_pool)->entry_sz = fi_get_aligned_sz(entry_sz, alignment);
slist_init(&(*buf_pool)->buf_list);
slist_init(&(*buf_pool)->region_list);
if (util_buf_grow(*buf_pool)) {
free(*buf_pool);
return -FI_ENOMEM;
}
return FI_SUCCESS;
}
/*****************************************************
PUBLIC: void medin_initparams()
*****************************************************/
void
medin_initparams( param *p, const char *progname )
{
p->readformat = BIBL_MEDLINEIN;
p->charsetin = BIBL_CHARSET_UNICODE;
p->charsetin_src = BIBL_SRC_DEFAULT;
p->latexin = 0;
p->xmlin = 1;
p->utf8in = 1;
p->nosplittitle = 0;
p->verbose = 0;
p->addcount = 0;
p->output_raw = BIBL_RAW_WITHMAKEREFID |
BIBL_RAW_WITHCHARCONVERT;
p->readf = medin_readf;
p->processf = medin_processf;
p->cleanf = NULL;
p->typef = NULL;
p->convertf = NULL;
p->all = NULL;
p->nall = 0;
slist_init( &(p->asis) );
slist_init( &(p->corps) );
if ( !progname ) p->progname = NULL;
else p->progname = strdup( progname );
}
int _gnix_sfl_init(int elem_size, int offset, int init_size,
int refill_size, int growth_factor,
int max_refill_size, struct gnix_s_freelist *fl)
{
assert(elem_size > 0);
assert(offset >= 0);
assert(init_size >= 0);
assert(refill_size >= 0);
assert(growth_factor >= 0);
assert(max_refill_size >= 0);
int fill_size = init_size != 0 ? init_size : GNIX_SFL_INIT_SIZE;
fl->refill_size = (refill_size != 0 ?
refill_size :
GNIX_SFL_INIT_REFILL_SIZE);
fl->growth_factor = (growth_factor != 0 ?
growth_factor :
GNIX_SFL_GROWTH_FACTOR);
fl->max_refill_size = (max_refill_size != 0 ?
max_refill_size :
fill_size);
fl->elem_size = elem_size;
fl->offset = offset;
assert(slist_empty(&fl->freelist)); /* maybe should be a warning? */
slist_init(&fl->freelist);
assert(slist_empty(&fl->chunks)); /* maybe should be a warning? */
slist_init(&fl->chunks);
return __gnix_sfl_refill(fl, fill_size);
}
int main()
{
int data[LOOP];
int i, res;
int* p;
struct slist_t* sl;
sl = slist_init();
assert(sl);
for (i = 0; i < LOOP; ++ i) {
data[i] = rand() % LOOP;
res = slist_push_front(sl, &data[i]);
assert(0 == res);
res = slist_push_back(sl, &data[i]);
assert(0 == res);
}
printf("list count=%d\n", slist_count(sl));
for (i = LOOP-1; i >= 0; -- i) {
res = slist_find(sl, &data[i]);
assert(0 == res);
p = slist_pop_front(sl);
assert(p == &data[i]);
p = slist_pop_back(sl);
assert(p == &data[i]);
res = slist_find(sl, &data[i]);
assert(res < 0);
}
printf("list count=%d\n", slist_count(sl));
slist_release(sl);
sl = 0;
return 0;
}
int chtbl_init(struct chtbl_t *htbl, int buckets, int (*h)(const void *key),
int (*match)(const void *key1, const void *key2),
void (*free_data)(void *data))
{
int i;
if (!htbl)
return -1;
htbl->table = (struct slist *) malloc(buckets * sizeof(struct slist));
if (htbl->table == NULL)
return -1;
htbl->buckets = buckets;
for (i = 0; i < htbl->buckets; i++)
slist_init(&htbl->table[i], free_data);
htbl->hash = h;
htbl->match = match;
htbl->free_data = free_data;
htbl->size = 0;
return 0;
}
struct sock_rx_entry *sock_rx_new_entry(struct sock_rx_ctx *rx_ctx)
{
struct sock_rx_entry *rx_entry;
struct slist_entry *entry;
int i;
if (rx_ctx->rx_entry_pool == NULL) {
rx_ctx->rx_entry_pool = calloc(rx_ctx->attr.size,
sizeof(*rx_entry));
if (!rx_ctx->rx_entry_pool)
return NULL;
slist_init(&rx_ctx->pool_list);
for (i = 0; i < rx_ctx->attr.size; i++) {
slist_insert_tail(&rx_ctx->rx_entry_pool[i].pool_entry,
&rx_ctx->pool_list);
rx_ctx->rx_entry_pool[i].is_pool_entry = 1;
}
}
if (!slist_empty(&rx_ctx->pool_list)) {
entry = slist_remove_head(&rx_ctx->pool_list);
rx_entry = container_of(entry, struct sock_rx_entry, pool_entry);
rx_entry->rx_ctx = rx_ctx;
entry = slist_remove_head(&rx_ctx->pool_list);
} else {
int tmodule_load(struct tconfig_block *tcfg, struct tconfig_block *global_cfg)
{
struct tconfig_block *myblk = tcfg;
struct ics_server *ics = NULL;
ics_servers = NULL;
tsockets = NULL;
g_tcfg = global_cfg;
slist_init(&ics_servers, free_ics_server);
while (myblk != NULL)
{
if (!strcmp(myblk->key,"ics_server"))
{
ics = ics_server_from_tconfig_block(myblk);
slist_insert_next(ics_servers, NULL, (void *)ics);
printf("We have an ICS server %s\n", ics->label);
}
myblk = myblk->next;
}
/* HACK */
ics_server_connect(ics, NULL);
/* FIXME: Need logging mechanism */
printf("ICS Module Loaded.\n");
return 1;
}
static void
test_12()
{
slist sl;
slist *l = &sl;
slist_init(l);
slist_add(l, (void *)42);
slist_add(l, (void *)15);
slist_add(l, (void *)14);
slist_add(l, (void *)13);
slist_add(l, (void *)29);
slist_add(l, (void *)15);
slist_add(l, (void *)25);
slist_add(l, (void *)55);
slist_add(l, (void *)66);
slist_add(l, (void *)23);
slist_qsort(l, test_12_compar);
ASSERT((int)slist_get(l, 0) == 13);
ASSERT((int)slist_get(l, 1) == 14);
ASSERT((int)slist_get(l, 2) == 15);
ASSERT((int)slist_get(l, 3) == 15);
ASSERT((int)slist_get(l, 4) == 23);
ASSERT((int)slist_get(l, 5) == 25);
ASSERT((int)slist_get(l, 6) == 29);
ASSERT((int)slist_get(l, 7) == 42);
ASSERT((int)slist_get(l, 8) == 55);
ASSERT((int)slist_get(l, 9) == 66);
}
static void
test_10()
{
int i;
slist sl;
slist *l = &sl;
slist_init(l);
slist_add(l, (void *)1);
slist_add(l, (void *)2);
slist_add(l, (void *)3);
slist_itr_first(l);
ASSERT((int)slist_itr_next(l) == 1);
ASSERT((int)slist_itr_next(l) == 2);
for (i = 4; i < 10000; i++) {
ASSERT(slist_itr_has_next(l));
ASSERT((int)slist_itr_next(l) == i - 1);
if (i % 3 == 1)
slist_add(l, (void *)i);
if (i % 3 == 0)
ASSERT((int)slist_itr_remove(l) == i - 1);
if (i % 3 != 1)
slist_add(l, (void *)i);
}
slist_itr_first(l);
while (slist_itr_has_next(l)) {
slist_itr_next(l);
slist_itr_remove(l);
}
ASSERT((int)slist_length(l) == 0);
slist_fini(l);
}
static void
test_08()
{
slist sl;
slist *l = &sl;
slist_init(l);
slist_set_size(l, 4);
slist_add(l, (void *)1);
slist_add(l, (void *)2);
slist_add(l, (void *)3);
/* [1, 2, 3] */
slist_itr_first(l);
slist_itr_has_next(l);
slist_itr_next(l);
slist_itr_remove(l);
/* [2, 3] */
slist_add(l, (void *)4);
/* [2, 3, 4] */
ASSERT((int)slist_get(l, 0) == 2);
ASSERT((int)slist_get(l, 1) == 3);
ASSERT((int)slist_get(l, 2) == 4);
slist_add(l, (void *)5);
/* [2, 3, 4, 5] */
ASSERT((int)slist_get(l, 0) == 2);
ASSERT((int)slist_get(l, 1) == 3);
ASSERT((int)slist_get(l, 2) == 4);
ASSERT((int)slist_get(l, 3) == 5);
}
static void
test_01()
{
int i;
slist sl;
slist *l = &sl;
slist_init(&sl);
for (i = 0; i < 255; i++) {
slist_add(&sl, (void *)i);
}
for (i = 0; i < 128; i++) {
slist_remove_first(&sl);
}
for (i = 0; i < 128; i++) {
slist_add(&sl, (void *)(i + 255));
}
ASSERT((int)slist_get(&sl, 127) == 255);
ASSERT((int)slist_get(&sl, 254) == 129 + 253);
ASSERT((int)slist_length(&sl) == 255);
/* dump(&sl); */
/* printf("==\n"); */
slist_add(&sl, (void *)(128 + 255));
ASSERT((int)slist_get(&sl, 127) == 255);
/* ASSERT((int)slist_get(&sl, 255) == 128 + 255); */
ASSERT((int)slist_length(&sl) == 256);
/* dump(&sl); */
}
int util_buf_pool_create_attr(struct util_buf_attr *attr,
struct util_buf_pool **buf_pool)
{
size_t entry_sz;
ssize_t hp_size;
(*buf_pool) = calloc(1, sizeof(**buf_pool));
if (!*buf_pool)
return -FI_ENOMEM;
(*buf_pool)->attr = *attr;
entry_sz = (attr->size + sizeof(struct util_buf_footer));
(*buf_pool)->entry_sz = fi_get_aligned_sz(entry_sz, attr->alignment);
hp_size = ofi_get_hugepage_size();
if ((*buf_pool)->attr.chunk_cnt * (*buf_pool)->entry_sz < hp_size)
(*buf_pool)->attr.is_mmap_region = 0;
else
(*buf_pool)->attr.is_mmap_region = 1;
if (!(*buf_pool)->attr.indexing.ordered)
slist_init(&(*buf_pool)->list.buffers);
else
dlist_init(&(*buf_pool)->list.regions);
return FI_SUCCESS;
}
ret_code_t ilcore_init_comp(ilcore_comp_h *h, OMX_CALLBACKTYPE *cb, char *name)
{
OMX_ERRORTYPE err;
ilcore_comp_ctx_t *ctx;
ctx = (ilcore_comp_ctx_t *)malloc(sizeof(ilcore_comp_ctx_t));
if (!ctx)
{
DBG_E("Memory allocation failed\n");
return L_FAILED;
}
memset(ctx, 0, sizeof(ilcore_comp_ctx_t));
slist_init(&ctx->event_list);
msleep_init(&ctx->event_sleep);
ctx->name = strdup(name);
if (!ctx->name)
{
DBG_E("strdup failed\n");
return L_FAILED;
}
err = OMX_GetHandle(&ctx->handle, name, ctx, cb);
if (err != OMX_ErrorNone)
{
DBG_E("OMX_GetHandle failed. err=%d\n", err);
return L_FAILED;
}
*h = ctx;
return L_OK;
}
/* Initializes all of the transition arrows to FAIL. representation_type must
be either DENSE_TRANSITIONS or SPARSE_TRANSITIONS. If everything is ok,
returns 0. If bad things happen, returns -1. */
static int aho_corasick_goto_initialize(aho_corasick_state_t *state) {
aho_corasick_transition_t rep_type = AHO_CORASICK_DENSE_TRANSITIONS;
if (state->depth >= TRANSITION_SWITCHING_THRESHOLD) {
rep_type = AHO_CORASICK_SPARSE_TRANSITIONS;
}
switch (rep_type) {
case AHO_CORASICK_DENSE_TRANSITIONS:
state->_transitions.type = AHO_CORASICK_DENSE_TRANSITIONS;
state->_transitions.data.array =
xalloc(AHO_CORASICK_CHARACTERS *
sizeof(aho_corasick_state_t *));
if (state->_transitions.data.array == NULL)
return -1;
memset(state->_transitions.data.array,
(int) FAIL,
AHO_CORASICK_CHARACTERS*sizeof(aho_corasick_state_t *));
return 0;
case AHO_CORASICK_SPARSE_TRANSITIONS:
state->_transitions.type = AHO_CORASICK_SPARSE_TRANSITIONS;
state->_transitions.data.slist =
xalloc(sizeof(slist_t));
if (state->_transitions.data.slist == NULL)
return -1;
slist_init(state->_transitions.data.slist);
return 0;
}
return -1;
}
static int setup(void) {
slist_init(&m);
slist_link_init(&x.lnk);
slist_link_init(&y.lnk);
slist_link_init(&z.lnk);
return 0;
}
int _gnix_queue_create(struct gnix_queue **queue, alloc_func alloc_item,
free_func free_item, size_t entry_size,
size_t entry_count)
{
struct gnix_queue *q;
struct slist_entry *temp;
int ret = FI_SUCCESS;
if (!alloc_item || !free_item) {
ret = -FI_EINVAL;
goto err;
}
q = calloc(1, sizeof(*q));
if (!q) {
ret = -FI_ENOMEM;
goto err;
}
q->alloc_item = alloc_item;
q->free_item = free_item;
q->entry_size = entry_size;
slist_init(&q->item_list);
slist_init(&q->free_list);
for (size_t count = 0; count < entry_count; count++) {
temp = q->alloc_item(entry_size);
if (!temp) {
ret = -FI_ENOMEM;
goto err1;
}
_gnix_queue_enqueue_free(q, temp);
}
*queue = q;
return ret;
err1:
_gnix_queue_destroy(q);
*queue = NULL;
err:
return ret;
}
/* initialize pptp daemon */
int
pptpd_init(pptpd *_this)
{
int i, m;
struct sockaddr_in sin0;
uint16_t call0, call[UINT16_MAX - 1];
memset(_this, 0, sizeof(pptpd));
_this->id = pptpd_seqno++;
slist_init(&_this->listener);
memset(&sin0, 0, sizeof(sin0));
sin0.sin_len = sizeof(sin0);
sin0.sin_family = AF_INET;
if (pptpd_add_listener(_this, 0, PPTPD_DEFAULT_LAYER2_LABEL,
(struct sockaddr *)&sin0) != 0) {
return 1;
}
_this->ip4_allow = NULL;
slist_init(&_this->ctrl_list);
slist_init(&_this->call_free_list);
/* randomize call id */
for (i = 0; i < countof(call) ; i++)
call[i] = i + 1;
for (i = countof(call); i > 1; i--) {
m = random() % i;
call0 = call[m];
call[m] = call[i - 1];
call[i - 1] = call0;
}
for (i = 0; i < MIN(PPTP_MAX_CALL, countof(call)); i++)
slist_add(&_this->call_free_list, (void *)(uintptr_t)call[i]);
slist_add(&_this->call_free_list, (void *)PPTPD_SHUFFLE_MARK);
if (_this->call_id_map == NULL)
_this->call_id_map = hash_create(pptp_call_cmp, pptp_call_hash,
0);
return 0;
}
/**
* initialize L2TP daemon instance
* <p>
* {@link _l2tpd#bind_sin} will return with .sin_family = AF_INET,
* .sin_port = 1701 and .sin_len = "appropriate value"
* </p>
*/
int
l2tpd_init(l2tpd *_this)
{
int i, off;
u_int id;
L2TPD_ASSERT(_this != NULL);
memset(_this, 0, sizeof(l2tpd));
slist_init(&_this->listener);
slist_init(&_this->free_session_id_list);
_this->id = l2tpd_id_seq++;
if ((_this->ctrl_map = hash_create(short_cmp, short_hash,
L2TPD_TUNNEL_HASH_SIZ)) == NULL) {
log_printf(LOG_ERR, "hash_create() failed in %s(): %m",
__func__);
return 1;
}
if (slist_add(&_this->free_session_id_list,
(void *)L2TP_SESSION_ID_SHUFFLE_MARK) == NULL) {
l2tpd_log(_this, LOG_ERR, "slist_add() failed on %s(): %m",
__func__);
return 1;
}
off = arc4random() & L2TP_SESSION_ID_MASK;
for (i = 0; i < L2TP_NCALL; i++) {
id = (i + off) & L2TP_SESSION_ID_MASK;
if (id == 0)
id = (off - 1) & L2TP_SESSION_ID_MASK;
if (slist_add(&_this->free_session_id_list,
(void *)(uintptr_t)id) == NULL) {
l2tpd_log(_this, LOG_ERR,
"slist_add() failed on %s(): %m", __func__);
return 1;
}
}
_this->purge_ipsec_sa = 1;
_this->state = L2TPD_STATE_INIT;
return 0;
}
int ioq_init(struct ioq *q, unsigned int bg_threads)
{
struct epoll_event evt;
syserr_t err;
if (runq_init(&q->run, bg_threads) < 0) {
err = syserr_last();
goto fail_runq;
}
if (!bg_threads)
q->run.wakeup = wakeup_runq;
waitq_init(&q->wait, &q->run);
q->wait.wakeup = wakeup_waitq;
thr_mutex_init(&q->lock);
slist_init(&q->mod_list);
if (pipe(q->intr) < 0) {
err = syserr_last();
goto fail_pipe;
}
fcntl(q->intr[0], F_SETFL, fcntl(q->intr[0], F_GETFL) | O_NONBLOCK);
q->intr_state = 0;
q->epoll_fd = epoll_create(64);
if (q->epoll_fd < 0) {
err = syserr_last();
goto fail_epoll;
}
memset(&evt, 0, sizeof(evt));
evt.events = EPOLLIN;
if (epoll_ctl(q->epoll_fd, EPOLL_CTL_ADD, q->intr[0], &evt) < 0) {
err = syserr_last();
goto fail_ctl;
}
return 0;
fail_ctl:
close(q->epoll_fd);
fail_epoll:
close(q->intr[0]);
close(q->intr[1]);
fail_pipe:
thr_mutex_destroy(&q->lock);
waitq_destroy(&q->wait);
runq_destroy(&q->run);
fail_runq:
syserr_set(err);
return -1;
}
static void
test_13()
{
slist sl;
slist *l = &sl;
slist_init(l);
slist_qsort(l, test_12_compar);
/* still alive without SIGFPE */
}
/* slist_t */
void _type_init_slist(const void* cpv_input, void* pv_output)
{
bool_t b_result = false;
assert(cpv_input != NULL && pv_output != NULL);
b_result = _create_slist_auxiliary((slist_t*)cpv_input, (char*)pv_output);
assert(b_result);
/* initialize slist_t */
slist_init((slist_t*)cpv_input);
}
/* Test code for removing of the first, last and middle item. */
static void
test_01a()
{
int i, f;
slist sl;
slist *l = &sl;
slist_init(&sl);
slist_add(&sl, (void *)1);
ASSERT(sl.list_size == 256);
#define SETUP() \
{ \
l->last_idx = 64; \
l->first_idx = 192; \
for (i = 0; i < slist_length(l); i++) { \
slist_set(l, i, (void *)i); \
} \
}
/* Remove the first item. */
SETUP();
f = 0;
while (slist_length(l) > 0) {
slist_remove(l, 0);
f++;
for (i = 0; i < slist_length(l); i++) {
ASSERT((int)slist_get(l, i) == i + f);
}
}
/* Remove the last item. */
SETUP();
while (slist_length(l) > 0) {
slist_remove(l, slist_length(l) - 1);
for (i = 0; i < slist_length(l); i++) {
ASSERT((int)slist_get(l, i) == i);
}
}
/* Remove the second item from the end. */
SETUP();
while (slist_length(l) > 1) {
slist_remove(l, slist_length(l) - 2);
for (i = 0; i < slist_length(l) - 1; i++) {
ASSERT((int)slist_get(l, i) == i);
}
if (slist_length(l) > 0) {
ASSERT((int)slist_get(l, slist_length(l) - 1) == 127);
}
}
slist_remove(l, slist_length(l) - 1);
ASSERT(slist_length(l) == 0);
}
void os_init(void)
{
moduleAddOperServCmds();
/* Initialization of the lists */
slist_init(&servadmins);
servadmins.opts = &saopts;
slist_init(&servopers);
servopers.opts = &soopts;
slist_init(&akills);
akills.opts = &akopts;
if (ircd->sgline) {
slist_init(&sglines);
sglines.opts = &sgopts;
}
if (ircd->sqline) {
slist_init(&sqlines);
sqlines.opts = &sqopts;
}
if (ircd->szline) {
slist_init(&szlines);
szlines.opts = &szopts;
}
}
static struct slist *get_map_bucket(struct hash_table *m, void *key, bool allocate_on_empty)
{
if (!m) { return NULL; }
const size_t bucket = (m->hasher)(m, key);
struct slist **index = &m->table[bucket];
if (!*index && allocate_on_empty) {
*index = slist_init((bool (*)(const void *, const void *))m->comparer);
}
return *index;
}
extern RET_T ss_create_worker_threads(size_t thread_num, P_THREAD_OBJ threads)
{
int i = 0;
pthread_attr_t attr;
int ret = 0;
pthread_mutex_init(&init_lock, NULL);
pthread_cond_init(&init_cond, NULL);
for (i=0; i < thread_num; ++i)
{
int fds[2];
if (pipe(fds)) {
SYS_ABORT("Can't create notify pipe");
}
threads[i].notify_receive_fd = fds[0];
threads[i].notify_send_fd = fds[1];
threads[i].base = event_init();
if (! threads[i].base ){
SYS_ABORT("Can't allocate event base");
}
threads[i].p_notify_event = event_new(threads[i].base, threads[i].notify_receive_fd,
EV_READ | EV_PERSIST, thread_process, &threads[i]);
if (! threads[i].p_notify_event ){
SYS_ABORT("Can't allocate new event");
}
if (event_add(threads[i].p_notify_event, 0) == -1) {
SYS_ABORT("Can't monitor libevent notify pipe");
}
slist_init(&threads[i].conn_queue);
pthread_mutex_init(&threads[i].q_lock, NULL);
pthread_attr_init(&attr);
if ((ret = pthread_create(&threads[i].thread_id, &attr, thread_run, (void*)(&threads[i]))) != 0)
{
SYS_ABORT("Cannot create worker thread %s", strerror(ret));
}
}
pthread_mutex_lock(&init_lock);
wait_for_thread_registration(thread_num);
pthread_mutex_unlock(&init_lock);
}
int
aho_corasick_maketree(aho_corasick_t *in)
{
slist_t queue;
aho_corasick_state_t *state,*s,*r;
aho_corasick_t *g = in;
int i;
slist_init(&queue);
// Set all FAIL transition of 0 state to point to itself
for(i = 0; i < AHO_CORASICK_CHARACTERS ;i++)
{
if ( aho_corasick_goto_get(g->zerostate,i) == FAIL )
aho_corasick_goto_set(g->zerostate, i, g->zerostate);
// Construct fail()
else
{
if ( slist_append(&queue,aho_corasick_goto_get(g->zerostate,i)) < 0 )
goto fail;
aho_corasick_fail(aho_corasick_goto_get(g->zerostate,i)) = g->zerostate;
}
}
// Set fail() for depth > 0
while( (r = slist_pop_first(&queue)) != NULL )
{
for(i = 0; i < AHO_CORASICK_CHARACTERS ;i++)
{
if ( (s = aho_corasick_goto_get(r,i)) == FAIL )
continue;
if ( slist_append(&queue,s) < 0 )
goto fail;
state = aho_corasick_fail(r);
while( aho_corasick_goto_get(state,i) == FAIL )
state = aho_corasick_fail(state);
aho_corasick_fail(s) = aho_corasick_goto_get(state,i);
debug(printf("Setting f(%u) == %u\n",s->id,
aho_corasick_goto_get(state,i)->id));
// Join outputs missing
}
}
slist_destroy(&queue,SLIST_LEAVE_DATA);
return 0;
fail:
slist_destroy(&queue,SLIST_LEAVE_DATA);
return -1;
}
