n_user.c

Go to the documentation of this file.

/*
 * Nilorea Library
 * Copyright (C) 2005-2026 Castagnier Mickael
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#include "nilorea/n_user.h"
 
N_USERLIST* userlist_new(int max) {
    N_USERLIST* ulist = NULL;
    __n_assert(max > 0, return NULL);
    Malloc(ulist, N_USERLIST, 1);
    __n_assert(ulist, return NULL);
 
    Malloc(ulist->list, N_USER, (size_t)max);
    __n_assert(ulist->list, Free(ulist); return NULL);
 
    ulist->max = max;
    ulist->highter = -1;
    for (int it = 0; it < max; it++) {
        ulist->list[it].state = 0;
        ulist->list[it].nb_rec_pos = 10;
        ulist->list[it].only_last_pos = 1;
        ulist->list[it].id = -1;
        Malloc(ulist->list[it].last_positions, VECTOR3D, 10);
        ulist->list[it].netw_waitlist = new_generic_list(MAX_LIST_ITEMS);
        memset(ulist->list[it].position, 0, 3 * sizeof(double));
        ulist->list[it].netw = NULL;
        memset(ulist->list[it].name, 0, 1024);
        ulist->list[it].netw = NULL;
    }
 
    init_lock(ulist->user_rwbolt);
 
    return ulist;
} /* userlist_new() */
 
int userlist_set_position_behavior(N_USERLIST* ulist, int id, int nb_rec_pos, int only_last_pos) {
    __n_assert(ulist, return FALSE);
    /* nb_rec_pos must be at least 1 */
    if (nb_rec_pos < 1) return FALSE;
    /* only_last_pos is a boolean: 0 or 1 */
    if (only_last_pos < 0 || only_last_pos > 1) return FALSE;
 
    read_lock(ulist->user_rwbolt);
    if (id < 0 || id >= ulist->max) {
        unlock(ulist->user_rwbolt);
        return FALSE;
    }
    /* user slot must be active */
    if (ulist->list[id].state == 0) {
        unlock(ulist->user_rwbolt);
        return FALSE;
    }
    unlock(ulist->user_rwbolt);
 
    write_lock(ulist->user_rwbolt);
    ulist->list[id].nb_rec_pos = nb_rec_pos;
    ulist->list[id].only_last_pos = only_last_pos;
    if (only_last_pos) {
        if (Realloc(ulist->list[id].last_positions, VECTOR3D, 1) == FALSE) {
            n_log(LOG_ERR, "could not resize to only_last_pos VECTOR3D");
            unlock(ulist->user_rwbolt);
            return FALSE;
        }
    } else {
        if (Realloc(ulist->list[id].last_positions, VECTOR3D, (size_t)nb_rec_pos) == FALSE) {
            n_log(LOG_ERR, "could not resize to %d VECTOR3D", nb_rec_pos);
            unlock(ulist->user_rwbolt);
            return FALSE;
        }
        /* nb_rec_pos is already set correctly above; do not overwrite it */
    }
    unlock(ulist->user_rwbolt);
 
    return TRUE;
} /* userlist_set_position_behavior() */
 
int userlist_add_user(N_USERLIST* ulist, NETWORK* netw) {
    __n_assert(ulist, return -1);
    __n_assert(netw, return -1);
 
    int it = -1;
    write_lock(ulist->user_rwbolt);
    do {
        it++;
    } while (it < ulist->max && ulist->list[it].state != 0);
    if (it < ulist->max) {
        ulist->list[it].state = 1;
        ulist->list[it].netw = netw;
        if (it > ulist->highter)
            ulist->highter = it;
        unlock(ulist->user_rwbolt);
        return it;
    }
    unlock(ulist->user_rwbolt);
    return -1;
} /* userlist_add_user() */
 
int userlist_del_user(N_USERLIST* ulist, int id) {
    __n_assert(ulist, return FALSE);
    __n_assert(id >= 0, return FALSE);
 
    write_lock(ulist->user_rwbolt);
    if (id >= ulist->max) {
        unlock(ulist->user_rwbolt);
        return FALSE;
    }
    if (ulist->list[id].state == 0) {
        unlock(ulist->user_rwbolt);
        return FALSE;
    }
    ulist->list[id].state = 0;
    ulist->list[id].nb_rec_pos = 1;
    ulist->list[id].only_last_pos = 1;
    ulist->list[id].id = -1;
    if (Realloc(ulist->list[id].last_positions, VECTOR3D, 1) == FALSE) {
        n_log(LOG_ERR, "couldn't resize to 1 element");
    }
    list_empty(ulist->list[id].netw_waitlist);
    memset(ulist->list[id].position, 0, 3 * sizeof(double));
    ulist->list[id].netw = NULL;
    memset(ulist->list[id].name, 0, 1024);
 
    if (id >= ulist->highter) {
        int it = id;
        while (it >= 0) {
            if (ulist->list[it].state == 1) {
                ulist->highter = it;
                break;
            }
            it--;
        }
        if (it < 0) ulist->highter = -1;
    }
    unlock(ulist->user_rwbolt);
    return TRUE;
} /* userlist_del_user() */
 
