]> CyberLeo.Net >> Repos - FreeBSD/FreeBSD.git/blob - contrib/unbound/services/listen_dnsport.h
Update to version 3.2.0
[FreeBSD/FreeBSD.git] / 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 tcp_conn_limit: TCP connection limit info.
163  * @param sslctx: nonNULL if ssl context.
164  * @param dtenv: nonNULL if dnstap enabled.
165  * @param cb: callback function when a request arrives. It is passed
166  *        the packet and user argument. Return true to send a reply.
167  * @param cb_arg: user data argument for callback function.
168  * @return: the malloced listening structure, ready for use. NULL on error.
169  */
170 struct listen_dnsport*
171 listen_create(struct comm_base* base, struct listen_port* ports,
172         size_t bufsize, int tcp_accept_count, int tcp_idle_timeout,
173         int harden_large_queries, uint32_t http_max_streams,
174         char* http_endpoint, struct tcl_list* tcp_conn_limit, void* sslctx,
175         struct dt_env* dtenv, comm_point_callback_type* cb, void *cb_arg);
176
177 /**
178  * delete the listening structure
179  * @param listen: listening structure.
180  */
181 void listen_delete(struct listen_dnsport* listen);
182
183 /**
184  * delete listen_list of commpoints. Calls commpointdelete() on items.
185  * This may close the fds or not depending on flags.
186  * @param list: to delete.
187  */
188 void listen_list_delete(struct listen_list* list);
189
190 /**
191  * get memory size used by the listening structs
192  * @param listen: listening structure.
193  * @return: size in bytes.
194  */
195 size_t listen_get_mem(struct listen_dnsport* listen);
196
197 /**
198  * stop accept handlers for TCP (until enabled again)
199  * @param listen: listening structure.
200  */
201 void listen_stop_accept(struct listen_dnsport* listen);
202
203 /**
204  * start accept handlers for TCP (was stopped before)
205  * @param listen: listening structure.
206  */
207 void listen_start_accept(struct listen_dnsport* listen);
208
209 /**
210  * Create and bind nonblocking UDP socket
211  * @param family: for socket call.
212  * @param socktype: for socket call.
213  * @param addr: for bind call.
214  * @param addrlen: for bind call.
215  * @param v6only: if enabled, IP6 sockets get IP6ONLY option set.
216  *      if enabled with value 2 IP6ONLY option is disabled.
217  * @param inuse: on error, this is set true if the port was in use.
218  * @param noproto: on error, this is set true if cause is that the
219         IPv6 proto (family) is not available.
220  * @param rcv: set size on rcvbuf with socket option, if 0 it is not set.
221  * @param snd: set size on sndbuf with socket option, if 0 it is not set.
222  * @param listen: if true, this is a listening UDP port, eg port 53, and 
223  *      set SO_REUSEADDR on it.
224  * @param reuseport: if nonNULL and true, try to set SO_REUSEPORT on
225  *      listening UDP port.  Set to false on return if it failed to do so.
226  * @param transparent: set IP_TRANSPARENT socket option.
227  * @param freebind: set IP_FREEBIND socket option.
228  * @param use_systemd: if true, fetch sockets from systemd.
229  * @param dscp: DSCP to use.
230  * @return: the socket. -1 on error.
231  */
232 int create_udp_sock(int family, int socktype, struct sockaddr* addr, 
233         socklen_t addrlen, int v6only, int* inuse, int* noproto, int rcv,
234         int snd, int listen, int* reuseport, int transparent, int freebind, int use_systemd, int dscp);
235
236 /**
237  * Create and bind TCP listening socket
238  * @param addr: address info ready to make socket.
239  * @param v6only: enable ip6 only flag on ip6 sockets.
240  * @param noproto: if error caused by lack of protocol support.
241  * @param reuseport: if nonNULL and true, try to set SO_REUSEPORT on
242  *      listening UDP port.  Set to false on return if it failed to do so.
243  * @param transparent: set IP_TRANSPARENT socket option.
244  * @param mss: maximum segment size of the socket. if zero, leaves the default. 
245  * @param nodelay: if true set TCP_NODELAY and TCP_QUICKACK socket options.
246  * @param freebind: set IP_FREEBIND socket option.
247  * @param use_systemd: if true, fetch sockets from systemd.
248  * @param dscp: DSCP to use.
249  * @return: the socket. -1 on error.
250  */
251 int create_tcp_accept_sock(struct addrinfo *addr, int v6only, int* noproto,
252         int* reuseport, int transparent, int mss, int nodelay, int freebind,
253         int use_systemd, int dscp);
254
255 /**
256  * Create and bind local listening socket
257  * @param path: path to the socket.
258  * @param noproto: on error, this is set true if cause is that local sockets
259  *      are not supported.
260  * @param use_systemd: if true, fetch sockets from systemd.
261  * @return: the socket. -1 on error.
262  */
263 int create_local_accept_sock(const char* path, int* noproto, int use_systemd);
264
265 /**
266  * TCP request info.  List of requests outstanding on the channel, that
267  * are asked for but not yet answered back.
268  */
269 struct tcp_req_info {
270         /** the TCP comm point for this.  Its buffer is used for read/write */
271         struct comm_point* cp;
272         /** the buffer to use to spool reply from mesh into,
273          * it can then be copied to the result list and written.
274          * it is a pointer to the shared udp buffer. */
275         struct sldns_buffer* spool_buffer;
276         /** are we in worker_handle function call (for recursion callback)*/
277         int in_worker_handle;
278         /** is the comm point dropped (by worker handle).
279          * That means we have to disconnect the channel. */
280         int is_drop;
281         /** is the comm point set to send_reply (by mesh new client in worker
282          * handle), if so answer is available in c.buffer */
283         int is_reply;
284         /** read channel has closed, just write pending results */
285         int read_is_closed;
286         /** read again */
287         int read_again;
288         /** number of outstanding requests */
289         int num_open_req;
290         /** list of outstanding requests */
291         struct tcp_req_open_item* open_req_list;
292         /** number of pending writeable results */
293         int num_done_req;
294         /** list of pending writable result packets, malloced one at a time */
295         struct tcp_req_done_item* done_req_list;
296 };
297
298 /**
299  * List of open items in TCP channel
300  */
301 struct tcp_req_open_item {
302         /** next in list */
303         struct tcp_req_open_item* next;
304         /** the mesh area of the mesh_state */
305         struct mesh_area* mesh;
306         /** the mesh state */
307         struct mesh_state* mesh_state;
308 };
309
310 /**
311  * List of done items in TCP channel
312  */
313 struct tcp_req_done_item {
314         /** next in list */
315         struct tcp_req_done_item* next;
316         /** the buffer with packet contents */
317         uint8_t* buf;
318         /** length of the buffer */
319         size_t len;
320 };
321
322 /**
323  * Create tcp request info structure that keeps track of open
324  * requests on the TCP channel that are resolved at the same time,
325  * and the pending results that have to get written back to that client.
326  * @param spoolbuf: shared buffer
327  * @return new structure or NULL on alloc failure.
328  */
329 struct tcp_req_info* tcp_req_info_create(struct sldns_buffer* spoolbuf);
330
331 /**
332  * Delete tcp request structure.  Called by owning commpoint.
333  * Removes mesh entry references and stored results from the lists.
334  * @param req: the tcp request info
335  */
336 void tcp_req_info_delete(struct tcp_req_info* req);
337
338 /**
339  * Clear tcp request structure.  Removes list entries, sets it up ready
340  * for the next connection.
341  * @param req: tcp request info structure.
342  */
343 void tcp_req_info_clear(struct tcp_req_info* req);
344
345 /**
346  * Remove mesh state entry from list in tcp_req_info.
347  * caller has to manage the mesh state reply entry in the mesh state.
348  * @param req: the tcp req info that has the entry removed from the list.
349  * @param m: the state removed from the list.
350  */
351 void tcp_req_info_remove_mesh_state(struct tcp_req_info* req,
352         struct mesh_state* m);
353
354 /**
355  * Handle write done of the last result packet
356  * @param req: the tcp req info.
357  */
358 void tcp_req_info_handle_writedone(struct tcp_req_info* req);
359
360 /**
361  * Handle read done of a new request from the client
362  * @param req: the tcp req info.
363  */
364 void tcp_req_info_handle_readdone(struct tcp_req_info* req);
365
366 /**
367  * Add mesh state to the tcp req list of open requests.
368  * So the comm_reply can be removed off the mesh reply list when
369  * the tcp channel has to be closed (for other reasons then that that
370  * request was done, eg. channel closed by client or some format error).
371  * @param req: tcp req info structure.  It keeps track of the simultaneous
372  *      requests and results on a tcp (or TLS) channel.
373  * @param mesh: mesh area for the state.
374  * @param m: mesh state to add.
375  * @return 0 on failure (malloc failure).
376  */
377 int tcp_req_info_add_meshstate(struct tcp_req_info* req,
378         struct mesh_area* mesh, struct mesh_state* m);
379
380 /**
381  * Send reply on tcp simultaneous answer channel.  May queue it up.
382  * @param req: request info structure.
383  */
384 void tcp_req_info_send_reply(struct tcp_req_info* req);
385
386 /** the read channel has closed
387  * @param req: request. remaining queries are looked up and answered. 
388  * @return zero if nothing to do, just close the tcp.
389  */
390 int tcp_req_info_handle_read_close(struct tcp_req_info* req);
391
392 /** get the size of currently used tcp stream wait buffers (in bytes) */
393 size_t tcp_req_info_get_stream_buffer_size(void);
394
395 /** get the size of currently used HTTP2 query buffers (in bytes) */
396 size_t http2_get_query_buffer_size(void);
397 /** get the size of currently used HTTP2 response buffers (in bytes) */
398 size_t http2_get_response_buffer_size(void);
399
400 #ifdef HAVE_NGHTTP2
401 /** 
402  * Create nghttp2 callbacks to handle HTTP2 requests.
403  * @return malloc'ed struct, NULL on failure
404  */
405 nghttp2_session_callbacks* http2_req_callbacks_create();
406
407 /** Free http2 stream buffers and decrease buffer counters */
408 void http2_req_stream_clear(struct http2_stream* h2_stream);
409
410 /**
411  * DNS response ready to be submitted to nghttp2, to be prepared for sending
412  * out. Response is stored in c->buffer. Copy to rbuffer because the c->buffer
413  * might be used before this will be send out.
414  * @param h2_session: http2 session, containing c->buffer which contains answer
415  * @param h2_stream: http2 stream, containing buffer to store answer in
416  * @return 0 on error, 1 otherwise
417  */
418 int http2_submit_dns_response(struct http2_session* h2_session);
419 #else
420 int http2_submit_dns_response(void* v);
421 #endif /* HAVE_NGHTTP2 */
422
423 char* set_ip_dscp(int socket, int addrfamily, int ds);
424
425 #endif /* LISTEN_DNSPORT_H */