n_network_msg.c

Go to the documentation of this file.

 
#include "nilorea/n_common.h"
#include "nilorea/n_log.h"
#include "nilorea/n_network.h"
#include "nilorea/n_network_msg.h"
 
double double_swap(double value) {
    double swaped = 0;
    unsigned char* src = (unsigned char*)&value;
    unsigned char* dst = (unsigned char*)&swaped;
 
    /* swap bytes */
    dst[0] = src[7];
    dst[1] = src[6];
    dst[2] = src[5];
    dst[3] = src[4];
    dst[4] = src[3];
    dst[5] = src[2];
    dst[6] = src[1];
    dst[7] = src[0];
 
    return swaped;
} /* double_swap() */
 
double htond(double value) {
    double ret = value;
    /* if byte order is little like x86, PC, ... we swap to network notation */
#if (BYTEORDER_ENDIAN == BYTEORDER_LITTLE_ENDIAN)
    ret = double_swap(value);
#endif
    return ret;
} /* htond() */
 
double ntohd(double value) {
    double ret = value;
    /* if byte order is little like x86, PC, ... we swap to network notation */
#if (BYTEORDER_ENDIAN == BYTEORDER_LITTLE_ENDIAN)
    ret = double_swap(value);
#endif
    return ret;
} /* ntohd() */
 
int create_msg(NETW_MSG** msg) {
    if ((*msg)) {
        n_log(LOG_ERR, "create_msg destination is valid and should be NULL !");
        return FALSE;
    }
 
    Malloc((*msg), NETW_MSG, 1);
    __n_assert(msg && (*msg), return FALSE);
 
    (*msg)->tabstr = new_generic_list(MAX_LIST_ITEMS);
    __n_assert((*msg)->tabstr, Free((*msg)); return FALSE);
    (*msg)->tabint = new_generic_list(MAX_LIST_ITEMS);
    __n_assert((*msg)->tabint, list_destroy(&(*msg)->tabstr); Free((*msg)); return FALSE);
    (*msg)->tabflt = new_generic_list(MAX_LIST_ITEMS);
    __n_assert((*msg)->tabflt, list_destroy(&(*msg)->tabstr); list_destroy(&(*msg)->tabint); Free((*msg)); return FALSE);
 
    return TRUE;
} /* create_msg( ... ) */
 
int delete_msg(NETW_MSG** msg) {
    if ((*msg)) {
        if ((*msg)->tabint) {
            list_destroy(&(*msg)->tabint);
        }
        if ((*msg)->tabflt) {
            list_destroy(&(*msg)->tabflt);
        }
        if ((*msg)->tabstr) {
            list_destroy(&(*msg)->tabstr);
        }
        Free((*msg));
    } else {
        n_log(LOG_ERR, "(*msg) already NULL");
        return FALSE;
    }
    return TRUE;
} /* delete_msg */
 
int empty_msg(NETW_MSG** msg) {
    __n_assert(msg && (*msg), return FALSE);
 
    list_empty((*msg)->tabint);
    list_empty((*msg)->tabflt);
    list_empty((*msg)->tabstr);
 
    return TRUE;
} /* empty_msg(...) */
 
int add_nb_to_msg(NETW_MSG* msg, double value) {
    double* new_val = NULL;
 
    __n_assert(msg, return FALSE);
 
    Malloc(new_val, double, 1);
    __n_assert(new_val, return FALSE);
 
    new_val[0] = value;
 
    return list_push(msg->tabflt, new_val, free);
} /* add_nb_to_msg( ... ) */
 
int add_int_to_msg(NETW_MSG* msg, int value) {
    int* new_val = NULL;
 
    __n_assert(msg, return FALSE);
 
    Malloc(new_val, int, 1);
    __n_assert(new_val, return FALSE);
 
    new_val[0] = value;
 
    return list_push(msg->tabint, new_val, free);
} /* add_int_to_msg( ... ) */
 
