contrib/unbound/services/listen_dnsport.h

   1 /*
   2  * services/listen_dnsport.h - listen on port 53 for incoming DNS queries.
   3  *
   4  * Copyright (c) 2007, NLnet Labs. All rights reserved.
   5  *
   6  * This software is open source.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  *
  12  * Redistributions of source code must retain the above copyright notice,
  13  * this list of conditions and the following disclaimer.
  14  *
  15  * Redistributions in binary form must reproduce the above copyright notice,
  16  * this list of conditions and the following disclaimer in the documentation
  17  * and/or other materials provided with the distribution.
  18  *
  19  * Neither the name of the NLNET LABS nor the names of its contributors may
  20  * be used to endorse or promote products derived from this software without
  21  * specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  24  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  25  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  26  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  27  * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  28  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
  29  * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  30  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  31  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  32  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  33  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  34  */
  35
  36 /**
  37  * \file
  38  *
  39  * This file has functions to get queries from clients.
  40  */
  41
  42 #ifndef LISTEN_DNSPORT_H
  43 #define LISTEN_DNSPORT_H
  44
  45 #include "util/netevent.h"
  46 #ifdef HAVE_NGHTTP2_NGHTTP2_H
  47 #include <nghttp2/nghttp2.h>
  48 #endif
  49 struct listen_list;
  50 struct config_file;
  51 struct addrinfo;
  52 struct sldns_buffer;
  53 struct tcl_list;
  54
  55 /**
  56  * Listening for queries structure.
  57  * Contains list of query-listen sockets.
  58  */
  59 struct listen_dnsport {
  60         /** Base for select calls */
  61         struct comm_base* base;
  62
  63         /** buffer shared by UDP connections, since there is only one
  64             datagram at any time. */
  65         struct sldns_buffer* udp_buff;
  66 #ifdef USE_DNSCRYPT
  67         struct sldns_buffer* dnscrypt_udp_buff;
  68 #endif
  69         /** list of comm points used to get incoming events */
  70         struct listen_list* cps;
  71 };
  72
  73 /**
  74  * Single linked list to store event points.
  75  */
  76 struct listen_list {
  77         /** next in list */
  78         struct listen_list* next;
  79         /** event info */
  80         struct comm_point* com;
  81 };
  82
  83 /**
  84  * type of ports
  85  */
  86 enum listen_type {
  87         /** udp type */
  88         listen_type_udp,
  89         /** tcp type */
  90         listen_type_tcp,
  91         /** udp ipv6 (v4mapped) for use with ancillary data */
  92         listen_type_udpancil,
  93         /** ssl over tcp type */
  94         listen_type_ssl,
  95         /** udp type  + dnscrypt*/
  96         listen_type_udp_dnscrypt,
  97         /** tcp type + dnscrypt */
  98         listen_type_tcp_dnscrypt,
  99         /** udp ipv6 (v4mapped) for use with ancillary data + dnscrypt*/
 100         listen_type_udpancil_dnscrypt,
 101         /** HTTP(2) over TLS over TCP */
 102         listen_type_http
 103 };
 104
 105 /**
 106  * Single linked list to store shared ports that have been
 107  * opened for use by all threads.
 108  */
 109 struct listen_port {
 110         /** next in list */
 111         struct listen_port* next;
 112         /** file descriptor, open and ready for use */
 113         int fd;
 114         /** type of file descriptor, udp or tcp */
 115         enum listen_type ftype;
 116 };
 117
 118 /**
 119  * Create shared listening ports
 120  * Getaddrinfo, create socket, bind and listen to zero or more
 121  * interfaces for IP4 and/or IP6, for UDP and/or TCP.
 122  * On the given port number. It creates the sockets.
 123  * @param cfg: settings on what ports to open.
 124  * @param ifs: interfaces to open, array of IP addresses, "ip[@port]".
 125  * @param num_ifs: length of ifs.
 126  * @param reuseport: set to true if you want reuseport, or NULL to not have it,
 127  *   set to false on exit if reuseport failed to apply (because of no
 128  *   kernel support).
 129  * @return: linked list of ports or NULL on error.
 130  */
 131 struct listen_port* listening_ports_open(struct config_file* cfg,
 132         char** ifs, int num_ifs, int* reuseport);
 133
 134 /**
 135  * Close and delete the (list of) listening ports.
 136  */
 137 void listening_ports_free(struct listen_port* list);
 138
 139 /**
 140  * Resolve interface names in config and store result IP addresses
 141  * @param cfg: config
 142  * @param resif: string array (malloced array of malloced strings) with
 143  *      result.  NULL if cfg has none.
 144  * @param num_resif: length of resif.  Zero if cfg has zero num_ifs.
 145  * @return 0 on failure.
 146  */
 147 int resolve_interface_names(struct config_file* cfg, char*** resif,
 148         int* num_resif);
 149
 150 /**
 151  * Create commpoints with for this thread for the shared ports.
 152  * @param base: the comm_base that provides event functionality.
 153  *      for default all ifs.
 154  * @param ports: the list of shared ports.
 155  * @param bufsize: size of datagram buffer.
 156  * @param tcp_accept_count: max number of simultaneous TCP connections
 157  *      from clients.
 158  * @param tcp_idle_timeout: idle timeout for TCP connections in msec.
 159  * @param harden_large_queries: whether query size should be limited.
 160  * @param http_max_streams: maximum number of HTTP/2 streams per connection.
 161  * @param http_endpoint: HTTP endpoint to service queries on
 162  * @param http_notls: no TLS for http downstream
 163  * @param tcp_conn_limit: TCP connection limit info.
 164  * @param sslctx: nonNULL if ssl context.
 165  * @param dtenv: nonNULL if dnstap enabled.
 166  * @param cb: callback function when a request arrives. It is passed
 167  *        the packet and user argument. Return true to send a reply.
 168  * @param cb_arg: user data argument for callback function.
 169  * @return: the malloced listening structure, ready for use. NULL on error.
 170  */
 171 struct listen_dnsport*
 172 listen_create(struct comm_base* base, struct listen_port* ports,
 173         size_t bufsize, int tcp_accept_count, int tcp_idle_timeout,
 174         int harden_large_queries, uint32_t http_max_streams,
 175         char* http_endpoint, int http_notls, struct tcl_list* tcp_conn_limit,
 176         void* sslctx, struct dt_env* dtenv, comm_point_callback_type* cb,
 177         void *cb_arg);
 178
 179 /**
 180  * delete the listening structure
 181  * @param listen: listening structure.
 182  */
 183 void listen_delete(struct listen_dnsport* listen);
 184
 185 /**
 186  * delete listen_list of commpoints. Calls commpointdelete() on items.
 187  * This may close the fds or not depending on flags.
 188  * @param list: to delete.
 189  */
 190 void listen_list_delete(struct listen_list* list);
 191
 192 /**
 193  * get memory size used by the listening structs
 194  * @param listen: listening structure.
 195  * @return: size in bytes.
 196  */
 197 size_t listen_get_mem(struct listen_dnsport* listen);
 198
 199 /**
 200  * stop accept handlers for TCP (until enabled again)
 201  * @param listen: listening structure.
 202  */
 203 void listen_stop_accept(struct listen_dnsport* listen);
 204
 205 /**
 206  * start accept handlers for TCP (was stopped before)
 207  * @param listen: listening structure.
 208  */
 209 void listen_start_accept(struct listen_dnsport* listen);
 210
 211 /**
 212  * Create and bind nonblocking UDP socket
 213  * @param family: for socket call.
 214  * @param socktype: for socket call.
 215  * @param addr: for bind call.
 216  * @param addrlen: for bind call.
 217  * @param v6only: if enabled, IP6 sockets get IP6ONLY option set.
 218  *      if enabled with value 2 IP6ONLY option is disabled.
 219  * @param inuse: on error, this is set true if the port was in use.
 220  * @param noproto: on error, this is set true if cause is that the
 221         IPv6 proto (family) is not available.
 222  * @param rcv: set size on rcvbuf with socket option, if 0 it is not set.
 223  * @param snd: set size on sndbuf with socket option, if 0 it is not set.
 224  * @param listen: if true, this is a listening UDP port, eg port 53, and
 225  *      set SO_REUSEADDR on it.
 226  * @param reuseport: if nonNULL and true, try to set SO_REUSEPORT on
 227  *      listening UDP port.  Set to false on return if it failed to do so.
 228  * @param transparent: set IP_TRANSPARENT socket option.
 229  * @param freebind: set IP_FREEBIND socket option.
 230  * @param use_systemd: if true, fetch sockets from systemd.
 231  * @param dscp: DSCP to use.
 232  * @return: the socket. -1 on error.
 233  */
 234 int create_udp_sock(int family, int socktype, struct sockaddr* addr,
 235         socklen_t addrlen, int v6only, int* inuse, int* noproto, int rcv,
 236         int snd, int listen, int* reuseport, int transparent, int freebind, int use_systemd, int dscp);
 237
 238 /**
 239  * Create and bind TCP listening socket
 240  * @param addr: address info ready to make socket.
 241  * @param v6only: enable ip6 only flag on ip6 sockets.
 242  * @param noproto: if error caused by lack of protocol support.
 243  * @param reuseport: if nonNULL and true, try to set SO_REUSEPORT on
 244  *      listening UDP port.  Set to false on return if it failed to do so.
 245  * @param transparent: set IP_TRANSPARENT socket option.
 246  * @param mss: maximum segment size of the socket. if zero, leaves the default.
 247  * @param nodelay: if true set TCP_NODELAY and TCP_QUICKACK socket options.
 248  * @param freebind: set IP_FREEBIND socket option.
 249  * @param use_systemd: if true, fetch sockets from systemd.
 250  * @param dscp: DSCP to use.
 251  * @return: the socket. -1 on error.
 252  */
 253 int create_tcp_accept_sock(struct addrinfo *addr, int v6only, int* noproto,
 254         int* reuseport, int transparent, int mss, int nodelay, int freebind,
 255         int use_systemd, int dscp);
 256
 257 /**
 258  * Create and bind local listening socket
 259  * @param path: path to the socket.
 260  * @param noproto: on error, this is set true if cause is that local sockets
 261  *      are not supported.
 262  * @param use_systemd: if true, fetch sockets from systemd.
 263  * @return: the socket. -1 on error.
 264  */
 265 int create_local_accept_sock(const char* path, int* noproto, int use_systemd);
 266
 267 /**
 268  * TCP request info.  List of requests outstanding on the channel, that
 269  * are asked for but not yet answered back.
 270  */
 271 struct tcp_req_info {
 272         /** the TCP comm point for this.  Its buffer is used for read/write */
 273         struct comm_point* cp;
 274         /** the buffer to use to spool reply from mesh into,
 275          * it can then be copied to the result list and written.
 276          * it is a pointer to the shared udp buffer. */
 277         struct sldns_buffer* spool_buffer;
 278         /** are we in worker_handle function call (for recursion callback)*/
 279         int in_worker_handle;
 280         /** is the comm point dropped (by worker handle).
 281          * That means we have to disconnect the channel. */
 282         int is_drop;
 283         /** is the comm point set to send_reply (by mesh new client in worker
 284          * handle), if so answer is available in c.buffer */
 285         int is_reply;
 286         /** read channel has closed, just write pending results */
 287         int read_is_closed;
 288         /** read again */
 289         int read_again;
 290         /** number of outstanding requests */
 291         int num_open_req;
 292         /** list of outstanding requests */
 293         struct tcp_req_open_item* open_req_list;
 294         /** number of pending writeable results */
 295         int num_done_req;
 296         /** list of pending writable result packets, malloced one at a time */
 297         struct tcp_req_done_item* done_req_list;
 298 };
 299
 300 /**
 301  * List of open items in TCP channel
 302  */
 303 struct tcp_req_open_item {
 304         /** next in list */
 305         struct tcp_req_open_item* next;
 306         /** the mesh area of the mesh_state */
 307         struct mesh_area* mesh;
 308         /** the mesh state */
 309         struct mesh_state* mesh_state;
 310 };
 311
 312 /**
 313  * List of done items in TCP channel
 314  */
 315 struct tcp_req_done_item {
 316         /** next in list */
 317         struct tcp_req_done_item* next;
 318         /** the buffer with packet contents */
 319         uint8_t* buf;
 320         /** length of the buffer */
 321         size_t len;
 322 };
 323
 324 /**
 325  * Create tcp request info structure that keeps track of open
 326  * requests on the TCP channel that are resolved at the same time,
 327  * and the pending results that have to get written back to that client.
 328  * @param spoolbuf: shared buffer
 329  * @return new structure or NULL on alloc failure.
 330  */
 331 struct tcp_req_info* tcp_req_info_create(struct sldns_buffer* spoolbuf);
 332
 333 /**
 334  * Delete tcp request structure.  Called by owning commpoint.
 335  * Removes mesh entry references and stored results from the lists.
 336  * @param req: the tcp request info
 337  */
 338 void tcp_req_info_delete(struct tcp_req_info* req);
 339
 340 /**
 341  * Clear tcp request structure.  Removes list entries, sets it up ready
 342  * for the next connection.
 343  * @param req: tcp request info structure.
 344  */
 345 void tcp_req_info_clear(struct tcp_req_info* req);
 346
 347 /**
 348  * Remove mesh state entry from list in tcp_req_info.
 349  * caller has to manage the mesh state reply entry in the mesh state.
 350  * @param req: the tcp req info that has the entry removed from the list.
 351  * @param m: the state removed from the list.
 352  */
 353 void tcp_req_info_remove_mesh_state(struct tcp_req_info* req,
 354         struct mesh_state* m);
 355
 356 /**
 357  * Handle write done of the last result packet
 358  * @param req: the tcp req info.
 359  */
 360 void tcp_req_info_handle_writedone(struct tcp_req_info* req);
 361
 362 /**
 363  * Handle read done of a new request from the client
 364  * @param req: the tcp req info.
 365  */
 366 void tcp_req_info_handle_readdone(struct tcp_req_info* req);
 367
 368 /**
 369  * Add mesh state to the tcp req list of open requests.
 370  * So the comm_reply can be removed off the mesh reply list when
 371  * the tcp channel has to be closed (for other reasons then that that
 372  * request was done, eg. channel closed by client or some format error).
 373  * @param req: tcp req info structure.  It keeps track of the simultaneous
 374  *      requests and results on a tcp (or TLS) channel.
 375  * @param mesh: mesh area for the state.
 376  * @param m: mesh state to add.
 377  * @return 0 on failure (malloc failure).
 378  */
 379 int tcp_req_info_add_meshstate(struct tcp_req_info* req,
 380         struct mesh_area* mesh, struct mesh_state* m);
 381
 382 /**
 383  * Send reply on tcp simultaneous answer channel.  May queue it up.
 384  * @param req: request info structure.
 385  */
 386 void tcp_req_info_send_reply(struct tcp_req_info* req);
 387
 388 /** the read channel has closed
 389  * @param req: request. remaining queries are looked up and answered.
 390  * @return zero if nothing to do, just close the tcp.
 391  */
 392 int tcp_req_info_handle_read_close(struct tcp_req_info* req);
 393
 394 /** get the size of currently used tcp stream wait buffers (in bytes) */
 395 size_t tcp_req_info_get_stream_buffer_size(void);
 396
 397 /** get the size of currently used HTTP2 query buffers (in bytes) */
 398 size_t http2_get_query_buffer_size(void);
 399 /** get the size of currently used HTTP2 response buffers (in bytes) */
 400 size_t http2_get_response_buffer_size(void);
 401
 402 #ifdef HAVE_NGHTTP2
 403 /**
 404  * Create nghttp2 callbacks to handle HTTP2 requests.
 405  * @return malloc'ed struct, NULL on failure
 406  */
 407 nghttp2_session_callbacks* http2_req_callbacks_create();
 408
 409 /** Free http2 stream buffers and decrease buffer counters */
 410 void http2_req_stream_clear(struct http2_stream* h2_stream);
 411
 412 /**
 413  * DNS response ready to be submitted to nghttp2, to be prepared for sending
 414  * out. Response is stored in c->buffer. Copy to rbuffer because the c->buffer
 415  * might be used before this will be send out.
 416  * @param h2_session: http2 session, containing c->buffer which contains answer
 417  * @param h2_stream: http2 stream, containing buffer to store answer in
 418  * @return 0 on error, 1 otherwise
 419  */
 420 int http2_submit_dns_response(struct http2_session* h2_session);
 421 #else
 422 int http2_submit_dns_response(void* v);
 423 #endif /* HAVE_NGHTTP2 */
 424
 425 char* set_ip_dscp(int socket, int addrfamily, int ds);
 426
 427 #endif /* LISTEN_DNSPORT_H */