namecachemain.c

p2p类源代码 kadc协议官方源代码

	signal(sig, SIG_IGN);
}

#else

/* This thread waits for TERM and INT signals, and when
   they are found, sets the shutdown_flag */
void* sig_handler_th(void* arg) {
	DNSIO *pdnsio = glob_pdnsio;
	sigset_t signal_set;
	int sig;

	/* we loop forever (and the main thread does not join() on this thread)
	   because under GNU Pth signal blocking doesn't seem to work; a
	   signal issued when no sigwait() is waiting for it always terminates
	   the process... So we leave this thread to sigwait() till the process'
	   exit.
	 */
	for(;;) {
		/* wait for these signal (they are all already blocked) */
		sigemptyset(&signal_set);
		sigaddset(&signal_set, SIGTERM);
		sigaddset(&signal_set, SIGINT);
		sigwait(&signal_set, &sig);

		/* here we've caught a signal! */
		pthread_mutex_lock(&pdnsio->mutex);
#ifdef DEBUG
		KadC_log("Signal %d caught, shutdown_flag set to 1\n", sig);
#endif
		pdnsio->shutdown_flag = 1;
		pthread_mutex_unlock(&pdnsio->mutex);
	}

	return NULL;
}

#endif


int main(int ac, char *av[]) {
	char *kadcinifile = NULL;
	int leafmode = 1;	/* default: leaf mode */
	KadC_status kcs;
	processing_thread_params ptp = {0};	/* don't forget to init to all 0's... */
	pthread_t udprecv;
	pthread_t proc;
	pthread_t publish;
	char c;
	DNSIO dnsio = {0};
	KadCcontext kcc = {0};
	int status;
	unsigned long int ip;
#ifndef __WIN32__
	char *user = NULL;
	char *group = NULL;
#endif
#ifndef OLD_STYLE_SIGNAL
	sigset_t signal_set;
	pthread_t sig_thread;
#endif

	KadC_log("namecache - KadC library version: %d.%d.%d\n",
		KadC_version.major, KadC_version.minor, KadC_version.patchlevel);

	dnsio.mutex = mutex_initializer;
	glob_pdnsio = &dnsio;

	ptp.cache_maxentries = -1;
	dnsio.port = DNS_PORT;	/* default */

#ifndef __WIN32__	/* if UNIX */
	while( (c = getopt( ac, av, "k:c:t:s:d:li:p:u:g:h")) != EOF ) {
#else
	while( (c = getopt( ac, av, "k:c:t:s:d:li:p:h")) != EOF ) {
#endif
		switch(c) {
		case 'k':
			kadcinifile = optarg;
			break;
		case 'c':
			ptp.cache_maxentries = atoi(optarg);
			break;
		case 't':
			if(ptp.ntlpd >= arraysize(ptp.tlpd)) {
				KadC_log("Can't handle more than %d \"-t\" options\n", arraysize(ptp.tlpd));
				exit(1);
			}
			ptp.tlpd[ptp.ntlpd++] = optarg;
			break;
		case 's':
			if(dnsio.nupstream >= arraysize(dnsio.upstream)) {
				KadC_log("Can't specify more than %d upstream servers with \"-s\" options\n", arraysize(dnsio.upstream));
				exit(1);
			}
			ip = inet_addr(optarg);
			if(ip == -1) {
				KadC_log("Invalid IP address %s in \"-s\" option\n", optarg);
				exit(1);
			}
			dnsio.upstream[dnsio.nupstream++] = ntohl(ip);
			break;

		case 'd':
			if(ptp.nmy_pseudo >= arraysize(ptp.my_pseudo)) {
				KadC_log("Can't handle more than %d \"-d\" options\n", arraysize(ptp.my_pseudo));
				exit(1);
			}
			ptp.my_pseudo[ptp.nmy_pseudo++] = optarg;
			break;
/*
		case 'l':
			leafmode = 1;
			break;
 */
		case 'i':				/* IP address to bind to */
			ip = inet_addr(optarg);
			if(ip == -1) {
				KadC_log("Invalid IP address %s in \"-b\" option\n", optarg);
				exit(1);
			}
			dnsio.ip = ntohl(ip);
			break;
		case 'p':				/* UDP port to bind to */
			dnsio.port = atoi(optarg);
			break;
#ifndef __WIN32__
		case 'u':
			user = optarg;
			break;
		case 'g':
			group = optarg;
			break;
#endif
		case 'h':
		default:
			usage(av[0]);
			return 1;
		}
	}

	/* a few consistency checks between options: */

#if !defined(__WIN32__) && !defined(__CYGWIN__)
	if(user != NULL) {
		dnsio.uid = user2uid(user);
		if(dnsio.uid < 0) {
			KadC_log("Could not retrieve the UID of the user %s\n", user);
			return 1;
		}
		dnsio.gid = user2gid(user);
		if(dnsio.gid < 0) {
			KadC_log("Could not retrieve the GID of the user %s\n", user);
			return 1;
		}
	} else {	/* "-u" option not present: no good if we are root! */
		if(we_have_root_privilege()) {	/* ###### FIXME: detect privilege here */
			KadC_log("For security reasons, this program must drop root privilege after startup.\n");
			KadC_log("Please use the \"-u\" option to define a non-privileged user (e.g., \"-u nobody\")\n");
			return 1;
		}
	}
	if(group != NULL) {
		dnsio.gid = group2gid(group);
		if(dnsio.gid < 0) {
			KadC_log("Could not retrieve the GID of the group %s\n", group);
			return 1;
		}
	}
#endif

	if(kadcinifile == NULL && ptp.ntlpd > 0) {
		KadC_log("Can't resolve queries via P2P for the %d pseudo-domains specified with \"-t\" options if a KadC ini file is not specified\n", ptp.ntlpd);
		usage(av[0]);
		return 1;
	}

	if(kadcinifile == NULL && ptp.nmy_pseudo != 0) {
		KadC_log("Can't publish via P2P with \"-d\" record associating names to IP addresses if a KadC ini file is not specified\n");
		usage(av[0]);
		return 1;
	}

	if(ptp.ntlpd == 0 && dnsio.nupstream == 0) {
		KadC_log("Can't resolve queries either via DNS or P2P: at least one of -s or -t must be specified.\n");
		usage(av[0]);
		return 1;
	}

	if(kadcinifile != NULL && ptp.ntlpd == 0 && ptp.nmy_pseudo == 0) {
		KadC_log("Warning: if we neither resolve (-t) nor publish (-p) via P2P, what's the point of specifying \"-k %s\" and running KadC?\n", kadcinifile);
	}

	if(ptp.cache_maxentries == -1)
		ptp.cache_maxentries = 4096;	/* default */



	/* if we are under WIN32, this will call WSAStartup() and put in
	   place an atexit hook to WSACleanup() */
	KadC_init_network();

	/* open UDP socket and prepare UDP I/O */
	dnsio.fifo = new_queue(8); /* not more than 8 outstanding requests */
	assert(dnsio.fifo != NULL);
	if(udp_dns_init(&dnsio) < 1) {
		KadC_log("dns_udp_recv_thread reports socket error %d\n", dnsio.err);
		dnsio.fifo->destroy(dnsio.fifo);
		goto exit;
	}

/* Drop root privileges, if under some flavour of *NIX */

#if !defined(__WIN32__) && !defined(__CYGWIN__)
	if((status = droppriv(dnsio.uid, dnsio.gid)) != 0) {
		KadC_log("FATAL: Couldn't drop root privilege: ");
		if(status == -1)
			KadC_log("suppl. group IDs reset to non-root GID failed\n");
		else if(status == -2)
			KadC_log("couldn't change to non-privileged GID %d\n", dnsio.gid);
		else if(status == -3)
			KadC_log("couldn't change to non-root UID %d\n", dnsio.uid);
		else if(status == -4)
			KadC_log("once non-root, setuid(0) managed to restore root UID!\n");
		exit(1);
	}
#endif

/* Install signal handlers */

#ifdef OLD_STYLE_SIGNAL

	signal(SIGTERM, sighandler);	/* for the TERM signal (15, default for kill command)...  */
	signal(SIGINT, sighandler); 	/* .. the INT signal... (Ctrl-C  hit on keyboard) */

#else

	/* block signals we'll wait for */
	sigemptyset(&signal_set);
	sigaddset(&signal_set, SIGTERM);
	sigaddset(&signal_set, SIGINT);
#ifdef __WIN32__
	sigaddset(&signal_set, SIGBREAK);
#endif
	pthread_sigmask(SIG_BLOCK, &signal_set,	NULL);

	/* create the signal handling thread */
	pthread_create(&sig_thread, NULL, sig_handler_th, NULL);

#endif

/* Start KadC engine, if the -k option was present */

	if(kadcinifile != NULL) {
		kcc = KadC_start(kadcinifile, leafmode, 0);
		if(kcc.s != KADC_OK) {
			KadC_log("KadC_start(%s, %d) returned error %d:\n",
				kadcinifile, leafmode, kcc.s);
			KadC_log("%s %s", kcc.errmsg1, kcc.errmsg2);
			return 2;
		}
		KadC_log("Our hash ID: %s ");
		KadC_int128flog(stdout, KadC_getourhashID(&kcc));
		KadC_log("\nour UDP port: %u, our TCP port: %u\n",
		KadC_getourUDPport(&kcc),
		KadC_getourTCPport(&kcc));
	}

	/* spawn the UDP init & listener loop thread */
	pthread_create(&udprecv, NULL, dns_udp_recv_thread, &dnsio);

	/* go to process requests posted by UDP listener to pdnsio->fifo,
	   spawning threads as needed, and send UDP replies with
	   sendto() to pdnsio->fd */
	ptp.pkcc = &kcc;
	ptp.pdnsio = &dnsio;
	/* create the pending questions table - ID is significant! */
	ptp.pending_q_rbt = rbt_new((rbtcomp *)&DNSpacket_qi_lt, (rbtcomp *)&DNSpacket_qi_eq);
	assert(ptp.pending_q_rbt != NULL);
	/* create the raw_qa cache. ID is NOT significant */
	ptp.cache_q_rbt = rbt_new((rbtcomp *)&DNSpacket_q_lt, (rbtcomp *)&DNSpacket_q_eq);
	assert(ptp.cache_q_rbt != NULL);
	ptp.mutex = mutex_initializer;

	/* start the processing thread, which reads incoming DNS data from FIFO queue */
	pthread_create(&proc, NULL, processing_thread, &ptp);

	/* start the publishing thread, which every two hours republishes records for our domain names */
	pthread_create(&publish, NULL, publishing_thread, &ptp);

	ConsoleLoop(&ptp);

	KadC_log("Shutting down, please wait...\n");

/* sig_thread never returns (see comments in processing_thread() ).
#ifndef OLD_STYLE_SIGNAL
	pthread_join(sig_thread, NULL);
#endif
 */
	pthread_join(publish, NULL);
	pthread_join(proc, NULL);
	pthread_mutex_destroy(&ptp.mutex);

	pthread_join(udprecv, NULL);
	pthread_mutex_destroy(&dnsio.mutex);

	status = qa_rbt_destroy(ptp.cache_q_rbt, 1);	/* also destroy data */
	assert(status == 0);
	status = qa_rbt_destroy(ptp.pending_q_rbt, 1);	/* also destroy data */
	assert(status == 0);

	dnsio.fifo->destroy(dnsio.fifo);	/* destroy queue used to communicate with udprecv */

	if(kadcinifile != NULL) {
		kcs = KadC_stop(&kcc);
		if(kcs != KADC_OK) {
			KadC_log("KadC_stop(&kcc) returned error %d:\n", kcc.s);
			KadC_log("%s %s", kcc.errmsg1, kcc.errmsg2);
			return 3;
		}
	}
exit:
	KadC_list_outstanding_mallocs(10);

	return 0;
}

/* converts "4.3.2.1.in-addr.arpa" into the IP address 1.2.3.4 */

unsigned long int reverse_inet_addr(char *s) {
	unsigned int b1, b2, b3, b4;
	char *p;
	int n;

	if(s == NULL)
		return -1;
	n = sscanf(s, "%u.%u.%u.%u.in-addr.arpa%s", &b4, &b3, &b2, &b1, p);
	if(n<4)
		return -1;
	if(n == 5 && strcmp(p, ".") != 0)
		return -1;
	return(b1<<24) + (b2<<16) + (b3<<8) + b4;
}

/* we are authoritative:
   - for PTR queries resolving to an address on some interface;
     the proper answer is "cachehost.cachedomain", replied immedately
   - for A queries relative to our pseudo-domain
     the proper answer is our external IP, replied immediately
   - for A queries under some tlpd
     the proper answer is a KadC search, replied later
 */

static void ConsoleLoop(processing_thread_params *pptp) {
	for(;;){
		int sf;
		pthread_mutex_lock(&pptp->pdnsio->mutex);	/* \\\\\\ LOCK \\\\\\ */
		sf = pptp->pdnsio->shutdown_flag;
		pthread_mutex_unlock(&pptp->pdnsio->mutex);	/* ///// UNLOCK ///// */
		if(sf)
			break;
#if 0	/* suppress console input when not in debug mode */
		KadCcontext *pkcc = pptp->pkcc;
		char line[80];
		int linesize = sizeof(line)-1;
		char *s;
		int fwstatus = KadC_getfwstatus(pkcc);
		KadC_log("%4d/%4d%s ",
			KadC_getnknodes(pkcc), KadC_getncontacts(pkcc),
			(fwstatus>0 ? (fwstatus>1 ? ">" : "]") : "?"));
		s = KadC_getsn(line, linesize);
		if(s == NULL)
			break;
#else
		/* KadC_log("."); */
		millisleep(1000);
#endif
	}
}

/* create an entry in the pending queries rbt, unless already there
   This is the single point where raw_qa objects are created. They
   are then converted in cached qa's in the processing thread by
   adding the reply, when it arrives. */
static int create_pending_entry(processing_thread_params *pptp, DNSpacket *pdnp, void *threadcode(void *)) {
	void *iter;
	rbt_StatusEnum rbt_status = rbt_find(pptp->pending_q_rbt, pdnp, &iter);
	if(rbt_status == RBT_STATUS_KEY_NOT_FOUND) {
		/* this is the only place where a raw_qa is created */
		raw_qa *pending_qa = calloc(1, sizeof(raw_qa));
		assert(pending_qa != NULL);
		pending_qa->q = pdnp;
		pending_qa->a = NULL;	/* answer is void, of course */
		pending_qa->last_accessed = time(NULL); /* informational, actually unused in pending_q_rbt */
		pending_qa->expiry = pending_qa->last_accessed + 300;
		pending_qa->being_refreshed = 0;	/* unused in pending_q_rbt */
		pending_qa->mutex = mutex_initializer;
		pending_qa->pptp = pptp;
		rbt_status = rbt_insert(pptp->pending_q_rbt, pending_qa->q, pending_qa, 0);
		assert(rbt_status == RBT_STATUS_OK);	/* can't be already there now... */
#ifdef VERBOSE_DEBUG
			KadC_log("create_pending_entry() created a pending_query entry \n");
#endif
		if(threadcode != NULL) {
#ifdef DEBUG
			KadC_log("create_pending_entry() also started a p2pquery thread\n");
#endif
			pending_qa->isdetached = 1;
			pthread_create(&pending_qa->thread, NULL, threadcode, pending_qa);