int add_nstrptr_to_msg(NETW_MSG* msg, N_STR* str) {
    __n_assert(msg, return FALSE);
    __n_assert(str, return FALSE);
    __n_assert(str->data, return FALSE);
    return list_push(msg->tabstr, str, free_nstr_ptr);
} /* add_nstrptr_to_msg(...) */
 
int add_nstrdup_to_msg(NETW_MSG* msg, N_STR* str) {
    __n_assert(msg, return FALSE);
    __n_assert(str, return FALSE);
    __n_assert(str->data, return FALSE);
    N_STR* dup = nstrdup(str);
    __n_assert(dup, return FALSE);
    return list_push(msg->tabstr, dup, free_nstr_ptr);
} /* add_nstrdup_to_msg(...) */
 
int add_strdup_to_msg(NETW_MSG* msg, const char* str) {
    __n_assert(msg, return FALSE);
    __n_assert(str, return FALSE);
 
    N_STR* dup = char_to_nstr(str);
    __n_assert(dup, return FALSE);
 
    return list_push(msg->tabstr, dup, free_nstr_ptr);
} /* add_strdup_to_msg(...) */
 
int get_nb_from_msg(NETW_MSG* msg, double* value) {
    double* val = NULL;
 
    __n_assert(msg, return FALSE);
 
    val = list_shift(msg->tabflt, double);
    if (val) {
        (*value) = val[0];
        Free(val);
        return TRUE;
    }
    return FALSE;
} /* get_nb_from_msg(...) */
 
int get_int_from_msg(NETW_MSG* msg, int* value) {
    int* val = NULL;
 
    __n_assert(msg, return FALSE);
 
    val = list_shift(msg->tabint, int);
    if (val) {
        (*value) = val[0];
        Free(val);
        return TRUE;
    }
    return FALSE;
 
} /* get_int_from_msg(...) */
 
int get_nstr_from_msg(NETW_MSG* msg, N_STR** value) {
    N_STR* val = NULL;
 
    __n_assert(msg, return FALSE);
 
    val = list_shift(msg->tabstr, N_STR);
    if (val) {
        if ((*value)) {
            n_log(LOG_ERR, "Previous pointer value %p overriden by pointer %p", (*value), val);
        }
        (*value) = val;
        return TRUE;
    }
    return FALSE;
} /* get_nstr_from_msg(...) */
 
int get_str_from_msg(NETW_MSG* msg, char** value) {
    N_STR* val = NULL;
 
    __n_assert(msg, return FALSE);
 
    val = list_shift(msg->tabstr, N_STR);
    if (val) {
        if ((*value)) {
            n_log(LOG_ERR, "Previous pointer value %p overriden by pointer %p", (*value), val);
        }
 
        (*value) = val->data;
        Free(val);
        return TRUE;
    }
    return FALSE;
} /* get_str_from_msg(...) */
 
