netsukuku/src/ntkresolv.c

#include <netinet/in.h>

#include "includes.h"

#include "ntkresolv.h"
#include "andns_net.h"
#include "snsd_cache.h"
#include "crypto.h"
#include "common.h"

static ntkresolv_opts globopts;
static struct timeval time_start,time_stop;
uint8_t mode_compute_hash=0;
uint8_t mode_parsable_output=0;

void version(void)
{
        say("ntk-resolv version %s (Netsukuku tools)\n\n"
            "Copyright (C) 2006.\n"
            "This is free software.  You may redistribute copies of it under the terms of\n"
            "the GNU General Public License <http://www.gnu.org/licenses/gpl.html>.\n"
            "There is NO WARRANTY, to the extent permitted by law.\n\n"
	    "Report bugs and ideas to <%s>.\n",VERSION,NTK_RESOLV_MAIL_BUGS);
	ntkresolv_safe_exit(1);
}


void usage(void)
{
        say("Usage:\n"
                "\tntk-resolv [OPTIONS] host\n"
                "\tntk-resolv -H host\n\n"
                " -v --version          print version, then exit.\n"
                " -n --nameserver=ns    use nameserver `ns' instead of localhost.\n"
                " -P --port=port        nameserver port, default 53.\n"
                " -t --query-type=qt    query type (`-t help' shows more info).\n"
                " -r --realm=realm      realm to scan (`-r help' shows more info).\n"
                " -s --service=service  SNSD service (`-s help' shows more info).\n"
                " -p --protocolo=proto  SNSD protocol (`-p help' shows more info).\n"
                " -S --silent           ntk-resolv will be not loquacious.\n"
                " -b --block-recursion  set recursion OFF.\n"
                " -m --md5-hash         hostname specified is hash-ed.\n"
                " -H --compute-hash     print the hash'ed hostname.\n"
                " -l --parsable-output  print answers in a synthetic way.\n"
                " -h --help             display this help, then exit.\n\n"
		"Report bugs and ideas to <%s>.\n",NTK_RESOLV_MAIL_BUGS);
	ntkresolv_safe_exit(1);
}
void qt_usage(char *arg)
{
	if (arg)
		say("Bad Query Type %s\n\n",arg);
	else
		say("ntk-resolv Query Type Help.\n\n");
	say(
	    "Valid query types are:\n"
            " * snsd\t\thost:port -> ip\n"
            "   ptr\t\tip -> host\n"
            "   global\thostname -> all services ip\n"
            "   mx\t\thostname MX -> ip\n\n"
            "(you can also use univoque abbreviation)\n"
	    "Note: mx query is equivalent to --query-type="
	    "snsd AND --service=25\n\n");
	ntkresolv_safe_exit(1);
}
void realm_usage(char *arg)
{
	if (arg)
		say("Bad Realm %s\n\n",arg);
	else
		say("ntk-resolv Realm Help.\n\n");
	say(
	    "Valid realms are:\n"
            " * ntk\tnetsukuku realm\n"
            "   inet\tinternet realm\n\n"
            "(you can also use univoque abbreviation)\n\n");
	ntkresolv_safe_exit(1);
}
void proto_usage(char *arg)
{
	if (arg)
		say("Bad Protocol %s\n\n",arg);
	else
		say("ntk-resolv Protocol Help.\n\n");
	say(
	    "Valid protocols are:\n"
            " * tcp\n"
            "   udp\n"
            "(you can also use univoque abbreviation)\n"
	    "Note: you can also specify the protocol with option `-s'.\n" 
	    "To know more, type:\n"
	    "\tntk-resolv -s help\n\n");
	ntkresolv_safe_exit(1);
}
void service_and_proto_usage(char *arg)
{
	if (arg)
		say("Bad service/proto %s\n\n"
			"Use `ntk-resolv -s help` for more info on"
			" service and proto.\n"	,arg);
	else say(
		"ntk-resolv Service and Proto Help.\n\n"
		"The form to specify a service and a protocol are:\n"
		"  ntk-resolv -s service/proto\n"
		"  ntk-resolv -s service -p proto\n\n"
		"Valid protocols are:\n"
	        " * tcp\n"
            	"   udp\n\n"
		"Valid services are expressed in /etc/services.\n"
		"You can use numeric form too.\n\n"
		"As example, the next commands are equivalent and\n"
		"will return the IP of the hostname that offers\n"
		"webpages for the hostname \"some_hostname\":\n\n"
		"  ntk-resolv -s http -p tcp some_hostname\n"
		"  ntk-resolv -s http/tcp    some_hostname\n"
		"  ntk-resolv -s 80/tcp      some_hostname\n"
		"  ntk-resolv -s 80          some_hostname\n\n");
	ntkresolv_safe_exit(1);
}
		