int userlist_add_msg_to_ex(N_USERLIST* ulist, N_STR* msg, int mode, int id) {
    __n_assert(ulist, return FALSE);
    __n_assert(msg, return FALSE);
 
    switch (mode) {
        case (USERLIST_ALL):
            read_lock(ulist->user_rwbolt);
            for (int it = 0; it <= ulist->highter; it++) {
                if (ulist->list[it].state == 1)
                    netw_add_msg(ulist->list[it].netw, nstrdup(msg));
            }
            unlock(ulist->user_rwbolt);
            break;
        case (USERLIST_ALL_EXCEPT):
            __n_assert(id >= 0, return FALSE);
            read_lock(ulist->user_rwbolt);
            for (int it = 0; it <= ulist->highter; it++) {
                if (it == id)
                    continue;
                if (ulist->list[it].state == 1)
                    netw_add_msg(ulist->list[it].netw, nstrdup(msg));
            }
            unlock(ulist->user_rwbolt);
            break;
        default:
        case (USERLIST_ONE):
            __n_assert(id >= 0, return FALSE);
 
            read_lock(ulist->user_rwbolt);
            netw_add_msg(ulist->list[id].netw, msg);
            unlock(ulist->user_rwbolt);
            break;
    }
    return TRUE;
} /* userlist_add_msg_to_ex() */
 
int userlist_add_msg_to(N_USERLIST* ulist, N_STR* msg, int id) {
    return userlist_add_msg_to_ex(ulist, msg, USERLIST_ONE, id);
} /* userlist_add_msg_to() */
 
int userlist_add_msg_to_all(N_USERLIST* ulist, N_STR* msg) {
    return userlist_add_msg_to_ex(ulist, msg, USERLIST_ALL, -1);
} /* userlist_add_msg_to_all() */
 
int userlist_add_msg_to_all_except(N_USERLIST* ulist, N_STR* msg, int id) {
    return userlist_add_msg_to_ex(ulist, msg, USERLIST_ALL_EXCEPT, id);
} /* userlist_add_msg_to_all_except() */
 
int userlist_destroy(N_USERLIST** ulist) {
    __n_assert(ulist && (*ulist), return FALSE);
 
    write_lock((*ulist)->user_rwbolt);
    for (int it = 0; it < (*ulist)->max; it++) {
        Free((*ulist)->list[it].last_positions);
        list_destroy(&(*ulist)->list[it].netw_waitlist);
    }
    Free((*ulist)->list);
    unlock((*ulist)->user_rwbolt);
 
    pthread_rwlock_destroy(&(*ulist)->user_rwbolt);
    Free((*ulist));
 
    return TRUE;
} /* userlist_destroy() */
 
int userlist_user_add_waiting_msg(N_USERLIST* ulist, int id, N_STR* netmsg) {
    __n_assert(ulist, return FALSE);
    __n_assert(netmsg, return FALSE);
    __n_assert(id >= 0, return FALSE);
 
    int ret = FALSE;
 
    write_lock(ulist->user_rwbolt);
    if (id <= ulist->highter) {
        if (ulist->list[id].state == 1) {
            ret = list_push(ulist->list[id].netw_waitlist, netmsg, NULL);
        }
    }
    unlock(ulist->user_rwbolt);
    return ret;
} /* userlist_user_add_waiting_msg() */
 
int userlist_user_send_waiting_msgs(N_USERLIST* ulist, int id) {
    __n_assert(ulist, return FALSE);
    __n_assert(id >= 0, return FALSE);
 
    write_lock(ulist->user_rwbolt);
    if (id <= ulist->highter) {
        if (ulist->list[id].state == 1) {
            list_foreach(node, ulist->list[id].netw_waitlist) {
                N_STR* netmsg = (N_STR*)node->ptr;
                netw_add_msg(ulist->list[id].netw, netmsg);
            }
            list_empty(ulist->list[id].netw_waitlist);
        }
    }
    unlock(ulist->user_rwbolt);
    return TRUE;
} /* userlist_user_send_waiting_msgs() */
 
int userlist_send_waiting_msgs(N_USERLIST* ulist) {
    __n_assert(ulist, return FALSE);
 
    write_lock(ulist->user_rwbolt);
    for (int id = 0; id <= ulist->highter; id++) {
        if (ulist->list[id].state == 1) {
            list_foreach(node, ulist->list[id].netw_waitlist) {
                N_STR* netmsg = (N_STR*)node->ptr;
                netw_add_msg(ulist->list[id].netw, netmsg);
            }
            list_empty(ulist->list[id].netw_waitlist);
        }
    }
    unlock(ulist->user_rwbolt);
    return TRUE;
} /* userlist_send_waiting_msgs() */