UDP-server added

CMakeLists.txt

@@ -4,4 +4,5 @@ cmake_minimum_required(VERSION 2.8)
 add_subdirectory(core_server)
 add_subdirectory(http_server)
 add_subdirectory(enc_server)
+add_subdirectory(udp_server)
 

udp_server/CMakeLists.txt

+cmake_minimum_required(VERSION 2.8)
+project (dap_udp_server C)
+  
+set(DAP_UDP_SERVER_SRCS  dap_udp_server.c dap_udp_client.h dap_udp_client.c )
+
+
+include_directories("${INCLUDE_DIRECTORIES} ${dap_core_INCLUDE_DIRS}")
+include_directories("${INCLUDE_DIRECTORIES} ${dap_crypto_INCLUDE_DIRS}")
+
+add_definitions ("${dap_core_DEFINITIONS}")
+add_definitions ("${dap_crypto_DEFINITIONS}")
+
+add_library(${PROJECT_NAME} STATIC ${DAP_UDP_SERVER_SRCS})
+set(${PROJECT_NAME}_DEFINITIONS CACHE INTERNAL "${PROJECT_NAME}: Definitions" FORCE)
+
+set(${PROJECT_NAME}_INCLUDE_DIRS ${PROJECT_SOURCE_DIR} CACHE INTERNAL "${PROJECT_NAME}: Include Directories" FORCE)
\ No newline at end of file

udp_server/dap_udp_client.c

