From 8e763bca55b0f10dd33cccf3cbd79b979351f67b Mon Sep 17 00:00:00 2001
From: "Dmitriy A. Gerasimov" <dmitriy.gerasimov@demlabs.net>
Date: Mon, 1 Oct 2018 20:56:30 +0700
Subject: [PATCH] [*] UDP server returned back to the codebase
---
CMakeLists.txt | 1 +
udp_server/CMakeLists.txt | 10 ++
udp_server/dap_udp_client.c | 205 +++++++++++++++++++++++++++
udp_server/dap_udp_client.h | 66 +++++++++
udp_server/dap_udp_server.c | 266 ++++++++++++++++++++++++++++++++++++
udp_server/dap_udp_server.h | 63 +++++++++
6 files changed, 611 insertions(+)
create mode 100644 udp_server/CMakeLists.txt
create mode 100644 udp_server/dap_udp_client.c
create mode 100644 udp_server/dap_udp_client.h
create mode 100644 udp_server/dap_udp_server.c
create mode 100644 udp_server/dap_udp_server.h
diff --git a/CMakeLists.txt b/CMakeLists.txt
index d40442b..7f46a9a 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -3,3 +3,4 @@ cmake_minimum_required(VERSION 3.0)
add_subdirectory(http_server)
add_subdirectory(enc_server)
+add_subdirectory(udp_server)
diff --git a/udp_server/CMakeLists.txt b/udp_server/CMakeLists.txt
new file mode 100644
index 0000000..e6037ca
--- /dev/null
+++ b/udp_server/CMakeLists.txt
@@ -0,0 +1,10 @@
+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)
+
+add_library(${PROJECT_NAME} STATIC ${DAP_UDP_SERVER_SRCS})
+
+target_link_libraries(dap_udp_server dap_core dap_core_server)
+
+target_include_directories(dap_udp_server INTERFACE .)
diff --git a/udp_server/dap_udp_client.c b/udp_server/dap_udp_client.c
new file mode 100644
index 0000000..056f1d5
--- /dev/null
+++ b/udp_server/dap_udp_client.c
@@ -0,0 +1,205 @@
+/*
+ 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_udp_server.h"
+
+#define LOG_TAG "udp_client"
+
+/**
+ * @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_server_client_t * dap_udp_client_create(dap_server_t * sh, ev_io* w_client, unsigned long host, unsigned short port)
+{
+ dap_udp_server_t* udp_server = DAP_UDP_SERVER(sh);
+ log_it(L_DEBUG,"Client structure create");
+
+ dap_udp_client_t * inh=DAP_NEW_Z(dap_udp_client_t);
+ inh->host_key = get_key(host,port);
+
+ dap_server_client_t * ret=DAP_NEW_Z(dap_server_client_t);
+ inh->client = ret;
+ ret->server = sh;
+ ret->watcher_client = w_client;
+ ret->signal_close = false;
+ ret->_ready_to_read=true;
+ ret->_ready_to_write=false;
+ ret->_inheritor = inh;
+ pthread_mutex_init(&inh->mutex_on_client, NULL);
+
+ pthread_mutex_lock(&udp_server->mutex_on_list);
+ HASH_ADD_INT( udp_server->clients, host_key, inh);
+ pthread_mutex_unlock(&udp_server->mutex_on_list);
+ if(sh->client_new_callback)
+ sh->client_new_callback(ret,NULL); // Init internal structure
+
+
+ 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_server_client_t *client, unsigned int* host,unsigned short* port){
+ dap_udp_client_t* udp_client = DAP_UDP_CLIENT(client);
+ *host = udp_client->host_key >> 32;
+ *port = udp_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_server_client_t * dap_udp_client_find(dap_server_t * sh, unsigned long host,unsigned short port)
+{
+ dap_udp_server_t* udp_server = DAP_UDP_SERVER(sh);
+ pthread_mutex_lock(&udp_server->mutex_on_list);
+ dap_udp_client_t* inh = NULL;
+
+ uint64_t token = get_key(host,port);
+ HASH_FIND_INT(udp_server->clients,&token,inh);
+
+ pthread_mutex_unlock(&udp_server->mutex_on_list);
+ if(inh == NULL)
+ return NULL;
+ else
+ return inh->client;
+}
+
+/**
+ * @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_server_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_server_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 add_waiting_client Add Client to write queue
+ * @param client Client instance
+ */
+void add_waiting_client(dap_server_client_t* client){
+ dap_server_t* sh = client->server;
+ dap_udp_server_t* udp_server = DAP_UDP_SERVER(sh);
+ dap_udp_client_t* udp_client = DAP_UDP_CLIENT(client);
+
+ pthread_mutex_lock(&udp_server->mutex_on_list);
+ dap_udp_client_t* udp_cl, *tmp;
+ LL_FOREACH_SAFE(udp_server->waiting_clients,udp_cl,tmp)
+ if(udp_cl == udp_client)
+ {
+ pthread_mutex_unlock(&udp_server->mutex_on_list);
+ return;
+ }
+ LL_APPEND(udp_server->waiting_clients, udp_client);
+ pthread_mutex_unlock(&udp_server->mutex_on_list);
+
+}
+
+size_t dap_udp_client_write(dap_server_client_t *sc, const void * data, size_t data_size){
+ size_t size = dap_client_write(sc,data,data_size);
+ add_waiting_client(sc);
+ return size;
+}
+
+size_t dap_udp_client_write_f(dap_server_client_t *a_client, const char * a_format,...){
+ size_t size = 0;
+ va_list ap;
+ va_start(ap,a_format);
+ size =dap_client_write_f(a_client,a_format,ap);
+ va_end(ap);
+ add_waiting_client(a_client);
+ return size;
+}
+
diff --git a/udp_server/dap_udp_client.h b/udp_server/dap_udp_client.h
new file mode 100644
index 0000000..4304c5c
--- /dev/null
+++ b/udp_server/dap_udp_client.h
@@ -0,0 +1,66 @@
+/*
+ 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 "dap_server_client.h"
+#include <ev.h>
+
+
+typedef struct dap_udp_server dap_udp_server_t;
+struct dap_udp_client;
+
+#define UDP_CLIENT_BUF 100000
+
+typedef struct dap_udp_client{
+ dap_server_client_t* client;
+ uint64_t host_key; //key contains host address in first 4 bytes and port in last 4 bytes
+
+ UT_hash_handle hh;
+ struct dap_udp_client *next, *prev; //pointers for writing queue
+ pthread_mutex_t mutex_on_client;
+
+ void * _inheritor; // Internal data to specific client type, usualy states for state machine
+} dap_udp_client_t; // Node of bidirectional list of clients
+
+#define DAP_UDP_CLIENT(a) ((dap_udp_client_t *) (a)->_inheritor)
+
+
+dap_server_client_t * dap_udp_client_create(dap_server_t * sh, ev_io* w_client, unsigned long host, unsigned short port); // Create new client and add it to the list
+dap_server_client_t * dap_udp_client_find(dap_server_t * sh, unsigned long host, unsigned short port); // Find client by host and port
+
+void dap_udp_client_ready_to_read(dap_server_client_t * sc,bool is_ready);
+void dap_udp_client_ready_to_write(dap_server_client_t * sc,bool is_ready);
+
+size_t dap_udp_client_write(dap_server_client_t *sc, const void * data, size_t data_size);
+size_t dap_udp_client_write_f(dap_server_client_t *a_client, const char * a_format,...);
+
+void add_waiting_client(dap_server_client_t* client); // Add client to writing queue
+
+void dap_udp_client_get_address(dap_server_client_t *client, unsigned int* host,unsigned short* port);
+
+#endif
diff --git a/udp_server/dap_udp_server.c b/udp_server/dap_udp_server.c
new file mode 100644
index 0000000..e7942db
--- /dev/null
+++ b/udp_server/dap_udp_server.c
@@ -0,0 +1,266 @@
+#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);
+int check_close(dap_server_client_t* client);
+
+/**
+ */
+void error(char *msg) {
+ perror(msg);
+ exit(1);
+}
+
+/**
+ * @brief dap_udp_server_new Initialize server structure
+ * @return Server pointer
+ */
+dap_server_t * dap_udp_server_new()
+{
+ dap_udp_server_t* udp_server = (dap_udp_server_t*)calloc(1,sizeof(dap_udp_server_t));
+ udp_server->waiting_clients = NULL;
+ dap_server_t* sh = (dap_server_t*) calloc(1,sizeof(dap_server_t));
+ sh->_inheritor = udp_server;
+ udp_server->dap_server = sh;
+ return sh;
+}
+
+/**
+ * @brief dap_udp_client_loop Create client listening event loop
+ */
+void* dap_udp_client_loop(void * arg)
+{
+ dap_server_t* sh = (dap_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_server_t * sh)
+{
+ if(sh->address)
+ free(sh->address);
+
+ dap_server_client_t * client, * tmp;
+ HASH_ITER(hh,sh->clients,client,tmp)
+ dap_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_server_t * dap_udp_server_listen(uint16_t port){
+ dap_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;
+ }
+ pthread_mutex_init(&DAP_UDP_SERVER(sh)->mutex_on_list, 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_server_t* sh = watcher->data;
+ dap_udp_server_t* udp = DAP_UDP_SERVER(sh);
+ dap_udp_client_t * udp_client, * tmp;
+ pthread_mutex_lock(&udp->mutex_on_list);
+ LL_FOREACH_SAFE(udp->waiting_clients,udp_client,tmp)
+ {
+ //log_it(L_INFO,"write_cb");
+ //pthread_mutex_lock(&udp_client->mutex_on_client);
+ dap_server_client_t* client = udp_client->client;
+ 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)
+ {
+ //log_it(L_INFO,"write_cb_client");
+ 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;
+ bzero(client->buf_out, DAP_CLIENT_REMOTE_BUF + 1);
+
+ }
+ LL_DELETE(udp->waiting_clients,udp_client);
+ }
+ else if(client == NULL)
+ LL_DELETE(udp->waiting_clients,udp_client);
+ //pthread_mutex_unlock(&udp_client->mutex_on_client);
+ }
+ pthread_mutex_unlock(&udp->mutex_on_list);
+ }
+}
+
+/**
+ * @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_server_client_t* client){
+ if(client->signal_close)
+ {
+ dap_udp_client_t* udp_client = DAP_UDP_CLIENT(client);
+ dap_server_t* sh = client->server;
+ dap_udp_server_t* udp_server = DAP_UDP_SERVER(sh);
+ dap_udp_client_t * client_check, * tmp;
+ LL_FOREACH_SAFE(udp_server->waiting_clients,client_check,tmp)
+ if(client_check->host_key == udp_client->host_key)
+ LL_DELETE(udp_server->waiting_clients,client_check);
+ dap_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)
+{
+ //log_it(L_INFO,"read_cb");
+ if ( revents & EV_READ )
+ {
+ struct sockaddr_in clientaddr;
+ int clientlen = sizeof(clientaddr);
+ dap_server_t* sh = watcher->data;
+ bzero(buf, BUFSIZE);
+ socklen_t bytes = recvfrom(sh->socket_listener, buf, BUFSIZE, 0,(struct sockaddr *) &clientaddr, &clientlen);
+ dap_server_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");
+ }
+ }
+ dap_udp_client_t* udp_client = client->_inheritor;
+ pthread_mutex_lock(&udp_client->mutex_on_client);
+ size_t bytes_processed = 0;
+ size_t bytes_recieved = bytes;
+ 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;
+ }
+ client->buf_in_size = 0;
+ bzero(client->buf_in, DAP_CLIENT_REMOTE_BUF + 1);
+ pthread_mutex_unlock(&udp_client->mutex_on_client);
+
+ }
+ 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_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);
+}
+
diff --git a/udp_server/dap_udp_server.h b/udp_server/dap_udp_server.h
new file mode 100644
index 0000000..d0deb3d
--- /dev/null
+++ b/udp_server/dap_udp_server.h
@@ -0,0 +1,63 @@
+/*
+ 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"
+#include "dap_server.h"
+#include "dap_server_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{
+ dap_udp_client_t * clients;
+ dap_udp_client_t * waiting_clients; // List clients for writing data
+ pthread_mutex_t mutex_on_list;
+ void* _inheritor;
+ dap_server_t* dap_server;
+} dap_udp_server_t;
+
+#define DAP_UDP_SERVER(a) ((dap_udp_server_t *) (a)->_inheritor)
+
+extern void dap_udp_server_delete(dap_server_t * sh);
+
+extern void dap_udp_server_loop(dap_server_t* udp_server); // Start server event loop
+
+extern dap_server_t* dap_udp_server_listen(uint16_t port); // Create and bind server
+
+#endif
+
+
--
GitLab