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;
}
}
// -----------------------------------------------------------------------------
// Client management functions
// -----------------------------------------------------------------------------
void *client_handler(void *args){
//Recover parameters
fprintf(stdout, "New client request.\n");
struct thread_info *tinfo = (struct thread_info*)args;
char buff[MSG_MAX_SIZE];
//Create the new client user
ServerData *server = tinfo->server;
User *user = user_create("new_user");
if(user == NULL){
fprintf(stderr, "Unable to create the user for socket %d\n", tinfo->socket);
pthread_exit(NULL);
}
user->socket = tinfo->socket;
//Listen for message
while(server->is_working == 1 && user->connected == 1){
//TODO CRIT: Add exit process
memset(buff, 0x00, sizeof(buff));
recv(user->socket, buff, MSG_MAX_SIZE, 0);
messaging_server_exec_receive(server, user, buff);
}
//Free data
fprintf(stdout, "Client deconnected\n");
user_destroy(user);
}
void poldiff_destroy(poldiff_t ** diff)
{
if (!diff || !(*diff))
return;
apol_policy_destroy(&(*diff)->orig_pol);
apol_policy_destroy(&(*diff)->mod_pol);
apol_bst_destroy(&(*diff)->class_bst);
apol_bst_destroy(&(*diff)->perm_bst);
apol_bst_destroy(&(*diff)->bool_bst);
type_map_destroy(&(*diff)->type_map);
attrib_summary_destroy(&(*diff)->attrib_diffs);
poldiff_avrule_destroy(&(*diff)->avrule_diffs[AVRULE_OFFSET_ALLOW]);
poldiff_avrule_destroy(&(*diff)->avrule_diffs[AVRULE_OFFSET_AUDITALLOW]);
poldiff_avrule_destroy(&(*diff)->avrule_diffs[AVRULE_OFFSET_DONTAUDIT]);
poldiff_avrule_destroy(&(*diff)->avrule_diffs[AVRULE_OFFSET_NEVERALLOW]);
bool_destroy(&(*diff)->bool_diffs);
cat_destroy(&(*diff)->cat_diffs);
class_destroy(&(*diff)->class_diffs);
common_destroy(&(*diff)->common_diffs);
level_destroy(&(*diff)->level_diffs);
range_trans_destroy(&(*diff)->range_trans_diffs);
role_destroy(&(*diff)->role_diffs);
role_allow_destroy(&(*diff)->role_allow_diffs);
role_trans_destroy(&(*diff)->role_trans_diffs);
user_destroy(&(*diff)->user_diffs);
terule_destroy(&(*diff)->terule_diffs[TERULE_OFFSET_CHANGE]);
terule_destroy(&(*diff)->terule_diffs[TERULE_OFFSET_MEMBER]);
terule_destroy(&(*diff)->terule_diffs[TERULE_OFFSET_TRANS]);
type_summary_destroy(&(*diff)->type_diffs);
free(*diff);
*diff = NULL;
}
static gboolean users_gc_hash_func(gpointer key,gpointer value,gpointer udata){
User *u=(User *)value;
if (u->refcount==0) {
user_destroy(u);
g_free(key);
}
return TRUE;
}
void user_disconnect(user_t *user) {
if (user) {
//update user list
for (vector<user_t*>::iterator iter = user_vec.begin(); iter != user_vec.end(); ++iter) {
if (*iter == user) {
user_vec.erase(iter);
break;
}
}
user_destroy(user);
}
LOG("now, %d users connecting", user_vec.size());
}
/*
* This callback function is used to clear user objects from the userlist.
* Should only be used in uman_shutdown().
*/
static void clear_user_list_callback(void* ptr)
{
if (ptr)
{
struct hub_user* u = (struct hub_user*) ptr;
/* Mark the user as already being disconnected.
* This prevents the hub from trying to send
* quit messages to other users.
*/
u->credentials = auth_cred_none;
user_destroy(u);
}
}
int user_free(User *u){
gpointer key,value;
char *njid;
g_assert(u->refcount==0);
g_assert(users_jid!=NULL);
njid=jid_normalized(u->jid,0);
g_assert(njid!=NULL);
if (g_hash_table_lookup_extended(users_jid,(gpointer)njid,&key,&value)){
g_assert(u==value);
g_hash_table_remove(users_jid,(gpointer)njid);
g_free(key);
}
else debug(L_("user_remove: user '%s' not found in hash table"),njid);
g_free(njid);
return user_destroy(u);
}
static void hub_event_dispatcher(void* callback_data, struct event_data* message)
{
int status;
struct hub_info* hub = (struct hub_info*) callback_data;
struct hub_user* user = (struct hub_user*) message->ptr;
uhub_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
{
/* Race condition, we could have two messages for two logins queued up.
So make sure we don't let the second client in. */
status = check_duplicate_logins_ok(hub, user);
if (!status)
{
on_login_success(hub, user);
}
else
{
on_login_failure(hub, user, (enum status_message) status);
}
}
break;
}
case UHUB_EVENT_USER_QUIT:
{
uman_remove(hub->users, user);
uman_send_quit_message(hub, hub->users, 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->users, u);
user_destroy(u);
u = (struct hub_user*) list_get_first(hub->users->list);
}
break;
}
default:
/* FIXME: ignored */
break;
}
}