+/*
+ Copyright (c) 2017-2018 (c) Project "DeM Labs Inc" https://github.com/demlabsinc
+  All rights reserved.
+
+ This file is part of DAP (Deus Applications Prototypes) the open source project
+
+    DAP (Deus Applicaions Prototypes) is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    DAP 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 Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with any DAP based project.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "dap_udp_client.h"
+#include <sys/epoll.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <unistd.h>
+#include <string.h>
+#include <stdint.h>
+#include <ev.h>
+#include "utlist.h"
+#include "dap_common.h"
+#include "dap_loop.h"
+#include "dap_udp_server.h"
+
+#define LOG_TAG "udp_client"
+
+
+/**
+ * @brief udp_client_init Init clients module
+ * @return Zero if ok others if no
+ */
+int dap_udp_client_init()
+{
+    log_it(L_NOTICE,"Initialized socket client module");
+    return 0;
+}
+
+/**
+ * @brief udp_client_deinit Deinit clients module
+ */
+void dap_udp_client_deinit()
+{
+
+}
+
+/**
+ * @brief get_key Make key for hash table from host and port
+ * @return 64 bit Key
+ */
+uint64_t get_key(unsigned long host,unsigned short port){
+    uint64_t key = host;
+    key = key << 32;
+    key += port;
+    return key;
+}
+
+/**
+ * @brief udp_client_create Create new client and add it to hashmap
+ * @param sh Server instance
+ * @param host Client host address
+ * @param w_client Clients event loop watcher
+ * @param port Client port
+ * @return Pointer to the new list's node
+ */
+dap_udp_client_t * dap_udp_client_create(dap_udp_server_t * sh, ev_io* w_client, unsigned long host, unsigned short port)
+{
+    pthread_mutex_lock(&sh->mutex_on_hash);
+    log_it(L_DEBUG,"Client structure create");
+
+    dap_udp_client_t * ret=DAP_NEW_Z(dap_udp_client_t);
+    ret->server = sh;
+    ret->watcher_client = w_client;
+    ret->signal_close = false;
+    ret->host_key = get_key(host,port);   
+    ret->_ready_to_read=true;
+    ret->_ready_to_write=false;
+    
+    HASH_ADD_INT( sh->clients, host_key, ret);
+    if(sh->client_new_callback)
+        sh->client_new_callback(ret,NULL); // Init internal structure
+
+    pthread_mutex_unlock(&sh->mutex_on_hash);
+    return ret;
+}
+
+/**
+ * @brief udp_client_get_address Get host address and port of client
+ * @param client Pointer to client structure
+ * @param host Variable for host address
+ * @param host Variable for port
+ */
+void dap_udp_client_get_address(dap_udp_client_t *client, unsigned long* host,unsigned short* port){    
+    *host = client->host_key >> 32;
+    *port = client->host_key - (*host<<32);
+}
+
+/**
+ * @brief udp_client_find Find client structure by host address and port
+ * @param sh Server instance
+ * @param host Source host address
+ * @param port Source port
+ * @return Pointer to client or NULL if not found
+ */
+dap_udp_client_t * dap_udp_client_find(dap_udp_server_t * sh, unsigned long host,unsigned short port)
+{
+    pthread_mutex_lock(&sh->mutex_on_hash);
+
+    dap_udp_client_t * ret = NULL;
+    uint64_t token = get_key(host,port);
+    HASH_FIND_INT(sh->clients,&token,ret);
+    
+    pthread_mutex_unlock(&sh->mutex_on_hash);
+    return ret;
+}
+
+/**
+ * @brief udp_client_read Read data from input buffer
+ * @param sc Client instance
+ * @param data Pointer to memory where to store the data
+ * @param data_size Size of data to read
+ * @return Actual bytes number that were read
+ */
+size_t dap_udp_client_read(dap_udp_client_t *sc, void * data, size_t data_size)
+{
+    if (data_size < sc->buf_in_size) {
+        memcpy(data, sc->buf_in, data_size);
+        memmove(data, sc->buf_in + data_size, sc->buf_in_size - data_size);
+    } else {
+        if (data_size > sc->buf_in_size) {
+            data_size = sc->buf_in_size;
+        }
+        memcpy(data, sc->buf_in, data_size);
+    }
+    sc->buf_in_size -= data_size;
+    return data_size;
+}
+
+/**
+ * @brief udp_client_ready_to_read Set ready_to_read flag
+ * @param sc Client structure
+ * @param is_ready Flag value
+ */
+void dap_udp_client_ready_to_read(dap_udp_client_t * sc,bool is_ready)
+{
+    if(is_ready != sc->_ready_to_read) {
+
+        uint32_t events = 0;
+        sc->_ready_to_read=is_ready;
+
+        if(sc->_ready_to_read)
+        {
+            events |= EV_READ;
+        }
+
+        if(sc->_ready_to_write)
+            events |= EV_WRITE;
+
+        ev_io_set(sc->watcher_client, sc->server->socket_listener, events );
+    }
+}
+
+/**
+ * @brief udp_client_ready_to_write Set ready_to_write flag
+ * @param sc Client structure
+ * @param is_ready Flag value
+ */
+void dap_udp_client_ready_to_write(dap_udp_client_t * sc,bool is_ready)
+{
+    if(is_ready)
+        add_waiting_client(sc); // Add client to writing queue
+    if(is_ready != sc->_ready_to_write) {
+        uint32_t events = 0;
+        sc->_ready_to_write=is_ready;
+
+        if(sc->_ready_to_read)
+            events |= EV_READ;
+
+        if(sc->_ready_to_write)
+        {
+            events |= EV_WRITE;
+        }
+        int descriptor = sc->watcher_client->fd;
+        ev_io_set(sc->watcher_client, descriptor, events );
+    }
+}
+
+/**
+ * @brief udp_client_remove Removes the client from the hashmap
+ * @param sc Client instance
+ * @param sh Server instance
+ */
+void dap_udp_client_remove(dap_udp_client_t *sc, dap_udp_server_t * sh)
+{
+    pthread_mutex_lock(&sh->mutex_on_hash);
+
+    log_it(L_DEBUG, "Client structure remove");
+    HASH_DEL(sc->server->clients,sc);
+
+    if(sc->server->client_delete_callback)
+        sc->server->client_delete_callback(sc,NULL); // Init internal structure
+    if(sc->_inheritor)
+        free(sc->_inheritor);
+    free(sc);
+    pthread_mutex_unlock(&sh->mutex_on_hash);
+}
+
+/**
+ * @brief udp_client_write Write data to the client
+ * @param sc Client instance
+ * @param data Pointer to data
+ * @param data_size Size of data to write
+ * @return Number of bytes that were placed into the buffer
+ */
+size_t dap_udp_client_write(dap_udp_client_t *sc, const void * data, size_t data_size)
+{
+     data_size = ((sc->buf_out_size+data_size)<(sizeof(sc->buf_out)))?data_size:(sizeof(sc->buf_out)-sc->buf_out_size );
+     memcpy(sc->buf_out+sc->buf_out_size,data,data_size);
+     sc->buf_out_size+=data_size;
+     return data_size;
+}
+
+/**
+ * @brief udp_client_write_f Write formatted text to the client
+ * @param a_client Client instance
+ * @param a_format Format
+ * @return Number of bytes that were placed into the buffer
+ */
+size_t dap_udp_client_write_f(dap_udp_client_t *a_client, const char * a_format,...)
+{
+    size_t max_data_size = sizeof(a_client->buf_out)-a_client->buf_out_size;
+    va_list ap;
+    va_start(ap,a_format);
+    int ret=vsnprintf(a_client->buf_out+a_client->buf_out_size,max_data_size,a_format,ap);
+    va_end(ap);
+    if(ret>0){
+        a_client->buf_out_size+=ret;
+        return ret;
+    }else{
+        log_it(L_ERROR,"Can't write out formatted data '%s'",a_format);
+        return 0;
+    }
+}
+
+/**
+ * @brief add_waiting_client Add Client to write queue
+ * @param client Client instance
+ */
+void add_waiting_client(dap_udp_client_t* client){
+    dap_udp_server_t* serv = client->server;
+    LL_APPEND(serv->waiting_clients, client);
+}
+
+
+/**
+ * @brief shrink_client_buf_in Shrink input buffer (shift it left)
+ * @param cl Client instance
+ * @param shrink_size Size on wich we shrink the buffer with shifting it left
+ */
+void dap_udp_client_shrink_buf_in(dap_udp_client_t * cl, size_t shrink_size)
+{
+    if((shrink_size==0)||(cl->buf_in_size==0) ){
+        return;
+    }else if(cl->buf_in_size>shrink_size){
+        size_t buf_size=cl->buf_in_size-shrink_size;
+        void * buf = malloc(buf_size);
+        memcpy(buf,cl->buf_in+ shrink_size,buf_size );
+        memcpy(cl->buf_in,buf,buf_size);
+        cl->buf_in_size=buf_size;
+        free(buf);
+    }else {
+        cl->buf_in_size=0;
+    }
+
+}
+

