n_network.h

Go to the documentation of this file.

 
#ifndef N_NETWORK
#define N_NETWORK
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include "n_common.h"
#include "n_str.h"
#include "n_list.h"
#include "n_hash.h"
 
#define NETWORK_IPALL 0
#define NETWORK_IPV4 1
#define NETWORK_IPV6 2
#define NETWORK_DEPLETE_SOCKET_TIMEOUT 512
#define NETWORK_DEPLETE_QUEUES_TIMEOUT 1024
#define NETWORK_CONSECUTIVE_SEND_WAIT 2048
#define NETWORK_WAIT_CLOSE_TIMEOUT 4096
#define HEAD_SIZE 10
#define HEAD_CODE 3
#define NETW_SOCKET_ERROR -1
#define NETW_SOCKET_DISCONNECTED -2
#define NETW_MAX_RETRIES 8
#define NETW_RETRY_DELAY 1000
 
#ifndef SOCKET
#ifdef __windows__
#ifndef ARCH32BITS
typedef long long unsigned int SOCKET;
#define SOCKET_SIZE_FORMAT "%zu"
#endif
#else
typedef int SOCKET;
#define SOCKET_SIZE_FORMAT "%d"
#endif
#endif
 
#if defined(__linux__) || defined(__sun) || defined(_AIX)
#include <sys/types.h>
#include <fcntl.h>
#include <stdio.h>
#include <errno.h>
#include <unistd.h>
#include <malloc.h>
#include <string.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <semaphore.h>
 
#define SOCKET_SIZE_FORMAT "%d"
 
#ifdef __linux__
#include <linux/sockios.h>
#include <signal.h>
#endif
 
#define netw_unload()
 
#define closesocket close
#define NETFLAGS MSG_NOSIGNAL /* for program to not quit under linux when a connection is crashing 2 times */
#define INVALID_SOCKET -1
 
#include "n_time.h"
 
#elif defined __windows__
 
#define SHUT_WR SD_SEND
#define SHUT_RD SD_RECEIVE
#define SHUT_RDWR SD_BOTH
 
#ifndef ECONNRESET
#define ECONNRESET 104
#endif
 
#if (_WIN32_WINNT < 0x0501)
#undef _WIN32_WINNT
#define _WIN32_WINNT 0x0501
#endif
 
#include <errno.h>
#include <unistd.h>
#include <malloc.h>
#include <string.h>
#include <winsock2.h>
#include <windows.h>
#include <ws2tcpip.h>
#include "n_time.h"
 
#ifndef MSG_EOR
#define MSG_EOR 0
#endif
 
#ifndef MSG_NOSIGNAL
#define MSG_NOSIGNAL 0
#endif
 
#ifndef MSG_WAITALL
#define MSG_WAITALL 0
#endif
 
#ifndef EAI_SYSTEM
#define EAI_SYSTEM 0
#endif
 
#ifndef AI_PASSIVE
#define AI_PASSIVE 0x00000001
#endif
#ifndef AI_CANONNAME
#define AI_CANONNAME 0x00000002
#endif
#ifndef AI_NUMERICHOST
#define AI_NUMERICHOST 0x00000004
#endif
#ifndef AI_NUMERICSERV
#define AI_NUMERICSERV 0x00000008
#endif
#ifndef AI_ALL
#define AI_ALL 0x00000100
#endif
#ifndef AI_ADDRCONFIG
#define AI_ADDRCONFIG 0x00000400
#endif
#ifndef AI_V4MAPPED
#define AI_V4MAPPED 0x00000800
#endif
#ifndef AI_NON_AUTHORITATIVE
#define AI_NON_AUTHORITATIVE 0x00004000
#endif
#ifndef AI_SECURE
#define AI_SECURE 0x00008000
#endif
#ifndef AI_RETURN_PREFERRED_NAMES
#define AI_RETURN_PREFERRED_NAMES 0x00010000
#endif
 
#include <pthread.h>
#include <semaphore.h>
 
#define NETFLAGS 0 /* no flags needed for microsoft */
 
#define netw_unload() netw_init_wsa(0, 2, 2)
 
#endif
 
#ifdef HAVE_OPENSSL
#define _OPEN_SYS_SOCK_IPV6 1
#include <openssl/err.h>
#include <openssl/ssl.h>
#include <openssl/crypto.h>
#endif
 
