unbound/daemon/worker.c

/*
 * daemon/worker.c - worker that handles a pending list of requests.
 *
 * Copyright (c) 2007, NLnet Labs. All rights reserved.
 *
 * This software is open source.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 
 * Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 * 
 * Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 * 
 * Neither the name of the NLNET LABS nor the names of its contributors may
 * be used to endorse or promote products derived from this software without
 * specific prior written permission.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

/**
 * \file
 *
 * This file implements the worker that handles callbacks on events, for
 * pending requests.
 */
#include "config.h"
#include "util/log.h"
#include "daemon/worker.h"
#include "util/netevent.h"
#include "services/listen_dnsport.h"
#include "services/outside_network.h"

#ifdef HAVE_SYS_TYPES_H
#  include <sys/types.h>
#endif
#include <netdb.h>
#include <errno.h>

/** timeout in seconds for UDP queries to auth servers. TODO: proper rtt */
#define UDP_QUERY_TIMEOUT 5

/** process incoming request */
static void worker_process_query(struct worker* worker) 
{
	/* query the forwarding address */
	pending_udp_query(worker->back, worker->query_reply.c->buffer, 
		&worker->fwd_addr, worker->fwd_addrlen, UDP_QUERY_TIMEOUT);
}

/** check request sanity. Returns error code, 0 OK, or -1 discard. 
 * @param pkt: the wire packet to examine for sanity.
*/
static int worker_check_request(ldns_buffer* pkt)
{
	if(ldns_buffer_limit(pkt) < LDNS_HEADER_SIZE) {
		verbose(VERB_DETAIL, "request too short, discarded");
		return -1;
	}
	if(LDNS_QR_WIRE(ldns_buffer_begin(pkt))) {
		verbose(VERB_DETAIL, "request has QR bit on, discarded");
		return -1;
	}
	if(LDNS_OPCODE_WIRE(ldns_buffer_begin(pkt)) != LDNS_PACKET_QUERY) {
		verbose(VERB_DETAIL, "request unknown opcode %d", 
			LDNS_OPCODE_WIRE(ldns_buffer_begin(pkt)));
		return LDNS_RCODE_NOTIMPL;
	}
	if(LDNS_QDCOUNT(ldns_buffer_begin(pkt)) != 1) {
		verbose(VERB_DETAIL, "request wrong nr qd=%d", 
			LDNS_QDCOUNT(ldns_buffer_begin(pkt)));
		return LDNS_RCODE_FORMERR;
	}
	if(LDNS_ANCOUNT(ldns_buffer_begin(pkt)) != 0) {
		verbose(VERB_DETAIL, "request wrong nr an=%d", 
			LDNS_ANCOUNT(ldns_buffer_begin(pkt)));
		return LDNS_RCODE_FORMERR;
	}
	if(LDNS_NSCOUNT(ldns_buffer_begin(pkt)) != 0) {
		verbose(VERB_DETAIL, "request wrong nr ns=%d", 
			LDNS_NSCOUNT(ldns_buffer_begin(pkt)));
		return LDNS_RCODE_FORMERR;
	}
	if(LDNS_ARCOUNT(ldns_buffer_begin(pkt)) != 0) {
		verbose(VERB_DETAIL, "request wrong nr ar=%d", 
			LDNS_ARCOUNT(ldns_buffer_begin(pkt)));
		return LDNS_RCODE_FORMERR;
	}
	return 0;
}

/** handles callbacks from listening event interface */
static int worker_handle_request(struct comm_point* c, void* arg, int error,
	struct comm_reply* repinfo)
{
	struct worker* worker = (struct worker*)arg;
	int ret;
	log_info("worker handle request");
	if(error != 0) {
		log_err("called with err=%d", error);
		return 0;
	}
	if((ret=worker_check_request(c->buffer)) != 0) {
		if(ret != -1) {
			LDNS_RCODE_SET(ldns_buffer_begin(c->buffer), ret);
			return 1;
		}
		return 0;
	}
	if(worker->num_requests > 0) {
		verbose(VERB_DETAIL, "worker: too many requests active. "
			"dropping incoming query.");
		return 0;
	}
	/* answer it */
	worker->num_requests ++;
	memcpy(&worker->query_reply, repinfo, sizeof(struct comm_reply));
	worker_process_query(worker);
	return 0;
}

struct worker* worker_init(const char* port, int do_ip4, int do_ip6,
	int do_udp, int do_tcp, size_t buffer_size, size_t numports,
	int base_port)
{
	struct worker* worker = (struct worker*)calloc(1, 
		sizeof(struct worker));
	if(!worker) 
		return NULL;
	worker->base = comm_base_create();
	if(!worker->base) {
		log_err("could not create event handling base");
		return NULL;
	}
	worker->front = listen_create(worker->base, 0, NULL, port, 
		do_ip4, do_ip6, do_udp, do_tcp, buffer_size, 
		worker_handle_request, worker);
	if(!worker->front) {
		comm_base_delete(worker->base);
		log_err("could not create listening sockets");
		return NULL;
	}
	worker->back = outside_network_create(worker->base,
		buffer_size, numports, NULL, 0, do_ip4, do_ip6, base_port);
	if(!worker->back) {
		comm_base_delete(worker->base);
		log_err("could not create outgoing sockets");
		return NULL;
	}
	/* init random(), large table size. */
	if(!initstate(time(NULL)^getpid(), worker->rndstate, RND_STATE_SIZE)) {
		log_err("could not init random numbers.");
		comm_base_delete(worker->base);
		return NULL;
	}
	return worker;
}

void worker_work(struct worker* worker)
{
	comm_base_dispatch(worker->base);
}

void worker_delete(struct worker* worker)
{
	if(!worker) 
		return;
	listen_delete(worker->front);
	outside_network_delete(worker->back);
	comm_base_delete(worker->base);
	free(worker);
}

int worker_set_fwd(struct worker* worker, const char* ip, const char* port)
{
	struct addrinfo *res = NULL;
	struct addrinfo hints;
	int r;
	log_assert(worker && ip);
	memset(&hints, 0, sizeof(hints));
	hints.ai_family = AF_UNSPEC;
	hints.ai_socktype = SOCK_DGRAM;
	if(!port) 
		port = UNBOUND_DNS_PORT;
	if((r=getaddrinfo(ip, port, &hints, &res)) != 0 || !res) {
		log_err("failed %s:%s getaddrinfo: %s %s",
			ip, port,
			gai_strerror(r), r==EAI_SYSTEM?strerror(errno):"");
		return 0;
	}
	worker->fwd_addrlen = res->ai_addrlen;
	memcpy(&worker->fwd_addr, &res->ai_addr, res->ai_addrlen);
	freeaddrinfo(res);
	return 1;
}