N_STR* make_str_from_msg(NETW_MSG* msg) {
    size_t str_length = 0;
    LIST_NODE* node = NULL;
 
    N_STR *strptr = NULL,
          *generated_str = NULL;
 
    char* charptr = NULL;
 
    __n_assert(msg, return NULL);
 
    /* the first thing to do is to computer the resulting string size
       the first 12 octets are for the number of ints , floats, strings in the message
       */
    str_length = 3 * sizeof(int32_t) + (msg->tabint->nb_items * sizeof(int32_t)) + (msg->tabflt->nb_items * sizeof(double));
 
    /* let's count the eventual string blocks */
    node = msg->tabstr->start;
    while (node) {
        strptr = (N_STR*)node->ptr;
        str_length += sizeof(int32_t) + sizeof(int32_t) + strptr->written;
        node = node->next;
    }
 
    /* preparing the new string */
    Malloc(generated_str, N_STR, 1);
    __n_assert(generated_str, return NULL);
    Malloc(generated_str->data, char, str_length + 1);
    __n_assert(generated_str->data, Free(generated_str); return NULL);
 
    generated_str->length = str_length + 1;
    generated_str->written = str_length;
 
    /* copying header */
    charptr = generated_str->data;
 
    /* testing limits */
    if (msg->tabint->nb_items >= UINT32_MAX) {
        n_log(LOG_ERR, "too much items (>=UINT32_MAX) in int list of message %p", msg);
        free_nstr(&generated_str);
        return NULL;
    }
    if (msg->tabflt->nb_items >= UINT32_MAX) {
        n_log(LOG_ERR, "too much items (>=UINT32_MAX) in float list of message %p", msg);
        free_nstr(&generated_str);
        return NULL;
    }
    if (msg->tabstr->nb_items >= UINT32_MAX) {
        n_log(LOG_ERR, "too much items (>=UINT32_MAX) in string list of message %p", msg);
        free_nstr(&generated_str);
        return NULL;
    }
 
    /* byte order */
    uint32_t nb_int_items = htonl((uint32_t)msg->tabint->nb_items);
    uint32_t nb_float_items = htonl((uint32_t)msg->tabflt->nb_items);
    uint32_t nb_str_items = htonl((uint32_t)msg->tabstr->nb_items);
 
    /* number of ints inside the message */
    memcpy(charptr, &nb_int_items, sizeof(uint32_t));
    charptr += sizeof(uint32_t);
    /* number of doubles inside the message */
    memcpy(charptr, &nb_float_items, sizeof(uint32_t));
    charptr += sizeof(uint32_t);
    /* number of string inside the message */
    memcpy(charptr, &nb_str_items, sizeof(uint32_t));
    charptr += sizeof(uint32_t);
 
    /* if there are numbers, copy all them ! */
    node = msg->tabint->start;
    while (node) {
        uint32_t* nbptr = (uint32_t*)node->ptr;
        uint32_t val = htonl(nbptr[0]);
        memcpy(charptr, &val, sizeof(uint32_t));
        charptr += sizeof(uint32_t);
        node = node->next;
    }
 
    /* if there are numbers, copy all them ! */
    node = msg->tabflt->start;
    while (node) {
        double* nbptr = (double*)node->ptr;
        double val = htond(nbptr[0]);
        memcpy(charptr, &val, sizeof(double));
        charptr += sizeof(double);
        node = node->next;
    }
 
    /* if there are strings, copy all them ! */
    if (msg->tabstr->nb_items > 0) {
        node = msg->tabstr->start;
        while (node) {
            strptr = (N_STR*)node->ptr;
            if (strptr->length >= UINT32_MAX) {
                n_log(LOG_ERR, "string too long (>=UINT32_MAX) in string list of message %p", msg);
                free_nstr(&generated_str);
                return NULL;
            }
            uint32_t var = htonl((uint32_t)strptr->length);
            memcpy(charptr, &var, sizeof(uint32_t));
            charptr += sizeof(uint32_t);
 
            if (strptr->written >= UINT32_MAX) {
                n_log(LOG_ERR, "string too long (>=UINT32_MAX) in string list of message %p", msg);
                free_nstr(&generated_str);
                return NULL;
            }
            var = htonl((uint32_t)strptr->written);
            memcpy(charptr, &var, sizeof(uint32_t));
            charptr += sizeof(uint32_t);
 
            memcpy(charptr, strptr->data, strptr->written);
            charptr += strptr->written;
            node = node->next;
        }
    }
 
    return generated_str;
} /* make_str_from_msg(...) */
 