#define N_ENUM_netw_code_type(_)     \
    _(NETW_CLIENT, 2)                \
    _(NETW_SERVER, 4)                \
    _(NETW_RESTART_TIMER, 8)         \
    _(NETW_EMPTY_SENDBUF, 16)        \
    _(NETW_EMPTY_RECVBUF, 32)        \
    _(NETW_RUN, 64)                  \
    _(NETW_EXIT_ASKED, 128)          \
    _(NETW_EXITED, 256)              \
    _(NETW_ERROR, 512)               \
    _(NETW_ENCRYPT_NONE, 1024)       \
    _(NETW_ENCRYPT_OPENSSL, 2048)    \
    _(NETW_THR_ENGINE_STARTED, 4096) \
    _(NETW_THR_ENGINE_STOPPED, 8192) \
    _(NETW_DESTROY_RECVBUF, 16384)   \
    _(NETW_DESTROY_SENDBUF, 32768)
 
N_ENUM_DECLARE(N_ENUM_netw_code_type, __netw_code_type);
 
typedef ssize_t (*netw_func)(void*, char*, uint32_t);
 
typedef struct N_SOCKET {
    char* port;
    SOCKET sock;
    char* ip;
 
    unsigned long int is_blocking;
 
    struct addrinfo hints;
    struct addrinfo* rhost;
    struct sockaddr_storage raddr;
} N_SOCKET;
 
typedef struct NETWORK {
    int nb_pending,
        mode,
        threaded_engine_status,
        addr_infos_loaded,
        send_queue_consecutive_wait,
        so_reuseaddr,
        /* disabled so reuseport state */
        // so_reuseport,
        so_keepalive,
        tcpnodelay,
        so_sndbuf,
        so_rcvbuf,
        so_sndtimeo,
        so_rcvtimeo,
        so_linger,
        crypto_mode,
        crypto_algo,
        user_id,
        nb_running_threads,
        deplete_queues_timeout,
        deplete_socket_timeout,
        wait_close_timeout;
 
    uint32_t state;
 
    netw_func send_data,
        recv_data;
 
#ifdef HAVE_OPENSSL
    const SSL_METHOD* method;
    SSL_CTX* ctx;
    SSL* ssl;
    char *certificate,
        *key;
#endif
 
    N_SOCKET link;
 
    LIST* send_buf;
    LIST* recv_buf;
 
    pthread_t send_thr;
    pthread_t recv_thr;
 
    pthread_mutex_t sendbolt;
    pthread_mutex_t recvbolt;
    pthread_mutex_t eventbolt;
    sem_t send_blocker;
 
    LIST* pools;
 
} NETWORK;
 
typedef struct NETWORK_POOL {
    HASH_TABLE* pool;
 
    pthread_rwlock_t rwlock;
 
} NETWORK_POOL;
 
typedef struct NETWORK_HTTP_INFO {
    // Store content type
    char content_type[256];
    // Store content length
    size_t content_length;
    // Pointer to the body data
    char* body;
    // Type of request
    char* type;
} NETWORK_HTTP_INFO;
 
