static void hub_event_dispatcher(void* callback_data, struct event_data* message)
{
struct hub_info* hub = (struct hub_info*) callback_data;
struct hub_user* user = (struct hub_user*) message->ptr;
assert(hub != NULL);
switch (message->id)
{
case UHUB_EVENT_USER_JOIN:
{
if (user_is_disconnecting(user))
break;
if (message->flags)
{
hub_send_password_challenge(hub, user);
}
else
{
on_login_success(hub, user);
}
break;
}
case UHUB_EVENT_USER_QUIT:
{
uman_remove(hub, user);
uman_send_quit_message(hub, user);
on_logout_user(hub, user);
hub_schedule_destroy_user(hub, user);
break;
}
case UHUB_EVENT_USER_DESTROY:
{
user_destroy(user);
break;
}
case UHUB_EVENT_HUB_SHUTDOWN:
{
struct hub_user* u = (struct hub_user*) list_get_first(hub->users->list);
while (u)
{
uman_remove(hub, u);
user_destroy(u);
u = (struct hub_user*) list_get_first(hub->users->list);
}
break;
}
default:
/* FIXME: ignored */
break;
}
}
void plugin_shutdown(struct uhub_plugins* handle)
{
struct plugin_handle* plugin = (struct plugin_handle*) list_get_first(handle->loaded);
while (plugin)
{
list_remove(handle->loaded, plugin);
plugin_unload(plugin);
plugin = (struct plugin_handle*) list_get_first(handle->loaded);
}
list_destroy(handle->loaded);
}
main()
{
DynamicList* l = list_inicialize();
/*Aluno* Al1 = (Aluno*)malloc(sizeof(Aluno));
Aluno* Al2 = (Aluno*)malloc(sizeof(Aluno));
Al1->RA = 1516;
Al1->nome = "JOAO";
Al2->RA = 2324;
Al2->nome = "SIBA";
*/
printf("\nInseriu? %s", list_add_last(l, 'a')?"sim":"não");
printf("\nInseriu? %s", list_add_last(l, 'b')?"sim":"não");
printf("\nFirst %c\n", list_get_first(l));
printf("\nLast %c\n", list_get_last(l));
printf("\nInseriu? %s", list_add_last(l, 'c')?"sim":"não");
printf("\nInseriu? %s", list_add_last(l, 'd')?"sim":"não");
printf("\nInseriu? %s", list_add_first(l, 'e')?"sim":"não");
printf("\nInseriu? %s", list_add_first(l, 'f')?"sim":"não");
printf("\nInseriu? %s", list_add_first(l, 'g')?"sim":"não");
printf("\nFirst %c\n", list_get_first(l));
printf("\nLast %c\n", list_get_last(l));
list_print(l);
printf("\nSize %d\n", list_size(l));
list_clear(l);
printf("\nSize %d\n", list_size(l));
printf("\nInseriu? %s", list_add_last(l, 'c')?"sim":"não");
printf("\nInseriu? %s", list_add_last(l, 'd')?"sim":"não");
printf("\nInseriu? %s", list_add_first(l, 'e')?"sim":"não");
printf("\nInseriu? %s", list_add_first(l, 'f')?"sim":"não");
printf("\nInseriu? %s", list_add_first(l, 'g')?"sim":"não");
list_print(l);
list_remove_first(l);
list_remove_first(l);
list_remove_first(l);
list_print(l);
}
int route_to_subscribers(struct hub_info* hub, struct adc_message* command) /* iterate users */
{
int do_send;
char* tmp;
struct hub_user* user = (struct hub_user*) list_get_first(hub->users->list);
while (user)
{
if (user->feature_cast)
{
do_send = 1;
tmp = list_get_first(command->feature_cast_include);
while (tmp)
{
if (!user_have_feature_cast_support(user, tmp))
{
do_send = 0;
break;
}
tmp = list_get_next(command->feature_cast_include);;
}
if (!do_send) {
user = (struct hub_user*) list_get_next(hub->users->list);
continue;
}
tmp = list_get_first(command->feature_cast_exclude);
while (tmp)
{
if (user_have_feature_cast_support(user, tmp))
{
do_send = 0;
break;
}
tmp = list_get_next(command->feature_cast_exclude);
}
if (do_send)
{
route_to_user(hub, user, command);
}
}
user = (struct hub_user*) list_get_next(hub->users->list);
}
return 0;
}
list_t * list_delete(list_t *li, void *data)
{
if(!li)
return NULL;
list_t *i = li;
if(data) {
i = list_get_first(li);
while(i) {
if(data == list_get_data(i))
break;
i = i->next;
}
if(!i)
return li;
}
list_t *r = NULL;
if(i->next) {
i->next->prev = i->prev;
r = i->next;
}
if(i->prev) {
i->prev->next = i->next;
r = i->prev;
}
free(i);
return r;
}
void jabber_mam_process(JabberStream *js, const char* after)
{
if (!js->mam)
return;
if (js->mam->current && js->mam->current->completed) {
free(js->mam->current->start);
free(js->mam->current->end);
free(js->mam->current->with);
memset(js->mam->last_timestamp, 0, 32);
free(js->mam->current);
js->mam->current = NULL;
}
if (!js->mam->current) {
list_t *queue_item = list_get_first(js->mam->queue);
if (queue_item) {
js->mam->queue = list_delete(js->mam->queue, queue_item);
js->mam->current = list_get_data(queue_item);
js->mam->queue = list_get_next(js->mam->queue);
}
}
if (js->mam->current)
jabber_mam_request(js, after);
}
static int Update_Analog_Input_Read_Property(BACNET_READ_PROPERTY_DATA *rpdata)
{
static int index;
word_object *object;
int instance_no = bacnet_Analog_Input_Instance_To_Index(rpdata -> object_instance);
if(rpdata->object_property != bacnet_PROP_PRESENT_VALUE)
{
goto not_pv;
}
pthread_mutex_lock(&list_lock);
if(list_heads[instance_no] == NULL)
{
pthread_mutex_unlock(&list_lock);
goto not_pv;
}
object = list_get_first(&list_heads[instance_no]);
pthread_mutex_unlock(&list_lock);
printf("AI_Present_Value request for instance %i\n", instance_no);
//bacnet_Analog_Input_Present_Value_Set(0, 20); // For testing and debugging purposes only
printf("-------------- %i:%04X\n", instance_no, object->value);
bacnet_Analog_Input_Present_Value_Set(instance_no, object->value);
free(object);
not_pv:
return bacnet_Analog_Input_Read_Property(rpdata);
}
/** get item from specific position
*/
void* list_get (linked_list* _this, int position) {
// list is empty
if (_this->size == 0) {
//NODE_DBG("LinkedList#get: The list is empty.");
return NULL;
} else if (position >= _this->size) {
// out of bound
//NODE_DBG("LinkedList#get: Index out of bound");
return NULL;
}
// get head item
if (position == 0) {
return list_get_first(_this);
} else if (position+1 == _this->size) {
// get tail item
return list_get_last(_this);
} else {
node* node = _this->head;
int i = 0;
// loop until position
while (i < position) {
node = node->next;
i++;
}
return node->item;
}
}
static void *print_func(void *arg) {
word_object *current_object;
fprintf(stderr, "Print thread starting\n");
while(1) {
pthread_mutex_lock(&list_lock);
while (list_head == NULL) {
pthread_cond_wait(&list_data_ready, &list_lock);
}
current_object = list_get_first();
pthread_mutex_unlock(&list_lock);
/* make sure that list_lock is released first-
printf() and free() can block*/
printf ("Print thread: %s\n", current_object->word);
free(current_object->word);
free(current_object);
/* Let list flush() know that we've done work */
pthread_cond_signal(&list_data_flush);
}
/* Silence compiler warning */
return arg;
}
static int command_patternadd(struct plugin_handle* plugin, struct plugin_user* user, struct plugin_command* cmd)
{
struct patterns_data* pdata = (struct patterns_data*) plugin->ptr;
struct cbuffer* buf = cbuf_create(128);
struct plugin_command_arg_data* arg1 = (struct plugin_command_arg_data*) list_get_first(cmd->args);
struct plugin_command_arg_data* arg2 = (struct plugin_command_arg_data*) list_get_next(cmd->args);
struct plugin_command_arg_data* arg3 = (struct plugin_command_arg_data*) list_get_next(cmd->args);
struct plugin_command_arg_data* arg4 = (struct plugin_command_arg_data*) list_get_next(cmd->args);
char* t = arg1->data.string;
enum pattern_types type;
if (!pattern_string_to_type(t, &type))
{
cbuf_append_format(buf, "*** %s: Wrong pattern type \"%s\". Available types are: MC, PM, NI, UA.", cmd->prefix, t);
}
else
{
enum auth_credentials mincred = arg2->data.credentials;
enum auth_credentials maxcred = arg3->data.credentials;
char* str = arg4->data.string;
int rc = sql_execute(pdata, null_callback, NULL, "INSERT INTO patterns VALUES(NULL, '%s', %d, '%s', '%s');", sql_escape_string(str), type, auth_cred_to_string(mincred), auth_cred_to_string(maxcred));
if (rc > 0)
cbuf_append_format(buf, "*** %s: Added pattern \"%s\" to %s group.", cmd->prefix, str, pattern_type_to_string(type));
else
cbuf_append_format(buf, "*** %s: Unable to add pattern \"%s\".", cmd->prefix, str);
}
plugin->hub.send_message(plugin, user, cbuf_get(buf));
cbuf_destroy(buf);
return 0;
}
static int command_patternexadd(struct plugin_handle* plugin, struct plugin_user* user, struct plugin_command* cmd)
{
struct patterns_data* pdata = (struct patterns_data*) plugin->ptr;
struct cbuffer* buf = cbuf_create(128);
struct plugin_command_arg_data* arg1 = (struct plugin_command_arg_data*) list_get_first(cmd->args);
struct plugin_command_arg_data* arg2 = (struct plugin_command_arg_data*) list_get_next(cmd->args);
struct plugin_command_arg_data* arg3 = (struct plugin_command_arg_data*) list_get_next(cmd->args);
struct plugin_command_arg_data* arg4 = (struct plugin_command_arg_data*) list_get_next(cmd->args);
int pattern_id = arg1->data.integer;
enum auth_credentials mincred = arg2->data.credentials;
enum auth_credentials maxcred = arg3->data.credentials;
char* str = arg4->data.string;
int rc = sql_execute(pdata, null_callback, NULL, "PRAGMA foreign_keys=ON; INSERT INTO pattern_exceptions VALUES(NULL, '%s', %d, '%s', '%s');", sql_escape_string(str), pattern_id, auth_cred_to_string(mincred), auth_cred_to_string(maxcred));
if (rc > 0)
cbuf_append_format(buf, "*** %s: Added pattern exception \"%s\" to pattern ID %d.", cmd->prefix, str, pattern_id);
else
cbuf_append_format(buf, "*** %s: Unable to add pattern exception \"%s\" to pattern ID %d.", cmd->prefix, str, pattern_id);
plugin->hub.send_message(plugin, user, cbuf_get(buf));
cbuf_destroy(buf);
return 0;
}
/**
* Obtain 'num' messages from the chat history and append them to outbuf.
*
* @return the number of messages added to the buffer.
*/
static size_t get_messages(struct chat_history_data* data, size_t num, struct cbuffer* outbuf)
{
struct linked_list* messages = data->chat_history;
char* message;
int skiplines = 0;
size_t lines = 0;
size_t total = list_size(messages);
if (total == 0)
return 0;
if (num <= 0 || num > total)
num = total;
if (num != total)
skiplines = total - num;
cbuf_append(outbuf, "\n");
message = (char*) list_get_first(messages);
while (message)
{
if (--skiplines < 0)
{
cbuf_append(outbuf, message);
lines++;
}
message = (char*) list_get_next(messages);
}
cbuf_append(outbuf, "\n");
return lines;
}
int uman_send_user_list(struct hub_info* hub, struct hub_user* target)
{
int ret = 1;
struct hub_user* user;
user_flag_set(target, flag_user_list);
user = (struct hub_user*) list_get_first(hub->users->list); /* iterate users - only on INF or PAS msg */
while (user)
{
if (user_is_logged_in(user))
{
ret = route_to_user(hub, target, user->info);
if (!ret)
break;
}
user = (struct hub_user*) list_get_next(hub->users->list);
}
#if 0
FIXME: FIXME FIXME handle send queue excess
if (!target->send_queue_size)
{
user_flag_unset(target, flag_user_list);
}
#endif
return ret;
}
int route_info_message(struct hub_info* hub, struct hub_user* u)
{
if (!user_is_nat_override(u))
{
return route_to_all(hub, u->info);
}
else
{
struct adc_message* cmd = adc_msg_copy(u->info);
const char* address = user_get_address(u);
struct hub_user* user = 0;
adc_msg_remove_named_argument(cmd, ADC_INF_FLAG_IPV4_ADDR);
adc_msg_add_named_argument(cmd, ADC_INF_FLAG_IPV4_ADDR, address);
user = (struct hub_user*) list_get_first(hub->users->list);
while (user)
{
if (user_is_nat_override(user))
route_to_user(hub, user, cmd);
else
route_to_user(hub, user, u->info);
user = (struct hub_user*) list_get_next(hub->users->list);
}
adc_msg_free(cmd);
}
return 0;
}
int route_to_all(struct hub_info* hub, struct adc_message* command) /* iterate users */
{
struct hub_user* user = (struct hub_user*) list_get_first(hub->users->list);
while (user)
{
route_to_user(hub, user, command);
user = (struct hub_user*) list_get_next(hub->users->list);
}
return 0;
}
struct hub_user* uman_get_user_by_nick(struct hub_info* hub, const char* nick)
{
struct hub_user* user = (struct hub_user*) list_get_first(hub->users->list); /* iterate users - only on incoming INF msg */
while (user)
{
if (strcmp(user->id.nick, nick) == 0)
return user;
user = (struct hub_user*) list_get_next(hub->users->list);
}
return NULL;
}
int event_queue_process(struct event_queue* queue)
{
struct event_data* data;
if (queue->locked)
return 0;
/* lock primary queue, and handle the primary queue messages. */
queue->locked = 1;
data = (struct event_data*) list_get_first(queue->q1);
while (data)
{
#ifdef EQ_DEBUG
eq_debug("EXEC", data);
#endif
queue->callback(queue->callback_data, data);
data = (struct event_data*) list_get_next(queue->q1);
}
list_clear(queue->q1, event_queue_cleanup_callback);
uhub_assert(list_size(queue->q1) == 0);
/* unlock queue */
queue->locked = 0;
/* transfer from secondary queue to the primary queue. */
data = (struct event_data*) list_get_first(queue->q2);
while (data)
{
list_remove(queue->q2, data);
list_append(queue->q1, data);
data = (struct event_data*) list_get_first(queue->q2);
}
/* if more events exist, schedule it */
if (list_size(queue->q1))
{
return 1;
}
return 0;
}
/** get item from tail
*/
void* list_get_last (linked_list* _this) {
// list is empty
if (_this->size == 0) {
//NODE_DBG("LinkedList#getLast: The list is empty.");
return NULL;
}
// only head node
if (_this->size == 1) {
return list_get_first(_this);
}
return _this->tail->item;
}
int user_have_feature_cast_support(struct hub_user* user, char feature[4])
{
char* tmp = list_get_first(user->feature_cast);
while (tmp)
{
if (strncmp(tmp, feature, 4) == 0)
return 1;
tmp = list_get_next(user->feature_cast);
}
return 0;
}
int main(void)
{
int i;
int ret;
t_list * list = list_init();
if (list == NULL)
return 1;
for (i = 0; i < NUM; i++) {
tab_item_ptr[i] = &tab_item[i];
}
for (i = 0; i < NUM; i++) {
ret = list_insert_last(list, tab_item_ptr[i]);
if (ret != LIST_OP_OK)
fprintf(stderr, "CHYBA\n");
}
printf("LIST\n");
for (i = 0; i < NUM; i++) {
printf("%d: %x\n", i, list_get_first(list));
list_free_first(list);
}
for (i = 0; i < NUM; i++) {
printf("%d: %x\n", i, list_get_first(list));
list_free_first(list);
}
list_free(list);
printf("%x\n", list);
return 0;
}
size_t uman_get_user_by_addr(struct hub_info* hub, struct linked_list* users, struct ip_range* range)
{
size_t num = 0;
struct hub_user* user = (struct hub_user*) list_get_first(hub->users->list); /* iterate users - only on incoming INF msg */
while (user)
{
if (ip_in_range(&user->id.addr, range))
{
list_append(users, user);
num++;
}
user = (struct hub_user*) list_get_next(hub->users->list);
}
return num;
}
int acl_is_ip_nat_override(struct acl_handle* handle, const char* ip_address)
{
struct ip_addr_encap raw;
struct ip_range* info = (struct ip_range*) list_get_first(handle->nat_override);
ip_convert_to_binary(ip_address, &raw);
while (info)
{
if (ip_in_range(&raw, info))
{
return 1;
}
info = (struct ip_range*) list_get_next(handle->nat_override);
}
return 0;
}
void hub_chat_history_add(struct hub_info* hub, struct hub_user* user, struct adc_message* cmd)
{
char* msg_esc = adc_msg_get_argument(cmd, 0);
char* message = adc_msg_unescape(msg_esc);
char* log = hub_malloc(strlen(message) + strlen(user->id.nick) + 14);
sprintf(log, "%s <%s> %s\n", get_timestamp(time(NULL)), user->id.nick, message);
list_append(hub->chat_history, log);
while (list_size(hub->chat_history) > (size_t) hub->config->max_chat_history)
{
char* msg = list_get_first(hub->chat_history);
list_remove(hub->chat_history, msg);
hub_free(msg);
}
hub_free(message);
hub_free(msg_esc);
}
/**
* Add a chat message to history.
*/
static void history_add(struct plugin_handle* plugin, struct plugin_user* from, const char* message, int flags)
{
size_t loglen = strlen(message) + strlen(from->nick) + 13;
struct chat_history_data* data = (struct chat_history_data*) plugin->ptr;
char* log = hub_malloc(loglen + 1);
snprintf(log, loglen, "%s <%s> %s\n", get_timestamp(time(NULL)), from->nick, message);
log[loglen] = '\0';
list_append(data->chat_history, log);
while (list_size(data->chat_history) > data->history_max)
{
char* msg = list_get_first(data->chat_history);
list_remove(data->chat_history, msg);
hub_free(msg);
}
}
static plugin_st get_user(struct plugin_handle* plugin, const char* nickname, struct auth_info* data)
{
struct acl_data* acl = (struct acl_data*) plugin->ptr;
struct auth_info* info = (struct auth_info*) list_get_first(acl->users);
while (info)
{
if (strcasecmp((char*)info->nickname, nickname) == 0)
{
memcpy(data, info, sizeof(struct auth_info));
return st_allow;
}
info = (struct auth_info*) list_get_next(acl->users);
}
if (acl->exclusive)
return st_deny;
return st_default;
}
void jabber_mam_clear(mam_t *mam)
{
if (mam)
return;
list_t *queue_item = list_get_first(mam->queue);
while (queue_item) {
mam_item_t *mam_item = list_get_data(queue_item);
free(mam_item->start);
free(mam_item->end);
free(mam_item->with);
free(mam_item);
queue_item = list_get_next(queue_item);
}
}
void hub_logout_log(struct hub_info* hub, struct hub_user* user)
{
struct hub_logout_info* loginfo = hub_malloc_zero(sizeof(struct hub_logout_info));
if (!loginfo) return;
loginfo->time = time(NULL);
strcpy(loginfo->cid, user->id.cid);
strcpy(loginfo->nick, user->id.nick);
memcpy(&loginfo->addr, &user->id.addr, sizeof(struct ip_addr_encap));
loginfo->reason = user->quit_reason;
list_append(hub->logout_info, loginfo);
while (list_size(hub->logout_info) > (size_t) hub->config->max_logout_log)
{
struct hub_logout_info* entry = list_get_first(hub->logout_info);
list_remove(hub->logout_info, entry);
hub_free(entry);
}
}
static int command_newsadd(struct plugin_handle* plugin, struct plugin_user* user, struct plugin_command* cmd)
{
struct extras_data* extrasdata = (struct extras_data*) plugin->ptr;
struct cbuffer* buf = cbuf_create(128);
struct plugin_command_arg_data* arg1 = (struct plugin_command_arg_data*) list_get_first(cmd->args);
const char* news_text = sql_escape_string(arg1->data.string);
int rc = sql_execute(extrasdata, null_callback, NULL, "INSERT INTO news (id, text) VALUES(NULL, '%s');", news_text);
if (rc > 0)
cbuf_append_format(buf, "*** %s: News updated.", cmd->prefix);
else
cbuf_append_format(buf, "*** %s: Unable to update news.", cmd->prefix);
plugin->hub.send_message(plugin, user, cbuf_get(buf));
cbuf_destroy(buf);
return 0;
}
static int command_patternexdel(struct plugin_handle* plugin, struct plugin_user* user, struct plugin_command* cmd)
{
struct patterns_data* pdata = (struct patterns_data*) plugin->ptr;
struct cbuffer* buf = cbuf_create(128);
struct plugin_command_arg_data* args = (struct plugin_command_arg_data*) list_get_first(cmd->args);
int id = args->data.integer;
int rc = sql_execute(pdata, null_callback, NULL, "DELETE FROM pattern_exceptions WHERE id=%d;", id);
if (rc > 0)
cbuf_append_format(buf, "*** %s: Deleted pattern exception with ID %d.", cmd->prefix, id);
else
cbuf_append_format(buf, "*** %s: Unable to delete pattern exception with id %d.", cmd->prefix, id);
plugin->hub.send_message(plugin, user, cbuf_get(buf));
cbuf_destroy(buf);
return 0;
}
static int command_patterntest(struct plugin_handle* plugin, struct plugin_user* user, struct plugin_command* cmd)
{
struct patterns_data* pdata = (struct patterns_data*) plugin->ptr;
struct cbuffer* buf = cbuf_create(128);
struct plugin_command_arg_data* arg1 = (struct plugin_command_arg_data*) list_get_first(cmd->args);
struct plugin_command_arg_data* arg2 = (struct plugin_command_arg_data*) list_get_next(cmd->args);
int id = arg1->data.integer;
char* str = arg2->data.string;
sqlite3_stmt *res;
int error = 0;
const char *tail;
char query[80];
cbuf_append_format(buf, "*** %s: ", cmd->prefix);
int n = sprintf(query, "SELECT regexp FROM patterns WHERE id=%d LIMIT 1;", id);
error = sqlite3_prepare_v2(pdata->db, query, n, &res, &tail);
if (sqlite3_step(res) == SQLITE_ROW)
{
if(pattern_match(str, (char*) sqlite3_column_text(res, 0)))
cbuf_append_format(buf, "Tested string \"%s\" matches pattern \"%s\".", str, sqlite3_column_text(res, 0));
else
cbuf_append_format(buf, "Tested string \"%s\" does not match pattern \"%s\".", str, sqlite3_column_text(res, 0));
}
else
{
cbuf_append_format(buf, "Pattern ID \"%d\" not found.", id);
}
sqlite3_finalize(res);
plugin->hub.send_message(plugin, user, cbuf_get(buf));
cbuf_destroy(buf);
return 0;
}