NETW_MSG* make_msg_from_str(N_STR* str) {
    NETW_MSG* generated_msg = NULL;
    N_STR* tmpstr = NULL;
 
    char* charptr = NULL;
 
    uint32_t it,
        nb_int = 0,
        nb_flt = 0,
        nb_str = 0;
    int32_t tmpnb = 0;
 
    double tmpflt = 0;
 
    __n_assert(str, return NULL);
 
    charptr = str->data;
 
    create_msg(&generated_msg);
 
    __n_assert(generated_msg, return NULL);
 
    memcpy(&nb_int, charptr, sizeof(uint32_t));
    charptr += sizeof(uint32_t);
    nb_int = ntohl(nb_int);
 
    memcpy(&nb_flt, charptr, sizeof(uint32_t));
    charptr += sizeof(uint32_t);
    nb_flt = ntohl(nb_flt);
 
    memcpy(&nb_str, charptr, sizeof(uint32_t));
    charptr += sizeof(uint32_t);
    nb_str = ntohl(nb_str);
 
    if (nb_int > 0) {
        for (it = 0; it < nb_int; it++) {
            memcpy(&tmpnb, charptr, sizeof(uint32_t));
            tmpnb = (int32_t)ntohl((uint32_t)tmpnb);
            charptr += sizeof(uint32_t);
            add_int_to_msg(generated_msg, tmpnb);
        }
    }
 
    if (nb_flt > 0) {
        for (it = 0; it < nb_flt; it++) {
            memcpy(&tmpflt, charptr, sizeof(double));
            tmpflt = ntohd(tmpflt);
            charptr += sizeof(double);
            add_nb_to_msg(generated_msg, tmpflt);
        }
    }
 
    if (nb_str > 0) {
        for (it = 0; it < nb_str; it++) {
            Malloc(tmpstr, N_STR, 1);
            __n_assert(tmpstr, return NULL);
            uint32_t var = 0;
            memcpy(&var, charptr, sizeof(uint32_t));
            charptr += sizeof(uint32_t);
            tmpstr->length = ntohl(var);
 
            memcpy(&var, charptr, sizeof(uint32_t));
            charptr += sizeof(uint32_t);
            tmpstr->written = ntohl(var);
 
            Malloc(tmpstr->data, char, tmpstr->length);
            __n_assert(tmpstr->data, return NULL);
 
            memcpy(tmpstr->data, charptr, tmpstr->written);
            charptr += tmpstr->written;
 
            add_nstrptr_to_msg(generated_msg, tmpstr);
        }
    }
    return generated_msg;
} /* make_msg_from_str(...) */
 
#ifndef NO_NETMSG_API
 
N_STR* netmsg_make_ping(int type, int id_from, int id_to, int time) {
    NETW_MSG* msg = NULL;
 
    N_STR* tmpstr = NULL;
 
    create_msg(&msg);
 
    __n_assert(msg, return NULL);
 
    if (add_int_to_msg(msg, type) == FALSE) {
        delete_msg(&msg);
        return NULL;
    }
    if (add_int_to_msg(msg, id_from) == FALSE) {
        delete_msg(&msg);
        return NULL;
    }
    if (add_int_to_msg(msg, id_to) == FALSE) {
        delete_msg(&msg);
        return NULL;
    }
    if (add_int_to_msg(msg, time) == FALSE) {
        delete_msg(&msg);
        return NULL;
    }
 
    tmpstr = make_str_from_msg(msg);
    delete_msg(&msg);
 
    return tmpstr;
} /* netmsg_make_ping() */
 
N_STR* netmsg_make_ident(int type, int id, N_STR* name, N_STR* passwd) {
    NETW_MSG* msg = NULL;
    N_STR* tmpstr = NULL;
 
    create_msg(&msg);
    __n_assert(msg, return FALSE);
 
    if (add_int_to_msg(msg, type) == FALSE) {
        delete_msg(&msg);
        return NULL;
    }
    if (add_int_to_msg(msg, id) == FALSE) {
        delete_msg(&msg);
        return NULL;
    }
 
    if (add_nstrdup_to_msg(msg, name) == FALSE) {
        delete_msg(&msg);
        return NULL;
    }
    if (add_nstrdup_to_msg(msg, passwd) == FALSE) {
        delete_msg(&msg);
        return NULL;
    }
 
    tmpstr = make_str_from_msg(msg);
    delete_msg(&msg);
 
    return tmpstr;
} /* netmsg_make_ident() */
 
