/*
* fds_select_check
*
* given an fd_set that has been passed to select, as well as a list of
* fds that are being monitored, figure out which ones have an event and
* use the callback provided to deal with the event.
*/
static void fds_select_check(fd_set *fdset, dlist_t *fds, int *count)
{
scamper_fd_poll_t *fdp;
dlist_node_t *node;
/* stop now if there is nothing to check */
if(fdset == NULL || *count == 0)
{
return;
}
/* nodes in this list should not be removed while this function is called */
dlist_lock(fds);
/* loop through */
node = dlist_head_node(fds);
while(node != NULL && *count > 0)
{
fdp = (scamper_fd_poll_t *)dlist_node_item(node);
node = dlist_node_next(node);
if(FD_ISSET(fdp->fdn->fd, fdset))
{
fdp->cb(fdp->fdn->fd, fdp->param);
(*count)--;
}
}
/* can modify the list now */
dlist_unlock(fds);
return;
}
static client client_new(int fd, int sock) {
client c;
if (NEW(c) == NULL)
return NULL;
/* FIXME */
net_nonblock(fd, NULL, 0);
net_tcp_nodelay(fd, NULL, 0);
if (create_file_event(el, fd, EVENT_READABLE, read_from_client, c) == -1) {
close(fd);
client_free(c);
return NULL;
}
c->fd = fd;
pthread_spin_init(&c->lock, 0);
c->sock = sock;
c->flags = 0;
c->inpos = 0;
c->argc = 0;
c->argv = NULL;
c->outpos = 0;
c->reply = ring_new();
c->sentlen = 0;
c->refcount = 0;
c->eagcount = 0;
c->authenticated = 0;
dlist_lock(clients);
dlist_insert_tail(clients, c);
dlist_unlock(clients);
return c;
}
int dlist_foreach(dlist_t *list, const dlist_foreach_t func, void *param)
{
dlist_node_t *node, *next;
assert(list != NULL);
assert(func != NULL);
dlist_lock(list);
dlist_assert(list);
node = list->head;
while(node != NULL)
{
next = node->next;
if(func(node->item, param) != 0)
{
dlist_unlock(list);
return -1;
}
node = next;
}
dlist_assert(list);
dlist_unlock(list);
return 0;
}
/* FIXME */
static void remove_from_clients(client c) {
dlist_node_t node;
dlist_lock(clients);
if ((node = dlist_find(clients, c)))
dlist_remove(clients, node);
dlist_unlock(clients);
}
int list_add_tail(list_t * list, void *data)
{
list_node_t *node = NULL;
return_val_if_fail(list != NULL, RET_INVALID_PARAMS);
node = node_create(data);
return_val_if_fail(node != NULL, RET_NOMEM);
dlist_lock(list);
__list_add(node, list->head.prev, &list->head);
dlist_unlock(list);
return 0;
}
Ret dlist_insert(DList* thiz, size_t index, void* data)
{
Ret ret = RET_OK;
DListNode* node = NULL;
DListNode* cursor = NULL;
return_val_if_fail(thiz != NULL, RET_INVALID_PARAMS);
dlist_lock(thiz);
do
{
if((node = dlist_create_node(thiz, data)) == NULL)
{
ret = RET_OOM;
break;
}
if(thiz->first == NULL)
{
thiz->first = node;
break;
}
cursor = dlist_get_node(thiz, index, 1);
if(index < dlist_length(thiz))
{
node->next = cursor;
if(cursor->prev != NULL)
{
cursor->prev->next = node;
}
cursor->prev = node;
if(thiz->first == cursor)
{
thiz->first = node;
}
}
else
{
cursor->next = node;
node->prev = cursor;
}
}while(0);
dlist_unlock(thiz);
return ret;
}
size_t list_length(list_t * thiz)
{
size_t length = 0;
list_node_t *iter = NULL;
return_val_if_fail(thiz != NULL, 0);
dlist_lock(thiz);
iter = &thiz->head;
while (iter->next != &thiz->head) {
length++;
iter = iter->next;
}
dlist_unlock(thiz);
return length;
}
Ret dlist_get_by_index(DList* thiz, size_t index, void** data)
{
DListNode* cursor = NULL;
return_val_if_fail(thiz != NULL && data != NULL, RET_INVALID_PARAMS);
dlist_lock(thiz);
cursor = dlist_get_node(thiz, index, 0);
if(cursor != NULL)
{
*data = cursor->data;
}
dlist_unlock(thiz);
return cursor != NULL ? RET_OK : RET_INVALID_PARAMS;
}
Ret dlist_delete(DList* thiz, size_t index)
{
Ret ret = RET_OK;
DListNode* cursor = NULL;
return_val_if_fail(thiz != NULL, RET_INVALID_PARAMS);
dlist_lock(thiz);
cursor = dlist_get_node(thiz, index, 0);
do
{
if(cursor == NULL)
{
ret = RET_INVALID_PARAMS;
break;
}
if(cursor != NULL)
{
if(cursor == thiz->first)
{
thiz->first = cursor->next;
}
if(cursor->next != NULL)
{
cursor->next->prev = cursor->prev;
}
if(cursor->prev != NULL)
{
cursor->prev->next = cursor->next;
}
dlist_destroy_node(thiz, cursor);
}
}while(0);
dlist_unlock(thiz);
return RET_OK;
}
Ret dlist_foreach(DList* thiz, DListDataVisitFunc visit, void* ctx)
{
Ret ret = RET_OK;
DListNode* iter = NULL;
return_val_if_fail(thiz != NULL && visit != NULL, RET_INVALID_PARAMS);
dlist_lock(thiz);
iter = thiz->first;
while(iter != NULL && ret != RET_STOP)
{
ret = visit(ctx, iter->data);
iter = iter->next;
}
dlist_unlock(thiz);
return ret;
}
size_t dlist_length(DList* thiz)
{
size_t length = 0;
DListNode* iter = NULL;
return_val_if_fail(thiz != NULL, 0);
dlist_lock(thiz);
iter = thiz->first;
while(iter != NULL)
{
length++;
iter = iter->next;
}
dlist_unlock(thiz);
return length;
}
void list_destroy(list_t * new_list)
{
list_node_t *iter = NULL;
list_node_t *next = NULL;
return_if_fail(new_list != NULL);
dlist_lock(new_list);
iter = new_list->head.next;
while (iter != &new_list->head) {
next = iter->next;
list_destroy_node(new_list, iter);
iter = next;
}
new_list->head.next = &new_list->head;
new_list->head.prev = &new_list->head;
dlist_destroy_locker(new_list);
SAFE_FREE(new_list);
return;
}
void dlist_destroy(DList* thiz)
{
DListNode* iter = NULL;
DListNode* next = NULL;
return_if_fail(thiz != NULL);
dlist_lock(thiz);
iter = thiz->first;
while(iter != NULL)
{
next = iter->next;
dlist_destroy_node(thiz, iter);
iter = next;
}
thiz->first = NULL;
dlist_destroy_locker(thiz);
SAFE_FREE(thiz);
return;
}
int dlist_find(DList* thiz, DListDataCompareFunc cmp, void* ctx)
{
int i = 0;
DListNode* iter = NULL;
return_val_if_fail(thiz != NULL && cmp != NULL, -1);
dlist_lock(thiz);
iter = thiz->first;
while(iter != NULL)
{
if(cmp(ctx, iter->data) == 0)
{
break;
}
i++;
iter = iter->next;
}
dlist_unlock(thiz);
return i;
}
static int server_cron(event_loop el, unsigned long id, void *data) {
dlist_iter_t iter;
dlist_node_t node;
NOT_USED(el);
NOT_USED(id);
NOT_USED(data);
if (log_reload) {
close_logger();
if (init_logger("/var/log/xcb/xcb-dp2.log", __LOG_DEBUG) == 0) {
const char *tmp;
pthread_mutex_lock(&cfg_lock);
if ((tmp = variable_retrieve(cfg, "general", "log_level"))) {
if (!strcasecmp(tmp, "debug"))
set_logger_level(__LOG_DEBUG);
else if (!strcasecmp(tmp, "info"))
set_logger_level(__LOG_INFO);
else if (!strcasecmp(tmp, "notice"))
set_logger_level(__LOG_NOTICE);
else if (!strcasecmp(tmp, "warning"))
set_logger_level(__LOG_WARNING);
}
pthread_mutex_unlock(&cfg_lock);
log_reload = 0;
}
/* FIXME */
if (addms)
table_clear(times);
}
if (shut_down) {
if (prepare_for_shutdown() == 0)
exit(0);
xcb_log(XCB_LOG_WARNING, "SIGTERM received, but errors trying to shutdown the server");
}
/* FIXME */
iter = dlist_iter_new(clients_to_close, DLIST_START_HEAD);
while ((node = dlist_next(iter))) {
client c = (client)dlist_node_value(node);
if (c->refcount == 0)
client_free(c);
}
dlist_iter_free(&iter);
/* FIXME */
if (cronloops % 200 == 0) {
char meme[] = "SU OT GNOLEB ERA ESAB RUOY LLA";
int status;
/* heartbeat */
dlist_lock(clients);
if (dlist_length(clients) > 0) {
dstr res = dstr_new("HEARTBEAT|");
dstr ip = getipv4();
res = dstr_cat(res, ip);
res = dstr_cat(res, "\r\n");
iter = dlist_iter_new(clients, DLIST_START_HEAD);
while ((node = dlist_next(iter))) {
client c = (client)dlist_node_value(node);
pthread_spin_lock(&c->lock);
if (net_try_write(c->fd, res, dstr_length(res), 100, NET_NONBLOCK) == -1)
xcb_log(XCB_LOG_WARNING, "Writing to client '%p': %s",
c, strerror(errno));
pthread_spin_unlock(&c->lock);
}
dlist_iter_free(&iter);
dstr_free(ip);
dstr_free(res);
}
dlist_unlock(clients);
/* FIXME: trying to lower the high CPU load while idle */
if ((status = pgm_send(pgm_sender, meme, sizeof meme, NULL)) != PGM_IO_STATUS_NORMAL)
xcb_log(XCB_LOG_WARNING, "Communication test failed");
}
++cronloops;
return 100;
}