udp_server/dap_udp_client.h

+/*
+ Copyright (c) 2017-2018 (c) Project "DeM Labs Inc" https://github.com/demlabsinc
+  All rights reserved.
+
+ This file is part of DAP (Deus Applications Prototypes) the open source project
+
+    DAP (Deus Applicaions Prototypes) is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    DAP 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 Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with any DAP based project.  If not, see <http://www.gnu.org/licenses/>.
+*/
+#pragma once
+#ifndef _UDP_CLIENT_H
+#define _UDP_CLIENT_H
+
+#include <sys/queue.h>
+#include <stdint.h>
+#include <stddef.h>
+#include <stdbool.h>
+#include <sys/queue.h>
+#include "uthash.h"
+#include <ev.h>
+
+
+typedef struct dap_udp_server dap_udp_server_t;
+struct dap_udp_client;
+
+typedef void (*dap_udp_client_callback_t) (struct udp_client *,void * arg); // Callback for specific client operations
+
+#define UDP_CLIENT_BUF 100000
+
+typedef struct dap_udp_client{
+    bool signal_close;
+
+    bool _ready_to_write;
+    bool _ready_to_read;
+
+    uint32_t buf_out_zero_count;
+    char buf_in[UDP_CLIENT_BUF+1]; // Internal buffer for input data
+    size_t buf_in_size; // size of data that is in the input buffer
+
+    char buf_out[UDP_CLIENT_BUF+1]; // Internal buffer for output data
+    size_t buf_out_size; // size of data that is in the output buffer
+
+    uint64_t host_key; //key contains host address in first 4 bytes and port in last 4 bytes
+
+    ev_io* watcher_client;
+
+    struct dap_udp_server * server;
+
+    UT_hash_handle hh;
+    struct dap_udp_client *next, *prev;   //pointers for writing queue
+
+    void * _inheritor; // Internal data to specific client type, usualy states for state machine
+} dap_udp_client_t; // Node of bidirectional list of clients
+
+
+
+int dap_udp_client_init(); //  Init clients module
+void dap_udp_client_deinit(); // Deinit clients module
+
+dap_udp_client_t * dap_udp_client_create(dap_udp_server_t * sh, ev_io* w_client, unsigned long host, unsigned short port); // Create new client and add it to the list
+dap_udp_client_t * dap_udp_client_find(dap_udp_server_t * sh, unsigned long host, unsigned short port); // Find client by host and port
+
+void dap_udp_client_ready_to_read(dap_udp_client_t * sc,bool is_ready);
+void dap_udp_client_ready_to_write(dap_udp_client_t * sc,bool is_ready);
+
+size_t dap_udp_client_write(dap_udp_client_t *sc, const void * data, size_t data_size);
+size_t dap_udp_client_write_f(dap_udp_client_t *a_client, const char * a_format,...);
+size_t dap_udp_client_read(dap_udp_client_t *sc, void * data, size_t data_size);
+
+void add_waiting_client(dap_udp_client_t* client); // Add client to writing queue
+
+void dap_udp_client_remove(dap_udp_client_t *sc, dap_udp_server_t * sh); // Removes the client from the hash-table
+
+void dap_udp_client_shrink_buf_in(dap_udp_client_t * cl, size_t shrink_size);
+
+#endif
\ No newline at end of file