N_STR* netmsg_make_position_msg(int id, double X, double Y, double vx, double vy, double acc_x, double acc_y, int time_stamp) {
    NETW_MSG* msg = NULL;
    N_STR* tmpstr = NULL;
 
    create_msg(&msg);
 
    __n_assert(msg, return NULL);
 
    if (add_int_to_msg(msg, NETMSG_POSITION) == FALSE) {
        delete_msg(&msg);
        return NULL;
    }
    if (add_int_to_msg(msg, id) == FALSE) {
        delete_msg(&msg);
        return NULL;
    }
    if (add_nb_to_msg(msg, X) == FALSE) {
        delete_msg(&msg);
        return NULL;
    }
    if (add_nb_to_msg(msg, Y) == FALSE) {
        delete_msg(&msg);
        return NULL;
    }
    if (add_nb_to_msg(msg, vx) == FALSE) {
        delete_msg(&msg);
        return NULL;
    }
    if (add_nb_to_msg(msg, vy) == FALSE) {
        delete_msg(&msg);
        return NULL;
    }
    if (add_nb_to_msg(msg, acc_x) == FALSE) {
        delete_msg(&msg);
        return NULL;
    }
    if (add_nb_to_msg(msg, acc_y) == FALSE) {
        delete_msg(&msg);
        return NULL;
    }
    if (add_int_to_msg(msg, time_stamp) == FALSE) {
        delete_msg(&msg);
        return NULL;
    }
 
    tmpstr = make_str_from_msg(msg);
    delete_msg(&msg);
    return tmpstr;
} /* netmsg_make_position_msg() */
 
N_STR* netmsg_make_string_msg(int id_from, int id_to, N_STR* name, N_STR* chan, N_STR* txt, int color) {
    NETW_MSG* msg = NULL;
 
    N_STR* tmpstr = NULL;
 
    create_msg(&msg);
 
    __n_assert(msg, return NULL);
 
    if (add_int_to_msg(msg, NETMSG_STRING) == FALSE) {
        delete_msg(&msg);
        return NULL;
    }
    if (add_int_to_msg(msg, id_from) == FALSE) {
        delete_msg(&msg);
        return NULL;
    }
    if (add_int_to_msg(msg, id_to) == FALSE) {
        delete_msg(&msg);
        return NULL;
    }
    if (add_int_to_msg(msg, color) == FALSE) {
        delete_msg(&msg);
        return NULL;
    }
 
    if (add_nstrdup_to_msg(msg, name) == FALSE) {
        delete_msg(&msg);
        return NULL;
    }
    if (add_nstrdup_to_msg(msg, chan) == FALSE) {
        delete_msg(&msg);
        return NULL;
    }
    if (add_nstrdup_to_msg(msg, txt) == FALSE) {
        delete_msg(&msg);
        return NULL;
    }
 
    tmpstr = make_str_from_msg(msg);
    delete_msg(&msg);
    __n_assert(tmpstr, return NULL);
 
    return tmpstr;
 
} /* netmsg_make_string_msg */
 
N_STR* netmsg_make_quit_msg(void) {
    NETW_MSG* msg = NULL;
    N_STR* tmpstr = NULL;
 
    create_msg(&msg);
    __n_assert(msg, return FALSE);
 
    if (add_int_to_msg(msg, NETMSG_QUIT) == FALSE) {
        delete_msg(&msg);
        return NULL;
    }
    tmpstr = make_str_from_msg(msg);
    delete_msg(&msg);
    __n_assert(tmpstr, return NULL);
 
    return tmpstr;
} /* netmsg_make_quit_msg() */
 
int netw_msg_get_type(N_STR* msg) {
    int32_t tmpnb = 0;
    char* charptr = NULL;
 
    __n_assert(msg, return FALSE);
 
    charptr = msg->data;
 
    /* here we bypass the number of int, numebr of flt, number of str, (4+4+4) to get the
     * first number which should be type */
    charptr += 3 * sizeof(uint32_t);
    memcpy(&tmpnb, charptr, sizeof(uint32_t));
    tmpnb = (int32_t)ntohl((uint32_t)tmpnb);
 
    return tmpnb;
} /* netw_msg_get_type(...) */
 
