static int put_zfs_value (kstat_t *ksp, char const *k, value_t v)
{
llentry_t *e;
char *k_copy;
value_t *v_copy;
k_copy = strdup (k);
if (k_copy == NULL)
return ENOMEM;
v_copy = malloc (sizeof (*v_copy));
if (v_copy == NULL)
{
sfree (k_copy);
return ENOMEM;
}
*v_copy = v;
e = llentry_create (k_copy, v_copy);
if (e == NULL)
{
sfree (v_copy);
sfree (k_copy);
return ENOMEM;
}
llist_append (ksp, e);
return 0;
}
void hmap_set(struct hash_map *map, void *key, void *data)
{
size_t hashed_key = map->hash_fn(key);
struct linked_list *list = &map->buckets_array[hashed_key % map->num_buckets];
struct ll_node *node;
node = llist_search(list, _find_key, (void*)&hashed_key);
if(!node) {
if(!(node = llist_append(list))) {
return;
}
}
/* set data */
{
struct keydata_pair *kdp;
if(!node->data) {
if(!(node->data = (struct keydata_pair*)malloc(sizeof(struct keydata_pair)))) {
llist_remove(list, node, NULL, NULL);
ERROR("hmap_set: out of memory!");
return;
}
}
kdp = (struct keydata_pair*)node->data;
kdp->hashed_key = hashed_key;
kdp->data = data;
}
}
static int register_callback (llist_t **list, /* {{{ */
const char *name, callback_func_t *cf)
{
llentry_t *le;
char *key;
if (*list == NULL)
{
*list = llist_create ();
if (*list == NULL)
{
ERROR ("plugin: register_callback: "
"llist_create failed.");
destroy_callback (cf);
return (-1);
}
}
key = strdup (name);
if (key == NULL)
{
ERROR ("plugin: register_callback: strdup failed.");
destroy_callback (cf);
return (-1);
}
le = llist_search (*list, name);
if (le == NULL)
{
le = llentry_create (key, cf);
if (le == NULL)
{
ERROR ("plugin: register_callback: "
"llentry_create failed.");
free (key);
destroy_callback (cf);
return (-1);
}
llist_append (*list, le);
}
else
{
callback_func_t *old_cf;
old_cf = le->value;
le->value = cf;
WARNING ("plugin: register_callback: "
"a callback named `%s' already exists - "
"overwriting the old entry!", name);
destroy_callback (old_cf);
sfree (key);
}
return (0);
} /* }}} int register_callback */
int sql_append_map (struct sql_expr *expr, char *alias)
{
struct sql_map *map;
map = type_alloc(struct sql_map);
map->expr = expr;
map->alias = alias;
llist_append(&query.map, map);
return 0;
}
int sql_append_group (struct sql_source *src, int fld)
{
struct sql_group *grp;
grp = type_alloc(struct sql_group);
grp->source = src;
grp->field = fld;
llist_append(&query.group, grp);
return 0;
}
int sql_append_aggre_resolved (aggre_t *func, struct sql_source *src, int fld)
{
struct sql_aggre *aggre;
aggre = type_alloc(struct sql_aggre);
aggre->aggre = func;
aggre->source = src;
aggre->field = fld;
llist_append(&(query.aggre), aggre);
return 0;
}
int sql_append_aggre (char *func, char *src, char *fld)
{
struct sql_aggre *aggre;
aggre = type_alloc(struct sql_aggre);
aggre->naggre = func;
aggre->nsource = src;
aggre->nfield = fld;
llist_append(&(query.aggre), aggre);
return 0;
}
void
string_hash_set (StringHash *hash, char *key, char *value)
{
StringHashItem *item;
item = (StringHashItem *) llist_append ((LList *) hash);
item->key = key;
item->hash = calc_hash (key);
item->value = value;
}
//doesn't check for key collisions
void hash_map_insert(hash_map *hm, void *key, void *value) {
int hash = hm->hash(key);
assert(hash < hm->hashLength);
hash_item *item = malloc(sizeof(hash_item));
item->key = key;
item->value = value;
llist_append(hm->boxes[hash], item);
}
int main()
{
node entry = node_new(28);
list head = NULL;
int i = 0;
while(i < 5)
{
llist_append(head,new_node(5*i++));
}
llist_append(head,entry);
while(i < 8)
{
llist_append(head,new_node(5*i++));
}
llist_show(head);
return 0;
}
int sql_append_filter (func_t *func, struct sql_source *src1, int fld1, struct sql_source *src2, int fld2)
{
struct sql_filter *filter;
filter = type_alloc(struct sql_filter);
filter->source = src1;
filter->field = fld1;
filter->source2 = src2;
filter->field2 = fld2;
filter->comp = func;
llist_append(&(query.filter), filter);
return 0;
}
int sql_append_src_filter (func_t *comp, struct sql_source *src, int fld, void *data, type_t *type)
{
struct sql_filter *filter;
filter = type_alloc(struct sql_filter) ;
filter->source = src;
filter->field = fld;
filter->data = data;
filter->type = type;
filter->comp = comp;
llist_append(&(src->filter), filter);
return 0;
}
int cllist_append(cLinkedList *cllist, void *elem)
{
int returnVal;
pthread_mutex_lock(&(cllist->mutex));
returnVal = llist_append(cllist->llist, elem);
pthread_mutex_unlock(&(cllist->mutex));
return returnVal;
}
int llist_reorder( llist_t *list_in, llist_t *list_out )
{
long i = list_in->begin;
long j = 0;
while( i != -1 && j < list_in->size )
{
if( llist_append( list_out, list_in->start[i].data ) < 0 )
return -1;
i = list_in->start[i].next;
++j;
}
return 0;
}
int list_push(struct list *list, void *item) {
struct item *listitem;
if (!list->first) {
list->first = llist_newitem(item);
list->last = list->first;
}
else {
listitem = llist_newitem(item);
llist_append(list->last, listitem);
list->last = listitem;
}
return ++list->size;
}
static int mr_config_add_meta_regex(llist_t **meta, /* {{{ */
oconfig_item_t *ci) {
char *meta_key;
llentry_t *entry;
mr_regex_t *re_head;
int status;
char buffer[1024];
if ((ci->values_num != 2) || (ci->values[0].type != OCONFIG_TYPE_STRING) ||
(ci->values[1].type != OCONFIG_TYPE_STRING)) {
log_warn("`%s' needs exactly two string arguments.", ci->key);
return -1;
}
if (*meta == NULL) {
*meta = llist_create();
if (*meta == NULL) {
log_err("mr_config_add_meta_regex: llist_create failed.");
return -1;
}
}
meta_key = ci->values[0].value.string;
entry = llist_search(*meta, meta_key);
if (entry == NULL) {
meta_key = strdup(meta_key);
if (meta_key == NULL) {
log_err("mr_config_add_meta_regex: strdup failed.");
return -1;
}
entry = llentry_create(meta_key, NULL);
if (entry == NULL) {
log_err("mr_config_add_meta_regex: llentry_create failed.");
sfree(meta_key);
return -1;
}
/* meta_key and entry will now be freed by mr_free_match(). */
llist_append(*meta, entry);
}
snprintf(buffer, sizeof(buffer), "%s `%s'", ci->key, meta_key);
/* Can't pass &entry->value into mr_add_regex, so copy in/out. */
re_head = entry->value;
status = mr_add_regex(&re_head, ci->values[1].value.string, buffer);
if (status == 0) {
entry->value = re_head;
}
return status;
} /* }}} int mr_config_add_meta_regex */
int sql_append_group_filter_pre (int cmp, struct sql_source *src, int fld, aggre_t *aggre, void *data, type_t *type)
{
func_t *f;
struct sql_group_filter *pre;
pre = type_alloc(struct sql_group_filter);
pre->aggre = aggre;
pre->source = src;
pre->field = fld;
pre->type = type;
pre->data = data;
f = func_load(cmp2text(cmp), aggre->otype, type);
if (f == NULL) sql_ok = 0;
pre->comp = f;
llist_append(&(query.aggre), pre);
return 0;
}
int streambuf_write(streambuf_t *p, struct streambuf_iov_st *iov)
{
int ret=0;
struct streambuf_st *buf=p;
pthread_mutex_lock(&buf->mut);
pthread_cleanup_push(mutex_unlock, &buf->mut);
while (buf->nr_bytes >= buf->h_limit) {
pthread_cond_wait(&buf->cond, &buf->mut);
}
llist_append(buf->ringbuf, iov);
buf->nr_bytes += iov->len;
pthread_cond_signal(&buf->cond);
pthread_cleanup_pop(1);
return ret;
}
int main(){
int D,N;
scanf("%d%d",&D,&N);
LList*peg_1=llist_new();
LList*peg_2=llist_new();
LList*peg_3=llist_new();
int i=1;
while(i<=D){
peg_1=llist_append(peg_1,i);
i++;
}
int num_of_steps = 0;
num_of_steps = play_TOH(peg_1,peg_2,peg_3);
printf(" No of steps= %d\n",num_of_steps);
return 0;
}
int streambuf_write_nb(streambuf_t *p, struct streambuf_iov_st *iov)
{
int ret=0;
struct streambuf_st *buf=p;
pthread_mutex_lock(&buf->mut);
pthread_cleanup_push(mutex_unlock, &buf->mut);
if (buf->nr_bytes >= buf->h_limit) {
ret = ENOMEM;
goto quit;
}
llist_append(buf->ringbuf, iov);
buf->nr_bytes += iov->len;
pthread_cond_signal(&buf->cond);
quit:
pthread_cleanup_pop(1);
return ret;
}
static void schan_members_join(struct llist_header *head, char *nick, char *uhost, char *user, char *chan)
{
struct stats_member *m;
char *host;
#ifndef NO_EGG
struct chanset_t *eggchan;
#endif
m = schan_members_create();
m->nick = nmalloc(strlen(nick) + 1);
strcpy(m->nick, nick);
m->uhost = nmalloc(strlen(uhost) + 1);
strcpy(m->uhost, uhost);
m->joined = now;
if (user) {
m->user = findsuser_by_name(user);
if (!m->user) {
m->user = addsuser(user, now, now);
debug1("Stats.Mod: Created suserrec for %s.", user);
}
} else {
host = nmalloc(strlen(nick) + 1 + strlen(uhost) + 1);
sprintf(host, "%s!%s", nick, uhost);
m->user = findsuser(host);
nfree(host);
}
if (m->user) {
m->user->laston = now;
m->stats = findlocstats(chan, m->user->user);
if (!m->stats)
m->stats = initstats(chan, m->user->user);
}
#ifndef NO_EGG
eggchan = findchan_by_dname(chan);
if (chan)
m->eggmember = ismember(eggchan, nick);
if (!m->eggmember)
debug2("Warning[stats.mod]: Couldn't find eggmember for %s in %s.", nick, chan);
#endif
llist_append(head, (void *) m);
}
llist *quadtree_retrieve_node(quadtree *q, quadtree_node *qn,
quadtree_rect *r, llist *list) {
if (!qn) {
return list;
}
if (qn->points && !llist_is_empty(qn->points)) {
quadtree_data *d = llist_first(qn->points);
if (quadtree_rect_contains(r, d->x, d->y)) {
llist_append(list, qn->points);
}
} else {
for(int i = 0; i < 4; i++) {
if (quadtree_rect_contains_node(r, qn->children[i])) {
quadtree_retrieve_node(q, qn->children[i], r, list);
}
}
}
return list;
}
int main() //@ : main
//@ requires emp;
//@ ensures emp;
{
struct llist *l1 = create_llist();
struct llist *l2 = create_llist();
llist_add(l1, 10);
llist_add(l1, 20);
llist_add(l1, 30);
llist_add(l2, 40);
llist_add(l2, 50);
llist_add(l2, 60);
int x = llist_removeFirst(l2); assert(x == 40);
llist_append(l1, l2);
int n = llist_length(l1); assert(n == 5);
int e0 = llist_lookup(l1, 0); assert(e0 == 10);
int e1 = llist_lookup(l1, 1); assert(e1 == 20);
int e2 = llist_lookup(l1, 2); assert(e2 == 30);
int e3 = llist_lookup(l1, 3); assert(e3 == 50);
int e4 = llist_lookup(l1, 4); assert(e4 == 60);
llist_dispose(l1);
return 0;
}
static int cx_config_add_xpath (cx_t *db, oconfig_item_t *ci) /* {{{ */
{
cx_xpath_t *xpath;
char *name;
llentry_t *le;
int status;
int i;
xpath = malloc (sizeof (*xpath));
if (xpath == NULL)
{
ERROR ("curl_xml plugin: malloc failed.");
return (-1);
}
memset (xpath, 0, sizeof (*xpath));
status = cf_util_get_string (ci, &xpath->path);
if (status != 0)
{
cx_xpath_free (xpath);
return (status);
}
/* error out if xpath->path is an empty string */
if (strlen (xpath->path) == 0)
{
ERROR ("curl_xml plugin: invalid xpath. "
"xpath value can't be an empty string");
cx_xpath_free (xpath);
return (-1);
}
status = 0;
for (i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
if (strcasecmp ("Type", child->key) == 0)
status = cf_util_get_string (child, &xpath->type);
else if (strcasecmp ("InstancePrefix", child->key) == 0)
status = cf_util_get_string (child, &xpath->instance_prefix);
else if (strcasecmp ("InstanceFrom", child->key) == 0)
status = cf_util_get_string (child, &xpath->instance);
else if (strcasecmp ("ValuesFrom", child->key) == 0)
status = cx_config_add_values ("ValuesFrom", xpath, child);
else
{
WARNING ("curl_xml plugin: Option `%s' not allowed here.", child->key);
status = -1;
}
if (status != 0)
break;
} /* for (i = 0; i < ci->children_num; i++) */
if (status != 0)
{
cx_xpath_free (xpath);
return status;
}
if (xpath->type == NULL)
{
WARNING ("curl_xml plugin: `Type' missing in `xpath' block.");
cx_xpath_free (xpath);
return -1;
}
if (db->list == NULL)
{
db->list = llist_create();
if (db->list == NULL)
{
ERROR ("curl_xml plugin: list creation failed.");
cx_xpath_free (xpath);
return (-1);
}
}
name = strdup (xpath->path);
if (name == NULL)
{
ERROR ("curl_xml plugin: strdup failed.");
cx_xpath_free (xpath);
return (-1);
}
le = llentry_create (name, xpath);
if (le == NULL)
{
ERROR ("curl_xml plugin: llentry_create failed.");
cx_xpath_free (xpath);
sfree (name);
return (-1);
}
llist_append (db->list, le);
return (0);
} /* }}} int cx_config_add_xpath */
int main(int argc, char **argv)
{
llist_t *paths,*src,*todo;
set_t *incl;
map_t *deps;
if (argc < 2) {
fprintf(stderr,"FastDep v%s for LAMMPS\n"
"Usage: %s [-I <path> ...] -- <src1> [<src2> ...]\n",
version,argv[0]);
fprintf(stderr,"Supported extensions: %s, %s, %s\n",
extensions[0], extensions[1], extensions[2]);
return 1;
}
/* hash tables for all known included files and dependencies
* we guesstimate a little over 2x as many entries as sources. */
incl = set_init(2*argc);
deps = map_init(2*argc);
/* list of include search paths. prefixed by "." and "..". */
paths = llist_init();
llist_append(paths,".");
llist_append(paths,"..");
while (++argv, --argc > 0) {
if (strncmp(*argv, "-I", 2) == 0) {
if ((*argv)[2] != '\0') {
llist_append(paths,trim_path(*argv+2));
} else {
++argv;
--argc;
if (argc > 0) {
if (strcmp(*argv,"--") == 0) {
break;
} else {
llist_append(paths,trim_path(*argv));
}
}
}
} else if (strcmp(*argv,"--") == 0) {
break;
} /* ignore all unrecognized arguments before '--'. */
}
src = llist_init();
while (++argv, --argc > 0) {
llist_append(src,*argv);
}
/* process files to look for includes */
todo = llist_init();
find_includes(src->head,todo,paths,incl,deps);
find_includes(todo->head,todo,paths,incl,deps);
llist_free(todo);
fprintf(stdout,"# FastDep v%s for LAMMPS\n",version);
fputs("# Search path: ",stdout);
llist_print(paths);
fprintf(stdout,"# % 5d sources\n# % 5d includes\n# % 5d depfiles\n",
llist_size(src),set_size(incl),map_size(deps));
set_free(incl);
do_depend(src->head,deps);
llist_free(src);
llist_free(paths);
map_free(deps);
return 0;
}
static void find_includes(llnode_t *head, llist_t *todo, llist_t *paths,
set_t *incl, map_t *deps)
{
FILE *fp;
llnode_t *tmp;
char *buffer,*full,*ptr,*end;
const char *file;
buffer = (char *)malloc(4096);
full = (char *)malloc(4096);
tmp = head;
while (tmp->next != NULL) {
file = tmp->key;
fp = fopen(file,"r");
if (fp == NULL) {
perror("Cannot read source");
fprintf(stderr,"For file: %s\n",file);
exit(EXIT_FAILURE);
}
/* read file line by line and look for #include "..." */
while (!feof(fp) && !ferror(fp)) {
if (fgets(buffer,4096,fp) == NULL) continue;
ptr = buffer;
while (*ptr == ' ' || *ptr == '\t') ++ptr;
if (*ptr != '#') continue;
while (*ptr == ' ' || *ptr == '\t') ++ptr;
if (*++ptr != 'i') continue;
if (*++ptr != 'n') continue;
if (*++ptr != 'c') continue;
if (*++ptr != 'l') continue;
if (*++ptr != 'u') continue;
if (*++ptr != 'd') continue;
if (*++ptr != 'e') continue;
++ptr;
while (*ptr == ' ' || *ptr == '\t') ++ptr;
if (*ptr != '"') continue;
++ptr;
end = ptr;
while (*end != '"') {
if (*end == '\0') {
fprintf(stderr,"Unmatched '\"': %s\n",buffer);
exit(EXIT_FAILURE);
}
++end;
}
*end = '\0';
/* get full path to include file */
make_path(ptr,paths,full);
/* skip, if not found or unreadable. */
if (full[0] == '\0') continue;
/* if this is a yet unknown include, add to the
* todo list, if append is enabled */
if (set_find(incl,full) == 0) {
set_add(incl,full);
llist_append(todo,full);
}
map_add(deps,file,full);
}
fclose(fp);
tmp = tmp->next;
}
free(buffer);
free(full);
}
static int cx_config_add_xpath(cx_t *db, oconfig_item_t *ci) /* {{{ */
{
cx_xpath_t *xpath = calloc(1, sizeof(*xpath));
if (xpath == NULL) {
ERROR("curl_xml plugin: calloc failed.");
return -1;
}
int status = cf_util_get_string(ci, &xpath->path);
if (status != 0) {
cx_xpath_free(xpath);
return status;
}
/* error out if xpath->path is an empty string */
if (strlen(xpath->path) == 0) {
ERROR("curl_xml plugin: invalid xpath. "
"xpath value can't be an empty string");
cx_xpath_free(xpath);
return -1;
}
status = 0;
for (int i = 0; i < ci->children_num; i++) {
oconfig_item_t *child = ci->children + i;
if (strcasecmp("Type", child->key) == 0)
status = cf_util_get_string(child, &xpath->type);
else if (strcasecmp("InstancePrefix", child->key) == 0)
status = cf_util_get_string(child, &xpath->instance_prefix);
else if (strcasecmp("InstanceFrom", child->key) == 0)
status = cf_util_get_string(child, &xpath->instance);
else if (strcasecmp("PluginInstanceFrom", child->key) == 0)
status = cf_util_get_string(child, &xpath->plugin_instance_from);
else if (strcasecmp("ValuesFrom", child->key) == 0)
status = cx_config_add_values("ValuesFrom", xpath, child);
else {
WARNING("curl_xml plugin: Option `%s' not allowed here.", child->key);
status = -1;
}
if (status != 0)
break;
} /* for (i = 0; i < ci->children_num; i++) */
if (status != 0) {
cx_xpath_free(xpath);
return status;
}
if (xpath->type == NULL) {
WARNING("curl_xml plugin: `Type' missing in `xpath' block.");
cx_xpath_free(xpath);
return -1;
}
if (xpath->values_len == 0) {
WARNING("curl_xml plugin: `ValuesFrom' missing in `xpath' block.");
cx_xpath_free(xpath);
return -1;
}
llentry_t *le = llentry_create(xpath->path, xpath);
if (le == NULL) {
ERROR("curl_xml plugin: llentry_create failed.");
cx_xpath_free(xpath);
return -1;
}
llist_append(db->xpath_list, le);
return 0;
} /* }}} int cx_config_add_xpath */
static int powerdns_config_add_server (oconfig_item_t *ci) /* {{{ */
{
char *socket_temp;
list_item_t *item;
int status;
int i;
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING))
{
WARNING ("powerdns plugin: `%s' needs exactly one string argument.",
ci->key);
return (-1);
}
item = (list_item_t *) malloc (sizeof (list_item_t));
if (item == NULL)
{
ERROR ("powerdns plugin: malloc failed.");
return (-1);
}
memset (item, '\0', sizeof (list_item_t));
item->instance = strdup (ci->values[0].value.string);
if (item->instance == NULL)
{
ERROR ("powerdns plugin: strdup failed.");
sfree (item);
return (-1);
}
/*
* Set default values for the members of list_item_t
*/
if (strcasecmp ("Server", ci->key) == 0)
{
item->server_type = SRV_AUTHORITATIVE;
item->func = powerdns_read_server;
item->socktype = SOCK_STREAM;
socket_temp = strdup (SERVER_SOCKET);
}
else if (strcasecmp ("Recursor", ci->key) == 0)
{
item->server_type = SRV_RECURSOR;
item->func = powerdns_read_recursor;
item->socktype = SOCK_DGRAM;
socket_temp = strdup (RECURSOR_SOCKET);
}
else
{
/* We must never get here.. */
assert (0);
return (-1);
}
status = 0;
for (i = 0; i < ci->children_num; i++)
{
oconfig_item_t *option = ci->children + i;
if (strcasecmp ("Collect", option->key) == 0)
status = powerdns_config_add_collect (item, option);
else if (strcasecmp ("Socket", option->key) == 0)
status = powerdns_config_add_string ("Socket", &socket_temp, option);
else
{
ERROR ("powerdns plugin: Option `%s' not allowed here.", option->key);
status = -1;
}
if (status != 0)
break;
}
while (status == 0)
{
llentry_t *e;
if (socket_temp == NULL)
{
ERROR ("powerdns plugin: socket_temp == NULL.");
status = -1;
break;
}
item->sockaddr.sun_family = AF_UNIX;
sstrncpy (item->sockaddr.sun_path, socket_temp,
sizeof (item->sockaddr.sun_path));
e = llentry_create (item->instance, item);
if (e == NULL)
{
ERROR ("powerdns plugin: llentry_create failed.");
status = -1;
break;
}
llist_append (list, e);
break;
}
if (status != 0)
{
sfree (item);
return (-1);
}
DEBUG ("powerdns plugin: Add server: instance = %s;", item->instance);
return (0);
} /* }}} int powerdns_config_add_server */
int main() {
running = 1;
signal(SIGINT, interrupt_handler);
printf("Starting server\n");
if(!init_server_socket(&sock, PORT))
return -1;
//A linked list might not be the most efficient for this
llist client_sessions;
llist_init(&client_sessions);
queue message_queue;
queue_init(&message_queue);
//TODO: initialise thread pool
const int num_workers = 4;
pthread_t workers[num_workers];
for(int i=0; i<num_workers; i++) {
pthread_create(&workers[i], NULL, worker_run, (void*)&message_queue);
}
//select stuff
fd_set readsocketset;
fd_set writesocketset;
fd_set errorsocketset;
struct timeval timeout;
while(running) {
timeout.tv_sec = 1;
timeout.tv_usec = 0;
printf("1\n");
build_socket_list(&client_sessions, &readsocketset);
FD_ZERO(&readsocketset);
FD_SET(sock, &readsocketset);
int s = select(client_sessions.len, &readsocketset, 0, 0, &timeout);
printf("2\n");
if(s < 0) {
printf("ERROR: Select error\n");
exit(1);
}
//if we have a new connection create a new session
if(FD_ISSET(sock, &readsocketset)) {
int csock = check_for_connections(sock);
session clientSession;
session_init(&clientSession, csock);
llist_append(&client_sessions, (void*)&clientSession);
}
printf("2\n");
//check if each session exists in the read socket thingE
llist_node *cur = client_sessions.head;
while(cur != NULL) {
int sock = ((session*)cur->data)->sock;
//check readsocketset
if(FD_ISSET(sock, &readsocketset))
client_read_data((session*)cur->data);
//check writesocketset
//check errorset
cur = cur->next;
}
//TODO:
//parse the messages
//add parsed message to the queue
//send messages on the queue (Should this be done here?)
}
printf("Exiting..\n");
//free memory
llist_node *cur = client_sessions.head;
while(cur != NULL) {
session *sess = (session*)cur->data;
session_end(sess);
free(sess);
cur = cur->next;
}
llist_free(&client_sessions);
close(sock);
pthread_exit(NULL);
}
void func_test()
{
char *s = "this is a test";
char *s2 = "x";
void *b;
int i, j;
llist_t *ll;
/*
* test 1
*/
ll = llist_new(20);
for (i = 0; i < 4; i++) {
if (i%3 == 0) {
llist_append(ll, &s2[0]);
}
llist_append(ll, &s[i]);
}
llist_travel(ll, &show);
printf("\n");
for (i = 0; i < 4; i++) {
llist_prepend(ll, &s[0]);
}
llist_travel(ll, &show);
printf("\n");
for (i = 0; i < 4; i++) {
llist_prepend_nb(ll, &s[1]);
}
llist_travel(ll, &show);
printf("\n");
llist_fetch_head(ll, &b);
llist_travel(ll, &show);
printf("\n");
llist_fetch_head(ll, &b);
llist_travel(ll, &show);
printf("\n");
llist_delete(ll);
printf("%stest1 successful%s\n", COR_BEGIN, COR_END);
/*
* test 2
*/
ll = llist_new(1000);
for (j = 0; j < 100; j++) {
for (i = 0; i < 10; i++) {
llist_append_nb(ll, &s[i]);
}
}
printf("append done.\n");
for (i = 0; i< 100; i++) {
llist_fetch_head_nb(ll, &b);
printf("%c", *(char *)b);
}
printf("\nthere are %d nodes\n", ll->nr_nodes);
for (i = 0; i< 100; i++) {
llist_get_head_nb(ll, &b);
printf("%c", *(char *)b);
}
printf("\n");
printf("%stest2 successful%s\n", COR_BEGIN, COR_END);
printf("there are %d nodes\n", ll->nr_nodes);
/*
* test 3
*/
void *ptr, *ptr2;
llist_get_head_node_nb(ll, &ptr);
for (i = 0; i< 100; i++) {
printf("%c", *(char *)(((llist_node_t *)ptr)->ptr));
ptr = llist_get_next_nb(ll, ptr);
}
printf("\nthere are %d nodes\n", ll->nr_nodes);
llist_delete(ll);
printf("%stest3 successful%s\n", COR_BEGIN, COR_END);
return;
}
