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 #include "daemon/acl_list.h" 47 #ifdef HAVE_NGHTTP2_NGHTTP2_H 48 #include <nghttp2/nghttp2.h> 49 #endif 50 struct listen_list; 51 struct config_file; 52 struct addrinfo; 53 struct sldns_buffer; 54 struct tcl_list; 55 56 /** 57 * Listening for queries structure. 58 * Contains list of query-listen sockets. 59 */ 60 struct listen_dnsport { 61 /** Base for select calls */ 62 struct comm_base* base; 63 64 /** buffer shared by UDP connections, since there is only one 65 datagram at any time. */ 66 struct sldns_buffer* udp_buff; 67 #ifdef USE_DNSCRYPT 68 struct sldns_buffer* dnscrypt_udp_buff; 69 #endif 70 /** list of comm points used to get incoming events */ 71 struct listen_list* cps; 72 }; 73 74 /** 75 * Single linked list to store event points. 76 */ 77 struct listen_list { 78 /** next in list */ 79 struct listen_list* next; 80 /** event info */ 81 struct comm_point* com; 82 }; 83 84 /** 85 * type of ports 86 */ 87 enum listen_type { 88 /** udp type */ 89 listen_type_udp, 90 /** tcp type */ 91 listen_type_tcp, 92 /** udp ipv6 (v4mapped) for use with ancillary data */ 93 listen_type_udpancil, 94 /** ssl over tcp type */ 95 listen_type_ssl, 96 /** udp type + dnscrypt*/ 97 listen_type_udp_dnscrypt, 98 /** tcp type + dnscrypt */ 99 listen_type_tcp_dnscrypt, 100 /** udp ipv6 (v4mapped) for use with ancillary data + dnscrypt*/ 101 listen_type_udpancil_dnscrypt, 102 /** HTTP(2) over TLS over TCP */ 103 listen_type_http 104 }; 105 106 /* 107 * socket properties (just like NSD nsd_socket structure definition) 108 */ 109 struct unbound_socket { 110 /** the address of the socket */ 111 struct sockaddr* addr; 112 /** length of the address */ 113 socklen_t addrlen; 114 /** socket descriptor returned by socket() syscall */ 115 int s; 116 /** address family (AF_INET/AF_INET6) */ 117 int fam; 118 /** ACL on the socket (listening interface) */ 119 struct acl_addr* acl; 120 }; 121 122 /** 123 * Single linked list to store shared ports that have been 124 * opened for use by all threads. 125 */ 126 struct listen_port { 127 /** next in list */ 128 struct listen_port* next; 129 /** file descriptor, open and ready for use */ 130 int fd; 131 /** type of file descriptor, udp or tcp */ 132 enum listen_type ftype; 133 /** if the port should support PROXYv2 */ 134 int pp2_enabled; 135 /** fill in unbound_socket structure for every opened socket at 136 * Unbound startup */ 137 struct unbound_socket* socket; 138 }; 139 140 /** 141 * Create shared listening ports 142 * Getaddrinfo, create socket, bind and listen to zero or more 143 * interfaces for IP4 and/or IP6, for UDP and/or TCP. 144 * On the given port number. It creates the sockets. 145 * @param cfg: settings on what ports to open. 146 * @param ifs: interfaces to open, array of IP addresses, "ip[@port]". 147 * @param num_ifs: length of ifs. 148 * @param reuseport: set to true if you want reuseport, or NULL to not have it, 149 * set to false on exit if reuseport failed to apply (because of no 150 * kernel support). 151 * @return: linked list of ports or NULL on error. 152 */ 153 struct listen_port* listening_ports_open(struct config_file* cfg, 154 char** ifs, int num_ifs, int* reuseport); 155 156 /** 157 * Close and delete the (list of) listening ports. 158 */ 159 void listening_ports_free(struct listen_port* list); 160 161 struct config_strlist; 162 /** 163 * Resolve interface names in config and store result IP addresses 164 * @param ifs: array of interfaces. The list of interface names, if not NULL. 165 * @param num_ifs: length of ifs array. 166 * @param list: if not NULL, this is used as the list of interface names. 167 * @param resif: string array (malloced array of malloced strings) with 168 * result. NULL if cfg has none. 169 * @param num_resif: length of resif. Zero if cfg has zero num_ifs. 170 * @return 0 on failure. 171 */ 172 int resolve_interface_names(char** ifs, int num_ifs, 173 struct config_strlist* list, char*** resif, int* num_resif); 174 175 /** 176 * Create commpoints with for this thread for the shared ports. 177 * @param base: the comm_base that provides event functionality. 178 * for default all ifs. 179 * @param ports: the list of shared ports. 180 * @param bufsize: size of datagram buffer. 181 * @param tcp_accept_count: max number of simultaneous TCP connections 182 * from clients. 183 * @param tcp_idle_timeout: idle timeout for TCP connections in msec. 184 * @param harden_large_queries: whether query size should be limited. 185 * @param http_max_streams: maximum number of HTTP/2 streams per connection. 186 * @param http_endpoint: HTTP endpoint to service queries on 187 * @param http_notls: no TLS for http downstream 188 * @param tcp_conn_limit: TCP connection limit info. 189 * @param sslctx: nonNULL if ssl context. 190 * @param dtenv: nonNULL if dnstap enabled. 191 * @param cb: callback function when a request arrives. It is passed 192 * the packet and user argument. Return true to send a reply. 193 * @param cb_arg: user data argument for callback function. 194 * @return: the malloced listening structure, ready for use. NULL on error. 195 */ 196 struct listen_dnsport* 197 listen_create(struct comm_base* base, struct listen_port* ports, 198 size_t bufsize, int tcp_accept_count, int tcp_idle_timeout, 199 int harden_large_queries, uint32_t http_max_streams, 200 char* http_endpoint, int http_notls, struct tcl_list* tcp_conn_limit, 201 void* sslctx, struct dt_env* dtenv, comm_point_callback_type* cb, 202 void *cb_arg); 203 204 /** 205 * delete the listening structure 206 * @param listen: listening structure. 207 */ 208 void listen_delete(struct listen_dnsport* listen); 209 210 /** setup the locks for the listen ports */ 211 void listen_setup_locks(void); 212 /** desetup the locks for the listen ports */ 213 void listen_desetup_locks(void); 214 215 /** 216 * delete listen_list of commpoints. Calls commpointdelete() on items. 217 * This may close the fds or not depending on flags. 218 * @param list: to delete. 219 */ 220 void listen_list_delete(struct listen_list* list); 221 222 /** 223 * get memory size used by the listening structs 224 * @param listen: listening structure. 225 * @return: size in bytes. 226 */ 227 size_t listen_get_mem(struct listen_dnsport* listen); 228 229 /** 230 * stop accept handlers for TCP (until enabled again) 231 * @param listen: listening structure. 232 */ 233 void listen_stop_accept(struct listen_dnsport* listen); 234 235 /** 236 * start accept handlers for TCP (was stopped before) 237 * @param listen: listening structure. 238 */ 239 void listen_start_accept(struct listen_dnsport* listen); 240 241 /** 242 * Create and bind nonblocking UDP socket 243 * @param family: for socket call. 244 * @param socktype: for socket call. 245 * @param addr: for bind call. 246 * @param addrlen: for bind call. 247 * @param v6only: if enabled, IP6 sockets get IP6ONLY option set. 248 * if enabled with value 2 IP6ONLY option is disabled. 249 * @param inuse: on error, this is set true if the port was in use. 250 * @param noproto: on error, this is set true if cause is that the 251 IPv6 proto (family) is not available. 252 * @param rcv: set size on rcvbuf with socket option, if 0 it is not set. 253 * @param snd: set size on sndbuf with socket option, if 0 it is not set. 254 * @param listen: if true, this is a listening UDP port, eg port 53, and 255 * set SO_REUSEADDR on it. 256 * @param reuseport: if nonNULL and true, try to set SO_REUSEPORT on 257 * listening UDP port. Set to false on return if it failed to do so. 258 * @param transparent: set IP_TRANSPARENT socket option. 259 * @param freebind: set IP_FREEBIND socket option. 260 * @param use_systemd: if true, fetch sockets from systemd. 261 * @param dscp: DSCP to use. 262 * @return: the socket. -1 on error. 263 */ 264 int create_udp_sock(int family, int socktype, struct sockaddr* addr, 265 socklen_t addrlen, int v6only, int* inuse, int* noproto, int rcv, 266 int snd, int listen, int* reuseport, int transparent, int freebind, int use_systemd, int dscp); 267 268 /** 269 * Create and bind TCP listening socket 270 * @param addr: address info ready to make socket. 271 * @param v6only: enable ip6 only flag on ip6 sockets. 272 * @param noproto: if error caused by lack of protocol support. 273 * @param reuseport: if nonNULL and true, try to set SO_REUSEPORT on 274 * listening UDP port. Set to false on return if it failed to do so. 275 * @param transparent: set IP_TRANSPARENT socket option. 276 * @param mss: maximum segment size of the socket. if zero, leaves the default. 277 * @param nodelay: if true set TCP_NODELAY and TCP_QUICKACK socket options. 278 * @param freebind: set IP_FREEBIND socket option. 279 * @param use_systemd: if true, fetch sockets from systemd. 280 * @param dscp: DSCP to use. 281 * @return: the socket. -1 on error. 282 */ 283 int create_tcp_accept_sock(struct addrinfo *addr, int v6only, int* noproto, 284 int* reuseport, int transparent, int mss, int nodelay, int freebind, 285 int use_systemd, int dscp); 286 287 /** 288 * Create and bind local listening socket 289 * @param path: path to the socket. 290 * @param noproto: on error, this is set true if cause is that local sockets 291 * are not supported. 292 * @param use_systemd: if true, fetch sockets from systemd. 293 * @return: the socket. -1 on error. 294 */ 295 int create_local_accept_sock(const char* path, int* noproto, int use_systemd); 296 297 /** 298 * TCP request info. List of requests outstanding on the channel, that 299 * are asked for but not yet answered back. 300 */ 301 struct tcp_req_info { 302 /** the TCP comm point for this. Its buffer is used for read/write */ 303 struct comm_point* cp; 304 /** the buffer to use to spool reply from mesh into, 305 * it can then be copied to the result list and written. 306 * it is a pointer to the shared udp buffer. */ 307 struct sldns_buffer* spool_buffer; 308 /** are we in worker_handle function call (for recursion callback)*/ 309 int in_worker_handle; 310 /** is the comm point dropped (by worker handle). 311 * That means we have to disconnect the channel. */ 312 int is_drop; 313 /** is the comm point set to send_reply (by mesh new client in worker 314 * handle), if so answer is available in c.buffer */ 315 int is_reply; 316 /** read channel has closed, just write pending results */ 317 int read_is_closed; 318 /** read again */ 319 int read_again; 320 /** number of outstanding requests */ 321 int num_open_req; 322 /** list of outstanding requests */ 323 struct tcp_req_open_item* open_req_list; 324 /** number of pending writeable results */ 325 int num_done_req; 326 /** list of pending writable result packets, malloced one at a time */ 327 struct tcp_req_done_item* done_req_list; 328 }; 329 330 /** 331 * List of open items in TCP channel 332 */ 333 struct tcp_req_open_item { 334 /** next in list */ 335 struct tcp_req_open_item* next; 336 /** the mesh area of the mesh_state */ 337 struct mesh_area* mesh; 338 /** the mesh state */ 339 struct mesh_state* mesh_state; 340 }; 341 342 /** 343 * List of done items in TCP channel 344 */ 345 struct tcp_req_done_item { 346 /** next in list */ 347 struct tcp_req_done_item* next; 348 /** the buffer with packet contents */ 349 uint8_t* buf; 350 /** length of the buffer */ 351 size_t len; 352 }; 353 354 /** 355 * Create tcp request info structure that keeps track of open 356 * requests on the TCP channel that are resolved at the same time, 357 * and the pending results that have to get written back to that client. 358 * @param spoolbuf: shared buffer 359 * @return new structure or NULL on alloc failure. 360 */ 361 struct tcp_req_info* tcp_req_info_create(struct sldns_buffer* spoolbuf); 362 363 /** 364 * Delete tcp request structure. Called by owning commpoint. 365 * Removes mesh entry references and stored results from the lists. 366 * @param req: the tcp request info 367 */ 368 void tcp_req_info_delete(struct tcp_req_info* req); 369 370 /** 371 * Clear tcp request structure. Removes list entries, sets it up ready 372 * for the next connection. 373 * @param req: tcp request info structure. 374 */ 375 void tcp_req_info_clear(struct tcp_req_info* req); 376 377 /** 378 * Remove mesh state entry from list in tcp_req_info. 379 * caller has to manage the mesh state reply entry in the mesh state. 380 * @param req: the tcp req info that has the entry removed from the list. 381 * @param m: the state removed from the list. 382 */ 383 void tcp_req_info_remove_mesh_state(struct tcp_req_info* req, 384 struct mesh_state* m); 385 386 /** 387 * Handle write done of the last result packet 388 * @param req: the tcp req info. 389 */ 390 void tcp_req_info_handle_writedone(struct tcp_req_info* req); 391 392 /** 393 * Handle read done of a new request from the client 394 * @param req: the tcp req info. 395 */ 396 void tcp_req_info_handle_readdone(struct tcp_req_info* req); 397 398 /** 399 * Add mesh state to the tcp req list of open requests. 400 * So the comm_reply can be removed off the mesh reply list when 401 * the tcp channel has to be closed (for other reasons then that that 402 * request was done, eg. channel closed by client or some format error). 403 * @param req: tcp req info structure. It keeps track of the simultaneous 404 * requests and results on a tcp (or TLS) channel. 405 * @param mesh: mesh area for the state. 406 * @param m: mesh state to add. 407 * @return 0 on failure (malloc failure). 408 */ 409 int tcp_req_info_add_meshstate(struct tcp_req_info* req, 410 struct mesh_area* mesh, struct mesh_state* m); 411 412 /** 413 * Send reply on tcp simultaneous answer channel. May queue it up. 414 * @param req: request info structure. 415 */ 416 void tcp_req_info_send_reply(struct tcp_req_info* req); 417 418 /** the read channel has closed 419 * @param req: request. remaining queries are looked up and answered. 420 * @return zero if nothing to do, just close the tcp. 421 */ 422 int tcp_req_info_handle_read_close(struct tcp_req_info* req); 423 424 /** get the size of currently used tcp stream wait buffers (in bytes) */ 425 size_t tcp_req_info_get_stream_buffer_size(void); 426 427 /** get the size of currently used HTTP2 query buffers (in bytes) */ 428 size_t http2_get_query_buffer_size(void); 429 /** get the size of currently used HTTP2 response buffers (in bytes) */ 430 size_t http2_get_response_buffer_size(void); 431 432 #ifdef HAVE_NGHTTP2 433 /** 434 * Create nghttp2 callbacks to handle HTTP2 requests. 435 * @return malloc'ed struct, NULL on failure 436 */ 437 nghttp2_session_callbacks* http2_req_callbacks_create(void); 438 439 /** Free http2 stream buffers and decrease buffer counters */ 440 void http2_req_stream_clear(struct http2_stream* h2_stream); 441 442 /** 443 * DNS response ready to be submitted to nghttp2, to be prepared for sending 444 * out. Response is stored in c->buffer. Copy to rbuffer because the c->buffer 445 * might be used before this will be send out. 446 * @param h2_session: http2 session, containing c->buffer which contains answer 447 * @param h2_stream: http2 stream, containing buffer to store answer in 448 * @return 0 on error, 1 otherwise 449 */ 450 int http2_submit_dns_response(struct http2_session* h2_session); 451 #else 452 int http2_submit_dns_response(void* v); 453 #endif /* HAVE_NGHTTP2 */ 454 455 char* set_ip_dscp(int socket, int addrfamily, int ds); 456 457 /** for debug and profiling purposes only 458 * @param ub_sock: the structure containing created socket info we want to print or log for 459 */ 460 void verbose_print_unbound_socket(struct unbound_socket* ub_sock); 461 462 #endif /* LISTEN_DNSPORT_H */ 463