/* host to network size_t */
size_t htonst(size_t value);
/* network to host size_t */
size_t ntohst(size_t value);
#ifdef HAVE_OPENSSL
/* set SSL */
int netw_set_crypto(NETWORK* netw, char* key, char* certificate);
/* init ssl helper */
int netw_init_openssl(void);
/* unload ssl helper */
int netw_unload_openssl(void);
/* connect ssl helper */
int netw_ssl_connect(NETWORK** netw, char* host, char* port, int ip_version, char* ssl_key_file, char* ssl_cert_file);
/* SSL Writting to a socket */
ssize_t send_ssl_data(void* netw, char* buf, uint32_t n);
/* SSL Reading from a socket */
ssize_t recv_ssl_data(void* netw, char* buf, uint32_t n);
#endif
/* Used by Init & Close network */
int netw_init_wsa(int mode, int v1, int v2);
/* Set flags on network */
int netw_set(NETWORK* netw, int flag);
/* Get flags from network */
int netw_get_state(NETWORK* netw, uint32_t* state, int* thr_engine_status);
/* Set common socket options (disable naggle, send/recv buf, reuse addr) */
int netw_setsockopt(NETWORK* netw, int optname, int value);
/* set blocking mode */
int netw_set_blocking(NETWORK* netw, unsigned long int is_blocking);
/* Connecting, extended */
int netw_connect_ex(NETWORK** netw, char* host, char* port, size_t send_list_limit, size_t recv_list_limit, int ip_version, char* ssl_key_file, char* ssl_cert_file);
/* Connecting */
int netw_connect(NETWORK** netw, char* host, char* port, int ip_version);
/* wait for send buffer to be empty */
int deplete_send_buffer(int fd, int timeout);
/* Closing */
int netw_close(NETWORK** netw);
/* Closing for peer */
int netw_wait_close(NETWORK** netw);
/* Closing for peer timeouted*/
int netw_wait_close_timed(NETWORK** netw, size_t timeout);
/* Stop a NETWORK connection sending and receing thread */
int netw_stop_thr_engine(NETWORK* netw);
/* Listening network */
int netw_make_listening(NETWORK** netw, char* addr, char* port, int nbpending, int ip_version);
/* Accepting routine extended */
NETWORK* netw_accept_from_ex(NETWORK* from, size_t send_list_limit, size_t recv_list_limit, int blocking, int* retval);
/* Accepting routine */
NETWORK* netw_accept_from(NETWORK* from);
/* Accepting routine */
NETWORK* netw_accept_nonblock_from(NETWORK* from, int blocking);
/* Add a message to send in aimed NETWORK */
int netw_add_msg(NETWORK* netw, N_STR* msg);
/* Add a char message to send in the aimed NETWORK */
int netw_add_msg_ex(NETWORK* netw, char* str, unsigned int length);
/* Get a message from aimed NETWORK. Instant return to NULL if no MSG */
N_STR* netw_get_msg(NETWORK* netw);
/* Wait a message from aimed NETWORK. Recheck each 'refresh' usec until 'timeout' usec */
N_STR* netw_wait_msg(NETWORK* netw, unsigned int refresh, size_t timeout);
/* Create the sending and receiving thread of a NETWORK */
int netw_start_thr_engine(NETWORK* netw);
/* Thread Sending management function */
void* netw_send_func(void* NET);
/* Thread Receiving management function */
void* netw_recv_func(void* NET);
/* Writting to a socket */
ssize_t send_data(void* netw, char* buf, uint32_t n);
/* Reading from a socket */
ssize_t recv_data(void* netw, char* buf, uint32_t n);
/* sending to php */
ssize_t send_php(SOCKET s, int _code, char* buf, int n);
/* receive from php */
ssize_t recv_php(SOCKET s, int* _code, char** buf);
/* get queue status */
int netw_get_queue_status(NETWORK* netw, size_t* nb_to_send, size_t* nb_to_read);
 
/* init pools */
NETWORK_POOL* netw_new_pool(size_t nb_min_element);
/* destroy pool */
int netw_destroy_pool(NETWORK_POOL** netw_pool);
/* close pool */
void netw_pool_netw_close(void* netw_ptr);
/* add network to pool */
int netw_pool_add(NETWORK_POOL* netw_pool, NETWORK* netw);
/* add network to pool */
int netw_pool_remove(NETWORK_POOL* netw_pool, NETWORK* netw);
/* add message to pool */
int netw_pool_broadcast(NETWORK_POOL* netw_pool, NETWORK* from, N_STR* net_msg);
/* get nb clients */
size_t netw_pool_nbclients(NETWORK_POOL* netw_pool);
 
/* set user id on a netw */
int netw_set_user_id(NETWORK* netw, int id);
 
/* homemade tcp ip protocol helpers */
int netw_send_ping(NETWORK* netw, int type, int id_from, int id_to, int time);
int netw_send_ident(NETWORK* netw, int type, int id, N_STR* name, N_STR* passwd);
int netw_send_position(NETWORK* netw, int id, double X, double Y, double vx, double vy, double acc_x, double acc_y, int time_stamp);
int netw_send_string_to(NETWORK* netw, int id_to, N_STR* name, N_STR* chan, N_STR* txt, int color);
int netw_send_string_to_all(NETWORK* netw, N_STR* name, N_STR* chan, N_STR* txt, int color);
int netw_send_quit(NETWORK* netw);
 
/* http helpers */
size_t netw_calculate_urlencoded_size(const char* str, size_t len);
char* netw_extract_http_request_type(const char* request);
NETWORK_HTTP_INFO netw_extract_http_info(char* request);
int netw_info_destroy(NETWORK_HTTP_INFO http_request);
char* netw_urlencode(const char* str, size_t len);
int netw_get_url_from_http_request(const char* request, char* url, size_t size);
char* netw_urldecode(const char* str);
HASH_TABLE* netw_parse_post_data(const char* post_data);
const char* netw_guess_http_content_type(const char* url);
const char* netw_get_http_status_message(int status_code);
int netw_get_http_date(char* buffer, size_t buffer_size);
int netw_build_http_response(N_STR** http_response, int status_code, const char* server_name, const char* content_type, char* additional_headers, N_STR* body);
 
#ifdef __cplusplus
}
#endif
 
#endif /*#ifndef N_NETWORK*/