From c198a21f6da1768e719ea1609e6ca3b53569a0ab Mon Sep 17 00:00:00 2001 From: =?utf8?q?Marek=20Vavru=C5=A1a?= Date: Tue, 31 Mar 2015 19:42:58 +0200 Subject: [PATCH] daemon/net: independent network manager --- daemon/daemon.mk | 4 +- daemon/io.c | 208 +++++++++++++++++++++++++++++++++++++++++ daemon/{tcp.h => io.h} | 8 +- daemon/main.c | 57 ++++------- daemon/network.c | 172 ++++++++++++++++++++++++++++++++++ daemon/network.h | 51 ++++++++++ daemon/tcp.c | 120 ------------------------ daemon/udp.c | 86 ----------------- daemon/udp.h | 23 ----- 9 files changed, 457 insertions(+), 272 deletions(-) create mode 100644 daemon/io.c rename daemon/{tcp.h => io.h} (78%) create mode 100644 daemon/network.c create mode 100644 daemon/network.h delete mode 100644 daemon/tcp.c delete mode 100644 daemon/udp.c delete mode 100644 daemon/udp.h diff --git a/daemon/daemon.mk b/daemon/daemon.mk index 6aff18725..918738d55 100644 --- a/daemon/daemon.mk +++ b/daemon/daemon.mk @@ -1,7 +1,7 @@ kresolved_SOURCES := \ daemon/layer/query.c \ - daemon/udp.c \ - daemon/tcp.c \ + daemon/io.c \ + daemon/network.c \ daemon/engine.c \ daemon/worker.c \ daemon/bindings.c \ diff --git a/daemon/io.c b/daemon/io.c new file mode 100644 index 000000000..88607dfdc --- /dev/null +++ b/daemon/io.c @@ -0,0 +1,208 @@ +/* Copyright (C) 2014 CZ.NIC, z.s.p.o. + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + */ + +#include +#include + +#include "daemon/io.h" +#include "daemon/network.h" +#include "daemon/worker.h" + +#define ENDPOINT_BUFSIZE 512 /**< This is an artificial limit for DNS query. */ + +static void *buf_alloc(void) +{ + struct endpoint_data *data = malloc(sizeof(*data) + ENDPOINT_BUFSIZE); + if (data == NULL) { + return NULL; + } + data->buf = uv_buf_init((char *)data + sizeof(*data), ENDPOINT_BUFSIZE); + return data; +} + +static void buf_get(uv_handle_t* handle, size_t suggested_size, uv_buf_t* buf) +{ + struct endpoint_data *data = handle->data; + *buf = data->buf; +} + +static void buf_free(uv_handle_t* handle) +{ + free(handle->data); +} + +static void udp_send(uv_udp_t *handle, knot_pkt_t *answer, const struct sockaddr *addr) +{ + uv_buf_t sendbuf = uv_buf_init((char *)answer->wire, answer->size); + uv_udp_try_send(handle, &sendbuf, 1, addr); +} + +static void udp_recv(uv_udp_t *handle, ssize_t nread, const uv_buf_t *buf, + const struct sockaddr *addr, unsigned flags) +{ + uv_loop_t *loop = handle->loop; + struct worker_ctx *worker = loop->data; + + /* Check the incoming wire length. */ + if (nread < KNOT_WIRE_HEADER_SIZE) { + return; + } + + /* Create packets */ + knot_pkt_t *query = knot_pkt_new(buf->base, nread, worker->mm); + knot_pkt_t *answer = knot_pkt_new(NULL, KNOT_WIRE_MAX_PKTSIZE, worker->mm); + + /* Resolve */ + int ret = worker_exec(worker, answer, query); + if (ret == KNOT_EOK && answer->size > 0) { + udp_send(handle, answer, addr); + } + + /* Cleanup */ + knot_pkt_free(&query); + knot_pkt_free(&answer); +} + +int udp_bind(struct endpoint *ep, struct sockaddr *addr) +{ + uv_udp_t *handle = &ep->udp; + int ret = uv_udp_bind(handle, addr, 0); + if (ret != 0) { + return ret; + } + + handle->data = buf_alloc(); + if (handle->data == NULL) { + udp_unbind(ep); + return kr_error(ENOMEM); + } + + uv_udp_recv_start(handle, &buf_get, &udp_recv); + return 0; +} + +void udp_unbind(struct endpoint *ep) +{ + uv_udp_t *handle = &ep->udp; + uv_udp_recv_stop(handle); + buf_free((uv_handle_t *)handle); + uv_close((uv_handle_t *)handle, NULL); +} + +static void tcp_unbind_handle(uv_handle_t *handle) +{ + uv_read_stop((uv_stream_t *)handle); + buf_free(handle); + uv_close(handle, NULL); +} + +static void tcp_send(uv_handle_t *handle, const knot_pkt_t *answer) +{ + uint16_t pkt_size = htons(answer->size); + uv_buf_t buf[2]; + buf[0].base = (char *)&pkt_size; + buf[0].len = sizeof(pkt_size); + buf[1].base = (char *)answer->wire; + buf[1].len = answer->size; + + uv_try_write((uv_stream_t *)handle, buf, 2); +} + +static void tcp_recv(uv_stream_t *handle, ssize_t nread, const uv_buf_t *buf) +{ + uv_loop_t *loop = handle->loop; + struct worker_ctx *worker = loop->data; + + /* Check the incoming wire length (malformed, EOF or error). */ + if (nread < (ssize_t) sizeof(uint16_t)) { + tcp_unbind_handle((uv_handle_t *)handle); + free(handle); + return; + } + + /* Set packet size */ + nread = wire_read_u16((const uint8_t *)buf->base); + + /* Create packets */ + knot_pkt_t *query = knot_pkt_new(buf->base + sizeof(uint16_t), nread, worker->mm); + knot_pkt_t *answer = knot_pkt_new(NULL, KNOT_WIRE_MAX_PKTSIZE, worker->mm); + + /* Resolve */ + int ret = worker_exec(worker, answer, query); + if (ret == KNOT_EOK && answer->size > 0) { + tcp_send((uv_handle_t *)handle, answer); + } + + /* Cleanup */ + knot_pkt_free(&query); + knot_pkt_free(&answer); +} + +static void tcp_accept(uv_stream_t *master, int status) +{ + if (status != 0) { + return; + } + + uv_tcp_t *client = malloc(sizeof(uv_tcp_t)); + if (client == NULL) { + return; + } + + uv_tcp_init(master->loop, client); + client->data = buf_alloc(); + if (client->data == NULL) { + tcp_unbind_handle((uv_handle_t *)client); + free(client); + return; + } + + if (uv_accept(master, (uv_stream_t*)client) != 0) { + tcp_unbind_handle((uv_handle_t *)client); + free(client); + return; + } + + uv_read_start((uv_stream_t*)client, buf_get, tcp_recv); +} + +int tcp_bind(struct endpoint *ep, struct sockaddr *addr) +{ + uv_tcp_t *handle = &ep->tcp; + int ret = uv_tcp_bind(handle, addr, 0); + if (ret != 0) { + return ret; + } + + ret = uv_listen((uv_stream_t *)handle, 16, tcp_accept); + if (ret != 0) { + tcp_unbind(ep); + return ret; + } + + handle->data = buf_alloc(); + if (handle->data == NULL) { + tcp_unbind(ep); + return kr_error(ENOMEM); + } + + return 0; +} + +void tcp_unbind(struct endpoint *ep) +{ + tcp_unbind_handle((uv_handle_t *)&ep->tcp); +} diff --git a/daemon/tcp.h b/daemon/io.h similarity index 78% rename from daemon/tcp.h rename to daemon/io.h index 964ba3e90..b5b0116be 100644 --- a/daemon/tcp.h +++ b/daemon/io.h @@ -17,7 +17,9 @@ #pragma once #include -#include "worker.h" +struct endpoint; -int tcp_bind(uv_handle_t *handle, struct worker_ctx *worker, struct sockaddr *addr); -void tcp_unbind(uv_handle_t *handle); +int udp_bind(struct endpoint *ep, struct sockaddr *addr); +void udp_unbind(struct endpoint *ep); +int tcp_bind(struct endpoint *ep, struct sockaddr *addr); +void tcp_unbind(struct endpoint *ep); \ No newline at end of file diff --git a/daemon/main.c b/daemon/main.c index 41411e66f..75cb473d6 100644 --- a/daemon/main.c +++ b/daemon/main.c @@ -22,8 +22,8 @@ #include "lib/defines.h" #include "lib/resolve.h" -#include "daemon/udp.h" -#include "daemon/tcp.h" +#include "daemon/network.h" +#include "daemon/worker.h" #include "daemon/engine.h" #include "daemon/bindings.h" @@ -63,27 +63,21 @@ static void help(int argc, char *argv[]) " [rundir] Path to the working directory (default: .)\n"); } -static int set_addr(struct sockaddr_storage *ss, char *addr) +static const char *set_addr(char *addr, int *port) { - char *port = strchr(addr, '#'); - if (port) { - sockaddr_port_set(ss, atoi(port + 1)); - *port = '\0'; + char *p = strchr(addr, '#'); + if (p) { + *port = atoi(p + 1); + *p = '\0'; } - int family = AF_INET; - if (strchr(addr, ':')) { - family = AF_INET6; - } - - return sockaddr_set(ss, family, addr, sockaddr_port(ss)); + return addr; } int main(int argc, char **argv) { - - struct sockaddr_storage addr; - sockaddr_set(&addr, AF_INET, "127.0.0.1", 53); + const char *addr = "127.0.0.1"; + int port = 53; /* Long options. */ int c = 0, li = 0, ret = 0; @@ -97,11 +91,7 @@ int main(int argc, char **argv) switch (c) { case 'a': - ret = set_addr(&addr, optarg); - if (ret != 0) { - fprintf(stderr, "[system]: address '%s': %s\n", optarg, knot_strerror(ret)); - return EXIT_FAILURE; - } + addr = set_addr(optarg, &port); break; case 'v': printf("%s, version %s\n", "Knot DNS Resolver", PACKAGE_VERSION); @@ -153,24 +143,14 @@ int main(int argc, char **argv) .loop = loop, .mm = NULL }; + loop->data = &worker; /* Bind to sockets. */ - char addr_str[SOCKADDR_STRLEN] = {'\0'}; - sockaddr_tostr(addr_str, sizeof(addr_str), &addr); - uv_udp_t udp_sock; - uv_udp_init(loop, &udp_sock); - uv_tcp_t tcp_sock; - uv_tcp_init(loop, &tcp_sock); - printf("[system] listening on '%s/UDP'\n", addr_str); - ret = udp_bind((uv_handle_t *)&udp_sock, &worker, (struct sockaddr *)&addr); - if (ret == 0) { - printf("[system] listening on '%s/TCP'\n", addr_str); - ret = tcp_bind((uv_handle_t *)&tcp_sock, &worker, (struct sockaddr *)&addr); - } - - /* Check results */ + struct network net; + network_init(&net, loop); + ret = network_listen(&net, addr, (uint16_t)port, NET_UDP|NET_TCP); if (ret != 0) { - fprintf(stderr, "[system] bind to '%s' %s\n", addr_str, knot_strerror(ret)); + fprintf(stderr, "[system] bind to '%s#%d' %s\n", addr, port, knot_strerror(ret)); ret = EXIT_FAILURE; } else { /* Allocate TTY */ @@ -181,6 +161,7 @@ int main(int argc, char **argv) /* Interactive stdin */ if (!feof(stdin)) { + printf("[system] listening on '%s#%d'\n", addr, port); printf("[system] started in interactive mode, type 'help()'\n"); tty_read(NULL, 0, NULL); uv_read_start((uv_stream_t*) &pipe, tty_alloc, tty_read); @@ -191,8 +172,8 @@ int main(int argc, char **argv) /* Cleanup. */ fprintf(stderr, "\n[system] quitting\n"); - udp_unbind((uv_handle_t *)&udp_sock); - tcp_unbind((uv_handle_t *)&tcp_sock); + network_deinit(&net); + engine_deinit(&engine); return ret; } diff --git a/daemon/network.c b/daemon/network.c new file mode 100644 index 000000000..2b3af1780 --- /dev/null +++ b/daemon/network.c @@ -0,0 +1,172 @@ +/* Copyright (C) 2015 CZ.NIC, z.s.p.o. + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + */ + +#include "daemon/network.h" +#include "daemon/worker.h" +#include "daemon/io.h" + +void network_init(struct network *net, uv_loop_t *loop) +{ + if (net != NULL) { + /* No multiplexing now, I/O in single thread. */ + net->loop = loop; + net->endpoints = map_make(); + } +} + +/** Close endpoint protocols. */ +static int close_endpoint(struct endpoint *ep) +{ + if (ep->flags & NET_UDP) { + udp_unbind(ep); + } + if (ep->flags & NET_TCP) { + tcp_unbind(ep); + } + + free(ep); + return kr_ok(); +} + +/** Endpoint visitor (see @file map.h) */ +static int visit_key(const char *key, void *val, void *ext) +{ + int (*callback)(struct endpoint *) = ext; + endpoint_array_t *ep_array = val; + for (size_t i = ep_array->len; i--;) { + callback(ep_array->at[i]); + } + return 0; +} + +static int free_key(const char *key, void *val, void *ext) +{ + endpoint_array_t *ep_array = val; + array_clear(*ep_array); + free(ep_array); + return kr_ok(); +} + +void network_deinit(struct network *net) +{ + if (net != NULL) { + map_walk(&net->endpoints, visit_key, close_endpoint); + map_walk(&net->endpoints, free_key, 0); + map_clear(&net->endpoints); + } +} + +/** Fetch or create endpoint array and insert endpoint. */ +static int insert_endpoint(struct network *net, const char *addr, struct endpoint *ep) +{ + /* Fetch or insert address into map */ + endpoint_array_t *ep_array = map_get(&net->endpoints, addr); + if (ep_array == NULL) { + ep_array = malloc(sizeof(*ep_array)); + if (ep_array == NULL) { + return kr_error(ENOMEM); + } + if (map_set(&net->endpoints, addr, ep_array) != 0) { + free(ep_array); + return kr_error(ENOMEM); + } + array_init(*ep_array); + } + + return array_push(*ep_array, ep); +} + +/** Open endpoint protocols. */ +static int open_endpoint(struct network *net, struct endpoint *ep, struct sockaddr *sa, uint32_t flags) +{ + if (flags & NET_UDP) { + uv_udp_init(net->loop, &ep->udp); + int ret = udp_bind(ep, sa); + if (ret != 0) { + return ret; + } + ep->flags |= NET_UDP; + } + if (flags & NET_TCP) { + uv_tcp_init(net->loop, &ep->tcp); + int ret = tcp_bind(ep, sa); + if (ret != 0) { + return ret; + } + ep->flags |= NET_TCP; + } + return kr_ok(); +} + +int network_listen(struct network *net, const char *addr, uint16_t port, uint32_t flags) +{ + if (net == NULL || addr == 0 || port == 0) { + return kr_error(EINVAL); + } + + /* Parse address. */ + int ret = 0; + struct sockaddr_storage sa; + if (strchr(addr, ':') != NULL) { + ret = uv_ip6_addr(addr, port, (struct sockaddr_in6 *)&sa); + } else { + ret = uv_ip4_addr(addr, port, (struct sockaddr_in *)&sa); + } + if (ret != 0) { + return ret; + } + + /* Bind interfaces */ + struct endpoint *ep = malloc(sizeof(*ep)); + memset(ep, 0, sizeof(*ep)); + ep->flags = NET_DOWN; + ep->port = port; + ret = open_endpoint(net, ep, (struct sockaddr *)&sa, flags); + if (ret == 0) { + ret = insert_endpoint(net, addr, ep); + } + if (ret != 0) { + close_endpoint(ep); + } + + return ret; +} + +int network_close(struct network *net, const char *addr, uint16_t port) +{ + endpoint_array_t *ep_array = map_get(&net->endpoints, addr); + if (ep_array == NULL) { + return kr_error(ENOENT); + } + + /* Close endpoint in array. */ + for (size_t i = ep_array->len; i--;) { + struct endpoint *ep = ep_array->at[i]; + if (ep->port == port) { + close_endpoint(ep); + array_del(*ep_array, i); + break; + } + } + + /* Collapse key if it has no endpoint. */ + if (ep_array->len == 0) { + free(ep_array); + map_del(&net->endpoints, addr); + } + + return kr_ok(); +} diff --git a/daemon/network.h b/daemon/network.h new file mode 100644 index 000000000..8048c9ef6 --- /dev/null +++ b/daemon/network.h @@ -0,0 +1,51 @@ +/* Copyright (C) 2015 CZ.NIC, z.s.p.o. + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + */ + +#pragma once + +#include + +#include "lib/generic/array.h" +#include "lib/generic/map.h" + +enum endpoint_flag { + NET_DOWN = 0 << 0, + NET_UDP = 1 << 0, + NET_TCP = 1 << 1 +}; + +struct endpoint_data { + uv_buf_t buf; +}; + +struct endpoint { + uv_udp_t udp; + uv_tcp_t tcp; + uint16_t port; + uint16_t flags; +}; + +typedef array_t(struct endpoint*) endpoint_array_t; + +struct network { + uv_loop_t *loop; + map_t endpoints; +}; + +void network_init(struct network *net, uv_loop_t *loop); +void network_deinit(struct network *net); +int network_listen(struct network *net, const char *addr, uint16_t port, uint32_t flags); +int network_close(struct network *net, const char *addr, uint16_t port); diff --git a/daemon/tcp.c b/daemon/tcp.c deleted file mode 100644 index 817925716..000000000 --- a/daemon/tcp.c +++ /dev/null @@ -1,120 +0,0 @@ -/* Copyright (C) 2014 CZ.NIC, z.s.p.o. - - This program is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - This program 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 General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program. If not, see . - */ - -#include -#include - -#include "daemon/tcp.h" -#include "daemon/worker.h" - -static void buf_alloc(uv_handle_t* handle, size_t suggested_size, uv_buf_t* buf) -{ - struct worker_ctx *worker = handle->data; - buf->base = mm_alloc(worker->mm, suggested_size); - buf->len = suggested_size; -} - -static void buf_free(uv_handle_t* handle, const uv_buf_t* buf) -{ - struct worker_ctx *worker = handle->data; - mm_free(worker->mm, buf->base); -} - -static void tcp_send(uv_handle_t *handle, const knot_pkt_t *answer) -{ - uint16_t pkt_size = 0; - uv_buf_t buf[2]; - buf[0].base = (char *)&pkt_size; - buf[0].len = sizeof(pkt_size); - buf[1].base = (char *)answer->wire; - buf[1].len = answer->size; - wire_write_u16((uint8_t *)buf[0].base, answer->size); - - uv_try_write((uv_stream_t *)handle, buf, 2); -} - -static void tcp_recv(uv_stream_t *handle, ssize_t nread, const uv_buf_t *buf) -{ - struct worker_ctx *worker = handle->data; - - /* Check the incoming wire length (malformed, EOF or error). */ - if (nread < (ssize_t) sizeof(uint16_t)) { - buf_free((uv_handle_t *)handle, buf); - tcp_unbind((uv_handle_t *)handle); - free(handle); - return; - } - - /* Set packet size */ - nread = wire_read_u16((const uint8_t *)buf->base); - - /* Create packets */ - knot_pkt_t *query = knot_pkt_new(buf->base + sizeof(uint16_t), nread, worker->mm); - knot_pkt_t *answer = knot_pkt_new(NULL, KNOT_WIRE_MAX_PKTSIZE, worker->mm); - - /* Resolve */ - int ret = worker_exec(worker, answer, query); - if (ret == KNOT_EOK && answer->size > 0) { - tcp_send((uv_handle_t *)handle, answer); - } - - /* Cleanup */ - knot_pkt_free(&query); - knot_pkt_free(&answer); - buf_free((uv_handle_t *)handle, buf); -} - -static void tcp_accept(uv_stream_t *server, int status) -{ - if (status != 0) { - return; - } - - uv_tcp_t *client = malloc(sizeof(uv_tcp_t)); - uv_tcp_init(server->loop, client); - client->data = server->data; - - if (uv_accept(server, (uv_stream_t*)client) != 0) { - uv_close((uv_handle_t*)client, NULL); - free(client); - } - - uv_read_start((uv_stream_t*)client, buf_alloc, tcp_recv); -} - -int tcp_bind(uv_handle_t *handle, struct worker_ctx *worker, struct sockaddr *addr) -{ - uv_tcp_t *sock = (uv_tcp_t *)handle; - - int ret = uv_tcp_bind(sock, addr, 0); - if (ret != 0) { - return KNOT_ERROR; - } - - ret = uv_listen((uv_stream_t *)sock, 128, tcp_accept); - if (ret != 0) { - return KNOT_ERROR; - } - - sock->data = worker; - return KNOT_EOK; -} - -void tcp_unbind(uv_handle_t *handle) -{ - uv_udp_recv_stop((uv_udp_t *)handle); - uv_close(handle, NULL); -} diff --git a/daemon/udp.c b/daemon/udp.c deleted file mode 100644 index 47a684836..000000000 --- a/daemon/udp.c +++ /dev/null @@ -1,86 +0,0 @@ -/* Copyright (C) 2014 CZ.NIC, z.s.p.o. - - This program is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - This program 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 General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program. If not, see . - */ - -#include - -#include "daemon/udp.h" -#include "daemon/worker.h" - -static void buf_alloc(uv_handle_t* handle, size_t suggested_size, uv_buf_t* buf) -{ - struct worker_ctx *worker = handle->data; - buf->base = mm_alloc(worker->mm, suggested_size); - buf->len = suggested_size; -} - -static void buf_free(uv_handle_t* handle, const uv_buf_t* buf) -{ - struct worker_ctx *worker = handle->data; - mm_free(worker->mm, buf->base); -} - -static void udp_send(uv_udp_t *handle, knot_pkt_t *answer, const struct sockaddr *addr) -{ - uv_buf_t sendbuf = uv_buf_init((char *)answer->wire, answer->size); - uv_udp_try_send(handle, &sendbuf, 1, addr); -} - -static void udp_recv(uv_udp_t *handle, ssize_t nread, const uv_buf_t *buf, - const struct sockaddr *addr, unsigned flags) -{ - struct worker_ctx *worker = handle->data; - - /* Check the incoming wire length. */ - if (nread < KNOT_WIRE_HEADER_SIZE) { - buf_free((uv_handle_t *)handle, buf); - return; - } - - /* Create packets */ - knot_pkt_t *query = knot_pkt_new(buf->base, nread, worker->mm); - knot_pkt_t *answer = knot_pkt_new(NULL, KNOT_WIRE_MAX_PKTSIZE, worker->mm); - - /* Resolve */ - int ret = worker_exec(worker, answer, query); - if (ret == KNOT_EOK && answer->size > 0) { - udp_send(handle, answer, addr); - } - - /* Cleanup */ - buf_free((uv_handle_t *)handle, buf); - knot_pkt_free(&query); - knot_pkt_free(&answer); -} - -int udp_bind(uv_handle_t *handle, struct worker_ctx *worker, struct sockaddr *addr) -{ - uv_udp_t *sock = (uv_udp_t *)handle; - - int ret = uv_udp_bind(sock, addr, 0); - if (ret != 0) { - return KNOT_ERROR; - } - - sock->data = worker; - uv_udp_recv_start(sock, &buf_alloc, &udp_recv); - return KNOT_EOK; -} - -void udp_unbind(uv_handle_t *handle) -{ - uv_udp_recv_stop((uv_udp_t *)handle); - uv_close(handle, NULL); -} diff --git a/daemon/udp.h b/daemon/udp.h deleted file mode 100644 index abc598cb3..000000000 --- a/daemon/udp.h +++ /dev/null @@ -1,23 +0,0 @@ -/* Copyright (C) 2014 CZ.NIC, z.s.p.o. - - This program is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - This program 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 General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program. If not, see . - */ - -#pragma once - -#include -#include "worker.h" - -int udp_bind(uv_handle_t *handle, struct worker_ctx *worker, struct sockaddr *addr); -void udp_unbind(uv_handle_t *handle); -- 2.47.2