/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */


/*
 * Copyright (C) 2009  Internet Systems Consortium, Inc. ("ISC")
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
 * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
 * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 * PERFORMANCE OF THIS SOFTWARE.
 */

#include "port_before.h"

#if __OpenBSD__
#include <sys/types.h>
#endif
#include <netinet/in.h>
#include <arpa/nameser.h>

#include <errno.h>
#include <resolv.h>
#include <string.h>

#include "port_after.h"

#define CONSUME_SRC \
	do { \
		rdata += n, rdlen -= n; \
	} while (0)

#define CONSUME_DST \
	do { \
		nrdata += n, nrdsiz -= n, nrdlen += n; \
	} while (0)

#define UNPACK_DNAME \
	do { \
		size_t t; \
		\
		if ((n = ns_name_unpack2(msg,eom,rdata,nrdata,nrdsiz,&t))<0) {\
			errno = EMSGSIZE; \
			return (-1); \
		} \
		CONSUME_SRC; \
		n = t; \
		CONSUME_DST; \
	} while (0)

#define UNPACK_SOME(x) \
	do { \
		n = (x); \
		if ((size_t)n > rdlen || (size_t)n > nrdsiz) { \
			errno = EMSGSIZE; \
			return (-1); \
		} \
		memcpy(nrdata, rdata, n); \
		CONSUME_SRC; CONSUME_DST; \
	} while (0)

#define	UNPACK_REST(x) \
	do { \
		n = (x); \
		if ((size_t)n != rdlen) { \
			errno = EMSGSIZE; \
			return (-1); \
		} \
		memcpy(nrdata, rdata, n); \
		CONSUME_SRC; CONSUME_DST; \
	} while (0)

ssize_t
ns_rdata_unpack(const u_char *msg, const u_char *eom,
		ns_type type, const u_char *rdata, size_t rdlen,
		u_char *nrdata, size_t nrdsiz)
{
	size_t nrdlen = 0;
	int n;

	switch (type) {
	case ns_t_a:
		UNPACK_REST(NS_INADDRSZ);
		break;
	case ns_t_aaaa:
		UNPACK_REST(NS_IN6ADDRSZ);
		break;
	case ns_t_cname:
	case ns_t_mb:
	case ns_t_mg:
	case ns_t_mr:
	case ns_t_ns:
	case ns_t_ptr:
	case ns_t_dname:
		UNPACK_DNAME;
		break;
	case ns_t_soa:
		UNPACK_DNAME;
		UNPACK_DNAME;
		UNPACK_SOME(NS_INT32SZ * 5);
		break;
	case ns_t_mx:
	case ns_t_afsdb:
	case ns_t_rt:
		UNPACK_SOME(NS_INT16SZ);
		UNPACK_DNAME;
		break;
	case ns_t_px:
		UNPACK_SOME(NS_INT16SZ);
		UNPACK_DNAME;
		UNPACK_DNAME;
		break;
	case ns_t_srv:
		UNPACK_SOME(NS_INT16SZ * 3);
		UNPACK_DNAME;
		break;
	case ns_t_minfo:
	case ns_t_rp:
		UNPACK_DNAME;
		UNPACK_DNAME;
		break;
	default:
		UNPACK_SOME(rdlen);
		break;
	}
	if (rdlen > 0) {
		errno = EMSGSIZE;
		return (-1);
	}
	return (nrdlen);
}

#define	EQUAL_CONSUME \
	do { \
		rdata1 += n, rdlen1 -= n; \
		rdata2 += n, rdlen2 -= n; \
	} while (0)

#define	EQUAL_DNAME \
	do { \
		ssize_t n; \
		\
		if (rdlen1 != rdlen2) \
			return (0); \
		n = ns_name_eq(rdata1, rdlen1, rdata2, rdlen2); \
		if (n <= 0) \
			return (n); \
		n = rdlen1; \
		EQUAL_CONSUME; \
	} while (0)

#define	EQUAL_SOME(x) \
	do { \
		size_t n = (x); \
		\
		if (n > rdlen1 || n > rdlen2) { \
			errno = EMSGSIZE; \
			return (-1); \
		} \
		if (memcmp(rdata1, rdata2, n) != 0) \
			return (0); \
		EQUAL_CONSUME; \
	} while (0)

int
ns_rdata_equal(ns_type type,
	       const u_char *rdata1, size_t rdlen1,
	       const u_char *rdata2, size_t rdlen2)
{
	switch (type) {
	case ns_t_cname:
	case ns_t_mb:
	case ns_t_mg:
	case ns_t_mr:
	case ns_t_ns:
	case ns_t_ptr:
	case ns_t_dname:
		EQUAL_DNAME;
		break;
	case ns_t_soa:
		/* "There can be only one." --Highlander */
		break;
	case ns_t_mx:
	case ns_t_afsdb:
	case ns_t_rt:
		EQUAL_SOME(NS_INT16SZ);
		EQUAL_DNAME;
		break;
	case ns_t_px:
		EQUAL_SOME(NS_INT16SZ);
		EQUAL_DNAME;
		EQUAL_DNAME;
		break;
	case ns_t_srv:
		EQUAL_SOME(NS_INT16SZ * 3);
		EQUAL_DNAME;
		break;
	case ns_t_minfo:
	case ns_t_rp:
		EQUAL_DNAME;
		EQUAL_DNAME;
		break;
	default:
		EQUAL_SOME(rdlen1);
		break;
	}
	if (rdlen1 != 0 || rdlen2 != 0)
		return (0);
	return (1);
}

#define REFERS_DNAME \
	do { \
		int n; \
		\
		n = ns_name_eq(rdata, rdlen, nname, NS_MAXNNAME); \
		if (n < 0) \
			return (-1); \
		if (n > 0) \
			return (1); \
		n = dn_skipname(rdata, rdata + rdlen); \
		if (n < 0) \
			return (-1); \
		CONSUME_SRC; \
	} while (0)

#define	REFERS_SOME(x) \
	do { \
		size_t n = (x); \
		\
		if (n > rdlen) { \
			errno = EMSGSIZE; \
			return (-1); \
		} \
		CONSUME_SRC; \
	} while (0)

int
ns_rdata_refers(ns_type type,
		const u_char *rdata, size_t rdlen,
		const u_char *nname)
{
	switch (type) {
	case ns_t_cname:
	case ns_t_mb:
	case ns_t_mg:
	case ns_t_mr:
	case ns_t_ns:
	case ns_t_ptr:
	case ns_t_dname:
		REFERS_DNAME;
		break;
	case ns_t_soa:
		REFERS_DNAME;
		REFERS_DNAME;
		REFERS_SOME(NS_INT32SZ * 5);
		break;
	case ns_t_mx:
	case ns_t_afsdb:
	case ns_t_rt:
		REFERS_SOME(NS_INT16SZ);
		REFERS_DNAME;
		break;
	case ns_t_px:
		REFERS_SOME(NS_INT16SZ);
		REFERS_DNAME;
		REFERS_DNAME;
		break;
	case ns_t_srv:
		REFERS_SOME(NS_INT16SZ * 3);
		REFERS_DNAME;
		break;
	case ns_t_minfo:
	case ns_t_rp:
		REFERS_DNAME;
		REFERS_DNAME;
		break;
	default:
		REFERS_SOME(rdlen);
		break;
	}
	if (rdlen != 0) {
		errno = EMSGSIZE;
		return (-1);
	}
	return (0);
}