udp_server/dap_udp_server.c

+/*
+ Copyright (c) 2017-2018 (c) Project "DeM Labs Inc" https://github.com/demlabsinc
+  All rights reserved.
+
+ This file is part of DAP (Deus Applications Prototypes) the open source project
+
+    DAP (Deus Applicaions Prototypes) is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    DAP 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 Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with any DAP based project.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "dap_udp_server.h"
+#include <stdio.h>
+#include "dap_common.h"
+#include <errno.h>
+#include <netdb.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <ev.h>
+#include "utlist.h"
+
+#define LOG_TAG "dap_udp_server"
+
+#define BUFSIZE 1024
+
+char buf[BUFSIZE]; /* message buf */
+struct ev_io w_read;
+struct ev_io w_write;
+
+static void write_cb(struct ev_loop* loop, struct ev_io* watcher, int revents);
+
+/**
+ * @brief dap_udp_server_init Init server module
+ * @return Zero if ok others if no
+ */
+int dap_udp_server_init()
+{
+    signal(SIGPIPE, SIG_IGN);
+    log_it(L_NOTICE,"Initialized socket server module");
+    return 0;
+}
+
+/**
+ * @brief dap_udp_server_deinit Deinit server module
+ */
+void dap_udp_server_deinit()
+{
+}
+
+/**
+ */
+void error(char *msg) {
+  perror(msg);
+  exit(1);
+}
+
+/**
+ * @brief dap_udp_server_new Initialize server structure
+ * @return Server pointer
+ */
+dap_udp_server_t * dap_udp_server_new()
+{
+    dap_udp_server_t* server = (dap_udp_server_t*)calloc(1,sizeof(dap_udp_server_t));
+    server->waiting_clients = NULL;
+    return server;
+}
+
+/**
+ * @brief dap_udp_client_loop Create client listening event loop
+ */
+void* dap_udp_client_loop(void * arg)
+{
+    dap_udp_server_t* sh = (dap_udp_server_t*)arg;
+    log_it(L_NOTICE, "Start client listener thread");
+    struct ev_loop * ev_client_loop = ev_loop_new(0);
+    w_write.data = sh;
+    ev_io_init(&w_write, write_cb, sh->socket_listener, EV_WRITE);
+    ev_io_start(ev_client_loop, &w_write);
+    ev_loop(ev_client_loop, 0);
+    return NULL;
+}
+
+/**
+ * @brief dap_udp_server_delete Safe delete server structure
+ * @param sh Server instance
+ */
+void dap_udp_server_delete(dap_udp_server_t * sh)
+{
+    if(sh->address)
+        free(sh->address);
+
+    dap_udp_client_t * client, * tmp;
+    HASH_ITER(hh,sh->clients,client,tmp)
+        dap_udp_client_remove(client, sh);    
+
+    if(sh->server_delete_callback)
+        sh->server_delete_callback(sh,NULL);
+    if(sh->_inheritor)
+        free(sh->_inheritor);
+    free(sh);
+}
+
+/**
+ * @brief dap_udp_server_listen Create and bind server structure
+ * @param port Binding port
+ * @return Server instance 
+ */
+dap_udp_server_t * dap_udp_server_listen(uint16_t port){
+    dap_udp_server_t* sh = dap_udp_server_new();
+
+    sh->socket_listener = socket (AF_INET, SOCK_DGRAM, 0);
+
+    if (sh->socket_listener < 0){
+        log_it (L_ERROR,"Socket error %s",strerror(errno));
+        dap_udp_server_delete(sh);
+        return NULL;
+    }
+
+    int optval = 1;
+    if(setsockopt(sh->socket_listener, SOL_SOCKET, SO_REUSEADDR,(const void *)&optval , sizeof(int)) < 0)
+        log_it(L_WARNING, "Can't set up REUSEADDR flag to the socket");
+
+    bzero((char *) &(sh->listener_addr), sizeof(sh->listener_addr));
+    sh->listener_addr.sin_family = AF_INET;
+    sh->listener_addr.sin_addr.s_addr = htonl(INADDR_ANY);
+    sh->listener_addr.sin_port = htons(port);
+
+    if(bind (sh->socket_listener, (struct sockaddr *) &(sh->listener_addr), sizeof(sh->listener_addr)) < 0) {
+        log_it(L_ERROR,"Bind error: %s",strerror(errno));
+        dap_udp_server_delete(sh);
+        return NULL;
+    }
+    return sh;
+}
+
+/**
+ * @brief write_cb
+ */
+static void write_cb(struct ev_loop* loop, struct ev_io* watcher, int revents)
+{
+    if( ( revents & EV_WRITE ) ) {
+        dap_udp_server_t* sh = watcher->data;
+        dap_udp_client_t * client, * tmp;
+        LL_FOREACH_SAFE(sh->waiting_clients,client,tmp)
+        {
+            if(client != NULL && check_close(client) == 0 && client->_ready_to_write)
+            {
+                if(sh->client_write_callback)
+                    sh->client_write_callback(client, NULL);
+                if(client->buf_out_size > 0)
+                {
+                    for(size_t total_sent = 0; total_sent < client->buf_out_size;) {
+                        struct sockaddr_in addr;
+                        addr.sin_family = AF_INET;
+                        dap_udp_client_get_address(client,&addr.sin_addr.s_addr,&addr.sin_port);
+                        int bytes_sent = sendto(sh->socket_listener, client->buf_out + total_sent, client->buf_out_size - total_sent, 0, (struct sockaddr*) &addr, sizeof(addr));
+                        if(bytes_sent < 0) {
+                            log_it(L_ERROR,"Some error occured in send() function");
+                            break;
+                        }
+                        total_sent += bytes_sent;
+                    }
+                    client->buf_out_size = 0;
+                }
+                LL_DELETE(sh->waiting_clients,client);
+            }
+            else if(client == NULL)
+            LL_DELETE(sh->waiting_clients,client);
+        }
+    }
+}
+
+/**
+ * @brief check_close Check if client need to close
+ * @param client Client structure
+ * @return 1 if client deleted, 0 if client is no need to delete
+ */
+int check_close(dap_udp_client_t* client){
+    if(client->signal_close)
+    {
+        dap_udp_server_t* sh = client->server;
+        dap_udp_client_t * client_check, * tmp;
+        LL_FOREACH_SAFE(sh->waiting_clients,client_check,tmp)
+            if(client_check->host_key == client->host_key)
+                LL_DELETE(sh->waiting_clients,client_check);
+        dap_udp_client_remove(client, sh);
+        return 1;
+    }
+    return 0;
+}
+
+/**
+ * @brief read_cb
+ */
+static void read_cb(struct ev_loop* loop, struct ev_io* watcher, int revents)
+{
+    if ( revents & EV_READ )
+    {
+        struct sockaddr_in clientaddr;
+        int clientlen = sizeof(clientaddr);
+        dap_udp_server_t* sh = watcher->data;
+        bzero(buf, BUFSIZE);
+        socklen_t bytes = recvfrom(sh->socket_listener, buf, BUFSIZE, 0,(struct sockaddr *) &clientaddr, &clientlen);
+        dap_udp_client_t *client = dap_udp_client_find(sh,clientaddr.sin_addr.s_addr,clientaddr.sin_port);
+        if(client != NULL && check_close(client) != 0)
+            return;
+        if(bytes > 0){
+            char * hostaddrp = inet_ntoa(clientaddr.sin_addr);
+            if(hostaddrp == NULL)
+            {
+                dap_udp_server_delete(sh);
+                error("ERROR on inet_ntoa\n");
+            }
+            if(client == NULL)
+            {
+                client = dap_udp_client_create(sh,&w_write,clientaddr.sin_addr.s_addr,clientaddr.sin_port);
+                if(client == NULL)
+                {
+                    dap_udp_server_delete(sh);
+                    error("ERROR create client structure\n");
+                }
+            }
+            size_t bytes_processed = 0;
+            size_t bytes_recieved = strlen(buf);
+            while(bytes_recieved > 0){
+                size_t bytes_to_transfer = 0;
+                if(bytes_recieved > UDP_CLIENT_BUF - client->buf_in_size)
+                    bytes_to_transfer = UDP_CLIENT_BUF - client->buf_in_size;
+                else
+                    bytes_to_transfer = bytes_recieved;
+                memcpy(client->buf_in + client->buf_in_size,buf+bytes_processed,bytes_to_transfer);
+                client->buf_in_size += bytes_to_transfer;
+                if(sh->client_read_callback)
+                    sh->client_read_callback(client,NULL);
+                bytes_processed += bytes_to_transfer;
+                bytes_recieved -= bytes_to_transfer;
+            }            
+        }
+        else if(bytes < 0)
+        {
+            log_it(L_ERROR,"Bytes read Error %s",strerror(errno));
+            if(client != NULL)
+                client->signal_close = true;
+
+        }
+        else if (bytes == 0)
+        {
+            if(client != NULL)
+                client->signal_close = true;
+        }
+    }
+}
+
+/**
+ * @brief dap_udp_server_loop Start server event loop
+ * @param sh Server instance
+ */
+void dap_udp_server_loop(dap_udp_server_t * sh){
+    sh->proc_thread.tid = pthread_self();
+
+    pthread_t thread;
+    pthread_create(&thread, NULL, dap_udp_client_loop, sh);
+    struct ev_loop * ev_main_loop = ev_default_loop(0);
+    w_read.data = sh;
+    ev_io_init(&w_read, read_cb, sh->socket_listener, EV_READ);
+    ev_io_start(ev_main_loop, &w_read);
+    ev_run(ev_main_loop, 0);
+}
+

