/* srv.c - DNS SRV code
 * Copyright (C) 2003 Free Software Foundation, Inc.
 *
 * This file is part of GNUPG.
 *
 * GNUPG is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * GNUPG is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

#undef TEST

#ifdef TEST
#define HAVE_RESOLV_A
#endif

#include <config.h>
#include <sys/types.h>

#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

#include "srv.h"
#include <glib.h>
#include <glib/gprintf.h>
#include <glib/gutils.h>

/* Not every installation has gotten around to supporting SRVs
 yet...*/
#ifndef T_SRV
#define T_SRV 33
#endif

static int priosort(const void *a, const void *b) {
	const struct ns_srv_reply *sa=a, *sb=b;
	if (sa->prio>sb->prio)
		return 1;
	else if (sa->prio<sb->prio)
		return -1;
	else
		return 0;
}

struct ns_srv_reply *srv_lookup(char *service, char *protocol, char *domain) {
	struct ns_srv_reply *reply = NULL;
	struct ns_srv_reply *list;
	char name[1024];
#ifdef HAVE_RESOLV_A
	unsigned char answer[PACKETSZ];
	int r, srvcount=0;
	unsigned char *pt, *emsg;
	int count, dlen;

    list = NULL;

	g_snprintf(name, sizeof(name ), "_%s._%s.%s", service, protocol, domain);

	_res.options |= RES_DEBUG;
	
	if ( res_init() != 0 ) 
		return NULL;
	
	r=res_query(name, C_IN, T_SRV, answer, PACKETSZ);
	
	if (r<sizeof(HEADER) || r>PACKETSZ)
		return NULL;

	if ((((HEADER *)answer)->rcode)==NOERROR && (count=ntohs(((HEADER *)answer)->ancount))) {
		int i, rc;

		emsg=&answer[r]; /* end of message ??? */
		pt=&answer[sizeof(HEADER)];

		/* Skip over the query */
		rc=dn_skipname(pt, emsg);
		if (rc==-1)
			goto fail;

		pt+=rc+QFIXEDSZ;

		while (count-->0 && pt<emsg) {
			struct ns_srv_reply *srv=NULL;
			int type, class;

			list=g_realloc(list, (srvcount+1)*sizeof(struct ns_srv_reply));
			memset(&list[srvcount], 0, sizeof(struct ns_srv_reply));
			srv=&list[srvcount];
			srvcount++;

			rc=dn_skipname(pt, emsg); /* the name we just queried for */
			if (rc==-1)
				goto fail;
			pt+=rc;

			/* Truncated message? */
			if ((emsg-pt)<16)
				goto fail;

			type=*pt++ << 8;
			type|=*pt++;
			/* We asked for SRV and got something else !? */
			if (type!=T_SRV)
				goto fail;

			class=*pt++ << 8;
			class|=*pt++;
			/* We asked for IN and got something else !? */
			if (class!=C_IN)
				goto fail;

			pt+=4; /* ttl */
			dlen=*pt++ << 8;
			dlen|=*pt++;
			srv->prio=*pt++ << 8;
			srv->prio|=*pt++;
			srv->weight=*pt++ << 8;
			srv->weight|=*pt++;
			srv->port=*pt++ << 8;
			srv->port|=*pt++;

			/* Get the name.  2782 doesn't allow name compression, but
			 dn_expand still works to pull the name out of the
			 packet. */
			rc=dn_expand(answer, emsg, pt, srv->name, MAXDNAME);
			if (rc==1 && srv->name[0]==0) /* "." */
				goto noanswer;
			if (rc==-1)
				goto fail;
			pt+=rc;
			/* Corrupt packet? */
			if (dlen!=rc+6)
				goto fail;
		}

		/* Now we have an array of all the srv records. */

		/* Order by priority */
		qsort(list, srvcount, sizeof(struct ns_srv_reply), priosort);

		/* For each priority, move the zero-weighted items first. */
		for (i=0; i<srvcount; i++) {
			int j;

			for (j=i; j<srvcount && list[i].prio==list[j].prio; j++) {
				if (list[j].weight==0) {
					/* Swap j with i */
					if (j!=i) {
						struct ns_srv_reply temp;

						memcpy(&temp, &list[j], sizeof(struct ns_srv_reply));
						memcpy(&list[j], &list[i], sizeof(struct ns_srv_reply));
						memcpy(&list[i], &temp, sizeof(struct ns_srv_reply));
					}

					break;
				}
			}
		}

		/* Run the RFC-2782 weighting algorithm.  We don't need very
		 high quality randomness for this, so regular libc srand/rand
		 is sufficient. */
		srand(time(NULL)*getpid());

		for (i=0; i<srvcount; i++) {
			int j;
			float prio_count=0, chose;

			for (j=i; j<srvcount && list[i].prio==list[j].prio; j++) {
				prio_count+=list[j].weight;
				list[j].run_count=prio_count;
			}

			chose=prio_count*rand()/RAND_MAX;

			for (j=i; j<srvcount && list[i].prio==list[j].prio; j++) {
				if (chose<=list[j].run_count) {
					/* Swap j with i */
					if (j!=i) {
						struct ns_srv_reply temp;

						memcpy(&temp, &list[j], sizeof(struct ns_srv_reply));
						memcpy(&list[j], &list[i], sizeof(struct ns_srv_reply));
						memcpy(&list[i], &temp, sizeof(struct ns_srv_reply));
					}
					break;
				}
			}
		}
	}

	/* TODO: bitlbee should expect a situation when more than one server
	 * is available for the given SRV record.
	 */
	reply = g_malloc(sizeof(ns_srv_reply));
	*reply = *list;
	g_free(list);
	/* list=NULL; */
#endif /* HAVE_RESOLV_A */
	return reply;

	noanswer: g_free(list);
	list=NULL;
	return NULL;

	fail: g_free(list);
	list=NULL;
	return NULL;
}

#ifdef TEST
int main(int argc, char *argv[]) {
	struct ns_srv_reply *srv;
	/*int rc,i;*/

	srv=srv_lookup("xmpp-client", "tcp", "jabber.org");
	printf("priority=%hu\n", srv->prio);
	printf("weight=%hu\n", srv->weight);
	printf("port=%hu\n", srv->port);
	printf("target=%s\n", srv->name);
	printf("\n");
	g_free(srv);

	return 0;
}
#endif /* TEST */