double diff_time(struct timeval a,struct timeval b)
{
        double res;
        res=(double)(b.tv_sec-a.tv_sec);
	if (res<0.9 || b.tv_usec>=a.tv_usec)
		res+=(b.tv_usec-a.tv_usec)/TIME_SCALE;
	else {
		res-=1.0;
		res+=(TIME_SCALE+b.tv_usec-a.tv_usec)/TIME_SCALE;
	}
        return res;
}


void opts_init(void)
{
	memset(&GOP,0,NTKRESOLV_OPTS_SZ);
	strcpy(GOP.nsserver,LOCALHOST);
	GOP.port=NTKRESOLV_PORT;
	GQT=create_andns_pkt();
	GQT->nk=REALM_NTK;
	GQT->p=SNSD_PROTO_DEFAULT;
	GQT->service=SNSD_SERVICE_DEFAULT;
	GQT->r=1;
	xsrand();
}

void opts_set_silent(void)
{
	GOP.silent=1;
}

void opts_set_port(char *arg)
{
	int res;
	uint16_t port;

	res=atoi(arg);
	port=(uint16_t)res;

	if (port!=res) {
		say("Bad port %s.",arg);
		ntkresolv_safe_exit(1);
	}
	GOP.port=port;
}

void opts_set_ns(char *arg)
{
	int slen;

	slen=strlen(arg);
	if (slen>=MAX_HOSTNAME_LEN) {
		say("Server hostname too long.");
		ntkresolv_safe_exit(1);
	}
	strcpy(GOP.nsserver,arg);
	GOP.nsserver[slen]=0;
}

void opts_set_qt(char *arg)
{
	int res;

	if (!strcmp(arg,HELP_STR))
		qt_usage(NULL);
	res=QTFROMPREF(arg);
	if (res==-1) 
		qt_usage(arg);
	if (res==QTYPE_MX) {
		GQT->qtype=QTYPE_A;
		GQT->service=25;
		GQT->p=SNSD_PROTO_TCP;
	} else
		GQT->qtype=res;
}

void opts_set_realm(char *arg)
{
	uint8_t res;

	if (!strcmp(arg,HELP_STR))
		realm_usage(NULL);
	res=REALMFROMPREF(arg);
	if (!res) 
		realm_usage(arg);
	GQT->nk=res;
}

void opts_set_service_and_proto(char *arg)
{
	int ret;

	if (!strcmp(arg,HELP_STR))
		service_and_proto_usage(NULL);
	ret=str_to_snsd_service(arg, (int *)&GQT->service, &GQT->p);
/*	if(ret == -1)
		say("Bad service %s.",arg);
	else if(ret == -2)
		proto_usage(arg);*/
	if(ret < 0)
		service_and_proto_usage(arg);
	GQT->p-=1;
}
void opts_set_proto(char *arg) 
{
	int ret;

	if (!strcmp(arg,HELP_STR))
		proto_usage(NULL);
	ret=PROTOFROMPREF(arg);
	if (ret<0)
		proto_usage(arg);
	GQT->p=ret;
}
/* This is a complex set of function. */
void opts_set_recursion(void)
{
	GQT->r=0;
}
void opts_set_hash(void) 
{
	GOP.hash=1;
}
void opts_set_compute_hash(void)
{
	mode_compute_hash=1;
}
void opts_set_parsable_output(void)
{
	mode_parsable_output=1;
	AMISILENT=1;
}
void opts_set_question(char *arg)
{
	struct in_addr ia;
	struct in6_addr i6a;
	int res;
	
	strcpy(GOP.obj,arg);
	res=strlen(arg);
	
	switch(GQT->qtype) {
		case QTYPE_A:
			if (GQT->nk==REALM_NTK) {
				G_ALIGN(ANDNS_HASH_H);
				if (GOP.hash) {
					if (res!=2*ANDNS_HASH_H) {
						say("Malformed Hostname hash `%s'.\n",arg);
						ntkresolv_safe_exit(1);
					}
					NTK_RESOLV_STR_HASH(arg,GQT->qstdata);
				}
				else
					hash_md5((unsigned char*)arg,res,
						(unsigned char*)GQT->qstdata);
			} else {
				if (res>255) {
					say("Hostname %s is too long for DNS standard.",arg);
					ntkresolv_safe_exit(1);
				}
				G_ALIGN(res);
				strcpy(GQT->qstdata,arg);
			}
			return;
		case QTYPE_PTR:
			res=inet_pton(AF_INET,arg,&ia);
			if (res) {
				G_ALIGN(ANDNS_HASH_H);
				memcpy(GQT->qstdata,&ia.s_addr,4);
				return;
			}
			res=inet_pton(AF_INET6,arg,&i6a);
			if (!res) {
				say("Bad address `%s'\n",arg);
				ntkresolv_safe_exit(1);
			}
			G_ALIGN(16);
			memcpy(GQT->qstdata,&i6a.__in6_u,16);
			GQT->ipv=ANDNS_IPV6;
			return;
		case QTYPE_G:
			if (GQT->nk!=REALM_NTK) {
				say("Global query type is valid only for the Ntk realm.");
				ntkresolv_safe_exit(1);
			}
			G_ALIGN(ANDNS_HASH_H);
			if (GOP.hash)
				NTK_RESOLV_STR_HASH(arg,GQT->qstdata);
			else
				hash_md5((unsigned char*)arg,res,
					(unsigned char*)GQT->qstdata);
			return;	
		default:
			say("Unknow Query Type.\n");
			return;
	}
}
void opts_finish(char *arg)
{
	int r;

	r=strlen(arg);
	if (r>NTKRESOLV_MAX_OBJ_LEN) {
		say("Object requested is too long: %s",arg);
		ntkresolv_safe_exit(1);
	}

	if (mode_compute_hash) { /* Do command here and exit */
		G_ALIGN(ANDNS_HASH_H);
		hash_md5((unsigned char*)arg,r,
			(unsigned char*)GQT->qstdata);
		NTK_RESOLV_HASH_STR(GQT->qstdata,GOP.obj);
		say("%s\n",GOP.obj);
		ntkresolv_safe_exit(0);
	}
	if (GOP.hash && GQT->qtype==AT_PTR) {
		say("Option `-m' is not usable with inverse queries.\n");
		ntkresolv_safe_exit(1);
	}
	r=rand();
	GQT->id=r>>16;
	opts_set_question(arg);
}