udp_server/dap_udp_server.h

+/*
+ Copyright (c) 2017-2018 (c) Project "DeM Labs Inc" https://github.com/demlabsinc
+  All rights reserved.
+
+ This file is part of DAP (Deus Applications Prototypes) the open source project
+
+    DAP (Deus Applicaions Prototypes) is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    DAP 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 Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with any DAP based project.  If not, see <http://www.gnu.org/licenses/>.
+*/
+#pragma once
+#ifndef _UDP_SERVER_H_
+#define _UDP_SERVER_H_
+
+#include <stdint.h>
+#include <sys/socket.h>
+#include <netdb.h>
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/select.h>
+#include <sys/queue.h>
+#include "dap_udp_client.h"
+
+struct dap_udp_server;
+
+typedef struct dap_udp_thread{
+    pthread_t tid;
+} dap_udp_thread_t;
+
+typedef void (*dap_udp_server_callback_t) (struct dap_udp_server *,void * arg); // Callback for specific server's operations
+
+typedef struct dap_udp_server{
+    uint16_t port; // Listen port
+    char * address; // Listen address
+
+    dap_udp_client_t * clients; // Hashmap of clients
+    dap_udp_client_t * waiting_clients; // List clients for writing data
+
+    int socket_listener; // Socket for listener
+    int epoll_fd; // Epoll fd
+
+    struct sockaddr_in listener_addr; // Kernel structure for listener's binded address
+
+    void * _inheritor;  // Pointer to the internal data, HTTP for example
+
+    dap_udp_thread_t proc_thread;
+    pthread_mutex_t mutex_on_hash; 
+
+    dap_udp_server_callback_t server_delete_callback;
+
+    dap_udp_client_callback_t client_new_callback; // Create new client callback
+    dap_udp_client_callback_t client_delete_callback; // Delete client callback
+    dap_udp_client_callback_t client_read_callback; // Read function
+    dap_udp_client_callback_t client_write_callback; // Write function
+    dap_udp_client_callback_t client_error_callback; // Error processing function
+
+} dap_udp_server_t;
+
+extern int dap_udp_server_init(); // Init server module
+
+extern void dap_udp_server_deinit(); // Deinit server module
+
+extern void dap_udp_server_delete(dap_udp_server_t * sh); 
+
+extern void dap_udp_server_loop(dap_udp_server_t* udp_server);      // Start server event loop
+
+extern dap_udp_server_t* dap_udp_server_listen(uint16_t port);      // Create and bind server
+
+#endif
+
+