int netw_get_ident(N_STR* msg, int* type, int* ident, N_STR** name, N_STR** passwd) {
    NETW_MSG* netmsg = NULL;
 
    __n_assert(msg, return FALSE);
 
    netmsg = make_msg_from_str(msg);
 
    __n_assert(netmsg, return FALSE);
 
    get_int_from_msg(netmsg, &(*type));
    get_int_from_msg(netmsg, &(*ident));
 
    if ((*type) != NETMSG_IDENT_REQUEST && (*type) != NETMSG_IDENT_REPLY_OK && (*type) != NETMSG_IDENT_REPLY_NOK) {
        n_log(LOG_ERR, "unknow (*type) %d", (*type));
        delete_msg(&netmsg);
        return FALSE;
    }
 
    get_nstr_from_msg(netmsg, &(*name));
    get_nstr_from_msg(netmsg, &(*passwd));
 
    delete_msg(&netmsg);
 
    return TRUE;
} /* netw_get_ident( ... ) */
 
int netw_get_position(N_STR* msg, int* id, double* X, double* Y, double* vx, double* vy, double* acc_x, double* acc_y, int* time_stamp) {
    NETW_MSG* netmsg = NULL;
 
    int type = 0;
 
    __n_assert(msg, return FALSE);
 
    netmsg = make_msg_from_str(msg);
 
    __n_assert(netmsg, return FALSE);
 
    get_int_from_msg(netmsg, &type);
 
    if (type != NETMSG_POSITION) {
        delete_msg(&netmsg);
        return FALSE;
    }
 
    get_int_from_msg(netmsg, &(*id));
    get_nb_from_msg(netmsg, &(*X));
    get_nb_from_msg(netmsg, &(*Y));
    get_nb_from_msg(netmsg, &(*vx));
    get_nb_from_msg(netmsg, &(*vy));
    get_nb_from_msg(netmsg, &(*acc_x));
    get_nb_from_msg(netmsg, &(*acc_y));
    get_int_from_msg(netmsg, &(*time_stamp));
 
    delete_msg(&netmsg);
 
    return TRUE;
} /* netw_get_position( ... ) */
 
int netw_get_string(N_STR* msg, int* id, N_STR** name, N_STR** chan, N_STR** txt, int* color) {
    NETW_MSG* netmsg = NULL;
 
    int type = 0;
 
    __n_assert(msg, return FALSE);
 
    netmsg = make_msg_from_str(msg);
 
    __n_assert(netmsg, return FALSE);
 
    get_int_from_msg(netmsg, &type);
 
    if (type != NETMSG_STRING) {
        delete_msg(&netmsg);
        return FALSE;
    }
 
    get_int_from_msg(netmsg, id);
    get_int_from_msg(netmsg, color);
 
    get_nstr_from_msg(netmsg, &(*name));
    get_nstr_from_msg(netmsg, &(*chan));
    get_nstr_from_msg(netmsg, &(*txt));
 
    delete_msg(&netmsg);
 
    return TRUE;
 
} /* netw_get_string( ... ) */
 
int netw_get_ping(N_STR* msg, int* type, int* from, int* to, int* time) {
    NETW_MSG* netmsg;
 
    __n_assert(msg, return FALSE);
 
    netmsg = make_msg_from_str(msg);
 
    __n_assert(netmsg, return FALSE);
 
    get_int_from_msg(netmsg, &(*type));
 
    if ((*type) != NETMSG_PING_REQUEST && (*type) != NETMSG_PING_REPLY) {
        delete_msg(&netmsg);
        return FALSE;
    }
 
    get_int_from_msg(netmsg, &(*from));
    get_int_from_msg(netmsg, &(*to));
    get_int_from_msg(netmsg, &(*time));
 
    delete_msg(&netmsg);
 
    return TRUE;
} /* netw_get_ping( ... ) */
 
int netw_get_quit(N_STR* msg) {
    __n_assert(msg, return FALSE);
 
    NETW_MSG* netmsg = NULL;
    netmsg = make_msg_from_str(msg);
    __n_assert(netmsg, return FALSE);
 
    int type = -1;
    get_int_from_msg(netmsg, &type);
    if (type != NETMSG_QUIT) {
        delete_msg(&netmsg);
        return FALSE;
    }
    delete_msg(&netmsg);
    return TRUE;
} /* netw_get_quit( ... ) */
 
#endif  // NO_NETMSG_API