1 /*
2  * dnstap/dnstap_collector.c -- nsd collector process for dnstap information
3  *
4  * Copyright (c) 2018, NLnet Labs. All rights reserved.
5  *
6  * See LICENSE for the license.
7  *
8  */
9 
10 #include "config.h"
11 #include <sys/types.h>
12 #include <sys/socket.h>
13 #include <errno.h>
14 #include <fcntl.h>
15 #include <unistd.h>
16 #ifndef USE_MINI_EVENT
17 #  ifdef HAVE_EVENT_H
18 #    include <event.h>
19 #  else
20 #    include <event2/event.h>
21 #    include "event2/event_struct.h"
22 #    include "event2/event_compat.h"
23 #  endif
24 #else
25 #  include "mini_event.h"
26 #endif
27 #include "dnstap/dnstap_collector.h"
28 #include "dnstap/dnstap.h"
29 #include "util.h"
30 #include "nsd.h"
31 #include "region-allocator.h"
32 #include "buffer.h"
33 #include "namedb.h"
34 #include "options.h"
35 
36 #include "udb.h"
37 #include "rrl.h"
38 
dt_collector_create(struct nsd * nsd)39 struct dt_collector* dt_collector_create(struct nsd* nsd)
40 {
41 	int i, sv[2];
42 	struct dt_collector* dt_col = (struct dt_collector*)xalloc_zero(
43 		sizeof(*dt_col));
44 	dt_col->count = nsd->child_count * 2;
45 	dt_col->dt_env = NULL;
46 	dt_col->region = region_create(xalloc, free);
47 	dt_col->send_buffer = buffer_create(dt_col->region,
48 		/* msglen + is_response + addrlen + is_tcp + packetlen + packet + zonelen + zone + spare + local_addr + addr */
49 		4+1+4+1+4+TCP_MAX_MESSAGE_LEN+4+MAXHOSTNAMELEN + 32 +
50 #ifdef INET6
51 		sizeof(struct sockaddr_storage) + sizeof(struct sockaddr_storage)
52 #else
53 		sizeof(struct sockaddr_in) + sizeof(struct sockaddr_in)
54 #endif
55 		);
56 
57 	/* open communication channels in struct nsd */
58 	nsd->dt_collector_fd_send = (int*)xalloc_array_zero(dt_col->count,
59 		sizeof(int));
60 	nsd->dt_collector_fd_recv = (int*)xalloc_array_zero(dt_col->count,
61 		sizeof(int));
62 	for(i=0; i<dt_col->count; i++) {
63 		int sv[2];
64 		int bufsz = buffer_capacity(dt_col->send_buffer);
65 		sv[0] = -1; /* For receiving by parent (dnstap-collector) */
66 		sv[1] = -1; /* For sending   by child  (server childs) */
67 		if(socketpair(AF_UNIX, SOCK_DGRAM | SOCK_NONBLOCK, 0, sv) < 0) {
68 			error("dnstap_collector: cannot create communication channel: %s",
69 				strerror(errno));
70 		}
71 		if(setsockopt(sv[0], SOL_SOCKET, SO_RCVBUF, &bufsz, sizeof(bufsz))) {
72 			log_msg(LOG_ERR, "setting dnstap_collector "
73 				"receive buffer size failed: %s", strerror(errno));
74 		}
75 		if(setsockopt(sv[1], SOL_SOCKET, SO_SNDBUF, &bufsz, sizeof(bufsz))) {
76 			log_msg(LOG_ERR, "setting dnstap_collector "
77 				"send buffer size failed: %s", strerror(errno));
78 		}
79 		nsd->dt_collector_fd_recv[i] = sv[0];
80 		nsd->dt_collector_fd_send[i] = sv[1];
81 	}
82 	nsd->dt_collector_fd_swap = nsd->dt_collector_fd_send + nsd->child_count;
83 
84 	/* open socketpair */
85 	if(socketpair(AF_UNIX, SOCK_STREAM, 0, sv) == -1) {
86 		error("dnstap_collector: cannot create socketpair: %s",
87 			strerror(errno));
88 	}
89 	if(fcntl(sv[0], F_SETFL, O_NONBLOCK) == -1) {
90 		log_msg(LOG_ERR, "fcntl failed: %s", strerror(errno));
91 	}
92 	if(fcntl(sv[1], F_SETFL, O_NONBLOCK) == -1) {
93 		log_msg(LOG_ERR, "fcntl failed: %s", strerror(errno));
94 	}
95 	dt_col->cmd_socket_dt = sv[0];
96 	dt_col->cmd_socket_nsd = sv[1];
97 
98 	return dt_col;
99 }
100 
dt_collector_destroy(struct dt_collector * dt_col,struct nsd * nsd)101 void dt_collector_destroy(struct dt_collector* dt_col, struct nsd* nsd)
102 {
103 	if(!dt_col) return;
104 	free(nsd->dt_collector_fd_recv);
105 	nsd->dt_collector_fd_recv = NULL;
106 	if (nsd->dt_collector_fd_send < nsd->dt_collector_fd_swap)
107 		free(nsd->dt_collector_fd_send);
108 	else
109 		free(nsd->dt_collector_fd_swap);
110 	nsd->dt_collector_fd_send = NULL;
111 	nsd->dt_collector_fd_swap = NULL;
112 	region_destroy(dt_col->region);
113 	free(dt_col);
114 }
115 
dt_collector_close(struct dt_collector * dt_col,struct nsd * nsd)116 void dt_collector_close(struct dt_collector* dt_col, struct nsd* nsd)
117 {
118 	int i, *fd_send;
119 	if(!dt_col) return;
120 	if(dt_col->cmd_socket_dt != -1) {
121 		close(dt_col->cmd_socket_dt);
122 		dt_col->cmd_socket_dt = -1;
123 	}
124 	if(dt_col->cmd_socket_nsd != -1) {
125 		close(dt_col->cmd_socket_nsd);
126 		dt_col->cmd_socket_nsd = -1;
127 	}
128 	fd_send = nsd->dt_collector_fd_send < nsd->dt_collector_fd_swap
129 	        ? nsd->dt_collector_fd_send : nsd->dt_collector_fd_swap;
130 	for(i=0; i<dt_col->count; i++) {
131 		if(nsd->dt_collector_fd_recv[i] != -1) {
132 			close(nsd->dt_collector_fd_recv[i]);
133 			nsd->dt_collector_fd_recv[i] = -1;
134 		}
135 		if(fd_send[i] != -1) {
136 			close(fd_send[i]);
137 			fd_send[i] = -1;
138 		}
139 	}
140 }
141 
142 /* handle command from nsd to dt collector.
143  * mostly, check for fd closed, this means we have to exit */
144 void
dt_handle_cmd_from_nsd(int ATTR_UNUSED (fd),short event,void * arg)145 dt_handle_cmd_from_nsd(int ATTR_UNUSED(fd), short event, void* arg)
146 {
147 	struct dt_collector* dt_col = (struct dt_collector*)arg;
148 	if((event&EV_READ) != 0) {
149 		event_base_loopexit(dt_col->event_base, NULL);
150 	}
151 }
152 
153 /* receive data from fd into buffer, 1 when message received, -1 on error */
recv_into_buffer(int fd,struct buffer * buf)154 static int recv_into_buffer(int fd, struct buffer* buf)
155 {
156 	size_t msglen;
157 	ssize_t r;
158 
159 	assert(buffer_position(buf) == 0);
160 	r = recv(fd, buffer_current(buf), buffer_capacity(buf), MSG_DONTWAIT);
161 	if(r == -1) {
162 		if(errno == EAGAIN || errno == EINTR || errno == EMSGSIZE) {
163 			/* continue to receive a message later */
164 			return 0;
165 		}
166 		log_msg(LOG_ERR, "dnstap collector: receive failed: %s",
167 			strerror(errno));
168 		return -1;
169 	}
170 	if(r == 0) {
171 		/* Remote end closed the connection? */
172 		log_msg(LOG_ERR, "dnstap collector: remote closed connection");
173 		return -1;
174 	}
175 	assert(r > 4);
176 	msglen = buffer_read_u32_at(buf, 0);
177 	if(msglen != (size_t)(r - 4)) {
178 		/* Is this still possible now the communication channel is of
179 		 * type SOCK_DGRAM? I think not, but better safe than sorry. */
180 		log_msg(LOG_ERR, "dnstap collector: out of sync (msglen: %u)",
181 			(unsigned int) msglen);
182 		return 0;
183 	}
184 	buffer_skip(buf, r);
185 	buffer_flip(buf);
186 	return 1;
187 }
188 
189 /* submit the content of the buffer received to dnstap */
190 static void
dt_submit_content(struct dt_env * dt_env,struct buffer * buf)191 dt_submit_content(struct dt_env* dt_env, struct buffer* buf)
192 {
193 	uint8_t is_response, is_tcp;
194 #ifdef INET6
195 	struct sockaddr_storage local_addr, addr;
196 #else
197 	struct sockaddr_in local_addr, addr;
198 #endif
199 	socklen_t addrlen;
200 	size_t pktlen;
201 	uint8_t* data;
202 	size_t zonelen;
203 	uint8_t* zone;
204 
205 	/* parse content from buffer */
206 	if(!buffer_available(buf, 4+1+4)) return;
207 	buffer_skip(buf, 4); /* skip msglen */
208 	is_response = buffer_read_u8(buf);
209 	addrlen = buffer_read_u32(buf);
210 	if(addrlen > sizeof(local_addr) || addrlen > sizeof(addr)) return;
211 	if(!buffer_available(buf, 2*addrlen)) return;
212 	buffer_read(buf, &local_addr, addrlen);
213 	buffer_read(buf, &addr, addrlen);
214 	if(!buffer_available(buf, 1+4)) return;
215 	is_tcp = buffer_read_u8(buf);
216 	pktlen = buffer_read_u32(buf);
217 	if(!buffer_available(buf, pktlen)) return;
218 	data = buffer_current(buf);
219 	buffer_skip(buf, pktlen);
220 	if(!buffer_available(buf, 4)) return;
221 	zonelen = buffer_read_u32(buf);
222 	if(zonelen == 0) {
223 		zone = NULL;
224 	} else {
225 		if(zonelen > MAXDOMAINLEN) return;
226 		if(!buffer_available(buf, zonelen)) return;
227 		zone = buffer_current(buf);
228 		buffer_skip(buf, zonelen);
229 	}
230 
231 	/* submit it */
232 	if(is_response) {
233 		dt_msg_send_auth_response(dt_env, &local_addr, &addr, is_tcp, zone,
234 			zonelen, data, pktlen);
235 	} else {
236 		dt_msg_send_auth_query(dt_env, &local_addr, &addr, is_tcp, zone,
237 			zonelen, data, pktlen);
238 	}
239 }
240 
241 /* handle input from worker for dnstap */
242 void
dt_handle_input(int fd,short event,void * arg)243 dt_handle_input(int fd, short event, void* arg)
244 {
245 	struct dt_collector_input* dt_input = (struct dt_collector_input*)arg;
246 	if((event&EV_READ) != 0) {
247 		/* receive */
248 		int r = recv_into_buffer(fd, dt_input->buffer);
249 		if(r == 0)
250 			return;
251 		else if(r < 0) {
252 			event_base_loopexit(dt_input->dt_collector->event_base, NULL);
253 			return;
254 		}
255 		/* once data is complete, send it to dnstap */
256 		VERBOSITY(4, (LOG_INFO, "dnstap collector: received msg len %d",
257 			(int)buffer_remaining(dt_input->buffer)));
258 		if(dt_input->dt_collector->dt_env) {
259 			dt_submit_content(dt_input->dt_collector->dt_env,
260 				dt_input->buffer);
261 		}
262 
263 		/* clear buffer for next message */
264 		buffer_clear(dt_input->buffer);
265 	}
266 }
267 
268 /* init dnstap */
dt_init_dnstap(struct dt_collector * dt_col,struct nsd * nsd)269 static void dt_init_dnstap(struct dt_collector* dt_col, struct nsd* nsd)
270 {
271 	int num_workers = 1;
272 #ifdef HAVE_CHROOT
273 	if(nsd->chrootdir && nsd->chrootdir[0]) {
274 		int l = strlen(nsd->chrootdir)-1; /* ends in trailing slash */
275 		if (nsd->options->dnstap_socket_path &&
276 			nsd->options->dnstap_socket_path[0] == '/' &&
277 			strncmp(nsd->options->dnstap_socket_path,
278 				nsd->chrootdir, l) == 0)
279 			nsd->options->dnstap_socket_path += l;
280 	}
281 #endif
282 	dt_col->dt_env = dt_create(nsd->options->dnstap_socket_path, num_workers);
283 	if(!dt_col->dt_env) {
284 		log_msg(LOG_ERR, "could not create dnstap env");
285 		return;
286 	}
287 	dt_apply_cfg(dt_col->dt_env, nsd->options);
288 	dt_init(dt_col->dt_env);
289 }
290 
291 /* cleanup dt collector process for exit */
dt_collector_cleanup(struct dt_collector * dt_col,struct nsd * nsd)292 static void dt_collector_cleanup(struct dt_collector* dt_col, struct nsd* nsd)
293 {
294 	int i;
295 	dt_delete(dt_col->dt_env);
296 	event_del(dt_col->cmd_event);
297 	for(i=0; i<dt_col->count; i++) {
298 		event_del(dt_col->inputs[i].event);
299 	}
300 	dt_collector_close(dt_col, nsd);
301 	event_base_free(dt_col->event_base);
302 #ifdef MEMCLEAN
303 	free(dt_col->cmd_event);
304 	if(dt_col->inputs) {
305 		for(i=0; i<dt_col->count; i++) {
306 			free(dt_col->inputs[i].event);
307 		}
308 		free(dt_col->inputs);
309 	}
310 	dt_collector_destroy(dt_col, nsd);
311 #endif
312 }
313 
314 /* attach events to the event base to listen to the workers and cmd channel */
dt_attach_events(struct dt_collector * dt_col,struct nsd * nsd)315 static void dt_attach_events(struct dt_collector* dt_col, struct nsd* nsd)
316 {
317 	int i;
318 	/* create event base */
319 	dt_col->event_base = nsd_child_event_base();
320 	if(!dt_col->event_base) {
321 		error("dnstap collector: event_base create failed");
322 	}
323 
324 	/* add command handler */
325 	dt_col->cmd_event = (struct event*)xalloc_zero(
326 		sizeof(*dt_col->cmd_event));
327 	event_set(dt_col->cmd_event, dt_col->cmd_socket_dt,
328 		EV_PERSIST|EV_READ, dt_handle_cmd_from_nsd, dt_col);
329 	if(event_base_set(dt_col->event_base, dt_col->cmd_event) != 0)
330 		log_msg(LOG_ERR, "dnstap collector: event_base_set failed");
331 	if(event_add(dt_col->cmd_event, NULL) != 0)
332 		log_msg(LOG_ERR, "dnstap collector: event_add failed");
333 
334 	/* add worker input handlers */
335 	dt_col->inputs = xalloc_array_zero(dt_col->count,
336 		sizeof(*dt_col->inputs));
337 	for(i=0; i<dt_col->count; i++) {
338 		dt_col->inputs[i].dt_collector = dt_col;
339 		dt_col->inputs[i].event = (struct event*)xalloc_zero(
340 			sizeof(struct event));
341 		event_set(dt_col->inputs[i].event,
342 			nsd->dt_collector_fd_recv[i], EV_PERSIST|EV_READ,
343 			dt_handle_input, &dt_col->inputs[i]);
344 		if(event_base_set(dt_col->event_base,
345 			dt_col->inputs[i].event) != 0)
346 			log_msg(LOG_ERR, "dnstap collector: event_base_set failed");
347 		if(event_add(dt_col->inputs[i].event, NULL) != 0)
348 			log_msg(LOG_ERR, "dnstap collector: event_add failed");
349 
350 		dt_col->inputs[i].buffer = buffer_create(dt_col->region,
351 			/* msglen + is_response + addrlen + is_tcp + packetlen + packet + zonelen + zone + spare + local_addr + addr */
352 			4+1+4+1+4+TCP_MAX_MESSAGE_LEN+4+MAXHOSTNAMELEN + 32 +
353 #ifdef INET6
354 			sizeof(struct sockaddr_storage) + sizeof(struct sockaddr_storage)
355 #else
356 			sizeof(struct sockaddr_in) + sizeof(struct sockaddr_in)
357 #endif
358 		);
359 		assert(buffer_capacity(dt_col->inputs[i].buffer) ==
360 			buffer_capacity(dt_col->send_buffer));
361 	}
362 }
363 
364 /* the dnstap collector process main routine */
dt_collector_run(struct dt_collector * dt_col,struct nsd * nsd)365 static void dt_collector_run(struct dt_collector* dt_col, struct nsd* nsd)
366 {
367 	/* init dnstap */
368 	VERBOSITY(1, (LOG_INFO, "dnstap collector started"));
369 	dt_init_dnstap(dt_col, nsd);
370 	dt_attach_events(dt_col, nsd);
371 
372 	/* run */
373 	if(event_base_loop(dt_col->event_base, 0) == -1) {
374 		error("dnstap collector: event_base_loop failed");
375 	}
376 
377 	/* cleanup and done */
378 	VERBOSITY(1, (LOG_INFO, "dnstap collector stopped"));
379 	dt_collector_cleanup(dt_col, nsd);
380 	exit(0);
381 }
382 
dt_collector_start(struct dt_collector * dt_col,struct nsd * nsd)383 void dt_collector_start(struct dt_collector* dt_col, struct nsd* nsd)
384 {
385 	int i, *fd_send;
386 	/* fork */
387 	dt_col->dt_pid = fork();
388 	if(dt_col->dt_pid == -1) {
389 		error("dnstap_collector: fork failed: %s", strerror(errno));
390 	}
391 	if(dt_col->dt_pid == 0) {
392 		/* the dt collector process is this */
393 		/* close the nsd side of the command channel */
394 		close(dt_col->cmd_socket_nsd);
395 		dt_col->cmd_socket_nsd = -1;
396 
397 		/* close the send side of the communication channels */
398 		assert(nsd->dt_collector_fd_send < nsd->dt_collector_fd_swap);
399 		fd_send = nsd->dt_collector_fd_send < nsd->dt_collector_fd_swap
400 			? nsd->dt_collector_fd_send : nsd->dt_collector_fd_swap;
401 		for(i=0; i<dt_col->count; i++) {
402 			if(fd_send[i] != -1) {
403 				close(fd_send[i]);
404 				fd_send[i] = -1;
405 			}
406 		}
407 #ifdef HAVE_SETPROCTITLE
408 		setproctitle("dnstap_collector");
409 #endif
410 		/* Free serve process specific memory pages */
411 #ifdef RATELIMIT
412 		rrl_mmap_deinit_keep_mmap();
413 #endif
414 		udb_base_free_keep_mmap(nsd->task[0]);
415 		udb_base_free_keep_mmap(nsd->task[1]);
416 		namedb_close_udb(nsd->db); /* keeps mmap */
417 		namedb_close(nsd->db);
418 
419 		dt_collector_run(dt_col, nsd);
420 		/* NOTREACH */
421 		exit(0);
422 	} else {
423 		/* the parent continues on, with starting NSD */
424 		/* close the dt side of the command channel */
425 		close(dt_col->cmd_socket_dt);
426 		dt_col->cmd_socket_dt = -1;
427 
428 		/* close the receive side of the communication channels */
429 		for(i=0; i<dt_col->count; i++) {
430 			if(nsd->dt_collector_fd_recv[i] != -1) {
431 				close(nsd->dt_collector_fd_recv[i]);
432 				nsd->dt_collector_fd_recv[i] = -1;
433 			}
434 		}
435 	}
436 }
437 
438 /* put data for sending to the collector process into the buffer */
439 static int
prep_send_data(struct buffer * buf,uint8_t is_response,struct sockaddr_storage * local_addr,struct sockaddr_storage * addr,socklen_t addrlen,int is_tcp,struct buffer * packet,struct zone * zone)440 prep_send_data(struct buffer* buf, uint8_t is_response,
441 #ifdef INET6
442 	struct sockaddr_storage* local_addr,
443 	struct sockaddr_storage* addr,
444 #else
445 	struct sockaddr_in* local_addr,
446 	struct sockaddr_in* addr,
447 #endif
448 	socklen_t addrlen, int is_tcp, struct buffer* packet,
449 	struct zone* zone)
450 {
451 	buffer_clear(buf);
452 #ifdef INET6
453 	if(local_addr->ss_family != addr->ss_family)
454 		return 0; /* must be same length to send */
455 #else
456 	if(local_addr->sin_family != addr->sin_family)
457 		return 0; /* must be same length to send */
458 #endif
459 	if(!buffer_available(buf, 4+1+4+2*addrlen+1+4+buffer_remaining(packet)))
460 		return 0; /* does not fit in send_buffer, log is dropped */
461 	buffer_skip(buf, 4); /* the length of the message goes here */
462 	buffer_write_u8(buf, is_response);
463 	buffer_write_u32(buf, addrlen);
464 	buffer_write(buf, local_addr, (size_t)addrlen);
465 	buffer_write(buf, addr, (size_t)addrlen);
466 	buffer_write_u8(buf, (is_tcp?1:0));
467 	buffer_write_u32(buf, buffer_remaining(packet));
468 	buffer_write(buf, buffer_begin(packet), buffer_remaining(packet));
469 	if(zone && zone->apex && domain_dname(zone->apex)) {
470 		if(!buffer_available(buf, 4 + domain_dname(zone->apex)->name_size))
471 			return 0;
472 		buffer_write_u32(buf, domain_dname(zone->apex)->name_size);
473 		buffer_write(buf, dname_name(domain_dname(zone->apex)),
474 			domain_dname(zone->apex)->name_size);
475 	} else {
476 		if(!buffer_available(buf, 4))
477 			return 0;
478 		buffer_write_u32(buf, 0);
479 	}
480 
481 	buffer_flip(buf);
482 	/* write length of message */
483 	buffer_write_u32_at(buf, 0, buffer_remaining(buf)-4);
484 	return 1;
485 }
486 
487 /* attempt to send buffer to socket, if it blocks do not send it.
488  * return 0 on success, -1 on error */
attempt_to_send(int s,uint8_t * data,size_t len)489 static int attempt_to_send(int s, uint8_t* data, size_t len)
490 {
491 	ssize_t r;
492 	if(len == 0)
493 		return 0;
494 	r = send(s, data, len, MSG_DONTWAIT | MSG_NOSIGNAL);
495 	if(r == -1) {
496 		if(errno == EAGAIN || errno == EINTR ||
497 				errno == ENOBUFS || errno == EMSGSIZE) {
498 			/* check if pipe is full, if the nonblocking fd blocks,
499 			 * then drop the message */
500 			return 0;
501 		}
502 		/* some sort of error, print it */
503 		log_msg(LOG_ERR, "dnstap collector: send failed: %s",
504 			strerror(errno));
505 		return -1;
506 	}
507 	assert(r > 0);
508 	if(r > 0) {
509 		assert((size_t)r == len);
510 		return 0;
511 	}
512 	/* Other end closed the channel? */
513 	log_msg(LOG_ERR, "dnstap collector: server child closed the channel");
514 	return -1;
515 }
516 
dt_collector_submit_auth_query(struct nsd * nsd,struct sockaddr_storage * local_addr,struct sockaddr_storage * addr,socklen_t addrlen,int is_tcp,struct buffer * packet)517 void dt_collector_submit_auth_query(struct nsd* nsd,
518 #ifdef INET6
519 	struct sockaddr_storage* local_addr,
520 	struct sockaddr_storage* addr,
521 #else
522 	struct sockaddr_in* local_addr,
523 	struct sockaddr_in* addr,
524 #endif
525 	socklen_t addrlen, int is_tcp, struct buffer* packet)
526 {
527 	if(!nsd->dt_collector) return;
528 	if(!nsd->options->dnstap_log_auth_query_messages) return;
529 	if(nsd->dt_collector_fd_send[nsd->this_child->child_num] == -1) return;
530 	VERBOSITY(4, (LOG_INFO, "dnstap submit auth query"));
531 
532 	/* marshal data into send buffer */
533 	if(!prep_send_data(nsd->dt_collector->send_buffer, 0, local_addr, addr, addrlen,
534 		is_tcp, packet, NULL))
535 		return; /* probably did not fit in buffer */
536 
537 	/* attempt to send data; do not block */
538 	if(attempt_to_send(nsd->dt_collector_fd_send[nsd->this_child->child_num],
539 			buffer_begin(nsd->dt_collector->send_buffer),
540 			buffer_remaining(nsd->dt_collector->send_buffer))) {
541 		/* Something went wrong sending to the socket. Don't send to
542 		 * this socket again. */
543 		close(nsd->dt_collector_fd_send[nsd->this_child->child_num]);
544 		nsd->dt_collector_fd_send[nsd->this_child->child_num] = -1;
545 	}
546 }
547 
dt_collector_submit_auth_response(struct nsd * nsd,struct sockaddr_storage * local_addr,struct sockaddr_storage * addr,socklen_t addrlen,int is_tcp,struct buffer * packet,struct zone * zone)548 void dt_collector_submit_auth_response(struct nsd* nsd,
549 #ifdef INET6
550 	struct sockaddr_storage* local_addr,
551 	struct sockaddr_storage* addr,
552 #else
553 	struct sockaddr_in* local_addr,
554 	struct sockaddr_in* addr,
555 #endif
556 	socklen_t addrlen, int is_tcp, struct buffer* packet,
557 	struct zone* zone)
558 {
559 	if(!nsd->dt_collector) return;
560 	if(!nsd->options->dnstap_log_auth_response_messages) return;
561 	if(nsd->dt_collector_fd_send[nsd->this_child->child_num] == -1) return;
562 	VERBOSITY(4, (LOG_INFO, "dnstap submit auth response"));
563 
564 	/* marshal data into send buffer */
565 	if(!prep_send_data(nsd->dt_collector->send_buffer, 1, local_addr, addr, addrlen,
566 		is_tcp, packet, zone))
567 		return; /* probably did not fit in buffer */
568 
569 	/* attempt to send data; do not block */
570 	if(attempt_to_send(nsd->dt_collector_fd_send[nsd->this_child->child_num],
571 			buffer_begin(nsd->dt_collector->send_buffer),
572 			buffer_remaining(nsd->dt_collector->send_buffer))) {
573 		/* Something went wrong sending to the socket. Don't send to
574 		 * this socket again. */
575 		close(nsd->dt_collector_fd_send[nsd->this_child->child_num]);
576 		nsd->dt_collector_fd_send[nsd->this_child->child_num] = -1;
577 	}
578 }
579