ex_network.h

Go to the documentation of this file.

 
#define NETMSG_DATA 1
 
#include <getopt.h>
#include <sys/time.h>
#include <sys/types.h>
 
#include "nilorea/n_common.h"
#include "nilorea/n_log.h"
#ifndef __windows__
#include <sys/wait.h>
#endif
 
#include "nilorea/n_network.h"
#include "nilorea/n_network_msg.h"
#include "nilorea/n_thread_pool.h"
 
int send_net_datas(NETWORK* netw, N_STR* data) {
    __n_assert(netw, return FALSE);
    __n_assert(data, return FALSE);
 
    NETW_MSG* msg = NULL;
    N_STR* tmpstr = NULL;
    N_STR* hostname = NULL;
 
    create_msg(&msg);
    __n_assert(msg, return FALSE);
 
    hostname = new_nstr(1024);
#ifdef __windows__
    if (gethostname(hostname->data, (int)hostname->length) != 0) {
#else
    if (gethostname(hostname->data, hostname->length) != 0) {
#endif
        n_log(LOG_ERR, "Couldn't resolve hostname. Error:%s", strerror(errno));
        free_nstr(&hostname);
        return FALSE;
    }
    hostname->written = strlen(hostname->data);
 
    add_int_to_msg(msg, NETMSG_DATA);
 
    add_nstrptr_to_msg(msg, hostname);
 
    n_log(LOG_DEBUG, "Adding string %s", data->data);
 
    add_nstrdup_to_msg(msg, data);
 
    for (int i = 0; i < 10; i++) {
        int val = (rand() % 20) - 10;
        add_int_to_msg(msg, val);
        n_log(LOG_DEBUG, "adding %d to message", val);
    }
 
    tmpstr = make_str_from_msg(msg);
 
    delete_msg(&msg);
 
    __n_assert(tmpstr, return FALSE);
 
    return netw_add_msg(netw, tmpstr);
} /* send_net_datas */
 
int get_net_datas(N_STR* str, N_STR** hostname, N_STR** data) {
    NETW_MSG* netmsg = NULL;
    int type = 0;
 
    __n_assert(str, return FALSE);
 
    netmsg = make_msg_from_str(str);
    __n_assert(netmsg, return FALSE);
 
    get_int_from_msg(netmsg, &type);
    if (type != NETMSG_DATA) {
        n_log(LOG_ERR, "Error: message is not NETMSG_DATA(%d) but %d !", NETMSG_DATA, type);
        delete_msg(&netmsg);
        return FALSE;
    }
    get_nstr_from_msg(netmsg, &(*hostname));
    get_nstr_from_msg(netmsg, &(*data));
    n_log(LOG_DEBUG, "getting string %s", (*data)->data);
 
    for (int i = 0; i < 10; i++) {
        int val = 0;
        get_int_from_msg(netmsg, &val);
        n_log(LOG_DEBUG, "getting %d from message", val);
    }
 
    delete_msg(&netmsg);
 
    return TRUE;
} /* get_net_datas( ... ) */
 
void* manage_client(void* ptr) {
    NETWORK* netw = (NETWORK*)ptr;
    N_STR* netw_exchange = NULL;
    uint32_t state = 0;
    int thr_engine_state = 0;
 
    n_log(LOG_NOTICE, "manage_client started for netw %d", netw->link.sock);
    netw_start_thr_engine(netw);
 
    int DONE = 0;
    while (!DONE) {
        if ((netw_exchange = netw_get_msg(netw))) {
            N_STR *hostname = NULL, *data = NULL;
 
            int type = netw_msg_get_type(netw_exchange);
            if (type == -1) {
                n_log(LOG_ERR, "Error getting message type from network exchange");
                free_nstr(&netw_exchange);
                continue;
            }
            switch (type) {
                case NETMSG_DATA:
                    get_net_datas(netw_exchange, &hostname, &data);
                    if (hostname && hostname->data && data && data->data) {
                        n_log(LOG_NOTICE, "RECV: %s: %s , %s", netw->link.ip, hostname->data, data->data);
                        send_net_datas(netw, data);
                    } else {
                        n_log(LOG_ERR, "Error decoding request");
                    }
                    break;
                default:
                    n_log(LOG_ERR, "Unknow message type %d", type);
                    DONE = 1;
                    break;
            }
            if (data)
                free_nstr(&data);
            if (hostname)
                free_nstr(&hostname);
            if (netw_exchange)
                free_nstr(&netw_exchange);
        } else {
            u_sleep(500);
        }
        netw_get_state(netw, &state, &thr_engine_state);
        if ((state & NETW_EXITED) || (state & NETW_ERROR) || (state & NETW_EXIT_ASKED))
            DONE = 1;
    } /* while( !DONE ) */
 
    SOCKET sockid = netw->link.sock;
    netw_close(&netw);
    n_log(LOG_NOTICE, "network closed for netw %d !", sockid);
 
    return NULL;
} /* manage_client(...) */