void print_headers()
{
	andns_pkt *ap=GQT;
	say("\n - Headers Section:\n"
		"\tid ~ %6d\tqr  ~ %4d\tqtype ~ %7s\n"
		"\tan ~ %6d\tipv ~ %s\trealm ~ %7s\n"
		"\tsv ~ %6s\tprt ~ %4s\trCode ~ %s\n"
		"\trc ~ %6d\n",
		ap->id,ap->qr,QTYPE_STR(ap),
		ap->ancount,IPV_STR(ap),NK_STR(ap),
		SERVICE_STR(ap),PROTO_STR(ap),
		RCODE_STR(ap),ap->r);
}
void print_question()
{
	say("\n - Question Section:\n"
		"\tObj ~ %s\n",GOP.obj);
}

void ip_bin_to_str(void *data,char *dst)
{
	int family;
	struct in_addr ia;
	struct in6_addr i6a;
	const void *via;
	const char *crow;

	family=GQT->ipv==ANDNS_IPV4?
		AF_INET:AF_INET6;
	switch(family) {
		case AF_INET:
			memcpy(&(ia.s_addr),data,4);
			via=(void*)(&ia);
			break;
		case AF_INET6:
			memcpy(&(i6a.__in6_u),data,16);
			via=(void*)(&i6a);
			break;
		default:
			strcpy(dst,"Unprintable Object");
			return;
	}
	crow=inet_ntop(family,via,dst,NTKRESOLV_MAX_OBJ_LEN);
	if (!crow) 
		strcpy(dst,"Unprintable Object");
}

void answer_data_to_str(andns_pkt_data *apd,char *dst)
{
	if (GQT->qtype==AT_PTR)
			strcpy(dst,apd->rdata);
	else if (GQT->qtype==AT_G || GQT->qtype==AT_A) {
			if (apd->m&APD_IP)
				ip_bin_to_str(apd->rdata,dst);
			else 
				NTK_RESOLV_HASH_STR(apd->rdata,dst);
	} 
	else
		strcpy(dst,"Unprintable Object");
}
void print_answers()
{
	int i=0;
	int ancount=GQT->ancount;
	andns_pkt_data *apd;

	if (!ancount)
		return;

	say("\n - Answers Section:\n");

	apd=GQT->pkt_answ;
	while (apd) {
		i++;
		if (i>ancount) 
			say("Answer not declared in Headers Packet.\n");
		answer_data_to_str(apd,GOP.obj);
		say("\t ~ %s",GOP.obj);
		if (apd->m&APD_MAIN_IP)
			say(" *");
		else if (GQT->qtype!=AT_PTR && !(apd->m&APD_IP) && GQT->r)
			say("\t + Recursion Failed");
		say("\n");
		if (GQT->qtype==AT_A || GQT->qtype==AT_G) 
			say("\t\tPrio ~ %d  Weigth ~ %d\n",
				apd->prio,apd->wg);
		if (GQT->qtype==AT_G)
			say("\t\tService ~ %d  Proto ~ %s\n",
				apd->service,apd->m&APD_UDP?
				"udp":"tcp");
		say("\n");
		apd=apd->next;
	}
}

void print_parsable_answers(void)
{
	int i=0;
	int ancount=GQT->ancount;
	andns_pkt_data *apd;

	if (!ancount)
		return;

	apd=GQT->pkt_answ;
	while(apd) {
		i++;
		if (i>ancount) 
			say("Answer not declared in Headers Packet.\n");
		answer_data_to_str(apd,GOP.obj);
		if (GQT->qtype==AT_PTR || 
		   (GQT->qtype==AT_A && !GQT->service)) 
			say("%s %s\n",NTK_RESOLV_SYMBOL(apd),GOP.obj);
		else if (GQT->qtype==AT_A) 
			say("%s %s %d %d\n",NTK_RESOLV_SYMBOL(apd),
				GOP.obj,apd->prio,apd->wg);
		else 
			say("%s %s %d %s %d %d\n",NTK_RESOLV_SYMBOL(apd),
				GOP.obj,apd->service,
				apd->m&APD_UDP?"udp":"tcp",
				apd->prio,apd->wg);
		apd=apd->next;
	}
}

void print_results(void) 
{
	if (!AMISILENT) {
		print_headers();
		print_question();
	}
	if (mode_parsable_output)
		print_parsable_answers();
	else
		print_answers();
}

void do_command(void)
{
	char buf[ANDNS_MAX_SZ];
	char answer[ANDNS_MAX_PK_LEN];
	int res;

	memset(buf,0,ANDNS_MAX_SZ);
	GOP.id=GQT->id;
	res=a_p(GQT,buf);
	if (res==-1) {
		say("Error building question.\n");
		ntkresolv_exit(1);
	}
	res=hn_send_recv_close(GOP.nsserver,GOP.port,
			SOCK_DGRAM,buf,res,answer,
			ANDNS_MAX_PK_LEN,0,NTK_RESOLV_TIMEOUT);
	if (res==-1) {
		say("Communication failed with %s.\n",GOP.nsserver);
		ntkresolv_exit(1);
	}
	if (res==-2) {
		say("Unable to send() to %s.\n",GOP.nsserver);
		ntkresolv_exit(1);
	}
	if (res==-3) {
		say("Unable to recv() from %s.\n",GOP.nsserver);
		ntkresolv_exit(1);
	}
	res=a_u(answer,res,&GQT);
	if (res<=0) {
		say("Error interpreting server answer.\n");
		ntkresolv_exit(1);
	}
	if (GQT->id!=GOP.id) 
		say("Warning: ID query (%d) is mismatching ID answer (%d)!\n",GOP.id,GQT->id);

	print_results();
	destroy_andns_pkt(GQT);
}
void ntkresolv_exit(int i)
{
	exit(i);
}
void ntkresolv_safe_exit(int i)
{
	destroy_andns_pkt(GQT);
	ntkresolv_exit(i);
}
int main(int argc, char **argv)
{
        int c;
        extern int optind, opterr, optopt;
        extern char *optarg;

	log_init("",0,1);
	gettimeofday(&time_start,NULL);

	opts_init();
	struct option longopts[]= {
                {"version",0,0,'v'},
                {"nameserver",1,0,'n'},
                {"port",1,0,'P'},
                {"query-type",1,0,'t'},
                {"realm",1,0,'r'},
                {"service",1,0,'s'},
                {"proto",1,0,'p'},
                {"silent",0,0,'S'},
                {"block-recursion",0,0,'b'},
                {"md5-hash",0,0,'m'},
                {"compute-hash",0,0,'H'},
                {"parsable-output",0,0,'l'},
                {"help",0,0,'h'},
                {0,0,0,0}
        };

	while(1) {
		int oindex=0;
		c=getopt_long(argc, argv, 
			"vn:P:t:r:s:p:ShbmHl", longopts, &oindex);
		if (c==-1)
			break;
		switch(c) {
			case 'v':
				version();
			case 'n':
				opts_set_ns(optarg);
				break;
			case 'P':
				opts_set_port(optarg);
				break;
			case 't':
				opts_set_qt(optarg);
				break;
			case 'r':
				opts_set_realm(optarg);
				break;
			case 's':
				opts_set_service_and_proto(optarg);
				break;	
			case 'p':
				opts_set_proto(optarg);
				break;	
			case 'h':
				usage();
			case 'S':
				opts_set_silent();
				break;
			case 'b':
				opts_set_recursion();
				break;
			case 'm':
				opts_set_hash();
				break;
			case 'H':
				opts_set_compute_hash();
				break;
			case 'l':
				opts_set_parsable_output();
				break;
			default:
				usage();
		}
	}
	if (optind==argc)
		usage();
	opts_finish(argv[optind]);
	do_command();
	time_report;
	bye;
	return 0;
}